"Merge Tagged PR 1340"

.ci/yuzu-patreon-step2.yml

@@ -9,7 +9,6 @@ stages:
   displayName: 'build'
   jobs:
   - job: build
-    timeoutInMinutes: 120
     displayName: 'windows-msvc'
     pool:
       vmImage: windows-2019

.gitmodules

@@ -1,12 +1,15 @@
 [submodule "inih"]
     path = externals/inih/inih
-    url = https://github.com/benhoyt/inih.git
+    url = https://github.com/svn2github/inih
 [submodule "cubeb"]
     path = externals/cubeb
     url = https://github.com/kinetiknz/cubeb.git
 [submodule "dynarmic"]
     path = externals/dynarmic
     url = https://github.com/MerryMage/dynarmic.git
+[submodule "unicorn"]
+    path = externals/unicorn
+    url = https://github.com/yuzu-emu/unicorn
 [submodule "soundtouch"]
     path = externals/soundtouch
     url = https://github.com/citra-emu/ext-soundtouch.git

.travis/linux-mingw/docker.sh

@@ -4,8 +4,16 @@ cd /yuzu
 # override Travis CI unreasonable ccache size
 echo 'max_size = 3.0G' > "$HOME/.ccache/ccache.conf"
 
+# Dirty hack to trick unicorn makefile into believing we are in a MINGW system
+mv /bin/uname /bin/uname1 && echo -e '#!/bin/sh\necho MINGW64' >> /bin/uname
+chmod +x /bin/uname
+
+# Dirty hack to trick unicorn makefile into believing we have cmd
+echo '' >> /bin/cmd
+chmod +x /bin/cmd
+
 mkdir build && cd build
-cmake .. -G Ninja -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
+cmake .. -G Ninja -DCMAKE_TOOLCHAIN_FILE="$(pwd)/../CMakeModules/MinGWCross.cmake" -DUSE_CCACHE=ON -DYUZU_USE_BUNDLED_UNICORN=ON -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DCMAKE_BUILD_TYPE=Release
 ninja
 
 # Clean up the dirty hacks

.travis/linux/docker.sh

@@ -3,7 +3,7 @@
 cd /yuzu
 
 mkdir build && cd build
-cmake .. -G Ninja -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON
+cmake .. -G Ninja -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=/usr/lib/ccache/gcc -DCMAKE_CXX_COMPILER=/usr/lib/ccache/g++ -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DUSE_DISCORD_PRESENCE=ON
 ninja
 
 ccache -s

.travis/macos/build.sh

@@ -4,12 +4,13 @@ set -o pipefail
 
 export MACOSX_DEPLOYMENT_TARGET=10.14
 export Qt5_DIR=$(brew --prefix)/opt/qt5
+export UNICORNDIR=$(pwd)/externals/unicorn
 export PATH="/usr/local/opt/ccache/libexec:$PATH"
 
 # TODO: Build using ninja instead of make
 mkdir build && cd build
 cmake --version
-cmake .. -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DUSE_DISCORD_PRESENCE=ON
+cmake .. -DYUZU_USE_BUNDLED_UNICORN=ON -DYUZU_USE_QT_WEB_ENGINE=ON -DCMAKE_BUILD_TYPE=Release -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} -DUSE_DISCORD_PRESENCE=ON
 make -j4
 
 ccache -s

CMakeLists.txt

@@ -18,6 +18,8 @@ CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_QT "Download bundled Qt binaries" ON "EN
 
 option(ENABLE_WEB_SERVICE "Enable web services (telemetry, etc.)" ON)
 
+option(YUZU_USE_BUNDLED_UNICORN "Build/Download bundled Unicorn" ON)
+
 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)
 
 option(YUZU_ENABLE_BOXCAT "Enable the Boxcat service, a yuzu high-level implementation of BCAT" ON)
@@ -159,7 +161,7 @@ macro(yuzu_find_packages)
     #    Cmake Pkg Prefix  Version     Conan Pkg
         "Boost             1.73        boost/1.73.0"
         "Catch2            2.13        catch2/2.13.0"
-        "fmt               7.1         fmt/7.1.2"
+        "fmt               7.0         fmt/7.0.3"
     # can't use until https://github.com/bincrafters/community/issues/1173
         #"libzip            1.5         libzip/1.5.2@bincrafters/stable"
         "lz4               1.8         lz4/1.9.2"
@@ -261,7 +263,6 @@ if (CONAN_REQUIRED_LIBS)
         libzip:with_openssl=False
         libzip:enable_windows_crypto=False
     )
-
     conan_check(VERSION 1.24.0 REQUIRED)
     # Add the bincrafters remote
     conan_add_remote(NAME bincrafters
@@ -353,23 +354,85 @@ if (NOT LIBUSB_FOUND)
     set(LIBUSB_LIBRARIES usb)
 endif()
 
-# Use system installed ffmpeg.
-if (NOT MSVC)
-    find_package(FFmpeg REQUIRED)
-else()
-    set(FFMPEG_EXT_NAME "ffmpeg-4.2.1")
-    set(FFMPEG_PATH "${CMAKE_BINARY_DIR}/externals/${FFMPEG_EXT_NAME}")
-    download_bundled_external("ffmpeg/" ${FFMPEG_EXT_NAME} "")
-    set(FFMPEG_FOUND YES)
-    set(FFMPEG_INCLUDE_DIR "${FFMPEG_PATH}/include" CACHE PATH "Path to FFmpeg headers" FORCE)
-    set(FFMPEG_LIBRARY_DIR "${FFMPEG_PATH}/bin" CACHE PATH "Path to FFmpeg library" FORCE)
-    set(FFMPEG_DLL_DIR "${FFMPEG_PATH}/bin" CACHE PATH "Path to FFmpeg dll's" FORCE)
-endif()
-
 # Prefer the -pthread flag on Linux.
 set(THREADS_PREFER_PTHREAD_FLAG ON)
 find_package(Threads REQUIRED)
 
+# If unicorn isn't found, msvc -> download bundled unicorn; everyone else -> build external
+if (YUZU_USE_BUNDLED_UNICORN)
+    if (MSVC)
+        message(STATUS "unicorn not found, falling back to bundled")
+        # Detect toolchain and platform
+        if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
+            set(UNICORN_VER "unicorn-yuzu")
+        else()
+            message(FATAL_ERROR "No bundled Unicorn binaries for your toolchain. Disable YUZU_USE_BUNDLED_UNICORN and provide your own.")
+        endif()
+
+        if (DEFINED UNICORN_VER)
+            download_bundled_external("unicorn/" ${UNICORN_VER} UNICORN_PREFIX)
+        endif()
+
+        if (DEFINED UNICORN_VER)
+            download_bundled_external("unicorn/" ${UNICORN_VER} UNICORN_PREFIX)
+        endif()
+
+        set(UNICORN_FOUND YES)
+        set(LIBUNICORN_INCLUDE_DIR "${UNICORN_PREFIX}/include" CACHE PATH "Path to Unicorn headers" FORCE)
+        set(LIBUNICORN_LIBRARY "${UNICORN_PREFIX}/lib/x64/unicorn_dynload.lib" CACHE PATH "Path to Unicorn library" FORCE)
+        set(UNICORN_DLL_DIR "${UNICORN_PREFIX}/lib/x64/" CACHE PATH "Path to unicorn.dll" FORCE)
+    else()
+        message(STATUS "unicorn not found, falling back to externals")
+        if (MINGW)
+            set(UNICORN_LIB_NAME "unicorn.a")
+        else()
+            set(UNICORN_LIB_NAME "libunicorn.a")
+        endif()
+
+        set(UNICORN_FOUND YES)
+        set(UNICORN_PREFIX ${PROJECT_SOURCE_DIR}/externals/unicorn)
+        set(LIBUNICORN_LIBRARY "${UNICORN_PREFIX}/${UNICORN_LIB_NAME}" CACHE PATH "Path to Unicorn library" FORCE)
+        set(LIBUNICORN_INCLUDE_DIR "${UNICORN_PREFIX}/include" CACHE PATH "Path to Unicorn headers" FORCE)
+        set(UNICORN_DLL_DIR "${UNICORN_PREFIX}/" CACHE PATH "Path to unicorn dynamic library" FORCE)
+
+        find_package(PythonInterp 2.7 REQUIRED)
+
+        if (MINGW)
+            # Intentionally call the unicorn makefile directly instead of using make.sh so that we can override the
+            # UNAME_S makefile variable to MINGW. This way we don't have to hack at the uname binary to build
+            # Additionally, overriding DO_WINDOWS_EXPORT prevents unicorn from patching the static unicorn.a by using msvc and cmd,
+            # which are both things we don't have in a mingw cross compiling environment.
+            add_custom_command(OUTPUT ${LIBUNICORN_LIBRARY}
+                COMMAND ${CMAKE_COMMAND} -E env UNICORN_ARCHS="aarch64" PYTHON="${PYTHON_EXECUTABLE}" CC=x86_64-w64-mingw32-gcc AR=x86_64-w64-mingw32-gcc-ar RANLIB=x86_64-w64-mingw32-gcc-ranlib make UNAME_S=MINGW DO_WINDOWS_EXPORT=0
+                WORKING_DIRECTORY ${UNICORN_PREFIX}
+            )
+        else()
+            add_custom_command(OUTPUT ${LIBUNICORN_LIBRARY}
+                COMMAND ${CMAKE_COMMAND} -E env UNICORN_ARCHS="aarch64" PYTHON="${PYTHON_EXECUTABLE}" /bin/sh make.sh macos-universal-no
+                WORKING_DIRECTORY ${UNICORN_PREFIX}
+            )
+        endif()
+
+        # ALL makes this custom target build every time
+        # but it won't actually build if LIBUNICORN_LIBRARY is up to date
+        add_custom_target(unicorn-build ALL
+            DEPENDS ${LIBUNICORN_LIBRARY}
+        )
+        unset(UNICORN_LIB_NAME)
+    endif()
+else()
+    find_package(Unicorn REQUIRED)
+endif()
+
+if (UNICORN_FOUND)
+    add_library(unicorn INTERFACE)
+    add_dependencies(unicorn unicorn-build)
+    target_link_libraries(unicorn INTERFACE "${LIBUNICORN_LIBRARY}")
+    target_include_directories(unicorn INTERFACE "${LIBUNICORN_INCLUDE_DIR}")
+else()
+    message(FATAL_ERROR "Could not find or build unicorn which is required.")
+endif()
+
 # Platform-specific library requirements
 # ======================================
 

CMakeModules/CopyYuzuFFmpegDeps.cmake

@@ -1,10 +0,0 @@
-function(copy_yuzu_FFmpeg_deps target_dir)
-    include(WindowsCopyFiles)
-    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
-    windows_copy_files(${target_dir} ${FFMPEG_DLL_DIR} ${DLL_DEST}
-        avcodec-58.dll
-        avutil-56.dll
-        swresample-3.dll
-        swscale-5.dll
-    )
-endfunction(copy_yuzu_FFmpeg_deps)

CMakeModules/CopyYuzuUnicornDeps.cmake

@@ -0,0 +1,9 @@
+function(copy_yuzu_unicorn_deps target_dir)
+    include(WindowsCopyFiles)
+    set(DLL_DEST "${CMAKE_BINARY_DIR}/bin/$<CONFIG>/")
+    windows_copy_files(${target_dir} ${UNICORN_DLL_DIR} ${DLL_DEST}
+        libgcc_s_seh-1.dll
+        libwinpthread-1.dll
+        unicorn.dll
+    )
+endfunction(copy_yuzu_unicorn_deps)

externals/CMakeLists.txt

@@ -73,29 +73,23 @@ if (NOT LIBZIP_FOUND)
 endif()
 
 if (ENABLE_WEB_SERVICE)
-    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/")
-        add_subdirectory(libressl EXCLUDE_FROM_ALL)
-        target_include_directories(ssl INTERFACE ./libressl/include)
-        target_compile_definitions(ssl PRIVATE -DHAVE_INET_NTOP)
-        get_directory_property(OPENSSL_LIBRARIES
-            DIRECTORY libressl
-            DEFINITION OPENSSL_LIBS)
-    endif()
+    # LibreSSL
+    set(LIBRESSL_SKIP_INSTALL ON CACHE BOOL "")
+    add_subdirectory(libressl EXCLUDE_FROM_ALL)
+    target_include_directories(ssl INTERFACE ./libressl/include)
+    target_compile_definitions(ssl PRIVATE -DHAVE_INET_NTOP)
+    get_directory_property(OPENSSL_LIBRARIES
+        DIRECTORY libressl
+        DEFINITION OPENSSL_LIBS)
+
+    # lurlparser
+    add_subdirectory(lurlparser EXCLUDE_FROM_ALL)
 
     # httplib
     add_library(httplib INTERFACE)
     target_include_directories(httplib INTERFACE ./httplib)
     target_compile_definitions(httplib INTERFACE -DCPPHTTPLIB_OPENSSL_SUPPORT)
     target_link_libraries(httplib INTERFACE ${OPENSSL_LIBRARIES})
-    if (WIN32)
-        target_link_libraries(httplib INTERFACE crypt32 cryptui ws2_32)
-    endif()
 endif()
 
 # Opus

externals/find-modules/FindFFmpeg.cmake

@@ -1,100 +0,0 @@
-# - Try to find ffmpeg libraries (libavcodec, libavformat and libavutil)
-# Once done this will define
-#
-# FFMPEG_FOUND - system has ffmpeg or libav
-# FFMPEG_INCLUDE_DIR - the ffmpeg include directory
-# FFMPEG_LIBRARIES - Link these to use ffmpeg
-# FFMPEG_LIBAVCODEC
-# FFMPEG_LIBAVFORMAT
-# FFMPEG_LIBAVUTIL
-#
-# Copyright (c) 2008 Andreas Schneider <mail@cynapses.org>
-# Modified for other libraries by Lasse Kärkkäinen <tronic>
-# Modified for Hedgewars by Stepik777
-# Modified for FFmpeg-example Tuukka Pasanen 2018
-# Modified for yuzu toastUnlimted 2020
-#
-# Redistribution and use is allowed according to the terms of the New
-# BSD license.
-#
-
-include(FindPackageHandleStandardArgs)
-
-find_package_handle_standard_args(FFMPEG
-  FOUND_VAR FFMPEG_FOUND
-  REQUIRED_VARS
-      FFMPEG_LIBRARY
-      FFMPEG_INCLUDE_DIR
-  VERSION_VAR FFMPEG_VERSION
-)
-
-if(FFMPEG_LIBRARIES AND FFMPEG_INCLUDE_DIR)
-  # in cache already
-  set(FFMPEG_FOUND TRUE)
-else()
-  # use pkg-config to get the directories and then use these values
-  # in the FIND_PATH() and FIND_LIBRARY() calls
-  find_package(PkgConfig)
-  if(PKG_CONFIG_FOUND)
-    pkg_check_modules(_FFMPEG_AVCODEC libavcodec)
-    pkg_check_modules(_FFMPEG_AVUTIL libavutil)
-    pkg_check_modules(_FFMPEG_SWSCALE libswscale)
-  endif()
-
-  find_path(FFMPEG_AVCODEC_INCLUDE_DIR
-    NAMES libavcodec/avcodec.h
-    PATHS ${_FFMPEG_AVCODEC_INCLUDE_DIRS}
-      /usr/include
-      /usr/local/include
-      /opt/local/include
-      /sw/include
-    PATH_SUFFIXES ffmpeg libav)
-
-  find_library(FFMPEG_LIBAVCODEC
-    NAMES avcodec
-    PATHS ${_FFMPEG_AVCODEC_LIBRARY_DIRS}
-      /usr/lib
-      /usr/local/lib
-      /opt/local/lib
-      /sw/lib)
-
-  find_library(FFMPEG_LIBAVUTIL
-    NAMES avutil
-    PATHS ${_FFMPEG_AVUTIL_LIBRARY_DIRS}
-      /usr/lib
-      /usr/local/lib
-      /opt/local/lib
-      /sw/lib)
-
-  find_library(FFMPEG_LIBSWSCALE
-    NAMES swscale
-    PATHS ${_FFMPEG_SWSCALE_LIBRARY_DIRS}
-      /usr/lib
-      /usr/local/lib
-      /opt/local/lib
-      /sw/lib)
-
-  if(FFMPEG_LIBAVCODEC AND FFMPEG_LIBAVUTIL AND FFMPEG_LIBSWSCALE)
-    set(FFMPEG_FOUND TRUE)
-  endif()
-
-  if(FFMPEG_FOUND)
-    set(FFMPEG_INCLUDE_DIR ${FFMPEG_AVCODEC_INCLUDE_DIR})
-    set(FFMPEG_LIBRARIES
-      ${FFMPEG_LIBAVCODEC}
-      ${FFMPEG_LIBAVUTIL}
-      ${FFMPEG_LIBSWSCALE})
-  endif()
-
-  if(FFMPEG_FOUND)
-    if(NOT FFMPEG_FIND_QUIETLY)
-      message(STATUS
-      "Found FFMPEG or Libav: ${FFMPEG_LIBRARIES}, ${FFMPEG_INCLUDE_DIR}")
-    endif()
-  else()
-    if(FFMPEG_FIND_REQUIRED)
-      message(FATAL_ERROR
-      "Could not find libavcodec or libavutil or libswscale")
-    endif()
-  endif()
-endif()

externals/httplib/README.md

@@ -1,4 +1,4 @@
-From https://github.com/yhirose/cpp-httplib/tree/ff5677ad197947177c158fe857caff4f0e242045 with https://github.com/yhirose/cpp-httplib/pull/701
+From https://github.com/yhirose/cpp-httplib/tree/fce8e6fefdab4ad48bc5b25c98e5ebfda4f3cf53
 
 MIT License
 

externals/lurlparser/CMakeLists.txt

@@ -0,0 +1,8 @@
+add_library(lurlparser
+        LUrlParser.cpp
+        LUrlParser.h
+)
+
+create_target_directory_groups(lurlparser)
+
+target_include_directories(lurlparser INTERFACE ${CMAKE_CURRENT_SOURCE_DIR})

externals/lurlparser/LUrlParser.cpp

@@ -0,0 +1,265 @@
+/*
+ * Lightweight URL & URI parser (RFC 1738, RFC 3986)
+ * https://github.com/corporateshark/LUrlParser
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (C) 2015 Sergey Kosarevsky (sk@linderdaum.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "LUrlParser.h"
+
+#include <algorithm>
+#include <cstring>
+#include <stdlib.h>
+
+// check if the scheme name is valid
+static bool IsSchemeValid( const std::string& SchemeName )
+{
+    for ( auto c : SchemeName  )
+    {
+        if ( !isalpha( c ) && c != '+' && c != '-' && c != '.' ) return false;
+    }
+
+    return true;
+}
+
+bool LUrlParser::clParseURL::GetPort( int* OutPort ) const
+{
+    if ( !IsValid() ) { return false; }
+
+    int Port = atoi( m_Port.c_str() );
+
+    if ( Port <= 0 || Port > 65535 ) { return false; }
+
+    if ( OutPort ) { *OutPort = Port; }
+
+    return true;
+}
+
+// based on RFC 1738 and RFC 3986
+LUrlParser::clParseURL LUrlParser::clParseURL::ParseURL( const std::string& URL )
+{
+    LUrlParser::clParseURL Result;
+
+    const char* CurrentString = URL.c_str();
+
+    /*
+     *	<scheme>:<scheme-specific-part>
+     *	<scheme> := [a-z\+\-\.]+
+     *	For resiliency, programs interpreting URLs should treat upper case letters as equivalent to lower case in scheme names
+     */
+
+    // try to read scheme
+    {
+        const char* LocalString = strchr( CurrentString, ':' );
+
+        if ( !LocalString )
+        {
+            return clParseURL( LUrlParserError_NoUrlCharacter );
+        }
+
+        // save the scheme name
+        Result.m_Scheme = std::string( CurrentString, LocalString - CurrentString );
+
+        if ( !IsSchemeValid( Result.m_Scheme ) )
+        {
+            return clParseURL( LUrlParserError_InvalidSchemeName );
+        }
+
+        // scheme should be lowercase
+        std::transform( Result.m_Scheme.begin(), Result.m_Scheme.end(), Result.m_Scheme.begin(), ::tolower );
+
+        // skip ':'
+        CurrentString = LocalString+1;
+    }
+
+    /*
+     *	//<user>:<password>@<host>:<port>/<url-path>
+     *	any ":", "@" and "/" must be normalized
+     */
+
+    // skip "//"
+    if ( *CurrentString++ != '/' ) return clParseURL( LUrlParserError_NoDoubleSlash );
+    if ( *CurrentString++ != '/' ) return clParseURL( LUrlParserError_NoDoubleSlash );
+
+    // check if the user name and password are specified
+    bool bHasUserName = false;
+
+    const char* LocalString = CurrentString;
+
+    while ( *LocalString )
+    {
+        if ( *LocalString == '@' )
+        {
+            // user name and password are specified
+            bHasUserName = true;
+            break;
+        }
+        else if ( *LocalString == '/' )
+        {
+            // end of <host>:<port> specification
+            bHasUserName = false;
+            break;
+        }
+
+        LocalString++;
+    }
+
+    // user name and password
+    LocalString = CurrentString;
+
+    if ( bHasUserName )
+    {
+        // read user name
+        while ( *LocalString && *LocalString != ':' && *LocalString != '@' ) LocalString++;
+
+        Result.m_UserName = std::string( CurrentString, LocalString - CurrentString );
+
+        // proceed with the current pointer
+        CurrentString = LocalString;
+
+        if ( *CurrentString == ':' )
+        {
+            // skip ':'
+            CurrentString++;
+
+            // read password
+            LocalString = CurrentString;
+
+            while ( *LocalString && *LocalString != '@' ) LocalString++;
+
+            Result.m_Password = std::string( CurrentString, LocalString - CurrentString );
+
+            CurrentString = LocalString;
+        }
+
+        // skip '@'
+        if ( *CurrentString != '@' )
+        {
+            return clParseURL( LUrlParserError_NoAtSign );
+        }
+
+        CurrentString++;
+    }
+
+    bool bHasBracket = ( *CurrentString == '[' );
+
+    // go ahead, read the host name
+    LocalString = CurrentString;
+
+    while ( *LocalString )
+    {
+        if ( bHasBracket && *LocalString == ']' )
+        {
+            // end of IPv6 address
+            LocalString++;
+            break;
+        }
+        else if ( !bHasBracket && ( *LocalString == ':' || *LocalString == '/' ) )
+        {
+            // port number is specified
+            break;
+        }
+
+        LocalString++;
+    }
+
+    Result.m_Host = std::string( CurrentString, LocalString - CurrentString );
+
+    CurrentString = LocalString;
+
+    // is port number specified?
+    if ( *CurrentString == ':' )
+    {
+        CurrentString++;
+
+        // read port number
+        LocalString = CurrentString;
+
+        while ( *LocalString && *LocalString != '/' ) LocalString++;
+
+        Result.m_Port = std::string( CurrentString, LocalString - CurrentString );
+
+        CurrentString = LocalString;
+    }
+
+    // end of string
+    if ( !*CurrentString )
+    {
+        Result.m_ErrorCode = LUrlParserError_Ok;
+
+        return Result;
+    }
+
+    // skip '/'
+    if ( *CurrentString != '/' )
+    {
+        return clParseURL( LUrlParserError_NoSlash );
+    }
+
+    CurrentString++;
+
+    // parse the path
+    LocalString = CurrentString;
+
+    while ( *LocalString && *LocalString != '#' && *LocalString != '?' ) LocalString++;
+
+    Result.m_Path = std::string( CurrentString, LocalString - CurrentString );
+
+    CurrentString = LocalString;
+
+    // check for query
+    if ( *CurrentString == '?' )
+    {
+        // skip '?'
+        CurrentString++;
+
+        // read query
+        LocalString = CurrentString;
+
+        while ( *LocalString && *LocalString != '#' ) LocalString++;
+
+        Result.m_Query = std::string( CurrentString, LocalString - CurrentString );
+
+        CurrentString = LocalString;
+    }
+
+    // check for fragment
+    if ( *CurrentString == '#' )
+    {
+        // skip '#'
+        CurrentString++;
+
+        // read fragment
+        LocalString = CurrentString;
+
+        while ( *LocalString ) LocalString++;
+
+        Result.m_Fragment = std::string( CurrentString, LocalString - CurrentString );
+
+        CurrentString = LocalString;
+    }
+
+    Result.m_ErrorCode = LUrlParserError_Ok;
+
+    return Result;
+}

