nvdec: Defer texture cache invalidation until end of video stream

.ci/scripts/linux/docker.sh

@@ -18,8 +18,7 @@ cmake .. \
       -DENABLE_COMPATIBILITY_LIST_DOWNLOAD=ON \
       -DENABLE_QT_TRANSLATION=ON \
       -DUSE_DISCORD_PRESENCE=ON \
-      -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"} \
-      -DYUZU_USE_BUNDLED_FFMPEG=ON
+      -DYUZU_ENABLE_COMPATIBILITY_REPORTING=${ENABLE_COMPATIBILITY_REPORTING:-"OFF"}
 
 make -j$(nproc)
 

.ci/yuzu-mainline-step2.yml

@@ -19,7 +19,6 @@ stages:
   displayName: 'build'
   jobs:
   - job: build
-    timeoutInMinutes: 120
     displayName: 'standard'
     pool:
       vmImage: ubuntu-latest
@@ -44,7 +43,6 @@ stages:
   displayName: 'build-windows'
   jobs:
   - job: build
-    timeoutInMinutes: 120
     displayName: 'msvc'
     pool:
       vmImage: windows-2019
@@ -67,4 +65,4 @@ stages:
   - job: github
     displayName: 'github'
     steps:
-    - template: ./templates/release-github.yml
+    - template: ./templates/release-github.yml

CMakeLists.txt

@@ -25,7 +25,7 @@ option(YUZU_USE_BUNDLED_BOOST "Download bundled Boost" OFF)
 
 option(YUZU_USE_BUNDLED_LIBUSB "Compile bundled libusb" OFF)
 
-option(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" "${WIN32}")
+CMAKE_DEPENDENT_OPTION(YUZU_USE_BUNDLED_FFMPEG "Download/Build bundled FFmpeg" ON "WIN32" OFF)
 
 option(YUZU_USE_QT_WEB_ENGINE "Use QtWebEngine for web applet implementation" OFF)
 
@@ -376,7 +376,7 @@ if (ENABLE_SDL2)
     if (YUZU_USE_BUNDLED_SDL2)
         # Detect toolchain and platform
         if ((MSVC_VERSION GREATER_EQUAL 1910 AND MSVC_VERSION LESS 1930) AND ARCHITECTURE_x86_64)
-            set(SDL2_VER "SDL2-2.0.16")
+            set(SDL2_VER "SDL2-2.0.15-prerelease")
         else()
             message(FATAL_ERROR "No bundled SDL2 binaries for your toolchain. Disable YUZU_USE_BUNDLED_SDL2 and provide your own.")
         endif()
@@ -396,7 +396,7 @@ if (ENABLE_SDL2)
     elseif (YUZU_USE_EXTERNAL_SDL2)
         message(STATUS "Using SDL2 from externals.")
     else()
-        find_package(SDL2 2.0.16 REQUIRED)
+        find_package(SDL2 2.0.15 REQUIRED)
 
         # Some installations don't set SDL2_LIBRARIES
         if("${SDL2_LIBRARIES}" STREQUAL "")
@@ -496,7 +496,7 @@ endif()
 # Ensure libusb is properly configured (based on dolphin libusb include)
 if(NOT APPLE AND NOT YUZU_USE_BUNDLED_LIBUSB)
     include(FindPkgConfig)
-    if (PKG_CONFIG_FOUND AND NOT CMAKE_SYSTEM_NAME MATCHES "DragonFly|FreeBSD")
+    if (PKG_CONFIG_FOUND)
         pkg_check_modules(LIBUSB QUIET libusb-1.0>=1.0.24)
     else()
         find_package(LibUSB)
@@ -583,32 +583,8 @@ if (YUZU_USE_BUNDLED_FFMPEG)
             "${FFmpeg_PREFIX};${FFmpeg_BUILD_DIR}"
             CACHE PATH "Path to FFmpeg headers" FORCE)
 
-        if (${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
-            Include(FindPkgConfig REQUIRED)
-            pkg_check_modules(LIBVA libva)
-        endif()
-        if(LIBVA_FOUND)
-            pkg_check_modules(LIBDRM libdrm REQUIRED)
-            find_package(X11 REQUIRED)
-            pkg_check_modules(LIBVA-DRM libva-drm REQUIRED)
-            pkg_check_modules(LIBVA-X11 libva-x11 REQUIRED)
-            set(FFmpeg_LIBVA_LIBRARIES
-                ${LIBDRM_LIBRARIES}
-                ${X11_LIBRARIES}
-                ${LIBVA-DRM_LIBRARIES}
-                ${LIBVA-X11_LIBRARIES}
-                ${LIBVA_LIBRARIES})
-            set(FFmpeg_HWACCEL_FLAGS
-                --enable-hwaccel=h264_vaapi
-                --enable-hwaccel=vp9_vaapi
-                --enable-libdrm)
-            message(STATUS "VA-API found")
-        else()
-            set(FFmpeg_HWACCEL_FLAGS --disable-vaapi)
-        endif()
-
         # `configure` parameters builds only exactly what yuzu needs from FFmpeg
-        # `--disable-vdpau` is needed to avoid linking issues
+        # `--disable-{vaapi,vdpau}` is needed to avoid linking issues
         add_custom_command(
             OUTPUT
                 ${FFmpeg_MAKEFILE}
@@ -624,16 +600,13 @@ if (YUZU_USE_BUNDLED_FFMPEG)
                     --disable-network
                     --disable-postproc
                     --disable-swresample
+                    --disable-vaapi
                     --disable-vdpau
                     --enable-decoder=h264
                     --enable-decoder=vp9
-                    --cc="${CMAKE_C_COMPILER}"
-                    --cxx="${CMAKE_CXX_COMPILER}"
-                    ${FFmpeg_HWACCEL_FLAGS}
             WORKING_DIRECTORY
                 ${FFmpeg_BUILD_DIR}
         )
-        unset(FFmpeg_HWACCEL_FLAGS)
 
         # Workaround for Ubuntu 18.04's older version of make not being able to call make as a child
         # with context of the jobserver. Also helps ninja users.
@@ -643,10 +616,9 @@ if (YUZU_USE_BUNDLED_FFMPEG)
             OUTPUT_VARIABLE
                 SYSTEM_THREADS)
 
-        set(FFmpeg_BUILD_LIBRARIES ${FFmpeg_LIBRARIES})
         add_custom_command(
             OUTPUT
-                ${FFmpeg_BUILD_LIBRARIES}
+                ${FFmpeg_LIBRARIES}
             COMMAND
                 make -j${SYSTEM_THREADS}
             WORKING_DIRECTORY
@@ -656,12 +628,7 @@ if (YUZU_USE_BUNDLED_FFMPEG)
         # ALL makes this custom target build every time
         # but it won't actually build if the DEPENDS parameter is up to date
         add_custom_target(ffmpeg-configure ALL DEPENDS ${FFmpeg_MAKEFILE})
-        add_custom_target(ffmpeg-build ALL DEPENDS ${FFmpeg_BUILD_LIBRARIES} ffmpeg-configure)
-        link_libraries(${FFmpeg_LIBVA_LIBRARIES})
-        set(FFmpeg_LIBRARIES ${FFmpeg_LIBVA_LIBRARIES} ${FFmpeg_BUILD_LIBRARIES}
-            CACHE PATH "Paths to FFmpeg libraries" FORCE)
-        unset(FFmpeg_BUILD_LIBRARIES)
-        unset(FFmpeg_LIBVA_LIBRARIES)
+        add_custom_target(ffmpeg-build ALL DEPENDS ${FFmpeg_LIBRARIES} ffmpeg-configure)
 
         if (FFmpeg_FOUND)
             message(STATUS "Found FFmpeg version ${FFmpeg_VERSION}")

CMakeModules/GenerateSCMRev.cmake

@@ -48,6 +48,69 @@ if (BUILD_REPOSITORY)
   endif()
 endif()
 
-# The variable SRC_DIR must be passed into the script
-# (since it uses the current build directory for all values of CMAKE_*_DIR)
+# The variable SRC_DIR must be passed into the script (since it uses the current build directory for all values of CMAKE_*_DIR)
+set(VIDEO_CORE "${SRC_DIR}/src/video_core")
+set(HASH_FILES
+    "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.cpp"
+    "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.h"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.cpp"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.h"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.cpp"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.h"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.cpp"
+    "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.h"
+    "${VIDEO_CORE}/shader/decode/arithmetic.cpp"
+    "${VIDEO_CORE}/shader/decode/arithmetic_half.cpp"
+    "${VIDEO_CORE}/shader/decode/arithmetic_half_immediate.cpp"
+    "${VIDEO_CORE}/shader/decode/arithmetic_immediate.cpp"
+    "${VIDEO_CORE}/shader/decode/arithmetic_integer.cpp"
+    "${VIDEO_CORE}/shader/decode/arithmetic_integer_immediate.cpp"
+    "${VIDEO_CORE}/shader/decode/bfe.cpp"
+    "${VIDEO_CORE}/shader/decode/bfi.cpp"
+    "${VIDEO_CORE}/shader/decode/conversion.cpp"
+    "${VIDEO_CORE}/shader/decode/ffma.cpp"
+    "${VIDEO_CORE}/shader/decode/float_set.cpp"
+    "${VIDEO_CORE}/shader/decode/float_set_predicate.cpp"
+    "${VIDEO_CORE}/shader/decode/half_set.cpp"
+    "${VIDEO_CORE}/shader/decode/half_set_predicate.cpp"
+    "${VIDEO_CORE}/shader/decode/hfma2.cpp"
+    "${VIDEO_CORE}/shader/decode/image.cpp"
+    "${VIDEO_CORE}/shader/decode/integer_set.cpp"
+    "${VIDEO_CORE}/shader/decode/integer_set_predicate.cpp"
+    "${VIDEO_CORE}/shader/decode/memory.cpp"
+    "${VIDEO_CORE}/shader/decode/texture.cpp"
+    "${VIDEO_CORE}/shader/decode/other.cpp"
+    "${VIDEO_CORE}/shader/decode/predicate_set_predicate.cpp"
+    "${VIDEO_CORE}/shader/decode/predicate_set_register.cpp"
+    "${VIDEO_CORE}/shader/decode/register_set_predicate.cpp"
+    "${VIDEO_CORE}/shader/decode/shift.cpp"
+    "${VIDEO_CORE}/shader/decode/video.cpp"
+    "${VIDEO_CORE}/shader/decode/warp.cpp"
+    "${VIDEO_CORE}/shader/decode/xmad.cpp"
+    "${VIDEO_CORE}/shader/ast.cpp"
+    "${VIDEO_CORE}/shader/ast.h"
+    "${VIDEO_CORE}/shader/compiler_settings.cpp"
+    "${VIDEO_CORE}/shader/compiler_settings.h"
+    "${VIDEO_CORE}/shader/control_flow.cpp"
+    "${VIDEO_CORE}/shader/control_flow.h"
+    "${VIDEO_CORE}/shader/decode.cpp"
+    "${VIDEO_CORE}/shader/expr.cpp"
+    "${VIDEO_CORE}/shader/expr.h"
+    "${VIDEO_CORE}/shader/node.h"
+    "${VIDEO_CORE}/shader/node_helper.cpp"
+    "${VIDEO_CORE}/shader/node_helper.h"
+    "${VIDEO_CORE}/shader/registry.cpp"
+    "${VIDEO_CORE}/shader/registry.h"
+    "${VIDEO_CORE}/shader/shader_ir.cpp"
+    "${VIDEO_CORE}/shader/shader_ir.h"
+    "${VIDEO_CORE}/shader/track.cpp"
+    "${VIDEO_CORE}/shader/transform_feedback.cpp"
+    "${VIDEO_CORE}/shader/transform_feedback.h"
+)
+set(COMBINED "")
+foreach (F IN LISTS HASH_FILES)
+    file(READ ${F} TMP)
+    set(COMBINED "${COMBINED}${TMP}")
+endforeach()
+string(MD5 SHADER_CACHE_VERSION "${COMBINED}")
 configure_file("${SRC_DIR}/src/common/scm_rev.cpp.in" "scm_rev.cpp" @ONLY)

README.md

@@ -35,7 +35,7 @@ It is written in C++ with portability in mind, and we actively maintain builds f
 
 The emulator is capable of running most commercial games at full speed, provided you meet the [necessary hardware requirements](https://yuzu-emu.org/help/quickstart/#hardware-requirements).
 
-For a full list of games yuzu support, please visit our [Compatibility page](https://yuzu-emu.org/game/)
+For a full list of games yuzu support, please visit our [Compatibility page](https://yuzu-emu.org/game/) 
 
 Check out our [website](https://yuzu-emu.org/) for the latest news on exciting features, monthly progress reports, and more!
 
@@ -43,7 +43,7 @@ Check out our [website](https://yuzu-emu.org/) for the latest news on exciting f
 
 Most of the development happens on GitHub. It's also where [our central repository](https://github.com/yuzu-emu/yuzu) is hosted. For development discussion, please join us on [Discord](https://discord.com/invite/u77vRWY).
 
-If you want to contribute, please take a look at the [Contributor's Guide](https://github.com/yuzu-emu/yuzu/wiki/Contributing) and [Developer Information](https://github.com/yuzu-emu/yuzu/wiki/Developer-Information).
+If you want to contribute, please take a look at the [Contributor's Guide](https://github.com/yuzu-emu/yuzu/wiki/Contributing) and [Developer Information](https://github.com/yuzu-emu/yuzu/wiki/Developer-Information). 
 You can also contact any of the developers on Discord in order to know about the current state of the emulator.
 
 If you want to contribute to the user interface translation project, please check out the [yuzu project on transifex](https://www.transifex.com/yuzu-emulator/yuzu). We centralize translation work there, and periodically upstream translations.
@@ -78,5 +78,3 @@ If you wish to support us a different way, please join our [Discord](https://dis
 ## License
 
 yuzu is licensed under the GPLv2 (or any later version). Refer to the [license.txt](https://github.com/yuzu-emu/yuzu/blob/master/license.txt) file.
-
-The [Skyline-Emulator Team](https://github.com/skyline-emu/skyline) is exempt from GPLv2 for the contributions from all these contributors [FernandoS27](https://github.com/FernandoS27), [lioncash](https://github.com/lioncash), [bunnei](https://github.com/bunnei), [ReinUsesLisp](https://github.com/ReinUsesLisp), [Morph1984](https://github.com/Morph1984), [ogniK5377](https://github.com/ogniK5377), [german77](https://github.com/german77), [ameerj](https://github.com/ameerj), [Kelebek1](https://github.com/Kelebek1) and [lat9nq](https://github.com/lat9nq). They may only use the code from these contributors under Mozilla Public License, version 2.0.

dist/qt_themes/default/style.qss

@@ -38,26 +38,6 @@ QPushButton#RendererStatusBarButton:!checked {
     color: #0066ff;
 }
 
-QPushButton#GPUStatusBarButton {
-    color: #656565;
-    border: 1px solid transparent;
-    background-color: transparent;
-    padding: 0px 3px 0px 3px;
-    text-align: center;
-}
-
-QPushButton#GPUStatusBarButton:hover {
-    border: 1px solid #76797C;
-}
-
-QPushButton#GPUStatusBarButton:checked {
-    color: #b06020;
-}
-
-QPushButton#GPUStatusBarButton:!checked {
-    color: #109010;
-}
-
 QPushButton#buttonRefreshDevices {
     min-width: 21px;
     min-height: 21px;

dist/qt_themes/qdarkstyle/style.qss

@@ -1283,27 +1283,6 @@ QPushButton#RendererStatusBarButton:!checked {
     color: #00ccdd;
 }
 
-QPushButton#GPUStatusBarButton {
-    min-width: 0px;
-    color: #656565;
-    border: 1px solid transparent;
-    background-color: transparent;
-    padding: 0px 3px 0px 3px;
-    text-align: center;
-}
-
-QPushButton#GPUStatusBarButton:hover {
-    border: 1px solid #76797C;
-}
-
-QPushButton#GPUStatusBarButton:checked {
-    color: #ff8040;
-}
-
-QPushButton#GPUStatusBarButton:!checked {
-    color: #40dd40;
-}
-
 QPushButton#buttonRefreshDevices {
     min-width: 23px;
     min-height: 23px;

dist/qt_themes/qdarkstyle_midnight_blue/style.qss

@@ -2186,27 +2186,6 @@ QPushButton#RendererStatusBarButton:!checked {
   color: #00ccdd;
 }
 
-QPushButton#GPUStatusBarButton {
-  min-width: 0px;
-  color: #656565;
-  border: 1px solid transparent;
-  background-color: transparent;
-  padding: 0px 3px 0px 3px;
-  text-align: center;
-}
-
-QPushButton#GPUStatusBarButton:hover {
-  border: 1px solid #76797C;
-}
-
-QPushButton#GPUStatusBarButton:checked {
-  color: #ff8040;
-}
-
-QPushButton#GPUStatusBarButton:!checked {
-  color: #40dd40;
-}
-
 QPushButton#buttonRefreshDevices {
   min-width: 19px;
   min-height: 19px;

externals/libusb/CMakeLists.txt

@@ -67,8 +67,6 @@ if (MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux") OR APPLE)
             "${LIBUSB_MAKEFILE}"
         COMMAND
             env
-                CC="${CMAKE_C_COMPILER}"
-                CXX="${CMAKE_CXX_COMPILER}"
                 CFLAGS="${LIBUSB_CFLAGS}"
             sh "${LIBUSB_CONFIGURE}"
                 ${LIBUSB_CONFIGURE_ARGS}

src/CMakeLists.txt

@@ -142,7 +142,6 @@ add_subdirectory(core)
 add_subdirectory(audio_core)
 add_subdirectory(video_core)
 add_subdirectory(input_common)
-add_subdirectory(shader_recompiler)
 add_subdirectory(tests)
 
 if (ENABLE_SDL2)

src/common/CMakeLists.txt

@@ -1,3 +1,8 @@
+# Add a custom command to generate a new shader_cache_version hash when any of the following files change
+# NOTE: This is an approximation of what files affect shader generation, its possible something else
+# could affect the result, but much more unlikely than the following files. Keeping a list of files
+# like this allows for much better caching since it doesn't force the user to recompile binary shaders every update
+set(VIDEO_CORE "${CMAKE_SOURCE_DIR}/src/video_core")
 if (DEFINED ENV{AZURECIREPO})
   set(BUILD_REPOSITORY $ENV{AZURECIREPO})
 endif()
@@ -25,7 +30,64 @@ add_custom_command(OUTPUT scm_rev.cpp
       -DGIT_EXECUTABLE=${GIT_EXECUTABLE}
       -P ${CMAKE_SOURCE_DIR}/CMakeModules/GenerateSCMRev.cmake
     DEPENDS
-      # Check that the scm_rev files haven't changed
+      # WARNING! It was too much work to try and make a common location for this list,
+      # so if you need to change it, please update CMakeModules/GenerateSCMRev.cmake as well
+      "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.cpp"
+      "${VIDEO_CORE}/renderer_opengl/gl_arb_decompiler.h"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.cpp"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_cache.h"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.cpp"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_decompiler.h"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.cpp"
+      "${VIDEO_CORE}/renderer_opengl/gl_shader_disk_cache.h"
+      "${VIDEO_CORE}/shader/decode/arithmetic.cpp"
+      "${VIDEO_CORE}/shader/decode/arithmetic_half.cpp"
+      "${VIDEO_CORE}/shader/decode/arithmetic_half_immediate.cpp"
+      "${VIDEO_CORE}/shader/decode/arithmetic_immediate.cpp"
+      "${VIDEO_CORE}/shader/decode/arithmetic_integer.cpp"
+      "${VIDEO_CORE}/shader/decode/arithmetic_integer_immediate.cpp"
+      "${VIDEO_CORE}/shader/decode/bfe.cpp"
+      "${VIDEO_CORE}/shader/decode/bfi.cpp"
+      "${VIDEO_CORE}/shader/decode/conversion.cpp"
+      "${VIDEO_CORE}/shader/decode/ffma.cpp"
+      "${VIDEO_CORE}/shader/decode/float_set.cpp"
+      "${VIDEO_CORE}/shader/decode/float_set_predicate.cpp"
+      "${VIDEO_CORE}/shader/decode/half_set.cpp"
+      "${VIDEO_CORE}/shader/decode/half_set_predicate.cpp"
+      "${VIDEO_CORE}/shader/decode/hfma2.cpp"
+      "${VIDEO_CORE}/shader/decode/image.cpp"
+      "${VIDEO_CORE}/shader/decode/integer_set.cpp"
+      "${VIDEO_CORE}/shader/decode/integer_set_predicate.cpp"
+      "${VIDEO_CORE}/shader/decode/memory.cpp"
+      "${VIDEO_CORE}/shader/decode/texture.cpp"
+      "${VIDEO_CORE}/shader/decode/other.cpp"
+      "${VIDEO_CORE}/shader/decode/predicate_set_predicate.cpp"
+      "${VIDEO_CORE}/shader/decode/predicate_set_register.cpp"
+      "${VIDEO_CORE}/shader/decode/register_set_predicate.cpp"
+      "${VIDEO_CORE}/shader/decode/shift.cpp"
+      "${VIDEO_CORE}/shader/decode/video.cpp"
+      "${VIDEO_CORE}/shader/decode/warp.cpp"
+      "${VIDEO_CORE}/shader/decode/xmad.cpp"
+      "${VIDEO_CORE}/shader/ast.cpp"
+      "${VIDEO_CORE}/shader/ast.h"
+      "${VIDEO_CORE}/shader/compiler_settings.cpp"
+      "${VIDEO_CORE}/shader/compiler_settings.h"
+      "${VIDEO_CORE}/shader/control_flow.cpp"
+      "${VIDEO_CORE}/shader/control_flow.h"
+      "${VIDEO_CORE}/shader/decode.cpp"
+      "${VIDEO_CORE}/shader/expr.cpp"
+      "${VIDEO_CORE}/shader/expr.h"
+      "${VIDEO_CORE}/shader/node.h"
+      "${VIDEO_CORE}/shader/node_helper.cpp"
+      "${VIDEO_CORE}/shader/node_helper.h"
+      "${VIDEO_CORE}/shader/registry.cpp"
+      "${VIDEO_CORE}/shader/registry.h"
+      "${VIDEO_CORE}/shader/shader_ir.cpp"
+      "${VIDEO_CORE}/shader/shader_ir.h"
+      "${VIDEO_CORE}/shader/track.cpp"
+      "${VIDEO_CORE}/shader/transform_feedback.cpp"
+      "${VIDEO_CORE}/shader/transform_feedback.h"
+      # and also check that the scm_rev files haven't changed
       "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.cpp.in"
       "${CMAKE_CURRENT_SOURCE_DIR}/scm_rev.h"
       # technically we should regenerate if the git version changed, but its not worth the effort imo
@@ -169,7 +231,7 @@ endif()
 
 create_target_directory_groups(common)
 
-target_link_libraries(common PUBLIC ${Boost_LIBRARIES} fmt::fmt microprofile Threads::Threads)
+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)

src/common/assert.h

@@ -52,12 +52,8 @@ assert_noinline_call(const Fn& fn) {
 #define DEBUG_ASSERT(_a_) ASSERT(_a_)
 #define DEBUG_ASSERT_MSG(_a_, ...) ASSERT_MSG(_a_, __VA_ARGS__)
 #else // not debug
-#define DEBUG_ASSERT(_a_)                                                                          \
-    do {                                                                                           \
-    } while (0)
-#define DEBUG_ASSERT_MSG(_a_, _desc_, ...)                                                         \
-    do {                                                                                           \
-    } while (0)
+#define DEBUG_ASSERT(_a_)
+#define DEBUG_ASSERT_MSG(_a_, _desc_, ...)
 #endif
 
 #define UNIMPLEMENTED() ASSERT_MSG(false, "Unimplemented code!")

src/common/fs/fs_util.cpp

@@ -20,10 +20,6 @@ std::string ToUTF8String(std::u8string_view u8_string) {
     return std::string{u8_string.begin(), u8_string.end()};
 }
 
-std::string BufferToUTF8String(std::span<const u8> buffer) {
-    return std::string{buffer.begin(), std::ranges::find(buffer, u8{0})};
-}
-
 std::string PathToUTF8String(const std::filesystem::path& path) {
     return ToUTF8String(path.u8string());
 }

src/common/fs/fs_util.h

@@ -46,17 +46,6 @@ concept IsChar = std::same_as<T, char>;
  */
 [[nodiscard]] std::string ToUTF8String(std::u8string_view u8_string);
 
-/**
- * Converts a buffer of bytes to a UTF8-encoded std::string.
- * This converts from the start of the buffer until the first encountered null-terminator.
- * If no null-terminator is found, this converts the entire buffer instead.
- *
- * @param buffer Buffer of bytes
- *
- * @returns UTF-8 encoded std::string.
- */
-[[nodiscard]] std::string BufferToUTF8String(std::span<const u8> buffer);
-
 /**
  * Converts a filesystem path to a UTF-8 encoded std::string.
  *

src/common/hex_util.h

@@ -61,7 +61,7 @@ template <typename ContiguousContainer>
     return out;
 }
 
-[[nodiscard]] constexpr std::array<u8, 16> AsArray(const char (&data)[33]) {
+[[nodiscard]] constexpr std::array<u8, 16> AsArray(const char (&data)[17]) {
     return HexStringToArray<16>(data);
 }
 

src/common/host_memory.cpp

@@ -6,7 +6,7 @@
 #include <windows.h>
 #include "common/dynamic_library.h"
 
-#elif defined(__linux__) || defined(__FreeBSD__) // ^^^ Windows ^^^ vvv Linux vvv
+#elif defined(__linux__) // ^^^ Windows ^^^ vvv Linux vvv
 
 #ifndef _GNU_SOURCE
 #define _GNU_SOURCE
@@ -343,7 +343,7 @@ private:
     std::unordered_map<size_t, size_t> placeholder_host_pointers; ///< Placeholder backing offset
 };
 
-#elif defined(__linux__) || defined(__FreeBSD__) // ^^^ Windows ^^^ vvv Linux vvv
+#elif defined(__linux__) // ^^^ Windows ^^^ vvv Linux vvv
 
 class HostMemory::Impl {
 public:
@@ -357,12 +357,7 @@ public:
         });
 
         // Backing memory initialization
-#if defined(__FreeBSD__) && __FreeBSD__ < 13
-        // XXX Drop after FreeBSD 12.* reaches EOL on 2024-06-30
-        fd = shm_open(SHM_ANON, O_RDWR, 0600);
-#else
         fd = memfd_create("HostMemory", 0);
-#endif
         if (fd == -1) {
             LOG_CRITICAL(HW_Memory, "memfd_create failed: {}", strerror(errno));
             throw std::bad_alloc{};

src/common/logging/filter.cpp

@@ -144,10 +144,6 @@ bool ParseFilterRule(Filter& instance, Iterator begin, Iterator end) {
     SUB(Render, Software)                                                                          \
     SUB(Render, OpenGL)                                                                            \
     SUB(Render, Vulkan)                                                                            \
-    CLS(Shader)                                                                                    \
-    SUB(Shader, SPIRV)                                                                             \
-    SUB(Shader, GLASM)                                                                             \
-    SUB(Shader, GLSL)                                                                              \
     CLS(Audio)                                                                                     \
     SUB(Audio, DSP)                                                                                \
     SUB(Audio, Sink)                                                                               \

src/common/logging/types.h

@@ -114,10 +114,6 @@ enum class Class : u8 {
     Render_Software,   ///< Software renderer backend
     Render_OpenGL,     ///< OpenGL backend
     Render_Vulkan,     ///< Vulkan backend
-    Shader,            ///< Shader recompiler
-    Shader_SPIRV,      ///< Shader SPIR-V code generation
-    Shader_GLASM,      ///< Shader GLASM code generation
-    Shader_GLSL,       ///< Shader GLSL code generation
     Audio,             ///< Audio emulation
     Audio_DSP,         ///< The HLE implementation of the DSP
     Audio_Sink,        ///< Emulator audio output backend

src/common/scm_rev.cpp.in

@@ -14,6 +14,7 @@
 #define BUILD_ID "@BUILD_ID@"
 #define TITLE_BAR_FORMAT_IDLE "@TITLE_BAR_FORMAT_IDLE@"
 #define TITLE_BAR_FORMAT_RUNNING "@TITLE_BAR_FORMAT_RUNNING@"
+#define SHADER_CACHE_VERSION "@SHADER_CACHE_VERSION@"
 
 namespace Common {
 
@@ -27,6 +28,7 @@ const char g_build_version[]  = BUILD_VERSION;
 const char g_build_id[] = BUILD_ID;
 const char g_title_bar_format_idle[] = TITLE_BAR_FORMAT_IDLE;
 const char g_title_bar_format_running[] = TITLE_BAR_FORMAT_RUNNING;
+const char g_shader_cache_version[] = SHADER_CACHE_VERSION;
 
 } // namespace
 

src/common/settings.cpp

@@ -48,8 +48,8 @@ void LogSettings() {
     log_setting("Core_UseMultiCore", values.use_multi_core.GetValue());
     log_setting("CPU_Accuracy", values.cpu_accuracy.GetValue());
     log_setting("Renderer_UseResolutionFactor", values.resolution_factor.GetValue());
-    log_setting("Renderer_UseSpeedLimit", values.use_speed_limit.GetValue());
-    log_setting("Renderer_SpeedLimit", values.speed_limit.GetValue());
+    log_setting("Renderer_UseFrameLimit", values.use_frame_limit.GetValue());
+    log_setting("Renderer_FrameLimit", values.frame_limit.GetValue());
     log_setting("Renderer_UseDiskShaderCache", values.use_disk_shader_cache.GetValue());
     log_setting("Renderer_GPUAccuracyLevel", values.gpu_accuracy.GetValue());
     log_setting("Renderer_UseAsynchronousGpuEmulation",
@@ -57,7 +57,7 @@ void LogSettings() {
     log_setting("Renderer_UseNvdecEmulation", values.use_nvdec_emulation.GetValue());
     log_setting("Renderer_AccelerateASTC", values.accelerate_astc.GetValue());
     log_setting("Renderer_UseVsync", values.use_vsync.GetValue());
-    log_setting("Renderer_ShaderBackend", values.shader_backend.GetValue());
+    log_setting("Renderer_UseAssemblyShaders", values.use_assembly_shaders.GetValue());
     log_setting("Renderer_UseAsynchronousShaders", values.use_asynchronous_shaders.GetValue());
     log_setting("Renderer_UseGarbageCollection", values.use_caches_gc.GetValue());
     log_setting("Renderer_AnisotropicFilteringLevel", values.max_anisotropy.GetValue());
@@ -132,15 +132,15 @@ void RestoreGlobalState(bool is_powered_on) {
     values.vulkan_device.SetGlobal(true);
     values.aspect_ratio.SetGlobal(true);
     values.max_anisotropy.SetGlobal(true);
-    values.use_speed_limit.SetGlobal(true);
-    values.speed_limit.SetGlobal(true);
+    values.use_frame_limit.SetGlobal(true);
+    values.frame_limit.SetGlobal(true);
     values.use_disk_shader_cache.SetGlobal(true);
     values.gpu_accuracy.SetGlobal(true);
     values.use_asynchronous_gpu_emulation.SetGlobal(true);
     values.use_nvdec_emulation.SetGlobal(true);
     values.accelerate_astc.SetGlobal(true);
     values.use_vsync.SetGlobal(true);
-    values.shader_backend.SetGlobal(true);
+    values.use_assembly_shaders.SetGlobal(true);
     values.use_asynchronous_shaders.SetGlobal(true);
     values.use_fast_gpu_time.SetGlobal(true);
     values.use_caches_gc.SetGlobal(true);

src/common/settings.h

@@ -4,7 +4,6 @@
 
 #pragma once
 
-#include <algorithm>
 #include <array>
 #include <atomic>
 #include <chrono>
@@ -25,12 +24,6 @@ enum class RendererBackend : u32 {
     Vulkan = 1,
 };
 
-enum class ShaderBackend : u32 {
-    GLSL = 0,
-    GLASM = 1,
-    SPIRV = 2,
-};
-
 enum class GPUAccuracy : u32 {
     Normal = 0,
     High = 1,
@@ -43,11 +36,6 @@ enum class CPUAccuracy : u32 {
     Unsafe = 2,
 };
 
-enum class FullscreenMode : u32 {
-    Borderless = 0,
-    Exclusive = 1,
-};
-
 /** The BasicSetting class is a simple resource manager. It defines a label and default value
  * alongside the actual value of the setting for simpler and less-error prone use with frontend
  * configurations. Setting a default value and label is required, though subclasses may deviate from
@@ -75,14 +63,14 @@ public:
      */
     explicit BasicSetting(const Type& default_val, const std::string& name)
         : default_value{default_val}, global{default_val}, label{name} {}
-    virtual ~BasicSetting() = default;
+    ~BasicSetting() = default;
 
     /**
      *  Returns a reference to the setting's value.
      *
      * @returns A reference to the setting
      */
-    [[nodiscard]] virtual const Type& GetValue() const {
+    [[nodiscard]] const Type& GetValue() const {
         return global;
     }
 
@@ -91,7 +79,7 @@ public:
      *
      * @param value The desired value
      */
-    virtual void SetValue(const Type& value) {
+    void SetValue(const Type& value) {
         Type temp{value};
         std::swap(global, temp);
     }
@@ -121,7 +109,7 @@ public:
      *
      * @returns A reference to the setting
      */
-    virtual const Type& operator=(const Type& value) {
+    const Type& operator=(const Type& value) {
         Type temp{value};
         std::swap(global, temp);
         return global;
@@ -132,7 +120,7 @@ public:
      *
      * @returns A reference to the setting
      */
-    explicit virtual operator const Type&() const {
+    explicit operator const Type&() const {
         return global;
     }
 
@@ -142,51 +130,6 @@ protected:
     const std::string label{};  ///< The setting's label
 };
 
-/**
- * BasicRangedSetting class is intended for use with quantifiable settings that need a more
- * restrictive range than implicitly defined by its type. Implements a minimum and maximum that is
- * simply used to sanitize SetValue and the assignment overload.
- */
-template <typename Type>
-class BasicRangedSetting : virtual public BasicSetting<Type> {
-public:
-    /**
-     * Sets a default value, minimum value, maximum value, and label.
-     *
-     * @param default_val Intial value of the setting, and default value of the setting
-     * @param min_val Sets the minimum allowed value of the setting
-     * @param max_val Sets the maximum allowed value of the setting
-     * @param name Label for the setting
-     */
-    explicit BasicRangedSetting(const Type& default_val, const Type& min_val, const Type& max_val,
-                                const std::string& name)
-        : BasicSetting<Type>{default_val, name}, minimum{min_val}, maximum{max_val} {}
-    virtual ~BasicRangedSetting() = default;
-
-    /**
-     * Like BasicSetting's SetValue, except value is clamped to the range of the setting.
-     *
-     * @param value The desired value
-     */
-    void SetValue(const Type& value) override {
-        this->global = std::clamp(value, minimum, maximum);
-    }
-
-    /**
-     * Like BasicSetting's assignment overload, except value is clamped to the range of the setting.
-     *
-     * @param value The desired value
-     * @returns A reference to the setting's value
-     */
-    const Type& operator=(const Type& value) override {
-        this->global = std::clamp(value, minimum, maximum);
-        return this->global;
-    }
-
-    const Type minimum; ///< Minimum allowed value of the setting
-    const Type maximum; ///< Maximum allowed value of the setting
-};
-
 /**
  * The Setting class is a slightly more complex version of the BasicSetting class. This adds a
  * custom setting to switch to when a guest application specifically requires it. The effect is that
@@ -198,7 +141,7 @@ public:
  * Like the BasicSetting, this requires setting a default value and label to use.
  */
 template <typename Type>
-class Setting : virtual public BasicSetting<Type> {
+class Setting final : public BasicSetting<Type> {
 public:
     /**
      * Sets a default value, label, and setting value.
@@ -208,7 +151,7 @@ public:
      */
     explicit Setting(const Type& default_val, const std::string& name)
         : BasicSetting<Type>(default_val, name) {}
-    virtual ~Setting() = default;
+    ~Setting() = default;
 
     /**
      * Tells this setting to represent either the global or custom setting when other member
@@ -237,13 +180,7 @@ public:
      *
      * @returns The required value of the setting
      */
-    [[nodiscard]] virtual const Type& GetValue() const override {
-        if (use_global) {
-            return this->global;
-        }
-        return custom;
-    }
-    [[nodiscard]] virtual const Type& GetValue(bool need_global) const {
+    [[nodiscard]] const Type& GetValue(bool need_global = false) const {
         if (use_global || need_global) {
             return this->global;
         }
@@ -255,7 +192,7 @@ public:
      *
      * @param value The new value
      */
-    void SetValue(const Type& value) override {
+    void SetValue(const Type& value) {
         Type temp{value};
         if (use_global) {
             std::swap(this->global, temp);
@@ -271,7 +208,7 @@ public:
      *
      * @returns A reference to the current setting value
      */
-    const Type& operator=(const Type& value) override {
+    const Type& operator=(const Type& value) {
         Type temp{value};
         if (use_global) {
             std::swap(this->global, temp);
@@ -286,87 +223,18 @@ public:
      *
      * @returns A reference to the current setting value
      */
-    virtual explicit operator const Type&() const override {
+    explicit operator const Type&() const {
         if (use_global) {
             return this->global;
         }
         return custom;
     }
 
-protected:
+private:
     bool use_global{true}; ///< The setting's global state
     Type custom{};         ///< The custom value of the setting
 };
 
-/**
- * RangedSetting is a Setting that implements a maximum and minimum value for its setting. Intended
- * for use with quantifiable settings.
- */
-template <typename Type>
-class RangedSetting final : public BasicRangedSetting<Type>, public Setting<Type> {
-public:
-    /**
-     * Sets a default value, minimum value, maximum value, and label.
-     *
-     * @param default_val Intial value of the setting, and default value of the setting
-     * @param min_val Sets the minimum allowed value of the setting
-     * @param max_val Sets the maximum allowed value of the setting
-     * @param name Label for the setting
-     */
-    explicit RangedSetting(const Type& default_val, const Type& min_val, const Type& max_val,
-                           const std::string& name)
-        : BasicSetting<Type>{default_val, name},
-          BasicRangedSetting<Type>{default_val, min_val, max_val, name}, Setting<Type>{default_val,
-                                                                                       name} {}
-    virtual ~RangedSetting() = default;
-
-    // The following are needed to avoid a MSVC bug
-    // (source: https://stackoverflow.com/questions/469508)
-    [[nodiscard]] const Type& GetValue() const override {
-        return Setting<Type>::GetValue();
-    }
-    [[nodiscard]] const Type& GetValue(bool need_global) const override {
-        return Setting<Type>::GetValue(need_global);
-    }
-    explicit operator const Type&() const override {
-        if (this->use_global) {
-            return this->global;
-        }
-        return this->custom;
-    }
-
-    /**
-     * Like BasicSetting's SetValue, except value is clamped to the range of the setting. Sets the
-     * appropriate value depending on the global state.
-     *
-     * @param value The desired value
-     */
-    void SetValue(const Type& value) override {
-        const Type temp = std::clamp(value, this->minimum, this->maximum);
-        if (this->use_global) {
-            this->global = temp;
-        }
-        this->custom = temp;
-    }
-
-    /**
-     * Like BasicSetting's assignment overload, except value is clamped to the range of the setting.
-     * Uses the appropriate value depending on the global state.
-     *
-     * @param value The desired value
-     * @returns A reference to the setting's value
-     */
-    const Type& operator=(const Type& value) override {
-        const Type temp = std::clamp(value, this->minimum, this->maximum);
-        if (this->use_global) {
-            this->global = temp;
-            return this->global;
-        }
-        this->custom = temp;
-        return this->custom;
-    }
-};
-
 /**
  * The InputSetting class allows for getting a reference to either the global or custom members.
  * This is required as we cannot easily modify the values of user-defined types within containers
@@ -410,14 +278,13 @@ struct Values {
     BasicSetting<std::string> sink_id{"auto", "output_engine"};
     BasicSetting<bool> audio_muted{false, "audio_muted"};
     Setting<bool> enable_audio_stretching{true, "enable_audio_stretching"};
-    RangedSetting<u8> volume{100, 0, 100, "volume"};
+    Setting<u8> volume{100, "volume"};
 
     // Core
     Setting<bool> use_multi_core{true, "use_multi_core"};
 
     // Cpu
-    RangedSetting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Auto, CPUAccuracy::Auto,
-                                            CPUAccuracy::Unsafe, "cpu_accuracy"};
+    Setting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Auto, "cpu_accuracy"};
     // TODO: remove cpu_accuracy_first_time, migration setting added 8 July 2021
     BasicSetting<bool> cpu_accuracy_first_time{true, "cpu_accuracy_first_time"};
     BasicSetting<bool> cpu_debug_mode{false, "cpu_debug_mode"};
@@ -439,40 +306,32 @@ struct Values {
     Setting<bool> cpuopt_unsafe_fastmem_check{true, "cpuopt_unsafe_fastmem_check"};
 
     // Renderer
-    RangedSetting<RendererBackend> renderer_backend{
-        RendererBackend::OpenGL, RendererBackend::OpenGL, RendererBackend::Vulkan, "backend"};
+    Setting<RendererBackend> renderer_backend{RendererBackend::OpenGL, "backend"};
     BasicSetting<bool> renderer_debug{false, "debug"};
-    BasicSetting<bool> renderer_shader_feedback{false, "shader_feedback"};
-    BasicSetting<bool> enable_nsight_aftermath{false, "nsight_aftermath"};
-    BasicSetting<bool> disable_shader_loop_safety_checks{false,
-                                                         "disable_shader_loop_safety_checks"};
     Setting<int> vulkan_device{0, "vulkan_device"};
 
     Setting<u16> resolution_factor{1, "resolution_factor"};
     // *nix platforms may have issues with the borderless windowed fullscreen mode.
     // Default to exclusive fullscreen on these platforms for now.
-    RangedSetting<FullscreenMode> fullscreen_mode{
+    Setting<int> fullscreen_mode{
 #ifdef _WIN32
-        FullscreenMode::Borderless,
+        0,
 #else
-        FullscreenMode::Exclusive,
+        1,
 #endif
-        FullscreenMode::Borderless, FullscreenMode::Exclusive, "fullscreen_mode"};
-    RangedSetting<int> aspect_ratio{0, 0, 3, "aspect_ratio"};
-    RangedSetting<int> max_anisotropy{0, 0, 4, "max_anisotropy"};
-    Setting<bool> use_speed_limit{true, "use_speed_limit"};
-    RangedSetting<u16> speed_limit{100, 0, 9999, "speed_limit"};
+        "fullscreen_mode"};
+    Setting<int> aspect_ratio{0, "aspect_ratio"};
+    Setting<int> max_anisotropy{0, "max_anisotropy"};
+    Setting<bool> use_frame_limit{true, "use_frame_limit"};
+    Setting<u16> frame_limit{100, "frame_limit"};
     Setting<bool> use_disk_shader_cache{true, "use_disk_shader_cache"};
-    RangedSetting<GPUAccuracy> gpu_accuracy{GPUAccuracy::High, GPUAccuracy::Normal,
-                                            GPUAccuracy::Extreme, "gpu_accuracy"};
+    Setting<GPUAccuracy> gpu_accuracy{GPUAccuracy::High, "gpu_accuracy"};
     Setting<bool> use_asynchronous_gpu_emulation{true, "use_asynchronous_gpu_emulation"};
     Setting<bool> use_nvdec_emulation{true, "use_nvdec_emulation"};
     Setting<bool> accelerate_astc{true, "accelerate_astc"};
     Setting<bool> use_vsync{true, "use_vsync"};
-    BasicRangedSetting<u16> fps_cap{1000, 1, 1000, "fps_cap"};
     BasicSetting<bool> disable_fps_limit{false, "disable_fps_limit"};
-    RangedSetting<ShaderBackend> shader_backend{ShaderBackend::GLASM, ShaderBackend::GLSL,
-                                                ShaderBackend::SPIRV, "shader_backend"};
+    Setting<bool> use_assembly_shaders{false, "use_assembly_shaders"};
     Setting<bool> use_asynchronous_shaders{false, "use_asynchronous_shaders"};
     Setting<bool> use_fast_gpu_time{true, "use_fast_gpu_time"};
     Setting<bool> use_caches_gc{false, "use_caches_gc"};
@@ -489,10 +348,10 @@ struct Values {
     std::chrono::seconds custom_rtc_differential;
 
     BasicSetting<s32> current_user{0, "current_user"};
-    RangedSetting<s32> language_index{1, 0, 16, "language_index"};
-    RangedSetting<s32> region_index{1, 0, 6, "region_index"};
-    RangedSetting<s32> time_zone_index{0, 0, 45, "time_zone_index"};
-    RangedSetting<s32> sound_index{1, 0, 2, "sound_index"};
+    Setting<s32> language_index{1, "language_index"};
+    Setting<s32> region_index{1, "region_index"};
+    Setting<s32> time_zone_index{0, "time_zone_index"};
+    Setting<s32> sound_index{1, "sound_index"};
 
     // Controls
     InputSetting<std::array<PlayerInput, 10>> players;
@@ -509,7 +368,7 @@ struct Values {
                                                 "udp_input_servers"};
 
     BasicSetting<bool> mouse_panning{false, "mouse_panning"};
-    BasicRangedSetting<u8> mouse_panning_sensitivity{10, 1, 100, "mouse_panning_sensitivity"};
+    BasicSetting<u8> mouse_panning_sensitivity{10, "mouse_panning_sensitivity"};
     BasicSetting<bool> mouse_enabled{false, "mouse_enabled"};
     std::string mouse_device;
     MouseButtonsRaw mouse_buttons;

src/common/thread_worker.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <atomic>
-#include <condition_variable>
 #include <functional>
 #include <mutex>
 #include <stop_token>
@@ -40,7 +39,7 @@ public:
         const auto lambda = [this, func](std::stop_token stop_token) {
             Common::SetCurrentThreadName(thread_name.c_str());
             {
-                [[maybe_unused]] std::conditional_t<with_state, StateType, int> state{func()};
+                std::conditional_t<with_state, StateType, int> state{func()};
                 while (!stop_token.stop_requested()) {
                     Task task;
                     {

src/common/threadsafe_queue.h

@@ -46,13 +46,15 @@ public:
         ElementPtr* new_ptr = new ElementPtr();
         write_ptr->next.store(new_ptr, std::memory_order_release);
         write_ptr = new_ptr;
-        ++size;
 
-        // cv_mutex must be held or else there will be a missed wakeup if the other thread is in the
-        // line before cv.wait
+        const size_t previous_size{size++};
+
+        // Acquire the mutex and then immediately release it as a fence.
         // TODO(bunnei): This can be replaced with C++20 waitable atomics when properly supported.
         // See discussion on https://github.com/yuzu-emu/yuzu/pull/3173 for details.
-        std::lock_guard lock{cv_mutex};
+        if (previous_size == 0) {
+            std::lock_guard lock{cv_mutex};
+        }
         cv.notify_one();
     }
 

src/common/uuid.cpp

@@ -6,64 +6,10 @@
 
 #include <fmt/format.h>
 
-#include "common/assert.h"
 #include "common/uuid.h"
 
 namespace Common {
 
-namespace {
-
-bool IsHexDigit(char c) {
-    return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F');
-}
-
-u8 HexCharToByte(char c) {
-    if (c >= '0' && c <= '9') {
-        return static_cast<u8>(c - '0');
-    }
-    if (c >= 'a' && c <= 'f') {
-        return static_cast<u8>(c - 'a' + 10);
-    }
-    if (c >= 'A' && c <= 'F') {
-        return static_cast<u8>(c - 'A' + 10);
-    }
-    ASSERT_MSG(false, "{} is not a hexadecimal digit!", c);
-    return u8{0};
-}
-
-} // Anonymous namespace
-
-u128 HexStringToU128(std::string_view hex_string) {
-    const size_t length = hex_string.length();
-
-    // Detect "0x" prefix.
-    const bool has_0x_prefix = length > 2 && hex_string[0] == '0' && hex_string[1] == 'x';
-    const size_t offset = has_0x_prefix ? 2 : 0;
-
-    // Check length.
-    if (length > 32 + offset) {
-        ASSERT_MSG(false, "hex_string has more than 32 hexadecimal characters!");
-        return INVALID_UUID;
-    }
-
-    u64 lo = 0;
-    u64 hi = 0;
-    for (size_t i = 0; i < length - offset; ++i) {
-        const char c = hex_string[length - 1 - i];
-        if (!IsHexDigit(c)) {
-            ASSERT_MSG(false, "{} is not a hexadecimal digit!", c);
-            return INVALID_UUID;
-        }
-        if (i < 16) {
-            lo |= u64{HexCharToByte(c)} << (i * 4);
-        }
-        if (i >= 16) {
-            hi |= u64{HexCharToByte(c)} << ((i - 16) * 4);
-        }
-    }
-    return u128{lo, hi};
-}
-
 UUID UUID::Generate() {
     std::random_device device;
     std::mt19937 gen(device());
@@ -72,7 +18,7 @@ UUID UUID::Generate() {
 }
 
 std::string UUID::Format() const {
-    return fmt::format("{:016x}{:016x}", uuid[1], uuid[0]);
+    return fmt::format("0x{:016X}{:016X}", uuid[1], uuid[0]);
 }
 
 std::string UUID::FormatSwitch() const {

src/common/uuid.h

@@ -5,7 +5,6 @@
 #pragma once
 
 #include <string>
-#include <string_view>
 
 #include "common/common_types.h"
 
@@ -13,30 +12,12 @@ namespace Common {
 
 constexpr u128 INVALID_UUID{{0, 0}};
 
-/**
- * Converts a hex string to a 128-bit unsigned integer.
- *
- * The hex string can be formatted in lowercase or uppercase, with or without the "0x" prefix.
- *
- * This function will assert and return INVALID_UUID under the following conditions:
- * - If the hex string is more than 32 characters long
- * - If the hex string contains non-hexadecimal characters
- *
- * @param hex_string Hexadecimal string
- *
- * @returns A 128-bit unsigned integer if successfully converted, INVALID_UUID otherwise.
- */
-[[nodiscard]] u128 HexStringToU128(std::string_view hex_string);
-
 struct UUID {
     // UUIDs which are 0 are considered invalid!
     u128 uuid;
     UUID() = default;
     constexpr explicit UUID(const u128& id) : uuid{id} {}
     constexpr explicit UUID(const u64 lo, const u64 hi) : uuid{{lo, hi}} {}
-    explicit UUID(std::string_view hex_string) {
-        uuid = HexStringToU128(hex_string);
-    }
 
     [[nodiscard]] constexpr explicit operator bool() const {
         return uuid != INVALID_UUID;
@@ -69,14 +50,3 @@ struct UUID {
 static_assert(sizeof(UUID) == 16, "UUID is an invalid size!");
 
 } // namespace Common
-
-namespace std {
-
-template <>
-struct hash<Common::UUID> {
-    size_t operator()(const Common::UUID& uuid) const noexcept {
-        return uuid.uuid[1] ^ uuid.uuid[0];
-    }
-};
-
-} // namespace std

src/core/CMakeLists.txt

@@ -517,8 +517,6 @@ add_library(core STATIC
     hle/service/psc/psc.h
     hle/service/ptm/psm.cpp
     hle/service/ptm/psm.h
-    hle/service/kernel_helpers.cpp
-    hle/service/kernel_helpers.h
     hle/service/service.cpp
     hle/service/service.h
     hle/service/set/set.cpp

src/core/core.cpp

@@ -411,7 +411,7 @@ struct System::Impl {
     std::string status_details = "";
 
     std::unique_ptr<Core::PerfStats> perf_stats;
-    Core::SpeedLimiter speed_limiter;
+    Core::FrameLimiter frame_limiter;
 
     bool is_multicore{};
     bool is_async_gpu{};
@@ -606,12 +606,12 @@ const Core::PerfStats& System::GetPerfStats() const {
     return *impl->perf_stats;
 }
 
-Core::SpeedLimiter& System::SpeedLimiter() {
-    return impl->speed_limiter;
+Core::FrameLimiter& System::FrameLimiter() {
+    return impl->frame_limiter;
 }
 
-const Core::SpeedLimiter& System::SpeedLimiter() const {
-    return impl->speed_limiter;
+const Core::FrameLimiter& System::FrameLimiter() const {
+    return impl->frame_limiter;
 }
 
 Loader::ResultStatus System::GetGameName(std::string& out) const {

src/core/core.h

@@ -94,7 +94,7 @@ class ARM_Interface;
 class CpuManager;
 class DeviceMemory;
 class ExclusiveMonitor;
-class SpeedLimiter;
+class FrameLimiter;
 class PerfStats;
 class Reporter;
 class TelemetrySession;
@@ -292,11 +292,11 @@ public:
     /// Provides a constant reference to the internal PerfStats instance.
     [[nodiscard]] const Core::PerfStats& GetPerfStats() const;
 
-    /// Provides a reference to the speed limiter;
-    [[nodiscard]] Core::SpeedLimiter& SpeedLimiter();
+    /// Provides a reference to the frame limiter;
+    [[nodiscard]] Core::FrameLimiter& FrameLimiter();
 
-    /// Provides a constant reference to the speed limiter
-    [[nodiscard]] const Core::SpeedLimiter& SpeedLimiter() const;
+    /// Provides a constant referent to the frame limiter
+    [[nodiscard]] const Core::FrameLimiter& FrameLimiter() const;
 
     /// Gets the name of the current game
     [[nodiscard]] Loader::ResultStatus GetGameName(std::string& out) const;

src/core/hle/api_version.h

@@ -12,9 +12,9 @@ namespace HLE::ApiVersion {
 
 // Horizon OS version constants.
 
-constexpr u8 HOS_VERSION_MAJOR = 12;
-constexpr u8 HOS_VERSION_MINOR = 1;
-constexpr u8 HOS_VERSION_MICRO = 0;
+constexpr u8 HOS_VERSION_MAJOR = 11;
+constexpr u8 HOS_VERSION_MINOR = 0;
+constexpr u8 HOS_VERSION_MICRO = 1;
 
 // NintendoSDK version constants.
 
@@ -22,15 +22,15 @@ constexpr u8 SDK_REVISION_MAJOR = 1;
 constexpr u8 SDK_REVISION_MINOR = 0;
 
 constexpr char PLATFORM_STRING[] = "NX";
-constexpr char VERSION_HASH[] = "76b10c2dab7d3aa73fc162f8dff1655e6a21caf4";
-constexpr char DISPLAY_VERSION[] = "12.1.0";
-constexpr char DISPLAY_TITLE[] = "NintendoSDK Firmware for NX 12.1.0-1.0";
+constexpr char VERSION_HASH[] = "69103fcb2004dace877094c2f8c29e6113be5dbf";
+constexpr char DISPLAY_VERSION[] = "11.0.1";
+constexpr char DISPLAY_TITLE[] = "NintendoSDK Firmware for NX 11.0.1-1.0";
 
 // Atmosphere version constants.
 
 constexpr u8 ATMOSPHERE_RELEASE_VERSION_MAJOR = 0;
 constexpr u8 ATMOSPHERE_RELEASE_VERSION_MINOR = 19;
-constexpr u8 ATMOSPHERE_RELEASE_VERSION_MICRO = 5;
+constexpr u8 ATMOSPHERE_RELEASE_VERSION_MICRO = 4;
 
 constexpr u32 GetTargetFirmware() {
     return u32{HOS_VERSION_MAJOR} << 24 | u32{HOS_VERSION_MINOR} << 16 |

src/core/hle/kernel/hle_ipc.cpp

@@ -58,9 +58,6 @@ bool SessionRequestManager::HasSessionRequestHandler(const HLERequestContext& co
 
 void SessionRequestHandler::ClientConnected(KServerSession* session) {
     session->ClientConnected(shared_from_this());
-
-    // Ensure our server session is tracked globally.
-    kernel.RegisterServerSession(session);
 }
 
 void SessionRequestHandler::ClientDisconnected(KServerSession* session) {

src/core/hle/kernel/k_auto_object.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include "core/hle/kernel/k_auto_object.h"
-#include "core/hle/kernel/kernel.h"
 
 namespace Kernel {
 
@@ -12,12 +11,4 @@ KAutoObject* KAutoObject::Create(KAutoObject* obj) {
     return obj;
 }
 
-void KAutoObject::RegisterWithKernel() {
-    kernel.RegisterKernelObject(this);
-}
-
-void KAutoObject::UnregisterWithKernel() {
-    kernel.UnregisterKernelObject(this);
-}
-
 } // namespace Kernel

src/core/hle/kernel/k_auto_object.h

@@ -85,12 +85,8 @@ private:
     KERNEL_AUTOOBJECT_TRAITS(KAutoObject, KAutoObject);
 
 public:
-    explicit KAutoObject(KernelCore& kernel_) : kernel(kernel_) {
-        RegisterWithKernel();
-    }
-    virtual ~KAutoObject() {
-        UnregisterWithKernel();
-    }
+    explicit KAutoObject(KernelCore& kernel_) : kernel(kernel_) {}
+    virtual ~KAutoObject() = default;
 
     static KAutoObject* Create(KAutoObject* ptr);
 
@@ -170,10 +166,6 @@ public:
         }
     }
 
-private:
-    void RegisterWithKernel();
-    void UnregisterWithKernel();
-
 protected:
     KernelCore& kernel;
     std::string name;

src/core/hle/kernel/k_process.cpp

@@ -10,7 +10,6 @@
 #include "common/alignment.h"
 #include "common/assert.h"
 #include "common/logging/log.h"
-#include "common/scope_exit.h"
 #include "common/settings.h"
 #include "core/core.h"
 #include "core/device_memory.h"
@@ -44,8 +43,6 @@ void SetupMainThread(Core::System& system, KProcess& owner_process, u32 priority
     ASSERT(owner_process.GetResourceLimit()->Reserve(LimitableResource::Threads, 1));
 
     KThread* thread = KThread::Create(system.Kernel());
-    SCOPE_EXIT({ thread->Close(); });
-
     ASSERT(KThread::InitializeUserThread(system, thread, entry_point, 0, stack_top, priority,
                                          owner_process.GetIdealCoreId(), &owner_process)
                .IsSuccess());
@@ -165,7 +162,7 @@ void KProcess::DecrementThreadCount() {
     ASSERT(num_threads > 0);
 
     if (const auto count = --num_threads; count == 0) {
-        LOG_WARNING(Kernel, "Process termination is not fully implemented.");
+        UNIMPLEMENTED_MSG("Process termination is not implemented!");
     }
 }
 
@@ -409,9 +406,6 @@ void KProcess::Finalize() {
         resource_limit->Close();
     }
 
-    // Finalize the handle table and close any open handles.
-    handle_table.Finalize();
-
     // Perform inherited finalization.
     KAutoObjectWithSlabHeapAndContainer<KProcess, KSynchronizationObject>::Finalize();
 }

src/core/hle/kernel/k_server_session.cpp

@@ -28,10 +28,7 @@ namespace Kernel {
 
 KServerSession::KServerSession(KernelCore& kernel_) : KSynchronizationObject{kernel_} {}
 
-KServerSession::~KServerSession() {
-    // Ensure that the global list tracking server sessions does not hold on to a reference.
-    kernel.UnregisterServerSession(this);
-}
+KServerSession::~KServerSession() {}
 
 void KServerSession::Initialize(KSession* parent_session_, std::string&& name_,
                                 std::shared_ptr<SessionRequestManager> manager_) {

src/core/hle/kernel/kernel.cpp

@@ -61,7 +61,6 @@ struct KernelCore::Impl {
     void Initialize(KernelCore& kernel) {
         global_scheduler_context = std::make_unique<Kernel::GlobalSchedulerContext>(kernel);
         global_handle_table = std::make_unique<Kernel::KHandleTable>(kernel);
-        global_handle_table->Initialize(KHandleTable::MaxTableSize);
 
         is_phantom_mode_for_singlecore = false;
 
@@ -91,39 +90,9 @@ struct KernelCore::Impl {
     }
 
     void Shutdown() {
-        // Shutdown all processes.
-        if (current_process) {
-            current_process->Finalize();
-            current_process->Close();
-            current_process = nullptr;
-        }
         process_list.clear();
 
-        // Close all open server ports.
-        std::unordered_set<KServerPort*> server_ports_;
-        {
-            std::lock_guard lk(server_ports_lock);
-            server_ports_ = server_ports;
-            server_ports.clear();
-        }
-        for (auto* server_port : server_ports_) {
-            server_port->Close();
-        }
-        // Close all open server sessions.
-        std::unordered_set<KServerSession*> server_sessions_;
-        {
-            std::lock_guard lk(server_sessions_lock);
-            server_sessions_ = server_sessions;
-            server_sessions.clear();
-        }
-        for (auto* server_session : server_sessions_) {
-            server_session->Close();
-        }
-
-        // Ensure that the object list container is finalized and properly shutdown.
-        object_list_container.Finalize();
-
-        // Ensures all service threads gracefully shutdown.
+        // Ensures all service threads gracefully shutdown
         service_threads.clear();
 
         next_object_id = 0;
@@ -142,7 +111,11 @@ struct KernelCore::Impl {
 
         cores.clear();
 
-        global_handle_table->Finalize();
+        if (current_process) {
+            current_process->Close();
+            current_process = nullptr;
+        }
+
         global_handle_table.reset();
 
         preemption_event = nullptr;
@@ -169,16 +142,6 @@ struct KernelCore::Impl {
 
         // Next host thead ID to use, 0-3 IDs represent core threads, >3 represent others
         next_host_thread_id = Core::Hardware::NUM_CPU_CORES;
-
-        // Track kernel objects that were not freed on shutdown
-        {
-            std::lock_guard lk(registered_objects_lock);
-            if (registered_objects.size()) {
-                LOG_WARNING(Kernel, "{} kernel objects were dangling on shutdown!",
-                            registered_objects.size());
-                registered_objects.clear();
-            }
-        }
     }
 
     void InitializePhysicalCores() {
@@ -267,23 +230,20 @@ struct KernelCore::Impl {
         }
     }
 
-    static inline thread_local u32 host_thread_id = UINT32_MAX;
-
-    /// Gets the host thread ID for the caller, allocating a new one if this is the first time
-    u32 GetHostThreadId(std::size_t core_id) {
-        if (host_thread_id == UINT32_MAX) {
-            // The first four slots are reserved for CPU core threads
-            ASSERT(core_id < Core::Hardware::NUM_CPU_CORES);
-            host_thread_id = static_cast<u32>(core_id);
+    /// Creates a new host thread ID, should only be called by GetHostThreadId
+    u32 AllocateHostThreadId(std::optional<std::size_t> core_id) {
+        if (core_id) {
+            // The first for slots are reserved for CPU core threads
+            ASSERT(*core_id < Core::Hardware::NUM_CPU_CORES);
+            return static_cast<u32>(*core_id);
+        } else {
+            return next_host_thread_id++;
         }
-        return host_thread_id;
     }
 
     /// Gets the host thread ID for the caller, allocating a new one if this is the first time
-    u32 GetHostThreadId() {
-        if (host_thread_id == UINT32_MAX) {
-            host_thread_id = next_host_thread_id++;
-        }
+    u32 GetHostThreadId(std::optional<std::size_t> core_id = std::nullopt) {
+        const thread_local auto host_thread_id{AllocateHostThreadId(core_id)};
         return host_thread_id;
     }
 
@@ -670,21 +630,6 @@ struct KernelCore::Impl {
             user_slab_heap_size);
     }
 
-    KClientPort* CreateNamedServicePort(std::string name) {
-        auto search = service_interface_factory.find(name);
-        if (search == service_interface_factory.end()) {
-            UNIMPLEMENTED();
-            return {};
-        }
-
-        KClientPort* port = &search->second(system.ServiceManager(), system);
-        {
-            std::lock_guard lk(server_ports_lock);
-            server_ports.insert(&port->GetParent()->GetServerPort());
-        }
-        return port;
-    }
-
     std::atomic<u32> next_object_id{0};
     std::atomic<u64> next_kernel_process_id{KProcess::InitialKIPIDMin};
     std::atomic<u64> next_user_process_id{KProcess::ProcessIDMin};
@@ -711,12 +656,6 @@ struct KernelCore::Impl {
     /// the ConnectToPort SVC.
     std::unordered_map<std::string, ServiceInterfaceFactory> service_interface_factory;
     NamedPortTable named_ports;
-    std::unordered_set<KServerPort*> server_ports;
-    std::unordered_set<KServerSession*> server_sessions;
-    std::unordered_set<KAutoObject*> registered_objects;
-    std::mutex server_ports_lock;
-    std::mutex server_sessions_lock;
-    std::mutex registered_objects_lock;
 
     std::unique_ptr<Core::ExclusiveMonitor> exclusive_monitor;
     std::vector<Kernel::PhysicalCore> cores;
@@ -905,27 +844,12 @@ void KernelCore::RegisterNamedService(std::string name, ServiceInterfaceFactory&
 }
 
 KClientPort* KernelCore::CreateNamedServicePort(std::string name) {
-    return impl->CreateNamedServicePort(std::move(name));
-}
-
-void KernelCore::RegisterServerSession(KServerSession* server_session) {
-    std::lock_guard lk(impl->server_sessions_lock);
-    impl->server_sessions.insert(server_session);
-}
-
-void KernelCore::UnregisterServerSession(KServerSession* server_session) {
-    std::lock_guard lk(impl->server_sessions_lock);
-    impl->server_sessions.erase(server_session);
-}
-
-void KernelCore::RegisterKernelObject(KAutoObject* object) {
-    std::lock_guard lk(impl->registered_objects_lock);
-    impl->registered_objects.insert(object);
-}
-
-void KernelCore::UnregisterKernelObject(KAutoObject* object) {
-    std::lock_guard lk(impl->registered_objects_lock);
-    impl->registered_objects.erase(object);
+    auto search = impl->service_interface_factory.find(name);
+    if (search == impl->service_interface_factory.end()) {
+        UNIMPLEMENTED();
+        return {};
+    }
+    return &search->second(impl->system.ServiceManager(), impl->system);
 }
 
 bool KernelCore::IsValidNamedPort(NamedPortTable::const_iterator port) const {

src/core/hle/kernel/kernel.h

@@ -45,7 +45,6 @@ class KPort;
 class KProcess;
 class KResourceLimit;
 class KScheduler;
-class KServerSession;
 class KSession;
 class KSharedMemory;
 class KThread;
@@ -186,22 +185,6 @@ public:
     /// Opens a port to a service previously registered with RegisterNamedService.
     KClientPort* CreateNamedServicePort(std::string name);
 
-    /// Registers a server session with the gobal emulation state, to be freed on shutdown. This is
-    /// necessary because we do not emulate processes for HLE sessions.
-    void RegisterServerSession(KServerSession* server_session);
-
-    /// Unregisters a server session previously registered with RegisterServerSession when it was
-    /// destroyed during the current emulation session.
-    void UnregisterServerSession(KServerSession* server_session);
-
-    /// Registers all kernel objects with the global emulation state, this is purely for tracking
-    /// leaks after emulation has been shutdown.
-    void RegisterKernelObject(KAutoObject* object);
-
-    /// Unregisters a kernel object previously registered with RegisterKernelObject when it was
-    /// destroyed during the current emulation session.
-    void UnregisterKernelObject(KAutoObject* object);
-
     /// Determines whether or not the given port is a valid named port.
     bool IsValidNamedPort(NamedPortTable::const_iterator port) const;
 

src/core/hle/kernel/svc.cpp

@@ -298,7 +298,6 @@ static ResultCode ConnectToNamedPort(Core::System& system, Handle* out, VAddr po
     // Create a session.
     KClientSession* session{};
     R_TRY(port->CreateSession(std::addressof(session)));
-    port->Close();
 
     // Register the session in the table, close the extra reference.
     handle_table.Register(*out, session);
@@ -1440,6 +1439,11 @@ static void ExitProcess(Core::System& system) {
     LOG_INFO(Kernel_SVC, "Process {} exiting", current_process->GetProcessID());
     ASSERT_MSG(current_process->GetStatus() == ProcessStatus::Running,
                "Process has already exited");
+
+    current_process->PrepareForTermination();
+
+    // Kill the current thread
+    system.Kernel().CurrentScheduler()->GetCurrentThread()->Exit();
 }
 
 static void ExitProcess32(Core::System& system) {

src/core/hle/service/acc/acc.cpp

@@ -292,7 +292,7 @@ public:
 
 protected:
     void Get(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_ACC, "called user_id=0x{}", user_id.Format());
+        LOG_DEBUG(Service_ACC, "called user_id={}", user_id.Format());
         ProfileBase profile_base{};
         ProfileData data{};
         if (profile_manager.GetProfileBaseAndData(user_id, profile_base, data)) {
@@ -301,7 +301,7 @@ protected:
             rb.Push(ResultSuccess);
             rb.PushRaw(profile_base);
         } else {
-            LOG_ERROR(Service_ACC, "Failed to get profile base and data for user=0x{}",
+            LOG_ERROR(Service_ACC, "Failed to get profile base and data for user={}",
                       user_id.Format());
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ResultUnknown); // TODO(ogniK): Get actual error code
@@ -309,14 +309,14 @@ protected:
     }
 
     void GetBase(Kernel::HLERequestContext& ctx) {
-        LOG_DEBUG(Service_ACC, "called user_id=0x{}", user_id.Format());
+        LOG_DEBUG(Service_ACC, "called user_id={}", user_id.Format());
         ProfileBase profile_base{};
         if (profile_manager.GetProfileBase(user_id, profile_base)) {
             IPC::ResponseBuilder rb{ctx, 16};
             rb.Push(ResultSuccess);
             rb.PushRaw(profile_base);
         } else {
-            LOG_ERROR(Service_ACC, "Failed to get profile base for user=0x{}", user_id.Format());
+            LOG_ERROR(Service_ACC, "Failed to get profile base for user={}", user_id.Format());
             IPC::ResponseBuilder rb{ctx, 2};
             rb.Push(ResultUnknown); // TODO(ogniK): Get actual error code
         }
@@ -372,7 +372,7 @@ protected:
 
         const auto user_data = ctx.ReadBuffer();
 
-        LOG_DEBUG(Service_ACC, "called, username='{}', timestamp={:016X}, uuid=0x{}",
+        LOG_DEBUG(Service_ACC, "called, username='{}', timestamp={:016X}, uuid={}",
                   Common::StringFromFixedZeroTerminatedBuffer(
                       reinterpret_cast<const char*>(base.username.data()), base.username.size()),
                   base.timestamp, base.user_uuid.Format());
@@ -405,7 +405,7 @@ protected:
         const auto user_data = ctx.ReadBuffer();
         const auto image_data = ctx.ReadBuffer(1);
 
-        LOG_DEBUG(Service_ACC, "called, username='{}', timestamp={:016X}, uuid=0x{}",
+        LOG_DEBUG(Service_ACC, "called, username='{}', timestamp={:016X}, uuid={}",
                   Common::StringFromFixedZeroTerminatedBuffer(
                       reinterpret_cast<const char*>(base.username.data()), base.username.size()),
                   base.timestamp, base.user_uuid.Format());
@@ -662,7 +662,7 @@ void Module::Interface::GetUserCount(Kernel::HLERequestContext& ctx) {
 void Module::Interface::GetUserExistence(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     Common::UUID user_id = rp.PopRaw<Common::UUID>();
-    LOG_DEBUG(Service_ACC, "called user_id=0x{}", user_id.Format());
+    LOG_DEBUG(Service_ACC, "called user_id={}", user_id.Format());
 
     IPC::ResponseBuilder rb{ctx, 3};
     rb.Push(ResultSuccess);
@@ -693,7 +693,7 @@ void Module::Interface::GetLastOpenedUser(Kernel::HLERequestContext& ctx) {
 void Module::Interface::GetProfile(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     Common::UUID user_id = rp.PopRaw<Common::UUID>();
-    LOG_DEBUG(Service_ACC, "called user_id=0x{}", user_id.Format());
+    LOG_DEBUG(Service_ACC, "called user_id={}", user_id.Format());
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
@@ -802,7 +802,7 @@ void Module::Interface::GetProfileEditor(Kernel::HLERequestContext& ctx) {
     IPC::RequestParser rp{ctx};
     Common::UUID user_id = rp.PopRaw<Common::UUID>();
 
-    LOG_DEBUG(Service_ACC, "called, user_id=0x{}", user_id.Format());
+    LOG_DEBUG(Service_ACC, "called, user_id={}", user_id.Format());
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);
@@ -844,7 +844,7 @@ void Module::Interface::StoreSaveDataThumbnailApplication(Kernel::HLERequestCont
     IPC::RequestParser rp{ctx};
     const auto uuid = rp.PopRaw<Common::UUID>();
 
-    LOG_WARNING(Service_ACC, "(STUBBED) called, uuid=0x{}", uuid.Format());
+    LOG_WARNING(Service_ACC, "(STUBBED) called, uuid={}", uuid.Format());
 
     // TODO(ogniK): Check if application ID is zero on acc initialize. As we don't have a reliable
     // way of confirming things like the TID, we're going to assume a non zero value for the time
@@ -858,7 +858,7 @@ void Module::Interface::StoreSaveDataThumbnailSystem(Kernel::HLERequestContext&
     const auto uuid = rp.PopRaw<Common::UUID>();
     const auto tid = rp.Pop<u64_le>();
 
-    LOG_WARNING(Service_ACC, "(STUBBED) called, uuid=0x{}, tid={:016X}", uuid.Format(), tid);
+    LOG_WARNING(Service_ACC, "(STUBBED) called, uuid={}, tid={:016X}", uuid.Format(), tid);
     StoreSaveDataThumbnail(ctx, uuid, tid);
 }
 

src/core/hle/service/am/applets/applet_controller.cpp

@@ -87,10 +87,6 @@ void Controller::Initialize() {
         case sizeof(ControllerUpdateFirmwareArg):
             controller_private_arg.mode = ControllerSupportMode::ShowControllerFirmwareUpdate;
             break;
-        case sizeof(ControllerKeyRemappingArg):
-            controller_private_arg.mode =
-                ControllerSupportMode::ShowControllerKeyRemappingForSystem;
-            break;
         default:
             UNIMPLEMENTED_MSG("Unknown ControllerPrivateArg mode={} with arg_size={}",
                               controller_private_arg.mode, controller_private_arg.arg_size);
@@ -103,9 +99,7 @@ void Controller::Initialize() {
     // This is always 0 (Application) except with ShowControllerFirmwareUpdateForSystem.
     if (controller_private_arg.caller >= ControllerSupportCaller::MaxControllerSupportCaller) {
         if (controller_private_arg.flag_1 &&
-            (controller_private_arg.mode == ControllerSupportMode::ShowControllerFirmwareUpdate ||
-             controller_private_arg.mode ==
-                 ControllerSupportMode::ShowControllerKeyRemappingForSystem)) {
+            controller_private_arg.mode == ControllerSupportMode::ShowControllerFirmwareUpdate) {
             controller_private_arg.caller = ControllerSupportCaller::System;
         } else {
             controller_private_arg.caller = ControllerSupportCaller::Application;
@@ -127,7 +121,6 @@ void Controller::Initialize() {
             std::memcpy(&controller_user_arg_old, user_arg.data(), user_arg.size());
             break;
         case ControllerAppletVersion::Version7:
-        case ControllerAppletVersion::Version8:
             ASSERT(user_arg.size() == sizeof(ControllerSupportArgNew));
             std::memcpy(&controller_user_arg_new, user_arg.data(), user_arg.size());
             break;
@@ -150,16 +143,6 @@ void Controller::Initialize() {
         std::memcpy(&controller_update_arg, update_arg.data(), update_arg.size());
         break;
     }
-    case ControllerSupportMode::ShowControllerKeyRemappingForSystem: {
-        const auto remapping_arg_storage = broker.PopNormalDataToApplet();
-        ASSERT(remapping_arg_storage != nullptr);
-
-        const auto& remapping_arg = remapping_arg_storage->GetData();
-        ASSERT(remapping_arg.size() == sizeof(ControllerKeyRemappingArg));
-
-        std::memcpy(&controller_key_remapping_arg, remapping_arg.data(), remapping_arg.size());
-        break;
-    }
     default: {
         UNIMPLEMENTED_MSG("Unimplemented ControllerSupportMode={}", controller_private_arg.mode);
         break;
@@ -196,7 +179,6 @@ void Controller::Execute() {
                     std::vector<ExplainText>(controller_user_arg_old.explain_text.begin(),
                                              controller_user_arg_old.explain_text.end()));
             case ControllerAppletVersion::Version7:
-            case ControllerAppletVersion::Version8:
             default:
                 return ConvertToFrontendParameters(
                     controller_private_arg, controller_user_arg_new.header,
@@ -228,7 +210,6 @@ void Controller::Execute() {
     }
     case ControllerSupportMode::ShowControllerStrapGuide:
     case ControllerSupportMode::ShowControllerFirmwareUpdate:
-    case ControllerSupportMode::ShowControllerKeyRemappingForSystem:
         UNIMPLEMENTED_MSG("ControllerSupportMode={} is not implemented",
                           controller_private_arg.mode);
         ConfigurationComplete();

src/core/hle/service/am/applets/applet_controller.h

@@ -25,15 +25,13 @@ enum class ControllerAppletVersion : u32_le {
     Version3 = 0x3, // 1.0.0 - 2.3.0
     Version4 = 0x4, // 3.0.0 - 5.1.0
     Version5 = 0x5, // 6.0.0 - 7.0.1
-    Version7 = 0x7, // 8.0.0 - 10.2.0
-    Version8 = 0x8, // 11.0.0+
+    Version7 = 0x7, // 8.0.0+
 };
 
 enum class ControllerSupportMode : u8 {
     ShowControllerSupport,
     ShowControllerStrapGuide,
     ShowControllerFirmwareUpdate,
-    ShowControllerKeyRemappingForSystem,
 
     MaxControllerSupportMode,
 };
@@ -80,7 +78,7 @@ struct ControllerSupportArgOld {
 static_assert(sizeof(ControllerSupportArgOld) == 0x21C,
               "ControllerSupportArgOld has incorrect size.");
 
-// LibraryAppletVersion 0x7, 0x8
+// LibraryAppletVersion 0x7
 struct ControllerSupportArgNew {
     ControllerSupportArgHeader header{};
     std::array<IdentificationColor, 8> identification_colors{};
@@ -97,14 +95,6 @@ struct ControllerUpdateFirmwareArg {
 static_assert(sizeof(ControllerUpdateFirmwareArg) == 0x4,
               "ControllerUpdateFirmwareArg has incorrect size.");
 
-struct ControllerKeyRemappingArg {
-    u64 unknown{};
-    u32 unknown_2{};
-    INSERT_PADDING_WORDS(1);
-};
-static_assert(sizeof(ControllerKeyRemappingArg) == 0x10,
-              "ControllerKeyRemappingArg has incorrect size.");
-
 struct ControllerSupportResultInfo {
     s8 player_count{};
     INSERT_PADDING_BYTES(3);
@@ -138,7 +128,6 @@ private:
     ControllerSupportArgOld controller_user_arg_old;
     ControllerSupportArgNew controller_user_arg_new;
     ControllerUpdateFirmwareArg controller_update_arg;
-    ControllerKeyRemappingArg controller_key_remapping_arg;
     bool complete{false};
     ResultCode status{ResultSuccess};
     bool is_single_mode{false};

src/core/hle/service/am/applets/applet_software_keyboard.cpp

@@ -377,8 +377,7 @@ void SoftwareKeyboard::SubmitForTextCheck(std::u16string submitted_text) {
 
     if (swkbd_config_common.use_utf8) {
         std::string utf8_submitted_text = Common::UTF16ToUTF8(current_text);
-        // Include the null terminator in the buffer size.
-        const u64 buffer_size = utf8_submitted_text.size() + 1;
+        const u64 buffer_size = sizeof(u64) + utf8_submitted_text.size();
 
         LOG_DEBUG(Service_AM, "\nBuffer Size: {}\nUTF-8 Submitted Text: {}", buffer_size,
                   utf8_submitted_text);
@@ -387,8 +386,7 @@ void SoftwareKeyboard::SubmitForTextCheck(std::u16string submitted_text) {
         std::memcpy(out_data.data() + sizeof(u64), utf8_submitted_text.data(),
                     utf8_submitted_text.size());
     } else {
-        // Include the null terminator in the buffer size.
-        const u64 buffer_size = (current_text.size() + 1) * sizeof(char16_t);
+        const u64 buffer_size = sizeof(u64) + current_text.size() * sizeof(char16_t);
 
         LOG_DEBUG(Service_AM, "\nBuffer Size: {}\nUTF-16 Submitted Text: {}", buffer_size,
                   Common::UTF16ToUTF8(current_text));

src/core/hle/service/friend/friend.cpp

@@ -158,7 +158,7 @@ private:
         const auto local_play = rp.Pop<bool>();
         const auto uuid = rp.PopRaw<Common::UUID>();
 
-        LOG_WARNING(Service_Friend, "(STUBBED) called, local_play={}, uuid=0x{}", local_play,
+        LOG_WARNING(Service_Friend, "(STUBBED) called local_play={} uuid={}", local_play,
                     uuid.Format());
 
         IPC::ResponseBuilder rb{ctx, 2};
@@ -171,7 +171,7 @@ private:
         const auto uuid = rp.PopRaw<Common::UUID>();
         [[maybe_unused]] const auto filter = rp.PopRaw<SizedFriendFilter>();
         const auto pid = rp.Pop<u64>();
-        LOG_WARNING(Service_Friend, "(STUBBED) called, offset={}, uuid=0x{}, pid={}", friend_offset,
+        LOG_WARNING(Service_Friend, "(STUBBED) called, offset={}, uuid={}, pid={}", friend_offset,
                     uuid.Format(), pid);
 
         IPC::ResponseBuilder rb{ctx, 3};
@@ -289,7 +289,7 @@ void Module::Interface::CreateNotificationService(Kernel::HLERequestContext& ctx
     IPC::RequestParser rp{ctx};
     auto uuid = rp.PopRaw<Common::UUID>();
 
-    LOG_DEBUG(Service_Friend, "called, uuid=0x{}", uuid.Format());
+    LOG_DEBUG(Service_Friend, "called, uuid={}", uuid.Format());
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};
     rb.Push(ResultSuccess);

src/core/hle/service/hid/controllers/npad.cpp

@@ -18,7 +18,6 @@
 #include "core/hle/kernel/k_writable_event.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/service/hid/controllers/npad.h"
-#include "core/hle/service/kernel_helpers.h"
 
 namespace Service::HID {
 constexpr s32 HID_JOYSTICK_MAX = 0x7fff;
@@ -148,9 +147,7 @@ bool Controller_NPad::IsDeviceHandleValid(const DeviceHandle& device_handle) {
            device_handle.device_index < DeviceIndex::MaxDeviceIndex;
 }
 
-Controller_NPad::Controller_NPad(Core::System& system_,
-                                 KernelHelpers::ServiceContext& service_context_)
-    : ControllerBase{system_}, service_context{service_context_} {
+Controller_NPad::Controller_NPad(Core::System& system_) : ControllerBase{system_} {
     latest_vibration_values.fill({DEFAULT_VIBRATION_VALUE, DEFAULT_VIBRATION_VALUE});
 }
 
@@ -254,9 +251,10 @@ void Controller_NPad::InitNewlyAddedController(std::size_t controller_idx) {
 }
 
 void Controller_NPad::OnInit() {
+    auto& kernel = system.Kernel();
     for (std::size_t i = 0; i < styleset_changed_events.size(); ++i) {
-        styleset_changed_events[i] =
-            service_context.CreateEvent(fmt::format("npad:NpadStyleSetChanged_{}", i));
+        styleset_changed_events[i] = Kernel::KEvent::Create(kernel);
+        styleset_changed_events[i]->Initialize(fmt::format("npad:NpadStyleSetChanged_{}", i));
     }
 
     if (!IsControllerActivated()) {
@@ -346,7 +344,8 @@ void Controller_NPad::OnRelease() {
     }
 
     for (std::size_t i = 0; i < styleset_changed_events.size(); ++i) {
-        service_context.CloseEvent(styleset_changed_events[i]);
+        styleset_changed_events[i]->Close();
+        styleset_changed_events[i] = nullptr;
     }
 }
 

src/core/hle/service/hid/controllers/npad.h

@@ -20,10 +20,6 @@ class KEvent;
 class KReadableEvent;
 } // namespace Kernel
 
-namespace Service::KernelHelpers {
-class ServiceContext;
-}
-
 namespace Service::HID {
 
 constexpr u32 NPAD_HANDHELD = 32;
@@ -31,8 +27,7 @@ constexpr u32 NPAD_UNKNOWN = 16; // TODO(ogniK): What is this?
 
 class Controller_NPad final : public ControllerBase {
 public:
-    explicit Controller_NPad(Core::System& system_,
-                             KernelHelpers::ServiceContext& service_context_);
+    explicit Controller_NPad(Core::System& system_);
     ~Controller_NPad() override;
 
     // Called when the controller is initialized
@@ -571,7 +566,6 @@ private:
         std::array<std::unique_ptr<Input::MotionDevice>, Settings::NativeMotion::NUM_MOTIONS_HID>,
         10>;
 
-    KernelHelpers::ServiceContext& service_context;
     std::mutex mutex;
     ButtonArray buttons;
     StickArray sticks;

src/core/hle/service/hid/hid.cpp

@@ -46,9 +46,8 @@ constexpr auto pad_update_ns = std::chrono::nanoseconds{1000 * 1000};         //
 constexpr auto motion_update_ns = std::chrono::nanoseconds{15 * 1000 * 1000}; // (15ms, 66.666Hz)
 constexpr std::size_t SHARED_MEMORY_SIZE = 0x40000;
 
-IAppletResource::IAppletResource(Core::System& system_,
-                                 KernelHelpers::ServiceContext& service_context_)
-    : ServiceFramework{system_, "IAppletResource"}, service_context{service_context_} {
+IAppletResource::IAppletResource(Core::System& system_)
+    : ServiceFramework{system_, "IAppletResource"} {
     static const FunctionInfo functions[] = {
         {0, &IAppletResource::GetSharedMemoryHandle, "GetSharedMemoryHandle"},
     };
@@ -64,7 +63,7 @@ IAppletResource::IAppletResource(Core::System& system_,
     MakeController<Controller_Stubbed>(HidController::CaptureButton);
     MakeController<Controller_Stubbed>(HidController::InputDetector);
     MakeController<Controller_Stubbed>(HidController::UniquePad);
-    MakeControllerWithServiceContext<Controller_NPad>(HidController::NPad);
+    MakeController<Controller_NPad>(HidController::NPad);
     MakeController<Controller_Gesture>(HidController::Gesture);
     MakeController<Controller_ConsoleSixAxis>(HidController::ConsoleSixAxisSensor);
 
@@ -192,14 +191,13 @@ private:
 
 std::shared_ptr<IAppletResource> Hid::GetAppletResource() {
     if (applet_resource == nullptr) {
-        applet_resource = std::make_shared<IAppletResource>(system, service_context);
+        applet_resource = std::make_shared<IAppletResource>(system);
     }
 
     return applet_resource;
 }
 
-Hid::Hid(Core::System& system_)
-    : ServiceFramework{system_, "hid"}, service_context{system_, service_name} {
+Hid::Hid(Core::System& system_) : ServiceFramework{system_, "hid"} {
     // clang-format off
     static const FunctionInfo functions[] = {
         {0, &Hid::CreateAppletResource, "CreateAppletResource"},
@@ -349,7 +347,7 @@ void Hid::CreateAppletResource(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_HID, "called, applet_resource_user_id={}", applet_resource_user_id);
 
     if (applet_resource == nullptr) {
-        applet_resource = std::make_shared<IAppletResource>(system, service_context);
+        applet_resource = std::make_shared<IAppletResource>(system);
     }
 
     IPC::ResponseBuilder rb{ctx, 2, 0, 1};

src/core/hle/service/hid/hid.h

@@ -7,7 +7,6 @@
 #include <chrono>
 
 #include "core/hle/service/hid/controllers/controller_base.h"
-#include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/service.h"
 
 namespace Core::Timing {
@@ -40,8 +39,7 @@ enum class HidController : std::size_t {
 
 class IAppletResource final : public ServiceFramework<IAppletResource> {
 public:
-    explicit IAppletResource(Core::System& system_,
-                             KernelHelpers::ServiceContext& service_context_);
+    explicit IAppletResource(Core::System& system_);
     ~IAppletResource() override;
 
     void ActivateController(HidController controller);
@@ -62,18 +60,11 @@ private:
     void MakeController(HidController controller) {
         controllers[static_cast<std::size_t>(controller)] = std::make_unique<T>(system);
     }
-    template <typename T>
-    void MakeControllerWithServiceContext(HidController controller) {
-        controllers[static_cast<std::size_t>(controller)] =
-            std::make_unique<T>(system, service_context);
-    }
 
     void GetSharedMemoryHandle(Kernel::HLERequestContext& ctx);
     void UpdateControllers(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
     void UpdateMotion(std::uintptr_t user_data, std::chrono::nanoseconds ns_late);
 
-    KernelHelpers::ServiceContext& service_context;
-
     std::shared_ptr<Core::Timing::EventType> pad_update_event;
     std::shared_ptr<Core::Timing::EventType> motion_update_event;
 
@@ -185,8 +176,6 @@ private:
     static_assert(sizeof(VibrationDeviceInfo) == 0x8, "VibrationDeviceInfo has incorrect size.");
 
     std::shared_ptr<IAppletResource> applet_resource;
-
-    KernelHelpers::ServiceContext service_context;
 };
 
 /// Reload input devices. Used when input configuration changed

src/core/hle/service/kernel_helpers.cpp

@@ -1,62 +0,0 @@
-// Copyright 2021 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "core/core.h"
-#include "core/hle/kernel/k_event.h"
-#include "core/hle/kernel/k_process.h"
-#include "core/hle/kernel/k_readable_event.h"
-#include "core/hle/kernel/k_resource_limit.h"
-#include "core/hle/kernel/k_scoped_resource_reservation.h"
-#include "core/hle/kernel/k_writable_event.h"
-#include "core/hle/service/kernel_helpers.h"
-
-namespace Service::KernelHelpers {
-
-ServiceContext::ServiceContext(Core::System& system_, std::string name_)
-    : kernel(system_.Kernel()) {
-    process = Kernel::KProcess::Create(kernel);
-    ASSERT(Kernel::KProcess::Initialize(process, system_, std::move(name_),
-                                        Kernel::KProcess::ProcessType::Userland)
-               .IsSuccess());
-}
-
-ServiceContext::~ServiceContext() {
-    process->Close();
-    process = nullptr;
-}
-
-Kernel::KEvent* ServiceContext::CreateEvent(std::string&& name) {
-    // Reserve a new event from the process resource limit
-    Kernel::KScopedResourceReservation event_reservation(process,
-                                                         Kernel::LimitableResource::Events);
-    if (!event_reservation.Succeeded()) {
-        LOG_CRITICAL(Service, "Resource limit reached!");
-        return {};
-    }
-
-    // Create a new event.
-    auto* event = Kernel::KEvent::Create(kernel);
-    if (!event) {
-        LOG_CRITICAL(Service, "Unable to create event!");
-        return {};
-    }
-
-    // Initialize the event.
-    event->Initialize(std::move(name));
-
-    // Commit the thread reservation.
-    event_reservation.Commit();
-
-    // Register the event.
-    Kernel::KEvent::Register(kernel, event);
-
-    return event;
-}
-
-void ServiceContext::CloseEvent(Kernel::KEvent* event) {
-    event->GetReadableEvent().Close();
-    event->GetWritableEvent().Close();
-}
-
-} // namespace Service::KernelHelpers

src/core/hle/service/kernel_helpers.h

@@ -1,35 +0,0 @@
-// Copyright 2021 yuzu emulator team
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-
-namespace Core {
-class System;
-}
-
-namespace Kernel {
-class KernelCore;
-class KEvent;
-class KProcess;
-} // namespace Kernel
-
-namespace Service::KernelHelpers {
-
-class ServiceContext {
-public:
-    ServiceContext(Core::System& system_, std::string name_);
-    ~ServiceContext();
-
-    Kernel::KEvent* CreateEvent(std::string&& name);
-
-    void CloseEvent(Kernel::KEvent* event);
-
-private:
-    Kernel::KernelCore& kernel;
-    Kernel::KProcess* process{};
-};
-
-} // namespace Service::KernelHelpers

src/core/hle/service/ns/language.cpp

@@ -339,16 +339,13 @@ std::optional<ApplicationLanguage> ConvertToApplicationLanguage(
     case Set::LanguageCode::FR_CA:
         return ApplicationLanguage::CanadianFrench;
     case Set::LanguageCode::PT:
-    case Set::LanguageCode::PT_BR:
         return ApplicationLanguage::Portuguese;
     case Set::LanguageCode::RU:
         return ApplicationLanguage::Russian;
     case Set::LanguageCode::KO:
         return ApplicationLanguage::Korean;
-    case Set::LanguageCode::ZH_TW:
     case Set::LanguageCode::ZH_HANT:
         return ApplicationLanguage::TraditionalChinese;
-    case Set::LanguageCode::ZH_CN:
     case Set::LanguageCode::ZH_HANS:
         return ApplicationLanguage::SimplifiedChinese;
     default:

src/core/hle/service/ns/ns_language.h

@@ -0,0 +1,42 @@
+// Copyright 2019 yuzu emulator team
+// Licensed under GPLv2 or any later version
+// Refer to the license.txt file included.
+
+#pragma once
+#include <optional>
+#include <string>
+#include "common/common_types.h"
+#include "core/hle/service/set/set.h"
+
+namespace Service::NS {
+/// This is nn::ns::detail::ApplicationLanguage
+enum class ApplicationLanguage : u8 {
+    AmericanEnglish = 0,
+    BritishEnglish,
+    Japanese,
+    French,
+    German,
+    LatinAmericanSpanish,
+    Spanish,
+    Italian,
+    Dutch,
+    CanadianFrench,
+    Portuguese,
+    Russian,
+    Korean,
+    TraditionalChinese,
+    SimplifiedChinese,
+    Count
+};
+using ApplicationLanguagePriorityList =
+    const std::array<ApplicationLanguage, static_cast<std::size_t>(ApplicationLanguage::Count)>;
+
+constexpr u32 GetSupportedLanguageFlag(const ApplicationLanguage lang) {
+    return 1U << static_cast<u32>(lang);
+}
+
+const ApplicationLanguagePriorityList* GetApplicationLanguagePriorityList(ApplicationLanguage lang);
+std::optional<ApplicationLanguage> ConvertToApplicationLanguage(
+    Service::Set::LanguageCode language_code);
+std::optional<Service::Set::LanguageCode> ConvertToLanguageCode(ApplicationLanguage lang);
+} // namespace Service::NS

src/core/hle/service/nvdrv/devices/nvdisp_disp0.cpp

@@ -54,7 +54,7 @@ void nvdisp_disp0::flip(u32 buffer_handle, u32 offset, u32 format, u32 width, u3
 
     system.GetPerfStats().EndSystemFrame();
     system.GPU().SwapBuffers(&framebuffer);
-    system.SpeedLimiter().DoSpeedLimiting(system.CoreTiming().GetGlobalTimeUs());
+    system.FrameLimiter().DoFrameLimiting(system.CoreTiming().GetGlobalTimeUs());
     system.GetPerfStats().BeginSystemFrame();
 }
 

src/core/hle/service/nvdrv/devices/nvhost_nvdec.cpp

@@ -68,6 +68,7 @@ void nvhost_nvdec::OnOpen(DeviceFD fd) {}
 void nvhost_nvdec::OnClose(DeviceFD fd) {
     LOG_INFO(Service_NVDRV, "NVDEC video stream ended");
     system.GPU().ClearCdmaInstance();
+    system.GPU().MemoryManager().InvalidateQueuedCaches();
 }
 
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.cpp

@@ -166,6 +166,8 @@ NvResult nvhost_nvdec_common::MapBuffer(const std::vector<u8>& input, std::vecto
             LOG_ERROR(Service_NVDRV, "failed to map size={}", object->size);
         } else {
             cmd_buffer.map_address = object->dma_map_addr;
+            AddBufferMap(object->dma_map_addr, object->size, object->addr,
+                         object->status == nvmap::Object::Status::Allocated);
         }
     }
     std::memcpy(output.data(), &params, sizeof(IoctlMapBuffer));
@@ -176,11 +178,36 @@ NvResult nvhost_nvdec_common::MapBuffer(const std::vector<u8>& input, std::vecto
 }
 
 NvResult nvhost_nvdec_common::UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output) {
-    // This is intntionally stubbed.
-    // Skip unmapping buffers here, as to not break the continuity of the VP9 reference frame
-    // addresses, and risk invalidating data before the async GPU thread is done with it
+    IoctlMapBuffer params{};
+    std::memcpy(&params, input.data(), sizeof(IoctlMapBuffer));
+    std::vector<MapBufferEntry> cmd_buffer_handles(params.num_entries);
+    SliceVectors(input, cmd_buffer_handles, params.num_entries, sizeof(IoctlMapBuffer));
+
+    auto& gpu = system.GPU();
+
+    for (auto& cmd_buffer : cmd_buffer_handles) {
+        const auto object{nvmap_dev->GetObject(cmd_buffer.map_handle)};
+        if (!object) {
+            LOG_ERROR(Service_NVDRV, "invalid cmd_buffer nvmap_handle={:X}", cmd_buffer.map_handle);
+            std::memcpy(output.data(), &params, output.size());
+            return NvResult::InvalidState;
+        }
+        if (const auto size{RemoveBufferMap(object->dma_map_addr)}; size) {
+            if (vic_device) {
+                // UnmapVicFrame defers texture_cache invalidation of the frame address until
+                // the stream is over
+                gpu.MemoryManager().UnmapVicFrame(object->dma_map_addr, *size);
+            } else {
+                gpu.MemoryManager().Unmap(object->dma_map_addr, *size);
+            }
+        } else {
+            // This occurs quite frequently, however does not seem to impact functionality
+            LOG_DEBUG(Service_NVDRV, "invalid offset=0x{:X} dma=0x{:X}", object->addr,
+                      object->dma_map_addr);
+        }
+        object->dma_map_addr = 0;
+    }
     std::memset(output.data(), 0, output.size());
-    LOG_DEBUG(Service_NVDRV, "(STUBBED) called");
     return NvResult::Success;
 }
 
@@ -191,4 +218,33 @@ NvResult nvhost_nvdec_common::SetSubmitTimeout(const std::vector<u8>& input,
     return NvResult::Success;
 }
 
+std::optional<nvhost_nvdec_common::BufferMap> nvhost_nvdec_common::FindBufferMap(
+    GPUVAddr gpu_addr) const {
+    const auto it = std::find_if(
+        buffer_mappings.begin(), buffer_mappings.upper_bound(gpu_addr), [&](const auto& entry) {
+            return (gpu_addr >= entry.second.StartAddr() && gpu_addr < entry.second.EndAddr());
+        });
+
+    ASSERT(it != buffer_mappings.end());
+    return it->second;
+}
+
+void nvhost_nvdec_common::AddBufferMap(GPUVAddr gpu_addr, std::size_t size, VAddr cpu_addr,
+                                       bool is_allocated) {
+    buffer_mappings.insert_or_assign(gpu_addr, BufferMap{gpu_addr, size, cpu_addr, is_allocated});
+}
+
+std::optional<std::size_t> nvhost_nvdec_common::RemoveBufferMap(GPUVAddr gpu_addr) {
+    const auto iter{buffer_mappings.find(gpu_addr)};
+    if (iter == buffer_mappings.end()) {
+        return std::nullopt;
+    }
+    std::size_t size = 0;
+    if (iter->second.IsAllocated()) {
+        size = iter->second.Size();
+    }
+    buffer_mappings.erase(iter);
+    return size;
+}
+
 } // namespace Service::Nvidia::Devices

src/core/hle/service/nvdrv/devices/nvhost_nvdec_common.h

@@ -23,6 +23,45 @@ public:
     ~nvhost_nvdec_common() override;
 
 protected:
+    class BufferMap final {
+    public:
+        constexpr BufferMap() = default;
+
+        constexpr BufferMap(GPUVAddr start_addr_, std::size_t size_)
+            : start_addr{start_addr_}, end_addr{start_addr_ + size_} {}
+
+        constexpr BufferMap(GPUVAddr start_addr_, std::size_t size_, VAddr cpu_addr_,
+                            bool is_allocated_)
+            : start_addr{start_addr_}, end_addr{start_addr_ + size_}, cpu_addr{cpu_addr_},
+              is_allocated{is_allocated_} {}
+
+        constexpr VAddr StartAddr() const {
+            return start_addr;
+        }
+
+        constexpr VAddr EndAddr() const {
+            return end_addr;
+        }
+
+        constexpr std::size_t Size() const {
+            return end_addr - start_addr;
+        }
+
+        constexpr VAddr CpuAddr() const {
+            return cpu_addr;
+        }
+
+        constexpr bool IsAllocated() const {
+            return is_allocated;
+        }
+
+    private:
+        GPUVAddr start_addr{};
+        GPUVAddr end_addr{};
+        VAddr cpu_addr{};
+        bool is_allocated{};
+    };
+
     struct IoctlSetNvmapFD {
         s32_le nvmap_fd{};
     };
@@ -115,11 +154,18 @@ protected:
     NvResult UnmapBuffer(const std::vector<u8>& input, std::vector<u8>& output);
     NvResult SetSubmitTimeout(const std::vector<u8>& input, std::vector<u8>& output);
 
+    std::optional<BufferMap> FindBufferMap(GPUVAddr gpu_addr) const;
+    void AddBufferMap(GPUVAddr gpu_addr, std::size_t size, VAddr cpu_addr, bool is_allocated);
+    std::optional<std::size_t> RemoveBufferMap(GPUVAddr gpu_addr);
+
     s32_le nvmap_fd{};
     u32_le submit_timeout{};
+    bool vic_device{};
     std::shared_ptr<nvmap> nvmap_dev;
     SyncpointManager& syncpoint_manager;
     std::array<u32, MaxSyncPoints> device_syncpoints{};
+    // This is expected to be ordered, therefore we must use a map, not unordered_map
+    std::map<GPUVAddr, BufferMap> buffer_mappings;
 };
 }; // namespace Devices
 } // namespace Service::Nvidia

src/core/hle/service/nvdrv/devices/nvhost_vic.cpp

@@ -12,8 +12,9 @@
 namespace Service::Nvidia::Devices {
 nvhost_vic::nvhost_vic(Core::System& system_, std::shared_ptr<nvmap> nvmap_dev_,
                        SyncpointManager& syncpoint_manager_)
-    : nvhost_nvdec_common{system_, std::move(nvmap_dev_), syncpoint_manager_} {}
-
+    : nvhost_nvdec_common(system_, std::move(nvmap_dev_), syncpoint_manager_) {
+    vic_device = true;
+}
 nvhost_vic::~nvhost_vic() = default;
 
 NvResult nvhost_vic::Ioctl1(DeviceFD fd, Ioctl command, const std::vector<u8>& input,

src/core/hle/service/nvdrv/nvdrv.cpp

@@ -39,11 +39,11 @@ void InstallInterfaces(SM::ServiceManager& service_manager, NVFlinger::NVFlinger
     nvflinger.SetNVDrvInstance(module_);
 }
 
-Module::Module(Core::System& system)
-    : syncpoint_manager{system.GPU()}, service_context{system, "nvdrv"} {
+Module::Module(Core::System& system) : syncpoint_manager{system.GPU()} {
+    auto& kernel = system.Kernel();
     for (u32 i = 0; i < MaxNvEvents; i++) {
-        events_interface.events[i].event =
-            service_context.CreateEvent(fmt::format("NVDRV::NvEvent_{}", i));
+        events_interface.events[i].event = Kernel::KEvent::Create(kernel);
+        events_interface.events[i].event->Initialize(fmt::format("NVDRV::NvEvent_{}", i));
         events_interface.status[i] = EventState::Free;
         events_interface.registered[i] = false;
     }
@@ -65,7 +65,8 @@ Module::Module(Core::System& system)
 
 Module::~Module() {
     for (u32 i = 0; i < MaxNvEvents; i++) {
-        service_context.CloseEvent(events_interface.events[i].event);
+        events_interface.events[i].event->Close();
+        events_interface.events[i].event = nullptr;
     }
 }
 

src/core/hle/service/nvdrv/nvdrv.h

@@ -9,7 +9,6 @@
 #include <vector>
 
 #include "common/common_types.h"
-#include "core/hle/service/kernel_helpers.h"
 #include "core/hle/service/nvdrv/nvdata.h"
 #include "core/hle/service/nvdrv/syncpoint_manager.h"
 #include "core/hle/service/service.h"
@@ -155,8 +154,6 @@ private:
     std::unordered_map<std::string, std::shared_ptr<Devices::nvdevice>> devices;
 
     EventInterface events_interface;
-
-    KernelHelpers::ServiceContext service_context;
 };
 
 /// Registers all NVDRV services with the specified service manager.

src/core/hle/service/nvflinger/nvflinger.cpp

@@ -307,12 +307,11 @@ void NVFlinger::Compose() {
 }
 
 s64 NVFlinger::GetNextTicks() const {
-    static constexpr s64 max_hertz = 120LL;
-
-    const auto& settings = Settings::values;
-    const bool unlocked_fps = settings.disable_fps_limit.GetValue();
-    const s64 fps_cap = unlocked_fps ? static_cast<s64>(settings.fps_cap.GetValue()) : 1;
-    return (1000000000 * (1LL << swap_interval)) / (max_hertz * fps_cap);
+    if (Settings::values.disable_fps_limit.GetValue()) {
+        return 0;
+    }
+    constexpr s64 max_hertz = 120LL;
+    return (1000000000 * (1LL << swap_interval)) / max_hertz;
 }
 
 } // namespace Service::NVFlinger

src/core/hle/service/service.cpp

@@ -104,22 +104,23 @@ ServiceFrameworkBase::~ServiceFrameworkBase() {
 void ServiceFrameworkBase::InstallAsService(SM::ServiceManager& service_manager) {
     const auto guard = LockService();
 
-    ASSERT(!service_registered);
+    ASSERT(!port_installed);
 
-    service_manager.RegisterService(service_name, max_sessions, shared_from_this());
-    service_registered = true;
+    auto port = service_manager.RegisterService(service_name, max_sessions).Unwrap();
+    port->SetSessionHandler(shared_from_this());
+    port_installed = true;
 }
 
 Kernel::KClientPort& ServiceFrameworkBase::CreatePort() {
     const auto guard = LockService();
 
-    ASSERT(!service_registered);
+    ASSERT(!port_installed);
 
     auto* port = Kernel::KPort::Create(kernel);
     port->Initialize(max_sessions, false, service_name);
     port->GetServerPort().SetSessionHandler(shared_from_this());
 
-    service_registered = true;
+    port_installed = true;
 
     return port->GetClientPort();
 }

src/core/hle/service/service.h

@@ -96,9 +96,6 @@ protected:
     /// System context that the service operates under.
     Core::System& system;
 
-    /// Identifier string used to connect to the service.
-    std::string service_name;
-
 private:
     template <typename T>
     friend class ServiceFramework;
@@ -120,12 +117,14 @@ private:
     void RegisterHandlersBaseTipc(const FunctionInfoBase* functions, std::size_t n);
     void ReportUnimplementedFunction(Kernel::HLERequestContext& ctx, const FunctionInfoBase* info);
 
+    /// Identifier string used to connect to the service.
+    std::string service_name;
     /// Maximum number of concurrent sessions that this service can handle.
     u32 max_sessions;
 
     /// Flag to store if a port was already create/installed to detect multiple install attempts,
     /// which is not supported.
-    bool service_registered = false;
+    bool port_installed = false;
 
     /// Function used to safely up-cast pointers to the derived class before invoking a handler.
     InvokerFn* handler_invoker;

src/core/hle/service/set/set.cpp

@@ -12,7 +12,7 @@
 
 namespace Service::Set {
 namespace {
-constexpr std::array<LanguageCode, 18> available_language_codes = {{
+constexpr std::array<LanguageCode, 17> available_language_codes = {{
     LanguageCode::JA,
     LanguageCode::EN_US,
     LanguageCode::FR,
@@ -30,7 +30,6 @@ constexpr std::array<LanguageCode, 18> available_language_codes = {{
     LanguageCode::ES_419,
     LanguageCode::ZH_HANS,
     LanguageCode::ZH_HANT,
-    LanguageCode::PT_BR,
 }};
 
 enum class KeyboardLayout : u64 {
@@ -51,7 +50,7 @@ enum class KeyboardLayout : u64 {
     ChineseTraditional = 14,
 };
 
-constexpr std::array<std::pair<LanguageCode, KeyboardLayout>, 18> language_to_layout{{
+constexpr std::array<std::pair<LanguageCode, KeyboardLayout>, 17> language_to_layout{{
     {LanguageCode::JA, KeyboardLayout::Japanese},
     {LanguageCode::EN_US, KeyboardLayout::EnglishUs},
     {LanguageCode::FR, KeyboardLayout::French},
@@ -69,11 +68,10 @@ constexpr std::array<std::pair<LanguageCode, KeyboardLayout>, 18> language_to_la
     {LanguageCode::ES_419, KeyboardLayout::SpanishLatin},
     {LanguageCode::ZH_HANS, KeyboardLayout::ChineseSimplified},
     {LanguageCode::ZH_HANT, KeyboardLayout::ChineseTraditional},
-    {LanguageCode::PT_BR, KeyboardLayout::Portuguese},
 }};
 
-constexpr std::size_t PRE_4_0_0_MAX_ENTRIES = 0xF;
-constexpr std::size_t POST_4_0_0_MAX_ENTRIES = 0x40;
+constexpr std::size_t pre4_0_0_max_entries = 15;
+constexpr std::size_t post4_0_0_max_entries = 17;
 
 constexpr ResultCode ERR_INVALID_LANGUAGE{ErrorModule::Settings, 625};
 
@@ -83,10 +81,9 @@ void PushResponseLanguageCode(Kernel::HLERequestContext& ctx, std::size_t num_la
     rb.Push(static_cast<u32>(num_language_codes));
 }
 
-void GetAvailableLanguageCodesImpl(Kernel::HLERequestContext& ctx, std::size_t max_entries) {
+void GetAvailableLanguageCodesImpl(Kernel::HLERequestContext& ctx, std::size_t max_size) {
     const std::size_t requested_amount = ctx.GetWriteBufferSize() / sizeof(LanguageCode);
-    const std::size_t max_amount = std::min(requested_amount, max_entries);
-    const std::size_t copy_amount = std::min(available_language_codes.size(), max_amount);
+    const std::size_t copy_amount = std::min(requested_amount, max_size);
     const std::size_t copy_size = copy_amount * sizeof(LanguageCode);
 
     ctx.WriteBuffer(available_language_codes.data(), copy_size);
@@ -121,7 +118,7 @@ LanguageCode GetLanguageCodeFromIndex(std::size_t index) {
 void SET::GetAvailableLanguageCodes(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_SET, "called");
 
-    GetAvailableLanguageCodesImpl(ctx, PRE_4_0_0_MAX_ENTRIES);
+    GetAvailableLanguageCodesImpl(ctx, pre4_0_0_max_entries);
 }
 
 void SET::MakeLanguageCode(Kernel::HLERequestContext& ctx) {
@@ -143,19 +140,19 @@ void SET::MakeLanguageCode(Kernel::HLERequestContext& ctx) {
 void SET::GetAvailableLanguageCodes2(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_SET, "called");
 
-    GetAvailableLanguageCodesImpl(ctx, POST_4_0_0_MAX_ENTRIES);
+    GetAvailableLanguageCodesImpl(ctx, post4_0_0_max_entries);
 }
 
 void SET::GetAvailableLanguageCodeCount(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_SET, "called");
 
-    PushResponseLanguageCode(ctx, PRE_4_0_0_MAX_ENTRIES);
+    PushResponseLanguageCode(ctx, pre4_0_0_max_entries);
 }
 
 void SET::GetAvailableLanguageCodeCount2(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_SET, "called");
 
-    PushResponseLanguageCode(ctx, POST_4_0_0_MAX_ENTRIES);
+    PushResponseLanguageCode(ctx, post4_0_0_max_entries);
 }
 
 void SET::GetQuestFlag(Kernel::HLERequestContext& ctx) {

src/core/hle/service/set/set.h

@@ -31,7 +31,6 @@ enum class LanguageCode : u64 {
     ES_419 = 0x00003931342D7365,
     ZH_HANS = 0x00736E61482D687A,
     ZH_HANT = 0x00746E61482D687A,
-    PT_BR = 0x00000052422D7470,
 };
 LanguageCode GetLanguageCodeFromIndex(std::size_t idx);
 

src/core/hle/service/sm/sm.cpp

@@ -4,7 +4,6 @@
 
 #include <tuple>
 #include "common/assert.h"
-#include "common/scope_exit.h"
 #include "core/core.h"
 #include "core/hle/ipc_helpers.h"
 #include "core/hle/kernel/k_client_port.h"
@@ -41,13 +40,17 @@ static ResultCode ValidateServiceName(const std::string& name) {
 }
 
 Kernel::KClientPort& ServiceManager::InterfaceFactory(ServiceManager& self, Core::System& system) {
-    self.sm_interface = std::make_shared<SM>(self, system);
+    ASSERT(self.sm_interface.expired());
+
+    auto sm = std::make_shared<SM>(self, system);
+    self.sm_interface = sm;
     self.controller_interface = std::make_unique<Controller>(system);
-    return self.sm_interface->CreatePort();
+
+    return sm->CreatePort();
 }
 
-ResultCode ServiceManager::RegisterService(std::string name, u32 max_sessions,
-                                           Kernel::SessionRequestHandlerPtr handler) {
+ResultVal<Kernel::KServerPort*> ServiceManager::RegisterService(std::string name,
+                                                                u32 max_sessions) {
 
     CASCADE_CODE(ValidateServiceName(name));
 
@@ -56,9 +59,12 @@ ResultCode ServiceManager::RegisterService(std::string name, u32 max_sessions,
         return ERR_ALREADY_REGISTERED;
     }
 
-    registered_services.emplace(std::move(name), handler);
+    auto* port = Kernel::KPort::Create(kernel);
+    port->Initialize(max_sessions, false, name);
 
-    return ResultSuccess;
+    registered_services.emplace(std::move(name), port);
+
+    return MakeResult(&port->GetServerPort());
 }
 
 ResultCode ServiceManager::UnregisterService(const std::string& name) {
@@ -70,11 +76,14 @@ ResultCode ServiceManager::UnregisterService(const std::string& name) {
         return ERR_SERVICE_NOT_REGISTERED;
     }
 
+    iter->second->Close();
+
     registered_services.erase(iter);
     return ResultSuccess;
 }
 
 ResultVal<Kernel::KPort*> ServiceManager::GetServicePort(const std::string& name) {
+
     CASCADE_CODE(ValidateServiceName(name));
     auto it = registered_services.find(name);
     if (it == registered_services.end()) {
@@ -82,14 +91,11 @@ ResultVal<Kernel::KPort*> ServiceManager::GetServicePort(const std::string& name
         return ERR_SERVICE_NOT_REGISTERED;
     }
 
-    auto* port = Kernel::KPort::Create(kernel);
-    port->Initialize(ServerSessionCountMax, false, name);
-    auto handler = it->second;
-    port->GetServerPort().SetSessionHandler(std::move(handler));
-
-    return MakeResult(port);
+    return MakeResult(it->second);
 }
 
+SM::~SM() = default;
+
 /**
  * SM::Initialize service function
  *  Inputs:
@@ -150,15 +156,11 @@ ResultVal<Kernel::KClientSession*> SM::GetServiceImpl(Kernel::HLERequestContext&
         LOG_ERROR(Service_SM, "called service={} -> error 0x{:08X}", name, port_result.Code().raw);
         return port_result.Code();
     }
-    auto& port = port_result.Unwrap();
-    SCOPE_EXIT({ port->GetClientPort().Close(); });
-
-    server_ports.emplace_back(&port->GetServerPort());
+    auto& port = port_result.Unwrap()->GetClientPort();
 
     // Create a new session.
     Kernel::KClientSession* session{};
-    if (const auto result = port->GetClientPort().CreateSession(std::addressof(session));
-        result.IsError()) {
+    if (const auto result = port.CreateSession(std::addressof(session)); result.IsError()) {
         LOG_ERROR(Service_SM, "called service={} -> error 0x{:08X}", name, result.raw);
         return result;
     }
@@ -178,21 +180,20 @@ void SM::RegisterService(Kernel::HLERequestContext& ctx) {
     LOG_DEBUG(Service_SM, "called with name={}, max_session_count={}, is_light={}", name,
               max_session_count, is_light);
 
-    if (const auto result = service_manager.RegisterService(name, max_session_count, nullptr);
-        result.IsError()) {
-        LOG_ERROR(Service_SM, "failed to register service with error_code={:08X}", result.raw);
+    auto handle = service_manager.RegisterService(name, max_session_count);
+    if (handle.Failed()) {
+        LOG_ERROR(Service_SM, "failed to register service with error_code={:08X}",
+                  handle.Code().raw);
         IPC::ResponseBuilder rb{ctx, 2};
-        rb.Push(result);
+        rb.Push(handle.Code());
         return;
     }
 
-    auto* port = Kernel::KPort::Create(kernel);
-    port->Initialize(ServerSessionCountMax, is_light, name);
-    SCOPE_EXIT({ port->GetClientPort().Close(); });
-
     IPC::ResponseBuilder rb{ctx, 2, 0, 1, IPC::ResponseBuilder::Flags::AlwaysMoveHandles};
-    rb.Push(ResultSuccess);
-    rb.PushMoveObjects(port->GetServerPort());
+    rb.Push(handle.Code());
+
+    auto server_port = handle.Unwrap();
+    rb.PushMoveObjects(server_port);
 }
 
 void SM::UnregisterService(Kernel::HLERequestContext& ctx) {
@@ -224,10 +225,4 @@ SM::SM(ServiceManager& service_manager_, Core::System& system_)
     });
 }
 
-SM::~SM() {
-    for (auto& server_port : server_ports) {
-        server_port->Close();
-    }
-}
-
 } // namespace Service::SM

src/core/hle/service/sm/sm.h

@@ -49,7 +49,6 @@ private:
     ServiceManager& service_manager;
     bool is_initialized{};
     Kernel::KernelCore& kernel;
-    std::vector<Kernel::KServerPort*> server_ports;
 };
 
 class ServiceManager {
@@ -59,8 +58,7 @@ public:
     explicit ServiceManager(Kernel::KernelCore& kernel_);
     ~ServiceManager();
 
-    ResultCode RegisterService(std::string name, u32 max_sessions,
-                               Kernel::SessionRequestHandlerPtr handler);
+    ResultVal<Kernel::KServerPort*> RegisterService(std::string name, u32 max_sessions);
     ResultCode UnregisterService(const std::string& name);
     ResultVal<Kernel::KPort*> GetServicePort(const std::string& name);
 
@@ -71,17 +69,21 @@ public:
             LOG_DEBUG(Service, "Can't find service: {}", service_name);
             return nullptr;
         }
-        return std::static_pointer_cast<T>(service->second);
+        auto* port = service->second;
+        if (port == nullptr) {
+            return nullptr;
+        }
+        return std::static_pointer_cast<T>(port->GetServerPort().GetSessionRequestHandler());
     }
 
     void InvokeControlRequest(Kernel::HLERequestContext& context);
 
 private:
-    std::shared_ptr<SM> sm_interface;
+    std::weak_ptr<SM> sm_interface;
     std::unique_ptr<Controller> controller_interface;
 
     /// Map of registered services, retrieved using GetServicePort.
-    std::unordered_map<std::string, Kernel::SessionRequestHandlerPtr> registered_services;
+    std::unordered_map<std::string, Kernel::KPort*> registered_services;
 
     /// Kernel context
     Kernel::KernelCore& kernel;

src/core/memory.cpp

@@ -4,6 +4,8 @@
 
 #include <algorithm>
 #include <cstring>
+#include <optional>
+#include <utility>
 
 #include "common/assert.h"
 #include "common/atomic_ops.h"
@@ -12,10 +14,12 @@
 #include "common/page_table.h"
 #include "common/settings.h"
 #include "common/swap.h"
+#include "core/arm/arm_interface.h"
 #include "core/core.h"
 #include "core/device_memory.h"
 #include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_process.h"
+#include "core/hle/kernel/physical_memory.h"
 #include "core/memory.h"
 #include "video_core/gpu.h"
 
@@ -58,7 +62,17 @@ struct Memory::Impl {
         }
     }
 
-    [[nodiscard]] u8* GetPointerFromRasterizerCachedMemory(VAddr vaddr) const {
+    bool IsValidVirtualAddress(const Kernel::KProcess& process, const VAddr vaddr) const {
+        const auto& page_table = process.PageTable().PageTableImpl();
+        const auto [pointer, type] = page_table.pointers[vaddr >> PAGE_BITS].PointerType();
+        return pointer != nullptr || type == Common::PageType::RasterizerCachedMemory;
+    }
+
+    bool IsValidVirtualAddress(VAddr vaddr) const {
+        return IsValidVirtualAddress(*system.CurrentProcess(), vaddr);
+    }
+
+    u8* GetPointerFromRasterizerCachedMemory(VAddr vaddr) const {
         const PAddr paddr{current_page_table->backing_addr[vaddr >> PAGE_BITS]};
 
         if (!paddr) {
@@ -68,6 +82,18 @@ struct Memory::Impl {
         return system.DeviceMemory().GetPointer(paddr) + vaddr;
     }
 
+    u8* GetPointer(const VAddr vaddr) const {
+        const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw();
+        if (u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
+            return pointer + vaddr;
+        }
+        const auto type = Common::PageTable::PageInfo::ExtractType(raw_pointer);
+        if (type == Common::PageType::RasterizerCachedMemory) {
+            return GetPointerFromRasterizerCachedMemory(vaddr);
+        }
+        return nullptr;
+    }
+
     u8 Read8(const VAddr addr) {
         return Read<u8>(addr);
     }
@@ -153,7 +179,7 @@ struct Memory::Impl {
         std::string string;
         string.reserve(max_length);
         for (std::size_t i = 0; i < max_length; ++i) {
-            const char c = Read<s8>(vaddr);
+            const char c = Read8(vaddr);
             if (c == '\0') {
                 break;
             }
@@ -164,14 +190,15 @@ struct Memory::Impl {
         return string;
     }
 
-    void WalkBlock(const Kernel::KProcess& process, const VAddr addr, const std::size_t size,
-                   auto on_unmapped, auto on_memory, auto on_rasterizer, auto increment) {
+    void ReadBlock(const Kernel::KProcess& process, const VAddr src_addr, void* dest_buffer,
+                   const std::size_t size) {
         const auto& page_table = process.PageTable().PageTableImpl();
-        std::size_t remaining_size = size;
-        std::size_t page_index = addr >> PAGE_BITS;
-        std::size_t page_offset = addr & PAGE_MASK;
 
-        while (remaining_size) {
+        std::size_t remaining_size = size;
+        std::size_t page_index = src_addr >> PAGE_BITS;
+        std::size_t page_offset = src_addr & PAGE_MASK;
+
+        while (remaining_size > 0) {
             const std::size_t copy_amount =
                 std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
             const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
@@ -179,18 +206,22 @@ struct Memory::Impl {
             const auto [pointer, type] = page_table.pointers[page_index].PointerType();
             switch (type) {
             case Common::PageType::Unmapped: {
-                on_unmapped(copy_amount, current_vaddr);
+                LOG_ERROR(HW_Memory,
+                          "Unmapped ReadBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
+                          current_vaddr, src_addr, size);
+                std::memset(dest_buffer, 0, copy_amount);
                 break;
             }
             case Common::PageType::Memory: {
                 DEBUG_ASSERT(pointer);
-                u8* mem_ptr = pointer + page_offset + (page_index << PAGE_BITS);
-                on_memory(copy_amount, mem_ptr);
+                const u8* const src_ptr = pointer + page_offset + (page_index << PAGE_BITS);
+                std::memcpy(dest_buffer, src_ptr, copy_amount);
                 break;
             }
             case Common::PageType::RasterizerCachedMemory: {
-                u8* const host_ptr{GetPointerFromRasterizerCachedMemory(current_vaddr)};
-                on_rasterizer(current_vaddr, copy_amount, host_ptr);
+                const u8* const host_ptr{GetPointerFromRasterizerCachedMemory(current_vaddr)};
+                system.GPU().FlushRegion(current_vaddr, copy_amount);
+                std::memcpy(dest_buffer, host_ptr, copy_amount);
                 break;
             }
             default:
@@ -199,122 +230,248 @@ struct Memory::Impl {
 
             page_index++;
             page_offset = 0;
-            increment(copy_amount);
+            dest_buffer = static_cast<u8*>(dest_buffer) + copy_amount;
             remaining_size -= copy_amount;
         }
     }
 
-    template <bool UNSAFE>
-    void ReadBlockImpl(const Kernel::KProcess& process, const VAddr src_addr, void* dest_buffer,
-                       const std::size_t size) {
-        WalkBlock(
-            process, src_addr, size,
-            [src_addr, size, &dest_buffer](const std::size_t copy_amount,
-                                           const VAddr current_vaddr) {
+    void ReadBlockUnsafe(const Kernel::KProcess& process, const VAddr src_addr, void* dest_buffer,
+                         const std::size_t size) {
+        const auto& page_table = process.PageTable().PageTableImpl();
+
+        std::size_t remaining_size = size;
+        std::size_t page_index = src_addr >> PAGE_BITS;
+        std::size_t page_offset = src_addr & PAGE_MASK;
+
+        while (remaining_size > 0) {
+            const std::size_t copy_amount =
+                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
+            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
+
+            const auto [pointer, type] = page_table.pointers[page_index].PointerType();
+            switch (type) {
+            case Common::PageType::Unmapped: {
                 LOG_ERROR(HW_Memory,
                           "Unmapped ReadBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
                           current_vaddr, src_addr, size);
                 std::memset(dest_buffer, 0, copy_amount);
-            },
-            [&dest_buffer](const std::size_t copy_amount, const u8* const src_ptr) {
+                break;
+            }
+            case Common::PageType::Memory: {
+                DEBUG_ASSERT(pointer);
+                const u8* const src_ptr = pointer + page_offset + (page_index << PAGE_BITS);
                 std::memcpy(dest_buffer, src_ptr, copy_amount);
-            },
-            [&system = system, &dest_buffer](const VAddr current_vaddr,
-                                             const std::size_t copy_amount,
-                                             const u8* const host_ptr) {
-                if constexpr (!UNSAFE) {
-                    system.GPU().FlushRegion(current_vaddr, copy_amount);
-                }
+                break;
+            }
+            case Common::PageType::RasterizerCachedMemory: {
+                const u8* const host_ptr{GetPointerFromRasterizerCachedMemory(current_vaddr)};
                 std::memcpy(dest_buffer, host_ptr, copy_amount);
-            },
-            [&dest_buffer](const std::size_t copy_amount) {
-                dest_buffer = static_cast<u8*>(dest_buffer) + copy_amount;
-            });
+                break;
+            }
+            default:
+                UNREACHABLE();
+            }
+
+            page_index++;
+            page_offset = 0;
+            dest_buffer = static_cast<u8*>(dest_buffer) + copy_amount;
+            remaining_size -= copy_amount;
+        }
     }
 
     void ReadBlock(const VAddr src_addr, void* dest_buffer, const std::size_t size) {
-        ReadBlockImpl<false>(*system.CurrentProcess(), src_addr, dest_buffer, size);
+        ReadBlock(*system.CurrentProcess(), src_addr, dest_buffer, size);
     }
 
     void ReadBlockUnsafe(const VAddr src_addr, void* dest_buffer, const std::size_t size) {
-        ReadBlockImpl<true>(*system.CurrentProcess(), src_addr, dest_buffer, size);
+        ReadBlockUnsafe(*system.CurrentProcess(), src_addr, dest_buffer, size);
     }
 
-    template <bool UNSAFE>
-    void WriteBlockImpl(const Kernel::KProcess& process, const VAddr dest_addr,
-                        const void* src_buffer, const std::size_t size) {
-        WalkBlock(
-            process, dest_addr, size,
-            [dest_addr, size](const std::size_t copy_amount, const VAddr current_vaddr) {
+    void WriteBlock(const Kernel::KProcess& process, const VAddr dest_addr, const void* src_buffer,
+                    const std::size_t size) {
+        const auto& page_table = process.PageTable().PageTableImpl();
+        std::size_t remaining_size = size;
+        std::size_t page_index = dest_addr >> PAGE_BITS;
+        std::size_t page_offset = dest_addr & PAGE_MASK;
+
+        while (remaining_size > 0) {
+            const std::size_t copy_amount =
+                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
+            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
+
+            const auto [pointer, type] = page_table.pointers[page_index].PointerType();
+            switch (type) {
+            case Common::PageType::Unmapped: {
                 LOG_ERROR(HW_Memory,
                           "Unmapped WriteBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
                           current_vaddr, dest_addr, size);
-            },
-            [&src_buffer](const std::size_t copy_amount, u8* const dest_ptr) {
+                break;
+            }
+            case Common::PageType::Memory: {
+                DEBUG_ASSERT(pointer);
+                u8* const dest_ptr = pointer + page_offset + (page_index << PAGE_BITS);
                 std::memcpy(dest_ptr, src_buffer, copy_amount);
-            },
-            [&system = system, &src_buffer](const VAddr current_vaddr,
-                                            const std::size_t copy_amount, u8* const host_ptr) {
-                if constexpr (!UNSAFE) {
-                    system.GPU().InvalidateRegion(current_vaddr, copy_amount);
-                }
+                break;
+            }
+            case Common::PageType::RasterizerCachedMemory: {
+                u8* const host_ptr{GetPointerFromRasterizerCachedMemory(current_vaddr)};
+                system.GPU().InvalidateRegion(current_vaddr, copy_amount);
                 std::memcpy(host_ptr, src_buffer, copy_amount);
-            },
-            [&src_buffer](const std::size_t copy_amount) {
-                src_buffer = static_cast<const u8*>(src_buffer) + copy_amount;
-            });
+                break;
+            }
+            default:
+                UNREACHABLE();
+            }
+
+            page_index++;
+            page_offset = 0;
+            src_buffer = static_cast<const u8*>(src_buffer) + copy_amount;
+            remaining_size -= copy_amount;
+        }
+    }
+
+    void WriteBlockUnsafe(const Kernel::KProcess& process, const VAddr dest_addr,
+                          const void* src_buffer, const std::size_t size) {
+        const auto& page_table = process.PageTable().PageTableImpl();
+        std::size_t remaining_size = size;
+        std::size_t page_index = dest_addr >> PAGE_BITS;
+        std::size_t page_offset = dest_addr & PAGE_MASK;
+
+        while (remaining_size > 0) {
+            const std::size_t copy_amount =
+                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
+            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
+
+            const auto [pointer, type] = page_table.pointers[page_index].PointerType();
+            switch (type) {
+            case Common::PageType::Unmapped: {
+                LOG_ERROR(HW_Memory,
+                          "Unmapped WriteBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
+                          current_vaddr, dest_addr, size);
+                break;
+            }
+            case Common::PageType::Memory: {
+                DEBUG_ASSERT(pointer);
+                u8* const dest_ptr = pointer + page_offset + (page_index << PAGE_BITS);
+                std::memcpy(dest_ptr, src_buffer, copy_amount);
+                break;
+            }
+            case Common::PageType::RasterizerCachedMemory: {
+                u8* const host_ptr{GetPointerFromRasterizerCachedMemory(current_vaddr)};
+                std::memcpy(host_ptr, src_buffer, copy_amount);
+                break;
+            }
+            default:
+                UNREACHABLE();
+            }
+
+            page_index++;
+            page_offset = 0;
+            src_buffer = static_cast<const u8*>(src_buffer) + copy_amount;
+            remaining_size -= copy_amount;
+        }
     }
 
     void WriteBlock(const VAddr dest_addr, const void* src_buffer, const std::size_t size) {
-        WriteBlockImpl<false>(*system.CurrentProcess(), dest_addr, src_buffer, size);
+        WriteBlock(*system.CurrentProcess(), dest_addr, src_buffer, size);
     }
 
     void WriteBlockUnsafe(const VAddr dest_addr, const void* src_buffer, const std::size_t size) {
-        WriteBlockImpl<true>(*system.CurrentProcess(), dest_addr, src_buffer, size);
+        WriteBlockUnsafe(*system.CurrentProcess(), dest_addr, src_buffer, size);
     }
 
     void ZeroBlock(const Kernel::KProcess& process, const VAddr dest_addr, const std::size_t size) {
-        WalkBlock(
-            process, dest_addr, size,
-            [dest_addr, size](const std::size_t copy_amount, const VAddr current_vaddr) {
+        const auto& page_table = process.PageTable().PageTableImpl();
+        std::size_t remaining_size = size;
+        std::size_t page_index = dest_addr >> PAGE_BITS;
+        std::size_t page_offset = dest_addr & PAGE_MASK;
+
+        while (remaining_size > 0) {
+            const std::size_t copy_amount =
+                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
+            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
+
+            const auto [pointer, type] = page_table.pointers[page_index].PointerType();
+            switch (type) {
+            case Common::PageType::Unmapped: {
                 LOG_ERROR(HW_Memory,
                           "Unmapped ZeroBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
                           current_vaddr, dest_addr, size);
-            },
-            [](const std::size_t copy_amount, u8* const dest_ptr) {
+                break;
+            }
+            case Common::PageType::Memory: {
+                DEBUG_ASSERT(pointer);
+                u8* const dest_ptr = pointer + page_offset + (page_index << PAGE_BITS);
                 std::memset(dest_ptr, 0, copy_amount);
-            },
-            [&system = system](const VAddr current_vaddr, const std::size_t copy_amount,
-                               u8* const host_ptr) {
+                break;
+            }
+            case Common::PageType::RasterizerCachedMemory: {
+                u8* const host_ptr{GetPointerFromRasterizerCachedMemory(current_vaddr)};
                 system.GPU().InvalidateRegion(current_vaddr, copy_amount);
                 std::memset(host_ptr, 0, copy_amount);
-            },
-            [](const std::size_t copy_amount) {});
+                break;
+            }
+            default:
+                UNREACHABLE();
+            }
+
+            page_index++;
+            page_offset = 0;
+            remaining_size -= copy_amount;
+        }
+    }
+
+    void ZeroBlock(const VAddr dest_addr, const std::size_t size) {
+        ZeroBlock(*system.CurrentProcess(), dest_addr, size);
     }
 
     void CopyBlock(const Kernel::KProcess& process, VAddr dest_addr, VAddr src_addr,
                    const std::size_t size) {
-        WalkBlock(
-            process, dest_addr, size,
-            [this, &process, &dest_addr, &src_addr, size](const std::size_t copy_amount,
-                                                          const VAddr current_vaddr) {
+        const auto& page_table = process.PageTable().PageTableImpl();
+        std::size_t remaining_size = size;
+        std::size_t page_index = src_addr >> PAGE_BITS;
+        std::size_t page_offset = src_addr & PAGE_MASK;
+
+        while (remaining_size > 0) {
+            const std::size_t copy_amount =
+                std::min(static_cast<std::size_t>(PAGE_SIZE) - page_offset, remaining_size);
+            const auto current_vaddr = static_cast<VAddr>((page_index << PAGE_BITS) + page_offset);
+
+            const auto [pointer, type] = page_table.pointers[page_index].PointerType();
+            switch (type) {
+            case Common::PageType::Unmapped: {
                 LOG_ERROR(HW_Memory,
                           "Unmapped CopyBlock @ 0x{:016X} (start address = 0x{:016X}, size = {})",
                           current_vaddr, src_addr, size);
                 ZeroBlock(process, dest_addr, copy_amount);
-            },
-            [this, &process, &dest_addr](const std::size_t copy_amount, const u8* const src_ptr) {
-                WriteBlockImpl<false>(process, dest_addr, src_ptr, copy_amount);
-            },
-            [this, &system = system, &process, &dest_addr](
-                const VAddr current_vaddr, const std::size_t copy_amount, u8* const host_ptr) {
+                break;
+            }
+            case Common::PageType::Memory: {
+                DEBUG_ASSERT(pointer);
+                const u8* src_ptr = pointer + page_offset + (page_index << PAGE_BITS);
+                WriteBlock(process, dest_addr, src_ptr, copy_amount);
+                break;
+            }
+            case Common::PageType::RasterizerCachedMemory: {
+                const u8* const host_ptr{GetPointerFromRasterizerCachedMemory(current_vaddr)};
                 system.GPU().FlushRegion(current_vaddr, copy_amount);
-                WriteBlockImpl<false>(process, dest_addr, host_ptr, copy_amount);
-            },
-            [&dest_addr, &src_addr](const std::size_t copy_amount) {
-                dest_addr += static_cast<VAddr>(copy_amount);
-                src_addr += static_cast<VAddr>(copy_amount);
-            });
+                WriteBlock(process, dest_addr, host_ptr, copy_amount);
+                break;
+            }
+            default:
+                UNREACHABLE();
+            }
+
+            page_index++;
+            page_offset = 0;
+            dest_addr += static_cast<VAddr>(copy_amount);
+            src_addr += static_cast<VAddr>(copy_amount);
+            remaining_size -= copy_amount;
+        }
+    }
+
+    void CopyBlock(VAddr dest_addr, VAddr src_addr, std::size_t size) {
+        return CopyBlock(*system.CurrentProcess(), dest_addr, src_addr, size);
     }
 
     void RasterizerMarkRegionCached(VAddr vaddr, u64 size, bool cached) {
@@ -357,7 +514,7 @@ struct Memory::Impl {
             } else {
                 // Switch page type to uncached if now uncached
                 switch (page_type) {
-                case Common::PageType::Unmapped: // NOLINT(bugprone-branch-clone)
+                case Common::PageType::Unmapped:
                     // It is not necessary for a process to have this region mapped into its address
                     // space, for example, a system module need not have a VRAM mapping.
                     break;
@@ -440,44 +597,6 @@ struct Memory::Impl {
         }
     }
 
-    [[nodiscard]] u8* GetPointerImpl(VAddr vaddr, auto on_unmapped, auto on_rasterizer) const {
-        // AARCH64 masks the upper 16 bit of all memory accesses
-        vaddr &= 0xffffffffffffLL;
-
-        if (vaddr >= 1uLL << current_page_table->GetAddressSpaceBits()) {
-            on_unmapped();
-            return nullptr;
-        }
-
-        // Avoid adding any extra logic to this fast-path block
-        const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw();
-        if (u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
-            return &pointer[vaddr];
-        }
-        switch (Common::PageTable::PageInfo::ExtractType(raw_pointer)) {
-        case Common::PageType::Unmapped:
-            on_unmapped();
-            return nullptr;
-        case Common::PageType::Memory:
-            ASSERT_MSG(false, "Mapped memory page without a pointer @ 0x{:016X}", vaddr);
-            return nullptr;
-        case Common::PageType::RasterizerCachedMemory: {
-            u8* const host_ptr{GetPointerFromRasterizerCachedMemory(vaddr)};
-            on_rasterizer();
-            return host_ptr;
-        }
-        default:
-            UNREACHABLE();
-        }
-        return nullptr;
-    }
-
-    [[nodiscard]] u8* GetPointer(const VAddr vaddr) const {
-        return GetPointerImpl(
-            vaddr, [vaddr]() { LOG_ERROR(HW_Memory, "Unmapped GetPointer @ 0x{:016X}", vaddr); },
-            []() {});
-    }
-
     /**
      * Reads a particular data type out of memory at the given virtual address.
      *
@@ -491,17 +610,39 @@ struct Memory::Impl {
      */
     template <typename T>
     T Read(VAddr vaddr) {
-        T result = 0;
-        const u8* const ptr = GetPointerImpl(
-            vaddr,
-            [vaddr]() {
-                LOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:016X}", sizeof(T) * 8, vaddr);
-            },
-            [&system = system, vaddr]() { system.GPU().FlushRegion(vaddr, sizeof(T)); });
-        if (ptr) {
-            std::memcpy(&result, ptr, sizeof(T));
+        // AARCH64 masks the upper 16 bit of all memory accesses
+        vaddr &= 0xffffffffffffLL;
+
+        if (vaddr >= 1uLL << current_page_table->GetAddressSpaceBits()) {
+            LOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:08X}", sizeof(T) * 8, vaddr);
+            return 0;
         }
-        return result;
+
+        // Avoid adding any extra logic to this fast-path block
+        const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw();
+        if (const u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
+            T value;
+            std::memcpy(&value, &pointer[vaddr], sizeof(T));
+            return value;
+        }
+        switch (Common::PageTable::PageInfo::ExtractType(raw_pointer)) {
+        case Common::PageType::Unmapped:
+            LOG_ERROR(HW_Memory, "Unmapped Read{} @ 0x{:08X}", sizeof(T) * 8, vaddr);
+            return 0;
+        case Common::PageType::Memory:
+            ASSERT_MSG(false, "Mapped memory page without a pointer @ {:016X}", vaddr);
+            break;
+        case Common::PageType::RasterizerCachedMemory: {
+            const u8* const host_ptr{GetPointerFromRasterizerCachedMemory(vaddr)};
+            system.GPU().FlushRegion(vaddr, sizeof(T));
+            T value;
+            std::memcpy(&value, host_ptr, sizeof(T));
+            return value;
+        }
+        default:
+            UNREACHABLE();
+        }
+        return {};
     }
 
     /**
@@ -515,46 +656,110 @@ struct Memory::Impl {
      */
     template <typename T>
     void Write(VAddr vaddr, const T data) {
-        u8* const ptr = GetPointerImpl(
-            vaddr,
-            [vaddr, data]() {
-                LOG_ERROR(HW_Memory, "Unmapped Write{} @ 0x{:016X} = 0x{:016X}", sizeof(T) * 8,
-                          vaddr, static_cast<u64>(data));
-            },
-            [&system = system, vaddr]() { system.GPU().InvalidateRegion(vaddr, sizeof(T)); });
-        if (ptr) {
-            std::memcpy(ptr, &data, sizeof(T));
+        // AARCH64 masks the upper 16 bit of all memory accesses
+        vaddr &= 0xffffffffffffLL;
+
+        if (vaddr >= 1uLL << current_page_table->GetAddressSpaceBits()) {
+            LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
+                      static_cast<u32>(data), vaddr);
+            return;
+        }
+
+        // Avoid adding any extra logic to this fast-path block
+        const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw();
+        if (u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
+            std::memcpy(&pointer[vaddr], &data, sizeof(T));
+            return;
+        }
+        switch (Common::PageTable::PageInfo::ExtractType(raw_pointer)) {
+        case Common::PageType::Unmapped:
+            LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
+                      static_cast<u32>(data), vaddr);
+            return;
+        case Common::PageType::Memory:
+            ASSERT_MSG(false, "Mapped memory page without a pointer @ {:016X}", vaddr);
+            break;
+        case Common::PageType::RasterizerCachedMemory: {
+            u8* const host_ptr{GetPointerFromRasterizerCachedMemory(vaddr)};
+            system.GPU().InvalidateRegion(vaddr, sizeof(T));
+            std::memcpy(host_ptr, &data, sizeof(T));
+            break;
+        }
+        default:
+            UNREACHABLE();
         }
     }
 
     template <typename T>
     bool WriteExclusive(VAddr vaddr, const T data, const T expected) {
-        u8* const ptr = GetPointerImpl(
-            vaddr,
-            [vaddr, data]() {
-                LOG_ERROR(HW_Memory, "Unmapped WriteExclusive{} @ 0x{:016X} = 0x{:016X}",
-                          sizeof(T) * 8, vaddr, static_cast<u64>(data));
-            },
-            [&system = system, vaddr]() { system.GPU().InvalidateRegion(vaddr, sizeof(T)); });
-        if (ptr) {
-            const auto volatile_pointer = reinterpret_cast<volatile T*>(ptr);
+        // AARCH64 masks the upper 16 bit of all memory accesses
+        vaddr &= 0xffffffffffffLL;
+
+        if (vaddr >= 1uLL << current_page_table->GetAddressSpaceBits()) {
+            LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
+                      static_cast<u32>(data), vaddr);
+            return true;
+        }
+
+        const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw();
+        if (u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
+            // NOTE: Avoid adding any extra logic to this fast-path block
+            const auto volatile_pointer = reinterpret_cast<volatile T*>(&pointer[vaddr]);
             return Common::AtomicCompareAndSwap(volatile_pointer, data, expected);
         }
+        switch (Common::PageTable::PageInfo::ExtractType(raw_pointer)) {
+        case Common::PageType::Unmapped:
+            LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
+                      static_cast<u32>(data), vaddr);
+            return true;
+        case Common::PageType::Memory:
+            ASSERT_MSG(false, "Mapped memory page without a pointer @ {:016X}", vaddr);
+            break;
+        case Common::PageType::RasterizerCachedMemory: {
+            u8* host_ptr{GetPointerFromRasterizerCachedMemory(vaddr)};
+            system.GPU().InvalidateRegion(vaddr, sizeof(T));
+            auto* pointer = reinterpret_cast<volatile T*>(&host_ptr);
+            return Common::AtomicCompareAndSwap(pointer, data, expected);
+        }
+        default:
+            UNREACHABLE();
+        }
         return true;
     }
 
     bool WriteExclusive128(VAddr vaddr, const u128 data, const u128 expected) {
-        u8* const ptr = GetPointerImpl(
-            vaddr,
-            [vaddr, data]() {
-                LOG_ERROR(HW_Memory, "Unmapped WriteExclusive128 @ 0x{:016X} = 0x{:016X}{:016X}",
-                          vaddr, static_cast<u64>(data[1]), static_cast<u64>(data[0]));
-            },
-            [&system = system, vaddr]() { system.GPU().InvalidateRegion(vaddr, sizeof(u128)); });
-        if (ptr) {
-            const auto volatile_pointer = reinterpret_cast<volatile u64*>(ptr);
+        // AARCH64 masks the upper 16 bit of all memory accesses
+        vaddr &= 0xffffffffffffLL;
+
+        if (vaddr >= 1uLL << current_page_table->GetAddressSpaceBits()) {
+            LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}", sizeof(data) * 8,
+                      static_cast<u32>(data[0]), vaddr);
+            return true;
+        }
+
+        const uintptr_t raw_pointer = current_page_table->pointers[vaddr >> PAGE_BITS].Raw();
+        if (u8* const pointer = Common::PageTable::PageInfo::ExtractPointer(raw_pointer)) {
+            // NOTE: Avoid adding any extra logic to this fast-path block
+            const auto volatile_pointer = reinterpret_cast<volatile u64*>(&pointer[vaddr]);
             return Common::AtomicCompareAndSwap(volatile_pointer, data, expected);
         }
+        switch (Common::PageTable::PageInfo::ExtractType(raw_pointer)) {
+        case Common::PageType::Unmapped:
+            LOG_ERROR(HW_Memory, "Unmapped Write{} 0x{:08X} @ 0x{:016X}{:016X}", sizeof(data) * 8,
+                      static_cast<u64>(data[1]), static_cast<u64>(data[0]), vaddr);
+            return true;
+        case Common::PageType::Memory:
+            ASSERT_MSG(false, "Mapped memory page without a pointer @ {:016X}", vaddr);
+            break;
+        case Common::PageType::RasterizerCachedMemory: {
+            u8* host_ptr{GetPointerFromRasterizerCachedMemory(vaddr)};
+            system.GPU().InvalidateRegion(vaddr, sizeof(u128));
+            auto* pointer = reinterpret_cast<volatile u64*>(&host_ptr);
+            return Common::AtomicCompareAndSwap(pointer, data, expected);
+        }
+        default:
+            UNREACHABLE();
+        }
         return true;
     }
 
@@ -584,11 +789,12 @@ void Memory::UnmapRegion(Common::PageTable& page_table, VAddr base, u64 size) {
     impl->UnmapRegion(page_table, base, size);
 }
 
+bool Memory::IsValidVirtualAddress(const Kernel::KProcess& process, const VAddr vaddr) const {
+    return impl->IsValidVirtualAddress(process, vaddr);
+}
+
 bool Memory::IsValidVirtualAddress(const VAddr vaddr) const {
-    const Kernel::KProcess& process = *system.CurrentProcess();
-    const auto& page_table = process.PageTable().PageTableImpl();
-    const auto [pointer, type] = page_table.pointers[vaddr >> PAGE_BITS].PointerType();
-    return pointer != nullptr || type == Common::PageType::RasterizerCachedMemory;
+    return impl->IsValidVirtualAddress(vaddr);
 }
 
 u8* Memory::GetPointer(VAddr vaddr) {
@@ -657,38 +863,64 @@ std::string Memory::ReadCString(VAddr vaddr, std::size_t max_length) {
 
 void Memory::ReadBlock(const Kernel::KProcess& process, const VAddr src_addr, void* dest_buffer,
                        const std::size_t size) {
-    impl->ReadBlockImpl<false>(process, src_addr, dest_buffer, size);
+    impl->ReadBlock(process, src_addr, dest_buffer, size);
 }
 
 void Memory::ReadBlock(const VAddr src_addr, void* dest_buffer, const std::size_t size) {
     impl->ReadBlock(src_addr, dest_buffer, size);
 }
 
+void Memory::ReadBlockUnsafe(const Kernel::KProcess& process, const VAddr src_addr,
+                             void* dest_buffer, const std::size_t size) {
+    impl->ReadBlockUnsafe(process, src_addr, dest_buffer, size);
+}
+
 void Memory::ReadBlockUnsafe(const VAddr src_addr, void* dest_buffer, const std::size_t size) {
     impl->ReadBlockUnsafe(src_addr, dest_buffer, size);
 }
 
 void Memory::WriteBlock(const Kernel::KProcess& process, VAddr dest_addr, const void* src_buffer,
                         std::size_t size) {
-    impl->WriteBlockImpl<false>(process, dest_addr, src_buffer, size);
+    impl->WriteBlock(process, dest_addr, src_buffer, size);
 }
 
 void Memory::WriteBlock(const VAddr dest_addr, const void* src_buffer, const std::size_t size) {
     impl->WriteBlock(dest_addr, src_buffer, size);
 }
 
+void Memory::WriteBlockUnsafe(const Kernel::KProcess& process, VAddr dest_addr,
+                              const void* src_buffer, std::size_t size) {
+    impl->WriteBlockUnsafe(process, dest_addr, src_buffer, size);
+}
+
 void Memory::WriteBlockUnsafe(const VAddr dest_addr, const void* src_buffer,
                               const std::size_t size) {
     impl->WriteBlockUnsafe(dest_addr, src_buffer, size);
 }
 
+void Memory::ZeroBlock(const Kernel::KProcess& process, VAddr dest_addr, std::size_t size) {
+    impl->ZeroBlock(process, dest_addr, size);
+}
+
+void Memory::ZeroBlock(VAddr dest_addr, std::size_t size) {
+    impl->ZeroBlock(dest_addr, size);
+}
+
 void Memory::CopyBlock(const Kernel::KProcess& process, VAddr dest_addr, VAddr src_addr,
                        const std::size_t size) {
     impl->CopyBlock(process, dest_addr, src_addr, size);
 }
 
+void Memory::CopyBlock(VAddr dest_addr, VAddr src_addr, std::size_t size) {
+    impl->CopyBlock(dest_addr, src_addr, size);
+}
+
 void Memory::RasterizerMarkRegionCached(VAddr vaddr, u64 size, bool cached) {
     impl->RasterizerMarkRegionCached(vaddr, size, cached);
 }
 
+bool IsKernelVirtualAddress(const VAddr vaddr) {
+    return KERNEL_REGION_VADDR <= vaddr && vaddr < KERNEL_REGION_END;
+}
+
 } // namespace Core::Memory

src/core/memory.h

@@ -39,6 +39,11 @@ enum : VAddr {
 
     /// Application stack
     DEFAULT_STACK_SIZE = 0x100000,
+
+    /// Kernel Virtual Address Range
+    KERNEL_REGION_VADDR = 0xFFFFFF8000000000,
+    KERNEL_REGION_SIZE = 0x7FFFE00000,
+    KERNEL_REGION_END = KERNEL_REGION_VADDR + KERNEL_REGION_SIZE,
 };
 
 /// Central class that handles all memory operations and state.
@@ -51,7 +56,7 @@ public:
     Memory& operator=(const Memory&) = delete;
 
     Memory(Memory&&) = default;
-    Memory& operator=(Memory&&) = delete;
+    Memory& operator=(Memory&&) = default;
 
     /**
      * Resets the state of the Memory system.
@@ -85,6 +90,17 @@ public:
      */
     void UnmapRegion(Common::PageTable& page_table, VAddr base, u64 size);
 
+    /**
+     * Checks whether or not the supplied address is a valid virtual
+     * address for the given process.
+     *
+     * @param process The emulated process to check the address against.
+     * @param vaddr   The virtual address to check the validity of.
+     *
+     * @returns True if the given virtual address is valid, false otherwise.
+     */
+    bool IsValidVirtualAddress(const Kernel::KProcess& process, VAddr vaddr) const;
+
     /**
      * Checks whether or not the supplied address is a valid virtual
      * address for the current process.
@@ -93,7 +109,7 @@ public:
      *
      * @returns True if the given virtual address is valid, false otherwise.
      */
-    [[nodiscard]] bool IsValidVirtualAddress(VAddr vaddr) const;
+    bool IsValidVirtualAddress(VAddr vaddr) const;
 
     /**
      * Gets a pointer to the given address.
@@ -118,7 +134,7 @@ public:
      * @returns The pointer to the given address, if the address is valid.
      *          If the address is not valid, nullptr will be returned.
      */
-    [[nodiscard]] const u8* GetPointer(VAddr vaddr) const;
+    const u8* GetPointer(VAddr vaddr) const;
 
     template <typename T>
     const T* GetPointer(VAddr vaddr) const {
@@ -311,6 +327,27 @@ public:
     void ReadBlock(const Kernel::KProcess& process, VAddr src_addr, void* dest_buffer,
                    std::size_t size);
 
+    /**
+     * Reads a contiguous block of bytes from a specified process' address space.
+     * This unsafe version does not trigger GPU flushing.
+     *
+     * @param process     The process to read the data from.
+     * @param src_addr    The virtual address to begin reading from.
+     * @param dest_buffer The buffer to place the read bytes into.
+     * @param size        The amount of data to read, in bytes.
+     *
+     * @note If a size of 0 is specified, then this function reads nothing and
+     *       no attempts to access memory are made at all.
+     *
+     * @pre dest_buffer must be at least size bytes in length, otherwise a
+     *      buffer overrun will occur.
+     *
+     * @post The range [dest_buffer, size) contains the read bytes from the
+     *       process' address space.
+     */
+    void ReadBlockUnsafe(const Kernel::KProcess& process, VAddr src_addr, void* dest_buffer,
+                         std::size_t size);
+
     /**
      * Reads a contiguous block of bytes from the current process' address space.
      *
@@ -371,6 +408,26 @@ public:
     void WriteBlock(const Kernel::KProcess& process, VAddr dest_addr, const void* src_buffer,
                     std::size_t size);
 
+    /**
+     * Writes a range of bytes into a given process' address space at the specified
+     * virtual address.
+     * This unsafe version does not invalidate GPU Memory.
+     *
+     * @param process    The process to write data into the address space of.
+     * @param dest_addr  The destination virtual address to begin writing the data at.
+     * @param src_buffer The data to write into the process' address space.
+     * @param size       The size of the data to write, in bytes.
+     *
+     * @post The address range [dest_addr, size) in the process' address space
+     *       contains the data that was within src_buffer.
+     *
+     * @post If an attempt is made to write into an unmapped region of memory, the writes
+     *       will be ignored and an error will be logged.
+     *
+     */
+    void WriteBlockUnsafe(const Kernel::KProcess& process, VAddr dest_addr, const void* src_buffer,
+                          std::size_t size);
+
     /**
      * Writes a range of bytes into the current process' address space at the specified
      * virtual address.
@@ -410,6 +467,29 @@ public:
      */
     void WriteBlockUnsafe(VAddr dest_addr, const void* src_buffer, std::size_t size);
 
+    /**
+     * Fills the specified address range within a process' address space with zeroes.
+     *
+     * @param process   The process that will have a portion of its memory zeroed out.
+     * @param dest_addr The starting virtual address of the range to zero out.
+     * @param size      The size of the address range to zero out, in bytes.
+     *
+     * @post The range [dest_addr, size) within the process' address space is
+     *       filled with zeroes.
+     */
+    void ZeroBlock(const Kernel::KProcess& process, VAddr dest_addr, std::size_t size);
+
+    /**
+     * Fills the specified address range within the current process' address space with zeroes.
+     *
+     * @param dest_addr The starting virtual address of the range to zero out.
+     * @param size      The size of the address range to zero out, in bytes.
+     *
+     * @post The range [dest_addr, size) within the current process' address space is
+     *       filled with zeroes.
+     */
+    void ZeroBlock(VAddr dest_addr, std::size_t size);
+
     /**
      * Copies data within a process' address space to another location within the
      * same address space.
@@ -425,6 +505,19 @@ public:
     void CopyBlock(const Kernel::KProcess& process, VAddr dest_addr, VAddr src_addr,
                    std::size_t size);
 
+    /**
+     * Copies data within the current process' address space to another location within the
+     * same address space.
+     *
+     * @param dest_addr The destination virtual address to begin copying the data into.
+     * @param src_addr  The source virtual address to begin copying the data from.
+     * @param size      The size of the data to copy, in bytes.
+     *
+     * @post The range [dest_addr, size) within the current process' address space
+     *       contains the same data within the range [src_addr, size).
+     */
+    void CopyBlock(VAddr dest_addr, VAddr src_addr, std::size_t size);
+
     /**
      * Marks each page within the specified address range as cached or uncached.
      *
@@ -442,4 +535,7 @@ private:
     std::unique_ptr<Impl> impl;
 };
 
+/// Determines if the given VAddr is a kernel address
+bool IsKernelVirtualAddress(VAddr vaddr);
+
 } // namespace Core::Memory

src/core/network/network.cpp

@@ -570,7 +570,7 @@ std::pair<s32, Errno> Socket::SendTo(u32 flags, const std::vector<u8>& message,
     ASSERT(flags == 0);
 
     const sockaddr* to = nullptr;
-    const int tolen = addr ? sizeof(sockaddr) : 0;
+    const int tolen = addr ? 0 : sizeof(sockaddr);
     sockaddr host_addr_in;
 
     if (addr) {

src/core/perf_stats.cpp

@@ -127,15 +127,15 @@ double PerfStats::GetLastFrameTimeScale() const {
     return duration_cast<DoubleSecs>(previous_frame_length).count() / FRAME_LENGTH;
 }
 
-void SpeedLimiter::DoSpeedLimiting(microseconds current_system_time_us) {
-    if (!Settings::values.use_speed_limit.GetValue() ||
+void FrameLimiter::DoFrameLimiting(microseconds current_system_time_us) {
+    if (!Settings::values.use_frame_limit.GetValue() ||
         Settings::values.use_multi_core.GetValue()) {
         return;
     }
 
     auto now = Clock::now();
 
-    const double sleep_scale = Settings::values.speed_limit.GetValue() / 100.0;
+    const double sleep_scale = Settings::values.frame_limit.GetValue() / 100.0;
 
     // Max lag caused by slow frames. Shouldn't be more than the length of a frame at the current
     // speed percent or it will clamp too much and prevent this from properly limiting to that
@@ -143,17 +143,17 @@ void SpeedLimiter::DoSpeedLimiting(microseconds current_system_time_us) {
     // limiting
     const microseconds max_lag_time_us = duration_cast<microseconds>(
         std::chrono::duration<double, std::chrono::microseconds::period>(25ms / sleep_scale));
-    speed_limiting_delta_err += duration_cast<microseconds>(
+    frame_limiting_delta_err += duration_cast<microseconds>(
         std::chrono::duration<double, std::chrono::microseconds::period>(
             (current_system_time_us - previous_system_time_us) / sleep_scale));
-    speed_limiting_delta_err -= duration_cast<microseconds>(now - previous_walltime);
-    speed_limiting_delta_err =
-        std::clamp(speed_limiting_delta_err, -max_lag_time_us, max_lag_time_us);
+    frame_limiting_delta_err -= duration_cast<microseconds>(now - previous_walltime);
+    frame_limiting_delta_err =
+        std::clamp(frame_limiting_delta_err, -max_lag_time_us, max_lag_time_us);
 
-    if (speed_limiting_delta_err > microseconds::zero()) {
-        std::this_thread::sleep_for(speed_limiting_delta_err);
+    if (frame_limiting_delta_err > microseconds::zero()) {
+        std::this_thread::sleep_for(frame_limiting_delta_err);
         auto now_after_sleep = Clock::now();
-        speed_limiting_delta_err -= duration_cast<microseconds>(now_after_sleep - now);
+        frame_limiting_delta_err -= duration_cast<microseconds>(now_after_sleep - now);
         now = now_after_sleep;
     }
 

src/core/perf_stats.h

@@ -85,11 +85,11 @@ private:
     double previous_fps = 0;
 };
 
-class SpeedLimiter {
+class FrameLimiter {
 public:
     using Clock = std::chrono::high_resolution_clock;
 
-    void DoSpeedLimiting(std::chrono::microseconds current_system_time_us);
+    void DoFrameLimiting(std::chrono::microseconds current_system_time_us);
 
 private:
     /// Emulated system time (in microseconds) at the last limiter invocation
@@ -98,7 +98,7 @@ private:
     Clock::time_point previous_walltime = Clock::now();
 
     /// Accumulated difference between walltime and emulated time
-    std::chrono::microseconds speed_limiting_delta_err{0};
+    std::chrono::microseconds frame_limiting_delta_err{0};
 };
 
 } // namespace Core

src/core/reporter.cpp

@@ -62,6 +62,7 @@ json GetYuzuVersionData() {
         {"build_date", std::string(Common::g_build_date)},
         {"build_fullname", std::string(Common::g_build_fullname)},
         {"build_version", std::string(Common::g_build_version)},
+        {"shader_cache_version", std::string(Common::g_shader_cache_version)},
     };
 }
 

src/core/telemetry_session.cpp

@@ -221,8 +221,8 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader,
              TranslateRenderer(Settings::values.renderer_backend.GetValue()));
     AddField(field_type, "Renderer_ResolutionFactor",
              Settings::values.resolution_factor.GetValue());
-    AddField(field_type, "Renderer_UseSpeedLimit", Settings::values.use_speed_limit.GetValue());
-    AddField(field_type, "Renderer_SpeedLimit", Settings::values.speed_limit.GetValue());
+    AddField(field_type, "Renderer_UseFrameLimit", Settings::values.use_frame_limit.GetValue());
+    AddField(field_type, "Renderer_FrameLimit", Settings::values.frame_limit.GetValue());
     AddField(field_type, "Renderer_UseDiskShaderCache",
              Settings::values.use_disk_shader_cache.GetValue());
     AddField(field_type, "Renderer_GPUAccuracyLevel",
@@ -233,8 +233,8 @@ void TelemetrySession::AddInitialInfo(Loader::AppLoader& app_loader,
              Settings::values.use_nvdec_emulation.GetValue());
     AddField(field_type, "Renderer_AccelerateASTC", Settings::values.accelerate_astc.GetValue());
     AddField(field_type, "Renderer_UseVsync", Settings::values.use_vsync.GetValue());
-    AddField(field_type, "Renderer_ShaderBackend",
-             static_cast<u32>(Settings::values.shader_backend.GetValue()));
+    AddField(field_type, "Renderer_UseAssemblyShaders",
+             Settings::values.use_assembly_shaders.GetValue());
     AddField(field_type, "Renderer_UseAsynchronousShaders",
              Settings::values.use_asynchronous_shaders.GetValue());
     AddField(field_type, "System_UseDockedMode", Settings::values.use_docked_mode.GetValue());

src/input_common/main.cpp

@@ -304,10 +304,10 @@ std::vector<std::unique_ptr<Polling::DevicePoller>> InputSubsystem::GetPollers([
 }
 
 std::string GenerateKeyboardParam(int key_code) {
-    Common::ParamPackage param;
-    param.Set("engine", "keyboard");
-    param.Set("code", key_code);
-    param.Set("toggle", false);
+    Common::ParamPackage param{
+        {"engine", "keyboard"},
+        {"code", std::to_string(key_code)},
+    };
     return param.Serialize();
 }
 

src/input_common/mouse/mouse_poller.cpp

@@ -57,7 +57,6 @@ Common::ParamPackage MouseButtonFactory::GetNextInput() const {
         if (pad.button != MouseInput::MouseButton::Undefined) {
             params.Set("engine", "mouse");
             params.Set("button", static_cast<u16>(pad.button));
-            params.Set("toggle", false);
             return params;
         }
     }

src/input_common/sdl/sdl_impl.cpp

@@ -82,12 +82,6 @@ public:
         state.buttons.insert_or_assign(button, value);
     }
 
-    void PreSetButton(int button) {
-        if (!state.buttons.contains(button)) {
-            SetButton(button, false);
-        }
-    }
-
     void SetMotion(SDL_ControllerSensorEvent event) {
         constexpr float gravity_constant = 9.80665f;
         std::lock_guard lock{mutex};
@@ -121,56 +115,14 @@ public:
         return state.buttons.at(button);
     }
 
-    bool ToggleButton(int button) {
-        std::lock_guard lock{mutex};
-
-        if (!state.toggle_buttons.contains(button) || !state.lock_buttons.contains(button)) {
-            state.toggle_buttons.insert_or_assign(button, false);
-            state.lock_buttons.insert_or_assign(button, false);
-        }
-
-        const bool button_state = state.toggle_buttons.at(button);
-        const bool button_lock = state.lock_buttons.at(button);
-
-        if (button_lock) {
-            return button_state;
-        }
-
-        state.lock_buttons.insert_or_assign(button, true);
-
-        if (button_state) {
-            state.toggle_buttons.insert_or_assign(button, false);
-        } else {
-            state.toggle_buttons.insert_or_assign(button, true);
-        }
-
-        return !button_state;
-    }
-
-    bool UnlockButton(int button) {
-        std::lock_guard lock{mutex};
-        if (!state.toggle_buttons.contains(button)) {
-            return false;
-        }
-        state.lock_buttons.insert_or_assign(button, false);
-        return state.toggle_buttons.at(button);
-    }
-
     void SetAxis(int axis, Sint16 value) {
         std::lock_guard lock{mutex};
         state.axes.insert_or_assign(axis, value);
     }
 
-    void PreSetAxis(int axis) {
-        if (!state.axes.contains(axis)) {
-            SetAxis(axis, 0);
-        }
-    }
-
-    float GetAxis(int axis, float range, float offset) const {
+    float GetAxis(int axis, float range) const {
         std::lock_guard lock{mutex};
-        const float value = static_cast<float>(state.axes.at(axis)) / 32767.0f;
-        return (value + offset) / range;
+        return static_cast<float>(state.axes.at(axis)) / (32767.0f * range);
     }
 
     bool RumblePlay(u16 amp_low, u16 amp_high) {
@@ -187,10 +139,9 @@ public:
         return false;
     }
 
-    std::tuple<float, float> GetAnalog(int axis_x, int axis_y, float range, float offset_x,
-                                       float offset_y) const {
-        float x = GetAxis(axis_x, range, offset_x);
-        float y = GetAxis(axis_y, range, offset_y);
+    std::tuple<float, float> GetAnalog(int axis_x, int axis_y, float range) const {
+        float x = GetAxis(axis_x, range);
+        float y = GetAxis(axis_y, range);
         y = -y; // 3DS uses an y-axis inverse from SDL
 
         // Make sure the coordinates are in the unit circle,
@@ -290,8 +241,6 @@ public:
 private:
     struct State {
         std::unordered_map<int, bool> buttons;
-        std::unordered_map<int, bool> toggle_buttons{};
-        std::unordered_map<int, bool> lock_buttons{};
         std::unordered_map<int, Sint16> axes;
         std::unordered_map<int, Uint8> hats;
     } state;
@@ -453,25 +402,16 @@ void SDLState::CloseJoysticks() {
 
 class SDLButton final : public Input::ButtonDevice {
 public:
-    explicit SDLButton(std::shared_ptr<SDLJoystick> joystick_, int button_, bool toggle_)
-        : joystick(std::move(joystick_)), button(button_), toggle(toggle_) {}
+    explicit SDLButton(std::shared_ptr<SDLJoystick> joystick_, int button_)
+        : joystick(std::move(joystick_)), button(button_) {}
 
     bool GetStatus() const override {
-        const bool button_state = joystick->GetButton(button);
-        if (!toggle) {
-            return button_state;
-        }
-
-        if (button_state) {
-            return joystick->ToggleButton(button);
-        }
-        return joystick->UnlockButton(button);
+        return joystick->GetButton(button);
     }
 
 private:
     std::shared_ptr<SDLJoystick> joystick;
     int button;
-    bool toggle;
 };
 
 class SDLDirectionButton final : public Input::ButtonDevice {
@@ -497,7 +437,7 @@ public:
           trigger_if_greater(trigger_if_greater_) {}
 
     bool GetStatus() const override {
-        const float axis_value = joystick->GetAxis(axis, 1.0f, 0.0f);
+        const float axis_value = joystick->GetAxis(axis, 1.0f);
         if (trigger_if_greater) {
             return axis_value > threshold;
         }
@@ -514,14 +454,12 @@ private:
 class SDLAnalog final : public Input::AnalogDevice {
 public:
     explicit SDLAnalog(std::shared_ptr<SDLJoystick> joystick_, int axis_x_, int axis_y_,
-                       bool invert_x_, bool invert_y_, float deadzone_, float range_,
-                       float offset_x_, float offset_y_)
+                       bool invert_x_, bool invert_y_, float deadzone_, float range_)
         : joystick(std::move(joystick_)), axis_x(axis_x_), axis_y(axis_y_), invert_x(invert_x_),
-          invert_y(invert_y_), deadzone(deadzone_), range(range_), offset_x(offset_x_),
-          offset_y(offset_y_) {}
+          invert_y(invert_y_), deadzone(deadzone_), range(range_) {}
 
     std::tuple<float, float> GetStatus() const override {
-        auto [x, y] = joystick->GetAnalog(axis_x, axis_y, range, offset_x, offset_y);
+        auto [x, y] = joystick->GetAnalog(axis_x, axis_y, range);
         const float r = std::sqrt((x * x) + (y * y));
         if (invert_x) {
             x = -x;
@@ -538,8 +476,8 @@ public:
     }
 
     std::tuple<float, float> GetRawStatus() const override {
-        const float x = joystick->GetAxis(axis_x, range, offset_x);
-        const float y = joystick->GetAxis(axis_y, range, offset_y);
+        const float x = joystick->GetAxis(axis_x, range);
+        const float y = joystick->GetAxis(axis_y, range);
         return {x, -y};
     }
 
@@ -571,8 +509,6 @@ private:
     const bool invert_y;
     const float deadzone;
     const float range;
-    const float offset_x;
-    const float offset_y;
 };
 
 class SDLVibration final : public Input::VibrationDevice {
@@ -639,7 +575,7 @@ public:
           trigger_if_greater(trigger_if_greater_) {}
 
     Input::MotionStatus GetStatus() const override {
-        const float axis_value = joystick->GetAxis(axis, 1.0f, 0.0f);
+        const float axis_value = joystick->GetAxis(axis, 1.0f);
         bool trigger = axis_value < threshold;
         if (trigger_if_greater) {
             trigger = axis_value > threshold;
@@ -699,7 +635,6 @@ public:
     std::unique_ptr<Input::ButtonDevice> Create(const Common::ParamPackage& params) override {
         const std::string guid = params.Get("guid", "0");
         const int port = params.Get("port", 0);
-        const auto toggle = params.Get("toggle", false);
 
         auto joystick = state.GetSDLJoystickByGUID(guid, port);
 
@@ -725,8 +660,7 @@ public:
 
         if (params.Has("axis")) {
             const int axis = params.Get("axis", 0);
-            // Convert range from (0.0, 1.0) to (-1.0, 1.0)
-            const float threshold = (params.Get("threshold", 0.5f) - 0.5f) * 2.0f;
+            const float threshold = params.Get("threshold", 0.5f);
             const std::string direction_name = params.Get("direction", "");
             bool trigger_if_greater;
             if (direction_name == "+") {
@@ -738,14 +672,14 @@ public:
                 LOG_ERROR(Input, "Unknown direction {}", direction_name);
             }
             // This is necessary so accessing GetAxis with axis won't crash
-            joystick->PreSetAxis(axis);
+            joystick->SetAxis(axis, 0);
             return std::make_unique<SDLAxisButton>(joystick, axis, threshold, trigger_if_greater);
         }
 
         const int button = params.Get("button", 0);
         // This is necessary so accessing GetButton with button won't crash
-        joystick->PreSetButton(button);
-        return std::make_unique<SDLButton>(joystick, button, toggle);
+        joystick->SetButton(button, false);
+        return std::make_unique<SDLButton>(joystick, button);
     }
 
 private:
@@ -775,15 +709,13 @@ public:
         const std::string invert_y_value = params.Get("invert_y", "+");
         const bool invert_x = invert_x_value == "-";
         const bool invert_y = invert_y_value == "-";
-        const float offset_x = params.Get("offset_x", 0.0f);
-        const float offset_y = params.Get("offset_y", 0.0f);
         auto joystick = state.GetSDLJoystickByGUID(guid, port);
 
         // This is necessary so accessing GetAxis with axis_x and axis_y won't crash
-        joystick->PreSetAxis(axis_x);
-        joystick->PreSetAxis(axis_y);
+        joystick->SetAxis(axis_x, 0);
+        joystick->SetAxis(axis_y, 0);
         return std::make_unique<SDLAnalog>(joystick, axis_x, axis_y, invert_x, invert_y, deadzone,
-                                           range, offset_x, offset_y);
+                                           range);
     }
 
 private:
@@ -864,13 +796,13 @@ public:
                 LOG_ERROR(Input, "Unknown direction {}", direction_name);
             }
             // This is necessary so accessing GetAxis with axis won't crash
-            joystick->PreSetAxis(axis);
+            joystick->SetAxis(axis, 0);
             return std::make_unique<SDLAxisMotion>(joystick, axis, threshold, trigger_if_greater);
         }
 
         const int button = params.Get("button", 0);
         // This is necessary so accessing GetButton with button won't crash
-        joystick->PreSetButton(button);
+        joystick->SetButton(button, false);
         return std::make_unique<SDLButtonMotion>(joystick, button);
     }
 
@@ -889,9 +821,6 @@ SDLState::SDLState() {
     RegisterFactory<VibrationDevice>("sdl", vibration_factory);
     RegisterFactory<MotionDevice>("sdl", motion_factory);
 
-    // Disable raw input. When enabled this setting causes SDL to die when a web applet opens
-    SDL_SetHint(SDL_HINT_JOYSTICK_RAWINPUT, "0");
-
     // Enable HIDAPI rumble. This prevents SDL from disabling motion on PS4 and PS5 controllers
     SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_PS4_RUMBLE, "1");
     SDL_SetHint(SDL_HINT_JOYSTICK_HIDAPI_PS5_RUMBLE, "1");
@@ -1004,11 +933,12 @@ Common::ParamPackage BuildAnalogParamPackageForButton(int port, std::string guid
     params.Set("port", port);
     params.Set("guid", std::move(guid));
     params.Set("axis", axis);
-    params.Set("threshold", "0.5");
     if (value > 0) {
         params.Set("direction", "+");
+        params.Set("threshold", "0.5");
     } else {
         params.Set("direction", "-");
+        params.Set("threshold", "-0.5");
     }
     return params;
 }
@@ -1018,7 +948,6 @@ Common::ParamPackage BuildButtonParamPackageForButton(int port, std::string guid
     params.Set("port", port);
     params.Set("guid", std::move(guid));
     params.Set("button", button);
-    params.Set("toggle", false);
     return params;
 }
 
@@ -1158,15 +1087,13 @@ Common::ParamPackage BuildParamPackageForBinding(int port, const std::string& gu
 }
 
 Common::ParamPackage BuildParamPackageForAnalog(int port, const std::string& guid, int axis_x,
-                                                int axis_y, float offset_x, float offset_y) {
+                                                int axis_y) {
     Common::ParamPackage params;
     params.Set("engine", "sdl");
     params.Set("port", port);
     params.Set("guid", guid);
     params.Set("axis_x", axis_x);
     params.Set("axis_y", axis_y);
-    params.Set("offset_x", offset_x);
-    params.Set("offset_y", offset_y);
     params.Set("invert_x", "+");
     params.Set("invert_y", "+");
     return params;
@@ -1368,39 +1295,24 @@ AnalogMapping SDLState::GetAnalogMappingForDevice(const Common::ParamPackage& pa
     const auto& binding_left_y =
         SDL_GameControllerGetBindForAxis(controller, SDL_CONTROLLER_AXIS_LEFTY);
     if (params.Has("guid2")) {
-        joystick2->PreSetAxis(binding_left_x.value.axis);
-        joystick2->PreSetAxis(binding_left_y.value.axis);
-        const auto left_offset_x = -joystick2->GetAxis(binding_left_x.value.axis, 1.0f, 0);
-        const auto left_offset_y = -joystick2->GetAxis(binding_left_y.value.axis, 1.0f, 0);
         mapping.insert_or_assign(
             Settings::NativeAnalog::LStick,
             BuildParamPackageForAnalog(joystick2->GetPort(), joystick2->GetGUID(),
-                                       binding_left_x.value.axis, binding_left_y.value.axis,
-                                       left_offset_x, left_offset_y));
+                                       binding_left_x.value.axis, binding_left_y.value.axis));
     } else {
-        joystick->PreSetAxis(binding_left_x.value.axis);
-        joystick->PreSetAxis(binding_left_y.value.axis);
-        const auto left_offset_x = -joystick->GetAxis(binding_left_x.value.axis, 1.0f, 0);
-        const auto left_offset_y = -joystick->GetAxis(binding_left_y.value.axis, 1.0f, 0);
         mapping.insert_or_assign(
             Settings::NativeAnalog::LStick,
             BuildParamPackageForAnalog(joystick->GetPort(), joystick->GetGUID(),
-                                       binding_left_x.value.axis, binding_left_y.value.axis,
-                                       left_offset_x, left_offset_y));
+                                       binding_left_x.value.axis, binding_left_y.value.axis));
     }
     const auto& binding_right_x =
         SDL_GameControllerGetBindForAxis(controller, SDL_CONTROLLER_AXIS_RIGHTX);
     const auto& binding_right_y =
         SDL_GameControllerGetBindForAxis(controller, SDL_CONTROLLER_AXIS_RIGHTY);
-    joystick->PreSetAxis(binding_right_x.value.axis);
-    joystick->PreSetAxis(binding_right_y.value.axis);
-    const auto right_offset_x = -joystick->GetAxis(binding_right_x.value.axis, 1.0f, 0);
-    const auto right_offset_y = -joystick->GetAxis(binding_right_y.value.axis, 1.0f, 0);
     mapping.insert_or_assign(Settings::NativeAnalog::RStick,
                              BuildParamPackageForAnalog(joystick->GetPort(), joystick->GetGUID(),
                                                         binding_right_x.value.axis,
-                                                        binding_right_y.value.axis, right_offset_x,
-                                                        right_offset_y));
+                                                        binding_right_y.value.axis));
     return mapping;
 }
 
@@ -1604,9 +1516,8 @@ public:
             }
 
             if (const auto joystick = state.GetSDLJoystickBySDLID(event.jaxis.which)) {
-                // Set offset to zero since the joystick is not on center
                 auto params = BuildParamPackageForAnalog(joystick->GetPort(), joystick->GetGUID(),
-                                                         first_axis, axis, 0, 0);
+                                                         first_axis, axis);
                 first_axis = -1;
                 return params;
             }

src/shader_recompiler/CMakeLists.txt

@@ -1,268 +0,0 @@
-add_library(shader_recompiler STATIC
-    backend/bindings.h
-    backend/glasm/emit_context.cpp
-    backend/glasm/emit_context.h
-    backend/glasm/emit_glasm.cpp
-    backend/glasm/emit_glasm.h
-    backend/glasm/emit_glasm_barriers.cpp
-    backend/glasm/emit_glasm_bitwise_conversion.cpp
-    backend/glasm/emit_glasm_composite.cpp
-    backend/glasm/emit_glasm_context_get_set.cpp
-    backend/glasm/emit_glasm_control_flow.cpp
-    backend/glasm/emit_glasm_convert.cpp
-    backend/glasm/emit_glasm_floating_point.cpp
-    backend/glasm/emit_glasm_image.cpp
-    backend/glasm/emit_glasm_instructions.h
-    backend/glasm/emit_glasm_integer.cpp
-    backend/glasm/emit_glasm_logical.cpp
-    backend/glasm/emit_glasm_memory.cpp
-    backend/glasm/emit_glasm_not_implemented.cpp
-    backend/glasm/emit_glasm_select.cpp
-    backend/glasm/emit_glasm_shared_memory.cpp
-    backend/glasm/emit_glasm_special.cpp
-    backend/glasm/emit_glasm_undefined.cpp
-    backend/glasm/emit_glasm_warp.cpp
-    backend/glasm/reg_alloc.cpp
-    backend/glasm/reg_alloc.h
-    backend/glsl/emit_context.cpp
-    backend/glsl/emit_context.h
-    backend/glsl/emit_glsl.cpp
-    backend/glsl/emit_glsl.h
-    backend/glsl/emit_glsl_atomic.cpp
-    backend/glsl/emit_glsl_barriers.cpp
-    backend/glsl/emit_glsl_bitwise_conversion.cpp
-    backend/glsl/emit_glsl_composite.cpp
-    backend/glsl/emit_glsl_context_get_set.cpp
-    backend/glsl/emit_glsl_control_flow.cpp
-    backend/glsl/emit_glsl_convert.cpp
-    backend/glsl/emit_glsl_floating_point.cpp
-    backend/glsl/emit_glsl_image.cpp
-    backend/glsl/emit_glsl_instructions.h
-    backend/glsl/emit_glsl_integer.cpp
-    backend/glsl/emit_glsl_logical.cpp
-    backend/glsl/emit_glsl_memory.cpp
-    backend/glsl/emit_glsl_not_implemented.cpp
-    backend/glsl/emit_glsl_select.cpp
-    backend/glsl/emit_glsl_shared_memory.cpp
-    backend/glsl/emit_glsl_special.cpp
-    backend/glsl/emit_glsl_undefined.cpp
-    backend/glsl/emit_glsl_warp.cpp
-    backend/glsl/var_alloc.cpp
-    backend/glsl/var_alloc.h
-    backend/spirv/emit_context.cpp
-    backend/spirv/emit_context.h
-    backend/spirv/emit_spirv.cpp
-    backend/spirv/emit_spirv.h
-    backend/spirv/emit_spirv_atomic.cpp
-    backend/spirv/emit_spirv_barriers.cpp
-    backend/spirv/emit_spirv_bitwise_conversion.cpp
-    backend/spirv/emit_spirv_composite.cpp
-    backend/spirv/emit_spirv_context_get_set.cpp
-    backend/spirv/emit_spirv_control_flow.cpp
-    backend/spirv/emit_spirv_convert.cpp
-    backend/spirv/emit_spirv_floating_point.cpp
-    backend/spirv/emit_spirv_image.cpp
-    backend/spirv/emit_spirv_image_atomic.cpp
-    backend/spirv/emit_spirv_instructions.h
-    backend/spirv/emit_spirv_integer.cpp
-    backend/spirv/emit_spirv_logical.cpp
-    backend/spirv/emit_spirv_memory.cpp
-    backend/spirv/emit_spirv_select.cpp
-    backend/spirv/emit_spirv_shared_memory.cpp
-    backend/spirv/emit_spirv_special.cpp
-    backend/spirv/emit_spirv_undefined.cpp
-    backend/spirv/emit_spirv_warp.cpp
-    environment.h
-    exception.h
-    frontend/ir/abstract_syntax_list.h
-    frontend/ir/attribute.cpp
-    frontend/ir/attribute.h
-    frontend/ir/basic_block.cpp
-    frontend/ir/basic_block.h
-    frontend/ir/breadth_first_search.h
-    frontend/ir/condition.cpp
-    frontend/ir/condition.h
-    frontend/ir/flow_test.cpp
-    frontend/ir/flow_test.h
-    frontend/ir/ir_emitter.cpp
-    frontend/ir/ir_emitter.h
-    frontend/ir/microinstruction.cpp
-    frontend/ir/modifiers.h
-    frontend/ir/opcodes.cpp
-    frontend/ir/opcodes.h
-    frontend/ir/opcodes.inc
-    frontend/ir/patch.cpp
-    frontend/ir/patch.h
-    frontend/ir/post_order.cpp
-    frontend/ir/post_order.h
-    frontend/ir/pred.h
-    frontend/ir/program.cpp
-    frontend/ir/program.h
-    frontend/ir/reg.h
-    frontend/ir/type.cpp
-    frontend/ir/type.h
-    frontend/ir/value.cpp
-    frontend/ir/value.h
-    frontend/maxwell/control_flow.cpp
-    frontend/maxwell/control_flow.h
-    frontend/maxwell/decode.cpp
-    frontend/maxwell/decode.h
-    frontend/maxwell/indirect_branch_table_track.cpp
-    frontend/maxwell/indirect_branch_table_track.h
-    frontend/maxwell/instruction.h
-    frontend/maxwell/location.h
-    frontend/maxwell/maxwell.inc
-    frontend/maxwell/opcodes.cpp
-    frontend/maxwell/opcodes.h
-    frontend/maxwell/structured_control_flow.cpp
-    frontend/maxwell/structured_control_flow.h
-    frontend/maxwell/translate/impl/atomic_operations_global_memory.cpp
-    frontend/maxwell/translate/impl/atomic_operations_shared_memory.cpp
-    frontend/maxwell/translate/impl/attribute_memory_to_physical.cpp
-    frontend/maxwell/translate/impl/barrier_operations.cpp
-    frontend/maxwell/translate/impl/bitfield_extract.cpp
-    frontend/maxwell/translate/impl/bitfield_insert.cpp
-    frontend/maxwell/translate/impl/branch_indirect.cpp
-    frontend/maxwell/translate/impl/common_encoding.h
-    frontend/maxwell/translate/impl/common_funcs.cpp
-    frontend/maxwell/translate/impl/common_funcs.h
-    frontend/maxwell/translate/impl/condition_code_set.cpp
-    frontend/maxwell/translate/impl/double_add.cpp
-    frontend/maxwell/translate/impl/double_compare_and_set.cpp
-    frontend/maxwell/translate/impl/double_fused_multiply_add.cpp
-    frontend/maxwell/translate/impl/double_min_max.cpp
-    frontend/maxwell/translate/impl/double_multiply.cpp
-    frontend/maxwell/translate/impl/double_set_predicate.cpp
-    frontend/maxwell/translate/impl/exit_program.cpp
-    frontend/maxwell/translate/impl/find_leading_one.cpp
-    frontend/maxwell/translate/impl/floating_point_add.cpp
-    frontend/maxwell/translate/impl/floating_point_compare.cpp
-    frontend/maxwell/translate/impl/floating_point_compare_and_set.cpp
-    frontend/maxwell/translate/impl/floating_point_conversion_floating_point.cpp
-    frontend/maxwell/translate/impl/floating_point_conversion_integer.cpp
-    frontend/maxwell/translate/impl/floating_point_fused_multiply_add.cpp
-    frontend/maxwell/translate/impl/floating_point_min_max.cpp
-    frontend/maxwell/translate/impl/floating_point_multi_function.cpp
-    frontend/maxwell/translate/impl/floating_point_multiply.cpp
-    frontend/maxwell/translate/impl/floating_point_range_reduction.cpp
-    frontend/maxwell/translate/impl/floating_point_set_predicate.cpp
-    frontend/maxwell/translate/impl/floating_point_swizzled_add.cpp
-    frontend/maxwell/translate/impl/half_floating_point_add.cpp
-    frontend/maxwell/translate/impl/half_floating_point_fused_multiply_add.cpp
-    frontend/maxwell/translate/impl/half_floating_point_helper.cpp
-    frontend/maxwell/translate/impl/half_floating_point_helper.h
-    frontend/maxwell/translate/impl/half_floating_point_multiply.cpp
-    frontend/maxwell/translate/impl/half_floating_point_set.cpp
-    frontend/maxwell/translate/impl/half_floating_point_set_predicate.cpp
-    frontend/maxwell/translate/impl/impl.cpp
-    frontend/maxwell/translate/impl/impl.h
-    frontend/maxwell/translate/impl/integer_add.cpp
-    frontend/maxwell/translate/impl/integer_add_three_input.cpp
-    frontend/maxwell/translate/impl/integer_compare.cpp
-    frontend/maxwell/translate/impl/integer_compare_and_set.cpp
-    frontend/maxwell/translate/impl/integer_floating_point_conversion.cpp
-    frontend/maxwell/translate/impl/integer_funnel_shift.cpp
-    frontend/maxwell/translate/impl/integer_minimum_maximum.cpp
-    frontend/maxwell/translate/impl/integer_popcount.cpp
-    frontend/maxwell/translate/impl/integer_scaled_add.cpp
-    frontend/maxwell/translate/impl/integer_set_predicate.cpp
-    frontend/maxwell/translate/impl/integer_shift_left.cpp
-    frontend/maxwell/translate/impl/integer_shift_right.cpp
-    frontend/maxwell/translate/impl/integer_short_multiply_add.cpp
-    frontend/maxwell/translate/impl/integer_to_integer_conversion.cpp
-    frontend/maxwell/translate/impl/internal_stage_buffer_entry_read.cpp
-    frontend/maxwell/translate/impl/load_constant.cpp
-    frontend/maxwell/translate/impl/load_constant.h
-    frontend/maxwell/translate/impl/load_effective_address.cpp
-    frontend/maxwell/translate/impl/load_store_attribute.cpp
-    frontend/maxwell/translate/impl/load_store_local_shared.cpp
-    frontend/maxwell/translate/impl/load_store_memory.cpp
-    frontend/maxwell/translate/impl/logic_operation.cpp
-    frontend/maxwell/translate/impl/logic_operation_three_input.cpp
-    frontend/maxwell/translate/impl/move_predicate_to_register.cpp
-    frontend/maxwell/translate/impl/move_register.cpp
-    frontend/maxwell/translate/impl/move_register_to_predicate.cpp
-    frontend/maxwell/translate/impl/move_special_register.cpp
-    frontend/maxwell/translate/impl/not_implemented.cpp
-    frontend/maxwell/translate/impl/output_geometry.cpp
-    frontend/maxwell/translate/impl/pixel_load.cpp
-    frontend/maxwell/translate/impl/predicate_set_predicate.cpp
-    frontend/maxwell/translate/impl/predicate_set_register.cpp
-    frontend/maxwell/translate/impl/select_source_with_predicate.cpp
-    frontend/maxwell/translate/impl/surface_atomic_operations.cpp
-    frontend/maxwell/translate/impl/surface_load_store.cpp
-    frontend/maxwell/translate/impl/texture_fetch.cpp
-    frontend/maxwell/translate/impl/texture_fetch_swizzled.cpp
-    frontend/maxwell/translate/impl/texture_gather.cpp
-    frontend/maxwell/translate/impl/texture_gather_swizzled.cpp
-    frontend/maxwell/translate/impl/texture_gradient.cpp
-    frontend/maxwell/translate/impl/texture_load.cpp
-    frontend/maxwell/translate/impl/texture_load_swizzled.cpp
-    frontend/maxwell/translate/impl/texture_mipmap_level.cpp
-    frontend/maxwell/translate/impl/texture_query.cpp
-    frontend/maxwell/translate/impl/video_helper.cpp
-    frontend/maxwell/translate/impl/video_helper.h
-    frontend/maxwell/translate/impl/video_minimum_maximum.cpp
-    frontend/maxwell/translate/impl/video_multiply_add.cpp
-    frontend/maxwell/translate/impl/video_set_predicate.cpp
-    frontend/maxwell/translate/impl/vote.cpp
-    frontend/maxwell/translate/impl/warp_shuffle.cpp
-    frontend/maxwell/translate/translate.cpp
-    frontend/maxwell/translate/translate.h
-    frontend/maxwell/translate_program.cpp
-    frontend/maxwell/translate_program.h
-    host_translate_info.h
-    ir_opt/collect_shader_info_pass.cpp
-    ir_opt/constant_propagation_pass.cpp
-    ir_opt/dead_code_elimination_pass.cpp
-    ir_opt/dual_vertex_pass.cpp
-    ir_opt/global_memory_to_storage_buffer_pass.cpp
-    ir_opt/identity_removal_pass.cpp
-    ir_opt/lower_fp16_to_fp32.cpp
-    ir_opt/lower_int64_to_int32.cpp
-    ir_opt/passes.h
-    ir_opt/ssa_rewrite_pass.cpp
-    ir_opt/texture_pass.cpp
-    ir_opt/verification_pass.cpp
-    object_pool.h
-    profile.h
-    program_header.h
-    runtime_info.h
-    shader_info.h
-    varying_state.h
-)
-
-target_link_libraries(shader_recompiler PUBLIC common fmt::fmt sirit)
-
-if (MSVC)
-    target_compile_options(shader_recompiler PRIVATE
-        /W4
-        /WX
-        /we4018 # 'expression' : signed/unsigned mismatch
-        /we4244 # 'argument' : conversion from 'type1' to 'type2', possible loss of data (floating-point)
-        /we4245 # 'conversion' : conversion from 'type1' to 'type2', signed/unsigned mismatch
-        /we4254 # 'operator': conversion from 'type1:field_bits' to 'type2:field_bits', possible loss of data
-        /we4267 # 'var' : conversion from 'size_t' to 'type', possible loss of data
-        /we4305 # 'context' : truncation from 'type1' to 'type2'
-        /we4800 # Implicit conversion from 'type' to bool. Possible information loss
-        /we4826 # Conversion from 'type1' to 'type2' is sign-extended. This may cause unexpected runtime behavior.
-    )
-else()
-    target_compile_options(shader_recompiler PRIVATE
-        -Werror
-        -Werror=conversion
-        -Werror=ignored-qualifiers
-        -Werror=implicit-fallthrough
-        -Werror=shadow
-        -Werror=sign-compare
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-parameter>
-        $<$<CXX_COMPILER_ID:GNU>:-Werror=unused-but-set-variable>
-        -Werror=unused-variable
-
-        # Bracket depth determines maximum size of a fold expression in Clang since 9c9974c3ccb6.
-        # And this in turns limits the size of a std::array.
-        $<$<CXX_COMPILER_ID:Clang>:-fbracket-depth=1024>
-    )
-endif()
-
-create_target_directory_groups(shader_recompiler)

src/shader_recompiler/backend/bindings.h

@@ -1,19 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-
-namespace Shader::Backend {
-
-struct Bindings {
-    u32 unified{};
-    u32 uniform_buffer{};
-    u32 storage_buffer{};
-    u32 texture{};
-    u32 image{};
-};
-
-} // namespace Shader::Backend

src/shader_recompiler/backend/glasm/emit_context.cpp

@@ -1,154 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <string_view>
-
-#include "shader_recompiler/backend/bindings.h"
-#include "shader_recompiler/backend/glasm/emit_context.h"
-#include "shader_recompiler/frontend/ir/program.h"
-#include "shader_recompiler/profile.h"
-#include "shader_recompiler/runtime_info.h"
-
-namespace Shader::Backend::GLASM {
-namespace {
-std::string_view InterpDecorator(Interpolation interp) {
-    switch (interp) {
-    case Interpolation::Smooth:
-        return "";
-    case Interpolation::Flat:
-        return "FLAT ";
-    case Interpolation::NoPerspective:
-        return "NOPERSPECTIVE ";
-    }
-    throw InvalidArgument("Invalid interpolation {}", interp);
-}
-
-bool IsInputArray(Stage stage) {
-    return stage == Stage::Geometry || stage == Stage::TessellationControl ||
-           stage == Stage::TessellationEval;
-}
-} // Anonymous namespace
-
-EmitContext::EmitContext(IR::Program& program, Bindings& bindings, const Profile& profile_,
-                         const RuntimeInfo& runtime_info_)
-    : info{program.info}, profile{profile_}, runtime_info{runtime_info_} {
-    // FIXME: Temporary partial implementation
-    u32 cbuf_index{};
-    for (const auto& desc : info.constant_buffer_descriptors) {
-        if (desc.count != 1) {
-            throw NotImplementedException("Constant buffer descriptor array");
-        }
-        Add("CBUFFER c{}[]={{program.buffer[{}]}};", desc.index, cbuf_index);
-        ++cbuf_index;
-    }
-    u32 ssbo_index{};
-    for (const auto& desc : info.storage_buffers_descriptors) {
-        if (desc.count != 1) {
-            throw NotImplementedException("Storage buffer descriptor array");
-        }
-        if (runtime_info.glasm_use_storage_buffers) {
-            Add("STORAGE ssbo{}[]={{program.storage[{}]}};", ssbo_index, bindings.storage_buffer);
-            ++bindings.storage_buffer;
-            ++ssbo_index;
-        }
-    }
-    if (!runtime_info.glasm_use_storage_buffers) {
-        if (const size_t num = info.storage_buffers_descriptors.size(); num > 0) {
-            Add("PARAM c[{}]={{program.local[0..{}]}};", num, num - 1);
-        }
-    }
-    stage = program.stage;
-    switch (program.stage) {
-    case Stage::VertexA:
-    case Stage::VertexB:
-        stage_name = "vertex";
-        attrib_name = "vertex";
-        break;
-    case Stage::TessellationControl:
-    case Stage::TessellationEval:
-        stage_name = "primitive";
-        attrib_name = "primitive";
-        break;
-    case Stage::Geometry:
-        stage_name = "primitive";
-        attrib_name = "vertex";
-        break;
-    case Stage::Fragment:
-        stage_name = "fragment";
-        attrib_name = "fragment";
-        break;
-    case Stage::Compute:
-        stage_name = "invocation";
-        break;
-    }
-    const std::string_view attr_stage{stage == Stage::Fragment ? "fragment" : "vertex"};
-    const VaryingState loads{info.loads.mask | info.passthrough.mask};
-    for (size_t index = 0; index < IR::NUM_GENERICS; ++index) {
-        if (loads.Generic(index)) {
-            Add("{}ATTRIB in_attr{}[]={{{}.attrib[{}..{}]}};",
-                InterpDecorator(info.interpolation[index]), index, attr_stage, index, index);
-        }
-    }
-    if (IsInputArray(stage) && loads.AnyComponent(IR::Attribute::PositionX)) {
-        Add("ATTRIB vertex_position=vertex.position;");
-    }
-    if (info.uses_invocation_id) {
-        Add("ATTRIB primitive_invocation=primitive.invocation;");
-    }
-    if (info.stores_tess_level_outer) {
-        Add("OUTPUT result_patch_tessouter[]={{result.patch.tessouter[0..3]}};");
-    }
-    if (info.stores_tess_level_inner) {
-        Add("OUTPUT result_patch_tessinner[]={{result.patch.tessinner[0..1]}};");
-    }
-    if (info.stores.ClipDistances()) {
-        Add("OUTPUT result_clip[]={{result.clip[0..7]}};");
-    }
-    for (size_t index = 0; index < info.uses_patches.size(); ++index) {
-        if (!info.uses_patches[index]) {
-            continue;
-        }
-        if (stage == Stage::TessellationControl) {
-            Add("OUTPUT result_patch_attrib{}[]={{result.patch.attrib[{}..{}]}};"
-                "ATTRIB primitive_out_patch_attrib{}[]={{primitive.out.patch.attrib[{}..{}]}};",
-                index, index, index, index, index, index);
-        } else {
-            Add("ATTRIB primitive_patch_attrib{}[]={{primitive.patch.attrib[{}..{}]}};", index,
-                index, index);
-        }
-    }
-    if (stage == Stage::Fragment) {
-        Add("OUTPUT frag_color0=result.color;");
-        for (size_t index = 1; index < info.stores_frag_color.size(); ++index) {
-            Add("OUTPUT frag_color{}=result.color[{}];", index, index);
-        }
-    }
-    for (size_t index = 0; index < IR::NUM_GENERICS; ++index) {
-        if (info.stores.Generic(index)) {
-            Add("OUTPUT out_attr{}[]={{result.attrib[{}..{}]}};", index, index, index);
-        }
-    }
-    image_buffer_bindings.reserve(info.image_buffer_descriptors.size());
-    for (const auto& desc : info.image_buffer_descriptors) {
-        image_buffer_bindings.push_back(bindings.image);
-        bindings.image += desc.count;
-    }
-    image_bindings.reserve(info.image_descriptors.size());
-    for (const auto& desc : info.image_descriptors) {
-        image_bindings.push_back(bindings.image);
-        bindings.image += desc.count;
-    }
-    texture_buffer_bindings.reserve(info.texture_buffer_descriptors.size());
-    for (const auto& desc : info.texture_buffer_descriptors) {
-        texture_buffer_bindings.push_back(bindings.texture);
-        bindings.texture += desc.count;
-    }
-    texture_bindings.reserve(info.texture_descriptors.size());
-    for (const auto& desc : info.texture_descriptors) {
-        texture_bindings.push_back(bindings.texture);
-        bindings.texture += desc.count;
-    }
-}
-
-} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_context.h

@@ -1,80 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-#include <utility>
-#include <vector>
-
-#include <fmt/format.h>
-
-#include "shader_recompiler/backend/glasm/reg_alloc.h"
-#include "shader_recompiler/stage.h"
-
-namespace Shader {
-struct Info;
-struct Profile;
-struct RuntimeInfo;
-} // namespace Shader
-
-namespace Shader::Backend {
-struct Bindings;
-}
-
-namespace Shader::IR {
-class Inst;
-struct Program;
-} // namespace Shader::IR
-
-namespace Shader::Backend::GLASM {
-
-class EmitContext {
-public:
-    explicit EmitContext(IR::Program& program, Bindings& bindings, const Profile& profile_,
-                         const RuntimeInfo& runtime_info_);
-
-    template <typename... Args>
-    void Add(const char* format_str, IR::Inst& inst, Args&&... args) {
-        code += fmt::format(fmt::runtime(format_str), reg_alloc.Define(inst),
-                            std::forward<Args>(args)...);
-        // TODO: Remove this
-        code += '\n';
-    }
-
-    template <typename... Args>
-    void LongAdd(const char* format_str, IR::Inst& inst, Args&&... args) {
-        code += fmt::format(fmt::runtime(format_str), reg_alloc.LongDefine(inst),
-                            std::forward<Args>(args)...);
-        // TODO: Remove this
-        code += '\n';
-    }
-
-    template <typename... Args>
-    void Add(const char* format_str, Args&&... args) {
-        code += fmt::format(fmt::runtime(format_str), std::forward<Args>(args)...);
-        // TODO: Remove this
-        code += '\n';
-    }
-
-    std::string code;
-    RegAlloc reg_alloc{};
-    const Info& info;
-    const Profile& profile;
-    const RuntimeInfo& runtime_info;
-
-    std::vector<u32> texture_buffer_bindings;
-    std::vector<u32> image_buffer_bindings;
-    std::vector<u32> texture_bindings;
-    std::vector<u32> image_bindings;
-
-    Stage stage{};
-    std::string_view stage_name = "invalid";
-    std::string_view attrib_name = "invalid";
-
-    u32 num_safety_loop_vars{};
-    bool uses_y_direction{};
-};
-
-} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm.cpp

@@ -1,492 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <algorithm>
-#include <string>
-#include <tuple>
-
-#include "common/div_ceil.h"
-#include "common/settings.h"
-#include "shader_recompiler/backend/bindings.h"
-#include "shader_recompiler/backend/glasm/emit_context.h"
-#include "shader_recompiler/backend/glasm/emit_glasm.h"
-#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
-#include "shader_recompiler/frontend/ir/ir_emitter.h"
-#include "shader_recompiler/frontend/ir/program.h"
-#include "shader_recompiler/profile.h"
-#include "shader_recompiler/runtime_info.h"
-
-namespace Shader::Backend::GLASM {
-namespace {
-template <class Func>
-struct FuncTraits {};
-
-template <class ReturnType_, class... Args>
-struct FuncTraits<ReturnType_ (*)(Args...)> {
-    using ReturnType = ReturnType_;
-
-    static constexpr size_t NUM_ARGS = sizeof...(Args);
-
-    template <size_t I>
-    using ArgType = std::tuple_element_t<I, std::tuple<Args...>>;
-};
-
-template <typename T>
-struct Identity {
-    Identity(T data_) : data{data_} {}
-
-    T Extract() {
-        return data;
-    }
-
-    T data;
-};
-
-template <bool scalar>
-class RegWrapper {
-public:
-    RegWrapper(EmitContext& ctx, const IR::Value& ir_value) : reg_alloc{ctx.reg_alloc} {
-        const Value value{reg_alloc.Peek(ir_value)};
-        if (value.type == Type::Register) {
-            inst = ir_value.InstRecursive();
-            reg = Register{value};
-        } else {
-            reg = value.type == Type::U64 ? reg_alloc.AllocLongReg() : reg_alloc.AllocReg();
-        }
-        switch (value.type) {
-        case Type::Register:
-        case Type::Void:
-            break;
-        case Type::U32:
-            ctx.Add("MOV.U {}.x,{};", reg, value.imm_u32);
-            break;
-        case Type::U64:
-            ctx.Add("MOV.U64 {}.x,{};", reg, value.imm_u64);
-            break;
-        }
-    }
-
-    auto Extract() {
-        if (inst) {
-            reg_alloc.Unref(*inst);
-        } else {
-            reg_alloc.FreeReg(reg);
-        }
-        return std::conditional_t<scalar, ScalarRegister, Register>{Value{reg}};
-    }
-
-private:
-    RegAlloc& reg_alloc;
-    IR::Inst* inst{};
-    Register reg{};
-};
-
-template <typename ArgType>
-class ValueWrapper {
-public:
-    ValueWrapper(EmitContext& ctx, const IR::Value& ir_value_)
-        : reg_alloc{ctx.reg_alloc}, ir_value{ir_value_}, value{reg_alloc.Peek(ir_value)} {}
-
-    ArgType Extract() {
-        if (!ir_value.IsImmediate()) {
-            reg_alloc.Unref(*ir_value.InstRecursive());
-        }
-        return value;
-    }
-
-private:
-    RegAlloc& reg_alloc;
-    const IR::Value& ir_value;
-    ArgType value;
-};
-
-template <typename ArgType>
-auto Arg(EmitContext& ctx, const IR::Value& arg) {
-    if constexpr (std::is_same_v<ArgType, Register>) {
-        return RegWrapper<false>{ctx, arg};
-    } else if constexpr (std::is_same_v<ArgType, ScalarRegister>) {
-        return RegWrapper<true>{ctx, arg};
-    } else if constexpr (std::is_base_of_v<Value, ArgType>) {
-        return ValueWrapper<ArgType>{ctx, arg};
-    } else if constexpr (std::is_same_v<ArgType, const IR::Value&>) {
-        return Identity<const IR::Value&>{arg};
-    } else if constexpr (std::is_same_v<ArgType, u32>) {
-        return Identity{arg.U32()};
-    } else if constexpr (std::is_same_v<ArgType, IR::Attribute>) {
-        return Identity{arg.Attribute()};
-    } else if constexpr (std::is_same_v<ArgType, IR::Patch>) {
-        return Identity{arg.Patch()};
-    } else if constexpr (std::is_same_v<ArgType, IR::Reg>) {
-        return Identity{arg.Reg()};
-    }
-}
-
-template <auto func, bool is_first_arg_inst>
-struct InvokeCall {
-    template <typename... Args>
-    InvokeCall(EmitContext& ctx, IR::Inst* inst, Args&&... args) {
-        if constexpr (is_first_arg_inst) {
-            func(ctx, *inst, args.Extract()...);
-        } else {
-            func(ctx, args.Extract()...);
-        }
-    }
-};
-
-template <auto func, bool is_first_arg_inst, size_t... I>
-void Invoke(EmitContext& ctx, IR::Inst* inst, std::index_sequence<I...>) {
-    using Traits = FuncTraits<decltype(func)>;
-    if constexpr (is_first_arg_inst) {
-        InvokeCall<func, is_first_arg_inst>{
-            ctx, inst, Arg<typename Traits::template ArgType<I + 2>>(ctx, inst->Arg(I))...};
-    } else {
-        InvokeCall<func, is_first_arg_inst>{
-            ctx, inst, Arg<typename Traits::template ArgType<I + 1>>(ctx, inst->Arg(I))...};
-    }
-}
-
-template <auto func>
-void Invoke(EmitContext& ctx, IR::Inst* inst) {
-    using Traits = FuncTraits<decltype(func)>;
-    static_assert(Traits::NUM_ARGS >= 1, "Insufficient arguments");
-    if constexpr (Traits::NUM_ARGS == 1) {
-        Invoke<func, false>(ctx, inst, std::make_index_sequence<0>{});
-    } else {
-        using FirstArgType = typename Traits::template ArgType<1>;
-        static constexpr bool is_first_arg_inst = std::is_same_v<FirstArgType, IR::Inst&>;
-        using Indices = std::make_index_sequence<Traits::NUM_ARGS - (is_first_arg_inst ? 2 : 1)>;
-        Invoke<func, is_first_arg_inst>(ctx, inst, Indices{});
-    }
-}
-
-void EmitInst(EmitContext& ctx, IR::Inst* inst) {
-    switch (inst->GetOpcode()) {
-#define OPCODE(name, result_type, ...)                                                             \
-    case IR::Opcode::name:                                                                         \
-        return Invoke<&Emit##name>(ctx, inst);
-#include "shader_recompiler/frontend/ir/opcodes.inc"
-#undef OPCODE
-    }
-    throw LogicError("Invalid opcode {}", inst->GetOpcode());
-}
-
-bool IsReference(IR::Inst& inst) {
-    return inst.GetOpcode() == IR::Opcode::Reference;
-}
-
-void PrecolorInst(IR::Inst& phi) {
-    // Insert phi moves before references to avoid overwritting other phis
-    const size_t num_args{phi.NumArgs()};
-    for (size_t i = 0; i < num_args; ++i) {
-        IR::Block& phi_block{*phi.PhiBlock(i)};
-        auto it{std::find_if_not(phi_block.rbegin(), phi_block.rend(), IsReference).base()};
-        IR::IREmitter ir{phi_block, it};
-        const IR::Value arg{phi.Arg(i)};
-        if (arg.IsImmediate()) {
-            ir.PhiMove(phi, arg);
-        } else {
-            ir.PhiMove(phi, IR::Value{&RegAlloc::AliasInst(*arg.Inst())});
-        }
-    }
-    for (size_t i = 0; i < num_args; ++i) {
-        IR::IREmitter{*phi.PhiBlock(i)}.Reference(IR::Value{&phi});
-    }
-}
-
-void Precolor(const IR::Program& program) {
-    for (IR::Block* const block : program.blocks) {
-        for (IR::Inst& phi : block->Instructions()) {
-            if (!IR::IsPhi(phi)) {
-                break;
-            }
-            PrecolorInst(phi);
-        }
-    }
-}
-
-void EmitCode(EmitContext& ctx, const IR::Program& program) {
-    const auto eval{
-        [&](const IR::U1& cond) { return ScalarS32{ctx.reg_alloc.Consume(IR::Value{cond})}; }};
-    for (const IR::AbstractSyntaxNode& node : program.syntax_list) {
-        switch (node.type) {
-        case IR::AbstractSyntaxNode::Type::Block:
-            for (IR::Inst& inst : node.data.block->Instructions()) {
-                EmitInst(ctx, &inst);
-            }
-            break;
-        case IR::AbstractSyntaxNode::Type::If:
-            ctx.Add("MOV.S.CC RC,{};"
-                    "IF NE.x;",
-                    eval(node.data.if_node.cond));
-            break;
-        case IR::AbstractSyntaxNode::Type::EndIf:
-            ctx.Add("ENDIF;");
-            break;
-        case IR::AbstractSyntaxNode::Type::Loop:
-            ctx.Add("REP;");
-            break;
-        case IR::AbstractSyntaxNode::Type::Repeat:
-            if (!Settings::values.disable_shader_loop_safety_checks) {
-                const u32 loop_index{ctx.num_safety_loop_vars++};
-                const u32 vector_index{loop_index / 4};
-                const char component{"xyzw"[loop_index % 4]};
-                ctx.Add("SUB.S.CC loop{}.{},loop{}.{},1;"
-                        "BRK(LT.{});",
-                        vector_index, component, vector_index, component, component);
-            }
-            if (node.data.repeat.cond.IsImmediate()) {
-                if (node.data.repeat.cond.U1()) {
-                    ctx.Add("ENDREP;");
-                } else {
-                    ctx.Add("BRK;"
-                            "ENDREP;");
-                }
-            } else {
-                ctx.Add("MOV.S.CC RC,{};"
-                        "BRK(EQ.x);"
-                        "ENDREP;",
-                        eval(node.data.repeat.cond));
-            }
-            break;
-        case IR::AbstractSyntaxNode::Type::Break:
-            if (node.data.break_node.cond.IsImmediate()) {
-                if (node.data.break_node.cond.U1()) {
-                    ctx.Add("BRK;");
-                }
-            } else {
-                ctx.Add("MOV.S.CC RC,{};"
-                        "BRK (NE.x);",
-                        eval(node.data.break_node.cond));
-            }
-            break;
-        case IR::AbstractSyntaxNode::Type::Return:
-        case IR::AbstractSyntaxNode::Type::Unreachable:
-            ctx.Add("RET;");
-            break;
-        }
-    }
-    if (!ctx.reg_alloc.IsEmpty()) {
-        LOG_WARNING(Shader_GLASM, "Register leak after generating code");
-    }
-}
-
-void SetupOptions(const IR::Program& program, const Profile& profile,
-                  const RuntimeInfo& runtime_info, std::string& header) {
-    const Info& info{program.info};
-    const Stage stage{program.stage};
-
-    // TODO: Track the shared atomic ops
-    header += "OPTION NV_internal;"
-              "OPTION NV_shader_storage_buffer;"
-              "OPTION NV_gpu_program_fp64;";
-    if (info.uses_int64_bit_atomics) {
-        header += "OPTION NV_shader_atomic_int64;";
-    }
-    if (info.uses_atomic_f32_add) {
-        header += "OPTION NV_shader_atomic_float;";
-    }
-    if (info.uses_atomic_f16x2_add || info.uses_atomic_f16x2_min || info.uses_atomic_f16x2_max) {
-        header += "OPTION NV_shader_atomic_fp16_vector;";
-    }
-    if (info.uses_subgroup_invocation_id || info.uses_subgroup_mask || info.uses_subgroup_vote ||
-        info.uses_fswzadd) {
-        header += "OPTION NV_shader_thread_group;";
-    }
-    if (info.uses_subgroup_shuffles) {
-        header += "OPTION NV_shader_thread_shuffle;";
-    }
-    if (info.uses_sparse_residency) {
-        header += "OPTION EXT_sparse_texture2;";
-    }
-    const bool stores_viewport_layer{info.stores[IR::Attribute::ViewportIndex] ||
-                                     info.stores[IR::Attribute::Layer]};
-    if ((stage != Stage::Geometry && stores_viewport_layer) ||
-        info.stores[IR::Attribute::ViewportMask]) {
-        if (profile.support_viewport_index_layer_non_geometry) {
-            header += "OPTION NV_viewport_array2;";
-        }
-    }
-    if (program.is_geometry_passthrough && profile.support_geometry_shader_passthrough) {
-        header += "OPTION NV_geometry_shader_passthrough;";
-    }
-    if (info.uses_typeless_image_reads && profile.support_typeless_image_loads) {
-        header += "OPTION EXT_shader_image_load_formatted;";
-    }
-    if (profile.support_derivative_control) {
-        header += "OPTION ARB_derivative_control;";
-    }
-    if (stage == Stage::Fragment && runtime_info.force_early_z != 0) {
-        header += "OPTION NV_early_fragment_tests;";
-    }
-    if (stage == Stage::Fragment) {
-        header += "OPTION ARB_draw_buffers;";
-    }
-}
-
-std::string_view StageHeader(Stage stage) {
-    switch (stage) {
-    case Stage::VertexA:
-    case Stage::VertexB:
-        return "!!NVvp5.0\n";
-    case Stage::TessellationControl:
-        return "!!NVtcp5.0\n";
-    case Stage::TessellationEval:
-        return "!!NVtep5.0\n";
-    case Stage::Geometry:
-        return "!!NVgp5.0\n";
-    case Stage::Fragment:
-        return "!!NVfp5.0\n";
-    case Stage::Compute:
-        return "!!NVcp5.0\n";
-    }
-    throw InvalidArgument("Invalid stage {}", stage);
-}
-
-std::string_view InputPrimitive(InputTopology topology) {
-    switch (topology) {
-    case InputTopology::Points:
-        return "POINTS";
-    case InputTopology::Lines:
-        return "LINES";
-    case InputTopology::LinesAdjacency:
-        return "LINES_ADJACENCY";
-    case InputTopology::Triangles:
-        return "TRIANGLES";
-    case InputTopology::TrianglesAdjacency:
-        return "TRIANGLES_ADJACENCY";
-    }
-    throw InvalidArgument("Invalid input topology {}", topology);
-}
-
-std::string_view OutputPrimitive(OutputTopology topology) {
-    switch (topology) {
-    case OutputTopology::PointList:
-        return "POINTS";
-    case OutputTopology::LineStrip:
-        return "LINE_STRIP";
-    case OutputTopology::TriangleStrip:
-        return "TRIANGLE_STRIP";
-    }
-    throw InvalidArgument("Invalid output topology {}", topology);
-}
-
-std::string_view GetTessMode(TessPrimitive primitive) {
-    switch (primitive) {
-    case TessPrimitive::Triangles:
-        return "TRIANGLES";
-    case TessPrimitive::Quads:
-        return "QUADS";
-    case TessPrimitive::Isolines:
-        return "ISOLINES";
-    }
-    throw InvalidArgument("Invalid tessellation primitive {}", primitive);
-}
-
-std::string_view GetTessSpacing(TessSpacing spacing) {
-    switch (spacing) {
-    case TessSpacing::Equal:
-        return "EQUAL";
-    case TessSpacing::FractionalOdd:
-        return "FRACTIONAL_ODD";
-    case TessSpacing::FractionalEven:
-        return "FRACTIONAL_EVEN";
-    }
-    throw InvalidArgument("Invalid tessellation spacing {}", spacing);
-}
-} // Anonymous namespace
-
-std::string EmitGLASM(const Profile& profile, const RuntimeInfo& runtime_info, IR::Program& program,
-                      Bindings& bindings) {
-    EmitContext ctx{program, bindings, profile, runtime_info};
-    Precolor(program);
-    EmitCode(ctx, program);
-    std::string header{StageHeader(program.stage)};
-    SetupOptions(program, profile, runtime_info, header);
-    switch (program.stage) {
-    case Stage::TessellationControl:
-        header += fmt::format("VERTICES_OUT {};", program.invocations);
-        break;
-    case Stage::TessellationEval:
-        header += fmt::format("TESS_MODE {};"
-                              "TESS_SPACING {};"
-                              "TESS_VERTEX_ORDER {};",
-                              GetTessMode(runtime_info.tess_primitive),
-                              GetTessSpacing(runtime_info.tess_spacing),
-                              runtime_info.tess_clockwise ? "CW" : "CCW");
-        break;
-    case Stage::Geometry:
-        header += fmt::format("PRIMITIVE_IN {};", InputPrimitive(runtime_info.input_topology));
-        if (program.is_geometry_passthrough) {
-            if (profile.support_geometry_shader_passthrough) {
-                for (size_t index = 0; index < IR::NUM_GENERICS; ++index) {
-                    if (program.info.passthrough.Generic(index)) {
-                        header += fmt::format("PASSTHROUGH result.attrib[{}];", index);
-                    }
-                }
-                if (program.info.passthrough.AnyComponent(IR::Attribute::PositionX)) {
-                    header += "PASSTHROUGH result.position;";
-                }
-            } else {
-                LOG_WARNING(Shader_GLASM, "Passthrough geometry program used but not supported");
-            }
-        } else {
-            header +=
-                fmt::format("VERTICES_OUT {};"
-                            "PRIMITIVE_OUT {};",
-                            program.output_vertices, OutputPrimitive(program.output_topology));
-        }
-        break;
-    case Stage::Compute:
-        header += fmt::format("GROUP_SIZE {} {} {};", program.workgroup_size[0],
-                              program.workgroup_size[1], program.workgroup_size[2]);
-        break;
-    default:
-        break;
-    }
-    if (program.shared_memory_size > 0) {
-        header += fmt::format("SHARED_MEMORY {};", program.shared_memory_size);
-        header += fmt::format("SHARED shared_mem[]={{program.sharedmem}};");
-    }
-    header += "TEMP ";
-    for (size_t index = 0; index < ctx.reg_alloc.NumUsedRegisters(); ++index) {
-        header += fmt::format("R{},", index);
-    }
-    if (program.local_memory_size > 0) {
-        header += fmt::format("lmem[{}],", program.local_memory_size);
-    }
-    if (program.info.uses_fswzadd) {
-        header += "FSWZA[4],FSWZB[4],";
-    }
-    const u32 num_safety_loop_vectors{Common::DivCeil(ctx.num_safety_loop_vars, 4u)};
-    for (u32 index = 0; index < num_safety_loop_vectors; ++index) {
-        header += fmt::format("loop{},", index);
-    }
-    header += "RC;"
-              "LONG TEMP ";
-    for (size_t index = 0; index < ctx.reg_alloc.NumUsedLongRegisters(); ++index) {
-        header += fmt::format("D{},", index);
-    }
-    header += "DC;";
-    if (program.info.uses_fswzadd) {
-        header += "MOV.F FSWZA[0],-1;"
-                  "MOV.F FSWZA[1],1;"
-                  "MOV.F FSWZA[2],-1;"
-                  "MOV.F FSWZA[3],0;"
-                  "MOV.F FSWZB[0],-1;"
-                  "MOV.F FSWZB[1],-1;"
-                  "MOV.F FSWZB[2],1;"
-                  "MOV.F FSWZB[3],-1;";
-    }
-    for (u32 index = 0; index < num_safety_loop_vectors; ++index) {
-        header += fmt::format("MOV.S loop{},{{0x2000,0x2000,0x2000,0x2000}};", index);
-    }
-    if (ctx.uses_y_direction) {
-        header += "PARAM y_direction[1]={state.material.front.ambient};";
-    }
-    ctx.code.insert(0, header);
-    ctx.code += "END";
-    return ctx.code;
-}
-
-} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm.h

@@ -1,25 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include <string>
-
-#include "shader_recompiler/backend/bindings.h"
-#include "shader_recompiler/frontend/ir/program.h"
-#include "shader_recompiler/profile.h"
-#include "shader_recompiler/runtime_info.h"
-
-namespace Shader::Backend::GLASM {
-
-[[nodiscard]] std::string EmitGLASM(const Profile& profile, const RuntimeInfo& runtime_info,
-                                    IR::Program& program, Bindings& bindings);
-
-[[nodiscard]] inline std::string EmitGLASM(const Profile& profile, const RuntimeInfo& runtime_info,
-                                           IR::Program& program) {
-    Bindings binding;
-    return EmitGLASM(profile, runtime_info, program, binding);
-}
-
-} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_bitwise_conversion.cpp

@@ -1,91 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "shader_recompiler/backend/glasm/emit_context.h"
-#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
-#include "shader_recompiler/frontend/ir/value.h"
-
-namespace Shader::Backend::GLASM {
-
-static void Alias(IR::Inst& inst, const IR::Value& value) {
-    if (value.IsImmediate()) {
-        return;
-    }
-    IR::Inst& value_inst{RegAlloc::AliasInst(*value.Inst())};
-    value_inst.DestructiveAddUsage(inst.UseCount());
-    value_inst.DestructiveRemoveUsage();
-    inst.SetDefinition(value_inst.Definition<Id>());
-}
-
-void EmitIdentity(EmitContext&, IR::Inst& inst, const IR::Value& value) {
-    Alias(inst, value);
-}
-
-void EmitConditionRef(EmitContext& ctx, IR::Inst& inst, const IR::Value& value) {
-    // Fake one usage to get a real register out of the condition
-    inst.DestructiveAddUsage(1);
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    const ScalarS32 input{ctx.reg_alloc.Consume(value)};
-    if (ret != input) {
-        ctx.Add("MOV.S {},{};", ret, input);
-    }
-}
-
-void EmitBitCastU16F16(EmitContext&, IR::Inst& inst, const IR::Value& value) {
-    Alias(inst, value);
-}
-
-void EmitBitCastU32F32(EmitContext&, IR::Inst& inst, const IR::Value& value) {
-    Alias(inst, value);
-}
-
-void EmitBitCastU64F64(EmitContext&, IR::Inst& inst, const IR::Value& value) {
-    Alias(inst, value);
-}
-
-void EmitBitCastF16U16(EmitContext&, IR::Inst& inst, const IR::Value& value) {
-    Alias(inst, value);
-}
-
-void EmitBitCastF32U32(EmitContext&, IR::Inst& inst, const IR::Value& value) {
-    Alias(inst, value);
-}
-
-void EmitBitCastF64U64(EmitContext&, IR::Inst& inst, const IR::Value& value) {
-    Alias(inst, value);
-}
-
-void EmitPackUint2x32(EmitContext& ctx, IR::Inst& inst, Register value) {
-    ctx.LongAdd("PK64.U {}.x,{};", inst, value);
-}
-
-void EmitUnpackUint2x32(EmitContext& ctx, IR::Inst& inst, Register value) {
-    ctx.Add("UP64.U {}.xy,{}.x;", inst, value);
-}
-
-void EmitPackFloat2x16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitUnpackFloat2x16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitPackHalf2x16(EmitContext& ctx, IR::Inst& inst, Register value) {
-    ctx.Add("PK2H {}.x,{};", inst, value);
-}
-
-void EmitUnpackHalf2x16(EmitContext& ctx, IR::Inst& inst, Register value) {
-    ctx.Add("UP2H {}.xy,{}.x;", inst, value);
-}
-
-void EmitPackDouble2x32(EmitContext& ctx, IR::Inst& inst, Register value) {
-    ctx.LongAdd("PK64 {}.x,{};", inst, value);
-}
-
-void EmitUnpackDouble2x32(EmitContext& ctx, IR::Inst& inst, Register value) {
-    ctx.Add("UP64 {}.xy,{}.x;", inst, value);
-}
-
-} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_composite.cpp

@@ -1,244 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "shader_recompiler/backend/glasm/emit_context.h"
-#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
-#include "shader_recompiler/frontend/ir/value.h"
-
-namespace Shader::Backend::GLASM {
-namespace {
-template <auto read_imm, char type, typename... Values>
-void CompositeConstruct(EmitContext& ctx, IR::Inst& inst, Values&&... elements) {
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    if (std::ranges::any_of(std::array{elements...},
-                            [](const IR::Value& value) { return value.IsImmediate(); })) {
-        using Type = std::invoke_result_t<decltype(read_imm), IR::Value>;
-        const std::array<Type, 4> values{(elements.IsImmediate() ? (elements.*read_imm)() : 0)...};
-        ctx.Add("MOV.{} {},{{{},{},{},{}}};", type, ret, fmt::to_string(values[0]),
-                fmt::to_string(values[1]), fmt::to_string(values[2]), fmt::to_string(values[3]));
-    }
-    size_t index{};
-    for (const IR::Value& element : {elements...}) {
-        if (!element.IsImmediate()) {
-            const ScalarU32 value{ctx.reg_alloc.Consume(element)};
-            ctx.Add("MOV.{} {}.{},{};", type, ret, "xyzw"[index], value);
-        }
-        ++index;
-    }
-}
-
-void CompositeExtract(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index, char type) {
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    if (ret == composite && index == 0) {
-        // No need to do anything here, the source and destination are the same register
-        return;
-    }
-    ctx.Add("MOV.{} {}.x,{}.{};", type, ret, composite, "xyzw"[index]);
-}
-
-template <typename ObjectType>
-void CompositeInsert(EmitContext& ctx, IR::Inst& inst, Register composite, ObjectType object,
-                     u32 index, char type) {
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    const char swizzle{"xyzw"[index]};
-    if (ret != composite && ret == object) {
-        // The object is aliased with the return value, so we have to use a temporary to insert
-        ctx.Add("MOV.{} RC,{};"
-                "MOV.{} RC.{},{};"
-                "MOV.{} {},RC;",
-                type, composite, type, swizzle, object, type, ret);
-    } else if (ret != composite) {
-        // The input composite is not aliased with the return value so we have to copy it before
-        // hand. But the insert object is not aliased with the return value, so we don't have to
-        // worry about that
-        ctx.Add("MOV.{} {},{};"
-                "MOV.{} {}.{},{};",
-                type, ret, composite, type, ret, swizzle, object);
-    } else {
-        // The return value is alised so we can just insert the object, it doesn't matter if it's
-        // aliased
-        ctx.Add("MOV.{} {}.{},{};", type, ret, swizzle, object);
-    }
-}
-} // Anonymous namespace
-
-void EmitCompositeConstructU32x2(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
-                                 const IR::Value& e2) {
-    CompositeConstruct<&IR::Value::U32, 'U'>(ctx, inst, e1, e2);
-}
-
-void EmitCompositeConstructU32x3(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
-                                 const IR::Value& e2, const IR::Value& e3) {
-    CompositeConstruct<&IR::Value::U32, 'U'>(ctx, inst, e1, e2, e3);
-}
-
-void EmitCompositeConstructU32x4(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
-                                 const IR::Value& e2, const IR::Value& e3, const IR::Value& e4) {
-    CompositeConstruct<&IR::Value::U32, 'U'>(ctx, inst, e1, e2, e3, e4);
-}
-
-void EmitCompositeExtractU32x2(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index) {
-    CompositeExtract(ctx, inst, composite, index, 'U');
-}
-
-void EmitCompositeExtractU32x3(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index) {
-    CompositeExtract(ctx, inst, composite, index, 'U');
-}
-
-void EmitCompositeExtractU32x4(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index) {
-    CompositeExtract(ctx, inst, composite, index, 'U');
-}
-
-void EmitCompositeInsertU32x2([[maybe_unused]] EmitContext& ctx,
-                              [[maybe_unused]] Register composite,
-                              [[maybe_unused]] ScalarU32 object, [[maybe_unused]] u32 index) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeInsertU32x3([[maybe_unused]] EmitContext& ctx,
-                              [[maybe_unused]] Register composite,
-                              [[maybe_unused]] ScalarU32 object, [[maybe_unused]] u32 index) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeInsertU32x4([[maybe_unused]] EmitContext& ctx,
-                              [[maybe_unused]] Register composite,
-                              [[maybe_unused]] ScalarU32 object, [[maybe_unused]] u32 index) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeConstructF16x2([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register e1,
-                                 [[maybe_unused]] Register e2) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeConstructF16x3([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register e1,
-                                 [[maybe_unused]] Register e2, [[maybe_unused]] Register e3) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeConstructF16x4([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register e1,
-                                 [[maybe_unused]] Register e2, [[maybe_unused]] Register e3,
-                                 [[maybe_unused]] Register e4) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeExtractF16x2([[maybe_unused]] EmitContext& ctx,
-                               [[maybe_unused]] Register composite, [[maybe_unused]] u32 index) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeExtractF16x3([[maybe_unused]] EmitContext& ctx,
-                               [[maybe_unused]] Register composite, [[maybe_unused]] u32 index) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeExtractF16x4([[maybe_unused]] EmitContext& ctx,
-                               [[maybe_unused]] Register composite, [[maybe_unused]] u32 index) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeInsertF16x2([[maybe_unused]] EmitContext& ctx,
-                              [[maybe_unused]] Register composite, [[maybe_unused]] Register object,
-                              [[maybe_unused]] u32 index) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeInsertF16x3([[maybe_unused]] EmitContext& ctx,
-                              [[maybe_unused]] Register composite, [[maybe_unused]] Register object,
-                              [[maybe_unused]] u32 index) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeInsertF16x4([[maybe_unused]] EmitContext& ctx,
-                              [[maybe_unused]] Register composite, [[maybe_unused]] Register object,
-                              [[maybe_unused]] u32 index) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeConstructF32x2(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
-                                 const IR::Value& e2) {
-    CompositeConstruct<&IR::Value::F32, 'F'>(ctx, inst, e1, e2);
-}
-
-void EmitCompositeConstructF32x3(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
-                                 const IR::Value& e2, const IR::Value& e3) {
-    CompositeConstruct<&IR::Value::F32, 'F'>(ctx, inst, e1, e2, e3);
-}
-
-void EmitCompositeConstructF32x4(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
-                                 const IR::Value& e2, const IR::Value& e3, const IR::Value& e4) {
-    CompositeConstruct<&IR::Value::F32, 'F'>(ctx, inst, e1, e2, e3, e4);
-}
-
-void EmitCompositeExtractF32x2(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index) {
-    CompositeExtract(ctx, inst, composite, index, 'F');
-}
-
-void EmitCompositeExtractF32x3(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index) {
-    CompositeExtract(ctx, inst, composite, index, 'F');
-}
-
-void EmitCompositeExtractF32x4(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index) {
-    CompositeExtract(ctx, inst, composite, index, 'F');
-}
-
-void EmitCompositeInsertF32x2(EmitContext& ctx, IR::Inst& inst, Register composite,
-                              ScalarF32 object, u32 index) {
-    CompositeInsert(ctx, inst, composite, object, index, 'F');
-}
-
-void EmitCompositeInsertF32x3(EmitContext& ctx, IR::Inst& inst, Register composite,
-                              ScalarF32 object, u32 index) {
-    CompositeInsert(ctx, inst, composite, object, index, 'F');
-}
-
-void EmitCompositeInsertF32x4(EmitContext& ctx, IR::Inst& inst, Register composite,
-                              ScalarF32 object, u32 index) {
-    CompositeInsert(ctx, inst, composite, object, index, 'F');
-}
-
-void EmitCompositeConstructF64x2([[maybe_unused]] EmitContext& ctx) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeConstructF64x3([[maybe_unused]] EmitContext& ctx) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeConstructF64x4([[maybe_unused]] EmitContext& ctx) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeExtractF64x2([[maybe_unused]] EmitContext& ctx) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeExtractF64x3([[maybe_unused]] EmitContext& ctx) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeExtractF64x4([[maybe_unused]] EmitContext& ctx) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeInsertF64x2([[maybe_unused]] EmitContext& ctx,
-                              [[maybe_unused]] Register composite, [[maybe_unused]] Register object,
-                              [[maybe_unused]] u32 index) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeInsertF64x3([[maybe_unused]] EmitContext& ctx,
-                              [[maybe_unused]] Register composite, [[maybe_unused]] Register object,
-                              [[maybe_unused]] u32 index) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitCompositeInsertF64x4([[maybe_unused]] EmitContext& ctx,
-                              [[maybe_unused]] Register composite, [[maybe_unused]] Register object,
-                              [[maybe_unused]] u32 index) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_context_get_set.cpp

@@ -1,346 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <string_view>
-
-#include "shader_recompiler/backend/glasm/emit_context.h"
-#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
-#include "shader_recompiler/frontend/ir/value.h"
-#include "shader_recompiler/profile.h"
-#include "shader_recompiler/shader_info.h"
-
-namespace Shader::Backend::GLASM {
-namespace {
-void GetCbuf(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU32 offset,
-             std::string_view size) {
-    if (!binding.IsImmediate()) {
-        throw NotImplementedException("Indirect constant buffer loading");
-    }
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    if (offset.type == Type::U32) {
-        // Avoid reading arrays out of bounds, matching hardware's behavior
-        if (offset.imm_u32 >= 0x10'000) {
-            ctx.Add("MOV.S {},0;", ret);
-            return;
-        }
-    }
-    ctx.Add("LDC.{} {},c{}[{}];", size, ret, binding.U32(), offset);
-}
-
-bool IsInputArray(Stage stage) {
-    return stage == Stage::Geometry || stage == Stage::TessellationControl ||
-           stage == Stage::TessellationEval;
-}
-
-std::string VertexIndex(EmitContext& ctx, ScalarU32 vertex) {
-    return IsInputArray(ctx.stage) ? fmt::format("[{}]", vertex) : "";
-}
-
-u32 TexCoordIndex(IR::Attribute attr) {
-    return (static_cast<u32>(attr) - static_cast<u32>(IR::Attribute::FixedFncTexture0S)) / 4;
-}
-} // Anonymous namespace
-
-void EmitGetCbufU8(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU32 offset) {
-    GetCbuf(ctx, inst, binding, offset, "U8");
-}
-
-void EmitGetCbufS8(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU32 offset) {
-    GetCbuf(ctx, inst, binding, offset, "S8");
-}
-
-void EmitGetCbufU16(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU32 offset) {
-    GetCbuf(ctx, inst, binding, offset, "U16");
-}
-
-void EmitGetCbufS16(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU32 offset) {
-    GetCbuf(ctx, inst, binding, offset, "S16");
-}
-
-void EmitGetCbufU32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU32 offset) {
-    GetCbuf(ctx, inst, binding, offset, "U32");
-}
-
-void EmitGetCbufF32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU32 offset) {
-    GetCbuf(ctx, inst, binding, offset, "F32");
-}
-
-void EmitGetCbufU32x2(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                      ScalarU32 offset) {
-    GetCbuf(ctx, inst, binding, offset, "U32X2");
-}
-
-void EmitGetAttribute(EmitContext& ctx, IR::Inst& inst, IR::Attribute attr, ScalarU32 vertex) {
-    const u32 element{static_cast<u32>(attr) % 4};
-    const char swizzle{"xyzw"[element]};
-    if (IR::IsGeneric(attr)) {
-        const u32 index{IR::GenericAttributeIndex(attr)};
-        ctx.Add("MOV.F {}.x,in_attr{}{}[0].{};", inst, index, VertexIndex(ctx, vertex), swizzle);
-        return;
-    }
-    if (attr >= IR::Attribute::FixedFncTexture0S && attr <= IR::Attribute::FixedFncTexture9Q) {
-        const u32 index{TexCoordIndex(attr)};
-        ctx.Add("MOV.F {}.x,{}.texcoord[{}].{};", inst, ctx.attrib_name, index, swizzle);
-        return;
-    }
-    switch (attr) {
-    case IR::Attribute::PrimitiveId:
-        ctx.Add("MOV.S {}.x,primitive.id;", inst);
-        break;
-    case IR::Attribute::PositionX:
-    case IR::Attribute::PositionY:
-    case IR::Attribute::PositionZ:
-    case IR::Attribute::PositionW:
-        if (IsInputArray(ctx.stage)) {
-            ctx.Add("MOV.F {}.x,vertex_position{}.{};", inst, VertexIndex(ctx, vertex), swizzle);
-        } else {
-            ctx.Add("MOV.F {}.x,{}.position.{};", inst, ctx.attrib_name, swizzle);
-        }
-        break;
-    case IR::Attribute::ColorFrontDiffuseR:
-    case IR::Attribute::ColorFrontDiffuseG:
-    case IR::Attribute::ColorFrontDiffuseB:
-    case IR::Attribute::ColorFrontDiffuseA:
-        ctx.Add("MOV.F {}.x,{}.color.{};", inst, ctx.attrib_name, swizzle);
-        break;
-    case IR::Attribute::PointSpriteS:
-    case IR::Attribute::PointSpriteT:
-        ctx.Add("MOV.F {}.x,{}.pointcoord.{};", inst, ctx.attrib_name, swizzle);
-        break;
-    case IR::Attribute::TessellationEvaluationPointU:
-    case IR::Attribute::TessellationEvaluationPointV:
-        ctx.Add("MOV.F {}.x,vertex.tesscoord.{};", inst, swizzle);
-        break;
-    case IR::Attribute::InstanceId:
-        ctx.Add("MOV.S {}.x,{}.instance;", inst, ctx.attrib_name);
-        break;
-    case IR::Attribute::VertexId:
-        ctx.Add("MOV.S {}.x,{}.id;", inst, ctx.attrib_name);
-        break;
-    case IR::Attribute::FrontFace:
-        ctx.Add("CMP.S {}.x,{}.facing.x,0,-1;", inst, ctx.attrib_name);
-        break;
-    default:
-        throw NotImplementedException("Get attribute {}", attr);
-    }
-}
-
-void EmitSetAttribute(EmitContext& ctx, IR::Attribute attr, ScalarF32 value,
-                      [[maybe_unused]] ScalarU32 vertex) {
-    const u32 element{static_cast<u32>(attr) % 4};
-    const char swizzle{"xyzw"[element]};
-    if (IR::IsGeneric(attr)) {
-        const u32 index{IR::GenericAttributeIndex(attr)};
-        ctx.Add("MOV.F out_attr{}[0].{},{};", index, swizzle, value);
-        return;
-    }
-    if (attr >= IR::Attribute::FixedFncTexture0S && attr <= IR::Attribute::FixedFncTexture9R) {
-        const u32 index{TexCoordIndex(attr)};
-        ctx.Add("MOV.F result.texcoord[{}].{},{};", index, swizzle, value);
-        return;
-    }
-    switch (attr) {
-    case IR::Attribute::Layer:
-        if (ctx.stage == Stage::Geometry || ctx.profile.support_viewport_index_layer_non_geometry) {
-            ctx.Add("MOV.F result.layer.x,{};", value);
-        } else {
-            LOG_WARNING(Shader_GLASM,
-                        "Layer stored outside of geometry shader not supported by device");
-        }
-        break;
-    case IR::Attribute::ViewportIndex:
-        if (ctx.stage == Stage::Geometry || ctx.profile.support_viewport_index_layer_non_geometry) {
-            ctx.Add("MOV.F result.viewport.x,{};", value);
-        } else {
-            LOG_WARNING(Shader_GLASM,
-                        "Viewport stored outside of geometry shader not supported by device");
-        }
-        break;
-    case IR::Attribute::ViewportMask:
-        // NV_viewport_array2 is required to access result.viewportmask, regardless of shader stage.
-        if (ctx.profile.support_viewport_index_layer_non_geometry) {
-            ctx.Add("MOV.F result.viewportmask[0].x,{};", value);
-        } else {
-            LOG_WARNING(Shader_GLASM, "Device does not support storing to ViewportMask");
-        }
-        break;
-    case IR::Attribute::PointSize:
-        ctx.Add("MOV.F result.pointsize.x,{};", value);
-        break;
-    case IR::Attribute::PositionX:
-    case IR::Attribute::PositionY:
-    case IR::Attribute::PositionZ:
-    case IR::Attribute::PositionW:
-        ctx.Add("MOV.F result.position.{},{};", swizzle, value);
-        break;
-    case IR::Attribute::ColorFrontDiffuseR:
-    case IR::Attribute::ColorFrontDiffuseG:
-    case IR::Attribute::ColorFrontDiffuseB:
-    case IR::Attribute::ColorFrontDiffuseA:
-        ctx.Add("MOV.F result.color.{},{};", swizzle, value);
-        break;
-    case IR::Attribute::ColorFrontSpecularR:
-    case IR::Attribute::ColorFrontSpecularG:
-    case IR::Attribute::ColorFrontSpecularB:
-    case IR::Attribute::ColorFrontSpecularA:
-        ctx.Add("MOV.F result.color.secondary.{},{};", swizzle, value);
-        break;
-    case IR::Attribute::ColorBackDiffuseR:
-    case IR::Attribute::ColorBackDiffuseG:
-    case IR::Attribute::ColorBackDiffuseB:
-    case IR::Attribute::ColorBackDiffuseA:
-        ctx.Add("MOV.F result.color.back.{},{};", swizzle, value);
-        break;
-    case IR::Attribute::ColorBackSpecularR:
-    case IR::Attribute::ColorBackSpecularG:
-    case IR::Attribute::ColorBackSpecularB:
-    case IR::Attribute::ColorBackSpecularA:
-        ctx.Add("MOV.F result.color.back.secondary.{},{};", swizzle, value);
-        break;
-    case IR::Attribute::FogCoordinate:
-        ctx.Add("MOV.F result.fogcoord.x,{};", value);
-        break;
-    case IR::Attribute::ClipDistance0:
-    case IR::Attribute::ClipDistance1:
-    case IR::Attribute::ClipDistance2:
-    case IR::Attribute::ClipDistance3:
-    case IR::Attribute::ClipDistance4:
-    case IR::Attribute::ClipDistance5:
-    case IR::Attribute::ClipDistance6:
-    case IR::Attribute::ClipDistance7: {
-        const u32 index{static_cast<u32>(attr) - static_cast<u32>(IR::Attribute::ClipDistance0)};
-        ctx.Add("MOV.F result.clip[{}].x,{};", index, value);
-        break;
-    }
-    default:
-        throw NotImplementedException("Set attribute {}", attr);
-    }
-}
-
-void EmitGetAttributeIndexed(EmitContext& ctx, IR::Inst& inst, ScalarS32 offset, ScalarU32 vertex) {
-    // RC.x = base_index
-    // RC.y = masked_index
-    // RC.z = compare_index
-    ctx.Add("SHR.S RC.x,{},2;"
-            "AND.S RC.y,RC.x,3;"
-            "SHR.S RC.z,{},4;",
-            offset, offset);
-
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    u32 num_endifs{};
-    const auto read{[&](u32 compare_index, const std::array<std::string, 4>& values) {
-        ++num_endifs;
-        ctx.Add("SEQ.S.CC RC.w,RC.z,{};" // compare_index
-                "IF NE.w;"
-                // X
-                "SEQ.S.CC RC.w,RC.y,0;"
-                "IF NE.w;"
-                "MOV {}.x,{};"
-                "ELSE;"
-                // Y
-                "SEQ.S.CC RC.w,RC.y,1;"
-                "IF NE.w;"
-                "MOV {}.x,{};"
-                "ELSE;"
-                // Z
-                "SEQ.S.CC RC.w,RC.y,2;"
-                "IF NE.w;"
-                "MOV {}.x,{};"
-                "ELSE;"
-                // W
-                "MOV {}.x,{};"
-                "ENDIF;"
-                "ENDIF;"
-                "ENDIF;"
-                "ELSE;",
-                compare_index, ret, values[0], ret, values[1], ret, values[2], ret, values[3]);
-    }};
-    const auto read_swizzled{[&](u32 compare_index, std::string_view value) {
-        const std::array values{fmt::format("{}.x", value), fmt::format("{}.y", value),
-                                fmt::format("{}.z", value), fmt::format("{}.w", value)};
-        read(compare_index, values);
-    }};
-    if (ctx.info.loads.AnyComponent(IR::Attribute::PositionX)) {
-        const u32 index{static_cast<u32>(IR::Attribute::PositionX)};
-        if (IsInputArray(ctx.stage)) {
-            read_swizzled(index, fmt::format("vertex_position{}", VertexIndex(ctx, vertex)));
-        } else {
-            read_swizzled(index, fmt::format("{}.position", ctx.attrib_name));
-        }
-    }
-    for (u32 index = 0; index < static_cast<u32>(IR::NUM_GENERICS); ++index) {
-        if (!ctx.info.loads.Generic(index)) {
-            continue;
-        }
-        read_swizzled(index, fmt::format("in_attr{}{}[0]", index, VertexIndex(ctx, vertex)));
-    }
-    for (u32 i = 0; i < num_endifs; ++i) {
-        ctx.Add("ENDIF;");
-    }
-}
-
-void EmitSetAttributeIndexed([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarU32 offset,
-                             [[maybe_unused]] ScalarF32 value, [[maybe_unused]] ScalarU32 vertex) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGetPatch(EmitContext& ctx, IR::Inst& inst, IR::Patch patch) {
-    if (!IR::IsGeneric(patch)) {
-        throw NotImplementedException("Non-generic patch load");
-    }
-    const u32 index{IR::GenericPatchIndex(patch)};
-    const u32 element{IR::GenericPatchElement(patch)};
-    const char swizzle{"xyzw"[element]};
-    const std::string_view out{ctx.stage == Stage::TessellationControl ? ".out" : ""};
-    ctx.Add("MOV.F {},primitive{}.patch.attrib[{}].{};", inst, out, index, swizzle);
-}
-
-void EmitSetPatch(EmitContext& ctx, IR::Patch patch, ScalarF32 value) {
-    if (IR::IsGeneric(patch)) {
-        const u32 index{IR::GenericPatchIndex(patch)};
-        const u32 element{IR::GenericPatchElement(patch)};
-        ctx.Add("MOV.F result.patch.attrib[{}].{},{};", index, "xyzw"[element], value);
-        return;
-    }
-    switch (patch) {
-    case IR::Patch::TessellationLodLeft:
-    case IR::Patch::TessellationLodRight:
-    case IR::Patch::TessellationLodTop:
-    case IR::Patch::TessellationLodBottom: {
-        const u32 index{static_cast<u32>(patch) - u32(IR::Patch::TessellationLodLeft)};
-        ctx.Add("MOV.F result.patch.tessouter[{}].x,{};", index, value);
-        break;
-    }
-    case IR::Patch::TessellationLodInteriorU:
-        ctx.Add("MOV.F result.patch.tessinner[0].x,{};", value);
-        break;
-    case IR::Patch::TessellationLodInteriorV:
-        ctx.Add("MOV.F result.patch.tessinner[1].x,{};", value);
-        break;
-    default:
-        throw NotImplementedException("Patch {}", patch);
-    }
-}
-
-void EmitSetFragColor(EmitContext& ctx, u32 index, u32 component, ScalarF32 value) {
-    ctx.Add("MOV.F frag_color{}.{},{};", index, "xyzw"[component], value);
-}
-
-void EmitSetSampleMask(EmitContext& ctx, ScalarS32 value) {
-    ctx.Add("MOV.S result.samplemask.x,{};", value);
-}
-
-void EmitSetFragDepth(EmitContext& ctx, ScalarF32 value) {
-    ctx.Add("MOV.F result.depth.z,{};", value);
-}
-
-void EmitLoadLocal(EmitContext& ctx, IR::Inst& inst, ScalarU32 word_offset) {
-    ctx.Add("MOV.U {},lmem[{}].x;", inst, word_offset);
-}
-
-void EmitWriteLocal(EmitContext& ctx, ScalarU32 word_offset, ScalarU32 value) {
-    ctx.Add("MOV.U lmem[{}].x,{};", word_offset, value);
-}
-
-} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_convert.cpp

@@ -1,231 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <string_view>
-
-#include "shader_recompiler/backend/glasm/emit_context.h"
-#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
-#include "shader_recompiler/frontend/ir/modifiers.h"
-#include "shader_recompiler/frontend/ir/value.h"
-
-namespace Shader::Backend::GLASM {
-namespace {
-std::string_view FpRounding(IR::FpRounding fp_rounding) {
-    switch (fp_rounding) {
-    case IR::FpRounding::DontCare:
-        return "";
-    case IR::FpRounding::RN:
-        return ".ROUND";
-    case IR::FpRounding::RZ:
-        return ".TRUNC";
-    case IR::FpRounding::RM:
-        return ".FLR";
-    case IR::FpRounding::RP:
-        return ".CEIL";
-    }
-    throw InvalidArgument("Invalid floating-point rounding {}", fp_rounding);
-}
-
-template <typename InputType>
-void Convert(EmitContext& ctx, IR::Inst& inst, InputType value, std::string_view dest,
-             std::string_view src, bool is_long_result) {
-    const std::string_view fp_rounding{FpRounding(inst.Flags<IR::FpControl>().rounding)};
-    const auto ret{is_long_result ? ctx.reg_alloc.LongDefine(inst) : ctx.reg_alloc.Define(inst)};
-    ctx.Add("CVT.{}.{}{} {}.x,{};", dest, src, fp_rounding, ret, value);
-}
-} // Anonymous namespace
-
-void EmitConvertS16F16(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "S16", "F16", false);
-}
-
-void EmitConvertS16F32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    Convert(ctx, inst, value, "S16", "F32", false);
-}
-
-void EmitConvertS16F64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value) {
-    Convert(ctx, inst, value, "S16", "F64", false);
-}
-
-void EmitConvertS32F16(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "S32", "F16", false);
-}
-
-void EmitConvertS32F32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    Convert(ctx, inst, value, "S32", "F32", false);
-}
-
-void EmitConvertS32F64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value) {
-    Convert(ctx, inst, value, "S32", "F64", false);
-}
-
-void EmitConvertS64F16(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "S64", "F16", true);
-}
-
-void EmitConvertS64F32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    Convert(ctx, inst, value, "S64", "F32", true);
-}
-
-void EmitConvertS64F64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value) {
-    Convert(ctx, inst, value, "S64", "F64", true);
-}
-
-void EmitConvertU16F16(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "U16", "F16", false);
-}
-
-void EmitConvertU16F32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    Convert(ctx, inst, value, "U16", "F32", false);
-}
-
-void EmitConvertU16F64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value) {
-    Convert(ctx, inst, value, "U16", "F64", false);
-}
-
-void EmitConvertU32F16(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "U32", "F16", false);
-}
-
-void EmitConvertU32F32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    Convert(ctx, inst, value, "U32", "F32", false);
-}
-
-void EmitConvertU32F64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value) {
-    Convert(ctx, inst, value, "U32", "F64", false);
-}
-
-void EmitConvertU64F16(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "U64", "F16", true);
-}
-
-void EmitConvertU64F32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    Convert(ctx, inst, value, "U64", "F32", true);
-}
-
-void EmitConvertU64F64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value) {
-    Convert(ctx, inst, value, "U64", "F64", true);
-}
-
-void EmitConvertU64U32(EmitContext& ctx, IR::Inst& inst, ScalarU32 value) {
-    Convert(ctx, inst, value, "U64", "U32", true);
-}
-
-void EmitConvertU32U64(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "U32", "U64", false);
-}
-
-void EmitConvertF16F32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    Convert(ctx, inst, value, "F16", "F32", false);
-}
-
-void EmitConvertF32F16(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F32", "F16", false);
-}
-
-void EmitConvertF32F64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value) {
-    Convert(ctx, inst, value, "F32", "F64", false);
-}
-
-void EmitConvertF64F32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    Convert(ctx, inst, value, "F64", "F32", true);
-}
-
-void EmitConvertF16S8(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F16", "S8", false);
-}
-
-void EmitConvertF16S16(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F16", "S16", false);
-}
-
-void EmitConvertF16S32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value) {
-    Convert(ctx, inst, value, "F16", "S32", false);
-}
-
-void EmitConvertF16S64(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F16", "S64", false);
-}
-
-void EmitConvertF16U8(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F16", "U8", false);
-}
-
-void EmitConvertF16U16(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F16", "U16", false);
-}
-
-void EmitConvertF16U32(EmitContext& ctx, IR::Inst& inst, ScalarU32 value) {
-    Convert(ctx, inst, value, "F16", "U32", false);
-}
-
-void EmitConvertF16U64(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F16", "U64", false);
-}
-
-void EmitConvertF32S8(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F32", "S8", false);
-}
-
-void EmitConvertF32S16(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F32", "S16", false);
-}
-
-void EmitConvertF32S32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value) {
-    Convert(ctx, inst, value, "F32", "S32", false);
-}
-
-void EmitConvertF32S64(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F32", "S64", false);
-}
-
-void EmitConvertF32U8(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F32", "U8", false);
-}
-
-void EmitConvertF32U16(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F32", "U16", false);
-}
-
-void EmitConvertF32U32(EmitContext& ctx, IR::Inst& inst, ScalarU32 value) {
-    Convert(ctx, inst, value, "F32", "U32", false);
-}
-
-void EmitConvertF32U64(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F32", "U64", false);
-}
-
-void EmitConvertF64S8(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F64", "S8", true);
-}
-
-void EmitConvertF64S16(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F64", "S16", true);
-}
-
-void EmitConvertF64S32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value) {
-    Convert(ctx, inst, value, "F64", "S32", true);
-}
-
-void EmitConvertF64S64(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F64", "S64", true);
-}
-
-void EmitConvertF64U8(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F64", "U8", true);
-}
-
-void EmitConvertF64U16(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F64", "U16", true);
-}
-
-void EmitConvertF64U32(EmitContext& ctx, IR::Inst& inst, ScalarU32 value) {
-    Convert(ctx, inst, value, "F64", "U32", true);
-}
-
-void EmitConvertF64U64(EmitContext& ctx, IR::Inst& inst, Register value) {
-    Convert(ctx, inst, value, "F64", "U64", true);
-}
-
-} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_floating_point.cpp

@@ -1,414 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <string_view>
-
-#include "shader_recompiler/backend/glasm/emit_context.h"
-#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
-#include "shader_recompiler/frontend/ir/modifiers.h"
-#include "shader_recompiler/frontend/ir/value.h"
-
-namespace Shader::Backend::GLASM {
-namespace {
-template <typename InputType>
-void Compare(EmitContext& ctx, IR::Inst& inst, InputType lhs, InputType rhs, std::string_view op,
-             std::string_view type, bool ordered, bool inequality = false) {
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    ctx.Add("{}.{} RC.x,{},{};", op, type, lhs, rhs);
-    if (ordered && inequality) {
-        ctx.Add("SEQ.{} RC.y,{},{};"
-                "SEQ.{} RC.z,{},{};"
-                "AND.U RC.x,RC.x,RC.y;"
-                "AND.U RC.x,RC.x,RC.z;"
-                "SNE.S {}.x,RC.x,0;",
-                type, lhs, lhs, type, rhs, rhs, ret);
-    } else if (ordered) {
-        ctx.Add("SNE.S {}.x,RC.x,0;", ret);
-    } else {
-        ctx.Add("SNE.{} RC.y,{},{};"
-                "SNE.{} RC.z,{},{};"
-                "OR.U RC.x,RC.x,RC.y;"
-                "OR.U RC.x,RC.x,RC.z;"
-                "SNE.S {}.x,RC.x,0;",
-                type, lhs, lhs, type, rhs, rhs, ret);
-    }
-}
-
-template <typename InputType>
-void Clamp(EmitContext& ctx, Register ret, InputType value, InputType min_value,
-           InputType max_value, std::string_view type) {
-    // Call MAX first to properly clamp nan to min_value instead
-    ctx.Add("MAX.{} RC.x,{},{};"
-            "MIN.{} {}.x,RC.x,{};",
-            type, min_value, value, type, ret, max_value);
-}
-
-std::string_view Precise(IR::Inst& inst) {
-    const bool precise{inst.Flags<IR::FpControl>().no_contraction};
-    return precise ? ".PREC" : "";
-}
-} // Anonymous namespace
-
-void EmitFPAbs16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                 [[maybe_unused]] Register value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPAbs32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    ctx.Add("MOV.F {}.x,|{}|;", inst, value);
-}
-
-void EmitFPAbs64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value) {
-    ctx.LongAdd("MOV.F64 {}.x,|{}|;", inst, value);
-}
-
-void EmitFPAdd16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                 [[maybe_unused]] Register a, [[maybe_unused]] Register b) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPAdd32(EmitContext& ctx, IR::Inst& inst, ScalarF32 a, ScalarF32 b) {
-    ctx.Add("ADD.F{} {}.x,{},{};", Precise(inst), ctx.reg_alloc.Define(inst), a, b);
-}
-
-void EmitFPAdd64(EmitContext& ctx, IR::Inst& inst, ScalarF64 a, ScalarF64 b) {
-    ctx.Add("ADD.F64{} {}.x,{},{};", Precise(inst), ctx.reg_alloc.LongDefine(inst), a, b);
-}
-
-void EmitFPFma16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                 [[maybe_unused]] Register a, [[maybe_unused]] Register b,
-                 [[maybe_unused]] Register c) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPFma32(EmitContext& ctx, IR::Inst& inst, ScalarF32 a, ScalarF32 b, ScalarF32 c) {
-    ctx.Add("MAD.F{} {}.x,{},{},{};", Precise(inst), ctx.reg_alloc.Define(inst), a, b, c);
-}
-
-void EmitFPFma64(EmitContext& ctx, IR::Inst& inst, ScalarF64 a, ScalarF64 b, ScalarF64 c) {
-    ctx.Add("MAD.F64{} {}.x,{},{},{};", Precise(inst), ctx.reg_alloc.LongDefine(inst), a, b, c);
-}
-
-void EmitFPMax32(EmitContext& ctx, IR::Inst& inst, ScalarF32 a, ScalarF32 b) {
-    ctx.Add("MAX.F {}.x,{},{};", inst, a, b);
-}
-
-void EmitFPMax64(EmitContext& ctx, IR::Inst& inst, ScalarF64 a, ScalarF64 b) {
-    ctx.LongAdd("MAX.F64 {}.x,{},{};", inst, a, b);
-}
-
-void EmitFPMin32(EmitContext& ctx, IR::Inst& inst, ScalarF32 a, ScalarF32 b) {
-    ctx.Add("MIN.F {}.x,{},{};", inst, a, b);
-}
-
-void EmitFPMin64(EmitContext& ctx, IR::Inst& inst, ScalarF64 a, ScalarF64 b) {
-    ctx.LongAdd("MIN.F64 {}.x,{},{};", inst, a, b);
-}
-
-void EmitFPMul16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                 [[maybe_unused]] Register a, [[maybe_unused]] Register b) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPMul32(EmitContext& ctx, IR::Inst& inst, ScalarF32 a, ScalarF32 b) {
-    ctx.Add("MUL.F{} {}.x,{},{};", Precise(inst), ctx.reg_alloc.Define(inst), a, b);
-}
-
-void EmitFPMul64(EmitContext& ctx, IR::Inst& inst, ScalarF64 a, ScalarF64 b) {
-    ctx.Add("MUL.F64{} {}.x,{},{};", Precise(inst), ctx.reg_alloc.LongDefine(inst), a, b);
-}
-
-void EmitFPNeg16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPNeg32(EmitContext& ctx, IR::Inst& inst, ScalarRegister value) {
-    ctx.Add("MOV.F {}.x,-{};", inst, value);
-}
-
-void EmitFPNeg64(EmitContext& ctx, IR::Inst& inst, Register value) {
-    ctx.LongAdd("MOV.F64 {}.x,-{};", inst, value);
-}
-
-void EmitFPSin(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    ctx.Add("SIN {}.x,{};", inst, value);
-}
-
-void EmitFPCos(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    ctx.Add("COS {}.x,{};", inst, value);
-}
-
-void EmitFPExp2(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    ctx.Add("EX2 {}.x,{};", inst, value);
-}
-
-void EmitFPLog2(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    ctx.Add("LG2 {}.x,{};", inst, value);
-}
-
-void EmitFPRecip32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    ctx.Add("RCP {}.x,{};", inst, value);
-}
-
-void EmitFPRecip64([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPRecipSqrt32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    ctx.Add("RSQ {}.x,{};", inst, value);
-}
-
-void EmitFPRecipSqrt64([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPSqrt(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    ctx.Add("RSQ RC.x,{};RCP {}.x,RC.x;", value, ret);
-}
-
-void EmitFPSaturate16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPSaturate32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    ctx.Add("MOV.F.SAT {}.x,{};", inst, value);
-}
-
-void EmitFPSaturate64([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPClamp16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register value,
-                   [[maybe_unused]] Register min_value, [[maybe_unused]] Register max_value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPClamp32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value, ScalarF32 min_value,
-                   ScalarF32 max_value) {
-    Clamp(ctx, ctx.reg_alloc.Define(inst), value, min_value, max_value, "F");
-}
-
-void EmitFPClamp64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value, ScalarF64 min_value,
-                   ScalarF64 max_value) {
-    Clamp(ctx, ctx.reg_alloc.LongDefine(inst), value, min_value, max_value, "F64");
-}
-
-void EmitFPRoundEven16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPRoundEven32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    ctx.Add("ROUND.F {}.x,{};", inst, value);
-}
-
-void EmitFPRoundEven64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value) {
-    ctx.LongAdd("ROUND.F64 {}.x,{};", inst, value);
-}
-
-void EmitFPFloor16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPFloor32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    ctx.Add("FLR.F {}.x,{};", inst, value);
-}
-
-void EmitFPFloor64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value) {
-    ctx.LongAdd("FLR.F64 {}.x,{};", inst, value);
-}
-
-void EmitFPCeil16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPCeil32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    ctx.Add("CEIL.F {}.x,{};", inst, value);
-}
-
-void EmitFPCeil64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value) {
-    ctx.LongAdd("CEIL.F64 {}.x,{};", inst, value);
-}
-
-void EmitFPTrunc16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPTrunc32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    ctx.Add("TRUNC.F {}.x,{};", inst, value);
-}
-
-void EmitFPTrunc64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value) {
-    ctx.LongAdd("TRUNC.F64 {}.x,{};", inst, value);
-}
-
-void EmitFPOrdEqual16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register lhs,
-                      [[maybe_unused]] Register rhs) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPOrdEqual32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SEQ", "F", true);
-}
-
-void EmitFPOrdEqual64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SEQ", "F64", true);
-}
-
-void EmitFPUnordEqual16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register lhs,
-                        [[maybe_unused]] Register rhs) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPUnordEqual32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SEQ", "F", false);
-}
-
-void EmitFPUnordEqual64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SEQ", "F64", false);
-}
-
-void EmitFPOrdNotEqual16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register lhs,
-                         [[maybe_unused]] Register rhs) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPOrdNotEqual32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SNE", "F", true, true);
-}
-
-void EmitFPOrdNotEqual64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SNE", "F64", true, true);
-}
-
-void EmitFPUnordNotEqual16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register lhs,
-                           [[maybe_unused]] Register rhs) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPUnordNotEqual32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SNE", "F", false, true);
-}
-
-void EmitFPUnordNotEqual64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SNE", "F64", false, true);
-}
-
-void EmitFPOrdLessThan16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register lhs,
-                         [[maybe_unused]] Register rhs) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPOrdLessThan32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SLT", "F", true);
-}
-
-void EmitFPOrdLessThan64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SLT", "F64", true);
-}
-
-void EmitFPUnordLessThan16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register lhs,
-                           [[maybe_unused]] Register rhs) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPUnordLessThan32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SLT", "F", false);
-}
-
-void EmitFPUnordLessThan64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SLT", "F64", false);
-}
-
-void EmitFPOrdGreaterThan16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register lhs,
-                            [[maybe_unused]] Register rhs) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPOrdGreaterThan32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SGT", "F", true);
-}
-
-void EmitFPOrdGreaterThan64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SGT", "F64", true);
-}
-
-void EmitFPUnordGreaterThan16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register lhs,
-                              [[maybe_unused]] Register rhs) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPUnordGreaterThan32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SGT", "F", false);
-}
-
-void EmitFPUnordGreaterThan64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SGT", "F64", false);
-}
-
-void EmitFPOrdLessThanEqual16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register lhs,
-                              [[maybe_unused]] Register rhs) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPOrdLessThanEqual32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SLE", "F", true);
-}
-
-void EmitFPOrdLessThanEqual64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SLE", "F64", true);
-}
-
-void EmitFPUnordLessThanEqual16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register lhs,
-                                [[maybe_unused]] Register rhs) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPUnordLessThanEqual32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SLE", "F", false);
-}
-
-void EmitFPUnordLessThanEqual64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SLE", "F64", false);
-}
-
-void EmitFPOrdGreaterThanEqual16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register lhs,
-                                 [[maybe_unused]] Register rhs) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPOrdGreaterThanEqual32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SGE", "F", true);
-}
-
-void EmitFPOrdGreaterThanEqual64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SGE", "F64", true);
-}
-
-void EmitFPUnordGreaterThanEqual16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register lhs,
-                                   [[maybe_unused]] Register rhs) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPUnordGreaterThanEqual32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SGE", "F", false);
-}
-
-void EmitFPUnordGreaterThanEqual64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs) {
-    Compare(ctx, inst, lhs, rhs, "SGE", "F64", false);
-}
-
-void EmitFPIsNan16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] Register value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitFPIsNan32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value) {
-    Compare(ctx, inst, value, value, "SNE", "F", true, false);
-}
-
-void EmitFPIsNan64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value) {
-    Compare(ctx, inst, value, value, "SNE", "F64", true, false);
-}
-
-} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_image.cpp

@@ -1,850 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <utility>
-
-#include "shader_recompiler/backend/glasm/emit_context.h"
-#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
-#include "shader_recompiler/frontend/ir/modifiers.h"
-#include "shader_recompiler/frontend/ir/value.h"
-
-namespace Shader::Backend::GLASM {
-namespace {
-struct ScopedRegister {
-    ScopedRegister() = default;
-    ScopedRegister(RegAlloc& reg_alloc_) : reg_alloc{&reg_alloc_}, reg{reg_alloc->AllocReg()} {}
-
-    ~ScopedRegister() {
-        if (reg_alloc) {
-            reg_alloc->FreeReg(reg);
-        }
-    }
-
-    ScopedRegister& operator=(ScopedRegister&& rhs) noexcept {
-        if (reg_alloc) {
-            reg_alloc->FreeReg(reg);
-        }
-        reg_alloc = std::exchange(rhs.reg_alloc, nullptr);
-        reg = rhs.reg;
-        return *this;
-    }
-
-    ScopedRegister(ScopedRegister&& rhs) noexcept
-        : reg_alloc{std::exchange(rhs.reg_alloc, nullptr)}, reg{rhs.reg} {}
-
-    ScopedRegister& operator=(const ScopedRegister&) = delete;
-    ScopedRegister(const ScopedRegister&) = delete;
-
-    RegAlloc* reg_alloc{};
-    Register reg;
-};
-
-std::string Texture(EmitContext& ctx, IR::TextureInstInfo info,
-                    [[maybe_unused]] const IR::Value& index) {
-    // FIXME: indexed reads
-    if (info.type == TextureType::Buffer) {
-        return fmt::format("texture[{}]", ctx.texture_buffer_bindings.at(info.descriptor_index));
-    } else {
-        return fmt::format("texture[{}]", ctx.texture_bindings.at(info.descriptor_index));
-    }
-}
-
-std::string Image(EmitContext& ctx, IR::TextureInstInfo info,
-                  [[maybe_unused]] const IR::Value& index) {
-    // FIXME: indexed reads
-    if (info.type == TextureType::Buffer) {
-        return fmt::format("image[{}]", ctx.image_buffer_bindings.at(info.descriptor_index));
-    } else {
-        return fmt::format("image[{}]", ctx.image_bindings.at(info.descriptor_index));
-    }
-}
-
-std::string_view TextureType(IR::TextureInstInfo info) {
-    if (info.is_depth) {
-        switch (info.type) {
-        case TextureType::Color1D:
-            return "SHADOW1D";
-        case TextureType::ColorArray1D:
-            return "SHADOWARRAY1D";
-        case TextureType::Color2D:
-            return "SHADOW2D";
-        case TextureType::ColorArray2D:
-            return "SHADOWARRAY2D";
-        case TextureType::Color3D:
-            return "SHADOW3D";
-        case TextureType::ColorCube:
-            return "SHADOWCUBE";
-        case TextureType::ColorArrayCube:
-            return "SHADOWARRAYCUBE";
-        case TextureType::Buffer:
-            return "SHADOWBUFFER";
-        }
-    } else {
-        switch (info.type) {
-        case TextureType::Color1D:
-            return "1D";
-        case TextureType::ColorArray1D:
-            return "ARRAY1D";
-        case TextureType::Color2D:
-            return "2D";
-        case TextureType::ColorArray2D:
-            return "ARRAY2D";
-        case TextureType::Color3D:
-            return "3D";
-        case TextureType::ColorCube:
-            return "CUBE";
-        case TextureType::ColorArrayCube:
-            return "ARRAYCUBE";
-        case TextureType::Buffer:
-            return "BUFFER";
-        }
-    }
-    throw InvalidArgument("Invalid texture type {}", info.type.Value());
-}
-
-std::string Offset(EmitContext& ctx, const IR::Value& offset) {
-    if (offset.IsEmpty()) {
-        return "";
-    }
-    return fmt::format(",offset({})", Register{ctx.reg_alloc.Consume(offset)});
-}
-
-std::pair<ScopedRegister, ScopedRegister> AllocOffsetsRegs(EmitContext& ctx,
-                                                           const IR::Value& offset2) {
-    if (offset2.IsEmpty()) {
-        return {};
-    } else {
-        return {ctx.reg_alloc, ctx.reg_alloc};
-    }
-}
-
-void SwizzleOffsets(EmitContext& ctx, Register off_x, Register off_y, const IR::Value& offset1,
-                    const IR::Value& offset2) {
-    const Register offsets_a{ctx.reg_alloc.Consume(offset1)};
-    const Register offsets_b{ctx.reg_alloc.Consume(offset2)};
-    // Input swizzle:  [XYXY] [XYXY]
-    // Output swizzle: [XXXX] [YYYY]
-    ctx.Add("MOV {}.x,{}.x;"
-            "MOV {}.y,{}.z;"
-            "MOV {}.z,{}.x;"
-            "MOV {}.w,{}.z;"
-            "MOV {}.x,{}.y;"
-            "MOV {}.y,{}.w;"
-            "MOV {}.z,{}.y;"
-            "MOV {}.w,{}.w;",
-            off_x, offsets_a, off_x, offsets_a, off_x, offsets_b, off_x, offsets_b, off_y,
-            offsets_a, off_y, offsets_a, off_y, offsets_b, off_y, offsets_b);
-}
-
-std::string GradOffset(const IR::Value& offset) {
-    if (offset.IsImmediate()) {
-        LOG_WARNING(Shader_GLASM, "Gradient offset is a scalar immediate");
-        return "";
-    }
-    IR::Inst* const vector{offset.InstRecursive()};
-    if (!vector->AreAllArgsImmediates()) {
-        LOG_WARNING(Shader_GLASM, "Gradient offset vector is not immediate");
-        return "";
-    }
-    switch (vector->NumArgs()) {
-    case 1:
-        return fmt::format(",({})", static_cast<s32>(vector->Arg(0).U32()));
-    case 2:
-        return fmt::format(",({},{})", static_cast<s32>(vector->Arg(0).U32()),
-                           static_cast<s32>(vector->Arg(1).U32()));
-    default:
-        throw LogicError("Invalid number of gradient offsets {}", vector->NumArgs());
-    }
-}
-
-std::pair<std::string, ScopedRegister> Coord(EmitContext& ctx, const IR::Value& coord) {
-    if (coord.IsImmediate()) {
-        ScopedRegister scoped_reg(ctx.reg_alloc);
-        ctx.Add("MOV.U {}.x,{};", scoped_reg.reg, ScalarU32{ctx.reg_alloc.Consume(coord)});
-        return {fmt::to_string(scoped_reg.reg), std::move(scoped_reg)};
-    }
-    std::string coord_vec{fmt::to_string(Register{ctx.reg_alloc.Consume(coord)})};
-    if (coord.InstRecursive()->HasUses()) {
-        // Move non-dead coords to a separate register, although this should never happen because
-        // vectors are only assembled for immediate texture instructions
-        ctx.Add("MOV.F RC,{};", coord_vec);
-        coord_vec = "RC";
-    }
-    return {std::move(coord_vec), ScopedRegister{}};
-}
-
-void StoreSparse(EmitContext& ctx, IR::Inst* sparse_inst) {
-    if (!sparse_inst) {
-        return;
-    }
-    const Register sparse_ret{ctx.reg_alloc.Define(*sparse_inst)};
-    ctx.Add("MOV.S {},-1;"
-            "MOV.S {}(NONRESIDENT),0;",
-            sparse_ret, sparse_ret);
-}
-
-std::string_view FormatStorage(ImageFormat format) {
-    switch (format) {
-    case ImageFormat::Typeless:
-        return "U";
-    case ImageFormat::R8_UINT:
-        return "U8";
-    case ImageFormat::R8_SINT:
-        return "S8";
-    case ImageFormat::R16_UINT:
-        return "U16";
-    case ImageFormat::R16_SINT:
-        return "S16";
-    case ImageFormat::R32_UINT:
-        return "U32";
-    case ImageFormat::R32G32_UINT:
-        return "U32X2";
-    case ImageFormat::R32G32B32A32_UINT:
-        return "U32X4";
-    }
-    throw InvalidArgument("Invalid image format {}", format);
-}
-
-template <typename T>
-void ImageAtomic(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord, T value,
-                 std::string_view op) {
-    const auto info{inst.Flags<IR::TextureInstInfo>()};
-    const std::string_view type{TextureType(info)};
-    const std::string image{Image(ctx, info, index)};
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    ctx.Add("ATOMIM.{} {},{},{},{},{};", op, ret, value, coord, image, type);
-}
-
-IR::Inst* PrepareSparse(IR::Inst& inst) {
-    const auto sparse_inst{inst.GetAssociatedPseudoOperation(IR::Opcode::GetSparseFromOp)};
-    if (sparse_inst) {
-        sparse_inst->Invalidate();
-    }
-    return sparse_inst;
-}
-} // Anonymous namespace
-
-void EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                                const IR::Value& coord, Register bias_lc, const IR::Value& offset) {
-    const auto info{inst.Flags<IR::TextureInstInfo>()};
-    const auto sparse_inst{PrepareSparse(inst)};
-    const std::string_view sparse_mod{sparse_inst ? ".SPARSE" : ""};
-    const std::string_view lod_clamp_mod{info.has_lod_clamp ? ".LODCLAMP" : ""};
-    const std::string_view type{TextureType(info)};
-    const std::string texture{Texture(ctx, info, index)};
-    const std::string offset_vec{Offset(ctx, offset)};
-    const auto [coord_vec, coord_alloc]{Coord(ctx, coord)};
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    if (info.has_bias) {
-        if (info.type == TextureType::ColorArrayCube) {
-            ctx.Add("TXB.F{}{} {},{},{},{},ARRAYCUBE{};", lod_clamp_mod, sparse_mod, ret, coord_vec,
-                    bias_lc, texture, offset_vec);
-        } else {
-            if (info.has_lod_clamp) {
-                ctx.Add("MOV.F {}.w,{}.x;"
-                        "TXB.F.LODCLAMP{} {},{},{}.y,{},{}{};",
-                        coord_vec, bias_lc, sparse_mod, ret, coord_vec, bias_lc, texture, type,
-                        offset_vec);
-            } else {
-                ctx.Add("MOV.F {}.w,{}.x;"
-                        "TXB.F{} {},{},{},{}{};",
-                        coord_vec, bias_lc, sparse_mod, ret, coord_vec, texture, type, offset_vec);
-            }
-        }
-    } else {
-        if (info.has_lod_clamp && info.type == TextureType::ColorArrayCube) {
-            ctx.Add("TEX.F.LODCLAMP{} {},{},{},{},ARRAYCUBE{};", sparse_mod, ret, coord_vec,
-                    bias_lc, texture, offset_vec);
-        } else {
-            ctx.Add("TEX.F{}{} {},{},{},{}{};", lod_clamp_mod, sparse_mod, ret, coord_vec, texture,
-                    type, offset_vec);
-        }
-    }
-    StoreSparse(ctx, sparse_inst);
-}
-
-void EmitImageSampleExplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                                const IR::Value& coord, ScalarF32 lod, const IR::Value& offset) {
-    const auto info{inst.Flags<IR::TextureInstInfo>()};
-    const auto sparse_inst{PrepareSparse(inst)};
-    const std::string_view sparse_mod{sparse_inst ? ".SPARSE" : ""};
-    const std::string_view type{TextureType(info)};
-    const std::string texture{Texture(ctx, info, index)};
-    const std::string offset_vec{Offset(ctx, offset)};
-    const auto [coord_vec, coord_alloc]{Coord(ctx, coord)};
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    if (info.type == TextureType::ColorArrayCube) {
-        ctx.Add("TXL.F{} {},{},{},{},ARRAYCUBE{};", sparse_mod, ret, coord_vec, lod, texture,
-                offset_vec);
-    } else {
-        ctx.Add("MOV.F {}.w,{};"
-                "TXL.F{} {},{},{},{}{};",
-                coord_vec, lod, sparse_mod, ret, coord_vec, texture, type, offset_vec);
-    }
-    StoreSparse(ctx, sparse_inst);
-}
-
-void EmitImageSampleDrefImplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                                    const IR::Value& coord, const IR::Value& dref,
-                                    const IR::Value& bias_lc, const IR::Value& offset) {
-    // Allocate early to avoid aliases
-    const auto info{inst.Flags<IR::TextureInstInfo>()};
-    ScopedRegister staging;
-    if (info.type == TextureType::ColorArrayCube) {
-        staging = ScopedRegister{ctx.reg_alloc};
-    }
-    const ScalarF32 dref_val{ctx.reg_alloc.Consume(dref)};
-    const Register bias_lc_vec{ctx.reg_alloc.Consume(bias_lc)};
-    const auto sparse_inst{PrepareSparse(inst)};
-    const std::string_view sparse_mod{sparse_inst ? ".SPARSE" : ""};
-    const std::string_view type{TextureType(info)};
-    const std::string texture{Texture(ctx, info, index)};
-    const std::string offset_vec{Offset(ctx, offset)};
-    const auto [coord_vec, coord_alloc]{Coord(ctx, coord)};
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    if (info.has_bias) {
-        if (info.has_lod_clamp) {
-            switch (info.type) {
-            case TextureType::Color1D:
-            case TextureType::ColorArray1D:
-            case TextureType::Color2D:
-                ctx.Add("MOV.F {}.z,{};"
-                        "MOV.F {}.w,{}.x;"
-                        "TXB.F.LODCLAMP{} {},{},{}.y,{},{}{};",
-                        coord_vec, dref_val, coord_vec, bias_lc_vec, sparse_mod, ret, coord_vec,
-                        bias_lc_vec, texture, type, offset_vec);
-                break;
-            case TextureType::ColorArray2D:
-            case TextureType::ColorCube:
-                ctx.Add("MOV.F {}.w,{};"
-                        "TXB.F.LODCLAMP{} {},{},{},{},{}{};",
-                        coord_vec, dref_val, sparse_mod, ret, coord_vec, bias_lc_vec, texture, type,
-                        offset_vec);
-                break;
-            default:
-                throw NotImplementedException("Invalid type {} with bias and lod clamp",
-                                              info.type.Value());
-            }
-        } else {
-            switch (info.type) {
-            case TextureType::Color1D:
-            case TextureType::ColorArray1D:
-            case TextureType::Color2D:
-                ctx.Add("MOV.F {}.z,{};"
-                        "MOV.F {}.w,{}.x;"
-                        "TXB.F{} {},{},{},{}{};",
-                        coord_vec, dref_val, coord_vec, bias_lc_vec, sparse_mod, ret, coord_vec,
-                        texture, type, offset_vec);
-                break;
-            case TextureType::ColorArray2D:
-            case TextureType::ColorCube:
-                ctx.Add("MOV.F {}.w,{};"
-                        "TXB.F{} {},{},{},{},{}{};",
-                        coord_vec, dref_val, sparse_mod, ret, coord_vec, bias_lc_vec, texture, type,
-                        offset_vec);
-                break;
-            case TextureType::ColorArrayCube:
-                ctx.Add("MOV.F {}.x,{};"
-                        "MOV.F {}.y,{}.x;"
-                        "TXB.F{} {},{},{},{},{}{};",
-                        staging.reg, dref_val, staging.reg, bias_lc_vec, sparse_mod, ret, coord_vec,
-                        staging.reg, texture, type, offset_vec);
-                break;
-            default:
-                throw NotImplementedException("Invalid type {}", info.type.Value());
-            }
-        }
-    } else {
-        if (info.has_lod_clamp) {
-            if (info.type != TextureType::ColorArrayCube) {
-                const bool w_swizzle{info.type == TextureType::ColorArray2D ||
-                                     info.type == TextureType::ColorCube};
-                const char dref_swizzle{w_swizzle ? 'w' : 'z'};
-                ctx.Add("MOV.F {}.{},{};"
-                        "TEX.F.LODCLAMP{} {},{},{},{},{}{};",
-                        coord_vec, dref_swizzle, dref_val, sparse_mod, ret, coord_vec, bias_lc_vec,
-                        texture, type, offset_vec);
-            } else {
-                ctx.Add("MOV.F {}.x,{};"
-                        "MOV.F {}.y,{};"
-                        "TEX.F.LODCLAMP{} {},{},{},{},{}{};",
-                        staging.reg, dref_val, staging.reg, bias_lc_vec, sparse_mod, ret, coord_vec,
-                        staging.reg, texture, type, offset_vec);
-            }
-        } else {
-            if (info.type != TextureType::ColorArrayCube) {
-                const bool w_swizzle{info.type == TextureType::ColorArray2D ||
-                                     info.type == TextureType::ColorCube};
-                const char dref_swizzle{w_swizzle ? 'w' : 'z'};
-                ctx.Add("MOV.F {}.{},{};"
-                        "TEX.F{} {},{},{},{}{};",
-                        coord_vec, dref_swizzle, dref_val, sparse_mod, ret, coord_vec, texture,
-                        type, offset_vec);
-            } else {
-                ctx.Add("TEX.F{} {},{},{},{},{}{};", sparse_mod, ret, coord_vec, dref_val, texture,
-                        type, offset_vec);
-            }
-        }
-    }
-    StoreSparse(ctx, sparse_inst);
-}
-
-void EmitImageSampleDrefExplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                                    const IR::Value& coord, const IR::Value& dref,
-                                    const IR::Value& lod, const IR::Value& offset) {
-    // Allocate early to avoid aliases
-    const auto info{inst.Flags<IR::TextureInstInfo>()};
-    ScopedRegister staging;
-    if (info.type == TextureType::ColorArrayCube) {
-        staging = ScopedRegister{ctx.reg_alloc};
-    }
-    const ScalarF32 dref_val{ctx.reg_alloc.Consume(dref)};
-    const ScalarF32 lod_val{ctx.reg_alloc.Consume(lod)};
-    const auto sparse_inst{PrepareSparse(inst)};
-    const std::string_view sparse_mod{sparse_inst ? ".SPARSE" : ""};
-    const std::string_view type{TextureType(info)};
-    const std::string texture{Texture(ctx, info, index)};
-    const std::string offset_vec{Offset(ctx, offset)};
-    const auto [coord_vec, coord_alloc]{Coord(ctx, coord)};
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    switch (info.type) {
-    case TextureType::Color1D:
-    case TextureType::ColorArray1D:
-    case TextureType::Color2D:
-        ctx.Add("MOV.F {}.z,{};"
-                "MOV.F {}.w,{};"
-                "TXL.F{} {},{},{},{}{};",
-                coord_vec, dref_val, coord_vec, lod_val, sparse_mod, ret, coord_vec, texture, type,
-                offset_vec);
-        break;
-    case TextureType::ColorArray2D:
-    case TextureType::ColorCube:
-        ctx.Add("MOV.F {}.w,{};"
-                "TXL.F{} {},{},{},{},{}{};",
-                coord_vec, dref_val, sparse_mod, ret, coord_vec, lod_val, texture, type,
-                offset_vec);
-        break;
-    case TextureType::ColorArrayCube:
-        ctx.Add("MOV.F {}.x,{};"
-                "MOV.F {}.y,{};"
-                "TXL.F{} {},{},{},{},{}{};",
-                staging.reg, dref_val, staging.reg, lod_val, sparse_mod, ret, coord_vec,
-                staging.reg, texture, type, offset_vec);
-        break;
-    default:
-        throw NotImplementedException("Invalid type {}", info.type.Value());
-    }
-    StoreSparse(ctx, sparse_inst);
-}
-
-void EmitImageGather(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                     const IR::Value& coord, const IR::Value& offset, const IR::Value& offset2) {
-    // Allocate offsets early so they don't overwrite any consumed register
-    const auto [off_x, off_y]{AllocOffsetsRegs(ctx, offset2)};
-    const auto info{inst.Flags<IR::TextureInstInfo>()};
-    const char comp{"xyzw"[info.gather_component]};
-    const auto sparse_inst{PrepareSparse(inst)};
-    const std::string_view sparse_mod{sparse_inst ? ".SPARSE" : ""};
-    const std::string_view type{TextureType(info)};
-    const std::string texture{Texture(ctx, info, index)};
-    const Register coord_vec{ctx.reg_alloc.Consume(coord)};
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    if (offset2.IsEmpty()) {
-        const std::string offset_vec{Offset(ctx, offset)};
-        ctx.Add("TXG.F{} {},{},{}.{},{}{};", sparse_mod, ret, coord_vec, texture, comp, type,
-                offset_vec);
-    } else {
-        SwizzleOffsets(ctx, off_x.reg, off_y.reg, offset, offset2);
-        ctx.Add("TXGO.F{} {},{},{},{},{}.{},{};", sparse_mod, ret, coord_vec, off_x.reg, off_y.reg,
-                texture, comp, type);
-    }
-    StoreSparse(ctx, sparse_inst);
-}
-
-void EmitImageGatherDref(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                         const IR::Value& coord, const IR::Value& offset, const IR::Value& offset2,
-                         const IR::Value& dref) {
-    // FIXME: This instruction is not working as expected
-
-    // Allocate offsets early so they don't overwrite any consumed register
-    const auto [off_x, off_y]{AllocOffsetsRegs(ctx, offset2)};
-    const auto info{inst.Flags<IR::TextureInstInfo>()};
-    const auto sparse_inst{PrepareSparse(inst)};
-    const std::string_view sparse_mod{sparse_inst ? ".SPARSE" : ""};
-    const std::string_view type{TextureType(info)};
-    const std::string texture{Texture(ctx, info, index)};
-    const Register coord_vec{ctx.reg_alloc.Consume(coord)};
-    const ScalarF32 dref_value{ctx.reg_alloc.Consume(dref)};
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    std::string args;
-    switch (info.type) {
-    case TextureType::Color2D:
-        ctx.Add("MOV.F {}.z,{};", coord_vec, dref_value);
-        args = fmt::to_string(coord_vec);
-        break;
-    case TextureType::ColorArray2D:
-    case TextureType::ColorCube:
-        ctx.Add("MOV.F {}.w,{};", coord_vec, dref_value);
-        args = fmt::to_string(coord_vec);
-        break;
-    case TextureType::ColorArrayCube:
-        args = fmt::format("{},{}", coord_vec, dref_value);
-        break;
-    default:
-        throw NotImplementedException("Invalid type {}", info.type.Value());
-    }
-    if (offset2.IsEmpty()) {
-        const std::string offset_vec{Offset(ctx, offset)};
-        ctx.Add("TXG.F{} {},{},{},{}{};", sparse_mod, ret, args, texture, type, offset_vec);
-    } else {
-        SwizzleOffsets(ctx, off_x.reg, off_y.reg, offset, offset2);
-        ctx.Add("TXGO.F{} {},{},{},{},{},{};", sparse_mod, ret, args, off_x.reg, off_y.reg, texture,
-                type);
-    }
-    StoreSparse(ctx, sparse_inst);
-}
-
-void EmitImageFetch(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                    const IR::Value& coord, const IR::Value& offset, ScalarS32 lod, ScalarS32 ms) {
-    const auto info{inst.Flags<IR::TextureInstInfo>()};
-    const auto sparse_inst{PrepareSparse(inst)};
-    const std::string_view sparse_mod{sparse_inst ? ".SPARSE" : ""};
-    const std::string_view type{TextureType(info)};
-    const std::string texture{Texture(ctx, info, index)};
-    const std::string offset_vec{Offset(ctx, offset)};
-    const auto [coord_vec, coord_alloc]{Coord(ctx, coord)};
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    if (info.type == TextureType::Buffer) {
-        ctx.Add("TXF.F{} {},{},{},{}{};", sparse_mod, ret, coord_vec, texture, type, offset_vec);
-    } else if (ms.type != Type::Void) {
-        ctx.Add("MOV.S {}.w,{};"
-                "TXFMS.F{} {},{},{},{}{};",
-                coord_vec, ms, sparse_mod, ret, coord_vec, texture, type, offset_vec);
-    } else {
-        ctx.Add("MOV.S {}.w,{};"
-                "TXF.F{} {},{},{},{}{};",
-                coord_vec, lod, sparse_mod, ret, coord_vec, texture, type, offset_vec);
-    }
-    StoreSparse(ctx, sparse_inst);
-}
-
-void EmitImageQueryDimensions(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                              ScalarS32 lod) {
-    const auto info{inst.Flags<IR::TextureInstInfo>()};
-    const std::string texture{Texture(ctx, info, index)};
-    const std::string_view type{TextureType(info)};
-    ctx.Add("TXQ {},{},{},{};", inst, lod, texture, type);
-}
-
-void EmitImageQueryLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord) {
-    const auto info{inst.Flags<IR::TextureInstInfo>()};
-    const std::string texture{Texture(ctx, info, index)};
-    const std::string_view type{TextureType(info)};
-    ctx.Add("LOD.F {},{},{},{};", inst, coord, texture, type);
-}
-
-void EmitImageGradient(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                       const IR::Value& coord, const IR::Value& derivatives,
-                       const IR::Value& offset, const IR::Value& lod_clamp) {
-    const auto info{inst.Flags<IR::TextureInstInfo>()};
-    ScopedRegister dpdx, dpdy;
-    const bool multi_component{info.num_derivates > 1 || info.has_lod_clamp};
-    if (multi_component) {
-        // Allocate this early to avoid aliasing other registers
-        dpdx = ScopedRegister{ctx.reg_alloc};
-        dpdy = ScopedRegister{ctx.reg_alloc};
-    }
-    const auto sparse_inst{PrepareSparse(inst)};
-    const std::string_view sparse_mod{sparse_inst ? ".SPARSE" : ""};
-    const std::string_view type{TextureType(info)};
-    const std::string texture{Texture(ctx, info, index)};
-    const std::string offset_vec{GradOffset(offset)};
-    const Register coord_vec{ctx.reg_alloc.Consume(coord)};
-    const Register derivatives_vec{ctx.reg_alloc.Consume(derivatives)};
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    if (multi_component) {
-        ctx.Add("MOV.F {}.x,{}.x;"
-                "MOV.F {}.y,{}.z;"
-                "MOV.F {}.x,{}.y;"
-                "MOV.F {}.y,{}.w;",
-                dpdx.reg, derivatives_vec, dpdx.reg, derivatives_vec, dpdy.reg, derivatives_vec,
-                dpdy.reg, derivatives_vec);
-        if (info.has_lod_clamp) {
-            const ScalarF32 lod_clamp_value{ctx.reg_alloc.Consume(lod_clamp)};
-            ctx.Add("MOV.F {}.w,{};"
-                    "TXD.F.LODCLAMP{} {},{},{},{},{},{}{};",
-                    dpdy.reg, lod_clamp_value, sparse_mod, ret, coord_vec, dpdx.reg, dpdy.reg,
-                    texture, type, offset_vec);
-        } else {
-            ctx.Add("TXD.F{} {},{},{},{},{},{}{};", sparse_mod, ret, coord_vec, dpdx.reg, dpdy.reg,
-                    texture, type, offset_vec);
-        }
-    } else {
-        ctx.Add("TXD.F{} {},{},{}.x,{}.y,{},{}{};", sparse_mod, ret, coord_vec, derivatives_vec,
-                derivatives_vec, texture, type, offset_vec);
-    }
-    StoreSparse(ctx, sparse_inst);
-}
-
-void EmitImageRead(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord) {
-    const auto info{inst.Flags<IR::TextureInstInfo>()};
-    const auto sparse_inst{PrepareSparse(inst)};
-    const std::string_view format{FormatStorage(info.image_format)};
-    const std::string_view sparse_mod{sparse_inst ? ".SPARSE" : ""};
-    const std::string_view type{TextureType(info)};
-    const std::string image{Image(ctx, info, index)};
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    ctx.Add("LOADIM.{}{} {},{},{},{};", format, sparse_mod, ret, coord, image, type);
-    StoreSparse(ctx, sparse_inst);
-}
-
-void EmitImageWrite(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                    Register color) {
-    const auto info{inst.Flags<IR::TextureInstInfo>()};
-    const std::string_view format{FormatStorage(info.image_format)};
-    const std::string_view type{TextureType(info)};
-    const std::string image{Image(ctx, info, index)};
-    ctx.Add("STOREIM.{} {},{},{},{};", format, image, color, coord, type);
-}
-
-void EmitImageAtomicIAdd32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                           ScalarU32 value) {
-    ImageAtomic(ctx, inst, index, coord, value, "ADD.U32");
-}
-
-void EmitImageAtomicSMin32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                           ScalarS32 value) {
-    ImageAtomic(ctx, inst, index, coord, value, "MIN.S32");
-}
-
-void EmitImageAtomicUMin32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                           ScalarU32 value) {
-    ImageAtomic(ctx, inst, index, coord, value, "MIN.U32");
-}
-
-void EmitImageAtomicSMax32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                           ScalarS32 value) {
-    ImageAtomic(ctx, inst, index, coord, value, "MAX.S32");
-}
-
-void EmitImageAtomicUMax32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                           ScalarU32 value) {
-    ImageAtomic(ctx, inst, index, coord, value, "MAX.U32");
-}
-
-void EmitImageAtomicInc32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                          ScalarU32 value) {
-    ImageAtomic(ctx, inst, index, coord, value, "IWRAP.U32");
-}
-
-void EmitImageAtomicDec32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                          ScalarU32 value) {
-    ImageAtomic(ctx, inst, index, coord, value, "DWRAP.U32");
-}
-
-void EmitImageAtomicAnd32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                          ScalarU32 value) {
-    ImageAtomic(ctx, inst, index, coord, value, "AND.U32");
-}
-
-void EmitImageAtomicOr32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                         ScalarU32 value) {
-    ImageAtomic(ctx, inst, index, coord, value, "OR.U32");
-}
-
-void EmitImageAtomicXor32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                          ScalarU32 value) {
-    ImageAtomic(ctx, inst, index, coord, value, "XOR.U32");
-}
-
-void EmitImageAtomicExchange32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                               Register coord, ScalarU32 value) {
-    ImageAtomic(ctx, inst, index, coord, value, "EXCH.U32");
-}
-
-void EmitBindlessImageSampleImplicitLod(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageSampleExplicitLod(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageSampleDrefImplicitLod(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageSampleDrefExplicitLod(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageGather(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageGatherDref(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageFetch(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageQueryDimensions(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageQueryLod(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageGradient(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageRead(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageWrite(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageSampleImplicitLod(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageSampleExplicitLod(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageSampleDrefImplicitLod(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageSampleDrefExplicitLod(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageGather(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageGatherDref(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageFetch(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageQueryDimensions(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageQueryLod(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageGradient(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageRead(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageWrite(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageAtomicIAdd32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageAtomicSMin32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageAtomicUMin32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageAtomicSMax32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageAtomicUMax32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageAtomicInc32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageAtomicDec32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageAtomicAnd32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageAtomicOr32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageAtomicXor32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBindlessImageAtomicExchange32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageAtomicIAdd32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageAtomicSMin32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageAtomicUMin32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageAtomicSMax32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageAtomicUMax32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageAtomicInc32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageAtomicDec32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageAtomicAnd32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageAtomicOr32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageAtomicXor32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-void EmitBoundImageAtomicExchange32(EmitContext&) {
-    throw LogicError("Unreachable instruction");
-}
-
-} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_instructions.h

@@ -1,625 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#pragma once
-
-#include "common/common_types.h"
-#include "shader_recompiler/backend/glasm/reg_alloc.h"
-
-namespace Shader::IR {
-enum class Attribute : u64;
-enum class Patch : u64;
-class Inst;
-class Value;
-} // namespace Shader::IR
-
-namespace Shader::Backend::GLASM {
-
-class EmitContext;
-
-// Microinstruction emitters
-void EmitPhi(EmitContext& ctx, IR::Inst& inst);
-void EmitVoid(EmitContext& ctx);
-void EmitIdentity(EmitContext& ctx, IR::Inst& inst, const IR::Value& value);
-void EmitConditionRef(EmitContext& ctx, IR::Inst& inst, const IR::Value& value);
-void EmitReference(EmitContext&, const IR::Value& value);
-void EmitPhiMove(EmitContext& ctx, const IR::Value& phi, const IR::Value& value);
-void EmitJoin(EmitContext& ctx);
-void EmitDemoteToHelperInvocation(EmitContext& ctx);
-void EmitBarrier(EmitContext& ctx);
-void EmitWorkgroupMemoryBarrier(EmitContext& ctx);
-void EmitDeviceMemoryBarrier(EmitContext& ctx);
-void EmitPrologue(EmitContext& ctx);
-void EmitEpilogue(EmitContext& ctx);
-void EmitEmitVertex(EmitContext& ctx, ScalarS32 stream);
-void EmitEndPrimitive(EmitContext& ctx, const IR::Value& stream);
-void EmitGetRegister(EmitContext& ctx);
-void EmitSetRegister(EmitContext& ctx);
-void EmitGetPred(EmitContext& ctx);
-void EmitSetPred(EmitContext& ctx);
-void EmitSetGotoVariable(EmitContext& ctx);
-void EmitGetGotoVariable(EmitContext& ctx);
-void EmitSetIndirectBranchVariable(EmitContext& ctx);
-void EmitGetIndirectBranchVariable(EmitContext& ctx);
-void EmitGetCbufU8(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU32 offset);
-void EmitGetCbufS8(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU32 offset);
-void EmitGetCbufU16(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU32 offset);
-void EmitGetCbufS16(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU32 offset);
-void EmitGetCbufU32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU32 offset);
-void EmitGetCbufF32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU32 offset);
-void EmitGetCbufU32x2(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU32 offset);
-void EmitGetAttribute(EmitContext& ctx, IR::Inst& inst, IR::Attribute attr, ScalarU32 vertex);
-void EmitSetAttribute(EmitContext& ctx, IR::Attribute attr, ScalarF32 value, ScalarU32 vertex);
-void EmitGetAttributeIndexed(EmitContext& ctx, IR::Inst& inst, ScalarS32 offset, ScalarU32 vertex);
-void EmitSetAttributeIndexed(EmitContext& ctx, ScalarU32 offset, ScalarF32 value, ScalarU32 vertex);
-void EmitGetPatch(EmitContext& ctx, IR::Inst& inst, IR::Patch patch);
-void EmitSetPatch(EmitContext& ctx, IR::Patch patch, ScalarF32 value);
-void EmitSetFragColor(EmitContext& ctx, u32 index, u32 component, ScalarF32 value);
-void EmitSetSampleMask(EmitContext& ctx, ScalarS32 value);
-void EmitSetFragDepth(EmitContext& ctx, ScalarF32 value);
-void EmitGetZFlag(EmitContext& ctx);
-void EmitGetSFlag(EmitContext& ctx);
-void EmitGetCFlag(EmitContext& ctx);
-void EmitGetOFlag(EmitContext& ctx);
-void EmitSetZFlag(EmitContext& ctx);
-void EmitSetSFlag(EmitContext& ctx);
-void EmitSetCFlag(EmitContext& ctx);
-void EmitSetOFlag(EmitContext& ctx);
-void EmitWorkgroupId(EmitContext& ctx, IR::Inst& inst);
-void EmitLocalInvocationId(EmitContext& ctx, IR::Inst& inst);
-void EmitInvocationId(EmitContext& ctx, IR::Inst& inst);
-void EmitSampleId(EmitContext& ctx, IR::Inst& inst);
-void EmitIsHelperInvocation(EmitContext& ctx, IR::Inst& inst);
-void EmitYDirection(EmitContext& ctx, IR::Inst& inst);
-void EmitLoadLocal(EmitContext& ctx, IR::Inst& inst, ScalarU32 word_offset);
-void EmitWriteLocal(EmitContext& ctx, ScalarU32 word_offset, ScalarU32 value);
-void EmitUndefU1(EmitContext& ctx, IR::Inst& inst);
-void EmitUndefU8(EmitContext& ctx, IR::Inst& inst);
-void EmitUndefU16(EmitContext& ctx, IR::Inst& inst);
-void EmitUndefU32(EmitContext& ctx, IR::Inst& inst);
-void EmitUndefU64(EmitContext& ctx, IR::Inst& inst);
-void EmitLoadGlobalU8(EmitContext& ctx, IR::Inst& inst, Register address);
-void EmitLoadGlobalS8(EmitContext& ctx, IR::Inst& inst, Register address);
-void EmitLoadGlobalU16(EmitContext& ctx, IR::Inst& inst, Register address);
-void EmitLoadGlobalS16(EmitContext& ctx, IR::Inst& inst, Register address);
-void EmitLoadGlobal32(EmitContext& ctx, IR::Inst& inst, Register address);
-void EmitLoadGlobal64(EmitContext& ctx, IR::Inst& inst, Register address);
-void EmitLoadGlobal128(EmitContext& ctx, IR::Inst& inst, Register address);
-void EmitWriteGlobalU8(EmitContext& ctx, Register address, Register value);
-void EmitWriteGlobalS8(EmitContext& ctx, Register address, Register value);
-void EmitWriteGlobalU16(EmitContext& ctx, Register address, Register value);
-void EmitWriteGlobalS16(EmitContext& ctx, Register address, Register value);
-void EmitWriteGlobal32(EmitContext& ctx, Register address, ScalarU32 value);
-void EmitWriteGlobal64(EmitContext& ctx, Register address, Register value);
-void EmitWriteGlobal128(EmitContext& ctx, Register address, Register value);
-void EmitLoadStorageU8(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                       ScalarU32 offset);
-void EmitLoadStorageS8(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                       ScalarU32 offset);
-void EmitLoadStorageU16(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                        ScalarU32 offset);
-void EmitLoadStorageS16(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                        ScalarU32 offset);
-void EmitLoadStorage32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                       ScalarU32 offset);
-void EmitLoadStorage64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                       ScalarU32 offset);
-void EmitLoadStorage128(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                        ScalarU32 offset);
-void EmitWriteStorageU8(EmitContext& ctx, const IR::Value& binding, ScalarU32 offset,
-                        ScalarU32 value);
-void EmitWriteStorageS8(EmitContext& ctx, const IR::Value& binding, ScalarU32 offset,
-                        ScalarS32 value);
-void EmitWriteStorageU16(EmitContext& ctx, const IR::Value& binding, ScalarU32 offset,
-                         ScalarU32 value);
-void EmitWriteStorageS16(EmitContext& ctx, const IR::Value& binding, ScalarU32 offset,
-                         ScalarS32 value);
-void EmitWriteStorage32(EmitContext& ctx, const IR::Value& binding, ScalarU32 offset,
-                        ScalarU32 value);
-void EmitWriteStorage64(EmitContext& ctx, const IR::Value& binding, ScalarU32 offset,
-                        Register value);
-void EmitWriteStorage128(EmitContext& ctx, const IR::Value& binding, ScalarU32 offset,
-                         Register value);
-void EmitLoadSharedU8(EmitContext& ctx, IR::Inst& inst, ScalarU32 offset);
-void EmitLoadSharedS8(EmitContext& ctx, IR::Inst& inst, ScalarU32 offset);
-void EmitLoadSharedU16(EmitContext& ctx, IR::Inst& inst, ScalarU32 offset);
-void EmitLoadSharedS16(EmitContext& ctx, IR::Inst& inst, ScalarU32 offset);
-void EmitLoadSharedU32(EmitContext& ctx, IR::Inst& inst, ScalarU32 offset);
-void EmitLoadSharedU64(EmitContext& ctx, IR::Inst& inst, ScalarU32 offset);
-void EmitLoadSharedU128(EmitContext& ctx, IR::Inst& inst, ScalarU32 offset);
-void EmitWriteSharedU8(EmitContext& ctx, ScalarU32 offset, ScalarU32 value);
-void EmitWriteSharedU16(EmitContext& ctx, ScalarU32 offset, ScalarU32 value);
-void EmitWriteSharedU32(EmitContext& ctx, ScalarU32 offset, ScalarU32 value);
-void EmitWriteSharedU64(EmitContext& ctx, ScalarU32 offset, Register value);
-void EmitWriteSharedU128(EmitContext& ctx, ScalarU32 offset, Register value);
-void EmitCompositeConstructU32x2(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
-                                 const IR::Value& e2);
-void EmitCompositeConstructU32x3(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
-                                 const IR::Value& e2, const IR::Value& e3);
-void EmitCompositeConstructU32x4(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
-                                 const IR::Value& e2, const IR::Value& e3, const IR::Value& e4);
-void EmitCompositeExtractU32x2(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index);
-void EmitCompositeExtractU32x3(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index);
-void EmitCompositeExtractU32x4(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index);
-void EmitCompositeInsertU32x2(EmitContext& ctx, Register composite, ScalarU32 object, u32 index);
-void EmitCompositeInsertU32x3(EmitContext& ctx, Register composite, ScalarU32 object, u32 index);
-void EmitCompositeInsertU32x4(EmitContext& ctx, Register composite, ScalarU32 object, u32 index);
-void EmitCompositeConstructF16x2(EmitContext& ctx, Register e1, Register e2);
-void EmitCompositeConstructF16x3(EmitContext& ctx, Register e1, Register e2, Register e3);
-void EmitCompositeConstructF16x4(EmitContext& ctx, Register e1, Register e2, Register e3,
-                                 Register e4);
-void EmitCompositeExtractF16x2(EmitContext& ctx, Register composite, u32 index);
-void EmitCompositeExtractF16x3(EmitContext& ctx, Register composite, u32 index);
-void EmitCompositeExtractF16x4(EmitContext& ctx, Register composite, u32 index);
-void EmitCompositeInsertF16x2(EmitContext& ctx, Register composite, Register object, u32 index);
-void EmitCompositeInsertF16x3(EmitContext& ctx, Register composite, Register object, u32 index);
-void EmitCompositeInsertF16x4(EmitContext& ctx, Register composite, Register object, u32 index);
-void EmitCompositeConstructF32x2(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
-                                 const IR::Value& e2);
-void EmitCompositeConstructF32x3(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
-                                 const IR::Value& e2, const IR::Value& e3);
-void EmitCompositeConstructF32x4(EmitContext& ctx, IR::Inst& inst, const IR::Value& e1,
-                                 const IR::Value& e2, const IR::Value& e3, const IR::Value& e4);
-void EmitCompositeExtractF32x2(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index);
-void EmitCompositeExtractF32x3(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index);
-void EmitCompositeExtractF32x4(EmitContext& ctx, IR::Inst& inst, Register composite, u32 index);
-void EmitCompositeInsertF32x2(EmitContext& ctx, IR::Inst& inst, Register composite,
-                              ScalarF32 object, u32 index);
-void EmitCompositeInsertF32x3(EmitContext& ctx, IR::Inst& inst, Register composite,
-                              ScalarF32 object, u32 index);
-void EmitCompositeInsertF32x4(EmitContext& ctx, IR::Inst& inst, Register composite,
-                              ScalarF32 object, u32 index);
-void EmitCompositeConstructF64x2(EmitContext& ctx);
-void EmitCompositeConstructF64x3(EmitContext& ctx);
-void EmitCompositeConstructF64x4(EmitContext& ctx);
-void EmitCompositeExtractF64x2(EmitContext& ctx);
-void EmitCompositeExtractF64x3(EmitContext& ctx);
-void EmitCompositeExtractF64x4(EmitContext& ctx);
-void EmitCompositeInsertF64x2(EmitContext& ctx, Register composite, Register object, u32 index);
-void EmitCompositeInsertF64x3(EmitContext& ctx, Register composite, Register object, u32 index);
-void EmitCompositeInsertF64x4(EmitContext& ctx, Register composite, Register object, u32 index);
-void EmitSelectU1(EmitContext& ctx, IR::Inst& inst, ScalarS32 cond, ScalarS32 true_value,
-                  ScalarS32 false_value);
-void EmitSelectU8(EmitContext& ctx, ScalarS32 cond, ScalarS32 true_value, ScalarS32 false_value);
-void EmitSelectU16(EmitContext& ctx, ScalarS32 cond, ScalarS32 true_value, ScalarS32 false_value);
-void EmitSelectU32(EmitContext& ctx, IR::Inst& inst, ScalarS32 cond, ScalarS32 true_value,
-                   ScalarS32 false_value);
-void EmitSelectU64(EmitContext& ctx, IR::Inst& inst, ScalarS32 cond, Register true_value,
-                   Register false_value);
-void EmitSelectF16(EmitContext& ctx, ScalarS32 cond, Register true_value, Register false_value);
-void EmitSelectF32(EmitContext& ctx, IR::Inst& inst, ScalarS32 cond, ScalarS32 true_value,
-                   ScalarS32 false_value);
-void EmitSelectF64(EmitContext& ctx, ScalarS32 cond, Register true_value, Register false_value);
-void EmitBitCastU16F16(EmitContext& ctx, IR::Inst& inst, const IR::Value& value);
-void EmitBitCastU32F32(EmitContext& ctx, IR::Inst& inst, const IR::Value& value);
-void EmitBitCastU64F64(EmitContext& ctx, IR::Inst& inst, const IR::Value& value);
-void EmitBitCastF16U16(EmitContext& ctx, IR::Inst& inst, const IR::Value& value);
-void EmitBitCastF32U32(EmitContext& ctx, IR::Inst& inst, const IR::Value& value);
-void EmitBitCastF64U64(EmitContext& ctx, IR::Inst& inst, const IR::Value& value);
-void EmitPackUint2x32(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitUnpackUint2x32(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitPackFloat2x16(EmitContext& ctx, Register value);
-void EmitUnpackFloat2x16(EmitContext& ctx, Register value);
-void EmitPackHalf2x16(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitUnpackHalf2x16(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitPackDouble2x32(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitUnpackDouble2x32(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitGetZeroFromOp(EmitContext& ctx);
-void EmitGetSignFromOp(EmitContext& ctx);
-void EmitGetCarryFromOp(EmitContext& ctx);
-void EmitGetOverflowFromOp(EmitContext& ctx);
-void EmitGetSparseFromOp(EmitContext& ctx);
-void EmitGetInBoundsFromOp(EmitContext& ctx);
-void EmitFPAbs16(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitFPAbs32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitFPAbs64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value);
-void EmitFPAdd16(EmitContext& ctx, IR::Inst& inst, Register a, Register b);
-void EmitFPAdd32(EmitContext& ctx, IR::Inst& inst, ScalarF32 a, ScalarF32 b);
-void EmitFPAdd64(EmitContext& ctx, IR::Inst& inst, ScalarF64 a, ScalarF64 b);
-void EmitFPFma16(EmitContext& ctx, IR::Inst& inst, Register a, Register b, Register c);
-void EmitFPFma32(EmitContext& ctx, IR::Inst& inst, ScalarF32 a, ScalarF32 b, ScalarF32 c);
-void EmitFPFma64(EmitContext& ctx, IR::Inst& inst, ScalarF64 a, ScalarF64 b, ScalarF64 c);
-void EmitFPMax32(EmitContext& ctx, IR::Inst& inst, ScalarF32 a, ScalarF32 b);
-void EmitFPMax64(EmitContext& ctx, IR::Inst& inst, ScalarF64 a, ScalarF64 b);
-void EmitFPMin32(EmitContext& ctx, IR::Inst& inst, ScalarF32 a, ScalarF32 b);
-void EmitFPMin64(EmitContext& ctx, IR::Inst& inst, ScalarF64 a, ScalarF64 b);
-void EmitFPMul16(EmitContext& ctx, IR::Inst& inst, Register a, Register b);
-void EmitFPMul32(EmitContext& ctx, IR::Inst& inst, ScalarF32 a, ScalarF32 b);
-void EmitFPMul64(EmitContext& ctx, IR::Inst& inst, ScalarF64 a, ScalarF64 b);
-void EmitFPNeg16(EmitContext& ctx, Register value);
-void EmitFPNeg32(EmitContext& ctx, IR::Inst& inst, ScalarRegister value);
-void EmitFPNeg64(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitFPSin(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitFPCos(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitFPExp2(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitFPLog2(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitFPRecip32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitFPRecip64(EmitContext& ctx, Register value);
-void EmitFPRecipSqrt32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitFPRecipSqrt64(EmitContext& ctx, Register value);
-void EmitFPSqrt(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitFPSaturate16(EmitContext& ctx, Register value);
-void EmitFPSaturate32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitFPSaturate64(EmitContext& ctx, Register value);
-void EmitFPClamp16(EmitContext& ctx, Register value, Register min_value, Register max_value);
-void EmitFPClamp32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value, ScalarF32 min_value,
-                   ScalarF32 max_value);
-void EmitFPClamp64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value, ScalarF64 min_value,
-                   ScalarF64 max_value);
-void EmitFPRoundEven16(EmitContext& ctx, Register value);
-void EmitFPRoundEven32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitFPRoundEven64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value);
-void EmitFPFloor16(EmitContext& ctx, Register value);
-void EmitFPFloor32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitFPFloor64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value);
-void EmitFPCeil16(EmitContext& ctx, Register value);
-void EmitFPCeil32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitFPCeil64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value);
-void EmitFPTrunc16(EmitContext& ctx, Register value);
-void EmitFPTrunc32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitFPTrunc64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value);
-void EmitFPOrdEqual16(EmitContext& ctx, Register lhs, Register rhs);
-void EmitFPOrdEqual32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs);
-void EmitFPOrdEqual64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs);
-void EmitFPUnordEqual16(EmitContext& ctx, Register lhs, Register rhs);
-void EmitFPUnordEqual32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs);
-void EmitFPUnordEqual64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs);
-void EmitFPOrdNotEqual16(EmitContext& ctx, Register lhs, Register rhs);
-void EmitFPOrdNotEqual32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs);
-void EmitFPOrdNotEqual64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs);
-void EmitFPUnordNotEqual16(EmitContext& ctx, Register lhs, Register rhs);
-void EmitFPUnordNotEqual32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs);
-void EmitFPUnordNotEqual64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs);
-void EmitFPOrdLessThan16(EmitContext& ctx, Register lhs, Register rhs);
-void EmitFPOrdLessThan32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs);
-void EmitFPOrdLessThan64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs);
-void EmitFPUnordLessThan16(EmitContext& ctx, Register lhs, Register rhs);
-void EmitFPUnordLessThan32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs);
-void EmitFPUnordLessThan64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs);
-void EmitFPOrdGreaterThan16(EmitContext& ctx, Register lhs, Register rhs);
-void EmitFPOrdGreaterThan32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs);
-void EmitFPOrdGreaterThan64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs);
-void EmitFPUnordGreaterThan16(EmitContext& ctx, Register lhs, Register rhs);
-void EmitFPUnordGreaterThan32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs);
-void EmitFPUnordGreaterThan64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs);
-void EmitFPOrdLessThanEqual16(EmitContext& ctx, Register lhs, Register rhs);
-void EmitFPOrdLessThanEqual32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs);
-void EmitFPOrdLessThanEqual64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs);
-void EmitFPUnordLessThanEqual16(EmitContext& ctx, Register lhs, Register rhs);
-void EmitFPUnordLessThanEqual32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs);
-void EmitFPUnordLessThanEqual64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs);
-void EmitFPOrdGreaterThanEqual16(EmitContext& ctx, Register lhs, Register rhs);
-void EmitFPOrdGreaterThanEqual32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs);
-void EmitFPOrdGreaterThanEqual64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs);
-void EmitFPUnordGreaterThanEqual16(EmitContext& ctx, Register lhs, Register rhs);
-void EmitFPUnordGreaterThanEqual32(EmitContext& ctx, IR::Inst& inst, ScalarF32 lhs, ScalarF32 rhs);
-void EmitFPUnordGreaterThanEqual64(EmitContext& ctx, IR::Inst& inst, ScalarF64 lhs, ScalarF64 rhs);
-void EmitFPIsNan16(EmitContext& ctx, Register value);
-void EmitFPIsNan32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitFPIsNan64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value);
-void EmitIAdd32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b);
-void EmitIAdd64(EmitContext& ctx, IR::Inst& inst, Register a, Register b);
-void EmitISub32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b);
-void EmitISub64(EmitContext& ctx, IR::Inst& inst, Register a, Register b);
-void EmitIMul32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b);
-void EmitINeg32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value);
-void EmitINeg64(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitIAbs32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value);
-void EmitShiftLeftLogical32(EmitContext& ctx, IR::Inst& inst, ScalarU32 base, ScalarU32 shift);
-void EmitShiftLeftLogical64(EmitContext& ctx, IR::Inst& inst, ScalarRegister base, ScalarU32 shift);
-void EmitShiftRightLogical32(EmitContext& ctx, IR::Inst& inst, ScalarU32 base, ScalarU32 shift);
-void EmitShiftRightLogical64(EmitContext& ctx, IR::Inst& inst, ScalarRegister base,
-                             ScalarU32 shift);
-void EmitShiftRightArithmetic32(EmitContext& ctx, IR::Inst& inst, ScalarS32 base, ScalarS32 shift);
-void EmitShiftRightArithmetic64(EmitContext& ctx, IR::Inst& inst, ScalarRegister base,
-                                ScalarS32 shift);
-void EmitBitwiseAnd32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b);
-void EmitBitwiseOr32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b);
-void EmitBitwiseXor32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b);
-void EmitBitFieldInsert(EmitContext& ctx, IR::Inst& inst, ScalarS32 base, ScalarS32 insert,
-                        ScalarS32 offset, ScalarS32 count);
-void EmitBitFieldSExtract(EmitContext& ctx, IR::Inst& inst, ScalarS32 base, ScalarS32 offset,
-                          ScalarS32 count);
-void EmitBitFieldUExtract(EmitContext& ctx, IR::Inst& inst, ScalarU32 base, ScalarU32 offset,
-                          ScalarU32 count);
-void EmitBitReverse32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value);
-void EmitBitCount32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value);
-void EmitBitwiseNot32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value);
-void EmitFindSMsb32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value);
-void EmitFindUMsb32(EmitContext& ctx, IR::Inst& inst, ScalarU32 value);
-void EmitSMin32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b);
-void EmitUMin32(EmitContext& ctx, IR::Inst& inst, ScalarU32 a, ScalarU32 b);
-void EmitSMax32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b);
-void EmitUMax32(EmitContext& ctx, IR::Inst& inst, ScalarU32 a, ScalarU32 b);
-void EmitSClamp32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value, ScalarS32 min, ScalarS32 max);
-void EmitUClamp32(EmitContext& ctx, IR::Inst& inst, ScalarU32 value, ScalarU32 min, ScalarU32 max);
-void EmitSLessThan(EmitContext& ctx, IR::Inst& inst, ScalarS32 lhs, ScalarS32 rhs);
-void EmitULessThan(EmitContext& ctx, IR::Inst& inst, ScalarU32 lhs, ScalarU32 rhs);
-void EmitIEqual(EmitContext& ctx, IR::Inst& inst, ScalarS32 lhs, ScalarS32 rhs);
-void EmitSLessThanEqual(EmitContext& ctx, IR::Inst& inst, ScalarS32 lhs, ScalarS32 rhs);
-void EmitULessThanEqual(EmitContext& ctx, IR::Inst& inst, ScalarU32 lhs, ScalarU32 rhs);
-void EmitSGreaterThan(EmitContext& ctx, IR::Inst& inst, ScalarS32 lhs, ScalarS32 rhs);
-void EmitUGreaterThan(EmitContext& ctx, IR::Inst& inst, ScalarU32 lhs, ScalarU32 rhs);
-void EmitINotEqual(EmitContext& ctx, IR::Inst& inst, ScalarS32 lhs, ScalarS32 rhs);
-void EmitSGreaterThanEqual(EmitContext& ctx, IR::Inst& inst, ScalarS32 lhs, ScalarS32 rhs);
-void EmitUGreaterThanEqual(EmitContext& ctx, IR::Inst& inst, ScalarU32 lhs, ScalarU32 rhs);
-void EmitSharedAtomicIAdd32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                            ScalarU32 value);
-void EmitSharedAtomicSMin32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                            ScalarS32 value);
-void EmitSharedAtomicUMin32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                            ScalarU32 value);
-void EmitSharedAtomicSMax32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                            ScalarS32 value);
-void EmitSharedAtomicUMax32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                            ScalarU32 value);
-void EmitSharedAtomicInc32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                           ScalarU32 value);
-void EmitSharedAtomicDec32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                           ScalarU32 value);
-void EmitSharedAtomicAnd32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                           ScalarU32 value);
-void EmitSharedAtomicOr32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                          ScalarU32 value);
-void EmitSharedAtomicXor32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                           ScalarU32 value);
-void EmitSharedAtomicExchange32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                                ScalarU32 value);
-void EmitSharedAtomicExchange64(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                                Register value);
-void EmitStorageAtomicIAdd32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, ScalarU32 value);
-void EmitStorageAtomicSMin32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, ScalarS32 value);
-void EmitStorageAtomicUMin32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, ScalarU32 value);
-void EmitStorageAtomicSMax32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, ScalarS32 value);
-void EmitStorageAtomicUMax32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, ScalarU32 value);
-void EmitStorageAtomicInc32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                            ScalarU32 offset, ScalarU32 value);
-void EmitStorageAtomicDec32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                            ScalarU32 offset, ScalarU32 value);
-void EmitStorageAtomicAnd32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                            ScalarU32 offset, ScalarU32 value);
-void EmitStorageAtomicOr32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                           ScalarU32 offset, ScalarU32 value);
-void EmitStorageAtomicXor32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                            ScalarU32 offset, ScalarU32 value);
-void EmitStorageAtomicExchange32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                                 ScalarU32 offset, ScalarU32 value);
-void EmitStorageAtomicIAdd64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, Register value);
-void EmitStorageAtomicSMin64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, Register value);
-void EmitStorageAtomicUMin64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, Register value);
-void EmitStorageAtomicSMax64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, Register value);
-void EmitStorageAtomicUMax64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, Register value);
-void EmitStorageAtomicAnd64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                            ScalarU32 offset, Register value);
-void EmitStorageAtomicOr64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                           ScalarU32 offset, Register value);
-void EmitStorageAtomicXor64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                            ScalarU32 offset, Register value);
-void EmitStorageAtomicExchange64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                                 ScalarU32 offset, Register value);
-void EmitStorageAtomicAddF32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, ScalarF32 value);
-void EmitStorageAtomicAddF16x2(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                               ScalarU32 offset, Register value);
-void EmitStorageAtomicAddF32x2(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                               ScalarU32 offset, Register value);
-void EmitStorageAtomicMinF16x2(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                               ScalarU32 offset, Register value);
-void EmitStorageAtomicMinF32x2(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                               ScalarU32 offset, Register value);
-void EmitStorageAtomicMaxF16x2(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                               ScalarU32 offset, Register value);
-void EmitStorageAtomicMaxF32x2(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                               ScalarU32 offset, Register value);
-void EmitGlobalAtomicIAdd32(EmitContext& ctx);
-void EmitGlobalAtomicSMin32(EmitContext& ctx);
-void EmitGlobalAtomicUMin32(EmitContext& ctx);
-void EmitGlobalAtomicSMax32(EmitContext& ctx);
-void EmitGlobalAtomicUMax32(EmitContext& ctx);
-void EmitGlobalAtomicInc32(EmitContext& ctx);
-void EmitGlobalAtomicDec32(EmitContext& ctx);
-void EmitGlobalAtomicAnd32(EmitContext& ctx);
-void EmitGlobalAtomicOr32(EmitContext& ctx);
-void EmitGlobalAtomicXor32(EmitContext& ctx);
-void EmitGlobalAtomicExchange32(EmitContext& ctx);
-void EmitGlobalAtomicIAdd64(EmitContext& ctx);
-void EmitGlobalAtomicSMin64(EmitContext& ctx);
-void EmitGlobalAtomicUMin64(EmitContext& ctx);
-void EmitGlobalAtomicSMax64(EmitContext& ctx);
-void EmitGlobalAtomicUMax64(EmitContext& ctx);
-void EmitGlobalAtomicInc64(EmitContext& ctx);
-void EmitGlobalAtomicDec64(EmitContext& ctx);
-void EmitGlobalAtomicAnd64(EmitContext& ctx);
-void EmitGlobalAtomicOr64(EmitContext& ctx);
-void EmitGlobalAtomicXor64(EmitContext& ctx);
-void EmitGlobalAtomicExchange64(EmitContext& ctx);
-void EmitGlobalAtomicAddF32(EmitContext& ctx);
-void EmitGlobalAtomicAddF16x2(EmitContext& ctx);
-void EmitGlobalAtomicAddF32x2(EmitContext& ctx);
-void EmitGlobalAtomicMinF16x2(EmitContext& ctx);
-void EmitGlobalAtomicMinF32x2(EmitContext& ctx);
-void EmitGlobalAtomicMaxF16x2(EmitContext& ctx);
-void EmitGlobalAtomicMaxF32x2(EmitContext& ctx);
-void EmitLogicalOr(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b);
-void EmitLogicalAnd(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b);
-void EmitLogicalXor(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b);
-void EmitLogicalNot(EmitContext& ctx, IR::Inst& inst, ScalarS32 value);
-void EmitConvertS16F16(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertS16F32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitConvertS16F64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value);
-void EmitConvertS32F16(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertS32F32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitConvertS32F64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value);
-void EmitConvertS64F16(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertS64F32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitConvertS64F64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value);
-void EmitConvertU16F16(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertU16F32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitConvertU16F64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value);
-void EmitConvertU32F16(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertU32F32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitConvertU32F64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value);
-void EmitConvertU64F16(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertU64F32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitConvertU64F64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value);
-void EmitConvertU64U32(EmitContext& ctx, IR::Inst& inst, ScalarU32 value);
-void EmitConvertU32U64(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF16F32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitConvertF32F16(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF32F64(EmitContext& ctx, IR::Inst& inst, ScalarF64 value);
-void EmitConvertF64F32(EmitContext& ctx, IR::Inst& inst, ScalarF32 value);
-void EmitConvertF16S8(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF16S16(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF16S32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value);
-void EmitConvertF16S64(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF16U8(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF16U16(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF16U32(EmitContext& ctx, IR::Inst& inst, ScalarU32 value);
-void EmitConvertF16U64(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF32S8(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF32S16(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF32S32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value);
-void EmitConvertF32S64(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF32U8(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF32U16(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF32U32(EmitContext& ctx, IR::Inst& inst, ScalarU32 value);
-void EmitConvertF32U64(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF64S8(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF64S16(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF64S32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value);
-void EmitConvertF64S64(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF64U8(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF64U16(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitConvertF64U32(EmitContext& ctx, IR::Inst& inst, ScalarU32 value);
-void EmitConvertF64U64(EmitContext& ctx, IR::Inst& inst, Register value);
-void EmitBindlessImageSampleImplicitLod(EmitContext&);
-void EmitBindlessImageSampleExplicitLod(EmitContext&);
-void EmitBindlessImageSampleDrefImplicitLod(EmitContext&);
-void EmitBindlessImageSampleDrefExplicitLod(EmitContext&);
-void EmitBindlessImageGather(EmitContext&);
-void EmitBindlessImageGatherDref(EmitContext&);
-void EmitBindlessImageFetch(EmitContext&);
-void EmitBindlessImageQueryDimensions(EmitContext&);
-void EmitBindlessImageQueryLod(EmitContext&);
-void EmitBindlessImageGradient(EmitContext&);
-void EmitBindlessImageRead(EmitContext&);
-void EmitBindlessImageWrite(EmitContext&);
-void EmitBoundImageSampleImplicitLod(EmitContext&);
-void EmitBoundImageSampleExplicitLod(EmitContext&);
-void EmitBoundImageSampleDrefImplicitLod(EmitContext&);
-void EmitBoundImageSampleDrefExplicitLod(EmitContext&);
-void EmitBoundImageGather(EmitContext&);
-void EmitBoundImageGatherDref(EmitContext&);
-void EmitBoundImageFetch(EmitContext&);
-void EmitBoundImageQueryDimensions(EmitContext&);
-void EmitBoundImageQueryLod(EmitContext&);
-void EmitBoundImageGradient(EmitContext&);
-void EmitBoundImageRead(EmitContext&);
-void EmitBoundImageWrite(EmitContext&);
-void EmitImageSampleImplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                                const IR::Value& coord, Register bias_lc, const IR::Value& offset);
-void EmitImageSampleExplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                                const IR::Value& coord, ScalarF32 lod, const IR::Value& offset);
-void EmitImageSampleDrefImplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                                    const IR::Value& coord, const IR::Value& dref,
-                                    const IR::Value& bias_lc, const IR::Value& offset);
-void EmitImageSampleDrefExplicitLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                                    const IR::Value& coord, const IR::Value& dref,
-                                    const IR::Value& lod, const IR::Value& offset);
-void EmitImageGather(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                     const IR::Value& coord, const IR::Value& offset, const IR::Value& offset2);
-void EmitImageGatherDref(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                         const IR::Value& coord, const IR::Value& offset, const IR::Value& offset2,
-                         const IR::Value& dref);
-void EmitImageFetch(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                    const IR::Value& coord, const IR::Value& offset, ScalarS32 lod, ScalarS32 ms);
-void EmitImageQueryDimensions(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                              ScalarS32 lod);
-void EmitImageQueryLod(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord);
-void EmitImageGradient(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                       const IR::Value& coord, const IR::Value& derivatives,
-                       const IR::Value& offset, const IR::Value& lod_clamp);
-void EmitImageRead(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord);
-void EmitImageWrite(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                    Register color);
-void EmitBindlessImageAtomicIAdd32(EmitContext&);
-void EmitBindlessImageAtomicSMin32(EmitContext&);
-void EmitBindlessImageAtomicUMin32(EmitContext&);
-void EmitBindlessImageAtomicSMax32(EmitContext&);
-void EmitBindlessImageAtomicUMax32(EmitContext&);
-void EmitBindlessImageAtomicInc32(EmitContext&);
-void EmitBindlessImageAtomicDec32(EmitContext&);
-void EmitBindlessImageAtomicAnd32(EmitContext&);
-void EmitBindlessImageAtomicOr32(EmitContext&);
-void EmitBindlessImageAtomicXor32(EmitContext&);
-void EmitBindlessImageAtomicExchange32(EmitContext&);
-void EmitBoundImageAtomicIAdd32(EmitContext&);
-void EmitBoundImageAtomicSMin32(EmitContext&);
-void EmitBoundImageAtomicUMin32(EmitContext&);
-void EmitBoundImageAtomicSMax32(EmitContext&);
-void EmitBoundImageAtomicUMax32(EmitContext&);
-void EmitBoundImageAtomicInc32(EmitContext&);
-void EmitBoundImageAtomicDec32(EmitContext&);
-void EmitBoundImageAtomicAnd32(EmitContext&);
-void EmitBoundImageAtomicOr32(EmitContext&);
-void EmitBoundImageAtomicXor32(EmitContext&);
-void EmitBoundImageAtomicExchange32(EmitContext&);
-void EmitImageAtomicIAdd32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                           ScalarU32 value);
-void EmitImageAtomicSMin32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                           ScalarS32 value);
-void EmitImageAtomicUMin32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                           ScalarU32 value);
-void EmitImageAtomicSMax32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                           ScalarS32 value);
-void EmitImageAtomicUMax32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                           ScalarU32 value);
-void EmitImageAtomicInc32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                          ScalarU32 value);
-void EmitImageAtomicDec32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                          ScalarU32 value);
-void EmitImageAtomicAnd32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                          ScalarU32 value);
-void EmitImageAtomicOr32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                         ScalarU32 value);
-void EmitImageAtomicXor32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index, Register coord,
-                          ScalarU32 value);
-void EmitImageAtomicExchange32(EmitContext& ctx, IR::Inst& inst, const IR::Value& index,
-                               Register coord, ScalarU32 value);
-void EmitLaneId(EmitContext& ctx, IR::Inst& inst);
-void EmitVoteAll(EmitContext& ctx, IR::Inst& inst, ScalarS32 pred);
-void EmitVoteAny(EmitContext& ctx, IR::Inst& inst, ScalarS32 pred);
-void EmitVoteEqual(EmitContext& ctx, IR::Inst& inst, ScalarS32 pred);
-void EmitSubgroupBallot(EmitContext& ctx, IR::Inst& inst, ScalarS32 pred);
-void EmitSubgroupEqMask(EmitContext& ctx, IR::Inst& inst);
-void EmitSubgroupLtMask(EmitContext& ctx, IR::Inst& inst);
-void EmitSubgroupLeMask(EmitContext& ctx, IR::Inst& inst);
-void EmitSubgroupGtMask(EmitContext& ctx, IR::Inst& inst);
-void EmitSubgroupGeMask(EmitContext& ctx, IR::Inst& inst);
-void EmitShuffleIndex(EmitContext& ctx, IR::Inst& inst, ScalarU32 value, ScalarU32 index,
-                      const IR::Value& clamp, const IR::Value& segmentation_mask);
-void EmitShuffleUp(EmitContext& ctx, IR::Inst& inst, ScalarU32 value, ScalarU32 index,
-                   const IR::Value& clamp, const IR::Value& segmentation_mask);
-void EmitShuffleDown(EmitContext& ctx, IR::Inst& inst, ScalarU32 value, ScalarU32 index,
-                     const IR::Value& clamp, const IR::Value& segmentation_mask);
-void EmitShuffleButterfly(EmitContext& ctx, IR::Inst& inst, ScalarU32 value, ScalarU32 index,
-                          const IR::Value& clamp, const IR::Value& segmentation_mask);
-void EmitFSwizzleAdd(EmitContext& ctx, IR::Inst& inst, ScalarF32 op_a, ScalarF32 op_b,
-                     ScalarU32 swizzle);
-void EmitDPdxFine(EmitContext& ctx, IR::Inst& inst, ScalarF32 op_a);
-void EmitDPdyFine(EmitContext& ctx, IR::Inst& inst, ScalarF32 op_a);
-void EmitDPdxCoarse(EmitContext& ctx, IR::Inst& inst, ScalarF32 op_a);
-void EmitDPdyCoarse(EmitContext& ctx, IR::Inst& inst, ScalarF32 op_a);
-
-} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_integer.cpp

@@ -1,294 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "shader_recompiler/backend/glasm/emit_context.h"
-#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
-#include "shader_recompiler/frontend/ir/value.h"
-
-namespace Shader::Backend::GLASM {
-namespace {
-void BitwiseLogicalOp(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b,
-                      std::string_view lop) {
-    const auto zero = inst.GetAssociatedPseudoOperation(IR::Opcode::GetZeroFromOp);
-    const auto sign = inst.GetAssociatedPseudoOperation(IR::Opcode::GetSignFromOp);
-    if (zero) {
-        zero->Invalidate();
-    }
-    if (sign) {
-        sign->Invalidate();
-    }
-    if (zero || sign) {
-        ctx.reg_alloc.InvalidateConditionCodes();
-    }
-    const auto ret{ctx.reg_alloc.Define(inst)};
-    ctx.Add("{}.S {}.x,{},{};", lop, ret, a, b);
-    if (zero) {
-        ctx.Add("SEQ.S {},{},0;", *zero, ret);
-    }
-    if (sign) {
-        ctx.Add("SLT.S {},{},0;", *sign, ret);
-    }
-}
-} // Anonymous namespace
-
-void EmitIAdd32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
-    const std::array flags{
-        inst.GetAssociatedPseudoOperation(IR::Opcode::GetZeroFromOp),
-        inst.GetAssociatedPseudoOperation(IR::Opcode::GetSignFromOp),
-        inst.GetAssociatedPseudoOperation(IR::Opcode::GetCarryFromOp),
-        inst.GetAssociatedPseudoOperation(IR::Opcode::GetOverflowFromOp),
-    };
-    for (IR::Inst* const flag_inst : flags) {
-        if (flag_inst) {
-            flag_inst->Invalidate();
-        }
-    }
-    const bool cc{inst.HasAssociatedPseudoOperation()};
-    const std::string_view cc_mod{cc ? ".CC" : ""};
-    if (cc) {
-        ctx.reg_alloc.InvalidateConditionCodes();
-    }
-    const auto ret{ctx.reg_alloc.Define(inst)};
-    ctx.Add("ADD.S{} {}.x,{},{};", cc_mod, ret, a, b);
-    if (!cc) {
-        return;
-    }
-    static constexpr std::array<std::string_view, 4> masks{"", "SF", "CF", "OF"};
-    for (size_t flag_index = 0; flag_index < flags.size(); ++flag_index) {
-        if (!flags[flag_index]) {
-            continue;
-        }
-        const auto flag_ret{ctx.reg_alloc.Define(*flags[flag_index])};
-        if (flag_index == 0) {
-            ctx.Add("SEQ.S {}.x,{}.x,0;", flag_ret, ret);
-        } else {
-            // We could use conditional execution here, but it's broken on Nvidia's compiler
-            ctx.Add("IF {}.x;"
-                    "MOV.S {}.x,-1;"
-                    "ELSE;"
-                    "MOV.S {}.x,0;"
-                    "ENDIF;",
-                    masks[flag_index], flag_ret, flag_ret);
-        }
-    }
-}
-
-void EmitIAdd64(EmitContext& ctx, IR::Inst& inst, Register a, Register b) {
-    ctx.LongAdd("ADD.S64 {}.x,{}.x,{}.x;", inst, a, b);
-}
-
-void EmitISub32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
-    ctx.Add("SUB.S {}.x,{},{};", inst, a, b);
-}
-
-void EmitISub64(EmitContext& ctx, IR::Inst& inst, Register a, Register b) {
-    ctx.LongAdd("SUB.S64 {}.x,{}.x,{}.x;", inst, a, b);
-}
-
-void EmitIMul32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
-    ctx.Add("MUL.S {}.x,{},{};", inst, a, b);
-}
-
-void EmitINeg32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value) {
-    if (value.type != Type::Register && static_cast<s32>(value.imm_u32) < 0) {
-        ctx.Add("MOV.S {},{};", inst, -static_cast<s32>(value.imm_u32));
-    } else {
-        ctx.Add("MOV.S {},-{};", inst, value);
-    }
-}
-
-void EmitINeg64(EmitContext& ctx, IR::Inst& inst, Register value) {
-    ctx.LongAdd("MOV.S64 {},-{};", inst, value);
-}
-
-void EmitIAbs32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value) {
-    ctx.Add("ABS.S {},{};", inst, value);
-}
-
-void EmitShiftLeftLogical32(EmitContext& ctx, IR::Inst& inst, ScalarU32 base, ScalarU32 shift) {
-    ctx.Add("SHL.U {}.x,{},{};", inst, base, shift);
-}
-
-void EmitShiftLeftLogical64(EmitContext& ctx, IR::Inst& inst, ScalarRegister base,
-                            ScalarU32 shift) {
-    ctx.LongAdd("SHL.U64 {}.x,{},{};", inst, base, shift);
-}
-
-void EmitShiftRightLogical32(EmitContext& ctx, IR::Inst& inst, ScalarU32 base, ScalarU32 shift) {
-    ctx.Add("SHR.U {}.x,{},{};", inst, base, shift);
-}
-
-void EmitShiftRightLogical64(EmitContext& ctx, IR::Inst& inst, ScalarRegister base,
-                             ScalarU32 shift) {
-    ctx.LongAdd("SHR.U64 {}.x,{},{};", inst, base, shift);
-}
-
-void EmitShiftRightArithmetic32(EmitContext& ctx, IR::Inst& inst, ScalarS32 base, ScalarS32 shift) {
-    ctx.Add("SHR.S {}.x,{},{};", inst, base, shift);
-}
-
-void EmitShiftRightArithmetic64(EmitContext& ctx, IR::Inst& inst, ScalarRegister base,
-                                ScalarS32 shift) {
-    ctx.LongAdd("SHR.S64 {}.x,{},{};", inst, base, shift);
-}
-
-void EmitBitwiseAnd32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
-    BitwiseLogicalOp(ctx, inst, a, b, "AND");
-}
-
-void EmitBitwiseOr32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
-    BitwiseLogicalOp(ctx, inst, a, b, "OR");
-}
-
-void EmitBitwiseXor32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
-    BitwiseLogicalOp(ctx, inst, a, b, "XOR");
-}
-
-void EmitBitFieldInsert(EmitContext& ctx, IR::Inst& inst, ScalarS32 base, ScalarS32 insert,
-                        ScalarS32 offset, ScalarS32 count) {
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    if (count.type != Type::Register && offset.type != Type::Register) {
-        ctx.Add("BFI.S {},{{{},{},0,0}},{},{};", ret, count, offset, insert, base);
-    } else {
-        ctx.Add("MOV.S RC.x,{};"
-                "MOV.S RC.y,{};"
-                "BFI.S {},RC,{},{};",
-                count, offset, ret, insert, base);
-    }
-}
-
-void EmitBitFieldSExtract(EmitContext& ctx, IR::Inst& inst, ScalarS32 base, ScalarS32 offset,
-                          ScalarS32 count) {
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    if (count.type != Type::Register && offset.type != Type::Register) {
-        ctx.Add("BFE.S {},{{{},{},0,0}},{};", ret, count, offset, base);
-    } else {
-        ctx.Add("MOV.S RC.x,{};"
-                "MOV.S RC.y,{};"
-                "BFE.S {},RC,{};",
-                count, offset, ret, base);
-    }
-}
-
-void EmitBitFieldUExtract(EmitContext& ctx, IR::Inst& inst, ScalarU32 base, ScalarU32 offset,
-                          ScalarU32 count) {
-    const auto zero = inst.GetAssociatedPseudoOperation(IR::Opcode::GetZeroFromOp);
-    const auto sign = inst.GetAssociatedPseudoOperation(IR::Opcode::GetSignFromOp);
-    if (zero) {
-        zero->Invalidate();
-    }
-    if (sign) {
-        sign->Invalidate();
-    }
-    if (zero || sign) {
-        ctx.reg_alloc.InvalidateConditionCodes();
-    }
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    if (count.type != Type::Register && offset.type != Type::Register) {
-        ctx.Add("BFE.U {},{{{},{},0,0}},{};", ret, count, offset, base);
-    } else {
-        ctx.Add("MOV.U RC.x,{};"
-                "MOV.U RC.y,{};"
-                "BFE.U {},RC,{};",
-                count, offset, ret, base);
-    }
-    if (zero) {
-        ctx.Add("SEQ.S {},{},0;", *zero, ret);
-    }
-    if (sign) {
-        ctx.Add("SLT.S {},{},0;", *sign, ret);
-    }
-}
-
-void EmitBitReverse32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value) {
-    ctx.Add("BFR {},{};", inst, value);
-}
-
-void EmitBitCount32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value) {
-    ctx.Add("BTC {},{};", inst, value);
-}
-
-void EmitBitwiseNot32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value) {
-    ctx.Add("NOT.S {},{};", inst, value);
-}
-
-void EmitFindSMsb32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value) {
-    ctx.Add("BTFM.S {},{};", inst, value);
-}
-
-void EmitFindUMsb32(EmitContext& ctx, IR::Inst& inst, ScalarU32 value) {
-    ctx.Add("BTFM.U {},{};", inst, value);
-}
-
-void EmitSMin32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
-    ctx.Add("MIN.S {},{},{};", inst, a, b);
-}
-
-void EmitUMin32(EmitContext& ctx, IR::Inst& inst, ScalarU32 a, ScalarU32 b) {
-    ctx.Add("MIN.U {},{},{};", inst, a, b);
-}
-
-void EmitSMax32(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
-    ctx.Add("MAX.S {},{},{};", inst, a, b);
-}
-
-void EmitUMax32(EmitContext& ctx, IR::Inst& inst, ScalarU32 a, ScalarU32 b) {
-    ctx.Add("MAX.U {},{},{};", inst, a, b);
-}
-
-void EmitSClamp32(EmitContext& ctx, IR::Inst& inst, ScalarS32 value, ScalarS32 min, ScalarS32 max) {
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    ctx.Add("MIN.S RC.x,{},{};"
-            "MAX.S {}.x,RC.x,{};",
-            max, value, ret, min);
-}
-
-void EmitUClamp32(EmitContext& ctx, IR::Inst& inst, ScalarU32 value, ScalarU32 min, ScalarU32 max) {
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    ctx.Add("MIN.U RC.x,{},{};"
-            "MAX.U {}.x,RC.x,{};",
-            max, value, ret, min);
-}
-
-void EmitSLessThan(EmitContext& ctx, IR::Inst& inst, ScalarS32 lhs, ScalarS32 rhs) {
-    ctx.Add("SLT.S {}.x,{},{};", inst, lhs, rhs);
-}
-
-void EmitULessThan(EmitContext& ctx, IR::Inst& inst, ScalarU32 lhs, ScalarU32 rhs) {
-    ctx.Add("SLT.U {}.x,{},{};", inst, lhs, rhs);
-}
-
-void EmitIEqual(EmitContext& ctx, IR::Inst& inst, ScalarS32 lhs, ScalarS32 rhs) {
-    ctx.Add("SEQ.S {}.x,{},{};", inst, lhs, rhs);
-}
-
-void EmitSLessThanEqual(EmitContext& ctx, IR::Inst& inst, ScalarS32 lhs, ScalarS32 rhs) {
-    ctx.Add("SLE.S {}.x,{},{};", inst, lhs, rhs);
-}
-
-void EmitULessThanEqual(EmitContext& ctx, IR::Inst& inst, ScalarU32 lhs, ScalarU32 rhs) {
-    ctx.Add("SLE.U {}.x,{},{};", inst, lhs, rhs);
-}
-
-void EmitSGreaterThan(EmitContext& ctx, IR::Inst& inst, ScalarS32 lhs, ScalarS32 rhs) {
-    ctx.Add("SGT.S {}.x,{},{};", inst, lhs, rhs);
-}
-
-void EmitUGreaterThan(EmitContext& ctx, IR::Inst& inst, ScalarU32 lhs, ScalarU32 rhs) {
-    ctx.Add("SGT.U {}.x,{},{};", inst, lhs, rhs);
-}
-
-void EmitINotEqual(EmitContext& ctx, IR::Inst& inst, ScalarS32 lhs, ScalarS32 rhs) {
-    ctx.Add("SNE.U {}.x,{},{};", inst, lhs, rhs);
-}
-
-void EmitSGreaterThanEqual(EmitContext& ctx, IR::Inst& inst, ScalarS32 lhs, ScalarS32 rhs) {
-    ctx.Add("SGE.S {}.x,{},{};", inst, lhs, rhs);
-}
-
-void EmitUGreaterThanEqual(EmitContext& ctx, IR::Inst& inst, ScalarU32 lhs, ScalarU32 rhs) {
-    ctx.Add("SGE.U {}.x,{},{};", inst, lhs, rhs);
-}
-
-} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_memory.cpp

@@ -1,568 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <string_view>
-
-#include "shader_recompiler/backend/glasm/emit_context.h"
-#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
-#include "shader_recompiler/frontend/ir/program.h"
-#include "shader_recompiler/frontend/ir/value.h"
-#include "shader_recompiler/runtime_info.h"
-
-namespace Shader::Backend::GLASM {
-namespace {
-void StorageOp(EmitContext& ctx, const IR::Value& binding, ScalarU32 offset,
-               std::string_view then_expr, std::string_view else_expr = {}) {
-    // Operate on bindless SSBO, call the expression with bounds checking
-    // address = c[binding].xy
-    // length  = c[binding].z
-    const u32 sb_binding{binding.U32()};
-    ctx.Add("PK64.U DC,c[{}];"           // pointer = address
-            "CVT.U64.U32 DC.z,{};"       // offset = uint64_t(offset)
-            "ADD.U64 DC.x,DC.x,DC.z;"    // pointer += offset
-            "SLT.U.CC RC.x,{},c[{}].z;", // cc = offset < length
-            sb_binding, offset, offset, sb_binding);
-    if (else_expr.empty()) {
-        ctx.Add("IF NE.x;{}ENDIF;", then_expr);
-    } else {
-        ctx.Add("IF NE.x;{}ELSE;{}ENDIF;", then_expr, else_expr);
-    }
-}
-
-void GlobalStorageOp(EmitContext& ctx, Register address, bool pointer_based, std::string_view expr,
-                     std::string_view else_expr = {}) {
-    const size_t num_buffers{ctx.info.storage_buffers_descriptors.size()};
-    for (size_t index = 0; index < num_buffers; ++index) {
-        if (!ctx.info.nvn_buffer_used[index]) {
-            continue;
-        }
-        const auto& ssbo{ctx.info.storage_buffers_descriptors[index]};
-        ctx.Add("LDC.U64 DC.x,c{}[{}];"    // ssbo_addr
-                "LDC.U32 RC.x,c{}[{}];"    // ssbo_size_u32
-                "CVT.U64.U32 DC.y,RC.x;"   // ssbo_size = ssbo_size_u32
-                "ADD.U64 DC.y,DC.y,DC.x;"  // ssbo_end = ssbo_addr + ssbo_size
-                "SGE.U64 RC.x,{}.x,DC.x;"  // a = input_addr >= ssbo_addr ? -1 : 0
-                "SLT.U64 RC.y,{}.x,DC.y;"  // b = input_addr < ssbo_end   ? -1 : 0
-                "AND.U.CC RC.x,RC.x,RC.y;" // cond = a && b
-                "IF NE.x;"                 // if cond
-                "SUB.U64 DC.x,{}.x,DC.x;", // offset = input_addr - ssbo_addr
-                ssbo.cbuf_index, ssbo.cbuf_offset, ssbo.cbuf_index, ssbo.cbuf_offset + 8, address,
-                address, address);
-        if (pointer_based) {
-            ctx.Add("PK64.U DC.y,c[{}];"      // host_ssbo = cbuf
-                    "ADD.U64 DC.x,DC.x,DC.y;" // host_addr = host_ssbo + offset
-                    "{}"
-                    "ELSE;",
-                    index, expr);
-        } else {
-            ctx.Add("CVT.U32.U64 RC.x,DC.x;"
-                    "{},ssbo{}[RC.x];"
-                    "ELSE;",
-                    expr, index);
-        }
-    }
-    if (!else_expr.empty()) {
-        ctx.Add("{}", else_expr);
-    }
-    const size_t num_used_buffers{ctx.info.nvn_buffer_used.count()};
-    for (size_t index = 0; index < num_used_buffers; ++index) {
-        ctx.Add("ENDIF;");
-    }
-}
-
-template <typename ValueType>
-void Write(EmitContext& ctx, const IR::Value& binding, ScalarU32 offset, ValueType value,
-           std::string_view size) {
-    if (ctx.runtime_info.glasm_use_storage_buffers) {
-        ctx.Add("STB.{} {},ssbo{}[{}];", size, value, binding.U32(), offset);
-    } else {
-        StorageOp(ctx, binding, offset, fmt::format("STORE.{} {},DC.x;", size, value));
-    }
-}
-
-void Load(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU32 offset,
-          std::string_view size) {
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    if (ctx.runtime_info.glasm_use_storage_buffers) {
-        ctx.Add("LDB.{} {},ssbo{}[{}];", size, ret, binding.U32(), offset);
-    } else {
-        StorageOp(ctx, binding, offset, fmt::format("LOAD.{} {},DC.x;", size, ret),
-                  fmt::format("MOV.U {},{{0,0,0,0}};", ret));
-    }
-}
-
-template <typename ValueType>
-void GlobalWrite(EmitContext& ctx, Register address, ValueType value, std::string_view size) {
-    if (ctx.runtime_info.glasm_use_storage_buffers) {
-        GlobalStorageOp(ctx, address, false, fmt::format("STB.{} {}", size, value));
-    } else {
-        GlobalStorageOp(ctx, address, true, fmt::format("STORE.{} {},DC.x;", size, value));
-    }
-}
-
-void GlobalLoad(EmitContext& ctx, IR::Inst& inst, Register address, std::string_view size) {
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    if (ctx.runtime_info.glasm_use_storage_buffers) {
-        GlobalStorageOp(ctx, address, false, fmt::format("LDB.{} {}", size, ret));
-    } else {
-        GlobalStorageOp(ctx, address, true, fmt::format("LOAD.{} {},DC.x;", size, ret),
-                        fmt::format("MOV.S {},0;", ret));
-    }
-}
-
-template <typename ValueType>
-void Atom(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding, ScalarU32 offset,
-          ValueType value, std::string_view operation, std::string_view size) {
-    const Register ret{ctx.reg_alloc.Define(inst)};
-    if (ctx.runtime_info.glasm_use_storage_buffers) {
-        ctx.Add("ATOMB.{}.{} {},{},ssbo{}[{}];", operation, size, ret, value, binding.U32(),
-                offset);
-    } else {
-        StorageOp(ctx, binding, offset,
-                  fmt::format("ATOM.{}.{} {},{},DC.x;", operation, size, ret, value));
-    }
-}
-} // Anonymous namespace
-
-void EmitLoadGlobalU8(EmitContext& ctx, IR::Inst& inst, Register address) {
-    GlobalLoad(ctx, inst, address, "U8");
-}
-
-void EmitLoadGlobalS8(EmitContext& ctx, IR::Inst& inst, Register address) {
-    GlobalLoad(ctx, inst, address, "S8");
-}
-
-void EmitLoadGlobalU16(EmitContext& ctx, IR::Inst& inst, Register address) {
-    GlobalLoad(ctx, inst, address, "U16");
-}
-
-void EmitLoadGlobalS16(EmitContext& ctx, IR::Inst& inst, Register address) {
-    GlobalLoad(ctx, inst, address, "S16");
-}
-
-void EmitLoadGlobal32(EmitContext& ctx, IR::Inst& inst, Register address) {
-    GlobalLoad(ctx, inst, address, "U32");
-}
-
-void EmitLoadGlobal64(EmitContext& ctx, IR::Inst& inst, Register address) {
-    GlobalLoad(ctx, inst, address, "U32X2");
-}
-
-void EmitLoadGlobal128(EmitContext& ctx, IR::Inst& inst, Register address) {
-    GlobalLoad(ctx, inst, address, "U32X4");
-}
-
-void EmitWriteGlobalU8(EmitContext& ctx, Register address, Register value) {
-    GlobalWrite(ctx, address, value, "U8");
-}
-
-void EmitWriteGlobalS8(EmitContext& ctx, Register address, Register value) {
-    GlobalWrite(ctx, address, value, "S8");
-}
-
-void EmitWriteGlobalU16(EmitContext& ctx, Register address, Register value) {
-    GlobalWrite(ctx, address, value, "U16");
-}
-
-void EmitWriteGlobalS16(EmitContext& ctx, Register address, Register value) {
-    GlobalWrite(ctx, address, value, "S16");
-}
-
-void EmitWriteGlobal32(EmitContext& ctx, Register address, ScalarU32 value) {
-    GlobalWrite(ctx, address, value, "U32");
-}
-
-void EmitWriteGlobal64(EmitContext& ctx, Register address, Register value) {
-    GlobalWrite(ctx, address, value, "U32X2");
-}
-
-void EmitWriteGlobal128(EmitContext& ctx, Register address, Register value) {
-    GlobalWrite(ctx, address, value, "U32X4");
-}
-
-void EmitLoadStorageU8(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                       ScalarU32 offset) {
-    Load(ctx, inst, binding, offset, "U8");
-}
-
-void EmitLoadStorageS8(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                       ScalarU32 offset) {
-    Load(ctx, inst, binding, offset, "S8");
-}
-
-void EmitLoadStorageU16(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                        ScalarU32 offset) {
-    Load(ctx, inst, binding, offset, "U16");
-}
-
-void EmitLoadStorageS16(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                        ScalarU32 offset) {
-    Load(ctx, inst, binding, offset, "S16");
-}
-
-void EmitLoadStorage32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                       ScalarU32 offset) {
-    Load(ctx, inst, binding, offset, "U32");
-}
-
-void EmitLoadStorage64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                       ScalarU32 offset) {
-    Load(ctx, inst, binding, offset, "U32X2");
-}
-
-void EmitLoadStorage128(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                        ScalarU32 offset) {
-    Load(ctx, inst, binding, offset, "U32X4");
-}
-
-void EmitWriteStorageU8(EmitContext& ctx, const IR::Value& binding, ScalarU32 offset,
-                        ScalarU32 value) {
-    Write(ctx, binding, offset, value, "U8");
-}
-
-void EmitWriteStorageS8(EmitContext& ctx, const IR::Value& binding, ScalarU32 offset,
-                        ScalarS32 value) {
-    Write(ctx, binding, offset, value, "S8");
-}
-
-void EmitWriteStorageU16(EmitContext& ctx, const IR::Value& binding, ScalarU32 offset,
-                         ScalarU32 value) {
-    Write(ctx, binding, offset, value, "U16");
-}
-
-void EmitWriteStorageS16(EmitContext& ctx, const IR::Value& binding, ScalarU32 offset,
-                         ScalarS32 value) {
-    Write(ctx, binding, offset, value, "S16");
-}
-
-void EmitWriteStorage32(EmitContext& ctx, const IR::Value& binding, ScalarU32 offset,
-                        ScalarU32 value) {
-    Write(ctx, binding, offset, value, "U32");
-}
-
-void EmitWriteStorage64(EmitContext& ctx, const IR::Value& binding, ScalarU32 offset,
-                        Register value) {
-    Write(ctx, binding, offset, value, "U32X2");
-}
-
-void EmitWriteStorage128(EmitContext& ctx, const IR::Value& binding, ScalarU32 offset,
-                         Register value) {
-    Write(ctx, binding, offset, value, "U32X4");
-}
-
-void EmitSharedAtomicIAdd32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                            ScalarU32 value) {
-    ctx.Add("ATOMS.ADD.U32 {},{},shared_mem[{}];", inst, value, pointer_offset);
-}
-
-void EmitSharedAtomicSMin32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                            ScalarS32 value) {
-    ctx.Add("ATOMS.MIN.S32 {},{},shared_mem[{}];", inst, value, pointer_offset);
-}
-
-void EmitSharedAtomicUMin32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                            ScalarU32 value) {
-    ctx.Add("ATOMS.MIN.U32 {},{},shared_mem[{}];", inst, value, pointer_offset);
-}
-
-void EmitSharedAtomicSMax32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                            ScalarS32 value) {
-    ctx.Add("ATOMS.MAX.S32 {},{},shared_mem[{}];", inst, value, pointer_offset);
-}
-
-void EmitSharedAtomicUMax32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                            ScalarU32 value) {
-    ctx.Add("ATOMS.MAX.U32 {},{},shared_mem[{}];", inst, value, pointer_offset);
-}
-
-void EmitSharedAtomicInc32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                           ScalarU32 value) {
-    ctx.Add("ATOMS.IWRAP.U32 {},{},shared_mem[{}];", inst, value, pointer_offset);
-}
-
-void EmitSharedAtomicDec32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                           ScalarU32 value) {
-    ctx.Add("ATOMS.DWRAP.U32 {},{},shared_mem[{}];", inst, value, pointer_offset);
-}
-
-void EmitSharedAtomicAnd32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                           ScalarU32 value) {
-    ctx.Add("ATOMS.AND.U32 {},{},shared_mem[{}];", inst, value, pointer_offset);
-}
-
-void EmitSharedAtomicOr32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                          ScalarU32 value) {
-    ctx.Add("ATOMS.OR.U32 {},{},shared_mem[{}];", inst, value, pointer_offset);
-}
-
-void EmitSharedAtomicXor32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                           ScalarU32 value) {
-    ctx.Add("ATOMS.XOR.U32 {},{},shared_mem[{}];", inst, value, pointer_offset);
-}
-
-void EmitSharedAtomicExchange32(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                                ScalarU32 value) {
-    ctx.Add("ATOMS.EXCH.U32 {},{},shared_mem[{}];", inst, value, pointer_offset);
-}
-
-void EmitSharedAtomicExchange64(EmitContext& ctx, IR::Inst& inst, ScalarU32 pointer_offset,
-                                Register value) {
-    ctx.LongAdd("ATOMS.EXCH.U64 {}.x,{},shared_mem[{}];", inst, value, pointer_offset);
-}
-
-void EmitStorageAtomicIAdd32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, ScalarU32 value) {
-    Atom(ctx, inst, binding, offset, value, "ADD", "U32");
-}
-
-void EmitStorageAtomicSMin32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, ScalarS32 value) {
-    Atom(ctx, inst, binding, offset, value, "MIN", "S32");
-}
-
-void EmitStorageAtomicUMin32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, ScalarU32 value) {
-    Atom(ctx, inst, binding, offset, value, "MIN", "U32");
-}
-
-void EmitStorageAtomicSMax32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, ScalarS32 value) {
-    Atom(ctx, inst, binding, offset, value, "MAX", "S32");
-}
-
-void EmitStorageAtomicUMax32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, ScalarU32 value) {
-    Atom(ctx, inst, binding, offset, value, "MAX", "U32");
-}
-
-void EmitStorageAtomicInc32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                            ScalarU32 offset, ScalarU32 value) {
-    Atom(ctx, inst, binding, offset, value, "IWRAP", "U32");
-}
-
-void EmitStorageAtomicDec32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                            ScalarU32 offset, ScalarU32 value) {
-    Atom(ctx, inst, binding, offset, value, "DWRAP", "U32");
-}
-
-void EmitStorageAtomicAnd32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                            ScalarU32 offset, ScalarU32 value) {
-    Atom(ctx, inst, binding, offset, value, "AND", "U32");
-}
-
-void EmitStorageAtomicOr32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                           ScalarU32 offset, ScalarU32 value) {
-    Atom(ctx, inst, binding, offset, value, "OR", "U32");
-}
-
-void EmitStorageAtomicXor32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                            ScalarU32 offset, ScalarU32 value) {
-    Atom(ctx, inst, binding, offset, value, "XOR", "U32");
-}
-
-void EmitStorageAtomicExchange32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                                 ScalarU32 offset, ScalarU32 value) {
-    Atom(ctx, inst, binding, offset, value, "EXCH", "U32");
-}
-
-void EmitStorageAtomicIAdd64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, Register value) {
-    Atom(ctx, inst, binding, offset, value, "ADD", "U64");
-}
-
-void EmitStorageAtomicSMin64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, Register value) {
-    Atom(ctx, inst, binding, offset, value, "MIN", "S64");
-}
-
-void EmitStorageAtomicUMin64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, Register value) {
-    Atom(ctx, inst, binding, offset, value, "MIN", "U64");
-}
-
-void EmitStorageAtomicSMax64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, Register value) {
-    Atom(ctx, inst, binding, offset, value, "MAX", "S64");
-}
-
-void EmitStorageAtomicUMax64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, Register value) {
-    Atom(ctx, inst, binding, offset, value, "MAX", "U64");
-}
-
-void EmitStorageAtomicAnd64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                            ScalarU32 offset, Register value) {
-    Atom(ctx, inst, binding, offset, value, "AND", "U64");
-}
-
-void EmitStorageAtomicOr64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                           ScalarU32 offset, Register value) {
-    Atom(ctx, inst, binding, offset, value, "OR", "U64");
-}
-
-void EmitStorageAtomicXor64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                            ScalarU32 offset, Register value) {
-    Atom(ctx, inst, binding, offset, value, "XOR", "U64");
-}
-
-void EmitStorageAtomicExchange64(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                                 ScalarU32 offset, Register value) {
-    Atom(ctx, inst, binding, offset, value, "EXCH", "U64");
-}
-
-void EmitStorageAtomicAddF32(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                             ScalarU32 offset, ScalarF32 value) {
-    Atom(ctx, inst, binding, offset, value, "ADD", "F32");
-}
-
-void EmitStorageAtomicAddF16x2(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                               ScalarU32 offset, Register value) {
-    Atom(ctx, inst, binding, offset, value, "ADD", "F16x2");
-}
-
-void EmitStorageAtomicAddF32x2([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                               [[maybe_unused]] const IR::Value& binding,
-                               [[maybe_unused]] ScalarU32 offset, [[maybe_unused]] Register value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitStorageAtomicMinF16x2(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                               ScalarU32 offset, Register value) {
-    Atom(ctx, inst, binding, offset, value, "MIN", "F16x2");
-}
-
-void EmitStorageAtomicMinF32x2([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                               [[maybe_unused]] const IR::Value& binding,
-                               [[maybe_unused]] ScalarU32 offset, [[maybe_unused]] Register value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitStorageAtomicMaxF16x2(EmitContext& ctx, IR::Inst& inst, const IR::Value& binding,
-                               ScalarU32 offset, Register value) {
-    Atom(ctx, inst, binding, offset, value, "MAX", "F16x2");
-}
-
-void EmitStorageAtomicMaxF32x2([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] IR::Inst& inst,
-                               [[maybe_unused]] const IR::Value& binding,
-                               [[maybe_unused]] ScalarU32 offset, [[maybe_unused]] Register value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicIAdd32(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicSMin32(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicUMin32(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicSMax32(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicUMax32(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicInc32(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicDec32(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicAnd32(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicOr32(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicXor32(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicExchange32(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicIAdd64(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicSMin64(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicUMin64(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicSMax64(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicUMax64(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicInc64(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicDec64(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicAnd64(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicOr64(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicXor64(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicExchange64(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicAddF32(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicAddF16x2(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicAddF32x2(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicMinF16x2(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicMinF32x2(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicMaxF16x2(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitGlobalAtomicMaxF32x2(EmitContext&) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_not_implemented.cpp

@@ -1,273 +0,0 @@
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include <string_view>
-
-#include "shader_recompiler/backend/glasm/emit_context.h"
-#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
-#include "shader_recompiler/frontend/ir/program.h"
-#include "shader_recompiler/frontend/ir/value.h"
-
-#ifdef _MSC_VER
-#pragma warning(disable : 4100)
-#endif
-
-namespace Shader::Backend::GLASM {
-
-#define NotImplemented() throw NotImplementedException("GLASM instruction {}", __LINE__)
-
-static void DefinePhi(EmitContext& ctx, IR::Inst& phi) {
-    switch (phi.Arg(0).Type()) {
-    case IR::Type::U1:
-    case IR::Type::U32:
-    case IR::Type::F32:
-        ctx.reg_alloc.Define(phi);
-        break;
-    case IR::Type::U64:
-    case IR::Type::F64:
-        ctx.reg_alloc.LongDefine(phi);
-        break;
-    default:
-        throw NotImplementedException("Phi node type {}", phi.Type());
-    }
-}
-
-void EmitPhi(EmitContext& ctx, IR::Inst& phi) {
-    const size_t num_args{phi.NumArgs()};
-    for (size_t i = 0; i < num_args; ++i) {
-        ctx.reg_alloc.Consume(phi.Arg(i));
-    }
-    if (!phi.Definition<Id>().is_valid) {
-        // The phi node wasn't forward defined
-        DefinePhi(ctx, phi);
-    }
-}
-
-void EmitVoid(EmitContext&) {}
-
-void EmitReference(EmitContext& ctx, const IR::Value& value) {
-    ctx.reg_alloc.Consume(value);
-}
-
-void EmitPhiMove(EmitContext& ctx, const IR::Value& phi_value, const IR::Value& value) {
-    IR::Inst& phi{RegAlloc::AliasInst(*phi_value.Inst())};
-    if (!phi.Definition<Id>().is_valid) {
-        // The phi node wasn't forward defined
-        DefinePhi(ctx, phi);
-    }
-    const Register phi_reg{ctx.reg_alloc.Consume(IR::Value{&phi})};
-    const Value eval_value{ctx.reg_alloc.Consume(value)};
-
-    if (phi_reg == eval_value) {
-        return;
-    }
-    switch (phi.Flags<IR::Type>()) {
-    case IR::Type::U1:
-    case IR::Type::U32:
-    case IR::Type::F32:
-        ctx.Add("MOV.S {}.x,{};", phi_reg, ScalarS32{eval_value});
-        break;
-    case IR::Type::U64:
-    case IR::Type::F64:
-        ctx.Add("MOV.U64 {}.x,{};", phi_reg, ScalarRegister{eval_value});
-        break;
-    default:
-        throw NotImplementedException("Phi node type {}", phi.Type());
-    }
-}
-
-void EmitJoin(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitDemoteToHelperInvocation(EmitContext& ctx) {
-    ctx.Add("KIL TR.x;");
-}
-
-void EmitBarrier(EmitContext& ctx) {
-    ctx.Add("BAR;");
-}
-
-void EmitWorkgroupMemoryBarrier(EmitContext& ctx) {
-    ctx.Add("MEMBAR.CTA;");
-}
-
-void EmitDeviceMemoryBarrier(EmitContext& ctx) {
-    ctx.Add("MEMBAR;");
-}
-
-void EmitPrologue(EmitContext& ctx) {
-    // TODO
-}
-
-void EmitEpilogue(EmitContext& ctx) {
-    // TODO
-}
-
-void EmitEmitVertex(EmitContext& ctx, ScalarS32 stream) {
-    if (stream.type == Type::U32 && stream.imm_u32 == 0) {
-        ctx.Add("EMIT;");
-    } else {
-        ctx.Add("EMITS {};", stream);
-    }
-}
-
-void EmitEndPrimitive(EmitContext& ctx, const IR::Value& stream) {
-    if (!stream.IsImmediate()) {
-        LOG_WARNING(Shader_GLASM, "Stream is not immediate");
-    }
-    ctx.reg_alloc.Consume(stream);
-    ctx.Add("ENDPRIM;");
-}
-
-void EmitGetRegister(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitSetRegister(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitGetPred(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitSetPred(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitSetGotoVariable(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitGetGotoVariable(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitSetIndirectBranchVariable(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitGetIndirectBranchVariable(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitGetZFlag(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitGetSFlag(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitGetCFlag(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitGetOFlag(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitSetZFlag(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitSetSFlag(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitSetCFlag(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitSetOFlag(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitWorkgroupId(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {},invocation.groupid;", inst);
-}
-
-void EmitLocalInvocationId(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {},invocation.localid;", inst);
-}
-
-void EmitInvocationId(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {}.x,primitive_invocation.x;", inst);
-}
-
-void EmitSampleId(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {}.x,fragment.sampleid.x;", inst);
-}
-
-void EmitIsHelperInvocation(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {}.x,fragment.helperthread.x;", inst);
-}
-
-void EmitYDirection(EmitContext& ctx, IR::Inst& inst) {
-    ctx.uses_y_direction = true;
-    ctx.Add("MOV.F {}.x,y_direction[0].w;", inst);
-}
-
-void EmitUndefU1(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {}.x,0;", inst);
-}
-
-void EmitUndefU8(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {}.x,0;", inst);
-}
-
-void EmitUndefU16(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {}.x,0;", inst);
-}
-
-void EmitUndefU32(EmitContext& ctx, IR::Inst& inst) {
-    ctx.Add("MOV.S {}.x,0;", inst);
-}
-
-void EmitUndefU64(EmitContext& ctx, IR::Inst& inst) {
-    ctx.LongAdd("MOV.S64 {}.x,0;", inst);
-}
-
-void EmitGetZeroFromOp(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitGetSignFromOp(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitGetCarryFromOp(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitGetOverflowFromOp(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitGetSparseFromOp(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitGetInBoundsFromOp(EmitContext& ctx) {
-    NotImplemented();
-}
-
-void EmitLogicalOr(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
-    ctx.Add("OR.S {},{},{};", inst, a, b);
-}
-
-void EmitLogicalAnd(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
-    ctx.Add("AND.S {},{},{};", inst, a, b);
-}
-
-void EmitLogicalXor(EmitContext& ctx, IR::Inst& inst, ScalarS32 a, ScalarS32 b) {
-    ctx.Add("XOR.S {},{},{};", inst, a, b);
-}
-
-void EmitLogicalNot(EmitContext& ctx, IR::Inst& inst, ScalarS32 value) {
-    ctx.Add("SEQ.S {},{},0;", inst, value);
-}
-
-} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_select.cpp

@@ -1,67 +0,0 @@
-
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "shader_recompiler/backend/glasm/emit_context.h"
-#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
-#include "shader_recompiler/frontend/ir/value.h"
-
-namespace Shader::Backend::GLASM {
-
-void EmitSelectU1(EmitContext& ctx, IR::Inst& inst, ScalarS32 cond, ScalarS32 true_value,
-                  ScalarS32 false_value) {
-    ctx.Add("CMP.S {},{},{},{};", inst, cond, true_value, false_value);
-}
-
-void EmitSelectU8([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 cond,
-                  [[maybe_unused]] ScalarS32 true_value, [[maybe_unused]] ScalarS32 false_value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitSelectU16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 cond,
-                   [[maybe_unused]] ScalarS32 true_value, [[maybe_unused]] ScalarS32 false_value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitSelectU32(EmitContext& ctx, IR::Inst& inst, ScalarS32 cond, ScalarS32 true_value,
-                   ScalarS32 false_value) {
-    ctx.Add("CMP.S {},{},{},{};", inst, cond, true_value, false_value);
-}
-
-void EmitSelectU64(EmitContext& ctx, IR::Inst& inst, ScalarS32 cond, Register true_value,
-                   Register false_value) {
-    ctx.reg_alloc.InvalidateConditionCodes();
-    const Register ret{ctx.reg_alloc.LongDefine(inst)};
-    if (ret == true_value) {
-        ctx.Add("MOV.S.CC RC.x,{};"
-                "MOV.U64 {}.x(EQ.x),{};",
-                cond, ret, false_value);
-    } else if (ret == false_value) {
-        ctx.Add("MOV.S.CC RC.x,{};"
-                "MOV.U64 {}.x(NE.x),{};",
-                cond, ret, true_value);
-    } else {
-        ctx.Add("MOV.S.CC RC.x,{};"
-                "MOV.U64 {}.x,{};"
-                "MOV.U64 {}.x(NE.x),{};",
-                cond, ret, false_value, ret, true_value);
-    }
-}
-
-void EmitSelectF16([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 cond,
-                   [[maybe_unused]] Register true_value, [[maybe_unused]] Register false_value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-void EmitSelectF32(EmitContext& ctx, IR::Inst& inst, ScalarS32 cond, ScalarS32 true_value,
-                   ScalarS32 false_value) {
-    ctx.Add("CMP.S {},{},{},{};", inst, cond, true_value, false_value);
-}
-
-void EmitSelectF64([[maybe_unused]] EmitContext& ctx, [[maybe_unused]] ScalarS32 cond,
-                   [[maybe_unused]] Register true_value, [[maybe_unused]] Register false_value) {
-    throw NotImplementedException("GLASM instruction");
-}
-
-} // namespace Shader::Backend::GLASM

src/shader_recompiler/backend/glasm/emit_glasm_shared_memory.cpp

@@ -1,58 +0,0 @@
-
-// Copyright 2021 yuzu Emulator Project
-// Licensed under GPLv2 or any later version
-// Refer to the license.txt file included.
-
-#include "shader_recompiler/backend/glasm/emit_context.h"
-#include "shader_recompiler/backend/glasm/emit_glasm_instructions.h"
-#include "shader_recompiler/frontend/ir/value.h"
-
-namespace Shader::Backend::GLASM {
-void EmitLoadSharedU8(EmitContext& ctx, IR::Inst& inst, ScalarU32 offset) {
-    ctx.Add("LDS.U8 {},shared_mem[{}];", inst, offset);
-}
-
-void EmitLoadSharedS8(EmitContext& ctx, IR::Inst& inst, ScalarU32 offset) {
-    ctx.Add("LDS.S8 {},shared_mem[{}];", inst, offset);
-}
-
-void EmitLoadSharedU16(EmitContext& ctx, IR::Inst& inst, ScalarU32 offset) {
-    ctx.Add("LDS.U16 {},shared_mem[{}];", inst, offset);
-}
-
-void EmitLoadSharedS16(EmitContext& ctx, IR::Inst& inst, ScalarU32 offset) {
-    ctx.Add("LDS.S16 {},shared_mem[{}];", inst, offset);
-}
-
-void EmitLoadSharedU32(EmitContext& ctx, IR::Inst& inst, ScalarU32 offset) {
-    ctx.Add("LDS.U32 {},shared_mem[{}];", inst, offset);
-}
-
-void EmitLoadSharedU64(EmitContext& ctx, IR::Inst& inst, ScalarU32 offset) {
-    ctx.Add("LDS.U32X2 {},shared_mem[{}];", inst, offset);
-}
-
-void EmitLoadSharedU128(EmitContext& ctx, IR::Inst& inst, ScalarU32 offset) {
-    ctx.Add("LDS.U32X4 {},shared_mem[{}];", inst, offset);
-}
-
-void EmitWriteSharedU8(EmitContext& ctx, ScalarU32 offset, ScalarU32 value) {
-    ctx.Add("STS.U8 {},shared_mem[{}];", value, offset);
-}
-
-void EmitWriteSharedU16(EmitContext& ctx, ScalarU32 offset, ScalarU32 value) {
-    ctx.Add("STS.U16 {},shared_mem[{}];", value, offset);
-}
-
-void EmitWriteSharedU32(EmitContext& ctx, ScalarU32 offset, ScalarU32 value) {
-    ctx.Add("STS.U32 {},shared_mem[{}];", value, offset);
-}
-
-void EmitWriteSharedU64(EmitContext& ctx, ScalarU32 offset, Register value) {
-    ctx.Add("STS.U32X2 {},shared_mem[{}];", value, offset);
-}
-
-void EmitWriteSharedU128(EmitContext& ctx, ScalarU32 offset, Register value) {
-    ctx.Add("STS.U32X4 {},shared_mem[{}];", value, offset);
-}
-} // namespace Shader::Backend::GLASM