externals/lurlparser/LUrlParser.h

@@ -0,0 +1,78 @@
+/*
+ * Lightweight URL & URI parser (RFC 1738, RFC 3986)
+ * https://github.com/corporateshark/LUrlParser
+ *
+ * The MIT License (MIT)
+ *
+ * Copyright (C) 2015 Sergey Kosarevsky (sk@linderdaum.com)
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#pragma once
+
+#include <string>
+
+namespace LUrlParser
+{
+enum LUrlParserError
+{
+    LUrlParserError_Ok = 0,
+    LUrlParserError_Uninitialized = 1,
+    LUrlParserError_NoUrlCharacter = 2,
+    LUrlParserError_InvalidSchemeName = 3,
+    LUrlParserError_NoDoubleSlash = 4,
+    LUrlParserError_NoAtSign = 5,
+    LUrlParserError_UnexpectedEndOfLine = 6,
+    LUrlParserError_NoSlash = 7,
+};
+
+class clParseURL
+{
+public:
+    LUrlParserError m_ErrorCode;
+    std::string m_Scheme;
+    std::string m_Host;
+    std::string m_Port;
+    std::string m_Path;
+    std::string m_Query;
+    std::string m_Fragment;
+    std::string m_UserName;
+    std::string m_Password;
+
+    clParseURL()
+            : m_ErrorCode( LUrlParserError_Uninitialized )
+    {}
+
+    /// return 'true' if the parsing was successful
+    bool IsValid() const { return m_ErrorCode == LUrlParserError_Ok; }
+
+    /// helper to convert the port number to int, return 'true' if the port is valid (within the 0..65535 range)
+    bool GetPort( int* OutPort ) const;
+
+    /// parse the URL
+    static clParseURL ParseURL( const std::string& URL );
+
+private:
+    explicit clParseURL( LUrlParserError ErrorCode )
+            : m_ErrorCode( ErrorCode )
+    {}
+};
+
+} // namespace LUrlParser

externals/lurlparser/README.md

@@ -0,0 +1,19 @@
+From https://github.com/corporateshark/LUrlParser/commit/455d5e2d27e3946f11ad0328fee9ee2628e6a8e2
+
+MIT License
+
+===
+
+Lightweight URL & URI parser (RFC 1738, RFC 3986)
+
+(C) Sergey Kosarevsky, 2015
+
+@corporateshark sk@linderdaum.com
+
+http://www.linderdaum.com
+
+http://blog.linderdaum.com
+
+=============================
+
+A tiny and lightweight URL & URI parser (RFC 1738, RFC 3986) written in C++.

externals/microprofile/microprofile.h

@@ -902,10 +902,8 @@ inline uint16_t MicroProfileGetGroupIndex(MicroProfileToken t)
 #include <windows.h>
 #define snprintf _snprintf
 
-#ifdef _MSC_VER
 #pragma warning(push)
 #pragma warning(disable: 4244)
-#endif
 int64_t MicroProfileTicksPerSecondCpu()
 {
     static int64_t nTicksPerSecond = 0;
@@ -948,11 +946,7 @@ typedef HANDLE MicroProfileThread;
 DWORD _stdcall ThreadTrampoline(void* pFunc)
 {
     MicroProfileThreadFunc F = (MicroProfileThreadFunc)pFunc;
-
-    // The return value of F will always return a void*, however, this is for
-    // compatibility with pthreads. The underlying "address" of the pointer
-    // is always a 32-bit value, so this cast is safe to perform.
-    return static_cast<DWORD>(reinterpret_cast<uint64_t>(F(0)));
+    return (uint32_t)F(0);
 }
 
 inline void MicroProfileThreadStart(MicroProfileThread* pThread, MicroProfileThreadFunc Func)
@@ -1748,10 +1742,10 @@ void MicroProfileFlip()
                             }
                         }
                     }
-                    for(uint32_t j = 0; j < MICROPROFILE_MAX_GROUPS; ++j)
+                    for(uint32_t i = 0; i < MICROPROFILE_MAX_GROUPS; ++i)
                     {
-                        pLog->nGroupTicks[j] += nGroupTicks[j];
-                        pFrameGroup[j] += nGroupTicks[j];
+                        pLog->nGroupTicks[i] += nGroupTicks[i];
+                        pFrameGroup[i] += nGroupTicks[i];
                     }
                     pLog->nStackPos = nStackPos;
                 }
@@ -3334,7 +3328,7 @@ bool MicroProfileIsLocalThread(uint32_t nThreadId)
 #endif
 #else
 
-bool MicroProfileIsLocalThread([[maybe_unused]] uint32_t nThreadId) { return false; }
+bool MicroProfileIsLocalThread(uint32_t nThreadId){return false;}
 void MicroProfileStopContextSwitchTrace(){}
 void MicroProfileStartContextSwitchTrace(){}
 
@@ -3582,7 +3576,7 @@ int MicroProfileGetGpuTickReference(int64_t* pOutCpu, int64_t* pOutGpu)
 
 #undef S
 
-#ifdef _MSC_VER
+#ifdef _WIN32
 #pragma warning(pop)
 #endif
 

src/CMakeLists.txt

@@ -32,6 +32,7 @@ if (MSVC)
     # /Zc:inline          - Let codegen omit inline functions in object files
     # /Zc:throwingNew     - Let codegen assume `operator new` (without std::nothrow) will never return null
     add_compile_options(
+        /W3
         /MP
         /Zi
         /Zo
@@ -42,13 +43,6 @@ if (MSVC)
         /Zc:externConstexpr
         /Zc:inline
         /Zc:throwingNew
-
-        # Warnings
-        /W3
-        /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
-        /we4834 # Discarding return value of function with 'nodiscard' attribute
     )
 
     # /GS- - No stack buffer overflow checks
@@ -62,7 +56,6 @@ else()
         -Werror=implicit-fallthrough
         -Werror=missing-declarations
         -Werror=reorder
-        -Werror=unused-result
         -Wextra
         -Wmissing-declarations
         -Wno-attributes

src/audio_core/CMakeLists.txt

@@ -44,22 +44,6 @@ add_library(audio_core STATIC
 
 create_target_directory_groups(audio_core)
 
-if (NOT MSVC)
-    target_compile_options(audio_core PRIVATE
-        -Werror=conversion
-        -Werror=ignored-qualifiers
-        -Werror=implicit-fallthrough
-        -Werror=reorder
-        -Werror=sign-compare
-        -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)
 target_link_libraries(audio_core PRIVATE SoundTouch)
 

src/audio_core/algorithm/filter.cpp

@@ -55,8 +55,7 @@ void Filter::Process(std::vector<s16>& signal) {
 /// @param total_count The total number of biquads to be cascaded.
 /// @param index 0-index of the biquad to calculate the Q value for.
 static double CascadingBiquadQ(std::size_t total_count, std::size_t index) {
-    const auto pole =
-        M_PI * static_cast<double>(2 * index + 1) / (4.0 * static_cast<double>(total_count));
+    const double pole = M_PI * (2 * index + 1) / (4.0 * total_count);
     return 1.0 / (2.0 * std::cos(pole));
 }
 

src/audio_core/algorithm/interpolate.cpp

@@ -146,7 +146,7 @@ std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input,
         return {};
 
     if (ratio <= 0) {
-        LOG_ERROR(Audio, "Nonsensical interpolation ratio {}", ratio);
+        LOG_CRITICAL(Audio, "Nonsensical interpolation ratio {}", ratio);
         return input;
     }
 
@@ -164,8 +164,7 @@ std::vector<s16> Interpolate(InterpolationState& state, std::vector<s16> input,
     const std::size_t num_frames{input.size() / 2};
 
     std::vector<s16> output;
-    output.reserve(static_cast<std::size_t>(static_cast<double>(input.size()) / ratio +
-                                            InterpolationState::taps));
+    output.reserve(static_cast<std::size_t>(input.size() / ratio + InterpolationState::taps));
 
     for (std::size_t frame{}; frame < num_frames; ++frame) {
         const std::size_t lut_index{(state.fraction >> 8) * InterpolationState::taps};

src/audio_core/audio_renderer.cpp

@@ -3,13 +3,16 @@
 // Refer to the license.txt file included.
 
 #include <vector>
-
+#include "audio_core/algorithm/interpolate.h"
 #include "audio_core/audio_out.h"
 #include "audio_core/audio_renderer.h"
+#include "audio_core/codec.h"
 #include "audio_core/common.h"
 #include "audio_core/info_updater.h"
 #include "audio_core/voice_context.h"
+#include "common/assert.h"
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/hle/kernel/writable_event.h"
 #include "core/memory.h"
 #include "core/settings.h"

src/audio_core/audio_renderer.h

@@ -21,6 +21,7 @@
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"
+#include "core/hle/kernel/object.h"
 #include "core/hle/result.h"
 
 namespace Core::Timing {

src/audio_core/behavior_info.cpp

@@ -57,15 +57,15 @@ bool BehaviorInfo::IsLongSizePreDelaySupported() const {
     return AudioCommon::IsRevisionSupported(3, user_revision);
 }
 
-bool BehaviorInfo::IsAudioRendererProcessingTimeLimit80PercentSupported() const {
+bool BehaviorInfo::IsAudioRenererProcessingTimeLimit80PercentSupported() const {
     return AudioCommon::IsRevisionSupported(5, user_revision);
 }
 
-bool BehaviorInfo::IsAudioRendererProcessingTimeLimit75PercentSupported() const {
+bool BehaviorInfo::IsAudioRenererProcessingTimeLimit75PercentSupported() const {
     return AudioCommon::IsRevisionSupported(4, user_revision);
 }
 
-bool BehaviorInfo::IsAudioRendererProcessingTimeLimit70PercentSupported() const {
+bool BehaviorInfo::IsAudioRenererProcessingTimeLimit70PercentSupported() const {
     return AudioCommon::IsRevisionSupported(1, user_revision);
 }
 

src/audio_core/behavior_info.h

@@ -49,9 +49,9 @@ public:
     bool IsAdpcmLoopContextBugFixed() const;
     bool IsSplitterSupported() const;
     bool IsLongSizePreDelaySupported() const;
-    bool IsAudioRendererProcessingTimeLimit80PercentSupported() const;
-    bool IsAudioRendererProcessingTimeLimit75PercentSupported() const;
-    bool IsAudioRendererProcessingTimeLimit70PercentSupported() const;
+    bool IsAudioRenererProcessingTimeLimit80PercentSupported() const;
+    bool IsAudioRenererProcessingTimeLimit75PercentSupported() const;
+    bool IsAudioRenererProcessingTimeLimit70PercentSupported() const;
     bool IsElapsedFrameCountSupported() const;
     bool IsMemoryPoolForceMappingEnabled() const;
     bool IsFlushVoiceWaveBuffersSupported() const;

src/audio_core/codec.cpp

@@ -16,9 +16,8 @@ std::vector<s16> DecodeADPCM(const u8* const data, std::size_t size, const ADPCM
 
     constexpr std::size_t FRAME_LEN = 8;
     constexpr std::size_t SAMPLES_PER_FRAME = 14;
-    static constexpr std::array<int, 16> SIGNED_NIBBLES{
-        0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1,
-    };
+    constexpr std::array<int, 16> SIGNED_NIBBLES = {
+        {0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1}};
 
     const std::size_t sample_count = (size / FRAME_LEN) * SAMPLES_PER_FRAME;
     const std::size_t ret_size =

src/audio_core/codec.h

@@ -38,7 +38,7 @@ using ADPCM_Coeff = std::array<s16, 16>;
  * @param state ADPCM state, this is updated with new state
  * @return Decoded stereo signed PCM16 data, sample_count in length
  */
-std::vector<s16> DecodeADPCM(const u8* data, std::size_t size, const ADPCM_Coeff& coeff,
+std::vector<s16> DecodeADPCM(const u8* const data, std::size_t size, const ADPCM_Coeff& coeff,
                              ADPCMState& state);
 
 }; // namespace AudioCore::Codec

src/audio_core/command_generator.cpp

@@ -152,7 +152,7 @@ void CommandGenerator::GenerateVoiceCommand(ServerVoiceInfo& voice_info) {
                     if (!destination_data->IsConfigured()) {
                         continue;
                     }
-                    if (destination_data->GetMixId() >= static_cast<int>(mix_context.GetCount())) {
+                    if (destination_data->GetMixId() >= mix_context.GetCount()) {
                         continue;
                     }
 
@@ -196,7 +196,7 @@ void CommandGenerator::PreCommand() {
     for (std::size_t i = 0; i < splitter_context.GetInfoCount(); i++) {
         const auto& base = splitter_context.GetInfo(i);
         std::string graph = fmt::format("b[{}]", i);
-        const auto* head = base.GetHead();
+        auto* head = base.GetHead();
         while (head != nullptr) {
             graph += fmt::format("->{}", head->GetMixId());
             head = head->GetNextDestination();
@@ -214,7 +214,7 @@ void CommandGenerator::PostCommand() {
 
 void CommandGenerator::GenerateDataSourceCommand(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
                                                  s32 channel) {
-    const auto& in_params = voice_info.GetInParams();
+    auto& in_params = voice_info.GetInParams();
     const auto depop = in_params.should_depop;
 
     if (depop) {
@@ -405,7 +405,7 @@ void CommandGenerator::GenerateBiquadFilterEffectCommand(s32 mix_buffer_offset,
 }
 
 void CommandGenerator::GenerateAuxCommand(s32 mix_buffer_offset, EffectBase* info, bool enabled) {
-    auto* aux = dynamic_cast<EffectAuxInfo*>(info);
+    auto aux = dynamic_cast<EffectAuxInfo*>(info);
     const auto& params = aux->GetParams();
     if (aux->GetSendBuffer() != 0 && aux->GetRecvBuffer() != 0) {
         const auto max_channels = params.count;
@@ -435,7 +435,7 @@ void CommandGenerator::GenerateAuxCommand(s32 mix_buffer_offset, EffectBase* inf
                     GetMixBuffer(output_index), worker_params.sample_count, offset, write_count);
                 memory.WriteBlock(aux->GetRecvInfo(), &recv_info, sizeof(AuxInfoDSP));
 
-                if (samples_read != static_cast<int>(worker_params.sample_count) &&
+                if (samples_read != worker_params.sample_count &&
                     samples_read <= params.sample_count) {
                     std::memset(GetMixBuffer(output_index), 0, params.sample_count - samples_read);
                 }
@@ -571,7 +571,7 @@ void CommandGenerator::GenerateSubMixCommand(ServerMixInfo& mix_info) {
     if (dumping_frame) {
         LOG_DEBUG(Audio, "(DSP_TRACE) GenerateSubMixCommand");
     }
-    const auto& in_params = mix_info.GetInParams();
+    auto& in_params = mix_info.GetInParams();
     GenerateDepopForMixBuffersCommand(in_params.buffer_count, in_params.buffer_offset,
                                       in_params.sample_rate);
 
@@ -611,8 +611,7 @@ void CommandGenerator::GenerateMixCommands(ServerMixInfo& mix_info) {
             const auto& dest_mix = mix_context.GetInfo(destination_data->GetMixId());
             const auto& dest_in_params = dest_mix.GetInParams();
             const auto mix_index = (base - 1) % in_params.buffer_count + in_params.buffer_offset;
-            for (std::size_t i = 0; i < static_cast<std::size_t>(dest_in_params.buffer_count);
-                 i++) {
+            for (std::size_t i = 0; i < dest_in_params.buffer_count; i++) {
                 const auto mixed_volume = in_params.volume * destination_data->GetMixVolume(i);
                 if (mixed_volume != 0.0f) {
                     GenerateMixCommand(dest_in_params.buffer_offset + i, mix_index, mixed_volume,
@@ -651,7 +650,7 @@ void CommandGenerator::GenerateFinalMixCommand() {
         LOG_DEBUG(Audio, "(DSP_TRACE) GenerateFinalMixCommand");
     }
     auto& mix_info = mix_context.GetFinalMixInfo();
-    const auto& in_params = mix_info.GetInParams();
+    const auto in_params = mix_info.GetInParams();
 
     GenerateDepopForMixBuffersCommand(in_params.buffer_count, in_params.buffer_offset,
                                       in_params.sample_rate);
@@ -675,7 +674,7 @@ void CommandGenerator::GenerateFinalMixCommand() {
 
 s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
                                   s32 sample_count, s32 channel, std::size_t mix_offset) {
-    const auto& in_params = voice_info.GetInParams();
+    auto& in_params = voice_info.GetInParams();
     const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
     if (wave_buffer.buffer_address == 0) {
         return 0;
@@ -705,7 +704,7 @@ s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_s
         std::vector<s16> buffer(samples_processed * channel_count);
         memory.ReadBlock(buffer_pos, buffer.data(), buffer.size() * sizeof(s16));
 
-        for (std::size_t i = 0; i < static_cast<std::size_t>(samples_processed); i++) {
+        for (std::size_t i = 0; i < samples_processed; i++) {
             sample_buffer[mix_offset + i] = buffer[i * channel_count + channel];
         }
     }
@@ -715,7 +714,7 @@ s32 CommandGenerator::DecodePcm16(ServerVoiceInfo& voice_info, VoiceState& dsp_s
 
 s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_state,
                                   s32 sample_count, s32 channel, std::size_t mix_offset) {
-    const auto& in_params = voice_info.GetInParams();
+    auto& in_params = voice_info.GetInParams();
     const auto& wave_buffer = in_params.wave_buffer[dsp_state.wave_buffer_index];
     if (wave_buffer.buffer_address == 0) {
         return 0;
@@ -727,9 +726,8 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
         return 0;
     }
 
-    static constexpr std::array<int, 16> SIGNED_NIBBLES{
-        0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1,
-    };
+    constexpr std::array<int, 16> SIGNED_NIBBLES = {
+        {0, 1, 2, 3, 4, 5, 6, 7, -8, -7, -6, -5, -4, -3, -2, -1}};
 
     constexpr std::size_t FRAME_LEN = 8;
     constexpr std::size_t NIBBLES_PER_SAMPLE = 16;
@@ -768,8 +766,8 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
         val = std::clamp<s32>(val, -32768, 32767);
         // Advance output feedback.
         yn2 = yn1;
-        yn1 = static_cast<s16>(val);
-        return yn1;
+        yn1 = val;
+        return static_cast<s16>(val);
     };
 
     std::size_t buffer_offset{};
@@ -791,8 +789,9 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
             position_in_frame += 2;
 
             // Decode entire frame
-            if (remaining_samples >= static_cast<int>(SAMPLES_PER_FRAME)) {
+            if (remaining_samples >= SAMPLES_PER_FRAME) {
                 for (std::size_t i = 0; i < SAMPLES_PER_FRAME / 2; i++) {
+
                     // Sample 1
                     const s32 s0 = SIGNED_NIBBLES[buffer[buffer_offset] >> 4];
                     const s32 s1 = SIGNED_NIBBLES[buffer[buffer_offset++] & 0xf];
@@ -801,7 +800,7 @@ s32 CommandGenerator::DecodeAdpcm(ServerVoiceInfo& voice_info, VoiceState& dsp_s
                     sample_buffer[cur_mix_offset++] = sample_1;
                     sample_buffer[cur_mix_offset++] = sample_2;
                 }
-                remaining_samples -= static_cast<int>(SAMPLES_PER_FRAME);
+                remaining_samples -= SAMPLES_PER_FRAME;
                 position_in_frame += SAMPLES_PER_FRAME;
                 continue;
             }
@@ -854,7 +853,7 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o
                                              VoiceState& dsp_state, s32 channel,
                                              s32 target_sample_rate, s32 sample_count,
                                              s32 node_id) {
-    const auto& in_params = voice_info.GetInParams();
+    auto& in_params = voice_info.GetInParams();
     if (dumping_frame) {
         LOG_DEBUG(Audio,
                   "(DSP_TRACE) DecodeFromWaveBuffers, node_id={}, channel={}, "
@@ -867,8 +866,8 @@ void CommandGenerator::DecodeFromWaveBuffers(ServerVoiceInfo& voice_info, s32* o
     const auto resample_rate = static_cast<s32>(
         static_cast<float>(in_params.sample_rate) / static_cast<float>(target_sample_rate) *
         static_cast<float>(static_cast<s32>(in_params.pitch * 32768.0f)));
-    if (dsp_state.fraction + sample_count * resample_rate >
-        static_cast<s32>(SCALED_MIX_BUFFER_SIZE - 4ULL)) {
+    auto* output_base = output;
+    if ((dsp_state.fraction + sample_count * resample_rate) > (SCALED_MIX_BUFFER_SIZE - 4ULL)) {
         return;
     }
 

src/audio_core/command_generator.h

@@ -7,6 +7,7 @@
 #include <array>
 #include "audio_core/common.h"
 #include "audio_core/voice_context.h"
+#include "common/common_funcs.h"
 #include "common/common_types.h"
 
 namespace Core::Memory {

src/audio_core/common.h

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #pragma once
-
 #include "common/common_funcs.h"
 #include "common/common_types.h"
 #include "common/swap.h"

src/audio_core/cubeb_sink.cpp

@@ -93,10 +93,8 @@ public:
                 constexpr s32 clev{707}; // center mixing level coefficient
                 constexpr s32 slev{707}; // surround mixing level coefficient
 
-                buf.push_back(static_cast<s16>(left + (clev * center / 1000) +
-                                               (slev * surround_left / 1000)));
-                buf.push_back(static_cast<s16>(right + (clev * center / 1000) +
-                                               (slev * surround_right / 1000)));
+                buf.push_back(left + (clev * center / 1000) + (slev * surround_left / 1000));
+                buf.push_back(right + (clev * center / 1000) + (slev * surround_right / 1000));
             }
             queue.Push(buf);
             return;
@@ -194,8 +192,8 @@ SinkStream& CubebSink::AcquireSinkStream(u32 sample_rate, u32 num_channels,
 
 long CubebSinkStream::DataCallback(cubeb_stream* stream, void* user_data, const void* input_buffer,
                                    void* output_buffer, long num_frames) {
-    auto* impl = static_cast<CubebSinkStream*>(user_data);
-    auto* buffer = static_cast<u8*>(output_buffer);
+    CubebSinkStream* impl = static_cast<CubebSinkStream*>(user_data);
+    u8* buffer = reinterpret_cast<u8*>(output_buffer);
 
     if (!impl) {
         return {};

src/audio_core/effect_context.cpp

@@ -184,19 +184,19 @@ void EffectAuxInfo::UpdateForCommandGeneration() {
     }
 }
 
-VAddr EffectAuxInfo::GetSendInfo() const {
+const VAddr EffectAuxInfo::GetSendInfo() const {
     return send_info;
 }
 
-VAddr EffectAuxInfo::GetSendBuffer() const {
+const VAddr EffectAuxInfo::GetSendBuffer() const {
     return send_buffer;
 }
 
-VAddr EffectAuxInfo::GetRecvInfo() const {
+const VAddr EffectAuxInfo::GetRecvInfo() const {
     return recv_info;
 }
 
-VAddr EffectAuxInfo::GetRecvBuffer() const {
+const VAddr EffectAuxInfo::GetRecvBuffer() const {
     return recv_buffer;
 }
 

src/audio_core/effect_context.h

@@ -166,13 +166,13 @@ public:
             std::array<u8, 0xa0> raw;
         };
     };
-    static_assert(sizeof(InParams) == 0xc0, "InParams is an invalid size");
+    static_assert(sizeof(EffectInfo::InParams) == 0xc0, "InParams is an invalid size");
 
     struct OutParams {
         UsageStatus status{};
         INSERT_PADDING_BYTES(15);
     };
-    static_assert(sizeof(OutParams) == 0x10, "OutParams is an invalid size");
+    static_assert(sizeof(EffectInfo::OutParams) == 0x10, "OutParams is an invalid size");
 };
 
 struct AuxAddress {
@@ -184,8 +184,8 @@ struct AuxAddress {
 
 class EffectBase {
 public:
-    explicit EffectBase(EffectType effect_type);
-    virtual ~EffectBase();
+    EffectBase(EffectType effect_type);
+    ~EffectBase();
 
     virtual void Update(EffectInfo::InParams& in_params) = 0;
     virtual void UpdateForCommandGeneration() = 0;
@@ -206,7 +206,8 @@ protected:
 template <typename T>
 class EffectGeneric : public EffectBase {
 public:
-    explicit EffectGeneric(EffectType effect_type) : EffectBase(effect_type) {}
+    EffectGeneric(EffectType effect_type) : EffectBase::EffectBase(effect_type) {}
+    ~EffectGeneric() = default;
 
     T& GetParams() {
         return internal_params;
@@ -223,7 +224,7 @@ private:
 class EffectStubbed : public EffectBase {
 public:
     explicit EffectStubbed();
-    ~EffectStubbed() override;
+    ~EffectStubbed();
 
     void Update(EffectInfo::InParams& in_params) override;
     void UpdateForCommandGeneration() override;
@@ -232,7 +233,7 @@ public:
 class EffectI3dl2Reverb : public EffectGeneric<I3dl2ReverbParams> {
 public:
     explicit EffectI3dl2Reverb();
-    ~EffectI3dl2Reverb() override;
+    ~EffectI3dl2Reverb();
 
     void Update(EffectInfo::InParams& in_params) override;
     void UpdateForCommandGeneration() override;
@@ -244,7 +245,7 @@ private:
 class EffectBiquadFilter : public EffectGeneric<BiquadFilterParams> {
 public:
     explicit EffectBiquadFilter();
-    ~EffectBiquadFilter() override;
+    ~EffectBiquadFilter();
 
     void Update(EffectInfo::InParams& in_params) override;
     void UpdateForCommandGeneration() override;
@@ -253,14 +254,14 @@ public:
 class EffectAuxInfo : public EffectGeneric<AuxInfo> {
 public:
     explicit EffectAuxInfo();
-    ~EffectAuxInfo() override;
+    ~EffectAuxInfo();
 
     void Update(EffectInfo::InParams& in_params) override;
     void UpdateForCommandGeneration() override;
-    VAddr GetSendInfo() const;
-    VAddr GetSendBuffer() const;
-    VAddr GetRecvInfo() const;
-    VAddr GetRecvBuffer() const;
+    const VAddr GetSendInfo() const;
+    const VAddr GetSendBuffer() const;
+    const VAddr GetRecvInfo() const;
+    const VAddr GetRecvBuffer() const;
 
 private:
     VAddr send_info{};
@@ -274,7 +275,7 @@ private:
 class EffectDelay : public EffectGeneric<DelayParams> {
 public:
     explicit EffectDelay();
-    ~EffectDelay() override;
+    ~EffectDelay();
 
     void Update(EffectInfo::InParams& in_params) override;
     void UpdateForCommandGeneration() override;
@@ -286,7 +287,7 @@ private:
 class EffectBufferMixer : public EffectGeneric<BufferMixerParams> {
 public:
     explicit EffectBufferMixer();
-    ~EffectBufferMixer() override;
+    ~EffectBufferMixer();
 
     void Update(EffectInfo::InParams& in_params) override;
     void UpdateForCommandGeneration() override;
@@ -295,7 +296,7 @@ public:
 class EffectReverb : public EffectGeneric<ReverbParams> {
 public:
     explicit EffectReverb();
-    ~EffectReverb() override;
+    ~EffectReverb();
 
     void Update(EffectInfo::InParams& in_params) override;
     void UpdateForCommandGeneration() override;

src/audio_core/info_updater.cpp

@@ -64,6 +64,7 @@ bool InfoUpdater::UpdateBehaviorInfo(BehaviorInfo& in_behavior_info) {
 }
 
 bool InfoUpdater::UpdateMemoryPools(std::vector<ServerMemoryPoolInfo>& memory_pool_info) {
+    const auto force_mapping = behavior_info.IsMemoryPoolForceMappingEnabled();
     const auto memory_pool_count = memory_pool_info.size();
     const auto total_memory_pool_in = sizeof(ServerMemoryPoolInfo::InParams) * memory_pool_count;
     const auto total_memory_pool_out = sizeof(ServerMemoryPoolInfo::OutParams) * memory_pool_count;
@@ -173,7 +174,7 @@ bool InfoUpdater::UpdateVoices(VoiceContext& voice_context,
         }
         // Voice states for each channel
         std::array<VoiceState*, AudioCommon::MAX_CHANNEL_COUNT> voice_states{};
-        ASSERT(static_cast<std::size_t>(in_params.id) < voice_count);
+        ASSERT(in_params.id < voice_count);
 
         // Grab our current voice info
         auto& voice_info = voice_context.GetInfo(static_cast<std::size_t>(in_params.id));
@@ -351,8 +352,8 @@ ResultCode InfoUpdater::UpdateMixes(MixContext& mix_context, std::size_t mix_buf
         for (std::size_t i = 0; i < mix_count; i++) {
             const auto& in = mix_in_params[i];
             total_buffer_count += in.buffer_count;
-            if (static_cast<std::size_t>(in.dest_mix_id) > mix_count &&
-                in.dest_mix_id != AudioCommon::NO_MIX && in.mix_id != AudioCommon::FINAL_MIX) {
+            if (in.dest_mix_id > mix_count && in.dest_mix_id != AudioCommon::NO_MIX &&
+                in.mix_id != AudioCommon::FINAL_MIX) {
                 LOG_ERROR(
                     Audio,
                     "Invalid mix destination, mix_id={:X}, dest_mix_id={:X}, mix_buffer_count={:X}",

src/audio_core/mix_context.cpp

@@ -53,7 +53,7 @@ void MixContext::UpdateDistancesFromFinalMix() {
         auto mix_id = in_params.mix_id;
         // Needs to be referenced out of scope
         s32 distance_to_final_mix{AudioCommon::FINAL_MIX};
-        for (; distance_to_final_mix < static_cast<s32>(info_count); distance_to_final_mix++) {
+        for (; distance_to_final_mix < info_count; distance_to_final_mix++) {
             if (mix_id == AudioCommon::FINAL_MIX) {
                 // If we're at the final mix, we're done
                 break;
@@ -77,7 +77,7 @@ void MixContext::UpdateDistancesFromFinalMix() {
         }
 
         // If we're out of range for our distance, mark it as no final mix
-        if (distance_to_final_mix >= static_cast<s32>(info_count)) {
+        if (distance_to_final_mix >= info_count) {
             distance_to_final_mix = AudioCommon::NO_FINAL_MIX;
         }
 

src/audio_core/splitter_context.cpp

@@ -306,7 +306,7 @@ bool SplitterContext::UpdateInfo(const std::vector<u8>& input, std::size_t& inpu
             break;
         }
 
-        if (header.send_id < 0 || static_cast<std::size_t>(header.send_id) > info_count) {
+        if (header.send_id < 0 || header.send_id > info_count) {
             LOG_ERROR(Audio, "Bad splitter data id");
             break;
         }
@@ -348,7 +348,7 @@ bool SplitterContext::UpdateData(const std::vector<u8>& input, std::size_t& inpu
             break;
         }
 
-        if (header.splitter_id < 0 || static_cast<std::size_t>(header.splitter_id) > data_count) {
+        if (header.splitter_id < 0 || header.splitter_id > data_count) {
             LOG_ERROR(Audio, "Bad splitter data id");
             break;
         }
@@ -434,7 +434,7 @@ const std::vector<s32>& NodeStates::GetIndexList() const {
 }
 
 void NodeStates::PushTsortResult(s32 index) {
-    ASSERT(index < static_cast<s32>(node_count));
+    ASSERT(index < node_count);
     index_list[index_pos++] = index;
 }
 

src/audio_core/stream.cpp

@@ -12,6 +12,7 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/settings.h"
 
 namespace AudioCore {

src/audio_core/voice_context.cpp

@@ -128,10 +128,7 @@ void ServerVoiceInfo::UpdateParameters(const VoiceInfo::InParams& voice_in,
     in_params.wave_buffer_count = voice_in.wave_buffer_count;
     in_params.wave_bufffer_head = voice_in.wave_buffer_head;
     if (behavior_info.IsFlushVoiceWaveBuffersSupported()) {
-        const auto in_request_count = in_params.wave_buffer_flush_request_count;
-        const auto voice_request_count = voice_in.wave_buffer_flush_request_count;
-        in_params.wave_buffer_flush_request_count =
-            static_cast<u8>(in_request_count + voice_request_count);
+        in_params.wave_buffer_flush_request_count += voice_in.wave_buffer_flush_request_count;
     }
     in_params.mix_id = voice_in.mix_id;
     if (behavior_info.IsSplitterSupported()) {
@@ -491,11 +488,11 @@ s32 VoiceContext::DecodePcm16(s32* output_buffer, ServerWaveBuffer* wave_buffer,
 
     // Fast path
     if (channel_count == 1) {
-        for (std::ptrdiff_t i = 0; i < samples_processed; i++) {
+        for (std::size_t i = 0; i < samples_processed; i++) {
             output_buffer[i] = buffer_data[i];
         }
     } else {
-        for (std::ptrdiff_t i = 0; i < samples_processed; i++) {
+        for (std::size_t i = 0; i < samples_processed; i++) {
             output_buffer[i] = buffer_data[i * channel_count + channel];
         }
     }

src/common/CMakeLists.txt

@@ -150,8 +150,6 @@ add_library(common STATIC
     scope_exit.h
     spin_lock.cpp
     spin_lock.h
-    stream.cpp
-    stream.h
     string_util.cpp
     string_util.h
     swap.h
@@ -190,29 +188,8 @@ if(ARCHITECTURE_x86_64)
     )
 endif()
 
-if (MSVC)
-  target_compile_definitions(common PRIVATE
-    # The standard library doesn't provide any replacement for codecvt yet
-    # so we can disable this deprecation warning for the time being.
-    _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING
-  )
-  target_compile_options(common PRIVATE
-    /W4
-    /WX
-  )
-else()
-  target_compile_options(common PRIVATE
-    -Werror
-  )
-endif()
-
 create_target_directory_groups(common)
 find_package(Boost 1.71 COMPONENTS context headers REQUIRED)
 
 target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile)
-target_link_libraries(common PRIVATE lz4::lz4 xbyak)
-if (MSVC)
-  target_link_libraries(common PRIVATE zstd::zstd)
-else()
-  target_link_libraries(common PRIVATE zstd)
-endif()
+target_link_libraries(common PRIVATE lz4::lz4 zstd::zstd xbyak)

src/common/fiber.cpp

@@ -4,8 +4,6 @@
 
 #include "common/assert.h"
 #include "common/fiber.h"
-#include "common/spin_lock.h"
-
 #if defined(_WIN32) || defined(WIN32)
 #include <windows.h>
 #else
@@ -16,45 +14,18 @@ namespace Common {
 
 constexpr std::size_t default_stack_size = 256 * 1024; // 256kb
 
-struct Fiber::FiberImpl {
-    SpinLock guard{};
-    std::function<void(void*)> entry_point;
-    std::function<void(void*)> rewind_point;
-    void* rewind_parameter{};
-    void* start_parameter{};
-    std::shared_ptr<Fiber> previous_fiber;
-    bool is_thread_fiber{};
-    bool released{};
-
 #if defined(_WIN32) || defined(WIN32)
+
+struct Fiber::FiberImpl {
     LPVOID handle = nullptr;
     LPVOID rewind_handle = nullptr;
-#else
-    alignas(64) std::array<u8, default_stack_size> stack;
-    alignas(64) std::array<u8, default_stack_size> rewind_stack;
-    u8* stack_limit;
-    u8* rewind_stack_limit;
-    boost::context::detail::fcontext_t context;
-    boost::context::detail::fcontext_t rewind_context;
-#endif
 };
 
-void Fiber::SetStartParameter(void* new_parameter) {
-    impl->start_parameter = new_parameter;
-}
-
-void Fiber::SetRewindPoint(std::function<void(void*)>&& rewind_func, void* rewind_param) {
-    impl->rewind_point = std::move(rewind_func);
-    impl->rewind_parameter = rewind_param;
-}
-
-#if defined(_WIN32) || defined(WIN32)
-
 void Fiber::Start() {
-    ASSERT(impl->previous_fiber != nullptr);
-    impl->previous_fiber->impl->guard.unlock();
-    impl->previous_fiber.reset();
-    impl->entry_point(impl->start_parameter);
+    ASSERT(previous_fiber != nullptr);
+    previous_fiber->guard.unlock();
+    previous_fiber.reset();
+    entry_point(start_parameter);
     UNREACHABLE();
 }
 
@@ -63,86 +34,99 @@ void Fiber::OnRewind() {
     DeleteFiber(impl->handle);
     impl->handle = impl->rewind_handle;
     impl->rewind_handle = nullptr;
-    impl->rewind_point(impl->rewind_parameter);
+    rewind_point(rewind_parameter);
     UNREACHABLE();
 }
 
 void Fiber::FiberStartFunc(void* fiber_parameter) {
-    auto* fiber = static_cast<Fiber*>(fiber_parameter);
+    auto fiber = static_cast<Fiber*>(fiber_parameter);
     fiber->Start();
 }
 
 void Fiber::RewindStartFunc(void* fiber_parameter) {
-    auto* fiber = static_cast<Fiber*>(fiber_parameter);
+    auto fiber = static_cast<Fiber*>(fiber_parameter);
     fiber->OnRewind();
 }
 
 Fiber::Fiber(std::function<void(void*)>&& entry_point_func, void* start_parameter)
-    : impl{std::make_unique<FiberImpl>()} {
-    impl->entry_point = std::move(entry_point_func);
-    impl->start_parameter = start_parameter;
+    : entry_point{std::move(entry_point_func)}, start_parameter{start_parameter} {
+    impl = std::make_unique<FiberImpl>();
     impl->handle = CreateFiber(default_stack_size, &FiberStartFunc, this);
 }
 
 Fiber::Fiber() : impl{std::make_unique<FiberImpl>()} {}
 
 Fiber::~Fiber() {
-    if (impl->released) {
+    if (released) {
         return;
     }
     // Make sure the Fiber is not being used
-    const bool locked = impl->guard.try_lock();
+    const bool locked = guard.try_lock();
     ASSERT_MSG(locked, "Destroying a fiber that's still running");
     if (locked) {
-        impl->guard.unlock();
+        guard.unlock();
     }
     DeleteFiber(impl->handle);
 }
 
 void Fiber::Exit() {
-    ASSERT_MSG(impl->is_thread_fiber, "Exitting non main thread fiber");
-    if (!impl->is_thread_fiber) {
+    ASSERT_MSG(is_thread_fiber, "Exitting non main thread fiber");
+    if (!is_thread_fiber) {
         return;
     }
     ConvertFiberToThread();
-    impl->guard.unlock();
-    impl->released = true;
+    guard.unlock();
+    released = true;
+}
+
+void Fiber::SetRewindPoint(std::function<void(void*)>&& rewind_func, void* start_parameter) {
+    rewind_point = std::move(rewind_func);
+    rewind_parameter = start_parameter;
 }
 
 void Fiber::Rewind() {
-    ASSERT(impl->rewind_point);
+    ASSERT(rewind_point);
     ASSERT(impl->rewind_handle == nullptr);
     impl->rewind_handle = CreateFiber(default_stack_size, &RewindStartFunc, this);
     SwitchToFiber(impl->rewind_handle);
 }
 
-void Fiber::YieldTo(std::shared_ptr<Fiber> from, std::shared_ptr<Fiber> to) {
+void Fiber::YieldTo(std::shared_ptr<Fiber>& from, std::shared_ptr<Fiber>& to) {
     ASSERT_MSG(from != nullptr, "Yielding fiber is null!");
     ASSERT_MSG(to != nullptr, "Next fiber is null!");
-    to->impl->guard.lock();
-    to->impl->previous_fiber = from;
+    to->guard.lock();
+    to->previous_fiber = from;
     SwitchToFiber(to->impl->handle);
-    ASSERT(from->impl->previous_fiber != nullptr);
-    from->impl->previous_fiber->impl->guard.unlock();
-    from->impl->previous_fiber.reset();
+    ASSERT(from->previous_fiber != nullptr);
+    from->previous_fiber->guard.unlock();
+    from->previous_fiber.reset();
 }
 
 std::shared_ptr<Fiber> Fiber::ThreadToFiber() {
     std::shared_ptr<Fiber> fiber = std::shared_ptr<Fiber>{new Fiber()};
-    fiber->impl->guard.lock();
+    fiber->guard.lock();
     fiber->impl->handle = ConvertThreadToFiber(nullptr);
-    fiber->impl->is_thread_fiber = true;
+    fiber->is_thread_fiber = true;
     return fiber;
 }
 
 #else
 
+struct Fiber::FiberImpl {
+    alignas(64) std::array<u8, default_stack_size> stack;
+    alignas(64) std::array<u8, default_stack_size> rewind_stack;
+    u8* stack_limit;
+    u8* rewind_stack_limit;
+    boost::context::detail::fcontext_t context;
+    boost::context::detail::fcontext_t rewind_context;
+};
+
 void Fiber::Start(boost::context::detail::transfer_t& transfer) {
-    ASSERT(impl->previous_fiber != nullptr);
-    impl->previous_fiber->impl->context = transfer.fctx;
-    impl->previous_fiber->impl->guard.unlock();
-    impl->previous_fiber.reset();
-    impl->entry_point(impl->start_parameter);
+    ASSERT(previous_fiber != nullptr);
+    previous_fiber->impl->context = transfer.fctx;
+    previous_fiber->guard.unlock();
+    previous_fiber.reset();
+    entry_point(start_parameter);
     UNREACHABLE();
 }
 
@@ -153,24 +137,23 @@ void Fiber::OnRewind([[maybe_unused]] boost::context::detail::transfer_t& transf
     u8* tmp = impl->stack_limit;
     impl->stack_limit = impl->rewind_stack_limit;
     impl->rewind_stack_limit = tmp;
-    impl->rewind_point(impl->rewind_parameter);
+    rewind_point(rewind_parameter);
     UNREACHABLE();
 }
 
 void Fiber::FiberStartFunc(boost::context::detail::transfer_t transfer) {
-    auto* fiber = static_cast<Fiber*>(transfer.data);
+    auto fiber = static_cast<Fiber*>(transfer.data);
     fiber->Start(transfer);
 }
 
 void Fiber::RewindStartFunc(boost::context::detail::transfer_t transfer) {
-    auto* fiber = static_cast<Fiber*>(transfer.data);
+    auto fiber = static_cast<Fiber*>(transfer.data);
     fiber->OnRewind(transfer);
 }
 
 Fiber::Fiber(std::function<void(void*)>&& entry_point_func, void* start_parameter)
-    : impl{std::make_unique<FiberImpl>()} {
-    impl->entry_point = std::move(entry_point_func);
-    impl->start_parameter = start_parameter;
+    : entry_point{std::move(entry_point_func)}, start_parameter{start_parameter} {
+    impl = std::make_unique<FiberImpl>();
     impl->stack_limit = impl->stack.data();
     impl->rewind_stack_limit = impl->rewind_stack.data();
     u8* stack_base = impl->stack_limit + default_stack_size;
@@ -178,31 +161,37 @@ Fiber::Fiber(std::function<void(void*)>&& entry_point_func, void* start_paramete
         boost::context::detail::make_fcontext(stack_base, impl->stack.size(), FiberStartFunc);
 }
 
+void Fiber::SetRewindPoint(std::function<void(void*)>&& rewind_func, void* start_parameter) {
+    rewind_point = std::move(rewind_func);
+    rewind_parameter = start_parameter;
+}
+
 Fiber::Fiber() : impl{std::make_unique<FiberImpl>()} {}
 
 Fiber::~Fiber() {
-    if (impl->released) {
+    if (released) {
         return;
     }
     // Make sure the Fiber is not being used
-    const bool locked = impl->guard.try_lock();
+    const bool locked = guard.try_lock();
     ASSERT_MSG(locked, "Destroying a fiber that's still running");
     if (locked) {
-        impl->guard.unlock();
+        guard.unlock();
     }
 }
 
 void Fiber::Exit() {
-    ASSERT_MSG(impl->is_thread_fiber, "Exitting non main thread fiber");
-    if (!impl->is_thread_fiber) {
+
+    ASSERT_MSG(is_thread_fiber, "Exitting non main thread fiber");
+    if (!is_thread_fiber) {
         return;
     }
-    impl->guard.unlock();
-    impl->released = true;
+    guard.unlock();
+    released = true;
 }
 
 void Fiber::Rewind() {
-    ASSERT(impl->rewind_point);
+    ASSERT(rewind_point);
     ASSERT(impl->rewind_context == nullptr);
     u8* stack_base = impl->rewind_stack_limit + default_stack_size;
     impl->rewind_context =
@@ -210,22 +199,22 @@ void Fiber::Rewind() {
     boost::context::detail::jump_fcontext(impl->rewind_context, this);
 }
 
-void Fiber::YieldTo(std::shared_ptr<Fiber> from, std::shared_ptr<Fiber> to) {
+void Fiber::YieldTo(std::shared_ptr<Fiber>& from, std::shared_ptr<Fiber>& to) {
     ASSERT_MSG(from != nullptr, "Yielding fiber is null!");
     ASSERT_MSG(to != nullptr, "Next fiber is null!");
-    to->impl->guard.lock();
-    to->impl->previous_fiber = from;
+    to->guard.lock();
+    to->previous_fiber = from;
     auto transfer = boost::context::detail::jump_fcontext(to->impl->context, to.get());
-    ASSERT(from->impl->previous_fiber != nullptr);
-    from->impl->previous_fiber->impl->context = transfer.fctx;
-    from->impl->previous_fiber->impl->guard.unlock();
-    from->impl->previous_fiber.reset();
+    ASSERT(from->previous_fiber != nullptr);
+    from->previous_fiber->impl->context = transfer.fctx;
+    from->previous_fiber->guard.unlock();
+    from->previous_fiber.reset();
 }
 
 std::shared_ptr<Fiber> Fiber::ThreadToFiber() {
     std::shared_ptr<Fiber> fiber = std::shared_ptr<Fiber>{new Fiber()};
-    fiber->impl->guard.lock();
-    fiber->impl->is_thread_fiber = true;
+    fiber->guard.lock();
+    fiber->is_thread_fiber = true;
     return fiber;
 }
 

src/common/fiber.h

@@ -7,6 +7,9 @@
 #include <functional>
 #include <memory>
 
+#include "common/common_types.h"
+#include "common/spin_lock.h"
+
 #if !defined(_WIN32) && !defined(WIN32)
 namespace boost::context::detail {
 struct transfer_t;
@@ -43,10 +46,10 @@ public:
 
     /// Yields control from Fiber 'from' to Fiber 'to'
     /// Fiber 'from' must be the currently running fiber.
-    static void YieldTo(std::shared_ptr<Fiber> from, std::shared_ptr<Fiber> to);
+    static void YieldTo(std::shared_ptr<Fiber>& from, std::shared_ptr<Fiber>& to);
     [[nodiscard]] static std::shared_ptr<Fiber> ThreadToFiber();
 
-    void SetRewindPoint(std::function<void(void*)>&& rewind_func, void* rewind_param);
+    void SetRewindPoint(std::function<void(void*)>&& rewind_func, void* start_parameter);
 
     void Rewind();
 
@@ -54,7 +57,9 @@ public:
     void Exit();
 
     /// Changes the start parameter of the fiber. Has no effect if the fiber already started
-    void SetStartParameter(void* new_parameter);
+    void SetStartParameter(void* new_parameter) {
+        start_parameter = new_parameter;
+    }
 
 private:
     Fiber();
@@ -72,7 +77,16 @@ private:
 #endif
 
     struct FiberImpl;
+
+    SpinLock guard{};
+    std::function<void(void*)> entry_point;
+    std::function<void(void*)> rewind_point;
+    void* rewind_parameter{};
+    void* start_parameter{};
+    std::shared_ptr<Fiber> previous_fiber;
     std::unique_ptr<FiberImpl> impl;
+    bool is_thread_fiber{};
+    bool released{};
 };
 
 } // namespace Common

src/common/file_util.cpp

@@ -472,14 +472,13 @@ u64 ScanDirectoryTree(const std::string& directory, FSTEntry& parent_entry,
 }
 
 bool DeleteDirRecursively(const std::string& directory, unsigned int recursion) {
-    const auto callback = [recursion](u64*, const std::string& directory,
-                                      const std::string& virtual_name) {
-        const std::string new_path = directory + DIR_SEP_CHR + virtual_name;
+    const auto callback = [recursion](u64* num_entries_out, const std::string& directory,
+                                      const std::string& virtual_name) -> bool {
+        std::string new_path = directory + DIR_SEP_CHR + virtual_name;
 
         if (IsDirectory(new_path)) {
-            if (recursion == 0) {
+            if (recursion == 0)
                 return false;
-            }
             return DeleteDirRecursively(new_path, recursion - 1);
         }
         return Delete(new_path);
@@ -493,8 +492,7 @@ bool DeleteDirRecursively(const std::string& directory, unsigned int recursion)
     return true;
 }
 
-void CopyDir([[maybe_unused]] const std::string& source_path,
-             [[maybe_unused]] const std::string& dest_path) {
+void CopyDir(const std::string& source_path, const std::string& dest_path) {
 #ifndef _WIN32
     if (source_path == dest_path) {
         return;
@@ -555,7 +553,7 @@ std::optional<std::string> GetCurrentDir() {
     std::string strDir = dir;
 #endif
     free(dir);
-    return strDir;
+    return std::move(strDir);
 }
 
 bool SetCurrentDir(const std::string& directory) {
@@ -774,23 +772,21 @@ std::size_t ReadFileToString(bool text_file, const std::string& filename, std::s
 
 void SplitFilename83(const std::string& filename, std::array<char, 9>& short_name,
                      std::array<char, 4>& extension) {
-    static constexpr std::string_view forbidden_characters = ".\"/\\[]:;=, ";
+    const std::string forbidden_characters = ".\"/\\[]:;=, ";
 
     // On a FAT32 partition, 8.3 names are stored as a 11 bytes array, filled with spaces.
     short_name = {{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', '\0'}};
     extension = {{' ', ' ', ' ', '\0'}};
 
-    auto point = filename.rfind('.');
-    if (point == filename.size() - 1) {
+    std::string::size_type point = filename.rfind('.');
+    if (point == filename.size() - 1)
         point = filename.rfind('.', point);
-    }
 
     // Get short name.
     int j = 0;
     for (char letter : filename.substr(0, point)) {
-        if (forbidden_characters.find(letter, 0) != std::string::npos) {
+        if (forbidden_characters.find(letter, 0) != std::string::npos)
             continue;
-        }
         if (j == 8) {
             // TODO(Link Mauve): also do that for filenames containing a space.
             // TODO(Link Mauve): handle multiple files having the same short name.
@@ -798,15 +794,14 @@ void SplitFilename83(const std::string& filename, std::array<char, 9>& short_nam
             short_name[7] = '1';
             break;
         }
-        short_name[j++] = static_cast<char>(std::toupper(letter));
+        short_name[j++] = toupper(letter);
     }
 
     // Get extension.
     if (point != std::string::npos) {
         j = 0;
-        for (char letter : filename.substr(point + 1, 3)) {
-            extension[j++] = static_cast<char>(std::toupper(letter));
-        }
+        for (char letter : filename.substr(point + 1, 3))
+            extension[j++] = toupper(letter);
     }
 }
 

src/common/file_util.h

@@ -232,7 +232,7 @@ public:
 
     void Swap(IOFile& other) noexcept;
 
-    bool Open(const std::string& filename, const char openmode[], int flags = 0);
+    [[nodiscard]] bool Open(const std::string& filename, const char openmode[], int flags = 0);
     bool Close();
 
     template <typename T>

src/common/hex_util.h

@@ -16,14 +16,14 @@ namespace Common {
 
 [[nodiscard]] constexpr u8 ToHexNibble(char c) {
     if (c >= 65 && c <= 70) {
-        return static_cast<u8>(c - 55);
+        return c - 55;
     }
 
     if (c >= 97 && c <= 102) {
-        return static_cast<u8>(c - 87);
+        return c - 87;
     }
 
-    return static_cast<u8>(c - 48);
+    return c - 48;
 }
 
 [[nodiscard]] std::vector<u8> HexStringToVector(std::string_view str, bool little_endian);
@@ -33,11 +33,11 @@ template <std::size_t Size, bool le = false>
     std::array<u8, Size> out{};
     if constexpr (le) {
         for (std::size_t i = 2 * Size - 2; i <= 2 * Size; i -= 2) {
-            out[i / 2] = static_cast<u8>((ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]));
+            out[i / 2] = (ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]);
         }
     } else {
         for (std::size_t i = 0; i < 2 * Size; i += 2) {
-            out[i / 2] = static_cast<u8>((ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]));
+            out[i / 2] = (ToHexNibble(str[i]) << 4) | ToHexNibble(str[i + 1]);
         }
     }
     return out;

src/common/logging/backend.cpp

@@ -274,6 +274,7 @@ const char* GetLogClassName(Class log_class) {
     case Class::Count:
         break;
     }
+    UNREACHABLE();
     return "Invalid";
 }
 
@@ -292,6 +293,7 @@ const char* GetLevelName(Level log_level) {
         break;
     }
 #undef LVL
+    UNREACHABLE();
     return "Invalid";
 }
 

src/common/math_util.h

@@ -20,14 +20,14 @@ struct Rectangle {
 
     constexpr Rectangle() = default;
 
-    constexpr Rectangle(T left_, T top_, T right_, T bottom_)
-        : left(left_), top(top_), right(right_), bottom(bottom_) {}
+    constexpr Rectangle(T left, T top, T right, T bottom)
+        : left(left), top(top), right(right), bottom(bottom) {}
 
     [[nodiscard]] T GetWidth() const {
         if constexpr (std::is_floating_point_v<T>) {
             return std::abs(right - left);
         } else {
-            return static_cast<T>(std::abs(static_cast<std::make_signed_t<T>>(right - left)));
+            return std::abs(static_cast<std::make_signed_t<T>>(right - left));
         }
     }
 
@@ -35,7 +35,7 @@ struct Rectangle {
         if constexpr (std::is_floating_point_v<T>) {
             return std::abs(bottom - top);
         } else {
-            return static_cast<T>(std::abs(static_cast<std::make_signed_t<T>>(bottom - top)));
+            return std::abs(static_cast<std::make_signed_t<T>>(bottom - top));
         }
     }
 

src/common/misc.cpp

@@ -16,23 +16,16 @@
 // Call directly after the command or use the error num.
 // This function might change the error code.
 std::string GetLastErrorMsg() {
-    static constexpr std::size_t buff_size = 255;
+    static const std::size_t buff_size = 255;
     char err_str[buff_size];
 
 #ifdef _WIN32
     FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM, nullptr, GetLastError(),
                    MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), err_str, buff_size, nullptr);
-    return std::string(err_str, buff_size);
-#elif defined(__GLIBC__) && (_GNU_SOURCE || (_POSIX_C_SOURCE < 200112L && _XOPEN_SOURCE < 600))
-    // Thread safe (GNU-specific)
-    const char* str = strerror_r(errno, err_str, buff_size);
-    return std::string(str);
 #else
     // Thread safe (XSI-compliant)
-    const int success = strerror_r(errno, err_str, buff_size);
-    if (success != 0) {
-        return {};
-    }
-    return std::string(err_str);
+    strerror_r(errno, err_str, buff_size);
 #endif
+
+    return std::string(err_str, buff_size);
 }

src/common/spin_lock.h

@@ -15,14 +15,6 @@ namespace Common {
  */
 class SpinLock {
 public:
-    SpinLock() = default;
-
-    SpinLock(const SpinLock&) = delete;
-    SpinLock& operator=(const SpinLock&) = delete;
-
-    SpinLock(SpinLock&&) = delete;
-    SpinLock& operator=(SpinLock&&) = delete;
-
     void lock();
     void unlock();
     [[nodiscard]] bool try_lock();

src/common/stream.cpp

@@ -1,47 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <stdexcept>
-#include "common/common_types.h"
-#include "common/stream.h"
-
-namespace Common {
-
-Stream::Stream() = default;
-Stream::~Stream() = default;
-
-void Stream::Seek(s32 offset, SeekOrigin origin) {
-    if (origin == SeekOrigin::SetOrigin) {
-        if (offset < 0) {
-            position = 0;
-        } else if (position >= buffer.size()) {
-            position = buffer.size();
-        } else {
-            position = offset;
-        }
-    } else if (origin == SeekOrigin::FromCurrentPos) {
-        Seek(static_cast<s32>(position) + offset, SeekOrigin::SetOrigin);
-    } else if (origin == SeekOrigin::FromEnd) {
-        Seek(static_cast<s32>(buffer.size()) - offset, SeekOrigin::SetOrigin);
-    }
-}
-
-u8 Stream::ReadByte() {
-    if (position < buffer.size()) {
-        return buffer[position++];
-    } else {
-        throw std::out_of_range("Attempting to read a byte not within the buffer range");
-    }
-}
-
-void Stream::WriteByte(u8 byte) {
-    if (position == buffer.size()) {
-        buffer.push_back(byte);
-        position++;
-    } else {
-        buffer.insert(buffer.begin() + position, byte);
-    }
-}
-
-} // namespace Common

src/common/stream.h

@@ -1,56 +0,0 @@
-// Copyright 2020 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <vector>
-#include "common/common_types.h"
-
-namespace Common {
-
-enum class SeekOrigin {
-    SetOrigin,
-    FromCurrentPos,
-    FromEnd,
-};
-
-class Stream {
-public:
-    /// Stream creates a bitstream and provides common functionality on the stream.
-    explicit Stream();
-    ~Stream();
-
-    Stream(const Stream&) = delete;
-    Stream& operator=(const Stream&) = delete;
-
-    Stream(Stream&&) = default;
-    Stream& operator=(Stream&&) = default;
-
-    /// Reposition bitstream "cursor" to the specified offset from origin
-    void Seek(s32 offset, SeekOrigin origin);
-
-    /// Reads next byte in the stream buffer and increments position
-    u8 ReadByte();
-
-    /// Writes byte at current position
-    void WriteByte(u8 byte);
-
-    [[nodiscard]] std::size_t GetPosition() const {
-        return position;
-    }
-
-    [[nodiscard]] std::vector<u8>& GetBuffer() {
-        return buffer;
-    }
-
-    [[nodiscard]] const std::vector<u8>& GetBuffer() const {
-        return buffer;
-    }
-
-private:
-    std::vector<u8> buffer;
-    std::size_t position{0};
-};
-
-} // namespace Common

src/common/string_util.cpp

@@ -8,7 +8,6 @@
 #include <cstdlib>
 #include <locale>
 #include <sstream>
-
 #include "common/common_paths.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
@@ -22,14 +21,14 @@ namespace Common {
 /// Make a string lowercase
 std::string ToLower(std::string str) {
     std::transform(str.begin(), str.end(), str.begin(),
-                   [](unsigned char c) { return static_cast<char>(std::tolower(c)); });
+                   [](unsigned char c) { return std::tolower(c); });
     return str;
 }
 
 /// Make a string uppercase
 std::string ToUpper(std::string str) {
     std::transform(str.begin(), str.end(), str.begin(),
-                   [](unsigned char c) { return static_cast<char>(std::toupper(c)); });
+                   [](unsigned char c) { return std::toupper(c); });
     return str;
 }
 

src/common/timer.cpp

@@ -142,18 +142,20 @@ std::string Timer::GetTimeFormatted() {
 // ----------------
 double Timer::GetDoubleTime() {
     // Get continuous timestamp
-    auto tmp_seconds = static_cast<u64>(GetTimeSinceJan1970().count());
-    const auto ms = static_cast<double>(static_cast<u64>(GetTimeMs().count()) % 1000);
+    u64 TmpSeconds = static_cast<u64>(Common::Timer::GetTimeSinceJan1970().count());
+    double ms = static_cast<u64>(GetTimeMs().count()) % 1000;
 
     // Remove a few years. We only really want enough seconds to make
     // sure that we are detecting actual actions, perhaps 60 seconds is
     // enough really, but I leave a year of seconds anyway, in case the
     // user's clock is incorrect or something like that.
-    tmp_seconds = tmp_seconds - (38 * 365 * 24 * 60 * 60);
+    TmpSeconds = TmpSeconds - (38 * 365 * 24 * 60 * 60);
 
     // Make a smaller integer that fits in the double
-    const auto seconds = static_cast<u32>(tmp_seconds);
-    return seconds + ms;
+    u32 Seconds = static_cast<u32>(TmpSeconds);
+    double TmpTime = Seconds + ms;
+
+    return TmpTime;
 }
 
 } // Namespace Common

src/common/vector_math.h

@@ -87,13 +87,7 @@ public:
 
     template <typename V>
     [[nodiscard]] constexpr Vec2<decltype(T{} * V{})> operator*(const V& f) const {
-        using TV = decltype(T{} * V{});
-        using C = std::common_type_t<T, V>;
-
-        return {
-            static_cast<TV>(static_cast<C>(x) * static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(y) * static_cast<C>(f)),
-        };
+        return {x * f, y * f};
     }
 
     template <typename V>
@@ -104,13 +98,7 @@ public:
 
     template <typename V>
     [[nodiscard]] constexpr Vec2<decltype(T{} / V{})> operator/(const V& f) const {
-        using TV = decltype(T{} / V{});
-        using C = std::common_type_t<T, V>;
-
-        return {
-            static_cast<TV>(static_cast<C>(x) / static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(y) / static_cast<C>(f)),
-        };
+        return {x / f, y / f};
     }
 
     template <typename V>
@@ -180,10 +168,7 @@ public:
 
 template <typename T, typename V>
 [[nodiscard]] constexpr Vec2<T> operator*(const V& f, const Vec2<T>& vec) {
-    using C = std::common_type_t<T, V>;
-
-    return Vec2<T>(static_cast<T>(static_cast<C>(f) * static_cast<C>(vec.x)),
-                   static_cast<T>(static_cast<C>(f) * static_cast<C>(vec.y)));
+    return Vec2<T>(f * vec.x, f * vec.y);
 }
 
 using Vec2f = Vec2<float>;
@@ -252,14 +237,7 @@ public:
 
     template <typename V>
     [[nodiscard]] constexpr Vec3<decltype(T{} * V{})> operator*(const V& f) const {
-        using TV = decltype(T{} * V{});
-        using C = std::common_type_t<T, V>;
-
-        return {
-            static_cast<TV>(static_cast<C>(x) * static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(y) * static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(z) * static_cast<C>(f)),
-        };
+        return {x * f, y * f, z * f};
     }
 
     template <typename V>
@@ -269,14 +247,7 @@ public:
     }
     template <typename V>
     [[nodiscard]] constexpr Vec3<decltype(T{} / V{})> operator/(const V& f) const {
-        using TV = decltype(T{} / V{});
-        using C = std::common_type_t<T, V>;
-
-        return {
-            static_cast<TV>(static_cast<C>(x) / static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(y) / static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(z) / static_cast<C>(f)),
-        };
+        return {x / f, y / f, z / f};
     }
 
     template <typename V>
@@ -396,11 +367,7 @@ public:
 
 template <typename T, typename V>
 [[nodiscard]] constexpr Vec3<T> operator*(const V& f, const Vec3<T>& vec) {
-    using C = std::common_type_t<T, V>;
-
-    return Vec3<T>(static_cast<T>(static_cast<C>(f) * static_cast<C>(vec.x)),
-                   static_cast<T>(static_cast<C>(f) * static_cast<C>(vec.y)),
-                   static_cast<T>(static_cast<C>(f) * static_cast<C>(vec.z)));
+    return Vec3<T>(f * vec.x, f * vec.y, f * vec.z);
 }
 
 template <>
@@ -479,15 +446,7 @@ public:
 
     template <typename V>
     [[nodiscard]] constexpr Vec4<decltype(T{} * V{})> operator*(const V& f) const {
-        using TV = decltype(T{} * V{});
-        using C = std::common_type_t<T, V>;
-
-        return {
-            static_cast<TV>(static_cast<C>(x) * static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(y) * static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(z) * static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(w) * static_cast<C>(f)),
-        };
+        return {x * f, y * f, z * f, w * f};
     }
 
     template <typename V>
@@ -498,15 +457,7 @@ public:
 
     template <typename V>
     [[nodiscard]] constexpr Vec4<decltype(T{} / V{})> operator/(const V& f) const {
-        using TV = decltype(T{} / V{});
-        using C = std::common_type_t<T, V>;
-
-        return {
-            static_cast<TV>(static_cast<C>(x) / static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(y) / static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(z) / static_cast<C>(f)),
-            static_cast<TV>(static_cast<C>(w) / static_cast<C>(f)),
-        };
+        return {x / f, y / f, z / f, w / f};
     }
 
     template <typename V>
@@ -631,15 +582,7 @@ public:
 
 template <typename T, typename V>
 [[nodiscard]] constexpr Vec4<decltype(V{} * T{})> operator*(const V& f, const Vec4<T>& vec) {
-    using TV = decltype(V{} * T{});
-    using C = std::common_type_t<T, V>;
-
-    return {
-        static_cast<TV>(static_cast<C>(f) * static_cast<C>(vec.x)),
-        static_cast<TV>(static_cast<C>(f) * static_cast<C>(vec.y)),
-        static_cast<TV>(static_cast<C>(f) * static_cast<C>(vec.z)),
-        static_cast<TV>(static_cast<C>(f) * static_cast<C>(vec.w)),
-    };
+    return {f * vec.x, f * vec.y, f * vec.z, f * vec.w};
 }
 
 using Vec4f = Vec4<float>;

src/common/wall_clock.cpp

@@ -15,7 +15,7 @@ namespace Common {
 using base_timer = std::chrono::steady_clock;
 using base_time_point = std::chrono::time_point<base_timer>;
 
-class StandardWallClock final : public WallClock {
+class StandardWallClock : public WallClock {
 public:
     StandardWallClock(u64 emulated_cpu_frequency, u64 emulated_clock_frequency)
         : WallClock(emulated_cpu_frequency, emulated_clock_frequency, false) {
@@ -53,7 +53,7 @@ public:
         return Common::Divide128On32(temporary, 1000000000).first;
     }
 
-    void Pause([[maybe_unused]] bool is_paused) override {
+    void Pause(bool is_paused) override {
         // Do nothing in this clock type.
     }
 

src/common/wall_clock.h

@@ -13,8 +13,6 @@ namespace Common {
 
 class WallClock {
 public:
-    virtual ~WallClock() = default;
-
     /// Returns current wall time in nanoseconds
     [[nodiscard]] virtual std::chrono::nanoseconds GetTimeNS() = 0;
 

src/common/x64/native_clock.h

@@ -12,7 +12,7 @@
 namespace Common {
 
 namespace X64 {
-class NativeClock final : public WallClock {
+class NativeClock : public WallClock {
 public:
     NativeClock(u64 emulated_cpu_frequency, u64 emulated_clock_frequency, u64 rtsc_frequency);
 
@@ -34,7 +34,7 @@ private:
     /// value used to reduce the native clocks accuracy as some apss rely on
     /// undefined behavior where the level of accuracy in the clock shouldn't
     /// be higher.
-    static constexpr u64 inaccuracy_mask = ~(UINT64_C(0x400) - 1);
+    static constexpr u64 inaccuracy_mask = ~(0x400 - 1);
 
     SpinLock rtsc_serialize{};
     u64 last_measure{};

src/core/CMakeLists.txt

@@ -1,3 +1,9 @@
+if (YUZU_ENABLE_BOXCAT)
+    set(BCAT_BOXCAT_ADDITIONAL_SOURCES hle/service/bcat/backend/boxcat.cpp hle/service/bcat/backend/boxcat.h)
+else()
+    set(BCAT_BOXCAT_ADDITIONAL_SOURCES)
+endif()
+
 add_library(core STATIC
     arm/arm_interface.h
     arm/arm_interface.cpp
@@ -13,6 +19,8 @@ add_library(core STATIC
     arm/dynarmic/arm_exclusive_monitor.h
     arm/exclusive_monitor.cpp
     arm/exclusive_monitor.h
+    arm/unicorn/arm_unicorn.cpp
+    arm/unicorn/arm_unicorn.h
     constants.cpp
     constants.h
     core.cpp
@@ -295,6 +303,7 @@ add_library(core STATIC
     hle/service/audio/hwopus.h
     hle/service/bcat/backend/backend.cpp
     hle/service/bcat/backend/backend.h
+    ${BCAT_BOXCAT_ADDITIONAL_SOURCES}
     hle/service/bcat/bcat.cpp
     hle/service/bcat/bcat.h
     hle/service/bcat/module.cpp
@@ -437,8 +446,6 @@ add_library(core STATIC
     hle/service/nvdrv/devices/nvhost_gpu.h
     hle/service/nvdrv/devices/nvhost_nvdec.cpp
     hle/service/nvdrv/devices/nvhost_nvdec.h
-    hle/service/nvdrv/devices/nvhost_nvdec_common.cpp
-    hle/service/nvdrv/devices/nvhost_nvdec_common.h
     hle/service/nvdrv/devices/nvhost_nvjpg.cpp
     hle/service/nvdrv/devices/nvhost_nvjpg.h
     hle/service/nvdrv/devices/nvhost_vic.cpp
@@ -452,8 +459,6 @@ add_library(core STATIC
     hle/service/nvdrv/nvdrv.h
     hle/service/nvdrv/nvmemp.cpp
     hle/service/nvdrv/nvmemp.h
-    hle/service/nvdrv/syncpoint_manager.cpp
-    hle/service/nvdrv/syncpoint_manager.h
     hle/service/nvflinger/buffer_queue.cpp
     hle/service/nvflinger/buffer_queue.h
     hle/service/nvflinger/nvflinger.cpp
@@ -603,13 +608,6 @@ add_library(core STATIC
     tools/freezer.h
 )
 
-if (YUZU_ENABLE_BOXCAT)
-    target_sources(core PRIVATE
-        hle/service/bcat/backend/boxcat.cpp
-        hle/service/bcat/backend/boxcat.h
-    )
-endif()
-
 if (MSVC)
     target_compile_options(core PRIVATE
         # 'expression' : signed/unsigned mismatch
@@ -625,26 +623,12 @@ if (MSVC)
         # 'context' : truncation from 'type1' to 'type2'
         /we4305
     )
-else()
-    target_compile_options(core PRIVATE
-        -Werror=conversion
-        -Werror=ignored-qualifiers
-        -Werror=implicit-fallthrough
-        -Werror=reorder
-        -Werror=sign-compare
-        -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()
 
 create_target_directory_groups(core)
 
 target_link_libraries(core PUBLIC common PRIVATE audio_core video_core)
-target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls opus zip)
+target_link_libraries(core PUBLIC Boost::boost PRIVATE fmt::fmt nlohmann_json::nlohmann_json mbedtls opus unicorn zip)
 
 if (YUZU_ENABLE_BOXCAT)
     target_compile_definitions(core PRIVATE -DYUZU_ENABLE_BOXCAT)

src/core/arm/arm_interface.cpp

@@ -147,18 +147,10 @@ std::vector<ARM_Interface::BacktraceEntry> ARM_Interface::GetBacktraceFromContex
     auto fp = ctx.cpu_registers[29];
     auto lr = ctx.cpu_registers[30];
     while (true) {
-        out.push_back({
-            .module = "",
-            .address = 0,
-            .original_address = lr,
-            .offset = 0,
-            .name = {},
-        });
-
-        if (fp == 0) {
+        out.push_back({"", 0, lr, 0});
+        if (!fp) {
             break;
         }
-
         lr = memory.Read64(fp + 8) - 4;
         fp = memory.Read64(fp);
     }

src/core/arm/cpu_interrupt_handler.h

@@ -21,8 +21,8 @@ public:
     CPUInterruptHandler(const CPUInterruptHandler&) = delete;
     CPUInterruptHandler& operator=(const CPUInterruptHandler&) = delete;
 
-    CPUInterruptHandler(CPUInterruptHandler&&) = delete;
-    CPUInterruptHandler& operator=(CPUInterruptHandler&&) = delete;
+    CPUInterruptHandler(CPUInterruptHandler&&) = default;
+    CPUInterruptHandler& operator=(CPUInterruptHandler&&) = default;
 
     bool IsInterrupted() const {
         return is_interrupted;

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -7,7 +7,6 @@
 #include <dynarmic/A32/a32.h>
 #include <dynarmic/A32/config.h>
 #include <dynarmic/A32/context.h>
-#include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/page_table.h"
 #include "core/arm/cpu_interrupt_handler.h"

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -6,7 +6,6 @@
 #include <memory>
 #include <dynarmic/A64/a64.h>
 #include <dynarmic/A64/config.h>
-#include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/page_table.h"
 #include "core/arm/cpu_interrupt_handler.h"
@@ -14,6 +13,7 @@
 #include "core/arm/dynarmic/arm_exclusive_monitor.h"
 #include "core/core.h"
 #include "core/core_timing.h"
+#include "core/core_timing_util.h"
 #include "core/gdbstub/gdbstub.h"
 #include "core/hardware_properties.h"
 #include "core/hle/kernel/process.h"
@@ -82,9 +82,16 @@ public:
     }
 
     void InterpreterFallback(u64 pc, std::size_t num_instructions) override {
-        LOG_ERROR(Core_ARM,
-                  "Unimplemented instruction @ 0x{:X} for {} instructions (instr = {:08X})", pc,
-                  num_instructions, MemoryReadCode(pc));
+        LOG_INFO(Core_ARM, "Unicorn fallback @ 0x{:X} for {} instructions (instr = {:08X})", pc,
+                 num_instructions, MemoryReadCode(pc));
+
+        ARM_Interface::ThreadContext64 ctx;
+        parent.SaveContext(ctx);
+        parent.inner_unicorn.LoadContext(ctx);
+        parent.inner_unicorn.ExecuteInstructions(num_instructions);
+        parent.inner_unicorn.SaveContext(ctx);
+        parent.LoadContext(ctx);
+        num_interpreted_instructions += num_instructions;
     }
 
     void ExceptionRaised(u64 pc, Dynarmic::A64::Exception exception) override {
@@ -120,17 +127,18 @@ public:
         if (parent.uses_wall_clock) {
             return;
         }
-
         // Divide the number of ticks by the amount of CPU cores. TODO(Subv): This yields only a
         // rough approximation of the amount of executed ticks in the system, it may be thrown off
         // if not all cores are doing a similar amount of work. Instead of doing this, we should
         // device a way so that timing is consistent across all cores without increasing the ticks 4
         // times.
-        u64 amortized_ticks = ticks / Core::Hardware::NUM_CPU_CORES;
+        u64 amortized_ticks =
+            (ticks - num_interpreted_instructions) / Core::Hardware::NUM_CPU_CORES;
         // Always execute at least one tick.
         amortized_ticks = std::max<u64>(amortized_ticks, 1);
 
         parent.system.CoreTiming().AddTicks(amortized_ticks);
+        num_interpreted_instructions = 0;
     }
 
     u64 GetTicksRemaining() override {
@@ -148,6 +156,7 @@ public:
     }
 
     ARM_Dynarmic_64& parent;
+    std::size_t num_interpreted_instructions = 0;
     u64 tpidrro_el0 = 0;
     u64 tpidr_el0 = 0;
     static constexpr u64 minimum_run_cycles = 1000U;
@@ -239,8 +248,12 @@ ARM_Dynarmic_64::ARM_Dynarmic_64(System& system, CPUInterrupts& interrupt_handle
                                  bool uses_wall_clock, ExclusiveMonitor& exclusive_monitor,
                                  std::size_t core_index)
     : ARM_Interface{system, interrupt_handlers, uses_wall_clock},
-      cb(std::make_unique<DynarmicCallbacks64>(*this)), core_index{core_index},
-      exclusive_monitor{dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {}
+      cb(std::make_unique<DynarmicCallbacks64>(*this)), inner_unicorn{system, interrupt_handlers,
+                                                                      uses_wall_clock,
+                                                                      ARM_Unicorn::Arch::AArch64,
+                                                                      core_index},
+      core_index{core_index}, exclusive_monitor{
+                                  dynamic_cast<DynarmicExclusiveMonitor&>(exclusive_monitor)} {}
 
 ARM_Dynarmic_64::~ARM_Dynarmic_64() = default;
 

src/core/arm/dynarmic/arm_dynarmic_64.h

@@ -12,6 +12,7 @@
 #include "common/hash.h"
 #include "core/arm/arm_interface.h"
 #include "core/arm/exclusive_monitor.h"
+#include "core/arm/unicorn/arm_unicorn.h"
 
 namespace Core::Memory {
 class Memory;
@@ -70,6 +71,7 @@ private:
     std::unique_ptr<DynarmicCallbacks64> cb;
     JitCacheType jit_cache;
     std::shared_ptr<Dynarmic::A64::Jit> jit;
+    ARM_Unicorn inner_unicorn;
 
     std::size_t core_index;
     DynarmicExclusiveMonitor& exclusive_monitor;

src/core/arm/dynarmic/arm_dynarmic_cp15.cpp

@@ -34,7 +34,7 @@ std::optional<Callback> DynarmicCP15::CompileInternalOperation(bool two, unsigne
                                                                CoprocReg CRm, unsigned opc2) {
     LOG_CRITICAL(Core_ARM, "CP15: cdp{} p15, {}, {}, {}, {}, {}", two ? "2" : "", opc1, CRd, CRn,
                  CRm, opc2);
-    return std::nullopt;
+    return {};
 }
 
 CallbackOrAccessOneWord DynarmicCP15::CompileSendOneWord(bool two, unsigned opc1, CoprocReg CRn,
@@ -115,7 +115,7 @@ std::optional<Callback> DynarmicCP15::CompileLoadWords(bool two, bool long_trans
         LOG_CRITICAL(Core_ARM, "CP15: mrrc{}{} p15, {}, [...]", two ? "2" : "",
                      long_transfer ? "l" : "", CRd);
     }
-    return std::nullopt;
+    return {};
 }
 
 std::optional<Callback> DynarmicCP15::CompileStoreWords(bool two, bool long_transfer, CoprocReg CRd,
@@ -127,7 +127,7 @@ std::optional<Callback> DynarmicCP15::CompileStoreWords(bool two, bool long_tran
         LOG_CRITICAL(Core_ARM, "CP15: mrrc{}{} p15, {}, [...]", two ? "2" : "",
                      long_transfer ? "l" : "", CRd);
     }
-    return std::nullopt;
+    return {};
 }
 
 } // namespace Core

src/core/arm/dynarmic/arm_dynarmic_cp15.h

@@ -35,8 +35,8 @@ public:
                                               std::optional<u8> option) override;
 
     ARM_Dynarmic_32& parent;
-    u32 uprw = 0;
-    u32 uro = 0;
+    u32 uprw;
+    u32 uro;
 };
 
 } // namespace Core

src/core/arm/unicorn/arm_unicorn.cpp

@@ -0,0 +1,295 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#include <algorithm>
+#include <unicorn/arm64.h>
+#include "common/assert.h"
+#include "common/microprofile.h"
+#include "core/arm/cpu_interrupt_handler.h"
+#include "core/arm/unicorn/arm_unicorn.h"
+#include "core/core.h"
+#include "core/core_timing.h"
+#include "core/hle/kernel/scheduler.h"
+#include "core/hle/kernel/svc.h"
+#include "core/memory.h"
+
+namespace Core {
+
+// Load Unicorn DLL once on Windows using RAII
+#ifdef _MSC_VER
+#include <unicorn_dynload.h>
+struct LoadDll {
+private:
+    LoadDll() {
+        ASSERT(uc_dyn_load(NULL, 0));
+    }
+    ~LoadDll() {
+        ASSERT(uc_dyn_free());
+    }
+    static LoadDll g_load_dll;
+};
+LoadDll LoadDll::g_load_dll;
+#endif
+
+#define CHECKED(expr)                                                                              \
+    do {                                                                                           \
+        if (auto _cerr = (expr)) {                                                                 \
+            ASSERT_MSG(false, "Call " #expr " failed with error: {} ({})\n", _cerr,                \
+                       uc_strerror(_cerr));                                                        \
+        }                                                                                          \
+    } while (0)
+
+static void CodeHook(uc_engine* uc, uint64_t address, uint32_t size, void* user_data) {
+    GDBStub::BreakpointAddress bkpt =
+        GDBStub::GetNextBreakpointFromAddress(address, GDBStub::BreakpointType::Execute);
+    if (GDBStub::IsMemoryBreak() ||
+        (bkpt.type != GDBStub::BreakpointType::None && address == bkpt.address)) {
+        auto core = static_cast<ARM_Unicorn*>(user_data);
+        core->RecordBreak(bkpt);
+        uc_emu_stop(uc);
+    }
+}
+
+static bool UnmappedMemoryHook(uc_engine* uc, uc_mem_type type, u64 addr, int size, u64 value,
+                               void* user_data) {
+    auto* const system = static_cast<System*>(user_data);
+
+    ARM_Interface::ThreadContext64 ctx{};
+    system->CurrentArmInterface().SaveContext(ctx);
+    ASSERT_MSG(false, "Attempted to read from unmapped memory: 0x{:X}, pc=0x{:X}, lr=0x{:X}", addr,
+               ctx.pc, ctx.cpu_registers[30]);
+
+    return false;
+}
+
+ARM_Unicorn::ARM_Unicorn(System& system, CPUInterrupts& interrupt_handlers, bool uses_wall_clock,
+                         Arch architecture, std::size_t core_index)
+    : ARM_Interface{system, interrupt_handlers, uses_wall_clock}, core_index{core_index} {
+    const auto arch = architecture == Arch::AArch32 ? UC_ARCH_ARM : UC_ARCH_ARM64;
+    CHECKED(uc_open(arch, UC_MODE_ARM, &uc));
+
+    auto fpv = 3 << 20;
+    CHECKED(uc_reg_write(uc, UC_ARM64_REG_CPACR_EL1, &fpv));
+
+    uc_hook hook{};
+    CHECKED(uc_hook_add(uc, &hook, UC_HOOK_INTR, (void*)InterruptHook, this, 0, UINT64_MAX));
+    CHECKED(uc_hook_add(uc, &hook, UC_HOOK_MEM_INVALID, (void*)UnmappedMemoryHook, &system, 0,
+                        UINT64_MAX));
+    if (GDBStub::IsServerEnabled()) {
+        CHECKED(uc_hook_add(uc, &hook, UC_HOOK_CODE, (void*)CodeHook, this, 0, UINT64_MAX));
+        last_bkpt_hit = false;
+    }
+}
+
+ARM_Unicorn::~ARM_Unicorn() {
+    CHECKED(uc_close(uc));
+}
+
+void ARM_Unicorn::SetPC(u64 pc) {
+    CHECKED(uc_reg_write(uc, UC_ARM64_REG_PC, &pc));
+}
+
+u64 ARM_Unicorn::GetPC() const {
+    u64 val{};
+    CHECKED(uc_reg_read(uc, UC_ARM64_REG_PC, &val));
+    return val;
+}
+
+u64 ARM_Unicorn::GetReg(int regn) const {
+    u64 val{};
+    auto treg = UC_ARM64_REG_SP;
+    if (regn <= 28) {
+        treg = (uc_arm64_reg)(UC_ARM64_REG_X0 + regn);
+    } else if (regn < 31) {
+        treg = (uc_arm64_reg)(UC_ARM64_REG_X29 + regn - 29);
+    }
+    CHECKED(uc_reg_read(uc, treg, &val));
+    return val;
+}
+
+void ARM_Unicorn::SetReg(int regn, u64 val) {
+    auto treg = UC_ARM64_REG_SP;
+    if (regn <= 28) {
+        treg = (uc_arm64_reg)(UC_ARM64_REG_X0 + regn);
+    } else if (regn < 31) {
+        treg = (uc_arm64_reg)(UC_ARM64_REG_X29 + regn - 29);
+    }
+    CHECKED(uc_reg_write(uc, treg, &val));
+}
+
+u128 ARM_Unicorn::GetVectorReg(int /*index*/) const {
+    UNIMPLEMENTED();
+    static constexpr u128 res{};
+    return res;
+}
+
+void ARM_Unicorn::SetVectorReg(int /*index*/, u128 /*value*/) {
+    UNIMPLEMENTED();
+}
+
+u32 ARM_Unicorn::GetPSTATE() const {
+    u64 nzcv{};
+    CHECKED(uc_reg_read(uc, UC_ARM64_REG_NZCV, &nzcv));
+    return static_cast<u32>(nzcv);
+}
+
+void ARM_Unicorn::SetPSTATE(u32 pstate) {
+    u64 nzcv = pstate;
+    CHECKED(uc_reg_write(uc, UC_ARM64_REG_NZCV, &nzcv));
+}
+
+VAddr ARM_Unicorn::GetTlsAddress() const {
+    u64 base{};
+    CHECKED(uc_reg_read(uc, UC_ARM64_REG_TPIDRRO_EL0, &base));
+    return base;
+}
+
+void ARM_Unicorn::SetTlsAddress(VAddr base) {
+    CHECKED(uc_reg_write(uc, UC_ARM64_REG_TPIDRRO_EL0, &base));
+}
+
+u64 ARM_Unicorn::GetTPIDR_EL0() const {
+    u64 value{};
+    CHECKED(uc_reg_read(uc, UC_ARM64_REG_TPIDR_EL0, &value));
+    return value;
+}
+
+void ARM_Unicorn::SetTPIDR_EL0(u64 value) {
+    CHECKED(uc_reg_write(uc, UC_ARM64_REG_TPIDR_EL0, &value));
+}
+
+void ARM_Unicorn::ChangeProcessorID(std::size_t new_core_id) {
+    core_index = new_core_id;
+}
+
+void ARM_Unicorn::Run() {
+    if (GDBStub::IsServerEnabled()) {
+        ExecuteInstructions(std::max(4000000U, 0U));
+    } else {
+        while (true) {
+            if (interrupt_handlers[core_index].IsInterrupted()) {
+                return;
+            }
+            ExecuteInstructions(10);
+        }
+    }
+}
+
+void ARM_Unicorn::Step() {
+    ExecuteInstructions(1);
+}
+
+MICROPROFILE_DEFINE(ARM_Jit_Unicorn, "ARM JIT", "Unicorn", MP_RGB(255, 64, 64));
+
+void ARM_Unicorn::ExecuteInstructions(std::size_t num_instructions) {
+    MICROPROFILE_SCOPE(ARM_Jit_Unicorn);
+
+    // Temporarily map the code page for Unicorn
+    u64 map_addr{GetPC() & ~Memory::PAGE_MASK};
+    std::vector<u8> page_buffer(Memory::PAGE_SIZE);
+    system.Memory().ReadBlock(map_addr, page_buffer.data(), page_buffer.size());
+
+    CHECKED(uc_mem_map_ptr(uc, map_addr, page_buffer.size(),
+                           UC_PROT_READ | UC_PROT_WRITE | UC_PROT_EXEC, page_buffer.data()));
+    CHECKED(uc_emu_start(uc, GetPC(), 1ULL << 63, 0, num_instructions));
+    CHECKED(uc_mem_unmap(uc, map_addr, page_buffer.size()));
+    if (GDBStub::IsServerEnabled()) {
+        if (last_bkpt_hit && last_bkpt.type == GDBStub::BreakpointType::Execute) {
+            uc_reg_write(uc, UC_ARM64_REG_PC, &last_bkpt.address);
+        }
+
+        Kernel::Thread* const thread = system.CurrentScheduler().GetCurrentThread();
+        SaveContext(thread->GetContext64());
+        if (last_bkpt_hit || GDBStub::IsMemoryBreak() || GDBStub::GetCpuStepFlag()) {
+            last_bkpt_hit = false;
+            GDBStub::Break();
+            GDBStub::SendTrap(thread, 5);
+        }
+    }
+}
+
+void ARM_Unicorn::SaveContext(ThreadContext64& ctx) {
+    int uregs[32];
+    void* tregs[32];
+
+    CHECKED(uc_reg_read(uc, UC_ARM64_REG_SP, &ctx.sp));
+    CHECKED(uc_reg_read(uc, UC_ARM64_REG_PC, &ctx.pc));
+    CHECKED(uc_reg_read(uc, UC_ARM64_REG_NZCV, &ctx.pstate));
+
+    for (auto i = 0; i < 29; ++i) {
+        uregs[i] = UC_ARM64_REG_X0 + i;
+        tregs[i] = &ctx.cpu_registers[i];
+    }
+    uregs[29] = UC_ARM64_REG_X29;
+    tregs[29] = (void*)&ctx.cpu_registers[29];
+    uregs[30] = UC_ARM64_REG_X30;
+    tregs[30] = (void*)&ctx.cpu_registers[30];
+
+    CHECKED(uc_reg_read_batch(uc, uregs, tregs, 31));
+
+    for (int i = 0; i < 32; ++i) {
+        uregs[i] = UC_ARM64_REG_Q0 + i;
+        tregs[i] = &ctx.vector_registers[i];
+    }
+
+    CHECKED(uc_reg_read_batch(uc, uregs, tregs, 32));
+}
+
+void ARM_Unicorn::LoadContext(const ThreadContext64& ctx) {
+    int uregs[32];
+    void* tregs[32];
+
+    CHECKED(uc_reg_write(uc, UC_ARM64_REG_SP, &ctx.sp));
+    CHECKED(uc_reg_write(uc, UC_ARM64_REG_PC, &ctx.pc));
+    CHECKED(uc_reg_write(uc, UC_ARM64_REG_NZCV, &ctx.pstate));
+
+    for (int i = 0; i < 29; ++i) {
+        uregs[i] = UC_ARM64_REG_X0 + i;
+        tregs[i] = (void*)&ctx.cpu_registers[i];
+    }
+    uregs[29] = UC_ARM64_REG_X29;
+    tregs[29] = (void*)&ctx.cpu_registers[29];
+    uregs[30] = UC_ARM64_REG_X30;
+    tregs[30] = (void*)&ctx.cpu_registers[30];
+
+    CHECKED(uc_reg_write_batch(uc, uregs, tregs, 31));
+
+    for (auto i = 0; i < 32; ++i) {
+        uregs[i] = UC_ARM64_REG_Q0 + i;
+        tregs[i] = (void*)&ctx.vector_registers[i];
+    }
+
+    CHECKED(uc_reg_write_batch(uc, uregs, tregs, 32));
+}
+
+void ARM_Unicorn::PrepareReschedule() {
+    CHECKED(uc_emu_stop(uc));
+}
+
+void ARM_Unicorn::ClearExclusiveState() {}
+
+void ARM_Unicorn::ClearInstructionCache() {}
+
+void ARM_Unicorn::RecordBreak(GDBStub::BreakpointAddress bkpt) {
+    last_bkpt = bkpt;
+    last_bkpt_hit = true;
+}
+
+void ARM_Unicorn::InterruptHook(uc_engine* uc, u32 int_no, void* user_data) {
+    u32 esr{};
+    CHECKED(uc_reg_read(uc, UC_ARM64_REG_ESR, &esr));
+
+    const auto ec = esr >> 26;
+    const auto iss = esr & 0xFFFFFF;
+
+    auto* const arm_instance = static_cast<ARM_Unicorn*>(user_data);
+
+    switch (ec) {
+    case 0x15: // SVC
+        Kernel::Svc::Call(arm_instance->system, iss);
+        break;
+    }
+}
+
+} // namespace Core

src/core/arm/unicorn/arm_unicorn.h

@@ -0,0 +1,63 @@
+// Copyright 2018 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+
+#include <unicorn/unicorn.h>
+#include "common/common_types.h"
+#include "core/arm/arm_interface.h"
+#include "core/gdbstub/gdbstub.h"
+
+namespace Core {
+
+class System;
+
+class ARM_Unicorn final : public ARM_Interface {
+public:
+    enum class Arch {
+        AArch32, // 32-bit ARM
+        AArch64, // 64-bit ARM
+    };
+
+    explicit ARM_Unicorn(System& system, CPUInterrupts& interrupt_handlers, bool uses_wall_clock,
+                         Arch architecture, std::size_t core_index);
+    ~ARM_Unicorn() override;
+
+    void SetPC(u64 pc) override;
+    u64 GetPC() const override;
+    u64 GetReg(int index) const override;
+    void SetReg(int index, u64 value) override;
+    u128 GetVectorReg(int index) const override;
+    void SetVectorReg(int index, u128 value) override;
+    u32 GetPSTATE() const override;
+    void SetPSTATE(u32 pstate) override;
+    VAddr GetTlsAddress() const override;
+    void SetTlsAddress(VAddr address) override;
+    void SetTPIDR_EL0(u64 value) override;
+    u64 GetTPIDR_EL0() const override;
+    void ChangeProcessorID(std::size_t new_core_id) override;
+    void PrepareReschedule() override;
+    void ClearExclusiveState() override;
+    void ExecuteInstructions(std::size_t num_instructions);
+    void Run() override;
+    void Step() override;
+    void ClearInstructionCache() override;
+    void PageTableChanged(Common::PageTable&, std::size_t) override {}
+    void RecordBreak(GDBStub::BreakpointAddress bkpt);
+
+    void SaveContext(ThreadContext32& ctx) override {}
+    void SaveContext(ThreadContext64& ctx) override;
+    void LoadContext(const ThreadContext32& ctx) override {}
+    void LoadContext(const ThreadContext64& ctx) override;
+
+private:
+    static void InterruptHook(uc_engine* uc, u32 int_no, void* user_data);
+
+    uc_engine* uc{};
+    GDBStub::BreakpointAddress last_bkpt{};
+    bool last_bkpt_hit = false;
+    std::size_t core_index;
+};
+
+} // namespace Core

src/core/core.cpp

@@ -40,7 +40,6 @@
 #include "core/hle/service/lm/manager.h"
 #include "core/hle/service/service.h"
 #include "core/hle/service/sm/sm.h"
-#include "core/hle/service/time/time_manager.h"
 #include "core/loader/loader.h"
 #include "core/memory.h"
 #include "core/memory/cheat_engine.h"
@@ -122,7 +121,7 @@ FileSys::VirtualFile GetGameFileFromPath(const FileSys::VirtualFilesystem& vfs,
 struct System::Impl {
     explicit Impl(System& system)
         : kernel{system}, fs_controller{system}, memory{system},
-          cpu_manager{system}, reporter{system}, applet_manager{system}, time_manager{system} {}
+          cpu_manager{system}, reporter{system}, applet_manager{system} {}
 
     ResultStatus Run() {
         status = ResultStatus::Success;
@@ -179,21 +178,16 @@ struct System::Impl {
         arp_manager.ResetAll();
 
         telemetry_session = std::make_unique<Core::TelemetrySession>();
-
-        gpu_core = VideoCore::CreateGPU(emu_window, system);
-        if (!gpu_core) {
-            return ResultStatus::ErrorVideoCore;
-        }
-
-        service_manager = std::make_shared<Service::SM::ServiceManager>(kernel);
+        service_manager = std::make_shared<Service::SM::ServiceManager>();
 
         Service::Init(service_manager, system);
         GDBStub::DeferStart();
 
         interrupt_manager = std::make_unique<Core::Hardware::InterruptManager>(system);
-
-        // Initialize time manager, which must happen after kernel is created
-        time_manager.Initialize();
+        gpu_core = VideoCore::CreateGPU(emu_window, system);
+        if (!gpu_core) {
+            return ResultStatus::ErrorVideoCore;
+        }
 
         is_powered_on = true;
         exit_lock = false;
@@ -227,7 +221,7 @@ struct System::Impl {
         telemetry_session->AddInitialInfo(*app_loader);
         auto main_process =
             Kernel::Process::Create(system, "main", Kernel::Process::ProcessType::Userland);
-        const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
+        const auto [load_result, load_parameters] = app_loader->Load(*main_process);
         if (load_result != Loader::ResultStatus::Success) {
             LOG_CRITICAL(Core, "Failed to load ROM (Error {})!", static_cast<int>(load_result));
             Shutdown();
@@ -393,7 +387,6 @@ struct System::Impl {
     /// Service State
     Service::Glue::ARPManager arp_manager;
     Service::LM::Manager lm_manager{reporter};
-    Service::Time::TimeManager time_manager;
 
     /// Service manager
     std::shared_ptr<Service::SM::ServiceManager> service_manager;
@@ -636,11 +629,11 @@ Loader::AppLoader& System::GetAppLoader() const {
     return *impl->app_loader;
 }
 
-void System::SetFilesystem(FileSys::VirtualFilesystem vfs) {
+void System::SetFilesystem(std::shared_ptr<FileSys::VfsFilesystem> vfs) {
     impl->virtual_filesystem = std::move(vfs);
 }
 
-FileSys::VirtualFilesystem System::GetFilesystem() const {
+std::shared_ptr<FileSys::VfsFilesystem> System::GetFilesystem() const {
     return impl->virtual_filesystem;
 }
 
@@ -724,14 +717,6 @@ const Service::LM::Manager& System::GetLogManager() const {
     return impl->lm_manager;
 }
 
-Service::Time::TimeManager& System::GetTimeManager() {
-    return impl->time_manager;
-}
-
-const Service::Time::TimeManager& System::GetTimeManager() const {
-    return impl->time_manager;
-}
-
 void System::SetExitLock(bool locked) {
     impl->exit_lock = locked;
 }

src/core/core.h

@@ -69,10 +69,6 @@ namespace SM {
 class ServiceManager;
 } // namespace SM
 
-namespace Time {
-class TimeManager;
-} // namespace Time
-
 } // namespace Service
 
 namespace Tegra {
@@ -124,7 +120,7 @@ public:
      * Gets the instance of the System singleton class.
      * @returns Reference to the instance of the System singleton class.
      */
-    [[deprecated("Use of the global system instance is deprecated")]] static System& GetInstance() {
+    static System& GetInstance() {
         return s_instance;
     }
 
@@ -320,9 +316,9 @@ public:
     Service::SM::ServiceManager& ServiceManager();
     const Service::SM::ServiceManager& ServiceManager() const;
 
-    void SetFilesystem(FileSys::VirtualFilesystem vfs);
+    void SetFilesystem(std::shared_ptr<FileSys::VfsFilesystem> vfs);
 
-    FileSys::VirtualFilesystem GetFilesystem() const;
+    std::shared_ptr<FileSys::VfsFilesystem> GetFilesystem() const;
 
     void RegisterCheatList(const std::vector<Memory::CheatEntry>& list,
                            const std::array<u8, 0x20>& build_id, VAddr main_region_begin,
@@ -365,10 +361,6 @@ public:
 
     const Service::LM::Manager& GetLogManager() const;
 
-    Service::Time::TimeManager& GetTimeManager();
-
-    const Service::Time::TimeManager& GetTimeManager() const;
-
     void SetExitLock(bool locked);
 
     bool GetExitLock() const;

src/core/cpu_manager.cpp

@@ -365,8 +365,6 @@ void CpuManager::RunThread(std::size_t core) {
     data.enter_barrier.reset();
     data.exit_barrier.reset();
     data.initialized = false;
-
-    MicroProfileOnThreadExit();
 }
 
 } // namespace Core

src/core/crypto/key_manager.cpp

@@ -23,6 +23,7 @@
 #include "common/hex_util.h"
 #include "common/logging/log.h"
 #include "common/string_util.h"
+#include "core/core.h"
 #include "core/crypto/aes_util.h"
 #include "core/crypto/key_manager.h"
 #include "core/crypto/partition_data_manager.h"
@@ -411,7 +412,7 @@ Loader::ResultStatus DeriveSDKeys(std::array<Key256, 2>& sd_keys, KeyManager& ke
     // Combine sources and seed
     for (auto& source : sd_key_sources) {
         for (std::size_t i = 0; i < source.size(); ++i) {
-            source[i] = static_cast<u8>(source[i] ^ sd_seed[i & 0xF]);
+            source[i] ^= sd_seed[i & 0xF];
         }
     }
 
@@ -1021,10 +1022,10 @@ void KeyManager::DeriveBase() {
     }
 }
 
-void KeyManager::DeriveETicket(PartitionDataManager& data,
-                               const FileSys::ContentProvider& provider) {
+void KeyManager::DeriveETicket(PartitionDataManager& data) {
     // ETicket keys
-    const auto es = provider.GetEntry(0x0100000000000033, FileSys::ContentRecordType::Program);
+    const auto es = Core::System::GetInstance().GetContentProvider().GetEntry(
+        0x0100000000000033, FileSys::ContentRecordType::Program);
 
     if (es == nullptr) {
         return;

src/core/crypto/key_manager.h

@@ -20,10 +20,6 @@ namespace Common::FS {
 class IOFile;
 }
 
-namespace FileSys {
-class ContentProvider;
-}
-
 namespace Loader {
 enum class ResultStatus : u16;
 }
@@ -256,7 +252,7 @@ public:
 
     bool BaseDeriveNecessary() const;
     void DeriveBase();
-    void DeriveETicket(PartitionDataManager& data, const FileSys::ContentProvider& provider);
+    void DeriveETicket(PartitionDataManager& data);
     void PopulateTickets();
     void SynthesizeTickets();
 

src/core/file_sys/bis_factory.cpp

@@ -4,10 +4,10 @@
 
 #include <fmt/format.h>
 #include "common/file_util.h"
+#include "core/core.h"
 #include "core/file_sys/bis_factory.h"
 #include "core/file_sys/mode.h"
 #include "core/file_sys/registered_cache.h"
-#include "core/file_sys/vfs.h"
 
 namespace FileSys {
 
@@ -81,11 +81,11 @@ VirtualDir BISFactory::OpenPartition(BisPartitionId id) const {
     }
 }
 
-VirtualFile BISFactory::OpenPartitionStorage(BisPartitionId id,
-                                             VirtualFilesystem file_system) const {
+VirtualFile BISFactory::OpenPartitionStorage(BisPartitionId id) const {
     auto& keys = Core::Crypto::KeyManager::Instance();
-    Core::Crypto::PartitionDataManager pdm{file_system->OpenDirectory(
-        Common::FS::GetUserPath(Common::FS::UserPath::SysDataDir), Mode::Read)};
+    Core::Crypto::PartitionDataManager pdm{
+        Core::System::GetInstance().GetFilesystem()->OpenDirectory(
+            Common::FS::GetUserPath(Common::FS::UserPath::SysDataDir), Mode::Read)};
     keys.PopulateFromPartitionData(pdm);
 
     switch (id) {

src/core/file_sys/bis_factory.h

@@ -52,7 +52,7 @@ public:
     VirtualDir GetModificationDumpRoot(u64 title_id) const;
 
     VirtualDir OpenPartition(BisPartitionId id) const;
-    VirtualFile OpenPartitionStorage(BisPartitionId id, VirtualFilesystem file_system) const;
+    VirtualFile OpenPartitionStorage(BisPartitionId id) const;
 
     VirtualDir GetImageDirectory() const;
 

src/core/file_sys/content_archive.cpp

@@ -323,7 +323,7 @@ bool NCA::ReadRomFSSection(const NCASectionHeader& section, const NCASectionTabl
         subsection_buckets.back().entries.push_back({section.bktr.relocation.offset, {0}, ctr_low});
         subsection_buckets.back().entries.push_back({size, {0}, 0});
 
-        std::optional<Core::Crypto::Key128> key;
+        std::optional<Core::Crypto::Key128> key = {};
         if (encrypted) {
             if (has_rights_id) {
                 status = Loader::ResultStatus::Success;
@@ -442,18 +442,18 @@ std::optional<Core::Crypto::Key128> NCA::GetTitlekey() {
     memcpy(rights_id.data(), header.rights_id.data(), 16);
     if (rights_id == u128{}) {
         status = Loader::ResultStatus::ErrorInvalidRightsID;
-        return std::nullopt;
+        return {};
     }
 
     auto titlekey = keys.GetKey(Core::Crypto::S128KeyType::Titlekey, rights_id[1], rights_id[0]);
     if (titlekey == Core::Crypto::Key128{}) {
         status = Loader::ResultStatus::ErrorMissingTitlekey;
-        return std::nullopt;
+        return {};
     }
 
     if (!keys.HasKey(Core::Crypto::S128KeyType::Titlekek, master_key_id)) {
         status = Loader::ResultStatus::ErrorMissingTitlekek;
-        return std::nullopt;
+        return {};
     }
 
     Core::Crypto::AESCipher<Core::Crypto::Key128> cipher(
@@ -477,7 +477,7 @@ VirtualFile NCA::Decrypt(const NCASectionHeader& s_header, VirtualFile in, u64 s
     case NCASectionCryptoType::BKTR:
         LOG_TRACE(Crypto, "called with mode=CTR, starting_offset={:016X}", starting_offset);
         {
-            std::optional<Core::Crypto::Key128> key;
+            std::optional<Core::Crypto::Key128> key = {};
             if (has_rights_id) {
                 status = Loader::ResultStatus::Success;
                 key = GetTitlekey();

src/core/file_sys/control_metadata.h

@@ -83,7 +83,7 @@ enum class Language : u8 {
     Italian = 7,
     Dutch = 8,
     CanadianFrench = 9,
-    Portuguese = 10,
+    Portugese = 10,
     Russian = 11,
     Korean = 12,
     Taiwanese = 13,

src/core/file_sys/fsmitm_romfsbuild.cpp

@@ -266,9 +266,8 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() {
         cur_file->offset = file_partition_size;
         file_partition_size += cur_file->size;
         cur_file->entry_offset = entry_offset;
-        entry_offset +=
-            static_cast<u32>(sizeof(RomFSFileEntry) +
-                             Common::AlignUp(cur_file->path_len - cur_file->cur_path_ofs, 4));
+        entry_offset += sizeof(RomFSFileEntry) +
+                        Common::AlignUp(cur_file->path_len - cur_file->cur_path_ofs, 4);
         prev_file = cur_file;
     }
     // Assign deferred parent/sibling ownership.
@@ -285,9 +284,8 @@ std::multimap<u64, VirtualFile> RomFSBuildContext::Build() {
     for (const auto& it : directories) {
         cur_dir = it.second;
         cur_dir->entry_offset = entry_offset;
-        entry_offset +=
-            static_cast<u32>(sizeof(RomFSDirectoryEntry) +
-                             Common::AlignUp(cur_dir->path_len - cur_dir->cur_path_ofs, 4));
+        entry_offset += sizeof(RomFSDirectoryEntry) +
+                        Common::AlignUp(cur_dir->path_len - cur_dir->cur_path_ofs, 4);
     }
     // Assign deferred parent/sibling ownership.
     for (auto it = directories.rbegin(); it->second != root; ++it) {

src/core/file_sys/ips_layer.cpp

@@ -245,11 +245,9 @@ void IPSwitchCompiler::Parse() {
 
             // Read rest of patch
             while (true) {
-                if (i + 1 >= lines.size()) {
+                if (i + 1 >= lines.size())
                     break;
-                }
-
-                const auto& patch_line = lines[++i];
+                const auto patch_line = lines[++i];
 
                 // Start of new patch
                 if (StartsWith(patch_line, "@enabled") || StartsWith(patch_line, "@disabled")) {
@@ -299,7 +297,7 @@ void IPSwitchCompiler::Parse() {
                              patch_text->GetName(), offset, Common::HexToString(replace));
                 }
 
-                patch.records.insert_or_assign(static_cast<u32>(offset), std::move(replace));
+                patch.records.insert_or_assign(offset, std::move(replace));
             }
 
             patches.push_back(std::move(patch));

src/core/file_sys/nca_metadata.cpp

@@ -108,7 +108,7 @@ std::vector<u8> CNMT::Serialize() const {
         memcpy(out.data() + sizeof(CNMTHeader), &opt_header, sizeof(OptionalHeader));
     }
 
-    u64_le offset = header.table_offset;
+    auto offset = header.table_offset;
 
     for (const auto& rec : content_records) {
         memcpy(out.data() + offset + sizeof(CNMTHeader), &rec, sizeof(ContentRecord));

src/core/file_sys/nca_patch.cpp

@@ -12,49 +12,6 @@
 #include "core/file_sys/nca_patch.h"
 
 namespace FileSys {
-namespace {
-template <bool Subsection, typename BlockType, typename BucketType>
-std::pair<std::size_t, std::size_t> SearchBucketEntry(u64 offset, const BlockType& block,
-                                                      const BucketType& buckets) {
-    if constexpr (Subsection) {
-        const auto& last_bucket = buckets[block.number_buckets - 1];
-        if (offset >= last_bucket.entries[last_bucket.number_entries].address_patch) {
-            return {block.number_buckets - 1, last_bucket.number_entries};
-        }
-    } else {
-        ASSERT_MSG(offset <= block.size, "Offset is out of bounds in BKTR relocation block.");
-    }
-
-    std::size_t bucket_id = std::count_if(
-        block.base_offsets.begin() + 1, block.base_offsets.begin() + block.number_buckets,
-        [&offset](u64 base_offset) { return base_offset <= offset; });
-
-    const auto& bucket = buckets[bucket_id];
-
-    if (bucket.number_entries == 1) {
-        return {bucket_id, 0};
-    }
-
-    std::size_t low = 0;
-    std::size_t mid = 0;
-    std::size_t high = bucket.number_entries - 1;
-    while (low <= high) {
-        mid = (low + high) / 2;
-        if (bucket.entries[mid].address_patch > offset) {
-            high = mid - 1;
-        } else {
-            if (mid == bucket.number_entries - 1 ||
-                bucket.entries[mid + 1].address_patch > offset) {
-                return {bucket_id, mid};
-            }
-
-            low = mid + 1;
-        }
-    }
-
-    UNREACHABLE_MSG("Offset could not be found in BKTR block.");
-}
-} // Anonymous namespace
 
 BKTR::BKTR(VirtualFile base_romfs_, VirtualFile bktr_romfs_, RelocationBlock relocation_,
            std::vector<RelocationBucket> relocation_buckets_, SubsectionBlock subsection_,
@@ -153,6 +110,46 @@ std::size_t BKTR::Read(u8* data, std::size_t length, std::size_t offset) const {
     return raw_read;
 }
 
+template <bool Subsection, typename BlockType, typename BucketType>
+std::pair<std::size_t, std::size_t> BKTR::SearchBucketEntry(u64 offset, BlockType block,
+                                                            BucketType buckets) const {
+    if constexpr (Subsection) {
+        const auto last_bucket = buckets[block.number_buckets - 1];
+        if (offset >= last_bucket.entries[last_bucket.number_entries].address_patch)
+            return {block.number_buckets - 1, last_bucket.number_entries};
+    } else {
+        ASSERT_MSG(offset <= block.size, "Offset is out of bounds in BKTR relocation block.");
+    }
+
+    std::size_t bucket_id = std::count_if(
+        block.base_offsets.begin() + 1, block.base_offsets.begin() + block.number_buckets,
+        [&offset](u64 base_offset) { return base_offset <= offset; });
+
+    const auto bucket = buckets[bucket_id];
+
+    if (bucket.number_entries == 1)
+        return {bucket_id, 0};
+
+    std::size_t low = 0;
+    std::size_t mid = 0;
+    std::size_t high = bucket.number_entries - 1;
+    while (low <= high) {
+        mid = (low + high) / 2;
+        if (bucket.entries[mid].address_patch > offset) {
+            high = mid - 1;
+        } else {
+            if (mid == bucket.number_entries - 1 ||
+                bucket.entries[mid + 1].address_patch > offset) {
+                return {bucket_id, mid};
+            }
+
+            low = mid + 1;
+        }
+    }
+
+    UNREACHABLE_MSG("Offset could not be found in BKTR block.");
+}
+
 RelocationEntry BKTR::GetRelocationEntry(u64 offset) const {
     const auto res = SearchBucketEntry<false>(offset, relocation, relocation_buckets);
     return relocation_buckets[res.first].entries[res.second];

src/core/file_sys/nca_patch.h

@@ -117,6 +117,10 @@ public:
     bool Rename(std::string_view name) override;
 
 private:
+    template <bool Subsection, typename BlockType, typename BucketType>
+    std::pair<std::size_t, std::size_t> SearchBucketEntry(u64 offset, BlockType block,
+                                                          BucketType buckets) const;
+
     RelocationEntry GetRelocationEntry(u64 offset) const;
     RelocationEntry GetNextRelocationEntry(u64 offset) const;
 

src/core/file_sys/patch_manager.cpp

@@ -27,9 +27,8 @@
 #include "core/settings.h"
 
 namespace FileSys {
-namespace {
 
-constexpr u32 SINGLE_BYTE_MODULUS = 0x100;
+constexpr u64 SINGLE_BYTE_MODULUS = 0x100;
 constexpr u64 DLC_BASE_TITLE_ID_MASK = 0xFFFFFFFFFFFFE000;
 
 constexpr std::array<const char*, 14> EXEFS_FILE_NAMES{
@@ -37,28 +36,19 @@ constexpr std::array<const char*, 14> EXEFS_FILE_NAMES{
     "subsdk3", "subsdk4",   "subsdk5", "subsdk6", "subsdk7", "subsdk8", "subsdk9",
 };
 
-enum class TitleVersionFormat : u8 {
-    ThreeElements, ///< vX.Y.Z
-    FourElements,  ///< vX.Y.Z.W
-};
-
-std::string FormatTitleVersion(u32 version,
-                               TitleVersionFormat format = TitleVersionFormat::ThreeElements) {
+std::string FormatTitleVersion(u32 version, TitleVersionFormat format) {
     std::array<u8, sizeof(u32)> bytes{};
-    bytes[0] = static_cast<u8>(version % SINGLE_BYTE_MODULUS);
+    bytes[0] = version % SINGLE_BYTE_MODULUS;
     for (std::size_t i = 1; i < bytes.size(); ++i) {
         version /= SINGLE_BYTE_MODULUS;
-        bytes[i] = static_cast<u8>(version % SINGLE_BYTE_MODULUS);
+        bytes[i] = version % SINGLE_BYTE_MODULUS;
     }
 
-    if (format == TitleVersionFormat::FourElements) {
+    if (format == TitleVersionFormat::FourElements)
         return fmt::format("v{}.{}.{}.{}", bytes[3], bytes[2], bytes[1], bytes[0]);
-    }
     return fmt::format("v{}.{}.{}", bytes[3], bytes[2], bytes[1]);
 }
 
-// Returns a directory with name matching name case-insensitive. Returns nullptr if directory
-// doesn't have a directory with name.
 VirtualDir FindSubdirectoryCaseless(const VirtualDir dir, std::string_view name) {
 #ifdef _WIN32
     return dir->GetSubdirectory(name);
@@ -75,43 +65,6 @@ VirtualDir FindSubdirectoryCaseless(const VirtualDir dir, std::string_view name)
 #endif
 }
 
-std::optional<std::vector<Core::Memory::CheatEntry>> ReadCheatFileFromFolder(
-    u64 title_id, const PatchManager::BuildID& build_id_, const VirtualDir& base_path, bool upper) {
-    const auto build_id_raw = Common::HexToString(build_id_, upper);
-    const auto build_id = build_id_raw.substr(0, sizeof(u64) * 2);
-    const auto file = base_path->GetFile(fmt::format("{}.txt", build_id));
-
-    if (file == nullptr) {
-        LOG_INFO(Common_Filesystem, "No cheats file found for title_id={:016X}, build_id={}",
-                 title_id, build_id);
-        return std::nullopt;
-    }
-
-    std::vector<u8> data(file->GetSize());
-    if (file->Read(data.data(), data.size()) != data.size()) {
-        LOG_INFO(Common_Filesystem, "Failed to read cheats file for title_id={:016X}, build_id={}",
-                 title_id, build_id);
-        return std::nullopt;
-    }
-
-    const Core::Memory::TextCheatParser parser;
-    return parser.Parse(std::string_view(reinterpret_cast<const char*>(data.data()), data.size()));
-}
-
-void AppendCommaIfNotEmpty(std::string& to, std::string_view with) {
-    if (to.empty()) {
-        to += with;
-    } else {
-        to += ", ";
-        to += with;
-    }
-}
-
-bool IsDirValidAndNonEmpty(const VirtualDir& dir) {
-    return dir != nullptr && (!dir->GetFiles().empty() || !dir->GetSubdirectories().empty());
-}
-} // Anonymous namespace
-
 PatchManager::PatchManager(u64 title_id) : title_id(title_id) {}
 
 PatchManager::~PatchManager() = default;
@@ -292,7 +245,7 @@ std::vector<u8> PatchManager::PatchNSO(const std::vector<u8>& nso, const std::st
     return out;
 }
 
-bool PatchManager::HasNSOPatch(const BuildID& build_id_) const {
+bool PatchManager::HasNSOPatch(const std::array<u8, 32>& build_id_) const {
     const auto build_id_raw = Common::HexToString(build_id_);
     const auto build_id = build_id_raw.substr(0, build_id_raw.find_last_not_of('0') + 1);
 
@@ -312,8 +265,36 @@ bool PatchManager::HasNSOPatch(const BuildID& build_id_) const {
     return !CollectPatches(patch_dirs, build_id).empty();
 }
 
+namespace {
+std::optional<std::vector<Core::Memory::CheatEntry>> ReadCheatFileFromFolder(
+    const Core::System& system, u64 title_id, const std::array<u8, 0x20>& build_id_,
+    const VirtualDir& base_path, bool upper) {
+    const auto build_id_raw = Common::HexToString(build_id_, upper);
+    const auto build_id = build_id_raw.substr(0, sizeof(u64) * 2);
+    const auto file = base_path->GetFile(fmt::format("{}.txt", build_id));
+
+    if (file == nullptr) {
+        LOG_INFO(Common_Filesystem, "No cheats file found for title_id={:016X}, build_id={}",
+                 title_id, build_id);
+        return std::nullopt;
+    }
+
+    std::vector<u8> data(file->GetSize());
+    if (file->Read(data.data(), data.size()) != data.size()) {
+        LOG_INFO(Common_Filesystem, "Failed to read cheats file for title_id={:016X}, build_id={}",
+                 title_id, build_id);
+        return std::nullopt;
+    }
+
+    Core::Memory::TextCheatParser parser;
+    return parser.Parse(system,
+                        std::string_view(reinterpret_cast<const char*>(data.data()), data.size()));
+}
+
+} // Anonymous namespace
+
 std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
-    const Core::System& system, const BuildID& build_id_) const {
+    const Core::System& system, const std::array<u8, 32>& build_id_) const {
     const auto load_dir = system.GetFileSystemController().GetModificationLoadRoot(title_id);
     if (load_dir == nullptr) {
         LOG_ERROR(Loader, "Cannot load mods for invalid title_id={:016X}", title_id);
@@ -333,12 +314,14 @@ std::vector<Core::Memory::CheatEntry> PatchManager::CreateCheatList(
 
         auto cheats_dir = FindSubdirectoryCaseless(subdir, "cheats");
         if (cheats_dir != nullptr) {
-            if (const auto res = ReadCheatFileFromFolder(title_id, build_id_, cheats_dir, true)) {
+            auto res = ReadCheatFileFromFolder(system, title_id, build_id_, cheats_dir, true);
+            if (res.has_value()) {
                 std::copy(res->begin(), res->end(), std::back_inserter(out));
                 continue;
             }
 
-            if (const auto res = ReadCheatFileFromFolder(title_id, build_id_, cheats_dir, false)) {
+            res = ReadCheatFileFromFolder(system, title_id, build_id_, cheats_dir, false);
+            if (res.has_value()) {
                 std::copy(res->begin(), res->end(), std::back_inserter(out));
             }
         }
@@ -452,11 +435,21 @@ VirtualFile PatchManager::PatchRomFS(VirtualFile romfs, u64 ivfc_offset, Content
     return romfs;
 }
 
-PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile update_raw) const {
-    if (title_id == 0) {
-        return {};
-    }
+static void AppendCommaIfNotEmpty(std::string& to, const std::string& with) {
+    if (to.empty())
+        to += with;
+    else
+        to += ", " + with;
+}
 
+static bool IsDirValidAndNonEmpty(const VirtualDir& dir) {
+    return dir != nullptr && (!dir->GetFiles().empty() || !dir->GetSubdirectories().empty());
+}
+
+std::map<std::string, std::string, std::less<>> PatchManager::GetPatchVersionNames(
+    VirtualFile update_raw) const {
+    if (title_id == 0)
+        return {};
     std::map<std::string, std::string, std::less<>> out;
     const auto& installed = Core::System::GetInstance().GetContentProvider();
     const auto& disabled = Settings::values.disabled_addons[title_id];
@@ -479,7 +472,8 @@ PatchManager::PatchVersionNames PatchManager::GetPatchVersionNames(VirtualFile u
             if (meta_ver.value_or(0) == 0) {
                 out.insert_or_assign(update_label, "");
             } else {
-                out.insert_or_assign(update_label, FormatTitleVersion(*meta_ver));
+                out.insert_or_assign(
+                    update_label, FormatTitleVersion(*meta_ver, TitleVersionFormat::ThreeElements));
             }
         } else if (update_raw != nullptr) {
             out.insert_or_assign(update_label, "PACKED");
@@ -568,46 +562,40 @@ std::optional<u32> PatchManager::GetGameVersion() const {
     return installed.GetEntryVersion(title_id);
 }
 
-PatchManager::Metadata PatchManager::GetControlMetadata() const {
+std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::GetControlMetadata() const {
     const auto& installed = Core::System::GetInstance().GetContentProvider();
 
     const auto base_control_nca = installed.GetEntry(title_id, ContentRecordType::Control);
-    if (base_control_nca == nullptr) {
+    if (base_control_nca == nullptr)
         return {};
-    }
 
     return ParseControlNCA(*base_control_nca);
 }
 
-PatchManager::Metadata PatchManager::ParseControlNCA(const NCA& nca) const {
+std::pair<std::unique_ptr<NACP>, VirtualFile> PatchManager::ParseControlNCA(const NCA& nca) const {
     const auto base_romfs = nca.GetRomFS();
-    if (base_romfs == nullptr) {
+    if (base_romfs == nullptr)
         return {};
-    }
 
     const auto romfs = PatchRomFS(base_romfs, nca.GetBaseIVFCOffset(), ContentRecordType::Control);
-    if (romfs == nullptr) {
+    if (romfs == nullptr)
         return {};
-    }
 
     const auto extracted = ExtractRomFS(romfs);
-    if (extracted == nullptr) {
+    if (extracted == nullptr)
         return {};
-    }
 
     auto nacp_file = extracted->GetFile("control.nacp");
-    if (nacp_file == nullptr) {
+    if (nacp_file == nullptr)
         nacp_file = extracted->GetFile("Control.nacp");
-    }
 
     auto nacp = nacp_file == nullptr ? nullptr : std::make_unique<NACP>(nacp_file);
 
     VirtualFile icon_file;
     for (const auto& language : FileSys::LANGUAGE_NAMES) {
-        icon_file = extracted->GetFile(std::string("icon_").append(language).append(".dat"));
-        if (icon_file != nullptr) {
+        icon_file = extracted->GetFile("icon_" + std::string(language) + ".dat");
+        if (icon_file != nullptr)
             break;
-        }
     }
 
     return {std::move(nacp), icon_file};

src/core/file_sys/patch_manager.h

@@ -22,62 +22,70 @@ namespace FileSys {
 class NCA;
 class NACP;
 
+enum class TitleVersionFormat : u8 {
+    ThreeElements, ///< vX.Y.Z
+    FourElements,  ///< vX.Y.Z.W
+};
+
+std::string FormatTitleVersion(u32 version,
+                               TitleVersionFormat format = TitleVersionFormat::ThreeElements);
+
+// Returns a directory with name matching name case-insensitive. Returns nullptr if directory
+// doesn't have a directory with name.
+VirtualDir FindSubdirectoryCaseless(VirtualDir dir, std::string_view name);
+
 // A centralized class to manage patches to games.
 class PatchManager {
 public:
-    using BuildID = std::array<u8, 0x20>;
-    using Metadata = std::pair<std::unique_ptr<NACP>, VirtualFile>;
-    using PatchVersionNames = std::map<std::string, std::string, std::less<>>;
-
     explicit PatchManager(u64 title_id);
     ~PatchManager();
 
-    [[nodiscard]] u64 GetTitleID() const;
+    u64 GetTitleID() const;
 
     // Currently tracked ExeFS patches:
     // - Game Updates
-    [[nodiscard]] VirtualDir PatchExeFS(VirtualDir exefs) const;
+    VirtualDir PatchExeFS(VirtualDir exefs) const;
 
     // Currently tracked NSO patches:
     // - IPS
     // - IPSwitch
-    [[nodiscard]] std::vector<u8> PatchNSO(const std::vector<u8>& nso,
-                                           const std::string& name) const;
+    std::vector<u8> PatchNSO(const std::vector<u8>& nso, const std::string& name) const;
 
     // Checks to see if PatchNSO() will have any effect given the NSO's build ID.
     // Used to prevent expensive copies in NSO loader.
-    [[nodiscard]] bool HasNSOPatch(const BuildID& build_id) const;
+    bool HasNSOPatch(const std::array<u8, 0x20>& build_id) const;
 
     // Creates a CheatList object with all
-    [[nodiscard]] std::vector<Core::Memory::CheatEntry> CreateCheatList(
-        const Core::System& system, const BuildID& build_id) const;
+    std::vector<Core::Memory::CheatEntry> CreateCheatList(
+        const Core::System& system, const std::array<u8, 0x20>& build_id) const;
 
     // Currently tracked RomFS patches:
     // - Game Updates
     // - LayeredFS
-    [[nodiscard]] VirtualFile PatchRomFS(VirtualFile base, u64 ivfc_offset,
-                                         ContentRecordType type = ContentRecordType::Program,
-                                         VirtualFile update_raw = nullptr) const;
+    VirtualFile PatchRomFS(VirtualFile base, u64 ivfc_offset,
+                           ContentRecordType type = ContentRecordType::Program,
+                           VirtualFile update_raw = nullptr) const;
 
     // Returns a vector of pairs between patch names and patch versions.
     // i.e. Update 3.2.2 will return {"Update", "3.2.2"}
-    [[nodiscard]] PatchVersionNames GetPatchVersionNames(VirtualFile update_raw = nullptr) const;
+    std::map<std::string, std::string, std::less<>> GetPatchVersionNames(
+        VirtualFile update_raw = nullptr) const;
 
     // If the game update exists, returns the u32 version field in its Meta-type NCA. If that fails,
     // it will fallback to the Meta-type NCA of the base game. If that fails, the result will be
     // std::nullopt
-    [[nodiscard]] std::optional<u32> GetGameVersion() const;
+    std::optional<u32> GetGameVersion() const;
 
     // Given title_id of the program, attempts to get the control data of the update and parse
     // it, falling back to the base control data.
-    [[nodiscard]] Metadata GetControlMetadata() const;
+    std::pair<std::unique_ptr<NACP>, VirtualFile> GetControlMetadata() const;
 
     // Version of GetControlMetadata that takes an arbitrary NCA
-    [[nodiscard]] Metadata ParseControlNCA(const NCA& nca) const;
+    std::pair<std::unique_ptr<NACP>, VirtualFile> ParseControlNCA(const NCA& nca) const;
 
 private:
-    [[nodiscard]] std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
-                                                          const std::string& build_id) const;
+    std::vector<VirtualFile> CollectPatches(const std::vector<VirtualDir>& patch_dirs,
+                                            const std::string& build_id) const;
 
     u64 title_id;
 };

src/core/file_sys/romfs_factory.cpp

@@ -6,6 +6,7 @@
 #include "common/assert.h"
 #include "common/common_types.h"
 #include "common/logging/log.h"
+#include "core/core.h"
 #include "core/file_sys/card_image.h"
 #include "core/file_sys/content_archive.h"
 #include "core/file_sys/nca_metadata.h"
@@ -18,9 +19,7 @@
 
 namespace FileSys {
 
-RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader, ContentProvider& provider,
-                           Service::FileSystem::FileSystemController& controller)
-    : content_provider{provider}, filesystem_controller{controller} {
+RomFSFactory::RomFSFactory(Loader::AppLoader& app_loader) {
     // Load the RomFS from the app
     if (app_loader.ReadRomFS(file) != Loader::ResultStatus::Success) {
         LOG_ERROR(Service_FS, "Unable to read RomFS!");
@@ -47,38 +46,39 @@ ResultVal<VirtualFile> RomFSFactory::OpenCurrentProcess(u64 current_process_titl
 
 ResultVal<VirtualFile> RomFSFactory::Open(u64 title_id, StorageId storage,
                                           ContentRecordType type) const {
-    const std::shared_ptr<NCA> res = GetEntry(title_id, storage, type);
+    std::shared_ptr<NCA> res;
+
+    switch (storage) {
+    case StorageId::None:
+        res = Core::System::GetInstance().GetContentProvider().GetEntry(title_id, type);
+        break;
+    case StorageId::NandSystem:
+        res =
+            Core::System::GetInstance().GetFileSystemController().GetSystemNANDContents()->GetEntry(
+                title_id, type);
+        break;
+    case StorageId::NandUser:
+        res = Core::System::GetInstance().GetFileSystemController().GetUserNANDContents()->GetEntry(
+            title_id, type);
+        break;
+    case StorageId::SdCard:
+        res = Core::System::GetInstance().GetFileSystemController().GetSDMCContents()->GetEntry(
+            title_id, type);
+        break;
+    default:
+        UNIMPLEMENTED_MSG("Unimplemented storage_id={:02X}", static_cast<u8>(storage));
+    }
+
     if (res == nullptr) {
         // TODO(DarkLordZach): Find the right error code to use here
         return RESULT_UNKNOWN;
     }
-
     const auto romfs = res->GetRomFS();
     if (romfs == nullptr) {
         // TODO(DarkLordZach): Find the right error code to use here
         return RESULT_UNKNOWN;
     }
-
     return MakeResult<VirtualFile>(romfs);
 }
 
-std::shared_ptr<NCA> RomFSFactory::GetEntry(u64 title_id, StorageId storage,
-                                            ContentRecordType type) const {
-    switch (storage) {
-    case StorageId::None:
-        return content_provider.GetEntry(title_id, type);
-    case StorageId::NandSystem:
-        return filesystem_controller.GetSystemNANDContents()->GetEntry(title_id, type);
-    case StorageId::NandUser:
-        return filesystem_controller.GetUserNANDContents()->GetEntry(title_id, type);
-    case StorageId::SdCard:
-        return filesystem_controller.GetSDMCContents()->GetEntry(title_id, type);
-    case StorageId::Host:
-    case StorageId::GameCard:
-    default:
-        UNIMPLEMENTED_MSG("Unimplemented storage_id={:02X}", static_cast<u8>(storage));
-        return nullptr;
-    }
-}
-
 } // namespace FileSys

src/core/file_sys/romfs_factory.h

@@ -13,15 +13,8 @@ namespace Loader {
 class AppLoader;
 } // namespace Loader
 
-namespace Service::FileSystem {
-class FileSystemController;
-}
-
 namespace FileSys {
 
-class ContentProvider;
-class NCA;
-
 enum class ContentRecordType : u8;
 
 enum class StorageId : u8 {
@@ -36,26 +29,18 @@ enum class StorageId : u8 {
 /// File system interface to the RomFS archive
 class RomFSFactory {
 public:
-    explicit RomFSFactory(Loader::AppLoader& app_loader, ContentProvider& provider,
-                          Service::FileSystem::FileSystemController& controller);
+    explicit RomFSFactory(Loader::AppLoader& app_loader);
     ~RomFSFactory();
 
     void SetPackedUpdate(VirtualFile update_raw);
-    [[nodiscard]] ResultVal<VirtualFile> OpenCurrentProcess(u64 current_process_title_id) const;
-    [[nodiscard]] ResultVal<VirtualFile> Open(u64 title_id, StorageId storage,
-                                              ContentRecordType type) const;
+    ResultVal<VirtualFile> OpenCurrentProcess(u64 current_process_title_id) const;
+    ResultVal<VirtualFile> Open(u64 title_id, StorageId storage, ContentRecordType type) const;
 
 private:
-    [[nodiscard]] std::shared_ptr<NCA> GetEntry(u64 title_id, StorageId storage,
-                                                ContentRecordType type) const;
-
     VirtualFile file;
     VirtualFile update_raw;
     bool updatable;
     u64 ivfc_offset;
-
-    ContentProvider& content_provider;
-    Service::FileSystem::FileSystemController& filesystem_controller;
 };
 
 } // namespace FileSys

src/core/file_sys/submission_package.cpp

@@ -19,6 +19,38 @@
 #include "core/loader/loader.h"
 
 namespace FileSys {
+namespace {
+void SetTicketKeys(const std::vector<VirtualFile>& files) {
+    auto& keys = Core::Crypto::KeyManager::Instance();
+
+    for (const auto& ticket_file : files) {
+        if (ticket_file == nullptr) {
+            continue;
+        }
+
+        if (ticket_file->GetExtension() != "tik") {
+            continue;
+        }
+
+        if (ticket_file->GetSize() <
+            Core::Crypto::TICKET_FILE_TITLEKEY_OFFSET + sizeof(Core::Crypto::Key128)) {
+            continue;
+        }
+
+        Core::Crypto::Key128 key{};
+        ticket_file->Read(key.data(), key.size(), Core::Crypto::TICKET_FILE_TITLEKEY_OFFSET);
+
+        // We get the name without the extension in order to create the rights ID.
+        std::string name_only(ticket_file->GetName());
+        name_only.erase(name_only.size() - 4);
+
+        const auto rights_id_raw = Common::HexStringToArray<16>(name_only);
+        u128 rights_id;
+        std::memcpy(rights_id.data(), rights_id_raw.data(), sizeof(u128));
+        keys.SetKey(Core::Crypto::S128KeyType::Titlekey, key, rights_id[1], rights_id[0]);
+    }
+}
+} // Anonymous namespace
 
 NSP::NSP(VirtualFile file_)
     : file(std::move(file_)), status{Loader::ResultStatus::Success},
@@ -200,35 +232,6 @@ VirtualDir NSP::GetParentDirectory() const {
     return file->GetContainingDirectory();
 }
 
-void NSP::SetTicketKeys(const std::vector<VirtualFile>& files) {
-    for (const auto& ticket_file : files) {
-        if (ticket_file == nullptr) {
-            continue;
-        }
-
-        if (ticket_file->GetExtension() != "tik") {
-            continue;
-        }
-
-        if (ticket_file->GetSize() <
-            Core::Crypto::TICKET_FILE_TITLEKEY_OFFSET + sizeof(Core::Crypto::Key128)) {
-            continue;
-        }
-
-        Core::Crypto::Key128 key{};
-        ticket_file->Read(key.data(), key.size(), Core::Crypto::TICKET_FILE_TITLEKEY_OFFSET);
-
-        // We get the name without the extension in order to create the rights ID.
-        std::string name_only(ticket_file->GetName());
-        name_only.erase(name_only.size() - 4);
-
-        const auto rights_id_raw = Common::HexStringToArray<16>(name_only);
-        u128 rights_id;
-        std::memcpy(rights_id.data(), rights_id_raw.data(), sizeof(u128));
-        keys.SetKey(Core::Crypto::S128KeyType::Titlekey, key, rights_id[1], rights_id[0]);
-    }
-}
-
 void NSP::InitializeExeFSAndRomFS(const std::vector<VirtualFile>& files) {
     exefs = pfs;
 
@@ -264,9 +267,9 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
             }
 
             const CNMT cnmt(inner_file);
+            auto& ncas_title = ncas[cnmt.GetTitleID()];
 
-            ncas[cnmt.GetTitleID()][{cnmt.GetType(), ContentRecordType::Meta}] = nca;
-
+            ncas_title[{cnmt.GetType(), ContentRecordType::Meta}] = nca;
             for (const auto& rec : cnmt.GetContentRecords()) {
                 const auto id_string = Common::HexToString(rec.nca_id, false);
                 auto next_file = pfs->GetFile(fmt::format("{}.nca", id_string));
@@ -283,32 +286,13 @@ void NSP::ReadNCAs(const std::vector<VirtualFile>& files) {
                 }
 
                 auto next_nca = std::make_shared<NCA>(std::move(next_file), nullptr, 0);
-
                 if (next_nca->GetType() == NCAContentType::Program) {
-                    program_status[next_nca->GetTitleId()] = next_nca->GetStatus();
+                    program_status[cnmt.GetTitleID()] = next_nca->GetStatus();
                 }
-
-                if (next_nca->GetStatus() != Loader::ResultStatus::Success &&
-                    next_nca->GetStatus() != Loader::ResultStatus::ErrorMissingBKTRBaseRomFS) {
-                    continue;
-                }
-
-                // If the last 3 hexadecimal digits of the CNMT TitleID is 0x800 or is missing the
-                // BKTRBaseRomFS, this is an update NCA. Otherwise, this is a base NCA.
-                if ((cnmt.GetTitleID() & 0x800) != 0 ||
-                    next_nca->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS) {
-                    // If the last 3 hexadecimal digits of the NCA's TitleID is between 0x1 and
-                    // 0x7FF, this is a multi-program update NCA. Otherwise, this is a regular
-                    // update NCA.
-                    if ((next_nca->GetTitleId() & 0x7FF) != 0 &&
-                        (next_nca->GetTitleId() & 0x800) == 0) {
-                        ncas[next_nca->GetTitleId()][{cnmt.GetType(), rec.type}] =
-                            std::move(next_nca);
-                    } else {
-                        ncas[cnmt.GetTitleID()][{cnmt.GetType(), rec.type}] = std::move(next_nca);
-                    }
-                } else {
-                    ncas[next_nca->GetTitleId()][{cnmt.GetType(), rec.type}] = std::move(next_nca);
+                if (next_nca->GetStatus() == Loader::ResultStatus::Success ||
+                    (next_nca->GetStatus() == Loader::ResultStatus::ErrorMissingBKTRBaseRomFS &&
+                     (cnmt.GetTitleID() & 0x800) != 0)) {
+                    ncas_title[{cnmt.GetType(), rec.type}] = std::move(next_nca);
                 }
             }
 

src/core/file_sys/submission_package.h

@@ -63,7 +63,6 @@ public:
     VirtualDir GetParentDirectory() const override;
 
 private:
-    void SetTicketKeys(const std::vector<VirtualFile>& files);
     void InitializeExeFSAndRomFS(const std::vector<VirtualFile>& files);
     void ReadNCAs(const std::vector<VirtualFile>& files);