Implement IME dialog overlay

Co-authored-by: Stefanos Costa <stefanos.costa1999@gmail.com>

.github/workflows/build.yml

@@ -6,9 +6,27 @@ on:
     branches: [ main, master ]
   pull_request:
 
+env:
+  KYTY_BUILD_ORIGIN: ${{ github.repository != 'KytyPS5/KytyPS5' && 'Fork' || github.event_name == 'push' && 'Official' || 'Source' }}
+  KYTY_BUILD_REPOSITORY: ${{ github.repository }}
+
 jobs:
+  metadata:
+    name: Prepare build metadata
+    runs-on: ubuntu-latest
+    outputs:
+      release_tag: ${{ steps.release_tag.outputs.value }}
+
+    steps:
+      - name: Generate release tag
+        id: release_tag
+        shell: bash
+        run: |
+          echo "value=KytyPS5-$(date -u +'%Y-%m-%d')-${GITHUB_SHA::7}" >> "$GITHUB_OUTPUT"
+
   windows:
     name: Build KytyPS5 (Windows)
+    needs: metadata
     runs-on: windows-2022
 
     steps:
@@ -76,6 +94,10 @@ jobs:
           cmake -S . -B _Build/windows ^
             -G Ninja ^
             -DCMAKE_BUILD_TYPE=Release ^
+            -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON ^
+            -DKYTY_BUILD_ORIGIN=%KYTY_BUILD_ORIGIN% ^
+            -DKYTY_BUILD_REPOSITORY=%KYTY_BUILD_REPOSITORY% ^
+            -DKYTY_RELEASE_TAG=${{ needs.metadata.outputs.release_tag }} ^
             -DCMAKE_C_COMPILER=clang-cl ^
             -DCMAKE_CXX_COMPILER=clang-cl ^
             -DCMAKE_PREFIX_PATH="%Qt6_DIR%"
@@ -83,12 +105,12 @@ jobs:
       - name: Build
         shell: cmd
         run: |
-          cmake --build _Build/windows --target launcher audio_out2_port_tests virtual_memory_allocation_tests --parallel
+          cmake --build _Build/windows --target launcher audio_out2_port_tests ime_dialog_tests virtual_memory_allocation_tests --parallel
 
       - name: Test
         shell: cmd
         run: |
-          ctest --test-dir _Build/windows --output-on-failure -R "^(audio_out2_port|virtual_memory_allocation)$"
+          ctest --test-dir _Build/windows --output-on-failure -R "^(audio_out2_port|ime_dialog|virtual_memory_allocation)$"
 
       - name: Install
         shell: cmd
@@ -104,6 +126,7 @@ jobs:
 
   macos:
     name: Build KytyPS5 (macOS)
+    needs: metadata
     runs-on: macos-15
 
     steps:
@@ -150,6 +173,10 @@ jobs:
           cmake -S . -B _Build/macos \
             -G Ninja \
             -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON \
+            -DKYTY_BUILD_ORIGIN="$KYTY_BUILD_ORIGIN" \
+            -DKYTY_BUILD_REPOSITORY="$KYTY_BUILD_REPOSITORY" \
+            -DKYTY_RELEASE_TAG="${{ needs.metadata.outputs.release_tag }}" \
             -DCMAKE_OSX_ARCHITECTURES=x86_64 \
             -DCMAKE_C_COMPILER=clang \
             -DCMAKE_CXX_COMPILER=clang++ \
@@ -159,14 +186,14 @@ jobs:
         shell: bash
         run: |
           cmake --build _Build/macos \
-            --target launcher audio_out2_port_tests virtual_memory_allocation_tests \
+            --target launcher audio_out2_port_tests ime_dialog_tests virtual_memory_allocation_tests \
             --parallel
 
       - name: Test
         shell: bash
         run: |
           ctest --test-dir _Build/macos --output-on-failure \
-            -R '^(audio_out2_port|virtual_memory_allocation)$'
+            -R '^(audio_out2_port|ime_dialog|virtual_memory_allocation)$'
 
       - name: Install
         shell: bash
@@ -213,6 +240,7 @@ jobs:
 
   linux:
     name: Build KytyPS5 (Linux)
+    needs: metadata
     runs-on: ubuntu-24.04
 
     steps:
@@ -273,6 +301,10 @@ jobs:
           cmake -S . -B _Build/linux \
             -G Ninja \
             -DCMAKE_BUILD_TYPE=Release \
+            -DCMAKE_INTERPROCEDURAL_OPTIMIZATION=ON \
+            -DKYTY_BUILD_ORIGIN="$KYTY_BUILD_ORIGIN" \
+            -DKYTY_BUILD_REPOSITORY="$KYTY_BUILD_REPOSITORY" \
+            -DKYTY_RELEASE_TAG="${{ needs.metadata.outputs.release_tag }}" \
             -DCMAKE_C_COMPILER=clang \
             -DCMAKE_CXX_COMPILER=clang++ \
             -DCMAKE_PREFIX_PATH="$Qt6_DIR" 2>&1 | tee _Build/configure.log
@@ -297,14 +329,14 @@ jobs:
         run: |
           cmake --build _Build/linux \
             --target launcher page_manager_tests memory_tracker_tests \
-              audio_out2_port_tests virtual_memory_allocation_tests \
+              audio_out2_port_tests ime_dialog_tests virtual_memory_allocation_tests \
             --parallel
 
       - name: Test
         shell: bash
         run: |
           ctest --test-dir _Build/linux --output-on-failure \
-            -R '^(audio_out2_port|page_manager|memory_tracker|virtual_memory_allocation)$'
+            -R '^(audio_out2_port|ime_dialog|page_manager|memory_tracker|virtual_memory_allocation)$'
 
       - name: Install
         shell: bash
@@ -342,10 +374,12 @@ jobs:
   release:
     name: Release KytyPS5
     if: github.event_name == 'push' && github.repository == 'KytyPS5/KytyPS5'
-    needs: [windows, macos, linux]
+    needs: [metadata, windows, macos, linux]
     runs-on: ubuntu-latest
     permissions:
       contents: write
+    env:
+      RELEASE_NAME: ${{ needs.metadata.outputs.release_tag }}
 
     steps:
       - name: Download builds
@@ -353,11 +387,6 @@ jobs:
         with:
           path: artifacts
 
-      - name: Set release name
-        shell: bash
-        run: |
-          echo "RELEASE_NAME=KytyPS5-$(date -u +'%Y-%m-%d')-${GITHUB_SHA::7}" >> "$GITHUB_ENV"
-
       - name: Package builds
         shell: bash
         run: |

.gitmodules

@@ -39,3 +39,6 @@
 [submodule "3rdparty/nlohmann_json"]
 	path = 3rdparty/nlohmann_json
 	url = https://github.com/nlohmann/json.git
+[submodule "3rdparty/imgui"]
+	path = 3rdparty/imgui
+	url = https://github.com/ocornut/imgui.git

3rdparty/CMakeLists.txt

@@ -11,6 +11,25 @@ target_include_directories(Vulkan-Headers INTERFACE
 	"${CMAKE_CURRENT_SOURCE_DIR}/Vulkan-Headers/include"
 )
 
+add_library(imgui STATIC
+	imgui/imgui.cpp
+	imgui/imgui_draw.cpp
+	imgui/imgui_tables.cpp
+	imgui/imgui_widgets.cpp
+	imgui/backends/imgui_impl_vulkan.cpp
+)
+target_include_directories(imgui PUBLIC
+	"${CMAKE_CURRENT_SOURCE_DIR}/imgui"
+	"${CMAKE_CURRENT_SOURCE_DIR}/imgui/backends"
+)
+target_compile_definitions(imgui PRIVATE IMGUI_IMPL_VULKAN_NO_PROTOTYPES)
+target_link_libraries(imgui PUBLIC Vulkan::Headers)
+if(MSVC)
+	target_compile_options(imgui PRIVATE /W0)
+else()
+	target_compile_options(imgui PRIVATE -w)
+endif()
+
 set(SPIRV_SKIP_TESTS ON CACHE BOOL "" FORCE)
 set(SPIRV_SKIP_EXECUTABLES ON CACHE BOOL "" FORCE)
 set(SKIP_SPIRV_TOOLS_INSTALL ON CACHE BOOL "" FORCE)

CMakeLists.txt

@@ -4,6 +4,12 @@ if(CMAKE_VERSION VERSION_GREATER_EQUAL 4.0)
 	set(CMAKE_POLICY_VERSION_MINIMUM 3.5 CACHE STRING "Minimum policy version for bundled dependencies")
 endif()
 
+get_property(KYTY_GENERATOR_IS_MULTI_CONFIG GLOBAL PROPERTY GENERATOR_IS_MULTI_CONFIG)
+if(NOT KYTY_GENERATOR_IS_MULTI_CONFIG AND NOT CMAKE_BUILD_TYPE)
+	set(CMAKE_BUILD_TYPE Release CACHE STRING "Choose the type of build" FORCE)
+	set_property(CACHE CMAKE_BUILD_TYPE PROPERTY STRINGS Debug Release RelWithDebInfo MinSizeRel)
+endif()
+
 project(Kyty)
 
 set(KYTY_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/src")
@@ -28,6 +34,29 @@ include(CTest)
 
 option(KYTY_ENABLE_CLANG_TIDY "Run clang-tidy checks during builds" OFF)
 
+set(KYTY_BUILD_ORIGIN "Source" CACHE STRING "Build provenance shown in diagnostics")
+set_property(CACHE KYTY_BUILD_ORIGIN PROPERTY STRINGS Source Official Fork)
+if(NOT KYTY_BUILD_ORIGIN STREQUAL "Source" AND NOT KYTY_BUILD_ORIGIN STREQUAL "Official" AND
+   NOT KYTY_BUILD_ORIGIN STREQUAL "Fork")
+	message(FATAL_ERROR "KYTY_BUILD_ORIGIN must be Source, Official, or Fork")
+endif()
+
+set(KYTY_RELEASE_TAG "" CACHE STRING "Release tag embedded in official builds")
+set(KYTY_BUILD_REPOSITORY "" CACHE STRING "GitHub repository embedded in fork builds")
+set(KYTY_OFFICIAL_BUILD OFF)
+set(KYTY_FORK_BUILD OFF)
+if(KYTY_BUILD_ORIGIN STREQUAL "Official")
+	if(KYTY_RELEASE_TAG STREQUAL "")
+		message(FATAL_ERROR "Official builds require KYTY_RELEASE_TAG")
+	endif()
+	set(KYTY_OFFICIAL_BUILD ON)
+elseif(KYTY_BUILD_ORIGIN STREQUAL "Fork")
+	if(KYTY_BUILD_REPOSITORY STREQUAL "")
+		message(FATAL_ERROR "Fork builds require KYTY_BUILD_REPOSITORY")
+	endif()
+	set(KYTY_FORK_BUILD ON)
+endif()
+
 set(CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS ON)
 
 include(TestBigEndian)
@@ -117,16 +146,20 @@ configure_file(
 
 find_package(Git)
 
-add_custom_target( KytyGitVersion
-    COMMAND ${CMAKE_COMMAND}
-	-D INPUT_FILE=${KYTY_SOURCE_DIR}/kytyGitVersion.h.in
-	-D OUTPUT_FILE=${PROJECT_BINARY_DIR}/kytyGitVersion.h
-	-D GIT_EXECUTABLE=${GIT_EXECUTABLE}
-	-D GIT_WORKING_DIRECTORY=${CMAKE_CURRENT_SOURCE_DIR}
-	-P ${KYTY_SOURCE_DIR}/generate_version.cmake
+add_custom_target(KytyGitVersion
+	COMMAND ${CMAKE_COMMAND}
+		-D INPUT_FILE=${KYTY_SOURCE_DIR}/kytyGitVersion.h.in
+		-D OUTPUT_FILE=${PROJECT_BINARY_DIR}/kytyGitVersion.h
+		-D GIT_EXECUTABLE=${GIT_EXECUTABLE}
+		-D GIT_WORKING_DIRECTORY=${CMAKE_CURRENT_SOURCE_DIR}
+		-P ${KYTY_SOURCE_DIR}/generate_version.cmake
+	BYPRODUCTS ${PROJECT_BINARY_DIR}/kytyGitVersion.h
 	COMMENT "Generate kytyGitVersion.h"
 )
 
+add_library(kyty_git_version INTERFACE)
+add_dependencies(kyty_git_version KytyGitVersion)
+
 if (CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 12.0.0)
 	list(APPEND KYTY_IWYU
 		kyty_emulator
@@ -259,7 +292,7 @@ if (KYTY_CLANG_CL)
 	set_source_files_properties(${kyty_emulator_src} PROPERTIES COMPILE_FLAGS "-Wno-pragma-pack -Wno-deprecated-declarations -D_TIMESPEC_DEFINED")
 endif()
 
-set(kyty_emulator_link_libraries common Vulkan::Headers spirv-tools-opt spirv-tools SDL2-static xxhash FFmpeg::ffmpeg fmt::fmt nlohmann_json::nlohmann_json LibAtrac9)
+set(kyty_emulator_link_libraries common Vulkan::Headers spirv-tools-opt spirv-tools SDL2-static imgui xxhash FFmpeg::ffmpeg fmt::fmt nlohmann_json::nlohmann_json LibAtrac9 kyty_git_version)
 
 # Linux system libraries required by the static FFmpeg archive.
 if(LINUX)
@@ -352,6 +385,12 @@ add_executable(bit_array_tests EXCLUDE_FROM_ALL
 )
 target_include_directories(bit_array_tests PRIVATE ${inc_headers})
 
+add_executable(ime_dialog_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/ImeDialogTests.cpp"
+	"${KYTY_SOURCE_DIR}/libs/imeDialog.cpp"
+)
+target_include_directories(ime_dialog_tests PRIVATE ${inc_headers})
+
 add_executable(memory_tracker_tests EXCLUDE_FROM_ALL
 	"${KYTY_TESTS_DIR}/MemoryTrackerTests.cpp"
 	"${KYTY_SOURCE_DIR}/graphics/host_gpu/pageManager.cpp"
@@ -417,6 +456,13 @@ add_executable(event_queue_lifetime_tests EXCLUDE_FROM_ALL
 target_link_libraries(event_queue_lifetime_tests common fmt::fmt)
 target_include_directories(event_queue_lifetime_tests PRIVATE ${inc_headers})
 
+add_executable(sync_on_address_tests EXCLUDE_FROM_ALL
+	"${KYTY_TESTS_DIR}/SyncOnAddressTests.cpp"
+	"${KYTY_SOURCE_DIR}/kernel/syncOnAddress.cpp"
+)
+target_link_libraries(sync_on_address_tests common)
+target_include_directories(sync_on_address_tests PRIVATE ${inc_headers})
+
 add_executable(image_page_table_tests EXCLUDE_FROM_ALL
 	"${KYTY_TESTS_DIR}/ImagePageTableTests.cpp"
 )
@@ -459,6 +505,7 @@ if(NOT KYTY_CLANG_CL)
 endif()
 
 if(BUILD_TESTING)
+	add_test(NAME ime_dialog COMMAND $<TARGET_FILE:ime_dialog_tests>)
 	add_test(NAME shader_cfg COMMAND $<TARGET_FILE:shader_cfg_tests>)
 	add_test(NAME scalar_provenance COMMAND $<TARGET_FILE:scalar_provenance_tests>)
 	add_test(NAME image_page_table COMMAND $<TARGET_FILE:image_page_table_tests>)
@@ -470,6 +517,7 @@ if(BUILD_TESTING)
 	add_test(NAME resource_tracking COMMAND $<TARGET_FILE:resource_tracking_tests>)
 	add_test(NAME resource_mutex COMMAND $<TARGET_FILE:resource_mutex_tests>)
 	add_test(NAME event_queue_lifetime COMMAND $<TARGET_FILE:event_queue_lifetime_tests>)
+	add_test(NAME sync_on_address COMMAND $<TARGET_FILE:sync_on_address_tests>)
 	add_test(NAME audio_out2_port COMMAND $<TARGET_FILE:audio_out2_port_tests>)
 	add_test(NAME shader_recompiler_compute COMMAND $<TARGET_FILE:shader_recompiler_compute_tests>)
 	add_test(NAME virtual_memory_allocation
@@ -480,6 +528,8 @@ if(BUILD_TESTING)
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --stream-buffer-only)
 	add_test(NAME gpu_command_lane
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --gpu-command-lane-only)
+	add_test(NAME pm4_context_state
+		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --context-state-only)
 	add_test(NAME gpu_tiler
 		COMMAND $<TARGET_FILE:shader_recompiler_compute_tests> --gpu-tiler-only)
 
@@ -505,6 +555,7 @@ if(BUILD_TESTING)
 	endif()
 
 	add_custom_target(kyty_tests DEPENDS
+		ime_dialog_tests
 		shader_cfg_tests
 		scalar_provenance_tests
 		image_page_table_tests
@@ -516,6 +567,7 @@ if(BUILD_TESTING)
 		resource_tracking_tests
 		resource_mutex_tests
 		event_queue_lifetime_tests
+		sync_on_address_tests
 		shader_recompiler_compute_tests
 		virtual_memory_allocation_tests
 	)
@@ -563,8 +615,6 @@ elseif(WIN32 OR LINUX)
 	set_target_properties(kyty_emulator PROPERTIES LINK_FLAGS "${KYTY_LD_OPTIONS} -Wl,-Map=${KYTY_EMULATOR_MAP_LINK_PATH}")
 endif()
 
-add_dependencies(kyty_emulator KytyGitVersion)
-
 if(APPLE)
 	# The emulator writes x86-64 trampolines/PLT stubs into memory and executes them, and
 	# runs guest code under Rosetta. That requires the JIT / unsigned-executable-memory

src/cmake_config.h.in

@@ -1,4 +1,8 @@
 #define KYTY_VERSION "@KYTY_VERSION@"
+#define KYTY_BUILD_REPOSITORY "@KYTY_BUILD_REPOSITORY@"
+#define KYTY_RELEASE_TAG "@KYTY_RELEASE_TAG@"
+#cmakedefine KYTY_OFFICIAL_BUILD
+#cmakedefine KYTY_FORK_BUILD
 #define KYTY_ENDIAN @KYTY_ENDIAN@
 #define KYTY_PLATFORM @KYTY_PLATFORM@
 #define KYTY_COMPILER KYTY_COMPILER_@KYTY_COMPILER@

src/common/emulatorConfig.cpp

@@ -33,10 +33,18 @@ uint32_t GetScreenHeight() {
 	return g_config->screen_height;
 }
 
+bool FullscreenEnabled() {
+	return g_config->fullscreen_enabled;
+}
+
 uint32_t GetVblankFrequency() {
 	return std::clamp(g_config->vblank_frequency, 30u, 360u);
 }
 
+uint32_t GetConsoleLanguage() {
+	return g_config->console_language;
+}
+
 bool VulkanValidationEnabled() {
 	return g_config->vulkan_validation_enabled;
 }
@@ -93,4 +101,8 @@ bool ReadbackLinearImagesEnabled() {
 	return g_config->readback_linear_images;
 }
 
+const Keymap& GetKeymap() {
+	return g_config->keymap;
+}
+
 } // namespace Config

src/common/emulatorConfig.h

@@ -5,6 +5,8 @@
 #include "common/subsystems.h"
 
 #include <filesystem>
+#include <string>
+#include <vector>
 
 namespace Config {
 
@@ -18,10 +20,17 @@ enum class ProfilerDirection { None, Network };
 
 enum class OutputDirection { Silent, Console, File };
 
+using Keymap = std::vector<std::string>;
+
+constexpr uint32_t DEFAULT_CONSOLE_LANGUAGE = 1;
+constexpr uint32_t MAX_CONSOLE_LANGUAGE     = 29;
+
 struct ConfigOptions {
 	uint32_t               screen_width                = 1280;
 	uint32_t               screen_height               = 720;
+	bool                   fullscreen_enabled          = false;
 	uint32_t               vblank_frequency            = 60;
+	uint32_t               console_language            = DEFAULT_CONSOLE_LANGUAGE;
 	bool                   vulkan_validation_enabled   = false;
 	bool                   shader_validation_enabled   = false;
 	ShaderOptimizationType shader_optimization_type    = ShaderOptimizationType::None;
@@ -36,13 +45,16 @@ struct ConfigOptions {
 	bool                   spirv_debug_printf_enabled  = false;
 	bool                   renderdoc_enabled           = false;
 	bool                   readback_linear_images      = false;
+	Keymap                 keymap;
 };
 
 void Load(const ConfigOptions& cfg);
 
 uint32_t GetScreenWidth();
 uint32_t GetScreenHeight();
+bool     FullscreenEnabled();
 uint32_t GetVblankFrequency();
+uint32_t GetConsoleLanguage();
 bool     VulkanValidationEnabled();
 
 bool                   ShaderValidationEnabled();
@@ -65,6 +77,8 @@ bool SpirvDebugPrintfEnabled();
 bool RenderDocEnabled();
 bool ReadbackLinearImagesEnabled();
 
+const Keymap& GetKeymap();
+
 } // namespace Config
 
 #endif /* KYTY_COMMON_EMULATOR_CONFIG_H_ */

src/generate_version.cmake

@@ -1,7 +1,8 @@
 set(KYTY_GIT_VERSION "unknown")
+set(KYTY_GIT_HASH "unknown")
 if(GIT_EXECUTABLE)
 	execute_process(
-		COMMAND "${GIT_EXECUTABLE}" describe --tags --always
+		COMMAND "${GIT_EXECUTABLE}" describe --tags --always --dirty
 		WORKING_DIRECTORY "${GIT_WORKING_DIRECTORY}"
 		OUTPUT_VARIABLE KYTY_GIT_VERSION
 		OUTPUT_STRIP_TRAILING_WHITESPACE
@@ -11,5 +12,27 @@ if(GIT_EXECUTABLE)
 	if(NOT GIT_RESULT EQUAL 0)
 		set(KYTY_GIT_VERSION "unknown")
 	endif()
+
+	execute_process(
+		COMMAND "${GIT_EXECUTABLE}" rev-parse --short=7 HEAD
+		WORKING_DIRECTORY "${GIT_WORKING_DIRECTORY}"
+		OUTPUT_VARIABLE KYTY_GIT_HASH
+		OUTPUT_STRIP_TRAILING_WHITESPACE
+		RESULT_VARIABLE GIT_HASH_RESULT
+		ERROR_QUIET
+	)
+	if(NOT GIT_HASH_RESULT EQUAL 0)
+		set(KYTY_GIT_HASH "unknown")
+	else()
+		execute_process(
+			COMMAND "${GIT_EXECUTABLE}" diff-index --quiet HEAD --
+			WORKING_DIRECTORY "${GIT_WORKING_DIRECTORY}"
+			RESULT_VARIABLE GIT_DIRTY_RESULT
+			ERROR_QUIET
+		)
+		if(NOT GIT_DIRTY_RESULT EQUAL 0)
+			string(APPEND KYTY_GIT_HASH "-dirty")
+		endif()
+	endif()
 endif()
 configure_file("${INPUT_FILE}" "${OUTPUT_FILE}")

src/graphics/guest_gpu/command_processor/commandProcessor.h

@@ -15,6 +15,13 @@ bool TestWaitRegMemValue(uint64_t value, uint64_t ref, uint64_t mask, uint32_t f
 
 enum class Pm4ProcessResult { Complete, Blocked };
 
+enum class ContextStateOperation : uint32_t {
+	Clear     = 0,
+	Push      = 1,
+	Pop       = 2,
+	PushClear = 3,
+};
+
 class Pm4Execution {
 public:
 	[[nodiscard]] bool MadeProgress() const noexcept { return m_made_progress; }
@@ -49,24 +56,12 @@ public:
 	KYTY_CLASS_NO_COPY(CommandProcessor);
 
 	void Reset();
+	void ApplyContextStateOperation(ContextStateOperation operation);
 
-	void BufferInit();
-	void BufferFlush();
-	void BufferFlushAndWait();
-	void BufferWait();
-	void BeginReadbackTransaction() {
-		if (m_readback_active) {
-			EXIT("nested command-processor readback transaction\n");
-		}
-		m_readback_active = true;
-	}
-	void EndReadbackTransaction() {
-		if (!m_readback_active) {
-			EXIT("command-processor readback transaction is not active\n");
-		}
-		m_readback_active = false;
-	}
-
+	void            BufferInit();
+	void            BufferFlush();
+	void            BufferFlushAndWait();
+	void            BufferWait();
 	HW::Context&    GetCtx() { return m_ctx; }
 	HW::UserConfig& GetUcfg() { return m_ucfg; }
 	HW::Shader&     GetShCtx() { return m_sh_ctx; }
@@ -162,6 +157,8 @@ private:
 
 	RenderContext&   m_renderer;
 	HW::Context      m_ctx;
+	HW::Context      m_saved_ctx;
+	bool             m_context_state_pushed = false;
 	HW::UserConfig   m_ucfg;
 	HW::Shader       m_sh_ctx;
 	HW::UserSgprType m_user_data_marker                 = HW::UserSgprType::Unknown;
@@ -173,10 +170,9 @@ private:
 	// Persistent draw state: indirect draws update it for subsequent draws.
 	uint32_t m_num_instances = 1;
 
-	uint32_t m_de_count        = 0;
-	uint32_t m_ce_count        = 0;
-	bool     m_ce_complete     = false;
-	bool     m_readback_active = false;
+	uint32_t m_de_count    = 0;
+	uint32_t m_ce_count    = 0;
+	bool     m_ce_complete = false;
 
 	uint32_t m_const_ram[0x3000] = {0};
 

src/graphics/guest_gpu/command_processor/pm4Dispatch.cpp

@@ -254,6 +254,7 @@ constexpr auto MakeCustomOpcodeDispatchTable() {
 	g_cp_op_custom_func[Pm4::R_WAIT_MEM_64]    = CpOpWaitRegMem64;
 	g_cp_op_custom_func[Pm4::R_FLIP]           = CpOpFlip;
 	g_cp_op_custom_func[Pm4::R_RELEASE_MEM]    = CpOpReleaseMem;
+	g_cp_op_custom_func[Pm4::R_CONTEXT_STATE]  = CpOpContextState;
 
 	return g_cp_op_custom_func;
 }

src/graphics/guest_gpu/command_processor/pm4Dispatch.h

@@ -121,6 +121,7 @@ uint32_t HwUcSetGeIndexOffset(CommandProcessor&, uint32_t, uint32_t, const uint3
 uint32_t HwUcSetGdsOaRegisters(CommandProcessor&, uint32_t, uint32_t, const uint32_t*, uint32_t);
 
 uint32_t CpOpNop(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
+uint32_t CpOpContextState(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpSetBase(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpClearState(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);
 uint32_t CpOpIndexBase(CommandProcessor&, uint32_t, const uint32_t*, uint32_t, uint32_t);

src/graphics/guest_gpu/command_processor/pm4Handlers.cpp

@@ -2107,6 +2107,19 @@ KYTY_CP_OP_PARSER(CpOpClearState) {
 	return 1;
 }
 
+KYTY_CP_OP_PARSER(CpOpContextState) {
+	KYTY_PROFILER_FUNCTION();
+
+	const auto packet_size_dw = KYTY_PM4_LEN(cmd_id);
+	EXIT_NOT_IMPLEMENTED(KYTY_PM4_R(cmd_id) != Pm4::R_CONTEXT_STATE);
+	EXIT_NOT_IMPLEMENTED(packet_size_dw != 3u && packet_size_dw != 5u);
+	EXIT_NOT_IMPLEMENTED(buffer[0] > static_cast<uint32_t>(ContextStateOperation::PushClear));
+
+	cp.ApplyContextStateOperation(static_cast<ContextStateOperation>(buffer[0]));
+
+	return packet_size_dw - 1u;
+}
+
 KYTY_CP_OP_PARSER(CpOpDumpConstRam) {
 	KYTY_PROFILER_FUNCTION();
 

src/graphics/guest_gpu/graphicsRun.cpp

@@ -36,6 +36,7 @@ static thread_local CommandProcessor* g_current_processor = nullptr;
 static thread_local Pm4Execution*     g_current_execution = nullptr;
 static thread_local bool              g_gpu_mutex_owned   = false;
 static thread_local bool              g_gpu_thread        = false;
+static thread_local GpuState*         g_gpu_state         = nullptr;
 
 class GpuMutexLock final {
 public:
@@ -98,11 +99,10 @@ public:
 	void SubmitFlipPreparation(uint64_t request_id);
 	void Done();
 	void Shutdown();
-	[[nodiscard]] bool IsStopping();
-	void               SendCommand(Common::UniqueFunction<void>&& command);
-	void               SendCommandSync(Common::UniqueFunction<void>&& command);
-	void SendCommandSyncWithProcessor(Common::UniqueFunction<void, CommandProcessor&>&& command);
-	int  GetFrameNum();
+	[[nodiscard]] bool        IsStopping();
+	void                      SendCommand(Common::UniqueFunction<void>&& command);
+	void                      SendCommandSync(Common::UniqueFunction<void>&& command);
+	int                       GetFrameNum();
 	[[nodiscard]] static bool IsGpuThread() noexcept { return g_gpu_thread; }
 
 private:
@@ -127,6 +127,7 @@ private:
 	void              WaitLocked();
 	void              Enqueue(Submission submission);
 	void              WaitForIdle();
+	void              ProcessCommands();
 	bool              Process(Submission& submission);
 	static void       ThreadRun(void* data);
 	CommandProcessor& GetProcessor(uint32_t queue_id);
@@ -139,6 +140,7 @@ private:
 	Common::CondVar                                m_idle;
 	std::array<std::deque<Submission>, QueueCount> m_queues;
 	std::deque<Common::UniqueFunction<void>>       m_commands;
+	std::atomic_uint32_t                           m_pending_commands {0};
 	uint32_t                                       m_next_queue        = 0;
 	uint32_t                                       m_submission_count  = 0;
 	bool                                           m_processing        = false;
@@ -153,6 +155,8 @@ private:
 	uint64_t        m_submit_id = 0;
 	std::atomic_int m_done_num  = 0;
 	std::jthread    m_thread;
+
+	friend class CommandProcessor;
 };
 
 static bool GraphicsRunDebugDumpEnabled() {
@@ -195,9 +199,25 @@ void GpuState::SendCommand(Common::UniqueFunction<void>&& command) {
 	Common::LockGuard lock(m_queue_mutex);
 	EXIT_IF(!m_accepting);
 	m_commands.push_back(std::move(command));
+	m_pending_commands.fetch_add(1, std::memory_order_release);
 	m_work_available.Signal();
 }
 
+void GpuState::ProcessCommands() {
+	EXIT_IF(!IsGpuThread());
+	while (m_pending_commands.load(std::memory_order_acquire) != 0) {
+		Common::UniqueFunction<void> command;
+		{
+			Common::LockGuard lock(m_queue_mutex);
+			EXIT_IF(m_commands.empty());
+			command = std::move(m_commands.front());
+			m_commands.pop_front();
+			EXIT_IF(m_pending_commands.fetch_sub(1, std::memory_order_acq_rel) == 0);
+		}
+		command();
+	}
+}
+
 void GpuState::SendCommandSync(Common::UniqueFunction<void>&& command) {
 	EXIT_IF(!command);
 	if (IsGpuThread()) {
@@ -212,17 +232,6 @@ void GpuState::SendCommandSync(Common::UniqueFunction<void>&& command) {
 	done.acquire();
 }
 
-void GpuState::SendCommandSyncWithProcessor(
-    Common::UniqueFunction<void, CommandProcessor&>&& command) {
-	EXIT_IF(!command);
-	SendCommandSync([this, operation = std::move(command)]() mutable {
-		EXIT_IF(g_current_processor != nullptr);
-		g_current_processor = m_gfx_cp.get();
-		operation(*m_gfx_cp);
-		g_current_processor = nullptr;
-	});
-}
-
 void GpuState::Submit(uint32_t* cmd_draw_buffer, uint32_t num_draw_dw, uint32_t* cmd_const_buffer,
                       uint32_t num_const_dw, bool trigger_agc_interrupt_on_done) {
 	GpuMutexLock lock(m_submission_mutex);
@@ -303,6 +312,8 @@ void CommandProcessor::Reset() {
 	m_sh_ctx.Reset();
 	m_ucfg.Reset();
 	m_ctx.Reset();
+	m_saved_ctx.Reset();
+	m_context_state_pushed = false;
 	m_index_type_and_size              = 0;
 	m_index_buffer_size                = 0;
 	m_user_data_marker                 = HW::UserSgprType::Unknown;
@@ -312,6 +323,30 @@ void CommandProcessor::Reset() {
 	std::memset(m_const_ram, 0, sizeof(m_const_ram));
 }
 
+void CommandProcessor::ApplyContextStateOperation(ContextStateOperation operation) {
+	switch (operation) {
+		case ContextStateOperation::Clear: m_ctx.Reset(); break;
+		case ContextStateOperation::Push:
+			EXIT_IF(m_context_state_pushed);
+			m_saved_ctx            = m_ctx;
+			m_context_state_pushed = true;
+			break;
+		case ContextStateOperation::Pop:
+			EXIT_IF(!m_context_state_pushed);
+			m_ctx                  = m_saved_ctx;
+			m_saved_ctx            = {};
+			m_context_state_pushed = false;
+			break;
+		case ContextStateOperation::PushClear:
+			EXIT_IF(m_context_state_pushed);
+			m_saved_ctx            = m_ctx;
+			m_context_state_pushed = true;
+			m_ctx.Reset();
+			break;
+		default: EXIT("unknown context state operation: %u\n", static_cast<uint32_t>(operation));
+	}
+}
+
 void CommandProcessor::BufferInit() {
 	GetScheduler().Begin(m_ctx, m_ucfg, m_sh_ctx);
 }
@@ -509,6 +544,7 @@ void GpuState::ThreadRun(void* data) {
 	EXIT_IF(gpu == nullptr);
 	KYTY_PROFILER_THREAD("Thread_Gpu");
 	g_gpu_thread = true;
+	g_gpu_state  = gpu;
 
 	for (;;) {
 		Submission                   submission;
@@ -529,6 +565,7 @@ void GpuState::ThreadRun(void* data) {
 			} else if (!gpu->m_commands.empty()) {
 				command = std::move(gpu->m_commands.front());
 				gpu->m_commands.pop_front();
+				EXIT_IF(gpu->m_pending_commands.fetch_sub(1, std::memory_order_acq_rel) == 0);
 				gpu->m_processing = true;
 			} else {
 				int selected_queue = -1;
@@ -560,6 +597,7 @@ void GpuState::ThreadRun(void* data) {
 		}
 		if (should_stop) {
 			gpu->m_gfx_cp->BufferWait();
+			g_gpu_state  = nullptr;
 			g_gpu_thread = false;
 			return;
 		}
@@ -741,6 +779,9 @@ void CommandProcessor::SuspendPm4() {
 
 void CommandProcessor::ProcessPm4(Pm4Execution& execution, size_t stop_depth) {
 	while (execution.m_buffer_stack.size() > stop_depth) {
+		if (g_gpu_state != nullptr) {
+			g_gpu_state->ProcessCommands();
+		}
 		const auto buffer_index = execution.m_buffer_stack.size() - 1;
 		auto&      cursor       = execution.m_buffer_stack[buffer_index];
 		if (cursor.deferred_advance_dw != 0) {
@@ -1650,10 +1691,6 @@ void Gpu::SendCommandSync(Common::UniqueFunction<void>&& command) {
 	m_state->SendCommandSync(std::move(command));
 }
 
-void Gpu::SendCommandSyncWithProcessor(Common::UniqueFunction<void, CommandProcessor&>&& command) {
-	m_state->SendCommandSyncWithProcessor(std::move(command));
-}
-
 void Gpu::Submit(uint32_t* draw_commands, uint32_t draw_size_dw, uint32_t* constant_commands,
                  uint32_t constant_size_dw, bool trigger_agc_interrupt_on_done) {
 	EXIT_IF(draw_commands == nullptr || draw_size_dw == 0);
@@ -1679,12 +1716,8 @@ int Gpu::GetFrameNum() const {
 	return m_state->GetFrameNum();
 }
 
-bool Gpu::IsCommandProcessorThread() noexcept {
-	return g_current_processor != nullptr;
-}
-
-CommandProcessor* Gpu::CurrentCommandProcessor() noexcept {
-	return g_current_processor;
+bool Gpu::IsGpuThread() noexcept {
+	return GpuState::IsGpuThread();
 }
 
 } // namespace Libs::Graphics

src/graphics/guest_gpu/graphicsRun.h

@@ -9,7 +9,6 @@
 
 namespace Libs::Graphics {
 
-class CommandProcessor;
 class GpuState;
 class RenderContext;
 
@@ -23,7 +22,6 @@ public:
 	[[nodiscard]] bool IsStopping();
 	void               SendCommand(Common::UniqueFunction<void>&& command);
 	void               SendCommandSync(Common::UniqueFunction<void>&& command);
-	void SendCommandSyncWithProcessor(Common::UniqueFunction<void, CommandProcessor&>&& command);
 
 	void Submit(uint32_t* draw_commands, uint32_t draw_size_dw, uint32_t* constant_commands,
 	            uint32_t constant_size_dw, bool trigger_agc_interrupt_on_done = false);
@@ -33,8 +31,7 @@ public:
 	void Done();
 	[[nodiscard]] int GetFrameNum() const;
 
-	[[nodiscard]] static bool              IsCommandProcessorThread() noexcept;
-	[[nodiscard]] static CommandProcessor* CurrentCommandProcessor() noexcept;
+	[[nodiscard]] static bool IsGpuThread() noexcept;
 
 private:
 	std::unique_ptr<GpuState> m_state;

src/graphics/guest_gpu/pm4.cpp

@@ -30,6 +30,7 @@ constexpr auto MakeRegisterNames() {
 	names[R_FLIP]           = "R_FLIP";
 	names[R_RELEASE_MEM]    = "R_RELEASE_MEM";
 	names[R_DMA_DATA]       = "R_DMA_DATA";
+	names[R_CONTEXT_STATE]  = "R_CONTEXT_STATE";
 	return names;
 }
 

src/graphics/guest_gpu/pm4.h

@@ -87,6 +87,7 @@ constexpr uint32_t R_WAIT_MEM_64    = 0x16;
 constexpr uint32_t R_FLIP           = 0x17;
 constexpr uint32_t R_RELEASE_MEM    = 0x18;
 constexpr uint32_t R_DMA_DATA       = 0x19;
+constexpr uint32_t R_CONTEXT_STATE  = 0x1A;
 
 constexpr uint32_t R_NUM = 0x3F + 1;
 

src/graphics/host_gpu/memoryTracker.h

@@ -29,45 +29,29 @@ public:
 	void               MarkRegionAsGpuModified(uint64_t vaddr, uint64_t size);
 	void               UnmarkRegionAsGpuModified(uint64_t vaddr, uint64_t size);
 	void               UntrackMemory(uint64_t vaddr, uint64_t size);
+	// Removes protection from a range and flushes GPU-owned data when required.
 	template <typename Flush>
-	void InvalidateRegion(uint64_t vaddr, uint64_t size, Flush&& on_flush) {
+	void InvalidateRegion(uint64_t vaddr, uint64_t size, Flush&& on_flush) noexcept {
 		static_assert(std::is_invocable_v<Flush&>);
 		CheckNotInUploadCallback();
 		ValidateRange(vaddr, size);
 
-		const auto update_cpu_state = [this, vaddr, size] {
-			std::lock_guard             access(m_access_mutex);
-			std::vector<RegionManager*> managers;
-			Iterate<false>(vaddr, size, [&](RegionManager* manager, uint64_t, uint64_t) {
-				managers.push_back(manager);
-			});
-			std::vector<std::unique_lock<TrackingSpinLock>> locks;
-			locks.reserve(managers.size());
-			for (auto* manager: managers) {
-				locks.emplace_back(manager->lock);
+		Iterate<false>(vaddr, size, [&](RegionManager* manager, uint64_t offset, uint64_t bytes) {
+			const bool should_flush = [&] {
+				// Perform both the GPU modification check and CPU state change with the lock in
+				// case the GPU thread is racing to mark the page modified. If a flush is needed,
+				// on_flush performs the CPU state change.
+				std::scoped_lock lock(manager->lock);
+				if (manager->IsModified<DirtySource::Gpu>(offset, bytes)) {
+					return true;
+				}
+				manager->ChangeState<DirtySource::Cpu, true>(manager->GetCpuAddr() + offset, bytes);
+				return false;
+			}();
+			if (should_flush) {
+				on_flush();
 			}
-			const bool gpu_modified = Iterate<false>(
-			    vaddr, size, [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-				    return manager->IsModified<DirtySource::Gpu>(offset, bytes);
-			    });
-			if (gpu_modified) {
-				return true;
-			}
-			Iterate<false>(vaddr, size,
-			               [](RegionManager* manager, uint64_t offset, uint64_t bytes) {
-				               manager->ChangeState<DirtySource::Cpu, true>(
-				                   manager->GetCpuAddr() + offset, bytes);
-			               });
-			return false;
-		};
-
-		if (!update_cpu_state()) {
-			return;
-		}
-		std::forward<Flush>(on_flush)();
-		if (update_cpu_state()) {
-			EXIT("memory invalidation retained GPU-owned pages\n");
-		}
+		});
 	}
 #if KYTY_BUILD == KYTY_BUILD_DEBUG
 	void ValidateGpuDirtyPages(const RangeSet& dirty, uint64_t vaddr, uint64_t size,

src/graphics/host_gpu/renderer/cache/bufferCache.cpp

@@ -3,15 +3,18 @@
 #include "common/assert.h"
 #include "common/logging/log.h"
 #include "common/profiler.h"
+#include "graphics/guest_gpu/graphicsRun.h"
 #include "graphics/host_gpu/graphicContext.h"
 #include "graphics/host_gpu/renderer/cache/resourceMutex.h"
 #include "graphics/host_gpu/renderer/cache/textureCache.h"
 #include "graphics/host_gpu/renderer/commandScheduler.h"
 #include "graphics/host_gpu/renderer/render.h"
+#include "graphics/host_gpu/renderer/renderContext.h"
 #include "kernel/memory.h"
 
 #include <algorithm>
 #include <array>
+#include <cinttypes>
 #include <cstring>
 #include <utility>
 #include <vector>
@@ -288,10 +291,29 @@ void BufferCache::InvalidateMemory(uint64_t vaddr, uint64_t size) {
 		return;
 	}
 	m_memory_tracker.InvalidateRegion(vaddr, size,
-	                                  [this, vaddr, size] { ReadMemory(vaddr, size); });
+	                                  [this, vaddr, size] { ReadMemory(vaddr, size, true); });
 }
 
-void BufferCache::ReadMemory(uint64_t vaddr, uint64_t size) {
+void BufferCache::ReadMemory(uint64_t vaddr, uint64_t size, bool is_write) {
+	if (Gpu::IsGpuThread()) {
+		ReadMemoryOnGpu(vaddr, size, is_write);
+		return;
+	}
+	if (CommandScheduler::InDeferredOperation()) {
+		EXIT("unsupported buffer readback from an asynchronous GPU completion, "
+		     "addr=0x%016" PRIx64 " size=0x%016" PRIx64 "\n",
+		     vaddr, size);
+	}
+	if (m_resource_mutex.IsOwnedByCurrentThread()) {
+		EXIT("unsupported buffer readback from a pre-owned resource transaction, "
+		     "addr=0x%016" PRIx64 " size=0x%016" PRIx64 "\n",
+		     vaddr, size);
+	}
+	m_scheduler.Context().GetGpu().SendCommandSync(
+	    [this, vaddr, size, is_write] { ReadMemoryOnGpu(vaddr, size, is_write); });
+}
+
+void BufferCache::ReadMemoryOnGpu(uint64_t vaddr, uint64_t size, bool is_write) {
 	std::vector<DownloadCopy> copies;
 	{
 		FaultSafeCacheLock lock(this, m_mutex);
@@ -322,9 +344,16 @@ void BufferCache::ReadMemory(uint64_t vaddr, uint64_t size) {
 				    }
 			    }
 		    });
-	}
-	if (copies.empty()) {
-		return;
+		if (copies.empty()) {
+			if (!is_write) {
+				return;
+			}
+			// A preceding read fault can consume the last GPU-owned copy after this write
+			// invalidation has already chosen to flush. Complete the CPU ownership handoff even
+			// though this callback no longer has bytes to download.
+			m_memory_tracker.MarkRegionAsCpuModified(vaddr, size);
+			return;
+		}
 	}
 	auto downloads = RecordDownloads(copies);
 	m_scheduler.FinishCurrent();
@@ -336,6 +365,9 @@ void BufferCache::ReadMemory(uint64_t vaddr, uint64_t size) {
 		}
 		// The enumeration above covered whole dirty pages and every exact interval on them.
 		m_memory_tracker.UnmarkRegionAsGpuModified(vaddr, size);
+		if (is_write) {
+			m_memory_tracker.MarkRegionAsCpuModified(vaddr, size);
+		}
 	}
 }
 

src/graphics/host_gpu/renderer/cache/bufferCache.h

@@ -46,7 +46,7 @@ public:
 	KYTY_CLASS_NO_COPY(BufferCache);
 
 	void                        InvalidateMemory(uint64_t vaddr, uint64_t size);
-	void                        ReadMemory(uint64_t vaddr, uint64_t size);
+	void                        ReadMemory(uint64_t vaddr, uint64_t size, bool is_write = false);
 	void                        UnmapMemory(uint64_t vaddr, uint64_t size);
 	[[nodiscard]] BufferBinding ObtainBuffer(CommandBuffer& command, uint64_t vaddr, uint64_t size,
 	                                         bool is_written = false, bool is_read = true,
@@ -97,6 +97,7 @@ private:
 	void PublishDownloads(std::span<const DownloadRange> downloads);
 	void QueueGarbageDownload(std::span<const DownloadCopy> copies, RetiredBuffer retire);
 	void WriteHostMemory(uint64_t vaddr, std::span<const uint8_t> data);
+	void ReadMemoryOnGpu(uint64_t vaddr, uint64_t size, bool is_write);
 
 	GraphicContext&                                   m_graphics;
 	CommandScheduler&                                 m_scheduler;

src/graphics/host_gpu/renderer/cache/gpuResourceManager.cpp

@@ -1,7 +1,6 @@
 #include "graphics/host_gpu/renderer/cache/gpuResourceManager.h"
 
 #include "common/assert.h"
-#include "graphics/guest_gpu/command_processor/commandProcessor.h"
 #include "graphics/guest_gpu/graphicsRun.h"
 #include "graphics/host_gpu/renderer/commandScheduler.h"
 namespace Libs::Graphics {
@@ -18,69 +17,21 @@ bool GpuResourceManager::HandleFault(PageFaultAccess access, uint64_t fault_vadd
 	if (!IsMapped(fault_vaddr, fault_size)) {
 		return false;
 	}
-	if (CommandScheduler::InDeferredOperation()) {
-		EXIT("unsupported guest-memory fault from an asynchronous GPU completion, "
-		     "addr=0x%016" PRIx64 " access=%u\n",
-		     fault_vaddr, static_cast<uint32_t>(access));
+	if (access == PageFaultAccess::Write) {
+		m_buffer_cache.InvalidateMemory(fault_vaddr, fault_size);
+		m_texture_cache.InvalidateMemory(fault_vaddr, fault_size);
+	} else {
+		m_buffer_cache.ReadMemory(fault_vaddr, fault_size);
 	}
-	bool       handled = false;
-	const auto resolve = [this, access, fault_vaddr, &handled](CommandProcessor& cp) {
-		cp.BeginReadbackTransaction();
-		{
-			ResourceMutex::FaultScope fault(m_resource_mutex);
-			if (access == PageFaultAccess::Write) {
-				m_buffer_cache.InvalidateMemory(fault_vaddr, fault_size);
-				m_texture_cache.InvalidateMemory(fault_vaddr, fault_size);
-			} else {
-				m_buffer_cache.ReadMemory(fault_vaddr, fault_size);
-			}
-			handled = true;
-		}
-		cp.EndReadbackTransaction();
-	};
-	if (auto* cp = Gpu::CurrentCommandProcessor(); cp != nullptr) {
-		resolve(*cp);
-		return handled;
-	}
-	if (m_resource_mutex.IsOwnedByCurrentThread()) {
-		EXIT("unsupported page fault from a pre-owned resource transaction, addr=0x%016" PRIx64
-		     " access=%u\n",
-		     fault_vaddr, static_cast<uint32_t>(access));
-	}
-	EXIT_IF(m_gpu == nullptr);
-	m_gpu->SendCommandSyncWithProcessor(resolve);
-	return handled;
+	return true;
 }
 
 bool GpuResourceManager::InvalidateMemory(uint64_t vaddr, uint64_t size) {
 	if (!IsMapped(vaddr, size)) {
 		return false;
 	}
-	if (CommandScheduler::InDeferredOperation()) {
-		EXIT("unsupported memory invalidation from an asynchronous GPU completion, "
-		     "addr=0x%016" PRIx64 " size=0x%016" PRIx64 "\n",
-		     vaddr, size);
-	}
-	const auto resolve = [this, vaddr, size](CommandProcessor& cp) {
-		cp.BeginReadbackTransaction();
-		{
-			ResourceMutex::FaultScope fault(m_resource_mutex);
-			m_buffer_cache.InvalidateMemory(vaddr, size);
-			m_texture_cache.InvalidateMemory(vaddr, size);
-		}
-		cp.EndReadbackTransaction();
-	};
-	if (auto* cp = Gpu::CurrentCommandProcessor(); cp != nullptr) {
-		resolve(*cp);
-		return true;
-	}
-	if (m_resource_mutex.IsOwnedByCurrentThread()) {
-		EXIT("unsupported memory invalidation from a pre-owned resource transaction, "
-		     "addr=0x%016" PRIx64 " size=0x%016" PRIx64 "\n",
-		     vaddr, size);
-	}
-	EXIT_IF(m_gpu == nullptr);
-	m_gpu->SendCommandSyncWithProcessor(resolve);
+	m_buffer_cache.InvalidateMemory(vaddr, size);
+	m_texture_cache.InvalidateMemory(vaddr, size);
 	return true;
 }
 

src/graphics/host_gpu/renderer/cache/multiLevelPageTable.h

@@ -7,8 +7,9 @@
 #include <array>
 #include <cstddef>
 #include <cstdint>
-#include <list>
+#include <cstring>
 #include <memory>
+#include <type_traits>
 #include <utility>
 #include <vector>
 
@@ -103,6 +104,158 @@ private:
 	size_t                               m_allocated_buckets = 0;
 };
 
+// Inline owner storage for page-table entries. Texture pages normally have only a
+// handful of owners, so avoid a heap allocation on the first 16 registrations.
+//
+// Owners are packed into live uint64_t objects instead of being constructed in
+// raw storage. This keeps sparse bucket construction cheap without relying on
+// subtle implicit-lifetime or pointer-provenance rules.
+template <typename OwnerT, size_t InlineCapacity = 16>
+class InlinePageOwnerList final {
+public:
+	using value_type = OwnerT;
+	using size_type  = size_t;
+
+	class const_iterator final {
+	public:
+		[[nodiscard]] OwnerT operator*() const noexcept { return m_owners->At(m_index); }
+		const_iterator&      operator++() noexcept {
+			++m_index;
+			return *this;
+		}
+		bool operator==(const const_iterator&) const = default;
+
+	private:
+		friend class InlinePageOwnerList;
+		const_iterator(const InlinePageOwnerList* owners, size_type index) noexcept
+		    : m_owners(owners), m_index(index) {}
+
+		const InlinePageOwnerList* m_owners = nullptr;
+		size_type                  m_index  = 0;
+	};
+
+	static_assert(InlineCapacity > 0);
+	static_assert(std::is_default_constructible_v<OwnerT>);
+	static_assert(std::is_trivially_copyable_v<OwnerT>);
+	static_assert(std::has_unique_object_representations_v<OwnerT>);
+	static_assert(sizeof(OwnerT) <= sizeof(uint64_t));
+
+	InlinePageOwnerList() noexcept {}
+	InlinePageOwnerList(const InlinePageOwnerList&)            = delete;
+	InlinePageOwnerList& operator=(const InlinePageOwnerList&) = delete;
+	InlinePageOwnerList(InlinePageOwnerList&& other) noexcept
+	    : m_overflow(std::move(other.m_overflow)),
+	      m_inline_size(std::exchange(other.m_inline_size, 0)) {
+		if (m_overflow == nullptr) {
+			std::copy_n(other.m_inline.begin(), m_inline_size, m_inline.begin());
+		}
+	}
+	InlinePageOwnerList& operator=(InlinePageOwnerList&& other) noexcept {
+		if (this != &other) {
+			m_overflow    = std::move(other.m_overflow);
+			m_inline_size = std::exchange(other.m_inline_size, 0);
+			if (m_overflow == nullptr) {
+				std::copy_n(other.m_inline.begin(), m_inline_size, m_inline.begin());
+			}
+		}
+		return *this;
+	}
+
+	[[nodiscard]] const_iterator begin() const noexcept { return {this, 0}; }
+	[[nodiscard]] const_iterator end() const noexcept { return {this, size()}; }
+
+	[[nodiscard]] bool      empty() const noexcept { return size() == 0; }
+	[[nodiscard]] size_type size() const noexcept {
+		return m_overflow == nullptr ? m_inline_size : m_overflow->size();
+	}
+	[[nodiscard]] OwnerT front() const noexcept { return At(0); }
+	[[nodiscard]] OwnerT operator[](size_type index) const noexcept { return At(index); }
+
+	void push_back(const OwnerT& owner) {
+		const uint64_t packed = Pack(owner);
+		if (m_overflow != nullptr) {
+			m_overflow->push_back(packed);
+			return;
+		}
+		if (m_inline_size < InlineCapacity) {
+			m_inline[m_inline_size] = packed;
+			++m_inline_size;
+			return;
+		}
+		auto overflow = std::make_unique<std::vector<uint64_t>>();
+		overflow->reserve(InlineCapacity * 2);
+		overflow->assign(m_inline.begin(), m_inline.end());
+		overflow->push_back(packed);
+		m_overflow = std::move(overflow);
+	}
+
+	[[nodiscard]] bool Contains(const OwnerT& owner) const noexcept {
+		const uint64_t packed = Pack(owner);
+		if (m_overflow != nullptr) {
+			return std::find(m_overflow->begin(), m_overflow->end(), packed) != m_overflow->end();
+		}
+		return std::find(m_inline.begin(), m_inline.begin() + static_cast<ptrdiff_t>(m_inline_size),
+		                 packed) != m_inline.begin() + static_cast<ptrdiff_t>(m_inline_size);
+	}
+
+	[[nodiscard]] bool Erase(const OwnerT& owner) noexcept {
+		const uint64_t packed = Pack(owner);
+		if (m_overflow != nullptr) {
+			const auto found = std::find(m_overflow->begin(), m_overflow->end(), packed);
+			if (found == m_overflow->end()) {
+				return false;
+			}
+			m_overflow->erase(found);
+			if (m_overflow->size() == InlineCapacity) {
+				std::copy(m_overflow->begin(), m_overflow->end(), m_inline.begin());
+				m_inline_size = InlineCapacity;
+				m_overflow.reset();
+			}
+			return true;
+		}
+		const auto end   = m_inline.begin() + static_cast<ptrdiff_t>(m_inline_size);
+		const auto found = std::find(m_inline.begin(), end, packed);
+		if (found == end) {
+			return false;
+		}
+		std::move(found + 1, end, found);
+		--m_inline_size;
+		return true;
+	}
+
+	template <typename Func>
+	void ForEach(Func&& func) const {
+		if (m_overflow != nullptr) {
+			for (const uint64_t owner: *m_overflow) {
+				func(Unpack(owner));
+			}
+			return;
+		}
+		for (size_type index = 0; index < m_inline_size; ++index) {
+			func(Unpack(m_inline[index]));
+		}
+	}
+
+private:
+	[[nodiscard]] OwnerT At(size_type index) const noexcept {
+		return Unpack(m_overflow == nullptr ? m_inline[index] : (*m_overflow)[index]);
+	}
+	[[nodiscard]] static uint64_t Pack(const OwnerT& owner) noexcept {
+		uint64_t packed = 0;
+		std::memcpy(&packed, &owner, sizeof(owner));
+		return packed;
+	}
+	[[nodiscard]] static OwnerT Unpack(uint64_t packed) noexcept {
+		OwnerT owner {};
+		std::memcpy(&owner, &packed, sizeof(owner));
+		return owner;
+	}
+
+	std::array<uint64_t, InlineCapacity>   m_inline;
+	std::unique_ptr<std::vector<uint64_t>> m_overflow;
+	size_type                              m_inline_size = 0;
+};
+
 // Removes only the requested owner. Other owners in the same page entry remain intact.
 template <typename Container, typename Value>
 [[nodiscard]] bool EraseExact(Container& owners, const Value& owner) {
@@ -114,247 +267,6 @@ template <typename Container, typename Value>
 	return true;
 }
 
-// Multi-range ownership with 1 MiB candidate buckets and precise 4 KiB
-// lifetime accounting. OwnerT only needs equality.
-template <typename OwnerT>
-class MultiRangePageOwnerIndex final {
-private:
-	struct Registration;
-	using MembershipList = std::vector<const Registration*>;
-
-public:
-	struct ByteRange final {
-		uint64_t address = 0;
-		uint64_t size    = 0;
-	};
-
-	using CoarseTable   = MultiLevelPageTable<MembershipList, 20, 40, 10>;
-	using TrackingTable = MultiLevelPageTable<MembershipList, 12, 40, 18>;
-
-	[[nodiscard]] bool Register(const OwnerT& owner, const std::vector<ByteRange>& ranges) {
-		if (FindRegistration(owner) != m_registrations.end()) {
-			return false;
-		}
-		auto normalized = Normalize(ranges);
-		if (normalized.empty()) {
-			return false;
-		}
-		m_registrations.push_back({owner, std::move(normalized)});
-		const Registration* registration = &m_registrations.back();
-		for (const size_t page: CollectPages<20>(registration->ranges)) {
-			m_coarse_pages[page].push_back(registration);
-		}
-		for (const size_t page: CollectPages<12>(registration->ranges)) {
-			m_tracking_pages[page].push_back(registration);
-		}
-		return true;
-	}
-
-	// No state changes if an expected membership is absent. Final releases are
-	// sorted and coalesced 4 KiB spans whose final owner disappeared.
-	[[nodiscard]] bool Unregister(const OwnerT& owner, std::vector<ByteRange>& final_releases) {
-		final_releases.clear();
-		auto registration = FindRegistration(owner);
-		if (registration == m_registrations.end()) {
-			return false;
-		}
-		const auto          coarse_pages     = CollectPages<20>(registration->ranges);
-		const auto          tracking_pages   = CollectPages<12>(registration->ranges);
-		const Registration* registration_ptr = &*registration;
-		if (!HasAllMemberships(m_coarse_pages, coarse_pages, registration_ptr) ||
-		    !HasAllMemberships(m_tracking_pages, tracking_pages, registration_ptr)) {
-			return false;
-		}
-		std::vector<size_t> final_pages;
-		for (const size_t page: coarse_pages) {
-			(void)EraseExact(*m_coarse_pages.Find(page), registration_ptr);
-		}
-		for (const size_t page: tracking_pages) {
-			auto& owners = *m_tracking_pages.Find(page);
-			if (owners.size() == 1) {
-				final_pages.push_back(page);
-			}
-			(void)EraseExact(owners, registration_ptr);
-		}
-		m_registrations.erase(registration);
-		final_releases = CoalesceTrackingPages(final_pages);
-		return true;
-	}
-
-	[[nodiscard]] std::vector<OwnerT> Query(uint64_t address, uint64_t size) const {
-		return Query(address, size, [](const OwnerT&) { return true; });
-	}
-
-	template <typename Predicate>
-	[[nodiscard]] std::vector<OwnerT> Query(uint64_t address, uint64_t size,
-	                                        Predicate&& predicate) const {
-		return QueryImpl(address, size, true, std::forward<Predicate>(predicate));
-	}
-
-	// Fault paths use page candidates: exact byte-disjoint owners sharing a
-	// touched 4 KiB page are intentionally retained.
-	[[nodiscard]] std::vector<OwnerT> QueryCandidates(uint64_t address, uint64_t size) const {
-		return QueryCandidates(address, size, [](const OwnerT&) { return true; });
-	}
-
-	template <typename Predicate>
-	[[nodiscard]] std::vector<OwnerT> QueryCandidates(uint64_t address, uint64_t size,
-	                                                  Predicate&& predicate) const {
-		return QueryImpl(address, size, false, std::forward<Predicate>(predicate));
-	}
-
-	[[nodiscard]] size_t CoarseMembershipCount(size_t page) const {
-		const auto* owners = m_coarse_pages.Find(page);
-		return owners == nullptr ? 0 : owners->size();
-	}
-	[[nodiscard]] size_t TrackingMembershipCount(size_t page) const {
-		const auto* owners = m_tracking_pages.Find(page);
-		return owners == nullptr ? 0 : owners->size();
-	}
-
-private:
-	template <typename Predicate>
-	[[nodiscard]] std::vector<OwnerT> QueryImpl(uint64_t address, uint64_t size, bool strict_bytes,
-	                                            Predicate&& predicate) const {
-		typename CoarseTable::PageRange   coarse_range {};
-		typename TrackingTable::PageRange tracking_range {};
-		if (!CoarseTable::TryGetPageRange(address, size, coarse_range) ||
-		    (!strict_bytes && !TrackingTable::TryGetPageRange(address, size, tracking_range))) {
-			return {};
-		}
-		MembershipList candidates;
-		for (size_t page = coarse_range.first; page < coarse_range.last_exclusive; ++page) {
-			if (const auto* owners = m_coarse_pages.Find(page); owners != nullptr) {
-				AppendUnique(candidates, *owners);
-			}
-		}
-		std::vector<OwnerT> result;
-		for (const Registration* registration: candidates) {
-			if ((strict_bytes ? Overlaps(registration->ranges, address, size)
-			                  : HasTrackingMembership(registration, tracking_range)) &&
-			    predicate(registration->owner)) {
-				result.push_back(registration->owner);
-			}
-		}
-		return result;
-	}
-
-	struct Registration final {
-		OwnerT                 owner;
-		std::vector<ByteRange> ranges;
-	};
-	using RegistrationIterator      = typename std::list<Registration>::iterator;
-	using ConstRegistrationIterator = typename std::list<Registration>::const_iterator;
-
-	[[nodiscard]] RegistrationIterator FindRegistration(const OwnerT& owner) {
-		return std::find_if(m_registrations.begin(), m_registrations.end(),
-		                    [&](const Registration& item) { return item.owner == owner; });
-	}
-	[[nodiscard]] ConstRegistrationIterator FindRegistration(const OwnerT& owner) const {
-		return std::find_if(m_registrations.begin(), m_registrations.end(),
-		                    [&](const Registration& item) { return item.owner == owner; });
-	}
-
-	[[nodiscard]] static std::vector<ByteRange> Normalize(const std::vector<ByteRange>& ranges) {
-		std::vector<ByteRange> sorted;
-		for (const auto& range: ranges) {
-			typename CoarseTable::PageRange ignored {};
-			if (!CoarseTable::TryGetPageRange(range.address, range.size, ignored)) {
-				return {};
-			}
-			sorted.push_back(range);
-		}
-		std::sort(sorted.begin(), sorted.end(), [](const ByteRange& lhs, const ByteRange& rhs) {
-			return lhs.address < rhs.address;
-		});
-		std::vector<ByteRange> merged;
-		for (const auto& range: sorted) {
-			if (merged.empty() || range.address > merged.back().address + merged.back().size) {
-				merged.push_back(range);
-			} else {
-				const uint64_t end = std::max(merged.back().address + merged.back().size,
-				                              range.address + range.size);
-				merged.back().size = end - merged.back().address;
-			}
-		}
-		return merged;
-	}
-
-	template <size_t Bits>
-	[[nodiscard]] static std::vector<size_t> CollectPages(const std::vector<ByteRange>& ranges) {
-		std::vector<size_t> pages;
-		for (const auto& range: ranges) {
-			const size_t first = static_cast<size_t>(range.address >> Bits);
-			const size_t last  = static_cast<size_t>((range.address + range.size - 1) >> Bits);
-			for (size_t page = first; page <= last; ++page) {
-				pages.push_back(page);
-			}
-		}
-		std::sort(pages.begin(), pages.end());
-		pages.erase(std::unique(pages.begin(), pages.end()), pages.end());
-		return pages;
-	}
-
-	template <typename Table>
-	[[nodiscard]] static bool HasAllMemberships(const Table&               table,
-	                                            const std::vector<size_t>& pages,
-	                                            const Registration*        registration) {
-		for (const size_t page: pages) {
-			const auto* owners = table.Find(page);
-			if (owners == nullptr ||
-			    std::find(owners->begin(), owners->end(), registration) == owners->end()) {
-				return false;
-			}
-		}
-		return true;
-	}
-
-	[[nodiscard]] bool HasTrackingMembership(const Registration*                      registration,
-	                                         const typename TrackingTable::PageRange& range) const {
-		for (size_t page = range.first; page < range.last_exclusive; ++page) {
-			const auto* owners = m_tracking_pages.Find(page);
-			if (owners != nullptr &&
-			    std::find(owners->begin(), owners->end(), registration) != owners->end()) {
-				return true;
-			}
-		}
-		return false;
-	}
-
-	[[nodiscard]] static bool Overlaps(const std::vector<ByteRange>& ranges, uint64_t address,
-	                                   uint64_t size) {
-		const uint64_t end = address + size;
-		return std::any_of(ranges.begin(), ranges.end(), [&](const ByteRange& range) {
-			return range.address < end && address < range.address + range.size;
-		});
-	}
-	static void AppendUnique(MembershipList& destination, const MembershipList& source) {
-		for (const Registration* registration: source) {
-			if (std::find(destination.begin(), destination.end(), registration) ==
-			    destination.end()) {
-				destination.push_back(registration);
-			}
-		}
-	}
-	[[nodiscard]] static std::vector<ByteRange>
-	CoalesceTrackingPages(const std::vector<size_t>& pages) {
-		std::vector<ByteRange> result;
-		for (const size_t page: pages) {
-			const uint64_t address = static_cast<uint64_t>(page) << 12;
-			if (!result.empty() && result.back().address + result.back().size == address) {
-				result.back().size += uint64_t {1} << 12;
-			} else {
-				result.push_back({address, uint64_t {1} << 12});
-			}
-		}
-		return result;
-	}
-
-	CoarseTable             m_coarse_pages;
-	TrackingTable           m_tracking_pages;
-	std::list<Registration> m_registrations;
-};
-
 } // namespace Libs::Graphics
 
 #endif // EMULATOR_SRC_GRAPHICS_HOST_GPU_RENDERER_MULTILEVELPAGETABLE_H_

src/graphics/host_gpu/renderer/cache/resourceMutex.cpp

@@ -4,18 +4,10 @@
 
 namespace Libs::Graphics {
 
-ResourceMutex::FaultScope::FaultScope(ResourceMutex& mutex): m_mutex(mutex) {
-	m_resource_preowned = m_mutex.BeginFault();
-}
-
-ResourceMutex::FaultScope::~FaultScope() {
-	m_mutex.EndFault(m_resource_preowned);
-}
-
 ResourceMutex::~ResourceMutex() {
 	std::lock_guard state(m_state);
-	if (m_resource_owner != std::thread::id {} || m_fault_owner != std::thread::id {}) {
-		EXIT("ResourceMutex destroyed with an active owner or fault transaction\n");
+	if (m_resource_owner != std::thread::id {}) {
+		EXIT("ResourceMutex destroyed with an active owner\n");
 	}
 }
 
@@ -26,9 +18,6 @@ void ResourceMutex::lock() {
 		if (m_resource_owner == current) {
 			EXIT("recursive resource transaction\n");
 		}
-		if (m_fault_owner == current) {
-			EXIT("resource transaction re-entered from a page-fault callback\n");
-		}
 	}
 	m_resource.lock();
 	std::lock_guard state(m_state);
@@ -55,39 +44,4 @@ bool ResourceMutex::IsOwnedByCurrentThread() {
 	return m_resource_owner == std::this_thread::get_id();
 }
 
-bool ResourceMutex::BeginFault() {
-	const auto current = std::this_thread::get_id();
-	{
-		std::lock_guard state(m_state);
-		if (m_fault_owner == current) {
-			EXIT("nested resource page-fault transaction\n");
-		}
-		if (m_resource_owner == current) {
-			m_fault_owner = current;
-			return true;
-		}
-	}
-	lock();
-	std::lock_guard state(m_state);
-	if (m_resource_owner != current || m_fault_owner != std::thread::id {}) {
-		EXIT("resource fault transaction acquired inconsistent ownership\n");
-	}
-	m_fault_owner = current;
-	return false;
-}
-
-void ResourceMutex::EndFault(bool resource_preowned) {
-	const auto current = std::this_thread::get_id();
-	{
-		std::lock_guard state(m_state);
-		if (m_fault_owner != current || m_resource_owner != current) {
-			EXIT("resource page-fault transaction ended with inconsistent ownership\n");
-		}
-		m_fault_owner = {};
-	}
-	if (!resource_preowned) {
-		unlock();
-	}
-}
-
 } // namespace Libs::Graphics

src/graphics/host_gpu/renderer/cache/resourceMutex.h

@@ -8,21 +8,9 @@
 
 namespace Libs::Graphics {
 
-// Owner-tracked shared buffer/image transaction. External faults pause GPU submissions first;
-// command-processor faults drain pending guest processors before entering this transaction.
+// Owner-tracked shared buffer/image transaction.
 class ResourceMutex final {
 public:
-	class FaultScope final {
-	public:
-		explicit FaultScope(ResourceMutex& mutex);
-		~FaultScope();
-		KYTY_CLASS_NO_COPY(FaultScope);
-
-	private:
-		ResourceMutex& m_mutex;
-		bool           m_resource_preowned = false;
-	};
-
 	ResourceMutex() = default;
 	~ResourceMutex();
 	KYTY_CLASS_NO_COPY(ResourceMutex);
@@ -32,15 +20,9 @@ public:
 	[[nodiscard]] bool IsOwnedByCurrentThread();
 
 private:
-	friend class FaultScope;
-
-	[[nodiscard]] bool BeginFault();
-	void               EndFault(bool resource_preowned);
-
 	std::mutex      m_resource;
 	std::mutex      m_state;
 	std::thread::id m_resource_owner;
-	std::thread::id m_fault_owner;
 };
 
 } // namespace Libs::Graphics

src/graphics/host_gpu/renderer/cache/textureCache.cpp

@@ -195,10 +195,12 @@ void TextureCache::RegisterImage(ImageId id) {
 	if (image.registered || image.info.data.Empty()) {
 		EXIT("TextureCache: invalid image registration\n");
 	}
-	std::vector<ImageOwnerIndex::ByteRange> ranges;
-	ranges.push_back({image.info.data.address, image.info.data.size});
-	if (!m_image_owner_index.Register(id, ranges)) {
-		EXIT("TextureCache: duplicate or invalid image registration\n");
+	ImagePageTable::PageRange pages {};
+	if (!ImagePageTable::TryGetPageRange(image.info.data.address, image.info.data.size, pages)) {
+		EXIT("TextureCache: image registration is outside the guest address space\n");
+	}
+	for (size_t page = pages.first; page < pages.last_exclusive; ++page) {
+		m_image_page_table[page].push_back(id);
 	}
 	image.registered = true;
 	image.lru_id     = m_lru_cache.Insert(id, m_gc_tick);
@@ -211,9 +213,15 @@ void TextureCache::UnregisterImage(ImageId id) {
 		return;
 	}
 	UntrackImage(id);
-	std::vector<ImageOwnerIndex::ByteRange> releases;
-	if (!m_image_owner_index.Unregister(id, releases)) {
-		EXIT("TextureCache: image missing from owner index\n");
+	ImagePageTable::PageRange pages {};
+	if (!ImagePageTable::TryGetPageRange(image.info.data.address, image.info.data.size, pages)) {
+		EXIT("TextureCache: registered image is outside the guest address space\n");
+	}
+	for (size_t page = pages.first; page < pages.last_exclusive; ++page) {
+		auto* owners = m_image_page_table.Find(page);
+		if (owners == nullptr || !owners->Erase(id)) {
+			EXIT("TextureCache: image missing from page owner index\n");
+		}
 	}
 	m_lru_cache.Free(image.lru_id);
 	const auto accounted = image.AccountedSize();
@@ -451,10 +459,48 @@ const Image& TextureCache::GetImage(ImageId id) const {
 	return ResolveImage(id);
 }
 
-std::vector<ImageId> TextureCache::FindImagesInRegion(uint64_t address, uint64_t size,
-                                                      bool page_overlap) const {
-	return page_overlap ? m_image_owner_index.QueryCandidates(address, size)
-	                    : m_image_owner_index.Query(address, size);
+TextureCache::ImageIds TextureCache::FindImagesInRegion(uint64_t address, uint64_t size,
+                                                        bool page_overlap) const {
+	ImagePageTable::PageRange pages {};
+	if (!ImagePageTable::TryGetPageRange(address, size, pages)) {
+		return {};
+	}
+
+	uint32_t query_epoch = ++m_image_query_epoch;
+	if (query_epoch == 0) {
+		for (const auto& slot: m_slots) {
+			if (slot.image != nullptr) {
+				slot.image->query_epoch = 0;
+			}
+		}
+		query_epoch = ++m_image_query_epoch;
+	}
+
+	ImageIds result;
+	for (size_t page = pages.first; page < pages.last_exclusive; ++page) {
+		const auto* owners = m_image_page_table.Find(page);
+		if (owners == nullptr) {
+			continue;
+		}
+		owners->ForEach([&](ImageId id) {
+			if (!id || id.index >= m_slots.size()) {
+				return;
+			}
+			const auto& slot = m_slots[id.index];
+			if (slot.generation != id.generation || slot.image == nullptr) {
+				return;
+			}
+			auto& image = *slot.image;
+			if (image.query_epoch == query_epoch) {
+				return;
+			}
+			image.query_epoch = query_epoch;
+			if (image.Overlaps(address, size, page_overlap)) {
+				result.push_back(id);
+			}
+		});
+	}
+	return result;
 }
 
 ImageId TextureCache::GetNullImage(const ImageDesc& desc) {
@@ -1152,9 +1198,9 @@ ImageId TextureCache::FindImage(ImageDesc& desc, bool exact_format) {
 	ImageId result {};
 	bool    inserted_new = false;
 	{
-		std::lock_guard            transaction(m_resource_mutex);
-		CacheLock                  lock(*this, m_lock);
-		const std::vector<ImageId> candidates =
+		std::lock_guard transaction(m_resource_mutex);
+		CacheLock       lock(*this, m_lock);
+		const auto      candidates =
 		    FindImagesInRegion(desc.info.data.address, desc.info.data.size, false);
 
 		for (const auto id: candidates) {

src/graphics/host_gpu/renderer/cache/textureCache.h

@@ -99,7 +99,8 @@ private:
 		int32_t layer = -1;
 	};
 
-	using ImageOwnerIndex = MultiRangePageOwnerIndex<ImageId>;
+	using ImageIds       = InlinePageOwnerList<ImageId, 16>;
+	using ImagePageTable = MultiLevelPageTable<ImageIds, 20, 40, 10>;
 
 	[[nodiscard]] Image&                 ResolveImage(ImageId id);
 	[[nodiscard]] const Image&           ResolveImage(ImageId id) const;
@@ -125,8 +126,9 @@ private:
 	[[nodiscard]] static BindingType UploadBinding(const Image& image);
 	[[nodiscard]] bool               SafeToDownload(const Image& image);
 
-	[[nodiscard]] std::vector<ImageId> FindImagesInRegion(uint64_t address, uint64_t size,
-	                                                      bool page_overlap) const;
+	// Caller holds m_lock; it also serializes the per-image query epoch.
+	[[nodiscard]] ImageIds      FindImagesInRegion(uint64_t address, uint64_t size,
+	                                               bool page_overlap) const;
 	[[nodiscard]] OverlapResult ResolveOverlap(const ImageInfo& requested, BindingType binding,
 	                                           ImageId cached, ImageId merged);
 	[[nodiscard]] ImageId       ResolveDepthOverlap(const ImageInfo& requested, BindingType binding,
@@ -169,7 +171,7 @@ private:
 	ResourceMutex&                                    m_resource_mutex;
 	std::vector<Slot>                                 m_slots;
 	std::vector<uint32_t>                             m_free_slots;
-	ImageOwnerIndex                                   m_image_owner_index;
+	ImagePageTable                                    m_image_page_table;
 	std::map<vk::Format, ImageId>                     m_null_images;
 	Common::LeastRecentlyUsedCache<ImageId, uint64_t> m_lru_cache;
 	std::set<ImageId>                                 m_download_images;
@@ -177,9 +179,10 @@ private:
 	uint64_t                                          m_total_used_memory  = 0;
 	uint64_t                                          m_trigger_gc_memory  = 0;
 	uint64_t                                          m_pressure_gc_memory = 1536ull * 1024 * 1024;
-	uint64_t m_critical_gc_memory     = 3ull * 1024 * 1024 * 1024;
-	uint64_t m_gc_tick                = 0;
-	bool     m_readback_linear_images = false;
+	uint64_t         m_critical_gc_memory     = 3ull * 1024 * 1024 * 1024;
+	uint64_t         m_gc_tick                = 0;
+	mutable uint32_t m_image_query_epoch      = 0;
+	bool             m_readback_linear_images = false;
 
 	friend struct TextureCacheTestAccess;
 	friend class BufferCache;

src/graphics/host_gpu/renderer/image/image.h

@@ -154,17 +154,18 @@ public:
 	}
 	[[nodiscard]] uint64_t HashGuestEdges() const;
 
-	ImageInfo      info;
-	VulkanImage    backing;
-	ImageViewCache views;
-	ImageUsage     usage;
-	ImageBinding   binding;
-	bool           registered     = false;
-	uint64_t       track_addr     = 0;
-	uint64_t       track_addr_end = 0;
-	ImageId        depth_id {};
-	uint64_t       tick_accessed_last = 0;
-	size_t         lru_id             = 0;
+	ImageInfo        info;
+	VulkanImage      backing;
+	ImageViewCache   views;
+	ImageUsage       usage;
+	ImageBinding     binding;
+	bool             registered     = false;
+	mutable uint32_t query_epoch    = 0;
+	uint64_t         track_addr     = 0;
+	uint64_t         track_addr_end = 0;
+	ImageId          depth_id {};
+	uint64_t         tick_accessed_last = 0;
+	size_t           lru_id             = 0;
 
 private:
 	friend struct ImageTestAccess;

src/graphics/host_gpu/renderer/image/textureCommon.cpp

@@ -22,6 +22,10 @@ struct RenderTargetFormatMapping {
 };
 
 constexpr RenderTargetFormatMapping kRenderTargetFormats[] = {
+    {Prospero::ChannelLayout::k8,
+     Prospero::ChannelType::kUInt,
+     Prospero::ChannelOrder::kStandard,
+     {vk::Format::eR8Uint, 1}},
     {Prospero::ChannelLayout::k8_8,
      Prospero::ChannelType::kUNorm,
      Prospero::ChannelOrder::kStandard,

src/graphics/host_gpu/renderer/pipeline/descriptors.cpp

@@ -379,6 +379,10 @@ static bool IsSupportedStorageTextureDescriptor(const ShaderRecompiler::IR::Imag
 	    tile == Prospero::GpuEnumValue(Prospero::TileMode::kDepth) && !resource.read &&
 	    !Prospero::IsFmaskTextureFormat(descriptor.Format()) && (is_2d || is_2d_array) &&
 	    TileGetBlockLayout(TileBlockFamily::Depth64KB, depth_bpe, depth_block);
+	const bool supported_standard_256b =
+	    (is_2d || is_2d_array) &&
+	    tile == Prospero::GpuEnumValue(Prospero::TileMode::kStandard256B) &&
+	    TileIsStandard256BTextureSupported(descriptor.Format());
 	const bool supported_standard_tile =
 	    (tile == Prospero::GpuEnumValue(Prospero::TileMode::kStandard4KB) &&
 	     TileIsStandard4KBTextureSupported(descriptor.Format())) ||
@@ -386,7 +390,8 @@ static bool IsSupportedStorageTextureDescriptor(const ShaderRecompiler::IR::Imag
 	     TileIsStandard64KBTextureSupported(descriptor.Format()));
 	const bool supported_tile = tile == Prospero::GpuEnumValue(Prospero::TileMode::kLinear) ||
 	                            tile == Prospero::GpuEnumValue(Prospero::TileMode::kRenderTarget) ||
-	                            supported_depth_tile || supported_standard_tile;
+	                            supported_depth_tile || supported_standard_256b ||
+	                            supported_standard_tile;
 	const auto swizzle        = descriptor.DstSelXYZW();
 	const bool supported_swizzle =
 	    IsValidImageSwizzle(swizzle) &&

src/graphics/host_gpu/renderer/renderDraw.cpp

@@ -664,12 +664,10 @@ struct DrawIndexBufferSource {
 
 struct PreparedIndexBuffer {
 	std::shared_ptr<void> owner;
-	vk::Buffer            buffer   = nullptr;
-	uint64_t              address  = 0;
-	uint64_t              size     = 0;
-	vk::DeviceSize        offset   = 0;
-	vk::IndexType         type     = vk::IndexType::eUint16;
-	bool                  streamed = false;
+	vk::Buffer            buffer = nullptr;
+	uint64_t              size   = 0;
+	vk::DeviceSize        offset = 0;
+	vk::IndexType         type   = vk::IndexType::eUint16;
 };
 
 static uint64_t VertexBufferDescriptorSize(const ShaderVertexInputBuffer& buffer) {
@@ -896,12 +894,6 @@ static std::vector<BufferBinding> PrepareVertexBuffers(uint64_t
 	return AcquireVertexBuffers(buffer, vs_input_info);
 }
 
-static void RebindVertexBuffers(RenderCommandBuffer&         buffer,
-                                const ShaderVertexInputInfo& vs_input_info,
-                                std::vector<BufferBinding>&  bindings) {
-	bindings = AcquireVertexBuffers(buffer, vs_input_info);
-}
-
 static PreparedIndexBuffer PrepareIndexBuffer(RenderCommandBuffer&         buffer,
                                               const DrawIndexBufferSource& source) {
 	PreparedIndexBuffer prepared;
@@ -909,16 +901,14 @@ static PreparedIndexBuffer PrepareIndexBuffer(RenderCommandBuffer&         buffe
 		return prepared;
 	}
 	EXIT_IF(source.size == 0);
-	prepared.address = source.address;
-	prepared.size    = source.size;
-	prepared.type    = source.type;
+	prepared.size = source.size;
+	prepared.type = source.type;
 	if (source.host_data != nullptr) {
 		auto binding =
 		    buffer.GetContext().GetBufferCache().UploadTransient(source.host_data, source.size, 16);
-		prepared.owner    = std::move(binding.owner);
-		prepared.buffer   = binding.buffer;
-		prepared.offset   = binding.offset;
-		prepared.streamed = true;
+		prepared.owner  = std::move(binding.owner);
+		prepared.buffer = binding.buffer;
+		prepared.offset = binding.offset;
 	} else {
 		auto binding =
 		    buffer.GetContext().GetBufferCache().ObtainBuffer(buffer, source.address, source.size);
@@ -929,17 +919,6 @@ static PreparedIndexBuffer PrepareIndexBuffer(RenderCommandBuffer&         buffe
 	return prepared;
 }
 
-static void RebindIndexBuffer(RenderCommandBuffer& buffer, PreparedIndexBuffer& prepared) {
-	if (prepared.size == 0 || prepared.streamed) {
-		return;
-	}
-	auto binding =
-	    buffer.GetContext().GetBufferCache().ObtainBuffer(buffer, prepared.address, prepared.size);
-	prepared.owner  = std::move(binding.owner);
-	prepared.buffer = binding.buffer;
-	prepared.offset = binding.offset;
-}
-
 static void CommitVertexBuffers(RenderCommandBuffer& buffer, vk::CommandBuffer vk_buffer,
                                 std::vector<BufferBinding>& bindings) {
 	for (uint32_t slot = 0; slot < bindings.size(); slot++) {
@@ -1046,8 +1025,6 @@ void RenderExecutor::ExecutePreparedDraw(uint64_t submit_id, RenderCommandBuffer
 	                                               state.ps_input_info.stage, state.ps_active);
 	auto vertex_bindings = PrepareVertexBuffers(submit_id, buffer, draw, state.vs_input_info);
 	auto index_binding   = PrepareIndexBuffer(buffer, index_source);
-	RebindVertexBuffers(buffer, state.vs_input_info, vertex_bindings);
-	RebindIndexBuffer(buffer, index_binding);
 	state.rendering =
 	    AcquireRenderTargets(buffer, state.color_info, state.color_count, state.depth_info);
 

src/graphics/presentation/imeDialogOverlay.cpp

@@ -0,0 +1,876 @@
+#include "graphics/presentation/imeDialogOverlay.h"
+
+#include "SDL.h"
+#include "common/assert.h"
+#include "common/stringUtils.h"
+#include "graphics/host_gpu/graphicContext.h"
+#include "imgui.h"
+#include "imgui_impl_vulkan.h"
+#include "libs/controller.h"
+#include "libs/imeDialog.h"
+
+#include <algorithm>
+#include <array>
+#include <atomic>
+#include <chrono>
+#include <cmath>
+#include <cstdint>
+#include <deque>
+#include <mutex>
+#include <span>
+#include <string>
+#include <string_view>
+#include <utility>
+
+namespace Libs::Graphics {
+
+namespace {
+
+namespace Ime = Libs::Dialog::ImeDialog;
+
+constexpr size_t INPUT_QUEUE_CAPACITY = 128;
+
+enum class InputKind : uint8_t {
+	Button,
+	Axis,
+	MousePosition,
+	MouseButton,
+	MouseWheel,
+	ResetController
+};
+
+struct InputEvent {
+	InputKind kind;
+	uint64_t  generation;
+	int       id;
+	float     x;
+	float     y;
+};
+
+struct VisibilityUpdate {
+	uint64_t generation;
+	bool     visible;
+	bool     capture_controller;
+	bool     capture_keyboard;
+	bool     multiline;
+};
+
+std::atomic<Uint32>          g_visibility_event {static_cast<Uint32>(-1)};
+std::mutex                   g_visibility_mutex;
+std::mutex                   g_input_mutex;
+std::deque<InputEvent>       g_input_events;
+std::deque<VisibilityUpdate> g_visibility_updates;
+size_t                       g_missing_visibility_wakeups = 0;
+bool                         g_input_reset_requested      = false;
+uint16_t                     g_last_external_keycode      = 0;
+uint32_t                     g_last_external_status       = 0;
+uint64_t                     g_input_generation           = 0;
+bool                         g_input_active               = false;
+bool                         g_input_controller           = false;
+bool                         g_input_keyboard             = false;
+bool                         g_input_multiline            = false;
+bool                         g_input_lifecycle_active     = false;
+bool                         g_active                     = false;
+bool                         g_controller_captured        = false;
+uint64_t                     g_generation                 = 0;
+
+void ClearInputEvents() {
+	std::scoped_lock lock(g_input_mutex);
+	g_input_events.clear();
+	g_input_reset_requested = false;
+}
+
+void QueueInput(InputEvent event) {
+	std::scoped_lock lock(g_input_mutex);
+	const bool       replaceable =
+	    event.kind == InputKind::Axis || event.kind == InputKind::MousePosition;
+	if (replaceable && !g_input_events.empty()) {
+		auto& last = g_input_events.back();
+		if (last.generation == event.generation && last.kind == event.kind && last.id == event.id) {
+			last = event;
+			return;
+		}
+	}
+	if (g_input_events.size() == INPUT_QUEUE_CAPACITY) {
+		g_input_events.clear();
+		g_input_reset_requested = true;
+	}
+	g_input_events.push_back(event);
+}
+
+void RetryVisibilityWakeup() {
+	const Uint32 type = g_visibility_event.load(std::memory_order_acquire);
+	if (type == static_cast<Uint32>(-1)) {
+		return;
+	}
+	std::scoped_lock lock(g_input_mutex);
+	if (g_missing_visibility_wakeups == 0) {
+		return;
+	}
+	SDL_Event event {};
+	event.type = type;
+	if (SDL_PushEvent(&event) > 0) {
+		g_missing_visibility_wakeups--;
+	}
+}
+
+void OnVisibilityChanged(bool visible, uint64_t generation) {
+	std::scoped_lock visibility_lock(g_visibility_mutex);
+	if (!g_input_lifecycle_active) {
+		return;
+	}
+	if (generation < g_generation || (generation == g_generation && visible == g_active)) {
+		return;
+	}
+
+	g_generation            = generation;
+	bool capture_controller = false;
+	bool capture_keyboard   = false;
+	bool multiline          = false;
+	if (visible) {
+		Ime::HostSnapshot snapshot;
+		if (Ime::GetHostSnapshot(&snapshot) && snapshot.generation == generation) {
+			capture_controller = (snapshot.disable_device & Ime::DISABLE_DEVICE_CONTROLLER) == 0;
+			capture_keyboard   = (snapshot.disable_device & Ime::DISABLE_DEVICE_EXT_KEYBOARD) == 0;
+			multiline          = (snapshot.option & Ime::OPTION_MULTILINE) != 0;
+		} else {
+			visible = false;
+		}
+	}
+	const bool was_controller = std::exchange(g_controller_captured, capture_controller);
+	if (capture_controller || was_controller) {
+		Controller::ControllerResetInputState();
+	}
+	g_active = visible;
+
+	const Uint32 type = g_visibility_event.load(std::memory_order_acquire);
+	if (type != static_cast<Uint32>(-1)) {
+		SDL_Event event {};
+		event.type = type;
+		std::scoped_lock input_lock(g_input_mutex);
+		g_visibility_updates.push_back(
+		    {generation, visible, capture_controller, capture_keyboard, multiline});
+		if (g_missing_visibility_wakeups != 0 || SDL_PushEvent(&event) <= 0) {
+			g_missing_visibility_wakeups++;
+		}
+	}
+}
+
+uint32_t ExternalKeyStatus(SDL_Keymod modifiers, bool character_valid) {
+	uint32_t status = 0x00000001 | (character_valid ? 0x00000002 : 0);
+	if ((modifiers & KMOD_LCTRL) != 0) status |= 0x00000100;
+	if ((modifiers & KMOD_LSHIFT) != 0) status |= 0x00000200;
+	if ((modifiers & KMOD_LALT) != 0) status |= 0x00000400;
+	if ((modifiers & KMOD_LGUI) != 0) status |= 0x00000800;
+	if ((modifiers & KMOD_RCTRL) != 0) status |= 0x00001000;
+	if ((modifiers & KMOD_RSHIFT) != 0) status |= 0x00002000;
+	if ((modifiers & KMOD_RALT) != 0) status |= 0x00004000;
+	if ((modifiers & KMOD_RGUI) != 0) status |= 0x00008000;
+	if ((modifiers & KMOD_NUM) != 0) status |= 0x00010000;
+	if ((modifiers & KMOD_CAPS) != 0) status |= 0x00020000;
+	return status;
+}
+
+Ime::ExternalInput MakeExternalInput(Ime::ExternalAction action, uint16_t keycode,
+                                     uint32_t status) {
+	Ime::ExternalInput input {};
+	input.key.keycode = keycode;
+	input.key.status  = status;
+	input.key.type    = 4;
+	input.action      = action;
+	return input;
+}
+
+std::u16string Utf8ToUtf16(std::string_view text) {
+	std::u16string result;
+	result.reserve(text.size());
+	for (size_t i = 0; i < text.size();) {
+		const auto first     = static_cast<uint8_t>(text[i++]);
+		uint32_t   codepoint = 0;
+		uint32_t   remaining = 0;
+		if (first < 0x80) {
+			codepoint = first;
+		} else if ((first & 0xe0) == 0xc0) {
+			codepoint = first & 0x1f;
+			remaining = 1;
+		} else if ((first & 0xf0) == 0xe0) {
+			codepoint = first & 0x0f;
+			remaining = 2;
+		} else if ((first & 0xf8) == 0xf0) {
+			codepoint = first & 0x07;
+			remaining = 3;
+		} else {
+			continue;
+		}
+		if (i + remaining > text.size()) {
+			break;
+		}
+		bool valid = true;
+		for (uint32_t j = 0; j < remaining; j++) {
+			const auto next = static_cast<uint8_t>(text[i++]);
+			if ((next & 0xc0) != 0x80) {
+				valid = false;
+				break;
+			}
+			codepoint = (codepoint << 6) | (next & 0x3f);
+		}
+		if (!valid || codepoint > 0x10ffff || (codepoint >= 0xd800 && codepoint <= 0xdfff)) {
+			continue;
+		}
+		if (codepoint <= 0xffff) {
+			result.push_back(static_cast<char16_t>(codepoint));
+		} else {
+			codepoint -= 0x10000;
+			result.push_back(static_cast<char16_t>(0xd800 + (codepoint >> 10)));
+			result.push_back(static_cast<char16_t>(0xdc00 + (codepoint & 0x3ff)));
+		}
+	}
+	return result;
+}
+
+std::string VisibleText(const Ime::HostSnapshot& snapshot, size_t max_units) {
+	const size_t cursor        = std::min<size_t>(snapshot.cursor, snapshot.text.size());
+	const size_t payload_units = max_units > 4 ? max_units - 4 : 1;
+	size_t       begin         = cursor > payload_units / 2 ? cursor - payload_units / 2 : 0;
+	size_t       end           = std::min(snapshot.text.size(), begin + payload_units);
+	if (end == snapshot.text.size() && end - begin < payload_units) {
+		begin = end > payload_units ? end - payload_units : 0;
+	}
+	if (begin > 0 && snapshot.text[begin] >= 0xdc00 && snapshot.text[begin] <= 0xdfff) {
+		begin--;
+	}
+	if (end < snapshot.text.size() && end > begin && snapshot.text[end - 1] >= 0xd800 &&
+	    snapshot.text[end - 1] <= 0xdbff) {
+		end--;
+	}
+
+	std::u16string visible;
+	if (begin != 0) {
+		visible.push_back(u'\u2026');
+	}
+	const size_t caret = visible.size() + cursor - begin;
+	if ((snapshot.option & Ime::OPTION_PASSWORD) != 0) {
+		visible.append(end - begin, u'*');
+	} else {
+		visible.append(snapshot.text, begin, end - begin);
+		std::replace(visible.begin(), visible.end(), u'\n', u'\u21b5');
+		std::replace(visible.begin(), visible.end(), u'\r', u'\u21b5');
+	}
+	visible.insert(std::min(caret, visible.size()), 1, u'|');
+	if (end != snapshot.text.size()) {
+		visible.push_back(u'\u2026');
+	}
+	return Common::Utf16ToUtf8(visible.c_str());
+}
+
+const char* EnterLabel(Ime::EnterLabel label) {
+	switch (label) {
+		case Ime::EnterLabel::Send: return "Send";
+		case Ime::EnterLabel::Search: return "Search";
+		case Ime::EnterLabel::Go: return "Go";
+		default: return "Done";
+	}
+}
+
+float AlignmentPivot(Ime::Alignment alignment) {
+	switch (alignment) {
+		case Ime::Alignment::Start: return 0.0f;
+		case Ime::Alignment::End: return 1.0f;
+		default: return 0.5f;
+	}
+}
+
+ImGuiKey ControllerButtonToKey(int button) {
+	switch (button) {
+		case SDL_CONTROLLER_BUTTON_A: return ImGuiKey_GamepadFaceDown;
+		case SDL_CONTROLLER_BUTTON_B: return ImGuiKey_GamepadFaceRight;
+		case SDL_CONTROLLER_BUTTON_X: return ImGuiKey_GamepadFaceLeft;
+		case SDL_CONTROLLER_BUTTON_Y: return ImGuiKey_GamepadFaceUp;
+		case SDL_CONTROLLER_BUTTON_DPAD_LEFT: return ImGuiKey_GamepadDpadLeft;
+		case SDL_CONTROLLER_BUTTON_DPAD_RIGHT: return ImGuiKey_GamepadDpadRight;
+		case SDL_CONTROLLER_BUTTON_DPAD_UP: return ImGuiKey_GamepadDpadUp;
+		case SDL_CONTROLLER_BUTTON_DPAD_DOWN: return ImGuiKey_GamepadDpadDown;
+		default: return ImGuiKey_None;
+	}
+}
+
+PFN_vkVoidFunction LoadVulkanFunction(const char* name, void* user_data) {
+	auto& graphics = *static_cast<GraphicContext*>(user_data);
+	return graphics.instance.getProcAddr(name);
+}
+
+void CheckVulkanResult(VkResult result) {
+	EXIT_IF(result != VK_SUCCESS);
+}
+
+} // namespace
+
+void InitializeImeDialogInput() {
+	const Uint32 type = SDL_RegisterEvents(1);
+	EXIT_IF(type == static_cast<Uint32>(-1));
+	{
+		std::scoped_lock lock(g_visibility_mutex);
+		g_input_lifecycle_active = true;
+		g_visibility_event.store(type, std::memory_order_release);
+	}
+	Ime::SetVisibilityCallback(OnVisibilityChanged);
+	Ime::HostSnapshot snapshot;
+	if (Ime::GetHostSnapshot(&snapshot)) {
+		OnVisibilityChanged(true, snapshot.generation);
+	}
+}
+
+void ShutdownImeDialogInput() {
+	Ime::SetVisibilityCallback(nullptr);
+	{
+		std::scoped_lock lock(g_visibility_mutex);
+		g_input_lifecycle_active = false;
+		g_active                 = false;
+		if (std::exchange(g_controller_captured, false)) {
+			Controller::ControllerResetInputState();
+		}
+		g_visibility_event.store(static_cast<Uint32>(-1), std::memory_order_release);
+	}
+	ClearInputEvents();
+	{
+		std::scoped_lock lock(g_input_mutex);
+		g_visibility_updates.clear();
+		g_missing_visibility_wakeups = 0;
+	}
+	g_input_active     = false;
+	g_input_controller = false;
+	g_input_keyboard   = false;
+	g_input_multiline  = false;
+	if (SDL_IsTextInputActive() == SDL_TRUE) {
+		SDL_StopTextInput();
+	}
+}
+
+bool ProcessImeDialogInput(const SDL_Event& event) {
+	RetryVisibilityWakeup();
+	if (event.type == g_visibility_event.load(std::memory_order_acquire)) {
+		VisibilityUpdate update {};
+		{
+			std::scoped_lock lock(g_input_mutex);
+			if (g_visibility_updates.empty()) {
+				return true;
+			}
+			update = g_visibility_updates.front();
+			g_visibility_updates.pop_front();
+		}
+		ClearInputEvents();
+		g_last_external_keycode = 0;
+		g_last_external_status  = 0;
+		g_input_generation      = update.generation;
+		g_input_active          = update.visible;
+		g_input_controller      = update.capture_controller;
+		g_input_keyboard        = update.capture_keyboard;
+		g_input_multiline       = update.multiline;
+		if (g_input_keyboard) {
+			SDL_StartTextInput();
+		} else if (SDL_IsTextInputActive() == SDL_TRUE) {
+			SDL_StopTextInput();
+		}
+		return true;
+	}
+	if (event.type == SDL_CONTROLLERDEVICEREMOVED) {
+		if (g_input_active && g_input_controller) {
+			QueueInput({InputKind::ResetController, g_input_generation, 0, 0.0f, 0.0f});
+		}
+		return false;
+	}
+	if (!g_input_active) {
+		return false;
+	}
+
+	const uint64_t generation       = g_input_generation;
+	const bool     controller_event = event.type == SDL_CONTROLLERBUTTONDOWN ||
+	                                  event.type == SDL_CONTROLLERBUTTONUP ||
+	                                  event.type == SDL_CONTROLLERAXISMOTION;
+	if (controller_event && !g_input_controller) {
+		return false;
+	}
+	const bool keyboard_event = event.type == SDL_TEXTINPUT || event.type == SDL_TEXTEDITING ||
+	                            event.type == SDL_KEYDOWN || event.type == SDL_KEYUP;
+	if (keyboard_event && !g_input_keyboard) {
+		return false;
+	}
+	switch (event.type) {
+		case SDL_TEXTINPUT: {
+			const auto text = Utf8ToUtf16(event.text.text);
+			if (!text.empty()) {
+				auto input = MakeExternalInput(Ime::ExternalAction::Text, g_last_external_keycode,
+				                               g_last_external_status | 0x00000002);
+				input.key.character = text.front();
+				input.text          = text;
+				Ime::HostQueueExternalInput(generation, std::move(input));
+			}
+			return true;
+		}
+		case SDL_TEXTEDITING: return true;
+		case SDL_KEYDOWN: {
+			g_last_external_keycode = static_cast<uint16_t>(event.key.keysym.scancode);
+			g_last_external_status =
+			    ExternalKeyStatus(static_cast<SDL_Keymod>(event.key.keysym.mod), false);
+			auto action = Ime::ExternalAction::Text;
+			bool queue  = true;
+			if (event.key.keysym.sym == SDLK_BACKSPACE) {
+				action = Ime::ExternalAction::Backspace;
+			} else if (event.key.keysym.sym == SDLK_LEFT) {
+				action = Ime::ExternalAction::MoveLeft;
+			} else if (event.key.keysym.sym == SDLK_RIGHT) {
+				action = Ime::ExternalAction::MoveRight;
+			} else if (event.key.keysym.sym == SDLK_ESCAPE) {
+				action = Ime::ExternalAction::Cancel;
+			} else if (event.key.keysym.sym == SDLK_RETURN ||
+			           event.key.keysym.sym == SDLK_KP_ENTER) {
+				action =
+				    g_input_multiline ? Ime::ExternalAction::Newline : Ime::ExternalAction::Accept;
+			} else if (event.key.keysym.sym == SDLK_TAB) {
+				action = Ime::ExternalAction::None;
+			} else {
+				queue = false;
+			}
+			if (queue) {
+				Ime::HostQueueExternalInput(
+				    generation,
+				    MakeExternalInput(action, g_last_external_keycode, g_last_external_status));
+			}
+			return true;
+		}
+		case SDL_KEYUP: return true;
+		case SDL_CONTROLLERBUTTONDOWN:
+		case SDL_CONTROLLERBUTTONUP:
+			QueueInput({InputKind::Button, generation, event.cbutton.button,
+			            event.type == SDL_CONTROLLERBUTTONDOWN ? 1.0f : 0.0f, 0.0f});
+			return true;
+		case SDL_CONTROLLERAXISMOTION:
+			QueueInput({InputKind::Axis, generation, event.caxis.axis,
+			            static_cast<float>(event.caxis.value), 0.0f});
+			return true;
+		case SDL_MOUSEMOTION:
+			QueueInput({InputKind::MousePosition, generation, 0, static_cast<float>(event.motion.x),
+			            static_cast<float>(event.motion.y)});
+			return true;
+		case SDL_MOUSEBUTTONDOWN:
+		case SDL_MOUSEBUTTONUP:
+			QueueInput({InputKind::MouseButton, generation, event.button.button,
+			            event.type == SDL_MOUSEBUTTONDOWN ? 1.0f : 0.0f, 0.0f});
+			return true;
+		case SDL_MOUSEWHEEL:
+			QueueInput({InputKind::MouseWheel, generation, 0, static_cast<float>(event.wheel.x),
+			            static_cast<float>(event.wheel.y)});
+			return true;
+		default: return false;
+	}
+}
+
+struct ImeDialogOverlay::Impl {
+	explicit Impl(GraphicContext& context): graphics(context) {}
+
+	~Impl() {
+		ReleaseVulkan();
+		if (imgui_context != nullptr) {
+			ImGui::DestroyContext(imgui_context);
+		}
+	}
+
+	void EnsureContext() {
+		if (imgui_context != nullptr) {
+			ImGui::SetCurrentContext(imgui_context);
+			return;
+		}
+		IMGUI_CHECKVERSION();
+		imgui_context = ImGui::CreateContext();
+		ImGui::SetCurrentContext(imgui_context);
+		auto& io       = ImGui::GetIO();
+		io.IniFilename = nullptr;
+		io.LogFilename = nullptr;
+		io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;
+		io.BackendFlags |= ImGuiBackendFlags_HasGamepad;
+		io.BackendPlatformName = "Kyty ImeDialog input";
+		ImGui::StyleColorsDark();
+		auto& style          = ImGui::GetStyle();
+		style.WindowRounding = 10.0f;
+		style.FrameRounding  = 6.0f;
+		style.ItemSpacing    = {8.0f, 8.0f};
+	}
+
+	void EnsureVulkan(vk::Format format, uint32_t image_count) {
+		EnsureContext();
+		if (vulkan_initialized) {
+			return;
+		}
+		EXIT_IF(image_count < 2);
+		EXIT_IF(!ImGui_ImplVulkan_LoadFunctions(VK_API_VERSION_1_3, LoadVulkanFunction, &graphics));
+
+		const VkFormat            color_format = static_cast<VkFormat>(format);
+		ImGui_ImplVulkan_InitInfo info {};
+		info.ApiVersion                   = VK_API_VERSION_1_3;
+		info.Instance                     = static_cast<VkInstance>(graphics.instance);
+		info.PhysicalDevice               = static_cast<VkPhysicalDevice>(graphics.physical_device);
+		info.Device                       = static_cast<VkDevice>(graphics.device);
+		info.QueueFamily                  = graphics.queue_family;
+		info.Queue                        = static_cast<VkQueue>(graphics.queue);
+		info.DescriptorPoolSize           = IMGUI_IMPL_VULKAN_MINIMUM_SAMPLED_IMAGE_POOL_SIZE;
+		info.MinImageCount                = image_count;
+		info.ImageCount                   = image_count;
+		info.UseDynamicRendering          = true;
+		info.PipelineInfoMain.MSAASamples = VK_SAMPLE_COUNT_1_BIT;
+		info.PipelineInfoMain.PipelineRenderingCreateInfo.sType =
+		    VK_STRUCTURE_TYPE_PIPELINE_RENDERING_CREATE_INFO;
+		info.PipelineInfoMain.PipelineRenderingCreateInfo.colorAttachmentCount    = 1;
+		info.PipelineInfoMain.PipelineRenderingCreateInfo.pColorAttachmentFormats = &color_format;
+		info.CheckVkResultFn = CheckVulkanResult;
+		EXIT_IF(!ImGui_ImplVulkan_Init(&info));
+		vulkan_initialized = true;
+	}
+
+	void DrainInput(uint64_t generation) {
+		std::deque<InputEvent> events;
+		bool                   reset = false;
+		{
+			std::scoped_lock lock(g_input_mutex);
+			events.swap(g_input_events);
+			reset                   = g_input_reset_requested;
+			g_input_reset_requested = false;
+		}
+		auto& io = ImGui::GetIO();
+		if (reset) {
+			io.ClearEventsQueue();
+			io.ClearInputKeys();
+			io.ClearInputMouse();
+			right_stick = {};
+		}
+		for (const auto& event: events) {
+			if (event.generation != generation) {
+				continue;
+			}
+			switch (event.kind) {
+				case InputKind::Button: {
+					const bool down = event.x != 0.0f;
+					if (down && event.id == SDL_CONTROLLER_BUTTON_B) {
+						Ime::HostCancel(generation);
+					} else if (down && event.id == SDL_CONTROLLER_BUTTON_Y) {
+						Ime::HostBackspace(generation);
+					}
+					const ImGuiKey key = ControllerButtonToKey(event.id);
+					if (key != ImGuiKey_None) {
+						io.AddKeyEvent(key, down);
+					}
+					break;
+				}
+				case InputKind::Axis: {
+					const float value = event.x / (event.x < 0.0f ? 32768.0f : 32767.0f);
+					if (event.id == SDL_CONTROLLER_AXIS_LEFTX) {
+						io.AddKeyAnalogEvent(ImGuiKey_GamepadLStickLeft, value < -0.25f,
+						                     std::max(-value, 0.0f));
+						io.AddKeyAnalogEvent(ImGuiKey_GamepadLStickRight, value > 0.25f,
+						                     std::max(value, 0.0f));
+					} else if (event.id == SDL_CONTROLLER_AXIS_LEFTY) {
+						io.AddKeyAnalogEvent(ImGuiKey_GamepadLStickUp, value < -0.25f,
+						                     std::max(-value, 0.0f));
+						io.AddKeyAnalogEvent(ImGuiKey_GamepadLStickDown, value > 0.25f,
+						                     std::max(value, 0.0f));
+					} else if (event.id == SDL_CONTROLLER_AXIS_RIGHTX) {
+						right_stick.x = std::abs(value) > 0.2f ? value : 0.0f;
+					} else if (event.id == SDL_CONTROLLER_AXIS_RIGHTY) {
+						right_stick.y = std::abs(value) > 0.2f ? value : 0.0f;
+					}
+					break;
+				}
+				case InputKind::MousePosition: io.AddMousePosEvent(event.x, event.y); break;
+				case InputKind::MouseButton: {
+					int button = -1;
+					if (event.id == SDL_BUTTON_LEFT) button = 0;
+					if (event.id == SDL_BUTTON_RIGHT) button = 1;
+					if (event.id == SDL_BUTTON_MIDDLE) button = 2;
+					if (button >= 0) io.AddMouseButtonEvent(button, event.x != 0.0f);
+					break;
+				}
+				case InputKind::MouseWheel: io.AddMouseWheelEvent(event.x, event.y); break;
+				case InputKind::ResetController:
+					io.ClearEventsQueue();
+					io.ClearInputKeys();
+					right_stick = {};
+					break;
+			}
+		}
+	}
+
+	void KeyButton(std::string_view label, char16_t value, uint64_t generation, float width,
+	               bool default_focus) {
+		const bool pressed = ImGui::Button(label.data(), {width, button_height});
+		if (default_focus) {
+			ImGui::SetItemDefaultFocus();
+		}
+		if (pressed) {
+			Ime::HostInsertText(generation, std::u16string_view(&value, 1));
+		}
+	}
+
+	void DrawKeyRows(const Ime::HostSnapshot& snapshot, float width) {
+		static constexpr std::array<std::string_view, 4> lower   = {"1234567890", "qwertyuiop",
+		                                                            "asdfghjkl", "zxcvbnm"};
+		static constexpr std::array<std::string_view, 4> upper   = {"1234567890", "QWERTYUIOP",
+		                                                            "ASDFGHJKL", "ZXCVBNM"};
+		static constexpr std::array<std::string_view, 3> symbols = {"1234567890", "!@#$%^&*()",
+		                                                            "-_=+/:?."};
+		static constexpr std::array<std::string_view, 4> number  = {"123", "456", "789", "-0."};
+
+		std::span<const std::string_view> rows;
+		if (snapshot.type == Ime::Type::Number) {
+			rows = number;
+		} else if (symbol_mode) {
+			rows = symbols;
+		} else {
+			rows = shift ? std::span<const std::string_view>(upper)
+			             : std::span<const std::string_view>(lower);
+		}
+		bool   first     = focus_pending;
+		size_t row_index = 0;
+		for (const auto row: rows) {
+			const float key_width =
+			    std::min(56.0f * ui_scale, (width - 8.0f * (row.size() - 1)) / row.size());
+			const float row_width = key_width * row.size() + 8.0f * (row.size() - 1);
+			ImGui::SetCursorPosX((width - row_width) * 0.5f);
+			ImGui::PushID(static_cast<int>(row_index++));
+			for (size_t i = 0; i < row.size(); i++) {
+				ImGui::PushID(static_cast<int>(i));
+				const char label[2] = {row[i], '\0'};
+				KeyButton(label, static_cast<char16_t>(row[i]), snapshot.generation, key_width,
+				          first);
+				first = false;
+				ImGui::PopID();
+				if (i + 1 < row.size()) ImGui::SameLine();
+			}
+			ImGui::PopID();
+		}
+		focus_pending = false;
+	}
+
+	void DrawDialog(const Ime::HostSnapshot& snapshot, vk::Extent2D extent) {
+		const ImVec2 display(static_cast<float>(extent.width), static_cast<float>(extent.height));
+		const bool   over_2k          = (snapshot.option & Ime::OPTION_USE_OVER_2K) != 0;
+		const float  reference_width  = over_2k ? 3840.0f : 1920.0f;
+		const float  reference_height = over_2k ? 2160.0f : 1080.0f;
+		const float  scale_x          = display.x / reference_width;
+		const float  scale_y          = display.y / reference_height;
+		const float  width            = static_cast<float>(snapshot.panel_width) * scale_x;
+		const float  height           = static_cast<float>(snapshot.panel_height) * scale_y;
+		ui_scale                      = std::min(scale_x, scale_y) * (over_2k ? 2.0f : 1.0f);
+		button_height                 = std::max(28.0f, 42.0f * ui_scale);
+
+		const ImVec2 pivot {AlignmentPivot(snapshot.horizontal_alignment),
+		                    AlignmentPivot(snapshot.vertical_alignment)};
+		if ((snapshot.option & Ime::OPTION_FIXED_POSITION) == 0) {
+			const float movement = 600.0f * ImGui::GetIO().DeltaTime;
+			panel_offset.x += right_stick.x * movement;
+			panel_offset.y += right_stick.y * movement;
+		}
+		const ImVec2 base_position {snapshot.posx * scale_x - pivot.x * width,
+		                            snapshot.posy * scale_y - pivot.y * height};
+		ImVec2       position {base_position.x + panel_offset.x, base_position.y + panel_offset.y};
+		if ((snapshot.option & Ime::OPTION_DISABLE_POSITION_ADJ) == 0) {
+			position.x   = std::clamp(position.x, 0.0f, std::max(display.x - width, 0.0f));
+			position.y   = std::clamp(position.y, 0.0f, std::max(display.y - height, 0.0f));
+			panel_offset = {position.x - base_position.x, position.y - base_position.y};
+		}
+		ImGui::SetNextWindowPos(position, ImGuiCond_Always);
+		ImGui::SetNextWindowSize({width, height}, ImGuiCond_Always);
+		constexpr ImGuiWindowFlags flags = ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoMove |
+		                                   ImGuiWindowFlags_NoSavedSettings;
+		ImGui::Begin("##ImeDialog", nullptr, flags);
+
+		const std::u16string title = snapshot.title.empty() ? u"Enter text" : snapshot.title;
+		if (!snapshot.key_panel_visible) {
+			std::string compact     = Common::Utf16ToUtf8(title.c_str()) + ": ";
+			const float glyph_width = std::max(ImGui::CalcTextSize("M").x, 1.0f);
+			const float text_width =
+			    std::max(ImGui::GetContentRegionAvail().x - ImGui::CalcTextSize(compact.c_str()).x,
+			             glyph_width);
+			const size_t visible_units =
+			    std::max<size_t>(6, static_cast<size_t>(text_width / glyph_width));
+			compact += snapshot.text.empty() && !snapshot.placeholder.empty()
+			               ? Common::Utf16ToUtf8(snapshot.placeholder.c_str())
+			               : VisibleText(snapshot, visible_units);
+			ImGui::TextUnformatted(compact.c_str());
+			const float compact_height = std::min(button_height, 28.0f * ui_scale);
+			if (ImGui::Button("Cancel", {90.0f * ui_scale, compact_height})) {
+				Ime::HostCancel(snapshot.generation);
+			}
+			ImGui::SameLine();
+			if (ImGui::Button(EnterLabel(snapshot.enter_label),
+			                  {90.0f * ui_scale, compact_height})) {
+				Ime::HostAccept(snapshot.generation);
+			}
+			ImGui::End();
+			return;
+		}
+
+		ImGui::TextUnformatted(Common::Utf16ToUtf8(title.c_str()).c_str());
+		ImGui::Separator();
+		const float text_height = std::max(
+		    32.0f, ((snapshot.option & Ime::OPTION_MULTILINE) != 0 ? 80.0f : 48.0f) * ui_scale);
+		ImGui::BeginChild("##ImeText", {0.0f, text_height}, true);
+		if (snapshot.text.empty() && !snapshot.placeholder.empty()) {
+			ImGui::TextDisabled("%s", Common::Utf16ToUtf8(snapshot.placeholder.c_str()).c_str());
+		} else {
+			const float  glyph_width = std::max(ImGui::CalcTextSize("M").x, 1.0f);
+			const size_t columns     = std::max<size_t>(
+			    8, static_cast<size_t>(ImGui::GetContentRegionAvail().x / glyph_width));
+			const size_t lines =
+			    std::max<size_t>(1, static_cast<size_t>(ImGui::GetContentRegionAvail().y /
+			                                            ImGui::GetTextLineHeightWithSpacing()));
+			const auto text = VisibleText(snapshot, columns * lines);
+			ImGui::TextWrapped("%s", text.c_str());
+		}
+		ImGui::EndChild();
+		ImGui::TextDisabled("%zu / %u", snapshot.text.size(), snapshot.max_text_length);
+		ImGui::Separator();
+
+		const float content_width = ImGui::GetContentRegionAvail().x;
+		DrawKeyRows(snapshot, content_width);
+		if (snapshot.type != Ime::Type::Number) {
+			if (ImGui::Button(shift ? "Lower" : "Shift", {84.0f * ui_scale, button_height})) {
+				shift = !shift;
+			}
+			ImGui::SameLine();
+			if (ImGui::Button(symbol_mode ? "ABC" : "Symbols", {84.0f * ui_scale, button_height})) {
+				symbol_mode = !symbol_mode;
+			}
+			ImGui::SameLine();
+			if (ImGui::Button("Space", {120.0f * ui_scale, button_height})) {
+				Ime::HostInsertText(snapshot.generation, u" ");
+			}
+			ImGui::SameLine();
+		}
+		const float action_width = snapshot.type == Ime::Type::Number
+		                               ? std::max((content_width - 16.0f) / 3.0f, 48.0f)
+		                               : 100.0f * ui_scale;
+		if (ImGui::Button("Backspace", {action_width, button_height})) {
+			Ime::HostBackspace(snapshot.generation);
+		}
+		ImGui::SameLine();
+		if ((snapshot.option & Ime::OPTION_MULTILINE) != 0) {
+			if (ImGui::Button("Newline", {action_width, button_height})) {
+				Ime::HostInsertText(snapshot.generation, u"\n");
+			}
+			ImGui::SameLine();
+		}
+		if (ImGui::Button("Cancel", {action_width, button_height})) {
+			Ime::HostCancel(snapshot.generation);
+		}
+		ImGui::SameLine();
+		if (ImGui::Button(EnterLabel(snapshot.enter_label), {action_width, button_height})) {
+			Ime::HostAccept(snapshot.generation);
+		}
+		ImGui::End();
+	}
+
+	bool PrepareFrame(vk::Extent2D frame_extent, vk::Format format, uint32_t image_count) {
+		Ime::HostSnapshot snapshot;
+		if (!Ime::GetHostSnapshot(&snapshot)) {
+			return false;
+		}
+		const uint64_t prepared_generation = snapshot.generation;
+		EnsureVulkan(format, image_count);
+		if (generation != snapshot.generation) {
+			generation    = snapshot.generation;
+			focus_pending = true;
+			shift         = (snapshot.option & Ime::OPTION_NO_AUTO_CAPITALIZE) == 0;
+			symbol_mode   = false;
+			panel_offset  = {};
+			right_stick   = {};
+			auto& io      = ImGui::GetIO();
+			io.ClearEventsQueue();
+			io.ClearInputKeys();
+			io.ClearInputMouse();
+		}
+		DrainInput(snapshot.generation);
+
+		auto& io       = ImGui::GetIO();
+		io.DisplaySize = {static_cast<float>(frame_extent.width),
+		                  static_cast<float>(frame_extent.height)};
+		const auto now = std::chrono::steady_clock::now();
+		io.DeltaTime   = last_frame == std::chrono::steady_clock::time_point {}
+		                     ? 1.0f / 60.0f
+		                     : std::clamp(std::chrono::duration<float>(now - last_frame).count(),
+		                                  1.0f / 1000.0f, 0.1f);
+		last_frame     = now;
+		ImGui_ImplVulkan_NewFrame();
+		ImGui::NewFrame();
+		if (!Ime::GetHostSnapshot(&snapshot) || snapshot.generation != prepared_generation) {
+			ImGui::EndFrame();
+			return false;
+		}
+		DrawDialog(snapshot, frame_extent);
+		ImGui::Render();
+		extent = frame_extent;
+		return true;
+	}
+
+	void Record(vk::CommandBuffer command, vk::ImageView target) {
+		vk::RenderingAttachmentInfo color {};
+		color.sType       = vk::StructureType::eRenderingAttachmentInfo;
+		color.imageView   = target;
+		color.imageLayout = vk::ImageLayout::eColorAttachmentOptimal;
+		color.loadOp      = vk::AttachmentLoadOp::eLoad;
+		color.storeOp     = vk::AttachmentStoreOp::eStore;
+		vk::RenderingInfo rendering {};
+		rendering.sType                = vk::StructureType::eRenderingInfo;
+		rendering.renderArea.extent    = extent;
+		rendering.layerCount           = 1;
+		rendering.colorAttachmentCount = 1;
+		rendering.pColorAttachments    = &color;
+		command.beginRendering(rendering);
+		{
+			Common::LockGuard queue_lock(graphics.queue_mutex);
+			ImGui_ImplVulkan_RenderDrawData(ImGui::GetDrawData(),
+			                                static_cast<VkCommandBuffer>(command));
+		}
+		command.endRendering();
+	}
+
+	void ReleaseVulkan() {
+		if (!vulkan_initialized) {
+			return;
+		}
+		ImGui::SetCurrentContext(imgui_context);
+		ImGui_ImplVulkan_Shutdown();
+		vulkan_initialized = false;
+	}
+
+	GraphicContext&                       graphics;
+	ImGuiContext*                         imgui_context      = nullptr;
+	bool                                  vulkan_initialized = false;
+	bool                                  shift              = false;
+	bool                                  symbol_mode        = false;
+	bool                                  focus_pending      = true;
+	float                                 ui_scale           = 1.0f;
+	float                                 button_height      = 42.0f;
+	ImVec2                                panel_offset {};
+	ImVec2                                right_stick {};
+	uint64_t                              generation = 0;
+	vk::Extent2D                          extent {};
+	std::chrono::steady_clock::time_point last_frame;
+};
+
+ImeDialogOverlay::ImeDialogOverlay(GraphicContext& graphics)
+    : m_impl(std::make_unique<Impl>(graphics)) {}
+
+ImeDialogOverlay::~ImeDialogOverlay() = default;
+
+bool ImeDialogOverlay::PrepareFrame(vk::Extent2D extent, vk::Format format, uint32_t image_count) {
+	return m_impl->PrepareFrame(extent, format, image_count);
+}
+
+void ImeDialogOverlay::Record(vk::CommandBuffer command, vk::ImageView target) {
+	m_impl->Record(command, target);
+}
+
+void ImeDialogOverlay::ReleaseVulkan() {
+	m_impl->ReleaseVulkan();
+}
+
+} // namespace Libs::Graphics

src/graphics/presentation/imeDialogOverlay.h

@@ -0,0 +1,36 @@
+#ifndef EMULATOR_SRC_GRAPHICS_PRESENTATION_IMEDIALOGOVERLAY_H_
+#define EMULATOR_SRC_GRAPHICS_PRESENTATION_IMEDIALOGOVERLAY_H_
+
+#include "common/common.h"
+#include "graphics/host_gpu/vulkanCommon.h"
+
+#include <memory>
+
+union SDL_Event;
+
+namespace Libs::Graphics {
+
+struct GraphicContext;
+
+void InitializeImeDialogInput();
+void ShutdownImeDialogInput();
+bool ProcessImeDialogInput(const SDL_Event& event);
+
+class ImeDialogOverlay final {
+public:
+	explicit ImeDialogOverlay(GraphicContext& graphics);
+	~ImeDialogOverlay();
+	KYTY_CLASS_NO_COPY(ImeDialogOverlay);
+
+	[[nodiscard]] bool PrepareFrame(vk::Extent2D extent, vk::Format format, uint32_t image_count);
+	void               Record(vk::CommandBuffer command, vk::ImageView target);
+	void               ReleaseVulkan();
+
+private:
+	struct Impl;
+	std::unique_ptr<Impl> m_impl;
+};
+
+} // namespace Libs::Graphics
+
+#endif // EMULATOR_SRC_GRAPHICS_PRESENTATION_IMEDIALOGOVERLAY_H_

src/graphics/presentation/presenter.h

@@ -25,6 +25,7 @@ public:
 	                                               CommandBuffer* producer = nullptr);
 	[[nodiscard]] Frame*         PrepareLastFrame();
 	[[nodiscard]] bool           IsGuestPaused() const noexcept;
+	[[nodiscard]] bool           NeedsImeRefresh() const noexcept;
 	[[nodiscard]] RenderContext& Renderer() const noexcept;
 	void                         Present(Frame& frame, bool reuse = false);
 	void                         Discard(Frame& frame);

src/graphics/presentation/videoOut.cpp

@@ -817,7 +817,24 @@ void VideoOutDriver::Impl::PresentThread(std::stop_token token) {
 		}
 
 		VblankBegin();
-		const bool presented = m_flip_queue.Flip(0);
+		bool presented = m_flip_queue.Flip(0);
+		if (!presented && m_presenter.NeedsImeRefresh()) {
+			if (auto* frame = m_presenter.PrepareLastFrame(); frame != nullptr) {
+				m_presenter.Present(*frame, true);
+				presented = true;
+			} else {
+				uint32_t width  = 0;
+				uint32_t height = 0;
+				{
+					Common::LockGuard lock(m_mutex);
+					width  = m_video_out_ctx[0].width;
+					height = m_video_out_ctx[0].height;
+				}
+				auto& blank = m_presenter.PrepareBlankFrame(width, height, true);
+				m_presenter.Present(blank);
+				presented = true;
+			}
+		}
 		if (!presented && total_wait < 0) {
 			bool     any_open = false;
 			uint32_t width    = 0;

src/graphics/presentation/window/hostInput.cpp

@@ -0,0 +1,256 @@
+#include "graphics/presentation/window/hostInput.h"
+
+#include "SDL_keyboard.h"
+#include "SDL_keycode.h"
+#include "SDL_mouse.h"
+#include "common/assert.h"
+#include "common/emulatorConfig.h"
+#include "libs/controller.h"
+
+#include <algorithm>
+#include <array>
+#include <cstddef>
+#include <string>
+#include <string_view>
+#include <utility>
+
+namespace Libs::Graphics {
+
+namespace {
+
+struct Binding {
+	SDL_Keycode key          = SDLK_UNKNOWN;
+	uint8_t     mouse_button = 0;
+	uint32_t    pad_button   = 0;
+};
+
+static constexpr std::array PAD_BUTTONS = {
+    std::pair {std::string_view("L3"), Controller::PAD_BUTTON_L3},
+    std::pair {std::string_view("R3"), Controller::PAD_BUTTON_R3},
+    std::pair {std::string_view("Options"), Controller::PAD_BUTTON_OPTIONS},
+    std::pair {std::string_view("Up"), Controller::PAD_BUTTON_UP},
+    std::pair {std::string_view("Right"), Controller::PAD_BUTTON_RIGHT},
+    std::pair {std::string_view("Down"), Controller::PAD_BUTTON_DOWN},
+    std::pair {std::string_view("Left"), Controller::PAD_BUTTON_LEFT},
+    std::pair {std::string_view("L2"), Controller::PAD_BUTTON_L2},
+    std::pair {std::string_view("R2"), Controller::PAD_BUTTON_R2},
+    std::pair {std::string_view("L1"), Controller::PAD_BUTTON_L1},
+    std::pair {std::string_view("R1"), Controller::PAD_BUTTON_R1},
+    std::pair {std::string_view("Triangle"), Controller::PAD_BUTTON_TRIANGLE},
+    std::pair {std::string_view("Circle"), Controller::PAD_BUTTON_CIRCLE},
+    std::pair {std::string_view("Cross"), Controller::PAD_BUTTON_CROSS},
+    std::pair {std::string_view("Square"), Controller::PAD_BUTTON_SQUARE},
+    std::pair {std::string_view("TouchPad"), Controller::PAD_BUTTON_TOUCH_PAD},
+};
+
+uint32_t PadButtonFromName(std::string_view name) {
+	const auto button = std::find_if(PAD_BUTTONS.begin(), PAD_BUTTONS.end(),
+	                                 [name](const auto& item) { return item.first == name; });
+	return button != PAD_BUTTONS.end() ? button->second : 0;
+}
+
+SDL_Keycode NormalizeKey(SDL_Keycode key) {
+	switch (key) {
+		case SDLK_RSHIFT: return SDLK_LSHIFT;
+		case SDLK_RCTRL: return SDLK_LCTRL;
+		case SDLK_RALT: return SDLK_LALT;
+		case SDLK_RGUI: return SDLK_LGUI;
+		default: return key;
+	}
+}
+
+uint8_t MouseButtonFromName(std::string_view name) {
+	static constexpr std::array buttons = {
+	    std::pair {std::string_view("Mouse:Left"), uint8_t {SDL_BUTTON_LEFT}},
+	    std::pair {std::string_view("Mouse:Middle"), uint8_t {SDL_BUTTON_MIDDLE}},
+	    std::pair {std::string_view("Mouse:Right"), uint8_t {SDL_BUTTON_RIGHT}},
+	    std::pair {std::string_view("Mouse:X1"), uint8_t {SDL_BUTTON_X1}},
+	    std::pair {std::string_view("Mouse:X2"), uint8_t {SDL_BUTTON_X2}},
+	};
+
+	const auto button = std::find_if(buttons.begin(), buttons.end(),
+	                                 [name](const auto& item) { return item.first == name; });
+	return button != buttons.end() ? button->second : 0;
+}
+
+bool Conflicts(const Binding& first, const Binding& second) {
+	return first.pad_button == second.pad_button ||
+	       (first.key != SDLK_UNKNOWN && first.key == second.key) ||
+	       (first.mouse_button != 0 && first.mouse_button == second.mouse_button);
+}
+
+class InputMap {
+public:
+	InputMap(): m_custom(!Config::GetKeymap().empty()) {
+		for (const auto& value: Config::GetKeymap()) {
+			const std::string_view entry = value;
+			const auto             split = entry.find('=');
+
+			Binding binding;
+			if (split != std::string_view::npos) {
+				binding.pad_button    = PadButtonFromName(entry.substr(0, split));
+				const auto host_input = entry.substr(split + 1);
+				binding.mouse_button  = MouseButtonFromName(host_input);
+				if (binding.mouse_button == 0) {
+					binding.key = NormalizeKey(SDL_GetKeyFromName(std::string(host_input).c_str()));
+				}
+			}
+
+			const bool reserved =
+			    binding.key == SDLK_ESCAPE || binding.key == SDLK_SPACE || binding.key == SDLK_F1;
+			if (binding.pad_button == 0 || reserved ||
+			    (binding.key == SDLK_UNKNOWN && binding.mouse_button == 0)) {
+				EXIT("Invalid input mapping: %s\n", value.c_str());
+			}
+			Add(binding);
+		}
+	}
+	[[nodiscard]] bool Custom() const { return m_custom; }
+
+	[[nodiscard]] uint32_t FindKey(int key_code) const {
+		key_code = NormalizeKey(static_cast<SDL_Keycode>(key_code));
+		const auto binding =
+		    std::find_if(m_bindings.begin(), m_bindings.begin() + m_size,
+		                 [key_code](const auto& item) { return item.key == key_code; });
+		return binding != m_bindings.begin() + m_size ? binding->pad_button : 0;
+	}
+
+	[[nodiscard]] uint32_t FindMouseButton(uint8_t mouse_button) const {
+		const auto binding = std::find_if(
+		    m_bindings.begin(), m_bindings.begin() + m_size,
+		    [mouse_button](const auto& item) { return item.mouse_button == mouse_button; });
+		return binding != m_bindings.begin() + m_size ? binding->pad_button : 0;
+	}
+
+private:
+	void Add(const Binding& binding) {
+		for (std::size_t index = 0; index < m_size;) {
+			if (Conflicts(m_bindings[index], binding)) {
+				m_bindings[index] = m_bindings[--m_size];
+			} else {
+				index++;
+			}
+		}
+		EXIT_IF(m_size >= m_bindings.size());
+		m_bindings[m_size++] = binding;
+	}
+
+	std::array<Binding, PAD_BUTTONS.size()> m_bindings {};
+	std::size_t                             m_size = 0;
+	bool                                    m_custom;
+};
+
+const InputMap& GetInputMap() {
+	static const InputMap map;
+	return map;
+}
+
+void SetButton(uint32_t button, bool down) {
+	if (button == Controller::PAD_BUTTON_L2) {
+		Controller::ControllerAxis(Controller::HOST_INPUT_CONTROLLER_ID,
+		                           Controller::Axis::TriggerLeft, down ? 255 : 0);
+	} else if (button == Controller::PAD_BUTTON_R2) {
+		Controller::ControllerAxis(Controller::HOST_INPUT_CONTROLLER_ID,
+		                           Controller::Axis::TriggerRight, down ? 255 : 0);
+	} else if (button != 0) {
+		Controller::ControllerButton(Controller::HOST_INPUT_CONTROLLER_ID, button, down);
+	}
+}
+
+uint32_t DefaultKeyboardButton(int key_code) {
+	switch (NormalizeKey(static_cast<SDL_Keycode>(key_code))) {
+		case SDLK_UP: return Controller::PAD_BUTTON_UP;
+		case SDLK_LEFT: return Controller::PAD_BUTTON_LEFT;
+		case SDLK_DOWN: return Controller::PAD_BUTTON_DOWN;
+		case SDLK_RIGHT: return Controller::PAD_BUTTON_RIGHT;
+		case SDLK_j: return Controller::PAD_BUTTON_CROSS;
+		case SDLK_i: return Controller::PAD_BUTTON_TRIANGLE;
+		case SDLK_k: return Controller::PAD_BUTTON_SQUARE;
+		case SDLK_l: return Controller::PAD_BUTTON_CIRCLE;
+		case SDLK_q: return Controller::PAD_BUTTON_L1;
+		case SDLK_e: return Controller::PAD_BUTTON_R1;
+		case SDLK_LSHIFT: return Controller::PAD_BUTTON_L3;
+		case SDLK_LCTRL: return Controller::PAD_BUTTON_R3;
+		case SDLK_RETURN:
+		case SDLK_RETURN2: return Controller::PAD_BUTTON_OPTIONS;
+		case SDLK_BACKSPACE:
+		case SDLK_TAB: return Controller::PAD_BUTTON_TOUCH_PAD;
+		default: return 0;
+	}
+}
+
+struct StickKeys {
+	bool left  = false;
+	bool right = false;
+	bool up    = false;
+	bool down  = false;
+};
+
+void SetStickAxis(Controller::Axis axis, bool negative, bool positive) {
+	const int value = negative == positive ? 128 : negative ? 0 : 255;
+	Controller::ControllerAxis(Controller::HOST_INPUT_CONTROLLER_ID, axis, value);
+}
+
+void DefaultKeyboardInput(int key_code, bool down) {
+	static StickKeys left;
+	static StickKeys right;
+
+	switch (NormalizeKey(static_cast<SDL_Keycode>(key_code))) {
+		case SDLK_a:
+			left.left = down;
+			SetStickAxis(Controller::Axis::LeftX, left.left, left.right);
+			return;
+		case SDLK_d:
+			left.right = down;
+			SetStickAxis(Controller::Axis::LeftX, left.left, left.right);
+			return;
+		case SDLK_w:
+			left.up = down;
+			SetStickAxis(Controller::Axis::LeftY, left.up, left.down);
+			return;
+		case SDLK_s:
+			left.down = down;
+			SetStickAxis(Controller::Axis::LeftY, left.up, left.down);
+			return;
+		case SDLK_f:
+			right.left = down;
+			SetStickAxis(Controller::Axis::RightX, right.left, right.right);
+			return;
+		case SDLK_h:
+			right.right = down;
+			SetStickAxis(Controller::Axis::RightX, right.left, right.right);
+			return;
+		case SDLK_t:
+			right.up = down;
+			SetStickAxis(Controller::Axis::RightY, right.up, right.down);
+			return;
+		case SDLK_g:
+			right.down = down;
+			SetStickAxis(Controller::Axis::RightY, right.up, right.down);
+			return;
+		default: SetButton(DefaultKeyboardButton(key_code), down); return;
+	}
+}
+} // namespace
+
+void HostInputInit() {
+	GetInputMap();
+}
+
+void HostInputKey(int key_code, bool down) {
+	const auto& map = GetInputMap();
+	if (map.Custom()) {
+		SetButton(map.FindKey(key_code), down);
+	} else {
+		DefaultKeyboardInput(key_code, down);
+	}
+}
+
+void HostInputMouseButton(uint8_t mouse_button, bool down) {
+	const auto& map = GetInputMap();
+	if (map.Custom() && mouse_button != 0) {
+		SetButton(map.FindMouseButton(mouse_button), down);
+	}
+}
+
+} // namespace Libs::Graphics

src/graphics/presentation/window/hostInput.h

@@ -0,0 +1,14 @@
+#ifndef KYTY_GRAPHICS_PRESENTATION_WINDOW_HOST_INPUT_H_
+#define KYTY_GRAPHICS_PRESENTATION_WINDOW_HOST_INPUT_H_
+
+#include <cstdint>
+
+namespace Libs::Graphics {
+
+void HostInputInit();
+void HostInputKey(int key_code, bool down);
+void HostInputMouseButton(uint8_t mouse_button, bool down);
+
+} // namespace Libs::Graphics
+
+#endif /* KYTY_GRAPHICS_PRESENTATION_WINDOW_HOST_INPUT_H_ */

src/graphics/presentation/window/swapchain.cpp

@@ -31,11 +31,13 @@
 #include "graphics/host_gpu/renderer/renderContext.h"
 #include "graphics/host_gpu/vma.h"
 #include "graphics/host_gpu/vulkanCommon.h"
+#include "graphics/presentation/imeDialogOverlay.h"
 #include "graphics/presentation/presenter.h"
 #include "graphics/presentation/renderDoc.h"
 #include "graphics/presentation/videoOut.h"
 #include "graphics/presentation/window/windowInternal.h"
 #include "libs/controller.h"
+#include "libs/imeDialog.h"
 #include "loader/systemContent.h"
 
 #include <algorithm>
@@ -329,8 +331,9 @@ public:
 	void                 Create();
 	void                 Recreate(bool surface_lost = false);
 	[[nodiscard]] Status AcquireNextImage();
-	void                 RecordPresentCommands(CommandBuffer& command, VulkanImage& source);
-	void                 Submit(CommandBuffer& command);
+	[[nodiscard]] bool   PrepareImeOverlay();
+	void RecordPresentCommands(CommandBuffer& command, VulkanImage& source, bool draw_ime_overlay);
+	void Submit(CommandBuffer& command);
 	[[nodiscard]] Status Present();
 
 	[[nodiscard]] uint32_t ImageCount() const noexcept {
@@ -342,16 +345,17 @@ private:
 	void Destroy();
 	void RefreshSurfaceSize();
 
-	WindowContext&             m_window;
-	vk::SwapchainKHR           m_handle = nullptr;
-	vk::Format                 m_format = vk::Format::eUndefined;
-	vk::Extent2D               m_extent {};
-	std::vector<vk::Image>     m_images;
-	std::vector<vk::ImageView> m_image_views;
-	std::vector<vk::Semaphore> m_image_acquired;
-	std::vector<vk::Semaphore> m_render_complete;
-	uint32_t                   m_image_index = static_cast<uint32_t>(-1);
-	uint32_t                   m_frame_index = 0;
+	WindowContext&                    m_window;
+	vk::SwapchainKHR                  m_handle = nullptr;
+	vk::Format                        m_format = vk::Format::eUndefined;
+	vk::Extent2D                      m_extent {};
+	std::vector<vk::Image>            m_images;
+	std::vector<vk::ImageView>        m_image_views;
+	std::vector<vk::Semaphore>        m_image_acquired;
+	std::vector<vk::Semaphore>        m_render_complete;
+	std::unique_ptr<ImeDialogOverlay> m_ime_overlay;
+	uint32_t                          m_image_index = static_cast<uint32_t>(-1);
+	uint32_t                          m_frame_index = 0;
 };
 
 struct Presenter::Impl {
@@ -389,11 +393,12 @@ struct Presenter::Impl {
 		return image;
 	}
 
-	RenderContext&   renderer;
-	WindowContext&   window;
-	Swapchain        swapchain;
-	CommandScheduler present_scheduler;
-	FramePool        frames;
+	RenderContext&        renderer;
+	WindowContext&        window;
+	Swapchain             swapchain;
+	CommandScheduler      present_scheduler;
+	FramePool             frames;
+	std::atomic<uint64_t> presented_ime_revision {0};
 };
 
 void Swapchain::Create() {
@@ -522,6 +527,9 @@ void Swapchain::Destroy() {
 		Common::LockGuard queue_lock(graphics.queue_mutex);
 		RequireVulkanSuccess(graphics.queue.waitIdle(), "wait for swapchain queue");
 	}
+	if (m_ime_overlay != nullptr) {
+		m_ime_overlay->ReleaseVulkan();
+	}
 
 	for (const auto semaphore: m_image_acquired) {
 		if (semaphore != nullptr) {
@@ -606,7 +614,15 @@ Swapchain::Status Swapchain::AcquireNextImage() {
 	return Status::Success;
 }
 
-void Swapchain::RecordPresentCommands(CommandBuffer& command, VulkanImage& source) {
+bool Swapchain::PrepareImeOverlay() {
+	if (m_ime_overlay == nullptr) {
+		m_ime_overlay = std::make_unique<ImeDialogOverlay>(m_window.graphic_ctx);
+	}
+	return m_ime_overlay->PrepareFrame(m_extent, m_format, ImageCount());
+}
+
+void Swapchain::RecordPresentCommands(CommandBuffer& command, VulkanImage& source,
+                                      bool draw_ime_overlay) {
 	if (source.state.layout != vk::ImageLayout::eTransferSrcOptimal) {
 		EXIT("invalid prepared presentation image, vk_image=%p layout=%d\n",
 		     static_cast<void*>(source.image), static_cast<int>(source.state.layout));
@@ -652,11 +668,14 @@ void Swapchain::RecordPresentCommands(CommandBuffer& command, VulkanImage& sourc
 	                     vk::Filter::eLinear);
 
 	vk::ImageMemoryBarrier to_present {};
-	to_present.sType                           = vk::StructureType::eImageMemoryBarrier;
-	to_present.srcAccessMask                   = vk::AccessFlagBits::eTransferWrite;
-	to_present.dstAccessMask                   = vk::AccessFlagBits::eMemoryRead;
-	to_present.oldLayout                       = vk::ImageLayout::eTransferDstOptimal;
-	to_present.newLayout                       = vk::ImageLayout::ePresentSrcKHR;
+	to_present.sType         = vk::StructureType::eImageMemoryBarrier;
+	to_present.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
+	to_present.dstAccessMask = draw_ime_overlay ? vk::AccessFlagBits::eColorAttachmentRead |
+	                                                  vk::AccessFlagBits::eColorAttachmentWrite
+	                                            : vk::AccessFlagBits::eMemoryRead;
+	to_present.oldLayout     = vk::ImageLayout::eTransferDstOptimal;
+	to_present.newLayout     = draw_ime_overlay ? vk::ImageLayout::eColorAttachmentOptimal
+	                                            : vk::ImageLayout::ePresentSrcKHR;
 	to_present.srcQueueFamilyIndex             = VK_QUEUE_FAMILY_IGNORED;
 	to_present.dstQueueFamilyIndex             = VK_QUEUE_FAMILY_IGNORED;
 	to_present.image                           = m_images[m_image_index];
@@ -665,9 +684,22 @@ void Swapchain::RecordPresentCommands(CommandBuffer& command, VulkanImage& sourc
 	to_present.subresourceRange.levelCount     = 1;
 	to_present.subresourceRange.baseArrayLayer = 0;
 	to_present.subresourceRange.layerCount     = 1;
-	vk_command.pipelineBarrier(
-	    vk::PipelineStageFlagBits::eAllCommands, vk::PipelineStageFlagBits::eAllCommands,
-	    vk::DependencyFlagBits::eByRegion, 0, nullptr, 0, nullptr, 1, &to_present);
+	vk_command.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
+	                           draw_ime_overlay ? vk::PipelineStageFlagBits::eColorAttachmentOutput
+	                                            : vk::PipelineStageFlagBits::eAllCommands,
+	                           vk::DependencyFlagBits::eByRegion, 0, nullptr, 0, nullptr, 1,
+	                           &to_present);
+	if (draw_ime_overlay) {
+		m_ime_overlay->Record(vk_command, m_image_views[m_image_index]);
+		to_present.srcAccessMask = vk::AccessFlagBits::eColorAttachmentWrite;
+		to_present.dstAccessMask = vk::AccessFlagBits::eMemoryRead;
+		to_present.oldLayout     = vk::ImageLayout::eColorAttachmentOptimal;
+		to_present.newLayout     = vk::ImageLayout::ePresentSrcKHR;
+		vk_command.pipelineBarrier(vk::PipelineStageFlagBits::eColorAttachmentOutput,
+		                           vk::PipelineStageFlagBits::eAllCommands,
+		                           vk::DependencyFlagBits::eByRegion, 0, nullptr, 0, nullptr, 1,
+		                           &to_present);
+	}
 	command.End();
 }
 
@@ -772,6 +804,12 @@ bool Presenter::IsGuestPaused() const noexcept {
 	return m_impl->window.loop.paused.load(std::memory_order_acquire);
 }
 
+bool Presenter::NeedsImeRefresh() const noexcept {
+	const auto visual = Dialog::ImeDialog::GetVisualState();
+	return visual.active ||
+	       visual.revision != m_impl->presented_ime_revision.load(std::memory_order_acquire);
+}
+
 RenderContext& Presenter::Renderer() const noexcept {
 	return m_impl->renderer;
 }
@@ -789,19 +827,22 @@ void Presenter::Present(Frame& frame, bool reuse) {
 		    [&window] {
 			    window.UpdateIcon();
 			    SDL_ShowWindow(window.window);
+			    SDL_RaiseWindow(window.window);
 		    },
 		    true);
 #else
 		window.UpdateIcon();
 
 		SDL_ShowWindow(window.window);
+		SDL_RaiseWindow(window.window);
 #endif
 
 		window.window_hidden = false;
 		m_impl->RecoverSwapchain(Swapchain::Status::Recreate);
 	}
 
-	auto& swapchain = m_impl->swapchain;
+	const auto ime_visual = Dialog::ImeDialog::GetVisualState();
+	auto&      swapchain  = m_impl->swapchain;
 	for (uint32_t attempt = 0; attempt < 2; attempt++) {
 		auto status = swapchain.AcquireNextImage();
 		if (status != Swapchain::Status::Success) {
@@ -814,8 +855,9 @@ void Presenter::Present(Frame& frame, bool reuse) {
 		{
 			Common::LockGuard render_lock(m_impl->renderer.GetMutex());
 			frame.present_commands->WaitForFenceAndReset();
-			auto& command = *frame.present_commands;
-			swapchain.RecordPresentCommands(command, frame.image);
+			auto&      command          = *frame.present_commands;
+			const bool draw_ime_overlay = ime_visual.active && swapchain.PrepareImeOverlay();
+			swapchain.RecordPresentCommands(command, frame.image, draw_ime_overlay);
 			swapchain.Submit(command);
 		}
 		status = swapchain.Present();
@@ -825,6 +867,7 @@ void Presenter::Present(Frame& frame, bool reuse) {
 		}
 
 		RenderDocOnPresent();
+		m_impl->presented_ime_revision.store(ime_visual.revision, std::memory_order_release);
 		window.UpdateTitle();
 		m_impl->frames.Release(&frame, true);
 		return;

src/graphics/presentation/window/vulkanWindow.cpp

@@ -31,6 +31,7 @@
 #include "graphics/host_gpu/renderer/renderContext.h"
 #include "graphics/host_gpu/vma.h"
 #include "graphics/host_gpu/vulkanCommon.h"
+#include "graphics/presentation/imeDialogOverlay.h"
 #include "graphics/presentation/presenter.h"
 #include "graphics/presentation/renderDoc.h"
 #include "graphics/presentation/videoOut.h"
@@ -1008,6 +1009,7 @@ void WindowContext::RecreateSurface() {
 }
 
 WindowContext::~WindowContext() {
+	ShutdownImeDialogInput();
 	presenter.reset();
 	LibKernel::Memory::InstallGpuResources(nullptr);
 	render_context.reset();

src/graphics/presentation/window/window.cpp

@@ -31,8 +31,11 @@
 #include "graphics/host_gpu/renderer/render.h"
 #include "graphics/host_gpu/vma.h"
 #include "graphics/host_gpu/vulkanCommon.h"
+#include "graphics/presentation/imeDialogOverlay.h"
 #include "graphics/presentation/renderDoc.h"
+#include "graphics/presentation/window/hostInput.h"
 #include "graphics/presentation/window/windowInternal.h"
+#include "kytyGitVersion.h"
 #include "libs/controller.h"
 #include "loader/systemContent.h"
 
@@ -58,8 +61,6 @@
 
 namespace Libs::Graphics {
 
-constexpr int KEYBOARD_CONTROLLER_ID = -1000;
-
 struct EventKeyboard {
 	bool     down;
 	bool     up;
@@ -72,26 +73,6 @@ struct EventKeyboard {
 	double   timestamp_seconds;
 };
 
-static uint32_t KeyboardKeyToPadButton(int key_code) {
-	switch (key_code) {
-		case SDLK_w: return Controller::PAD_BUTTON_UP;
-		case SDLK_a: return Controller::PAD_BUTTON_LEFT;
-		case SDLK_s: return Controller::PAD_BUTTON_DOWN;
-		case SDLK_d: return Controller::PAD_BUTTON_RIGHT;
-		case SDLK_j: return Controller::PAD_BUTTON_CROSS;
-		case SDLK_i: return Controller::PAD_BUTTON_TRIANGLE;
-		case SDLK_k: return Controller::PAD_BUTTON_SQUARE;
-		case SDLK_l: return Controller::PAD_BUTTON_CIRCLE;
-		case SDLK_q: return Controller::PAD_BUTTON_L1;
-		case SDLK_e: return Controller::PAD_BUTTON_R1;
-		case SDLK_RETURN:
-		case SDLK_RETURN2: return Controller::PAD_BUTTON_OPTIONS;
-		case SDLK_BACKSPACE:
-		case SDLK_TAB: return Controller::PAD_BUTTON_TOUCH_PAD;
-		default: return 0;
-	}
-}
-
 static uint32_t ControllerButtonToPadButton(int button) {
 	switch (button) {
 		case SDL_CONTROLLER_BUTTON_A: return Controller::PAD_BUTTON_CROSS;
@@ -260,16 +241,11 @@ static void GameEventKeyboard(WindowLoopState& game, const EventKeyboard& key) {
 		}
 	}
 
-	const auto button = KeyboardKeyToPadButton(key.key_code);
-	if (button != 0 && (key.down || key.up) && !key.repeat) {
-		static bool keyboard_connected = false;
-		if (!keyboard_connected) {
-			Controller::ControllerConnect(KEYBOARD_CONTROLLER_ID);
-			keyboard_connected = true;
-		}
-		Controller::ControllerButton(KEYBOARD_CONTROLLER_ID, button, key.down);
-	}
 #endif
+
+	if ((key.down || key.up) && !key.repeat) {
+		HostInputKey(key.key_code, key.down);
+	}
 }
 
 static void GameEventMouse([[maybe_unused]] const EventMouse& mb) {
@@ -291,6 +267,23 @@ static void GameEventMouse([[maybe_unused]] const EventMouse& mb) {
 		     mb.x, mb.y);
 	}
 #endif
+
+	if (mb.down || mb.up) {
+		uint8_t mouse_button = 0;
+		if (mb.left) {
+			mouse_button = SDL_BUTTON_LEFT;
+		} else if (mb.middle) {
+			mouse_button = SDL_BUTTON_MIDDLE;
+		} else if (mb.right) {
+			mouse_button = SDL_BUTTON_RIGHT;
+		} else if (mb.x1) {
+			mouse_button = SDL_BUTTON_X1;
+		} else if (mb.x2) {
+			mouse_button = SDL_BUTTON_X2;
+		}
+
+		HostInputMouseButton(mouse_button, mb.down);
+	}
 }
 
 static void GameEventFinger([[maybe_unused]] const EventFinger& f) {
@@ -484,6 +477,9 @@ void WindowContext::ProcessEvent(double time_s) {
 	auto& game  = loop;
 	auto* event = &game.event;
 	EXIT_IF(SDL_GetEventState(SDL_DISPLAYEVENT) != SDL_ENABLE);
+	if (ProcessImeDialogInput(*event)) {
+		return;
+	}
 
 	switch (event->type) {
 		case SDL_QUIT: GameEventQuit(game); break;
@@ -794,10 +790,15 @@ static void WindowCreate(WindowContext& context) {
 	if (SDL_InitSubSystem(SDL_INIT_VIDEO | SDL_INIT_GAMECONTROLLER) < 0) {
 		EXIT("%s\n", SDL_GetError());
 	}
+	HostInputInit();
+	InitializeImeDialogInput();
 
 	LOGF("WindowCreate(): width = %d, height = %d\n", width, height);
 
 	uint32_t window_flags = KYTY_SDL_WINDOW_FLAGS;
+	if (Config::FullscreenEnabled()) {
+		window_flags |= static_cast<uint32_t>(SDL_WINDOW_FULLSCREEN_DESKTOP);
+	}
 #if defined(__APPLE__)
 	// macOS 26 window chrome (CoreUI asset decode, SwiftUI titlebar) has been observed
 	// throwing NSExceptions under Rosetta during the first CATransaction commit. A
@@ -937,6 +938,22 @@ void WindowContext::UpdateTitle() {
 	static uint64_t fps_frames  = 0;
 	static double   current_fps = 0.0;
 
+#if KYTY_BUILD == KYTY_BUILD_DEBUG
+	static constexpr auto build_type = "Debug";
+#elif KYTY_BUILD == KYTY_BUILD_RELEASE
+	static constexpr auto build_type = "Release";
+#else
+	static constexpr auto build_type = "Unknown";
+#endif
+
+#if defined(KYTY_OFFICIAL_BUILD)
+	static constexpr auto build_label = "Official build " KYTY_RELEASE_TAG;
+#elif defined(KYTY_FORK_BUILD)
+	static constexpr auto build_label = "Fork build " KYTY_BUILD_REPOSITORY " " KYTY_GIT_HASH;
+#else
+	static constexpr auto build_label = "Source build " KYTY_GIT_HASH;
+#endif
+
 	const auto now       = Common::Timer::QueryPerformanceCounter();
 	const auto frequency = Common::Timer::QueryPerformanceFrequency();
 	frame_num++;
@@ -948,11 +965,11 @@ void WindowContext::UpdateTitle() {
 		fps_frames  = 0;
 	}
 
-	auto fps =
-	    fmt::format("{}{}{}{}{}{}[{}] [{}], frame: {}, fps: {:f}", (has_title ? title : ""),
-	                (has_title ? ", " : ""), (has_title_id ? title_id : ""),
-	                (has_title_id ? ", " : ""), (has_app_ver ? app_ver : ""),
-	                (has_app_ver ? " " : ""), device_name, processor_name, frame_num, current_fps);
+	auto fps = fmt::format("[{} | {}] {}{}{}{}{}{}[{}] [{}], frame: {}, fps: {:f}", build_label,
+	                       build_type, (has_title ? title : ""), (has_title ? ", " : ""),
+	                       (has_title_id ? title_id : ""), (has_title_id ? ", " : ""),
+	                       (has_app_ver ? app_ver : ""), (has_app_ver ? " " : ""), device_name,
+	                       processor_name, frame_num, current_fps);
 
 #if defined(__APPLE__)
 	// AppKit traps on title changes off the main thread; fire-and-forget keeps present pacing.

src/graphics/shader/recompiler/ShaderRecompiler.cpp

@@ -84,6 +84,8 @@ bool InstructionMaySplitSpirvBlock(const IR::Instruction& inst) {
 		case IR::Opcode::AtomicAndU32:
 		case IR::Opcode::AtomicOrU32:
 		case IR::Opcode::AtomicXorU32:
+		case IR::Opcode::AtomicFMinF32:
+		case IR::Opcode::AtomicFMaxF32:
 		case IR::Opcode::FlatLoadUbyte:
 		case IR::Opcode::FlatLoadSbyte:
 		case IR::Opcode::FlatLoadUshort:

src/graphics/shader/recompiler/decompiler/MemoryOps.cpp

@@ -57,6 +57,8 @@ constexpr MemoryOpcodeInfo MUBUF_OPS[] = {
     {0x39u, Opcode::BufferAtomicAnd, 1, 32},
     {0x3au, Opcode::BufferAtomicOr, 1, 32},
     {0x3bu, Opcode::BufferAtomicXor, 1, 32},
+    {0x3fu, Opcode::BufferAtomicFMin, 1, 32},
+    {0x40u, Opcode::BufferAtomicFMax, 1, 32},
 };
 
 constexpr MemoryOpcodeInfo MTBUF_OPS[] = {

src/graphics/shader/recompiler/decompiler/OpcodeTable.h

@@ -0,0 +1,45 @@
+#ifndef EMULATOR_INCLUDE_EMULATOR_GRAPHICS_SHADER_RECOMPILER_DECOMPILER_OPCODETABLE_H_
+#define EMULATOR_INCLUDE_EMULATOR_GRAPHICS_SHADER_RECOMPILER_DECOMPILER_OPCODETABLE_H_
+
+#include "graphics/shader/recompiler/decompiler/ShaderDecoder.h"
+
+#include <cstddef>
+
+namespace Libs::Graphics::ShaderRecompiler::Decoder::Detail {
+
+struct OpcodeMap {
+	uint32_t encoding = 0;
+	Opcode   decoded  = Opcode::Unknown;
+};
+
+template <typename Entry, size_t N>
+constexpr const Entry* FindOpcode(const Entry (&table)[N], uint32_t encoding) {
+	for (const auto& entry: table) {
+		if (entry.encoding == encoding) {
+			return &entry;
+		}
+	}
+	return nullptr;
+}
+
+template <typename Entry, size_t N>
+constexpr Opcode LookupOpcode(const Entry (&table)[N], uint32_t encoding) {
+	const auto* entry = FindOpcode(table, encoding);
+	return entry != nullptr ? entry->decoded : Opcode::Unsupported;
+}
+
+template <typename Entry, size_t N>
+constexpr bool HasUniqueEncodings(const Entry (&table)[N]) {
+	for (size_t i = 0; i < N; i++) {
+		for (size_t j = i + 1; j < N; j++) {
+			if (table[i].encoding == table[j].encoding) {
+				return false;
+			}
+		}
+	}
+	return true;
+}
+
+} // namespace Libs::Graphics::ShaderRecompiler::Decoder::Detail
+
+#endif // EMULATOR_INCLUDE_EMULATOR_GRAPHICS_SHADER_RECOMPILER_DECOMPILER_OPCODETABLE_H_

src/graphics/shader/recompiler/decompiler/ScalarAluOps.cpp

@@ -1,14 +1,11 @@
 #include "graphics/shader/recompiler/decompiler/ScalarAluOps.h"
 
-#include <iterator>
+#include "graphics/shader/recompiler/decompiler/OpcodeTable.h"
 
 namespace Libs::Graphics::ShaderRecompiler::Decoder {
 namespace {
 
-struct OpcodeMap {
-	uint32_t opcode = 0;
-	Opcode   ir     = Opcode::Unknown;
-};
+using Detail::OpcodeMap;
 
 constexpr OpcodeMap SOP2_OPS[] = {
     {0x00u, Opcode::SAddU32},       {0x01u, Opcode::SSubU32},       {0x02u, Opcode::SAddI32},
@@ -58,7 +55,8 @@ constexpr OpcodeMap SOPC_OPS[] = {
     {0x03u, Opcode::SCmpGeI32},   {0x04u, Opcode::SCmpLtI32},   {0x05u, Opcode::SCmpLeI32},
     {0x06u, Opcode::SCmpEqU32},   {0x07u, Opcode::SCmpLgU32},   {0x08u, Opcode::SCmpGtU32},
     {0x09u, Opcode::SCmpGeU32},   {0x0au, Opcode::SCmpLtU32},   {0x0bu, Opcode::SCmpLeU32},
-    {0x0cu, Opcode::SBitcmp0B32}, {0x0du, Opcode::SBitcmp1B32}, {0x13u, Opcode::SCmpLgU64},
+    {0x0cu, Opcode::SBitcmp0B32}, {0x0du, Opcode::SBitcmp1B32}, {0x12u, Opcode::SCmpEqU64},
+    {0x13u, Opcode::SCmpLgU64},
 };
 
 constexpr OpcodeMap SOPK_OPS[] = {
@@ -78,15 +76,11 @@ constexpr OpcodeMap SOPP_OPS[] = {
     {0x0au, Opcode::SBarrier},      {0x0cu, Opcode::SWaitcnt},      {0x0eu, Opcode::SSleep},
     {0x10u, Opcode::SSendmsg},      {0x16u, Opcode::STtraceData},   {0x20u, Opcode::SInstPrefetch},
 };
-
-Opcode Lookup(const OpcodeMap* ops, uint32_t count, uint32_t opcode) {
-	for (uint32_t i = 0; i < count; i++) {
-		if (ops[i].opcode == opcode) {
-			return ops[i].ir;
-		}
-	}
-	return Opcode::Unsupported;
-}
+static_assert(Detail::HasUniqueEncodings(SOP1_OPS));
+static_assert(Detail::HasUniqueEncodings(SOP2_OPS));
+static_assert(Detail::HasUniqueEncodings(SOPK_OPS));
+static_assert(Detail::HasUniqueEncodings(SOPC_OPS));
+static_assert(Detail::HasUniqueEncodings(SOPP_OPS));
 
 bool DecodeBinarySources(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index,
                          Instruction& inst, uint32_t ssrc0, uint32_t ssrc1, std::string* error) {
@@ -111,7 +105,7 @@ bool DecodeSop1(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	inst.word      = word;
 	inst.family    = Family::SOP1;
 	inst.opcode_id = opcode;
-	inst.opcode    = Lookup(SOP1_OPS, static_cast<uint32_t>(std::size(SOP1_OPS)), opcode);
+	inst.opcode    = Detail::LookupOpcode(SOP1_OPS, opcode);
 	SetRawWords(inst, code, word_index, 1);
 
 	if (inst.opcode == Opcode::Unsupported) {
@@ -153,7 +147,7 @@ bool DecodeSop2(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	inst.word      = word;
 	inst.family    = Family::SOP2;
 	inst.opcode_id = opcode;
-	inst.opcode    = Lookup(SOP2_OPS, static_cast<uint32_t>(std::size(SOP2_OPS)), opcode);
+	inst.opcode    = Detail::LookupOpcode(SOP2_OPS, opcode);
 	SetRawWords(inst, code, word_index, 1);
 
 	if (inst.opcode == Opcode::Unsupported) {
@@ -180,7 +174,7 @@ bool DecodeSopk(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	inst.word            = word;
 	inst.family          = Family::SOPK;
 	inst.opcode_id       = opcode;
-	inst.opcode          = Lookup(SOPK_OPS, static_cast<uint32_t>(std::size(SOPK_OPS)), opcode);
+	inst.opcode          = Detail::LookupOpcode(SOPK_OPS, opcode);
 	inst.src0.kind       = OperandKind::IntegerInlineConstant;
 	inst.src0.signed_val = imm;
 	inst.src0.value      = static_cast<uint32_t>(imm);
@@ -237,7 +231,7 @@ bool DecodeSopc(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	inst.word      = word;
 	inst.family    = Family::SOPC;
 	inst.opcode_id = opcode;
-	inst.opcode    = Lookup(SOPC_OPS, static_cast<uint32_t>(std::size(SOPC_OPS)), opcode);
+	inst.opcode    = Detail::LookupOpcode(SOPC_OPS, opcode);
 	inst.dst.kind  = OperandKind::Scc;
 	SetRawWords(inst, code, word_index, 1);
 
@@ -261,7 +255,7 @@ bool DecodeSopp(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	inst.word            = word;
 	inst.family          = Family::SOPP;
 	inst.opcode_id       = opcode;
-	inst.opcode          = Lookup(SOPP_OPS, static_cast<uint32_t>(std::size(SOPP_OPS)), opcode);
+	inst.opcode          = Detail::LookupOpcode(SOPP_OPS, opcode);
 	inst.src0.kind       = OperandKind::LiteralConstant;
 	inst.src0.value      = simm;
 	inst.src0.signed_val = static_cast<int16_t>(simm);

src/graphics/shader/recompiler/decompiler/ShaderDecoder.cpp

@@ -77,6 +77,16 @@ std::string FormatBinary(const Instruction& inst) {
 	return text;
 }
 
+std::string FormatSources(const Instruction& inst) {
+	std::string    text      = fmt::format("0x{:08x}: {}", inst.pc, OpcodeToString(inst.opcode));
+	const Operand* sources[] = {&inst.src0, &inst.src1, &inst.src2, &inst.src3};
+	for (uint32_t i = 0; i < inst.src_count && i < 4u; i++) {
+		text += i == 0 ? " " : ", ";
+		text += OperandToString(*sources[i]);
+	}
+	return text;
+}
+
 std::string FormatMemory(const Instruction& inst) {
 	std::string text = fmt::format("0x{:08x}: {} {}", inst.pc, OpcodeToString(inst.opcode).c_str(),
 	                               OperandToString(inst.dst).c_str());
@@ -511,6 +521,7 @@ std::string OpcodeToString(Opcode opcode) {
 		case Opcode::SCmpGeU32: return "s_cmp_ge_u32";
 		case Opcode::SCmpLtU32: return "s_cmp_lt_u32";
 		case Opcode::SCmpLeU32: return "s_cmp_le_u32";
+		case Opcode::SCmpEqU64: return "s_cmp_eq_u64";
 		case Opcode::SCmpLgU64: return "s_cmp_lg_u64";
 		case Opcode::VNop: return "v_nop";
 		case Opcode::VMovB32: return "v_mov_b32";
@@ -766,6 +777,7 @@ std::string OpcodeToString(Opcode opcode) {
 		case Opcode::VCmpNeU32: return "v_cmp_ne_u32";
 		case Opcode::VCmpGeU32: return "v_cmp_ge_u32";
 		case Opcode::VCmpTU32: return "v_cmp_t_u32";
+		case Opcode::VCmpEqI64: return "v_cmp_eq_i64";
 		case Opcode::VCmpNeU64: return "v_cmp_ne_u64";
 		case Opcode::VCmpxLtU32: return "v_cmpx_lt_u32";
 		case Opcode::VCmpxEqU32: return "v_cmpx_eq_u32";
@@ -823,6 +835,8 @@ std::string OpcodeToString(Opcode opcode) {
 		case Opcode::BufferAtomicAnd: return "buffer_atomic_and";
 		case Opcode::BufferAtomicOr: return "buffer_atomic_or";
 		case Opcode::BufferAtomicXor: return "buffer_atomic_xor";
+		case Opcode::BufferAtomicFMin: return "buffer_atomic_fmin";
+		case Opcode::BufferAtomicFMax: return "buffer_atomic_fmax";
 		case Opcode::FlatLoadUbyte: return "flat_load_ubyte";
 		case Opcode::FlatLoadSbyte: return "flat_load_sbyte";
 		case Opcode::FlatLoadUshort: return "flat_load_ushort";
@@ -983,6 +997,9 @@ std::string InstructionToString(const Instruction& inst) {
 		                   inst.pc, FamilyToString(inst.family).c_str(), inst.opcode_id,
 		                   RawWordsToString(inst).c_str(), inst.unsupported_reason.c_str());
 	}
+	if (inst.family == Family::SOPC) {
+		return WithUnsupportedReason(inst, FormatSources(inst));
+	}
 
 	switch (inst.opcode) {
 		case Opcode::SMovB32:
@@ -1110,6 +1127,8 @@ std::string InstructionToString(const Instruction& inst) {
 		case Opcode::BufferAtomicAnd:
 		case Opcode::BufferAtomicOr:
 		case Opcode::BufferAtomicXor:
+		case Opcode::BufferAtomicFMin:
+		case Opcode::BufferAtomicFMax:
 		case Opcode::BufferLoadSbyte:
 		case Opcode::BufferLoadSshort:
 		case Opcode::FlatLoadUbyte:
@@ -1171,25 +1190,6 @@ std::string InstructionToString(const Instruction& inst) {
 		case Opcode::DsWriteB128:
 		case Opcode::DsWriteAddtidB32:
 		case Opcode::DsReadAddtidB32: return WithUnsupportedReason(inst, FormatMemory(inst));
-		case Opcode::SCmpEqU32:
-		case Opcode::SCmpEqI32:
-		case Opcode::SCmpLgU32:
-		case Opcode::SCmpLgI32:
-		case Opcode::SCmpGtU32:
-		case Opcode::SCmpGtI32:
-		case Opcode::SCmpGeU32:
-		case Opcode::SCmpGeI32:
-		case Opcode::SCmpLtU32:
-		case Opcode::SCmpLtI32:
-		case Opcode::SCmpLeU32:
-		case Opcode::SCmpLeI32:
-		case Opcode::SBitcmp0B32:
-		case Opcode::SBitcmp1B32:
-		case Opcode::SCmpLgU64:
-			return WithUnsupportedReason(inst, fmt::format("0x{:08x}: {} {}, {}", inst.pc,
-			                                               OpcodeToString(inst.opcode).c_str(),
-			                                               OperandToString(inst.src0).c_str(),
-			                                               OperandToString(inst.src1).c_str()));
 		default: return WithUnsupportedReason(inst, FormatBinary(inst));
 	}
 }

src/graphics/shader/recompiler/decompiler/ShaderDecoder.h

@@ -118,6 +118,7 @@ enum class Opcode {
 	SCmpGeU32,
 	SCmpLtU32,
 	SCmpLeU32,
+	SCmpEqU64,
 	SCmpLgU64,
 
 	VNop,
@@ -374,6 +375,7 @@ enum class Opcode {
 	VCmpNeU32,
 	VCmpGeU32,
 	VCmpTU32,
+	VCmpEqI64,
 	VCmpNeU64,
 	VCmpxLtU32,
 	VCmpxEqU32,
@@ -432,6 +434,8 @@ enum class Opcode {
 	BufferAtomicAnd,
 	BufferAtomicOr,
 	BufferAtomicXor,
+	BufferAtomicFMin,
+	BufferAtomicFMax,
 	FlatLoadUbyte,
 	FlatLoadSbyte,
 	FlatLoadUshort,

src/graphics/shader/recompiler/decompiler/VectorAluOps.cpp

@@ -1,43 +1,91 @@
 #include "graphics/shader/recompiler/decompiler/VectorAluOps.h"
 
+#include "graphics/shader/recompiler/decompiler/OpcodeTable.h"
+
 #include <fmt/format.h>
-#include <iterator>
 
 namespace Libs::Graphics::ShaderRecompiler::Decoder {
 namespace {
 
-struct OpcodeMap {
-	uint32_t opcode = 0;
-	Opcode   ir     = Opcode::Unknown;
+using Detail::OpcodeMap;
+
+// These profiles describe the selectors that the current lowering implements. They are not
+// architectural SDWA legality classes.
+enum class Vop2SdwaProfile {
+	None,
+	Cndmask,
+	Float32,
+	Float16,
+	IntegerFullDestination,
+	IntegerPartialDestination,
+	ReverseLogicalRight,
+	ReverseLogicalLeft,
+	Bitwise,
+	Count,
 };
 
-constexpr OpcodeMap VOP2_OPS[] = {
-    {0x01u, Opcode::VCndmaskB32},    {0x02u, Opcode::VDot2cF32F16},
-    {0x03u, Opcode::VAddF32},        {0x04u, Opcode::VSubF32},
-    {0x05u, Opcode::VSubrevF32},     {0x08u, Opcode::VMulF32},
-    {0x09u, Opcode::VMulI32I24},     {0x0bu, Opcode::VMulU32U24},
-    {0x0fu, Opcode::VMinF32},        {0x10u, Opcode::VMaxF32},
-    {0x11u, Opcode::VMinI32},        {0x12u, Opcode::VMaxI32},
-    {0x13u, Opcode::VMinU32},        {0x14u, Opcode::VMaxU32},
-    {0x15u, Opcode::VLshrB32},       {0x16u, Opcode::VLshrrevB32},
-    {0x17u, Opcode::VAshrI32},       {0x18u, Opcode::VAshrrevI32},
-    {0x19u, Opcode::VLshlB32},       {0x1au, Opcode::VLshlrevB32},
-    {0x1bu, Opcode::VAndB32},        {0x1cu, Opcode::VOrB32},
-    {0x1du, Opcode::VXorB32},        {0x1eu, Opcode::VXnorB32},
-    {0x1fu, Opcode::VMacF32},        {0x20u, Opcode::VMadmkF32},
-    {0x21u, Opcode::VMadakF32},      {0x22u, Opcode::VBcntU32B32},
-    {0x23u, Opcode::VMbcntLoU32B32}, {0x24u, Opcode::VMbcntHiU32B32},
-    {0x25u, Opcode::VAddNcU32},      {0x28u, Opcode::VAddcU32},
-    {0x26u, Opcode::VSubNcU32},      {0x27u, Opcode::VSubrevNcU32},
-    {0x2bu, Opcode::VMacF32},        {0x2cu, Opcode::VMadmkF32},
-    {0x2du, Opcode::VMadakF32},      {0x2fu, Opcode::VCvtPkrtzF16F32},
-    {0x32u, Opcode::VAddF16},        {0x33u, Opcode::VSubF16},
-    {0x34u, Opcode::VSubrevF16},     {0x35u, Opcode::VMulF16},
-    {0x36u, Opcode::VFmacF16},       {0x37u, Opcode::VFmamkF16},
-    {0x38u, Opcode::VFmaakF16},      {0x39u, Opcode::VMaxF16},
-    {0x3au, Opcode::VMinF16},        {0x3cu, Opcode::VPkFmacF16},
+struct Vop2OpcodeInfo {
+	uint32_t        encoding     = 0;
+	Opcode          decoded      = Opcode::Unknown;
+	Vop2SdwaProfile sdwa_profile = Vop2SdwaProfile::None;
 };
 
+constexpr Vop2OpcodeInfo VOP2_OPS[] = {
+    {0x01u, Opcode::VCndmaskB32, Vop2SdwaProfile::Cndmask},
+    {0x02u, Opcode::VDot2cF32F16},
+    {0x03u, Opcode::VAddF32, Vop2SdwaProfile::Float32},
+    {0x04u, Opcode::VSubF32, Vop2SdwaProfile::Float32},
+    {0x05u, Opcode::VSubrevF32},
+    {0x08u, Opcode::VMulF32, Vop2SdwaProfile::Float32},
+    {0x09u, Opcode::VMulI32I24, Vop2SdwaProfile::IntegerFullDestination},
+    {0x0bu, Opcode::VMulU32U24, Vop2SdwaProfile::IntegerFullDestination},
+    {0x0fu, Opcode::VMinF32},
+    {0x10u, Opcode::VMaxF32},
+    {0x11u, Opcode::VMinI32},
+    {0x12u, Opcode::VMaxI32},
+    {0x13u, Opcode::VMinU32, Vop2SdwaProfile::IntegerPartialDestination},
+    {0x14u, Opcode::VMaxU32, Vop2SdwaProfile::IntegerFullDestination},
+    {0x15u, Opcode::VLshrB32},
+    {0x16u, Opcode::VLshrrevB32, Vop2SdwaProfile::ReverseLogicalRight},
+    {0x17u, Opcode::VAshrI32},
+    {0x18u, Opcode::VAshrrevI32},
+    {0x19u, Opcode::VLshlB32},
+    {0x1au, Opcode::VLshlrevB32, Vop2SdwaProfile::ReverseLogicalLeft},
+    {0x1bu, Opcode::VAndB32, Vop2SdwaProfile::Bitwise},
+    {0x1cu, Opcode::VOrB32, Vop2SdwaProfile::Bitwise},
+    {0x1du, Opcode::VXorB32, Vop2SdwaProfile::Bitwise},
+    {0x1eu, Opcode::VXnorB32, Vop2SdwaProfile::Bitwise},
+    {0x1fu, Opcode::VMacF32},
+    {0x20u, Opcode::VMadmkF32},
+    {0x21u, Opcode::VMadakF32},
+    {0x22u, Opcode::VBcntU32B32},
+    {0x23u, Opcode::VMbcntLoU32B32},
+    {0x24u, Opcode::VMbcntHiU32B32},
+    {0x25u, Opcode::VAddNcU32, Vop2SdwaProfile::IntegerFullDestination},
+    {0x28u, Opcode::VAddcU32},
+    {0x26u, Opcode::VSubNcU32, Vop2SdwaProfile::IntegerPartialDestination},
+    {0x27u, Opcode::VSubrevNcU32, Vop2SdwaProfile::IntegerFullDestination},
+    {0x2bu, Opcode::VMacF32},
+    {0x2cu, Opcode::VMadmkF32},
+    {0x2du, Opcode::VMadakF32},
+    {0x2fu, Opcode::VCvtPkrtzF16F32},
+    {0x32u, Opcode::VAddF16, Vop2SdwaProfile::Float16},
+    {0x33u, Opcode::VSubF16, Vop2SdwaProfile::Float16},
+    {0x34u, Opcode::VSubrevF16, Vop2SdwaProfile::Float16},
+    {0x35u, Opcode::VMulF16, Vop2SdwaProfile::Float16},
+    {0x36u, Opcode::VFmacF16},
+    {0x37u, Opcode::VFmamkF16},
+    {0x38u, Opcode::VFmaakF16},
+    {0x39u, Opcode::VMaxF16, Vop2SdwaProfile::Float16},
+    {0x3au, Opcode::VMinF16, Vop2SdwaProfile::Float16},
+    {0x3cu, Opcode::VPkFmacF16},
+};
+static_assert(Detail::HasUniqueEncodings(VOP2_OPS));
+
+constexpr Opcode LookupVop2Opcode(uint32_t encoding) {
+	return Detail::LookupOpcode(VOP2_OPS, encoding);
+}
+
 constexpr OpcodeMap VOP1_OPS[] = {
     {0x00u, Opcode::VNop},
     {0x01u, Opcode::VMovB32},
@@ -135,37 +183,59 @@ constexpr OpcodeMap VOP3_ENCODED_VOP1_OPS[] = {
     {0x5eu, Opcode::VRndneF16},
 };
 
-constexpr OpcodeMap VOPC_OPS[] = {
-    {0x00u, Opcode::VCmpFF32},     {0x01u, Opcode::VCmpLtF32},   {0x02u, Opcode::VCmpEqF32},
-    {0x03u, Opcode::VCmpLeF32},    {0x04u, Opcode::VCmpGtF32},   {0x05u, Opcode::VCmpLgF32},
-    {0x06u, Opcode::VCmpGeF32},    {0x07u, Opcode::VCmpOF32},    {0x08u, Opcode::VCmpUF32},
-    {0x09u, Opcode::VCmpNgeF32},   {0x0au, Opcode::VCmpNlgF32},  {0x0bu, Opcode::VCmpNgtF32},
-    {0x0cu, Opcode::VCmpNleF32},   {0x0du, Opcode::VCmpNeqF32},  {0x0eu, Opcode::VCmpNltF32},
-    {0x0fu, Opcode::VCmpTruF32},   {0x11u, Opcode::VCmpxLtF32},  {0x12u, Opcode::VCmpxEqF32},
-    {0x13u, Opcode::VCmpxLeF32},   {0x14u, Opcode::VCmpxGtF32},  {0x15u, Opcode::VCmpxLgF32},
-    {0x16u, Opcode::VCmpxGeF32},   {0x19u, Opcode::VCmpxNgeF32}, {0x1au, Opcode::VCmpxNlgF32},
-    {0x1bu, Opcode::VCmpxNgtF32},  {0x1cu, Opcode::VCmpxNleF32}, {0x1du, Opcode::VCmpxNeqF32},
-    {0x1eu, Opcode::VCmpxNltF32},  {0x80u, Opcode::VCmpFI32},    {0x81u, Opcode::VCmpLtI32},
-    {0x82u, Opcode::VCmpEqI32},    {0x83u, Opcode::VCmpLeI32},   {0x84u, Opcode::VCmpGtI32},
-    {0x85u, Opcode::VCmpNeI32},    {0x86u, Opcode::VCmpGeI32},   {0x87u, Opcode::VCmpTI32},
-    {0x88u, Opcode::VCmpClassF32}, {0x89u, Opcode::VCmpLtI16},   {0x8au, Opcode::VCmpEqI16},
-    {0x8bu, Opcode::VCmpLeI16},    {0x8cu, Opcode::VCmpGtI16},   {0x8du, Opcode::VCmpNeI16},
-    {0x8eu, Opcode::VCmpGeI16},    {0x91u, Opcode::VCmpxLtI32},  {0x92u, Opcode::VCmpxEqI32},
-    {0x93u, Opcode::VCmpxLeI32},   {0x94u, Opcode::VCmpxGtI32},  {0x95u, Opcode::VCmpxNeI32},
-    {0x96u, Opcode::VCmpxGeI32},   {0xa9u, Opcode::VCmpLtU16},   {0xaau, Opcode::VCmpEqU16},
-    {0xabu, Opcode::VCmpLeU16},    {0xacu, Opcode::VCmpGtU16},   {0xadu, Opcode::VCmpNeU16},
-    {0xaeu, Opcode::VCmpGeU16},    {0xc0u, Opcode::VCmpFU32},    {0xc1u, Opcode::VCmpLtU32},
-    {0xc2u, Opcode::VCmpEqU32},    {0xc3u, Opcode::VCmpLeU32},   {0xc4u, Opcode::VCmpGtU32},
-    {0xc5u, Opcode::VCmpNeU32},    {0xc6u, Opcode::VCmpGeU32},   {0xc7u, Opcode::VCmpTU32},
-    {0xd1u, Opcode::VCmpxLtU32},   {0xd2u, Opcode::VCmpxEqU32},  {0xd3u, Opcode::VCmpxLeU32},
-    {0xd4u, Opcode::VCmpxGtU32},   {0xd5u, Opcode::VCmpxNeU32},  {0xd6u, Opcode::VCmpxGeU32},
-    {0xe5u, Opcode::VCmpNeU64},    {0xc9u, Opcode::VCmpLtF16},   {0xcau, Opcode::VCmpEqF16},
-    {0xcbu, Opcode::VCmpLeF16},    {0xccu, Opcode::VCmpGtF16},   {0xcdu, Opcode::VCmpLgF16},
-    {0xceu, Opcode::VCmpGeF16},    {0xedu, Opcode::VCmpNeqF16},  {0xd9u, Opcode::VCmpxLtF16},
-    {0xdau, Opcode::VCmpxEqF16},   {0xdbu, Opcode::VCmpxLeF16},  {0xdcu, Opcode::VCmpxGtF16},
-    {0xdeu, Opcode::VCmpxGeF16},   {0xfdu, Opcode::VCmpxNeqF16}, {0xfeu, Opcode::VCmpxNltF16},
+struct VopcOpcodeInfo {
+	uint32_t encoding     = 0;
+	Opcode   decoded      = Opcode::Unknown;
+	bool     supports_dpp = true;
 };
 
+constexpr VopcOpcodeInfo VOPC_OPS[] = {
+    {0x00u, Opcode::VCmpFF32},         {0x01u, Opcode::VCmpLtF32},
+    {0x02u, Opcode::VCmpEqF32},        {0x03u, Opcode::VCmpLeF32},
+    {0x04u, Opcode::VCmpGtF32},        {0x05u, Opcode::VCmpLgF32},
+    {0x06u, Opcode::VCmpGeF32},        {0x07u, Opcode::VCmpOF32},
+    {0x08u, Opcode::VCmpUF32},         {0x09u, Opcode::VCmpNgeF32},
+    {0x0au, Opcode::VCmpNlgF32},       {0x0bu, Opcode::VCmpNgtF32},
+    {0x0cu, Opcode::VCmpNleF32},       {0x0du, Opcode::VCmpNeqF32},
+    {0x0eu, Opcode::VCmpNltF32},       {0x0fu, Opcode::VCmpTruF32},
+    {0x11u, Opcode::VCmpxLtF32},       {0x12u, Opcode::VCmpxEqF32},
+    {0x13u, Opcode::VCmpxLeF32},       {0x14u, Opcode::VCmpxGtF32},
+    {0x15u, Opcode::VCmpxLgF32},       {0x16u, Opcode::VCmpxGeF32},
+    {0x19u, Opcode::VCmpxNgeF32},      {0x1au, Opcode::VCmpxNlgF32},
+    {0x1bu, Opcode::VCmpxNgtF32},      {0x1cu, Opcode::VCmpxNleF32},
+    {0x1du, Opcode::VCmpxNeqF32},      {0x1eu, Opcode::VCmpxNltF32},
+    {0x80u, Opcode::VCmpFI32},         {0x81u, Opcode::VCmpLtI32},
+    {0x82u, Opcode::VCmpEqI32},        {0x83u, Opcode::VCmpLeI32},
+    {0x84u, Opcode::VCmpGtI32},        {0x85u, Opcode::VCmpNeI32},
+    {0x86u, Opcode::VCmpGeI32},        {0x87u, Opcode::VCmpTI32},
+    {0x88u, Opcode::VCmpClassF32},     {0x89u, Opcode::VCmpLtI16},
+    {0x8au, Opcode::VCmpEqI16},        {0x8bu, Opcode::VCmpLeI16},
+    {0x8cu, Opcode::VCmpGtI16},        {0x8du, Opcode::VCmpNeI16},
+    {0x8eu, Opcode::VCmpGeI16},        {0x91u, Opcode::VCmpxLtI32},
+    {0x92u, Opcode::VCmpxEqI32},       {0x93u, Opcode::VCmpxLeI32},
+    {0x94u, Opcode::VCmpxGtI32},       {0x95u, Opcode::VCmpxNeI32},
+    {0x96u, Opcode::VCmpxGeI32},       {0xa9u, Opcode::VCmpLtU16},
+    {0xaau, Opcode::VCmpEqU16},        {0xabu, Opcode::VCmpLeU16},
+    {0xacu, Opcode::VCmpGtU16},        {0xadu, Opcode::VCmpNeU16},
+    {0xaeu, Opcode::VCmpGeU16},        {0xc0u, Opcode::VCmpFU32},
+    {0xc1u, Opcode::VCmpLtU32},        {0xc2u, Opcode::VCmpEqU32},
+    {0xc3u, Opcode::VCmpLeU32},        {0xc4u, Opcode::VCmpGtU32},
+    {0xc5u, Opcode::VCmpNeU32},        {0xc6u, Opcode::VCmpGeU32},
+    {0xc7u, Opcode::VCmpTU32},         {0xa2u, Opcode::VCmpEqI64, false},
+    {0xd1u, Opcode::VCmpxLtU32},       {0xd2u, Opcode::VCmpxEqU32},
+    {0xd3u, Opcode::VCmpxLeU32},       {0xd4u, Opcode::VCmpxGtU32},
+    {0xd5u, Opcode::VCmpxNeU32},       {0xd6u, Opcode::VCmpxGeU32},
+    {0xe5u, Opcode::VCmpNeU64, false}, {0xc9u, Opcode::VCmpLtF16},
+    {0xcau, Opcode::VCmpEqF16},        {0xcbu, Opcode::VCmpLeF16},
+    {0xccu, Opcode::VCmpGtF16},        {0xcdu, Opcode::VCmpLgF16},
+    {0xceu, Opcode::VCmpGeF16},        {0xedu, Opcode::VCmpNeqF16},
+    {0xd9u, Opcode::VCmpxLtF16},       {0xdau, Opcode::VCmpxEqF16},
+    {0xdbu, Opcode::VCmpxLeF16},       {0xdcu, Opcode::VCmpxGtF16},
+    {0xdeu, Opcode::VCmpxGeF16},       {0xfdu, Opcode::VCmpxNeqF16},
+    {0xfeu, Opcode::VCmpxNltF16},
+};
+static_assert(Detail::HasUniqueEncodings(VOPC_OPS));
+
 constexpr OpcodeMap VOP3_OPS[] = {
     {0x141u, Opcode::VMadF32},          {0x142u, Opcode::VMadI32I24},
     {0x143u, Opcode::VMadU32U24},       {0x176u, Opcode::VMadU64U32},
@@ -214,16 +284,6 @@ constexpr OpcodeMap VOP3P_OPS[] = {
     {0x22u, Opcode::VMadMixhiF16},
 };
 
-Opcode Lookup(const OpcodeMap* ops, uint32_t count, uint32_t opcode) {
-	for (uint32_t i = 0; i < count; i++) {
-		const auto& op = ops[i];
-		if (op.opcode == opcode) {
-			return op.ir;
-		}
-	}
-	return Opcode::Unsupported;
-}
-
 bool IsVop2LiteralMadOpcode(uint32_t opcode) {
 	return opcode == 0x20u || opcode == 0x21u || opcode == 0x2cu || opcode == 0x2du;
 }
@@ -234,24 +294,23 @@ bool IsUnsupportedVop3EncodedVop2Alias(uint32_t opcode) {
 }
 
 Opcode LookupVop3Opcode(uint32_t opcode) {
-	const auto direct = Lookup(VOP3_OPS, static_cast<uint32_t>(std::size(VOP3_OPS)), opcode);
+	const auto direct = Detail::LookupOpcode(VOP3_OPS, opcode);
 	if (direct != Opcode::Unsupported) {
 		return direct;
 	}
 	if (opcode <= 0xffu) {
-		return Lookup(VOPC_OPS, static_cast<uint32_t>(std::size(VOPC_OPS)), opcode);
+		return Detail::LookupOpcode(VOPC_OPS, opcode);
 	}
 	if (opcode >= 0x100u && opcode <= 0x13fu) {
 		if (IsUnsupportedVop3EncodedVop2Alias(opcode - 0x100u)) {
 			return Opcode::Unsupported;
 		}
-		return Lookup(VOP2_OPS, static_cast<uint32_t>(std::size(VOP2_OPS)), opcode - 0x100u);
+		return LookupVop2Opcode(opcode - 0x100u);
 	}
 	if (opcode >= 0x180u && opcode <= 0x1ffu) {
-		return Lookup(VOP3_ENCODED_VOP1_OPS,
-		              static_cast<uint32_t>(std::size(VOP3_ENCODED_VOP1_OPS)), opcode - 0x180u);
+		return Detail::LookupOpcode(VOP3_ENCODED_VOP1_OPS, opcode - 0x180u);
 	}
-	return Lookup(VOP3_OPS, static_cast<uint32_t>(std::size(VOP3_OPS)), opcode);
+	return Detail::LookupOpcode(VOP3_OPS, opcode);
 }
 
 bool IsVop3EncodedVopc(uint32_t opcode) {
@@ -791,7 +850,6 @@ Vop2SdwaFields DecodeVop2SdwaFields(uint32_t modifier) {
 }
 
 struct Vop2SdwaRule {
-	Opcode   opcode           = Opcode::Unknown;
 	uint32_t dst_selectors    = SdwaSelFull();
 	uint32_t src0_selectors   = SdwaSelFull();
 	uint32_t src1_selectors   = SdwaSelFull();
@@ -804,46 +862,27 @@ constexpr uint32_t SdwaSelAll() {
 }
 
 constexpr Vop2SdwaRule VOP2_SDWA_RULES[] = {
-    {Opcode::VCndmaskB32, SdwaSelWords(), SdwaSelWords() | SdwaSelFull(),
-     SdwaSelWords() | SdwaSelFull(), true, false},
-    {Opcode::VAddF32, SdwaSelFull(), SdwaSelFull(), SdwaSelFull(), false, true},
-    {Opcode::VSubF32, SdwaSelFull(), SdwaSelFull(), SdwaSelFull(), false, true},
-    {Opcode::VMulF32, SdwaSelFull(), SdwaSelFull(), SdwaSelFull(), false, true},
-    {Opcode::VAddF16, SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(),
-     SdwaSelWords() | SdwaSelFull(), true, true},
-    {Opcode::VSubF16, SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(),
-     SdwaSelWords() | SdwaSelFull(), true, true},
-    {Opcode::VSubrevF16, SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(),
-     SdwaSelWords() | SdwaSelFull(), true, true},
-    {Opcode::VMulF16, SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(),
-     SdwaSelWords() | SdwaSelFull(), true, true},
-    {Opcode::VMaxF16, SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(),
-     SdwaSelWords() | SdwaSelFull(), true, true},
-    {Opcode::VMinF16, SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(),
-     SdwaSelWords() | SdwaSelFull(), true, true},
-    {Opcode::VMulI32I24, SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
-    {Opcode::VMulU32U24, SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
-    {Opcode::VMinU32, SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
-    {Opcode::VMaxU32, SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
-    {Opcode::VLshrrevB32, SdwaSelFull(), SdwaSelFull(), SdwaSelWords() | SdwaSelFull(), false,
-     false},
-    {Opcode::VLshlrevB32, SdwaSelFull(), SdwaSelFull(), SdwaSelAll(), false, false},
-    {Opcode::VAndB32, SdwaSelWords() | SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), true, false},
-    {Opcode::VOrB32, SdwaSelWords() | SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), true, false},
-    {Opcode::VXorB32, SdwaSelWords() | SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), true, false},
-    {Opcode::VXnorB32, SdwaSelWords() | SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), true, false},
-    {Opcode::VAddNcU32, SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
-    {Opcode::VSubNcU32, SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
-    {Opcode::VSubrevNcU32, SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
+    {},
+    {SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(),
+     true, false},
+    {SdwaSelFull(), SdwaSelFull(), SdwaSelFull(), false, true},
+    {SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(), SdwaSelWords() | SdwaSelFull(),
+     true, true},
+    {SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), false, false},
+    {SdwaSelAll(), SdwaSelAll(), SdwaSelAll(), true, false},
+    {SdwaSelFull(), SdwaSelFull(), SdwaSelWords() | SdwaSelFull(), false, false},
+    {SdwaSelFull(), SdwaSelFull(), SdwaSelAll(), false, false},
+    {SdwaSelWords() | SdwaSelFull(), SdwaSelAll(), SdwaSelAll(), true, false},
 };
+static_assert(sizeof(VOP2_SDWA_RULES) / sizeof(VOP2_SDWA_RULES[0]) ==
+              static_cast<size_t>(Vop2SdwaProfile::Count));
 
-const Vop2SdwaRule* FindVop2SdwaRule(Opcode opcode) {
-	for (const auto& rule: VOP2_SDWA_RULES) {
-		if (rule.opcode == opcode) {
-			return &rule;
-		}
+const Vop2SdwaRule* FindVop2SdwaRule(uint32_t encoding) {
+	const auto* info = Detail::FindOpcode(VOP2_OPS, encoding);
+	if (info == nullptr || info->sdwa_profile == Vop2SdwaProfile::None) {
+		return nullptr;
 	}
-	return nullptr;
+	return &VOP2_SDWA_RULES[static_cast<size_t>(info->sdwa_profile)];
 }
 
 bool IsVop2SdwaDestinationSupported(const Vop2SdwaRule& rule, const Vop2SdwaFields& fields) {
@@ -881,7 +920,7 @@ bool ValidateVop2Sdwa(Instruction& inst, uint32_t opcode, const Vop2SdwaFields&
 		return true;
 	}
 
-	const auto* rule = FindVop2SdwaRule(inst.opcode);
+	const auto* rule = FindVop2SdwaRule(opcode);
 	if (rule == nullptr) {
 		SetUnsupported(inst, Family::VOP2, opcode,
 		               "VOP2 SDWA modifier is not supported for opcode");
@@ -1135,6 +1174,11 @@ bool DecodeVopcDpp(uint32_t pc, std::span<const uint32_t> code, uint32_t word_in
 		SetUnsupported(inst, Family::VOPC, opcode, "VOPC opcode is not implemented");
 		return true;
 	}
+	const auto* info = Detail::FindOpcode(VOPC_OPS, opcode);
+	if (info == nullptr || !info->supports_dpp) {
+		SetUnsupported(inst, Family::VOPC, opcode, "VOPC DPP modifier is not supported for opcode");
+		return true;
+	}
 	if (!DecodeScalarSource(src0 + 256u, pc, inst.src0, error) ||
 	    !DecodeVectorGpr(vsrc1, inst.src1, error)) {
 		return false;
@@ -1427,7 +1471,7 @@ bool DecodeVop2(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	inst.word      = word;
 	inst.family    = Family::VOP2;
 	inst.opcode_id = opcode;
-	inst.opcode    = Lookup(VOP2_OPS, static_cast<uint32_t>(std::size(VOP2_OPS)), opcode);
+	inst.opcode    = LookupVop2Opcode(opcode);
 	SetRawWords(inst, code, word_index, 1);
 
 	switch (opcode) {
@@ -1468,7 +1512,7 @@ bool DecodeVop1(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	inst.word      = word;
 	inst.family    = Family::VOP1;
 	inst.opcode_id = opcode;
-	inst.opcode    = Lookup(VOP1_OPS, static_cast<uint32_t>(std::size(VOP1_OPS)), opcode);
+	inst.opcode    = Detail::LookupOpcode(VOP1_OPS, opcode);
 	SetRawWords(inst, code, word_index, 1);
 
 	if (inst.opcode == Opcode::Unsupported) {
@@ -1509,7 +1553,7 @@ bool DecodeVopc(uint32_t pc, std::span<const uint32_t> code, uint32_t word_index
 	inst.word      = word;
 	inst.family    = Family::VOPC;
 	inst.opcode_id = opcode;
-	inst.opcode    = Lookup(VOPC_OPS, static_cast<uint32_t>(std::size(VOPC_OPS)), opcode);
+	inst.opcode    = Detail::LookupOpcode(VOPC_OPS, opcode);
 	inst.dst.kind  = IsVopcCompareExec(inst.opcode) ? OperandKind::ExecLo : OperandKind::VccLo;
 	SetRawWords(inst, code, word_index, 1);
 
@@ -1723,7 +1767,7 @@ bool DecodeVop3p(uint32_t pc, std::span<const uint32_t> code, uint32_t word_inde
 	inst.word      = word0;
 	inst.family    = Family::VOP3P;
 	inst.opcode_id = opcode;
-	inst.opcode    = Lookup(VOP3P_OPS, static_cast<uint32_t>(std::size(VOP3P_OPS)), opcode);
+	inst.opcode    = Detail::LookupOpcode(VOP3P_OPS, opcode);
 	SetRawWords(inst, code, word_index, 2);
 
 	if (inst.opcode == Opcode::Unsupported) {

src/graphics/shader/recompiler/emitter/SpirvEmitter.cpp

@@ -131,7 +131,9 @@ bool IsAtomic(IR::Opcode op) {
 		case IR::Opcode::AtomicUMaxU32:
 		case IR::Opcode::AtomicAndU32:
 		case IR::Opcode::AtomicOrU32:
-		case IR::Opcode::AtomicXorU32: return true;
+		case IR::Opcode::AtomicXorU32:
+		case IR::Opcode::AtomicFMinF32:
+		case IR::Opcode::AtomicFMaxF32: return true;
 		default: return false;
 	}
 }
@@ -141,6 +143,9 @@ uint32_t BufferAddressOperandCount(const IR::Instruction& inst) {
 }
 
 bool ValidateInstructionContract(const IR::Instruction& inst, std::string* error) {
+	if (static_cast<size_t>(inst.op) >= static_cast<size_t>(IR::Opcode::Count)) {
+		return Fail(error, "IR instruction opcode is out of range");
+	}
 	if (inst.src_count > std::size(inst.src)) {
 		return Fail(error, "instruction source count exceeds fixed IR storage");
 	}
@@ -200,6 +205,12 @@ bool ValidateInstructionContract(const IR::Instruction& inst, std::string* error
 	     inst.src_count != 2)) {
 		return Fail(error, "storage image instruction has an invalid resource class");
 	}
+	const auto float_atomic =
+	    inst.op == IR::Opcode::AtomicFMinF32 || inst.op == IR::Opcode::AtomicFMaxF32;
+	if (float_atomic &&
+	    (kind != IR::ResourceKind::Buffer || inst.src_count != buffer_address_count + 1u)) {
+		return Fail(error, "floating-point atomic instruction must target a buffer");
+	}
 	if (IsAtomic(inst.op) &&
 	    !((kind == IR::ResourceKind::Buffer && inst.src_count == buffer_address_count + 1u) ||
 	      ((kind == IR::ResourceKind::Lds || kind == IR::ResourceKind::Gds) &&
@@ -389,7 +400,7 @@ bool ProgramRequiresExactSubgroupSize(const IR::Program& program) {
 			if (Emitter::InstructionHasDppSource(inst)) {
 				return true;
 			}
-			if (Emitter::IsCompareOpcode(inst.op) && !Emitter::IsSccOperand(inst.dst)) {
+			if (IR::IsCompareOpcode(inst.op) && !Emitter::IsSccOperand(inst.dst)) {
 				return true;
 			}
 			if ((IsExecDestination(inst.dst) || IsExecDestination(inst.dst2)) &&
@@ -488,6 +499,13 @@ bool EmitProgram(const IR::Program& program, const IR::ResourceSnapshot& resourc
 	AllocateBlockLabels(state, program);
 	AllocateDispatcherState(state, program);
 	EmitFunction(state, program);
+	if (state.unsupported_ir_instruction) {
+		char pc[9] {};
+		std::snprintf(pc, sizeof(pc), "%08x", state.unsupported_ir_pc);
+		return Fail(error, "SPIR-V emitter has no handler for IR opcode " +
+		                       std::string(IR::OpcodeName(state.unsupported_ir_opcode)) +
+		                       " at pc 0x" + pc);
+	}
 
 	ReportReserveExceeded(program, "registers", state.registers.size());
 	ReportReserveExceeded(program, "inputs", state.inputs.size());

src/graphics/shader/recompiler/emitter/spirvEmitterAluOps.cpp

@@ -1486,17 +1486,20 @@ void EmitBitCompareB32(EmitterState& state, const IR::Instruction& inst, bool bi
 	EmitStoreU32(state, inst.dst, ret);
 }
 
-void EmitCompareNeU64(EmitterState& state, const IR::Instruction& inst) {
-	const auto lhs_low  = EmitSequentialValueLoad(state, inst.src[0], 0);
-	const auto lhs_high = EmitSequentialValueLoad(state, inst.src[0], 1);
-	const auto rhs_low  = EmitSequentialValueLoad(state, inst.src[1], 0);
-	const auto rhs_high = EmitSequentialValueLoad(state, inst.src[1], 1);
-	const auto ne_low   = state.builder.AllocateId();
-	const auto ne_high  = state.builder.AllocateId();
-	const auto cond     = state.builder.AllocateId();
-	state.builder.AddFunction({OpINotEqual, state.bool_type, ne_low, lhs_low, rhs_low});
-	state.builder.AddFunction({OpINotEqual, state.bool_type, ne_high, lhs_high, rhs_high});
-	state.builder.AddFunction({OpLogicalOr, state.bool_type, cond, ne_low, ne_high});
+void EmitCompareU64(EmitterState& state, const IR::Instruction& inst) {
+	const bool equal      = inst.op == IR::Opcode::CompareEqU64;
+	const auto lhs_low    = EmitSequentialValueLoad(state, inst.src[0], 0);
+	const auto lhs_high   = EmitSequentialValueLoad(state, inst.src[0], 1);
+	const auto rhs_low    = EmitSequentialValueLoad(state, inst.src[1], 0);
+	const auto rhs_high   = EmitSequentialValueLoad(state, inst.src[1], 1);
+	const auto low        = state.builder.AllocateId();
+	const auto high       = state.builder.AllocateId();
+	const auto cond       = state.builder.AllocateId();
+	const auto compare_op = equal ? OpIEqual : OpINotEqual;
+	state.builder.AddFunction({compare_op, state.bool_type, low, lhs_low, rhs_low});
+	state.builder.AddFunction({compare_op, state.bool_type, high, lhs_high, rhs_high});
+	state.builder.AddFunction(
+	    {equal ? OpLogicalAnd : OpLogicalOr, state.bool_type, cond, low, high});
 	EmitCompareResult(state, inst.dst, cond);
 }
 

src/graphics/shader/recompiler/emitter/spirvEmitterAnalysis.cpp

@@ -75,8 +75,6 @@ bool IsSccOperand(const IR::Operand& operand) {
 	return operand.kind == IR::OperandKind::Register && operand.reg.file == IR::RegisterFile::Scc;
 }
 
-bool IsCompareOpcode(IR::Opcode op);
-
 void CollectMaskStateRegisters(std::vector<RegisterBinding>& registers) {
 	CollectRegister(registers, {IR::RegisterFile::Exec, 0});
 	CollectRegister(registers, {IR::RegisterFile::Exec, 1});
@@ -189,11 +187,11 @@ void CollectRegisters(const IR::Program& program, std::vector<RegisterBinding>&
 			if (inst.op == IR::Opcode::BitCountU64 || inst.op == IR::Opcode::FindMsbFromHighU64) {
 				CollectSequentialRegisters(registers, inst.src[0], 2);
 			}
-			if (inst.op == IR::Opcode::CompareNeU64) {
+			if (IR::IsCompare64Opcode(inst.op)) {
 				CollectSequentialRegisters(registers, inst.src[0], 2);
 				CollectSequentialRegisters(registers, inst.src[1], 2);
 			}
-			if (IsCompareOpcode(inst.op) && inst.dst.kind == IR::OperandKind::Register &&
+			if (IR::IsCompareOpcode(inst.op) && inst.dst.kind == IR::OperandKind::Register &&
 			    inst.dst.reg.file != IR::RegisterFile::Scc) {
 				CollectSequentialRegisters(registers, inst.dst, 2);
 			}
@@ -384,93 +382,6 @@ bool ProgramNeedsSubgroupShuffle(const IR::Program& program) {
 	return false;
 }
 
-bool IsCompareOpcode(IR::Opcode op) {
-	switch (op) {
-		case IR::Opcode::CompareFalse:
-		case IR::Opcode::CompareTrue:
-		case IR::Opcode::CompareEqU32:
-		case IR::Opcode::CompareNeU32:
-		case IR::Opcode::CompareGtU32:
-		case IR::Opcode::CompareGeU32:
-		case IR::Opcode::CompareLtU32:
-		case IR::Opcode::CompareLeU32:
-		case IR::Opcode::CompareNeU64:
-		case IR::Opcode::CompareMaskEqU32:
-		case IR::Opcode::CompareMaskNeU32:
-		case IR::Opcode::CompareMaskGtU32:
-		case IR::Opcode::CompareMaskGeU32:
-		case IR::Opcode::CompareMaskLtU32:
-		case IR::Opcode::CompareMaskLeU32:
-		case IR::Opcode::CompareEqI32:
-		case IR::Opcode::CompareNeI32:
-		case IR::Opcode::CompareGtI32:
-		case IR::Opcode::CompareGeI32:
-		case IR::Opcode::CompareLtI32:
-		case IR::Opcode::CompareLeI32:
-		case IR::Opcode::CompareEqI16:
-		case IR::Opcode::CompareNeI16:
-		case IR::Opcode::CompareGtI16:
-		case IR::Opcode::CompareGeI16:
-		case IR::Opcode::CompareLtI16:
-		case IR::Opcode::CompareLeI16:
-		case IR::Opcode::CompareMaskEqI32:
-		case IR::Opcode::CompareMaskNeI32:
-		case IR::Opcode::CompareMaskGtI32:
-		case IR::Opcode::CompareMaskGeI32:
-		case IR::Opcode::CompareMaskLtI32:
-		case IR::Opcode::CompareMaskLeI32:
-		case IR::Opcode::CompareEqU16:
-		case IR::Opcode::CompareNeU16:
-		case IR::Opcode::CompareGtU16:
-		case IR::Opcode::CompareGeU16:
-		case IR::Opcode::CompareLtU16:
-		case IR::Opcode::CompareLeU16:
-		case IR::Opcode::CompareEqF32:
-		case IR::Opcode::CompareNeF32:
-		case IR::Opcode::CompareGtF32:
-		case IR::Opcode::CompareGeF32:
-		case IR::Opcode::CompareLtF32:
-		case IR::Opcode::CompareLeF32:
-		case IR::Opcode::CompareOrderedF32:
-		case IR::Opcode::CompareUnorderedF32:
-		case IR::Opcode::CompareUnordEqF32:
-		case IR::Opcode::CompareUnordNeF32:
-		case IR::Opcode::CompareUnordGtF32:
-		case IR::Opcode::CompareUnordGeF32:
-		case IR::Opcode::CompareUnordLtF32:
-		case IR::Opcode::CompareUnordLeF32:
-		case IR::Opcode::CompareClassF32:
-		case IR::Opcode::CompareEqF16:
-		case IR::Opcode::CompareNeF16:
-		case IR::Opcode::CompareGtF16:
-		case IR::Opcode::CompareGeF16:
-		case IR::Opcode::CompareLtF16:
-		case IR::Opcode::CompareLeF16:
-		case IR::Opcode::CompareUnordNeF16:
-		case IR::Opcode::CompareMaskEqF16:
-		case IR::Opcode::CompareMaskNeF16:
-		case IR::Opcode::CompareMaskGtF16:
-		case IR::Opcode::CompareMaskGeF16:
-		case IR::Opcode::CompareMaskLtF16:
-		case IR::Opcode::CompareMaskLeF16:
-		case IR::Opcode::CompareMaskUnordNeF16:
-		case IR::Opcode::CompareMaskUnordGeF16:
-		case IR::Opcode::CompareMaskEqF32:
-		case IR::Opcode::CompareMaskNeF32:
-		case IR::Opcode::CompareMaskGtF32:
-		case IR::Opcode::CompareMaskGeF32:
-		case IR::Opcode::CompareMaskLtF32:
-		case IR::Opcode::CompareMaskLeF32:
-		case IR::Opcode::CompareMaskUnordEqF32:
-		case IR::Opcode::CompareMaskUnordNeF32:
-		case IR::Opcode::CompareMaskUnordGtF32:
-		case IR::Opcode::CompareMaskUnordGeF32:
-		case IR::Opcode::CompareMaskUnordLtF32:
-		case IR::Opcode::CompareMaskUnordLeF32: return true;
-		default: return false;
-	}
-}
-
 bool ProgramNeedsSubgroupLocalInvocationId(const IR::Program& program) {
 	for (const auto& block: program.blocks) {
 		for (const auto& inst: block.instructions) {
@@ -481,7 +392,7 @@ bool ProgramNeedsSubgroupLocalInvocationId(const IR::Program& program) {
 			    InstructionHasDppSource(inst)) {
 				return true;
 			}
-			if (IsCompareOpcode(inst.op)) {
+			if (IR::IsCompareOpcode(inst.op)) {
 				return true;
 			}
 			if (inst.dst.kind == IR::OperandKind::Register &&

src/graphics/shader/recompiler/emitter/spirvEmitterControlFlow.cpp

@@ -516,7 +516,8 @@ void EmitInstruction(EmitterState& state, const IR::Instruction& inst) {
 		case IR::Opcode::CompareGeU32: EmitCompareU32(state, inst, OpUGreaterThanEqual); break;
 		case IR::Opcode::CompareLtU32: EmitCompareU32(state, inst, OpULessThan); break;
 		case IR::Opcode::CompareLeU32: EmitCompareU32(state, inst, OpULessThanEqual); break;
-		case IR::Opcode::CompareNeU64: EmitCompareNeU64(state, inst); break;
+		case IR::Opcode::CompareEqU64:
+		case IR::Opcode::CompareNeU64: EmitCompareU64(state, inst); break;
 		case IR::Opcode::CompareMaskEqU32: EmitCompareMaskU32(state, inst, OpIEqual); break;
 		case IR::Opcode::CompareMaskNeU32: EmitCompareMaskU32(state, inst, OpINotEqual); break;
 		case IR::Opcode::CompareMaskGtU32: EmitCompareMaskU32(state, inst, OpUGreaterThan); break;
@@ -774,6 +775,12 @@ void EmitInstruction(EmitterState& state, const IR::Instruction& inst) {
 		case IR::Opcode::AtomicXorU32:
 			EmitGuardedByExec(state, [&]() { EmitAtomicU32(state, inst, OpAtomicXor); });
 			break;
+		case IR::Opcode::AtomicFMinF32:
+			EmitGuardedByExec(state, [&]() { EmitAtomicFMinF32(state, inst); });
+			break;
+		case IR::Opcode::AtomicFMaxF32:
+			EmitGuardedByExec(state, [&]() { EmitAtomicFMaxF32(state, inst); });
+			break;
 		case IR::Opcode::FlatLoadUbyte: EmitFlatLoadUbyte(state, inst); break;
 		case IR::Opcode::FlatLoadSbyte: EmitFlatLoadSbyte(state, inst); break;
 		case IR::Opcode::FlatLoadUshort: EmitFlatLoadUshort(state, inst); break;
@@ -850,7 +857,13 @@ void EmitInstruction(EmitterState& state, const IR::Instruction& inst) {
 			}
 			EmitGuardedByExec(state, [&]() { EmitExport(state, inst); });
 			break;
-		default: break;
+		default:
+			if (!state.unsupported_ir_instruction) {
+				state.unsupported_ir_instruction = true;
+				state.unsupported_ir_opcode      = inst.op;
+				state.unsupported_ir_pc          = inst.pc;
+			}
+			break;
 	}
 }
 

src/graphics/shader/recompiler/emitter/spirvEmitterInternal.h

@@ -414,6 +414,9 @@ struct EmitterState {
 	bool                                             needs_image_gather_extended           = false;
 	bool                                             needs_function_lds                    = false;
 	bool                                             needs_pixel_valid_mask                = false;
+	bool                                             unsupported_ir_instruction            = false;
+	IR::Opcode                                       unsupported_ir_opcode = IR::Opcode::Count;
+	uint32_t                                         unsupported_ir_pc     = 0;
 	std::vector<RegisterBinding>                     registers;
 	std::vector<InputBinding>                        inputs;
 	std::vector<OutputBinding>                       outputs;
@@ -611,8 +614,6 @@ bool IsMaskRegisterFile(IR::RegisterFile file);
 
 bool IsSccOperand(const IR::Operand& operand);
 
-bool IsCompareOpcode(IR::Opcode op);
-
 void CollectMaskStateRegisters(std::vector<RegisterBinding>& registers);
 
 void CollectSequentialRegisters(std::vector<RegisterBinding>& registers, const IR::Operand& base,
@@ -651,8 +652,6 @@ bool ProgramNeedsSubgroupBallot(const IR::Program& program);
 
 bool ProgramNeedsSubgroupShuffle(const IR::Program& program);
 
-bool IsCompareOpcode(IR::Opcode op);
-
 bool ProgramNeedsSubgroupLocalInvocationId(const IR::Program& program);
 
 uint32_t PointerForRegister(const EmitterState& state, IR::Register reg);
@@ -1015,6 +1014,9 @@ void EmitDeviceAtomicMemoryBarrier(EmitterState& state);
 
 void EmitAtomicU32(EmitterState& state, const IR::Instruction& inst, uint32_t opcode);
 
+void EmitAtomicFMinF32(EmitterState& state, const IR::Instruction& inst);
+void EmitAtomicFMaxF32(EmitterState& state, const IR::Instruction& inst);
+
 void EmitSLoadDword(EmitterState& state, const IR::Instruction& inst);
 
 void EmitLoadSrtDword(EmitterState& state, const IR::Instruction& inst);
@@ -1345,7 +1347,7 @@ void EmitCompareI16(EmitterState& state, const IR::Instruction& inst, uint32_t o
 
 void EmitBitCompareB32(EmitterState& state, const IR::Instruction& inst, bool bit_set);
 
-void EmitCompareNeU64(EmitterState& state, const IR::Instruction& inst);
+void EmitCompareU64(EmitterState& state, const IR::Instruction& inst);
 
 void EmitCompareConstant(EmitterState& state, const IR::Instruction& inst, bool value);
 
@@ -1577,19 +1579,22 @@ uint32_t EmitValueOrZeroIfCondition(EmitterState& state, uint32_t condition, Fn&
 	}
 
 	const auto then_label  = state.builder.AllocateId();
+	const auto then_exit   = state.builder.AllocateId();
 	const auto else_label  = state.builder.AllocateId();
 	const auto merge_label = state.builder.AllocateId();
 	state.builder.AddFunction({OpSelectionMerge, merge_label, SelectionControlNone});
 	state.builder.AddFunction({OpBranchConditional, condition, then_label, else_label});
 	state.builder.AddFunction({OpLabel, then_label});
 	const auto then_value = fn();
+	state.builder.AddFunction({OpBranch, then_exit});
+	state.builder.AddFunction({OpLabel, then_exit});
 	state.builder.AddFunction({OpBranch, merge_label});
 	state.builder.AddFunction({OpLabel, else_label});
 	state.builder.AddFunction({OpBranch, merge_label});
 	state.builder.AddFunction({OpLabel, merge_label});
 	const auto value = state.builder.AllocateId();
 	state.builder.AddFunction(
-	    {OpPhi, state.uint_type, value, then_value, then_label, ConstantU32(state, 0), else_label});
+	    {OpPhi, state.uint_type, value, then_value, then_exit, ConstantU32(state, 0), else_label});
 	return value;
 }
 

src/graphics/shader/recompiler/emitter/spirvEmitterMemory.cpp

@@ -640,8 +640,8 @@ void EmitMemoryStoreU32(EmitterState& state, const IR::Instruction& inst, IR::Re
 }
 
 template <typename Fn>
-void EmitAtomicUpdateU32(EmitterState& state, uint32_t pointer, IR::ResourceKind kind,
-                         Fn&& desired_value) {
+uint32_t EmitAtomicUpdateU32(EmitterState& state, uint32_t pointer, IR::ResourceKind kind,
+                             Fn&& desired_value) {
 	const auto scope          = kind == IR::ResourceKind::Lds ? ScopeWorkgroup : ScopeDevice;
 	const auto memory         = kind == IR::ResourceKind::Lds ? MemorySemanticsWorkgroupMemory
 	                                                          : MemorySemanticsUniformMemory;
@@ -675,6 +675,7 @@ void EmitAtomicUpdateU32(EmitterState& state, uint32_t pointer, IR::ResourceKind
 	const auto semantics = MemorySemanticsAcquireRelease | memory;
 	state.builder.AddFunction(
 	    {OpMemoryBarrier, ConstantU32(state, scope), ConstantU32(state, semantics)});
+	return observed;
 }
 
 void EmitMemoryStoreSubDwordU32(EmitterState& state, const IR::Instruction& inst,
@@ -1181,6 +1182,79 @@ void EmitAtomicU32(EmitterState& state, const IR::Instruction& inst, uint32_t op
 	EmitStoreU32(state, inst.dst, old);
 }
 
+namespace {
+
+uint32_t EmitF32BitsOrderedCompare(EmitterState& state, uint32_t lhs_bits, uint32_t rhs_bits,
+                                   uint32_t comparison_opcode) {
+	struct ClassifiedBits {
+		uint32_t nan  = 0;
+		uint32_t zero = 0;
+		uint32_t key  = 0;
+	};
+	const auto Classify = [&](uint32_t bits) {
+		ClassifiedBits cls;
+		const auto     abs_bits      = EmitAndConstant(state, bits, 0x7fffffffu);
+		const auto     exponent_bits = EmitAndConstant(state, abs_bits, 0x7f800000u);
+		const auto     mantissa_bits = EmitAndConstant(state, abs_bits, 0x007fffffu);
+		const auto     exponent_max =
+		    EmitCompareU32Constant(state, OpIEqual, exponent_bits, 0x7f800000u);
+		const auto mantissa_nonzero = EmitCompareU32Constant(state, OpINotEqual, mantissa_bits, 0);
+		const auto negative = EmitCompareU32Constant(state, OpINotEqual,
+		                                             EmitAndConstant(state, bits, 0x80000000u), 0);
+		const auto negative_key = state.builder.AllocateId();
+		const auto positive_key = state.builder.AllocateId();
+		// Map all non-NaN IEEE-754 encodings to monotonically increasing unsigned keys.
+		state.builder.AddFunction({OpNot, state.uint_type, negative_key, bits});
+		state.builder.AddFunction(
+		    {OpBitwiseXor, state.uint_type, positive_key, bits, ConstantU32(state, 0x80000000u)});
+		cls.nan  = EmitLogicalAndBool(state, exponent_max, mantissa_nonzero);
+		cls.zero = EmitCompareU32Constant(state, OpIEqual, abs_bits, 0);
+		cls.key  = EmitSelectValueU32(state, negative, negative_key, positive_key);
+		return cls;
+	};
+
+	const auto lhs     = Classify(lhs_bits);
+	const auto rhs     = Classify(rhs_bits);
+	const auto any_nan = EmitLogicalOrBool(state, lhs.nan, rhs.nan);
+	// The key transform orders -0 below +0, while the floating comparison treats them as equal.
+	const auto both_zero = EmitLogicalAndBool(state, lhs.zero, rhs.zero);
+	const auto ordered_nonzero =
+	    EmitLogicalNotBool(state, EmitLogicalOrBool(state, any_nan, both_zero));
+	const auto comparison = state.builder.AllocateId();
+	state.builder.AddFunction({comparison_opcode, state.bool_type, comparison, lhs.key, rhs.key});
+	return EmitLogicalAndBool(state, ordered_nonzero, comparison);
+}
+
+void EmitAtomicFMinMaxF32(EmitterState& state, const IR::Instruction& inst,
+                          uint32_t comparison_opcode) {
+	const auto index =
+	    EmitMemoryDwordIndex(state, inst, inst.memory, 1, AddressSourceCount(inst, 1));
+	const auto in_bounds = EmitStorageBufferElementInBounds(state, inst.memory, index, inst.pc);
+	const auto src_u32   = EmitValueLoad(state, inst.src[0]);
+	const auto old       = EmitValueOrZeroIfCondition(state, in_bounds, [&]() {
+		const auto pointer = EmitStorageBufferElementPointer(state, inst.memory, index, inst.pc);
+		return EmitAtomicUpdateU32(state, pointer, inst.memory.kind, [&](uint32_t old_u32) {
+			const auto replace_old = state.builder.AllocateId();
+			const auto replace =
+			    EmitF32BitsOrderedCompare(state, src_u32, old_u32, comparison_opcode);
+			state.builder.AddFunction(
+			    {OpSelect, state.uint_type, replace_old, replace, src_u32, old_u32});
+			return replace_old;
+		});
+	});
+	EmitStoreU32(state, inst.dst, old);
+}
+
+} // namespace
+
+void EmitAtomicFMinF32(EmitterState& state, const IR::Instruction& inst) {
+	EmitAtomicFMinMaxF32(state, inst, OpULessThan);
+}
+
+void EmitAtomicFMaxF32(EmitterState& state, const IR::Instruction& inst) {
+	EmitAtomicFMinMaxF32(state, inst, OpUGreaterThan);
+}
+
 void EmitSLoadDword(EmitterState& state, const IR::Instruction& inst) {
 	if (state.address_memory_variable == 0) {
 		ExitDescriptorBindingFailure(state, IR::DescriptorBindingKind::AddressMemory,

src/graphics/shader/recompiler/ir/ResourceMaterialization.cpp

@@ -200,12 +200,12 @@ bool ValidateResourceSpecialization(const Program& program, const ResourceSnapsh
 		if (dimension == Decoder::ImageDimension::Unknown || dimension != image.dimension ||
 		    DescriptorIsCube(descriptor) != image.cube) {
 			if (error != nullptr) {
-				*error = fmt::format(
-				    "image descriptor {} no longer matches specialized dimension: "
-				    "{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x}",
-				    i, descriptor.dwords[0], descriptor.dwords[1], descriptor.dwords[2],
-				    descriptor.dwords[3], descriptor.dwords[4], descriptor.dwords[5],
-				    descriptor.dwords[6], descriptor.dwords[7]);
+				*error =
+				    fmt::format("image descriptor {} no longer matches specialized dimension: "
+				                "{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x}",
+				                i, descriptor.dwords[0], descriptor.dwords[1], descriptor.dwords[2],
+				                descriptor.dwords[3], descriptor.dwords[4], descriptor.dwords[5],
+				                descriptor.dwords[6], descriptor.dwords[7]);
 			}
 			return false;
 		}
@@ -224,14 +224,17 @@ bool ValidateResourceSpecialization(const Program& program, const ResourceSnapsh
 			const bool raw_sint_storage =
 			    storage && format == Prospero::GpuEnumValue(Prospero::BufferFormat::k32SInt) &&
 			    !image.read && !image.atomic;
-			const bool uint_descriptor =
-			    Prospero::IsUintTextureFormat(format) || raw_sint_storage;
-			const auto uint_program = image.kind == ResourceKind::ImageUint ||
-			                          image.kind == ResourceKind::StorageImageUint;
+			const bool uint_descriptor = Prospero::IsUintTextureFormat(format) || raw_sint_storage;
+			const auto uint_program    = image.kind == ResourceKind::ImageUint ||
+			                             image.kind == ResourceKind::StorageImageUint;
 			if (uint_descriptor != uint_program && !(image.atomic && uint_program)) {
 				if (error != nullptr) {
-					*error =
-					    fmt::format("image descriptor {} no longer matches specialized format", i);
+					*error = fmt::format(
+					    "image descriptor {} no longer matches specialized format: "
+					    "{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x},{:08x}",
+					    i, descriptor.dwords[0], descriptor.dwords[1], descriptor.dwords[2],
+					    descriptor.dwords[3], descriptor.dwords[4], descriptor.dwords[5],
+					    descriptor.dwords[6], descriptor.dwords[7]);
 				}
 				return false;
 			}

src/graphics/shader/recompiler/ir/ResourceTracking.cpp

@@ -30,7 +30,9 @@ bool IsAtomic(Opcode op) {
 		case Opcode::AtomicUMaxU32:
 		case Opcode::AtomicAndU32:
 		case Opcode::AtomicOrU32:
-		case Opcode::AtomicXorU32: return true;
+		case Opcode::AtomicXorU32:
+		case Opcode::AtomicFMinF32:
+		case Opcode::AtomicFMaxF32: return true;
 		default: return false;
 	}
 }

src/graphics/shader/recompiler/ir/ShaderIR.cpp

@@ -490,13 +490,26 @@ bool IsScalarMinMaxOpcode(Decoder::Opcode opcode) {
 	}
 }
 
+bool ResolveIrOpcode(Decoder::Opcode decoded, Opcode& lowered, std::string* error) {
+	const auto opcode = LookupIrOpcode(decoded);
+	if (!opcode.has_value()) {
+		if (error != nullptr) {
+			*error = fmt::format("decoded opcode has no IR lowering: {}",
+			                     Decoder::OpcodeToString(decoded));
+		}
+		return false;
+	}
+	lowered = *opcode;
+	return true;
+}
+
 bool LowerScalarMinMaxWithScc(const Decoder::Instruction& decoded, BasicBlock& block,
                               std::string* error) {
 	Instruction result;
 	result.pc        = decoded.pc;
-	result.op        = LookupIrOpcode(decoded.opcode);
 	result.src_count = 2;
-	if (!LowerRegisterOperand(decoded.dst, result.dst, error) ||
+	if (!ResolveIrOpcode(decoded.opcode, result.op, error) ||
+	    !LowerRegisterOperand(decoded.dst, result.dst, error) ||
 	    !LowerSourceOperand(decoded.src0, result.src[0], error) ||
 	    !LowerSourceOperand(decoded.src1, result.src[1], error)) {
 		return false;
@@ -962,7 +975,12 @@ bool LowerControlInstruction(const Decoder::Instruction& decoded, BasicBlock& bl
 			return LowerControlMarker(decoded, block, Opcode::TtraceData, true, error);
 		case Decoder::Opcode::SInstPrefetch:
 			return LowerControlMarker(decoded, block, Opcode::InstPrefetch, true, error);
-		default: return false;
+		default:
+			if (error != nullptr) {
+				*error = fmt::format("control opcode has no specialized IR lowering: {}",
+				                     Decoder::OpcodeToString(decoded.opcode));
+			}
+			return false;
 	}
 }
 
@@ -1051,6 +1069,18 @@ bool IsTerminatorOpcode(Decoder::Opcode opcode) {
 
 bool LowerImplemented(const Decoder::Instruction& decoded, BasicBlock& block, std::string* error);
 
+bool IsMemoryFamily(Decoder::Family family) {
+	switch (family) {
+		case Decoder::Family::SMEM:
+		case Decoder::Family::MUBUF:
+		case Decoder::Family::MTBUF:
+		case Decoder::Family::FLAT:
+		case Decoder::Family::DS:
+		case Decoder::Family::MIMG: return true;
+		default: return false;
+	}
+}
+
 bool LowerDecodedInstruction(const Decoder::Instruction& inst, BasicBlock& block,
                              std::string* error) {
 	switch (inst.opcode) {
@@ -1104,6 +1134,15 @@ bool LowerDecodedInstruction(const Decoder::Instruction& inst, BasicBlock& block
 	if (IsMemoryOpcode(inst.opcode)) {
 		return LowerMemoryInstruction(inst, block, error);
 	}
+	// Memory instructions require specialized lowering to populate MemoryInfo. Never let a
+	// newly decoded memory-family opcode fall through to generic register-only IR.
+	if (IsMemoryFamily(inst.family)) {
+		if (error != nullptr) {
+			*error = fmt::format("decoded memory-family opcode has no specialized IR lowering: {}",
+			                     Decoder::OpcodeToString(inst.opcode));
+		}
+		return false;
+	}
 	if (ScalarShiftLeftAddAmount(inst.opcode) != 0) {
 		return LowerScalarShiftLeftAdd(inst, block, error);
 	}
@@ -1116,23 +1155,16 @@ bool LowerDecodedInstruction(const Decoder::Instruction& inst, BasicBlock& block
 	if (VectorByteConvertIndex(inst.opcode) <= 3u) {
 		return LowerVectorByteConvert(inst, block, error);
 	}
-	if (!IsImplemented(inst.opcode)) {
-		if (error != nullptr) {
-			*error = fmt::format("decoded opcode has no IR lowering yet: {}",
-			                     Decoder::InstructionToString(inst).c_str());
-		}
-		return false;
-	}
 	return LowerImplemented(inst, block, error);
 }
 
 bool LowerImplemented(const Decoder::Instruction& decoded, BasicBlock& block, std::string* error) {
 	Instruction inst;
 	inst.pc        = decoded.pc;
-	inst.op        = LookupIrOpcode(decoded.opcode);
 	inst.src_count = decoded.src_count;
 
-	if (!LowerRegisterOperand(decoded.dst, inst.dst, error)) {
+	if (!ResolveIrOpcode(decoded.opcode, inst.op, error) ||
+	    !LowerRegisterOperand(decoded.dst, inst.dst, error)) {
 		return false;
 	}
 	ApplyDppDestinationMask(decoded, inst.dst);

src/graphics/shader/recompiler/ir/ShaderIR.h

@@ -8,350 +8,48 @@
 #include "graphics/shader/shader.h"
 
 #include <array>
+#include <string_view>
 #include <vector>
 
 namespace Libs::Graphics::ShaderRecompiler::IR {
 
 enum class Opcode {
-	ControlNop,
-	Waitcnt,
-	Barrier,
-	Sendmsg,
-	TtraceData,
-	InstPrefetch,
-	MoveU32,
-	MoveF32Bits,
-	MoveRelDestU32,
-	MoveRelSourceU32,
-	MoveU64,
-	WqmB64,
-	SaveexecB32,
-	SaveexecB64,
-	ReadFirstLaneU32,
-	ReadLaneU32,
-	WriteLaneU32,
-	Permlane16B32,
-	Permlanex16B32,
-	AbsI32,
-	IAddU32,
-	IAddCarryU32,
-	ISubBorrowU32,
-	ScalarAddCarryU32,
-	ScalarSubBorrowU32,
-	ScalarSubBorrowCarryU32,
-	ScalarSignedAddOverflowI32,
-	ScalarSignedSubOverflowI32,
-	ScalarShiftLeftAddCarryU32,
-	ISubU32,
-	IMulU32,
-	UMulHighU32,
-	SMulHighI32,
-	IMadI24U32,
-	UMadU24U32,
-	UMadU64U32,
-	SadU32,
-	IAdd3U32,
-	IMulI24U32,
-	UMulU24U32,
-	IMinI32,
-	IMaxI32,
-	IMin3I32,
-	IMax3I32,
-	IMed3I32,
-	UMinU32,
-	UMaxU32,
-	UMin3U32,
-	UMax3U32,
-	UMed3U32,
-	BitwiseAndU32,
-	BitwiseAndU64,
-	BitwiseAndNotU32,
-	BitwiseAndNotU64,
-	BitwiseOrU32,
-	BitwiseOrU64,
-	BitwiseOrNotU32,
-	BitwiseOrNotU64,
-	BitwiseAndOrU32,
-	BitwiseOr3U32,
-	BitwiseXorU32,
-	BitwiseXorU64,
-	BitwiseXor3U32,
-	BitwiseNandU32,
-	BitwiseNandU64,
-	BitwiseNorU32,
-	BitwiseNorU64,
-	BitwiseXnorU32,
-	BitwiseXnorU64,
-	BitwiseNotU32,
-	BitwiseNotU64,
-	BitClearU32,
-	BitSetU32,
-	BitReverseU32,
-	BitCountU32,
-	BitCountU64,
-	BitReplicateB64B32,
-	BitCountAddU32,
-	MaskedBitCountLowU32,
-	MaskedBitCountHighU32,
-	FindLsbU32,
-	FindMsbFromHighU32,
-	FindMsbFromHighU64,
-	BitFieldMaskU32,
-	BitFieldMaskU64,
-	BitFieldExtractU32,
-	BitFieldExtractU64,
-	BitFieldExtract3U32,
-	BitFieldExtract3I32,
-	BitFieldInsertSelectU32,
-	BitCompare0B32,
-	BitCompare1B32,
-	AlignBitU32,
-	ShiftLeftAddU32,
-	AddShiftLeftU32,
-	XorAddU32,
-	ShiftLeftOrU32,
-	ShiftLeftLogicalU32,
-	ShiftLeftLogicalU64,
-	ShiftLeftLogicalU16,
-	ShiftRightLogicalU32,
-	ShiftRightLogicalU64,
-	ShiftRightLogicalU16,
-	ShiftRightArithmeticI32,
-	ShiftRightArithmeticI16,
-	SelectU32,
-	SelectMaskU32,
-	SelectF32Bits,
-	SelectMaskF32Bits,
-	SelectU64,
-	PackLowLowU16,
-	PackLowHighU16,
-	PackHighHighU16,
-	CompareFalse,
-	CompareTrue,
-	CompareEqU32,
-	CompareNeU32,
-	CompareGtU32,
-	CompareGeU32,
-	CompareLtU32,
-	CompareLeU32,
-	CompareNeU64,
-	CompareMaskEqU32,
-	CompareMaskNeU32,
-	CompareMaskGtU32,
-	CompareMaskGeU32,
-	CompareMaskLtU32,
-	CompareMaskLeU32,
-	CompareEqI32,
-	CompareNeI32,
-	CompareGtI32,
-	CompareGeI32,
-	CompareLtI32,
-	CompareLeI32,
-	CompareEqI16,
-	CompareNeI16,
-	CompareGtI16,
-	CompareGeI16,
-	CompareLtI16,
-	CompareLeI16,
-	CompareMaskEqI32,
-	CompareMaskNeI32,
-	CompareMaskGtI32,
-	CompareMaskGeI32,
-	CompareMaskLtI32,
-	CompareMaskLeI32,
-	CompareEqU16,
-	CompareNeU16,
-	CompareGtU16,
-	CompareGeU16,
-	CompareLtU16,
-	CompareLeU16,
-	CompareEqF32,
-	CompareNeF32,
-	CompareGtF32,
-	CompareGeF32,
-	CompareLtF32,
-	CompareLeF32,
-	CompareOrderedF32,
-	CompareUnorderedF32,
-	CompareUnordEqF32,
-	CompareUnordNeF32,
-	CompareUnordGtF32,
-	CompareUnordGeF32,
-	CompareUnordLtF32,
-	CompareUnordLeF32,
-	CompareClassF32,
-	CompareEqF16,
-	CompareNeF16,
-	CompareGtF16,
-	CompareGeF16,
-	CompareLtF16,
-	CompareLeF16,
-	CompareUnordNeF16,
-	CompareMaskEqF16,
-	CompareMaskNeF16,
-	CompareMaskGtF16,
-	CompareMaskGeF16,
-	CompareMaskLtF16,
-	CompareMaskLeF16,
-	CompareMaskUnordNeF16,
-	CompareMaskUnordGeF16,
-	CompareMaskEqF32,
-	CompareMaskNeF32,
-	CompareMaskGtF32,
-	CompareMaskGeF32,
-	CompareMaskLtF32,
-	CompareMaskLeF32,
-	CompareMaskUnordEqF32,
-	CompareMaskUnordNeF32,
-	CompareMaskUnordGtF32,
-	CompareMaskUnordGeF32,
-	CompareMaskUnordLtF32,
-	CompareMaskUnordLeF32,
-	ConvertByteU32ToF32,
-	ConvertU32ToF32,
-	ConvertI32ToF32,
-	ConvertF32ToU32,
-	ConvertF32ToI32,
-	ConvertF32ToF16,
-	ConvertF16ToF32,
-	ConvertU16ToF16,
-	ConvertF16ToU16,
-	ConvertI16ToF16,
-	ConvertF16ToI16,
-	ConvertRoundPlusInfF32ToI32,
-	ConvertFloorF32ToI32,
-	ConvertI4ToOffsetF32,
-	LdexpF32,
-	PackF32ToF16Rtz,
-	PackSnorm2x16F32,
-	PackUnorm2x16F32,
-	PackU16U32,
-	PackU8F32,
-	PackB32F16,
-	PackedMadI16,
-	PackedMulLoU16,
-	PackedAddI16,
-	PackedSubI16,
-	PackedLshlrevB16,
-	PackedLshrrevB16,
-	PackedAshrrevI16,
-	PackedMaxI16,
-	PackedMinI16,
-	PackedMadU16,
-	PackedAddU16,
-	PackedSubU16,
-	PackedMaxU16,
-	PackedMinU16,
-	PackedAddF16,
-	PackedMulF16,
-	PackedMinF16,
-	PackedMaxF16,
-	PackedFmaF16,
-	AddF16,
-	SubF16,
-	MulF16,
-	MinF16,
-	MaxF16,
-	FmaF16,
-	MadMixF16,
-	IAddU16,
-	ISubI16,
-	IMinI16,
-	IMaxI16,
-	UMinU16,
-	UMaxU16,
-	RcpF32,
-	FractF32,
-	TruncF32,
-	CeilF32,
-	RoundEvenF32,
-	FloorF32,
-	Exp2F32,
-	Log2F32,
-	InverseSqrtF32,
-	SqrtF32,
-	RcpF16,
-	SqrtF16,
-	InverseSqrtF16,
-	Log2F16,
-	Exp2F16,
-	FloorF16,
-	CeilF16,
-	TruncF16,
-	RoundEvenF16,
-	SinF32,
-	CosF32,
-	CubeIdF32,
-	CubeScF32,
-	CubeTcF32,
-	CubeMaF32,
-	FAddF32,
-	FSubF32,
-	FMulF32,
-	FMinF32,
-	FMaxF32,
-	FMadF32,
-	Dot2AccF32F16,
-	FMin3F32,
-	FMax3F32,
-	FMed3F32,
-	Min3F16,
-	Max3F16,
-	Med3F16,
-	LoadSrtDword,
-	SLoadDword,
-	SBufferLoadDword,
-	BufferLoadUbyte,
-	BufferLoadSbyte,
-	BufferLoadUshort,
-	BufferLoadSshort,
-	BufferLoadDword,
-	BufferStoreByte,
-	BufferStoreShort,
-	BufferStoreDword,
-	AtomicSwapU32,
-	AtomicAddU32,
-	AtomicSubU32,
-	AtomicSMinI32,
-	AtomicUMinU32,
-	AtomicSMaxI32,
-	AtomicUMaxU32,
-	AtomicAndU32,
-	AtomicOrU32,
-	AtomicXorU32,
-	FlatLoadUbyte,
-	FlatLoadSbyte,
-	FlatLoadUshort,
-	FlatLoadSshort,
-	FlatLoadDword,
-	FlatStoreByte,
-	FlatStoreShort,
-	FlatStoreDword,
-	DsReadUbyte,
-	DsReadSbyte,
-	DsReadUshort,
-	DsReadSshort,
-	DsReadB32,
-	DsWriteByte,
-	DsWriteShort,
-	DsWriteB32,
-	DsMinF32,
-	DsMaxF32,
-	DsSwizzleB32,
-	DsConsume,
-	DsAppend,
-	DsWriteAddtidB32,
-	DsReadAddtidB32,
-	ImageGetResinfo,
-	ImageGetLod,
-	ImageLoad,
-	ImageStore,
-	ImageSample,
-	ImageGather4,
-	LoadInputF32,
-	Export,
+#define IR_OPCODE(name, category) name,
+#include "graphics/shader/recompiler/ir/ShaderIROpcodes.inc"
+#undef IR_OPCODE
+	Count,
 };
 
+enum class OpcodeClass { General, Compare, Compare64 };
+
+struct OpcodeInfo {
+	std::string_view name;
+	OpcodeClass      opcode_class = OpcodeClass::General;
+};
+
+inline constexpr OpcodeInfo OPCODE_INFO[] = {
+#define IR_OPCODE(name, category) {#name, OpcodeClass::category},
+#include "graphics/shader/recompiler/ir/ShaderIROpcodes.inc"
+#undef IR_OPCODE
+};
+static_assert(sizeof(OPCODE_INFO) / sizeof(OPCODE_INFO[0]) == static_cast<size_t>(Opcode::Count));
+
+constexpr const OpcodeInfo& GetOpcodeInfo(Opcode opcode) {
+	return OPCODE_INFO[static_cast<size_t>(opcode)];
+}
+
+constexpr std::string_view OpcodeName(Opcode opcode) {
+	return GetOpcodeInfo(opcode).name;
+}
+
+constexpr bool IsCompareOpcode(Opcode opcode) {
+	return GetOpcodeInfo(opcode).opcode_class != OpcodeClass::General;
+}
+
+constexpr bool IsCompare64Opcode(Opcode opcode) {
+	return GetOpcodeInfo(opcode).opcode_class == OpcodeClass::Compare64;
+}
+
 enum class RegisterFile { Scalar, Vector, Vcc, Exec, Scc, M0 };
 
 struct Register {

src/graphics/shader/recompiler/ir/ShaderIRInternal.h

@@ -3,16 +3,17 @@
 
 #include "graphics/shader/recompiler/ir/ShaderIR.h"
 
+#include <optional>
+
 namespace Libs::Graphics::ShaderRecompiler::IR {
 
 void SetError(std::string* error, const char* message);
 
-Opcode LookupIrOpcode(Decoder::Opcode opcode);
-bool   IsImplemented(Decoder::Opcode opcode);
-bool   IsReversedBinary(Decoder::Opcode opcode);
-bool   IsVectorCarryOutOpcode(Decoder::Opcode opcode);
-bool   ScalarResultWritesSccNonZero(Decoder::Opcode opcode);
-bool   ScalarResultIs64Bit(Decoder::Opcode opcode);
+std::optional<Opcode> LookupIrOpcode(Decoder::Opcode opcode);
+bool                  IsReversedBinary(Decoder::Opcode opcode);
+bool                  IsVectorCarryOutOpcode(Decoder::Opcode opcode);
+bool                  ScalarResultWritesSccNonZero(Decoder::Opcode opcode);
+bool                  ScalarResultIs64Bit(Decoder::Opcode opcode);
 
 Operand  MakeSccOperand();
 Operand  MakeImmediateU32(uint32_t value);

src/graphics/shader/recompiler/ir/ShaderIRLog.cpp

@@ -157,345 +157,7 @@ std::string InstructionToString(const Instruction& inst) {
 		text += ExportInfoToString(inst.export_info);
 		return text;
 	}
-	switch (inst.op) {
-		case Opcode::ControlNop: text += "ControlNop"; break;
-		case Opcode::Waitcnt: text += "Waitcnt"; break;
-		case Opcode::Barrier: text += "Barrier"; break;
-		case Opcode::Sendmsg: text += "Sendmsg"; break;
-		case Opcode::TtraceData: text += "TtraceData"; break;
-		case Opcode::InstPrefetch: text += "InstPrefetch"; break;
-		case Opcode::MoveU32: text += "MoveU32"; break;
-		case Opcode::MoveF32Bits: text += "MoveF32Bits"; break;
-		case Opcode::MoveRelDestU32: text += "MoveRelDestU32"; break;
-		case Opcode::MoveRelSourceU32: text += "MoveRelSourceU32"; break;
-		case Opcode::MoveU64: text += "MoveU64"; break;
-		case Opcode::WqmB64: text += "WqmB64"; break;
-		case Opcode::SaveexecB32: text += "SaveexecB32"; break;
-		case Opcode::SaveexecB64: text += "SaveexecB64"; break;
-		case Opcode::ReadFirstLaneU32: text += "ReadFirstLaneU32"; break;
-		case Opcode::ReadLaneU32: text += "ReadLaneU32"; break;
-		case Opcode::WriteLaneU32: text += "WriteLaneU32"; break;
-		case Opcode::Permlane16B32: text += "Permlane16B32"; break;
-		case Opcode::Permlanex16B32: text += "Permlanex16B32"; break;
-		case Opcode::AbsI32: text += "AbsI32"; break;
-		case Opcode::IAddU32: text += "IAddU32"; break;
-		case Opcode::IAddCarryU32: text += "IAddCarryU32"; break;
-		case Opcode::ISubBorrowU32: text += "ISubBorrowU32"; break;
-		case Opcode::ScalarAddCarryU32: text += "ScalarAddCarryU32"; break;
-		case Opcode::ScalarSubBorrowU32: text += "ScalarSubBorrowU32"; break;
-		case Opcode::ScalarSubBorrowCarryU32: text += "ScalarSubBorrowCarryU32"; break;
-		case Opcode::ScalarSignedAddOverflowI32: text += "ScalarSignedAddOverflowI32"; break;
-		case Opcode::ScalarSignedSubOverflowI32: text += "ScalarSignedSubOverflowI32"; break;
-		case Opcode::ScalarShiftLeftAddCarryU32: text += "ScalarShiftLeftAddCarryU32"; break;
-		case Opcode::ISubU32: text += "ISubU32"; break;
-		case Opcode::IMulU32: text += "IMulU32"; break;
-		case Opcode::UMulHighU32: text += "UMulHighU32"; break;
-		case Opcode::SMulHighI32: text += "SMulHighI32"; break;
-		case Opcode::IMadI24U32: text += "IMadI24U32"; break;
-		case Opcode::UMadU24U32: text += "UMadU24U32"; break;
-		case Opcode::UMadU64U32: text += "UMadU64U32"; break;
-		case Opcode::SadU32: text += "SadU32"; break;
-		case Opcode::IAdd3U32: text += "IAdd3U32"; break;
-		case Opcode::IMulI24U32: text += "IMulI24U32"; break;
-		case Opcode::UMulU24U32: text += "UMulU24U32"; break;
-		case Opcode::IMinI32: text += "IMinI32"; break;
-		case Opcode::IMaxI32: text += "IMaxI32"; break;
-		case Opcode::IMin3I32: text += "IMin3I32"; break;
-		case Opcode::IMax3I32: text += "IMax3I32"; break;
-		case Opcode::IMed3I32: text += "IMed3I32"; break;
-		case Opcode::UMinU32: text += "UMinU32"; break;
-		case Opcode::UMaxU32: text += "UMaxU32"; break;
-		case Opcode::UMin3U32: text += "UMin3U32"; break;
-		case Opcode::UMax3U32: text += "UMax3U32"; break;
-		case Opcode::UMed3U32: text += "UMed3U32"; break;
-		case Opcode::BitwiseAndU32: text += "BitwiseAndU32"; break;
-		case Opcode::BitwiseAndU64: text += "BitwiseAndU64"; break;
-		case Opcode::BitwiseAndNotU32: text += "BitwiseAndNotU32"; break;
-		case Opcode::BitwiseAndNotU64: text += "BitwiseAndNotU64"; break;
-		case Opcode::BitwiseOrU32: text += "BitwiseOrU32"; break;
-		case Opcode::BitwiseOrU64: text += "BitwiseOrU64"; break;
-		case Opcode::BitwiseOrNotU32: text += "BitwiseOrNotU32"; break;
-		case Opcode::BitwiseOrNotU64: text += "BitwiseOrNotU64"; break;
-		case Opcode::BitwiseAndOrU32: text += "BitwiseAndOrU32"; break;
-		case Opcode::BitwiseOr3U32: text += "BitwiseOr3U32"; break;
-		case Opcode::BitwiseXorU32: text += "BitwiseXorU32"; break;
-		case Opcode::BitwiseXorU64: text += "BitwiseXorU64"; break;
-		case Opcode::BitwiseXor3U32: text += "BitwiseXor3U32"; break;
-		case Opcode::BitwiseNandU32: text += "BitwiseNandU32"; break;
-		case Opcode::BitwiseNandU64: text += "BitwiseNandU64"; break;
-		case Opcode::BitwiseNorU32: text += "BitwiseNorU32"; break;
-		case Opcode::BitwiseNorU64: text += "BitwiseNorU64"; break;
-		case Opcode::BitwiseXnorU32: text += "BitwiseXnorU32"; break;
-		case Opcode::BitwiseXnorU64: text += "BitwiseXnorU64"; break;
-		case Opcode::BitwiseNotU32: text += "BitwiseNotU32"; break;
-		case Opcode::BitwiseNotU64: text += "BitwiseNotU64"; break;
-		case Opcode::BitClearU32: text += "BitClearU32"; break;
-		case Opcode::BitSetU32: text += "BitSetU32"; break;
-		case Opcode::BitReverseU32: text += "BitReverseU32"; break;
-		case Opcode::BitCountU32: text += "BitCountU32"; break;
-		case Opcode::BitCountU64: text += "BitCountU64"; break;
-		case Opcode::BitReplicateB64B32: text += "BitReplicateB64B32"; break;
-		case Opcode::BitCountAddU32: text += "BitCountAddU32"; break;
-		case Opcode::MaskedBitCountLowU32: text += "MaskedBitCountLowU32"; break;
-		case Opcode::MaskedBitCountHighU32: text += "MaskedBitCountHighU32"; break;
-		case Opcode::FindLsbU32: text += "FindLsbU32"; break;
-		case Opcode::FindMsbFromHighU32: text += "FindMsbFromHighU32"; break;
-		case Opcode::FindMsbFromHighU64: text += "FindMsbFromHighU64"; break;
-		case Opcode::BitFieldMaskU32: text += "BitFieldMaskU32"; break;
-		case Opcode::BitFieldMaskU64: text += "BitFieldMaskU64"; break;
-		case Opcode::BitFieldExtractU32: text += "BitFieldExtractU32"; break;
-		case Opcode::BitFieldExtractU64: text += "BitFieldExtractU64"; break;
-		case Opcode::BitFieldExtract3U32: text += "BitFieldExtract3U32"; break;
-		case Opcode::BitFieldExtract3I32: text += "BitFieldExtract3I32"; break;
-		case Opcode::BitFieldInsertSelectU32: text += "BitFieldInsertSelectU32"; break;
-		case Opcode::BitCompare0B32: text += "BitCompare0B32"; break;
-		case Opcode::BitCompare1B32: text += "BitCompare1B32"; break;
-		case Opcode::AlignBitU32: text += "AlignBitU32"; break;
-		case Opcode::ShiftLeftAddU32: text += "ShiftLeftAddU32"; break;
-		case Opcode::AddShiftLeftU32: text += "AddShiftLeftU32"; break;
-		case Opcode::XorAddU32: text += "XorAddU32"; break;
-		case Opcode::ShiftLeftOrU32: text += "ShiftLeftOrU32"; break;
-		case Opcode::ShiftLeftLogicalU32: text += "ShiftLeftLogicalU32"; break;
-		case Opcode::ShiftLeftLogicalU64: text += "ShiftLeftLogicalU64"; break;
-		case Opcode::ShiftLeftLogicalU16: text += "ShiftLeftLogicalU16"; break;
-		case Opcode::ShiftRightLogicalU32: text += "ShiftRightLogicalU32"; break;
-		case Opcode::ShiftRightLogicalU64: text += "ShiftRightLogicalU64"; break;
-		case Opcode::ShiftRightLogicalU16: text += "ShiftRightLogicalU16"; break;
-		case Opcode::ShiftRightArithmeticI32: text += "ShiftRightArithmeticI32"; break;
-		case Opcode::ShiftRightArithmeticI16: text += "ShiftRightArithmeticI16"; break;
-		case Opcode::SelectU32: text += "SelectU32"; break;
-		case Opcode::SelectMaskU32: text += "SelectMaskU32"; break;
-		case Opcode::SelectF32Bits: text += "SelectF32Bits"; break;
-		case Opcode::SelectMaskF32Bits: text += "SelectMaskF32Bits"; break;
-		case Opcode::SelectU64: text += "SelectU64"; break;
-		case Opcode::PackLowLowU16: text += "PackLowLowU16"; break;
-		case Opcode::PackLowHighU16: text += "PackLowHighU16"; break;
-		case Opcode::PackHighHighU16: text += "PackHighHighU16"; break;
-		case Opcode::CompareFalse: text += "CompareFalse"; break;
-		case Opcode::CompareTrue: text += "CompareTrue"; break;
-		case Opcode::CompareEqU32: text += "CompareEqU32"; break;
-		case Opcode::CompareNeU32: text += "CompareNeU32"; break;
-		case Opcode::CompareGtU32: text += "CompareGtU32"; break;
-		case Opcode::CompareGeU32: text += "CompareGeU32"; break;
-		case Opcode::CompareLtU32: text += "CompareLtU32"; break;
-		case Opcode::CompareLeU32: text += "CompareLeU32"; break;
-		case Opcode::CompareNeU64: text += "CompareNeU64"; break;
-		case Opcode::CompareMaskEqU32: text += "CompareMaskEqU32"; break;
-		case Opcode::CompareMaskNeU32: text += "CompareMaskNeU32"; break;
-		case Opcode::CompareMaskGtU32: text += "CompareMaskGtU32"; break;
-		case Opcode::CompareMaskGeU32: text += "CompareMaskGeU32"; break;
-		case Opcode::CompareMaskLtU32: text += "CompareMaskLtU32"; break;
-		case Opcode::CompareMaskLeU32: text += "CompareMaskLeU32"; break;
-		case Opcode::CompareEqI32: text += "CompareEqI32"; break;
-		case Opcode::CompareNeI32: text += "CompareNeI32"; break;
-		case Opcode::CompareGtI32: text += "CompareGtI32"; break;
-		case Opcode::CompareGeI32: text += "CompareGeI32"; break;
-		case Opcode::CompareLtI32: text += "CompareLtI32"; break;
-		case Opcode::CompareLeI32: text += "CompareLeI32"; break;
-		case Opcode::CompareEqI16: text += "CompareEqI16"; break;
-		case Opcode::CompareNeI16: text += "CompareNeI16"; break;
-		case Opcode::CompareGtI16: text += "CompareGtI16"; break;
-		case Opcode::CompareGeI16: text += "CompareGeI16"; break;
-		case Opcode::CompareLtI16: text += "CompareLtI16"; break;
-		case Opcode::CompareLeI16: text += "CompareLeI16"; break;
-		case Opcode::CompareMaskEqI32: text += "CompareMaskEqI32"; break;
-		case Opcode::CompareMaskNeI32: text += "CompareMaskNeI32"; break;
-		case Opcode::CompareMaskGtI32: text += "CompareMaskGtI32"; break;
-		case Opcode::CompareMaskGeI32: text += "CompareMaskGeI32"; break;
-		case Opcode::CompareMaskLtI32: text += "CompareMaskLtI32"; break;
-		case Opcode::CompareMaskLeI32: text += "CompareMaskLeI32"; break;
-		case Opcode::CompareEqU16: text += "CompareEqU16"; break;
-		case Opcode::CompareNeU16: text += "CompareNeU16"; break;
-		case Opcode::CompareGtU16: text += "CompareGtU16"; break;
-		case Opcode::CompareGeU16: text += "CompareGeU16"; break;
-		case Opcode::CompareLtU16: text += "CompareLtU16"; break;
-		case Opcode::CompareLeU16: text += "CompareLeU16"; break;
-		case Opcode::CompareEqF32: text += "CompareEqF32"; break;
-		case Opcode::CompareNeF32: text += "CompareNeF32"; break;
-		case Opcode::CompareGtF32: text += "CompareGtF32"; break;
-		case Opcode::CompareGeF32: text += "CompareGeF32"; break;
-		case Opcode::CompareLtF32: text += "CompareLtF32"; break;
-		case Opcode::CompareLeF32: text += "CompareLeF32"; break;
-		case Opcode::CompareOrderedF32: text += "CompareOrderedF32"; break;
-		case Opcode::CompareUnorderedF32: text += "CompareUnorderedF32"; break;
-		case Opcode::CompareUnordEqF32: text += "CompareUnordEqF32"; break;
-		case Opcode::CompareUnordNeF32: text += "CompareUnordNeF32"; break;
-		case Opcode::CompareUnordGtF32: text += "CompareUnordGtF32"; break;
-		case Opcode::CompareUnordGeF32: text += "CompareUnordGeF32"; break;
-		case Opcode::CompareUnordLtF32: text += "CompareUnordLtF32"; break;
-		case Opcode::CompareUnordLeF32: text += "CompareUnordLeF32"; break;
-		case Opcode::CompareClassF32: text += "CompareClassF32"; break;
-		case Opcode::CompareEqF16: text += "CompareEqF16"; break;
-		case Opcode::CompareNeF16: text += "CompareNeF16"; break;
-		case Opcode::CompareGtF16: text += "CompareGtF16"; break;
-		case Opcode::CompareGeF16: text += "CompareGeF16"; break;
-		case Opcode::CompareLtF16: text += "CompareLtF16"; break;
-		case Opcode::CompareLeF16: text += "CompareLeF16"; break;
-		case Opcode::CompareUnordNeF16: text += "CompareUnordNeF16"; break;
-		case Opcode::CompareMaskEqF16: text += "CompareMaskEqF16"; break;
-		case Opcode::CompareMaskNeF16: text += "CompareMaskNeF16"; break;
-		case Opcode::CompareMaskGtF16: text += "CompareMaskGtF16"; break;
-		case Opcode::CompareMaskGeF16: text += "CompareMaskGeF16"; break;
-		case Opcode::CompareMaskLtF16: text += "CompareMaskLtF16"; break;
-		case Opcode::CompareMaskLeF16: text += "CompareMaskLeF16"; break;
-		case Opcode::CompareMaskUnordNeF16: text += "CompareMaskUnordNeF16"; break;
-		case Opcode::CompareMaskUnordGeF16: text += "CompareMaskUnordGeF16"; break;
-		case Opcode::CompareMaskEqF32: text += "CompareMaskEqF32"; break;
-		case Opcode::CompareMaskNeF32: text += "CompareMaskNeF32"; break;
-		case Opcode::CompareMaskGtF32: text += "CompareMaskGtF32"; break;
-		case Opcode::CompareMaskGeF32: text += "CompareMaskGeF32"; break;
-		case Opcode::CompareMaskLtF32: text += "CompareMaskLtF32"; break;
-		case Opcode::CompareMaskLeF32: text += "CompareMaskLeF32"; break;
-		case Opcode::CompareMaskUnordEqF32: text += "CompareMaskUnordEqF32"; break;
-		case Opcode::CompareMaskUnordNeF32: text += "CompareMaskUnordNeF32"; break;
-		case Opcode::CompareMaskUnordGtF32: text += "CompareMaskUnordGtF32"; break;
-		case Opcode::CompareMaskUnordGeF32: text += "CompareMaskUnordGeF32"; break;
-		case Opcode::CompareMaskUnordLtF32: text += "CompareMaskUnordLtF32"; break;
-		case Opcode::CompareMaskUnordLeF32: text += "CompareMaskUnordLeF32"; break;
-		case Opcode::ConvertByteU32ToF32: text += "ConvertByteU32ToF32"; break;
-		case Opcode::ConvertU32ToF32: text += "ConvertU32ToF32"; break;
-		case Opcode::ConvertI32ToF32: text += "ConvertI32ToF32"; break;
-		case Opcode::ConvertF32ToU32: text += "ConvertF32ToU32"; break;
-		case Opcode::ConvertF32ToI32: text += "ConvertF32ToI32"; break;
-		case Opcode::ConvertF32ToF16: text += "ConvertF32ToF16"; break;
-		case Opcode::ConvertF16ToF32: text += "ConvertF16ToF32"; break;
-		case Opcode::ConvertU16ToF16: text += "ConvertU16ToF16"; break;
-		case Opcode::ConvertF16ToU16: text += "ConvertF16ToU16"; break;
-		case Opcode::ConvertI16ToF16: text += "ConvertI16ToF16"; break;
-		case Opcode::ConvertF16ToI16: text += "ConvertF16ToI16"; break;
-		case Opcode::ConvertRoundPlusInfF32ToI32: text += "ConvertRoundPlusInfF32ToI32"; break;
-		case Opcode::ConvertFloorF32ToI32: text += "ConvertFloorF32ToI32"; break;
-		case Opcode::ConvertI4ToOffsetF32: text += "ConvertI4ToOffsetF32"; break;
-		case Opcode::LdexpF32: text += "LdexpF32"; break;
-		case Opcode::PackF32ToF16Rtz: text += "PackF32ToF16Rtz"; break;
-		case Opcode::PackSnorm2x16F32: text += "PackSnorm2x16F32"; break;
-		case Opcode::PackUnorm2x16F32: text += "PackUnorm2x16F32"; break;
-		case Opcode::PackU16U32: text += "PackU16U32"; break;
-		case Opcode::PackU8F32: text += "PackU8F32"; break;
-		case Opcode::PackB32F16: text += "PackB32F16"; break;
-		case Opcode::PackedMadI16: text += "PackedMadI16"; break;
-		case Opcode::PackedMulLoU16: text += "PackedMulLoU16"; break;
-		case Opcode::PackedAddI16: text += "PackedAddI16"; break;
-		case Opcode::PackedSubI16: text += "PackedSubI16"; break;
-		case Opcode::PackedLshlrevB16: text += "PackedLshlrevB16"; break;
-		case Opcode::PackedLshrrevB16: text += "PackedLshrrevB16"; break;
-		case Opcode::PackedAshrrevI16: text += "PackedAshrrevI16"; break;
-		case Opcode::PackedMaxI16: text += "PackedMaxI16"; break;
-		case Opcode::PackedMinI16: text += "PackedMinI16"; break;
-		case Opcode::PackedMadU16: text += "PackedMadU16"; break;
-		case Opcode::PackedAddU16: text += "PackedAddU16"; break;
-		case Opcode::PackedSubU16: text += "PackedSubU16"; break;
-		case Opcode::PackedMaxU16: text += "PackedMaxU16"; break;
-		case Opcode::PackedMinU16: text += "PackedMinU16"; break;
-		case Opcode::PackedAddF16: text += "PackedAddF16"; break;
-		case Opcode::PackedMulF16: text += "PackedMulF16"; break;
-		case Opcode::PackedMinF16: text += "PackedMinF16"; break;
-		case Opcode::PackedMaxF16: text += "PackedMaxF16"; break;
-		case Opcode::PackedFmaF16: text += "PackedFmaF16"; break;
-		case Opcode::AddF16: text += "AddF16"; break;
-		case Opcode::SubF16: text += "SubF16"; break;
-		case Opcode::MulF16: text += "MulF16"; break;
-		case Opcode::MinF16: text += "MinF16"; break;
-		case Opcode::MaxF16: text += "MaxF16"; break;
-		case Opcode::FmaF16: text += "FmaF16"; break;
-		case Opcode::MadMixF16: text += "MadMixF16"; break;
-		case Opcode::IAddU16: text += "IAddU16"; break;
-		case Opcode::ISubI16: text += "ISubI16"; break;
-		case Opcode::IMinI16: text += "IMinI16"; break;
-		case Opcode::IMaxI16: text += "IMaxI16"; break;
-		case Opcode::UMinU16: text += "UMinU16"; break;
-		case Opcode::UMaxU16: text += "UMaxU16"; break;
-		case Opcode::RcpF32: text += "RcpF32"; break;
-		case Opcode::FractF32: text += "FractF32"; break;
-		case Opcode::TruncF32: text += "TruncF32"; break;
-		case Opcode::CeilF32: text += "CeilF32"; break;
-		case Opcode::RoundEvenF32: text += "RoundEvenF32"; break;
-		case Opcode::FloorF32: text += "FloorF32"; break;
-		case Opcode::Exp2F32: text += "Exp2F32"; break;
-		case Opcode::Log2F32: text += "Log2F32"; break;
-		case Opcode::InverseSqrtF32: text += "InverseSqrtF32"; break;
-		case Opcode::SqrtF32: text += "SqrtF32"; break;
-		case Opcode::RcpF16: text += "RcpF16"; break;
-		case Opcode::SqrtF16: text += "SqrtF16"; break;
-		case Opcode::InverseSqrtF16: text += "InverseSqrtF16"; break;
-		case Opcode::Log2F16: text += "Log2F16"; break;
-		case Opcode::Exp2F16: text += "Exp2F16"; break;
-		case Opcode::FloorF16: text += "FloorF16"; break;
-		case Opcode::CeilF16: text += "CeilF16"; break;
-		case Opcode::TruncF16: text += "TruncF16"; break;
-		case Opcode::RoundEvenF16: text += "RoundEvenF16"; break;
-		case Opcode::SinF32: text += "SinF32"; break;
-		case Opcode::CosF32: text += "CosF32"; break;
-		case Opcode::CubeIdF32: text += "CubeIdF32"; break;
-		case Opcode::CubeScF32: text += "CubeScF32"; break;
-		case Opcode::CubeTcF32: text += "CubeTcF32"; break;
-		case Opcode::CubeMaF32: text += "CubeMaF32"; break;
-		case Opcode::FAddF32: text += "FAddF32"; break;
-		case Opcode::FSubF32: text += "FSubF32"; break;
-		case Opcode::FMulF32: text += "FMulF32"; break;
-		case Opcode::FMinF32: text += "FMinF32"; break;
-		case Opcode::FMaxF32: text += "FMaxF32"; break;
-		case Opcode::FMadF32: text += "FMadF32"; break;
-		case Opcode::Dot2AccF32F16: text += "Dot2AccF32F16"; break;
-		case Opcode::FMin3F32: text += "FMin3F32"; break;
-		case Opcode::FMax3F32: text += "FMax3F32"; break;
-		case Opcode::FMed3F32: text += "FMed3F32"; break;
-		case Opcode::Min3F16: text += "Min3F16"; break;
-		case Opcode::Max3F16: text += "Max3F16"; break;
-		case Opcode::Med3F16: text += "Med3F16"; break;
-		case Opcode::LoadSrtDword: text += "LoadSrtDword"; break;
-		case Opcode::SLoadDword: text += "SLoadDword"; break;
-		case Opcode::SBufferLoadDword: text += "SBufferLoadDword"; break;
-		case Opcode::BufferLoadUbyte: text += "BufferLoadUbyte"; break;
-		case Opcode::BufferLoadSbyte: text += "BufferLoadSbyte"; break;
-		case Opcode::BufferLoadUshort: text += "BufferLoadUshort"; break;
-		case Opcode::BufferLoadSshort: text += "BufferLoadSshort"; break;
-		case Opcode::BufferLoadDword: text += "BufferLoadDword"; break;
-		case Opcode::BufferStoreByte: text += "BufferStoreByte"; break;
-		case Opcode::BufferStoreShort: text += "BufferStoreShort"; break;
-		case Opcode::BufferStoreDword: text += "BufferStoreDword"; break;
-		case Opcode::AtomicSwapU32: text += "AtomicSwapU32"; break;
-		case Opcode::AtomicAddU32: text += "AtomicAddU32"; break;
-		case Opcode::AtomicSubU32: text += "AtomicSubU32"; break;
-		case Opcode::AtomicSMinI32: text += "AtomicSMinI32"; break;
-		case Opcode::AtomicUMinU32: text += "AtomicUMinU32"; break;
-		case Opcode::AtomicSMaxI32: text += "AtomicSMaxI32"; break;
-		case Opcode::AtomicUMaxU32: text += "AtomicUMaxU32"; break;
-		case Opcode::AtomicAndU32: text += "AtomicAndU32"; break;
-		case Opcode::AtomicOrU32: text += "AtomicOrU32"; break;
-		case Opcode::AtomicXorU32: text += "AtomicXorU32"; break;
-		case Opcode::FlatLoadUbyte: text += "FlatLoadUbyte"; break;
-		case Opcode::FlatLoadSbyte: text += "FlatLoadSbyte"; break;
-		case Opcode::FlatLoadUshort: text += "FlatLoadUshort"; break;
-		case Opcode::FlatLoadSshort: text += "FlatLoadSshort"; break;
-		case Opcode::FlatLoadDword: text += "FlatLoadDword"; break;
-		case Opcode::FlatStoreByte: text += "FlatStoreByte"; break;
-		case Opcode::FlatStoreShort: text += "FlatStoreShort"; break;
-		case Opcode::FlatStoreDword: text += "FlatStoreDword"; break;
-		case Opcode::DsReadUbyte: text += "DsReadUbyte"; break;
-		case Opcode::DsReadSbyte: text += "DsReadSbyte"; break;
-		case Opcode::DsReadUshort: text += "DsReadUshort"; break;
-		case Opcode::DsReadSshort: text += "DsReadSshort"; break;
-		case Opcode::DsReadB32: text += "DsReadB32"; break;
-		case Opcode::DsWriteByte: text += "DsWriteByte"; break;
-		case Opcode::DsWriteShort: text += "DsWriteShort"; break;
-		case Opcode::DsWriteB32: text += "DsWriteB32"; break;
-		case Opcode::DsMinF32: text += "DsMinF32"; break;
-		case Opcode::DsMaxF32: text += "DsMaxF32"; break;
-		case Opcode::DsSwizzleB32: text += "DsSwizzleB32"; break;
-		case Opcode::DsConsume: text += "DsConsume"; break;
-		case Opcode::DsAppend: text += "DsAppend"; break;
-		case Opcode::DsWriteAddtidB32: text += "DsWriteAddtidB32"; break;
-		case Opcode::DsReadAddtidB32: text += "DsReadAddtidB32"; break;
-		case Opcode::ImageGetResinfo: text += "ImageGetResinfo"; break;
-		case Opcode::ImageGetLod: text += "ImageGetLod"; break;
-		case Opcode::ImageLoad: text += "ImageLoad"; break;
-		case Opcode::ImageStore: text += "ImageStore"; break;
-		case Opcode::ImageSample: text += "ImageSample"; break;
-		case Opcode::ImageGather4: text += "ImageGather4"; break;
-		case Opcode::LoadInputF32: text += "LoadInputF32"; break;
-		case Opcode::Export: text += "Export"; break;
-	}
+	text += OpcodeName(inst.op);
 	text += " ";
 	text += OperandToString(inst.dst);
 	if (inst.dst2.kind != OperandKind::Null) {

src/graphics/shader/recompiler/ir/ShaderIRMemory.cpp

@@ -569,6 +569,10 @@ bool LowerMemoryInstruction(const Decoder::Instruction& decoded, BasicBlock& blo
 			return LowerBufferAtomicDword(decoded, block, Opcode::AtomicOrU32, error);
 		case Decoder::Opcode::BufferAtomicXor:
 			return LowerBufferAtomicDword(decoded, block, Opcode::AtomicXorU32, error);
+		case Decoder::Opcode::BufferAtomicFMin:
+			return LowerBufferAtomicDword(decoded, block, Opcode::AtomicFMinF32, error);
+		case Decoder::Opcode::BufferAtomicFMax:
+			return LowerBufferAtomicDword(decoded, block, Opcode::AtomicFMaxF32, error);
 		case Decoder::Opcode::FlatLoadUbyte:
 		case Decoder::Opcode::FlatLoadSbyte:
 		case Decoder::Opcode::FlatLoadUshort:
@@ -673,7 +677,12 @@ bool LowerMemoryInstruction(const Decoder::Instruction& decoded, BasicBlock& blo
 		case Decoder::Opcode::ImageAtomicAnd:
 		case Decoder::Opcode::ImageAtomicOr:
 		case Decoder::Opcode::ImageAtomicXor: return LowerImageAtomicU32(decoded, block, error);
-		default: return false;
+		default:
+			if (error != nullptr) {
+				*error = fmt::format("memory opcode has no specialized IR lowering: {}",
+				                     Decoder::OpcodeToString(decoded.opcode));
+			}
+			return false;
 	}
 }
 
@@ -729,6 +738,8 @@ bool IsMemoryOpcode(Decoder::Opcode opcode) {
 		case Decoder::Opcode::BufferAtomicAnd:
 		case Decoder::Opcode::BufferAtomicOr:
 		case Decoder::Opcode::BufferAtomicXor:
+		case Decoder::Opcode::BufferAtomicFMin:
+		case Decoder::Opcode::BufferAtomicFMax:
 		case Decoder::Opcode::FlatLoadUbyte:
 		case Decoder::Opcode::FlatLoadSbyte:
 		case Decoder::Opcode::FlatLoadUshort:

src/graphics/shader/recompiler/ir/ShaderIROpcodes.cpp

@@ -82,6 +82,7 @@ constexpr LowerMap LOWER_OPS[] = {
     {Decoder::Opcode::SCmpGeU32, Opcode::CompareGeU32},
     {Decoder::Opcode::SCmpLtU32, Opcode::CompareLtU32},
     {Decoder::Opcode::SCmpLeU32, Opcode::CompareLeU32},
+    {Decoder::Opcode::SCmpEqU64, Opcode::CompareEqU64},
     {Decoder::Opcode::SCmpLgU64, Opcode::CompareNeU64},
     {Decoder::Opcode::VReadfirstlaneB32, Opcode::ReadFirstLaneU32},
     {Decoder::Opcode::VReadlaneB32, Opcode::ReadLaneU32},
@@ -325,6 +326,7 @@ constexpr LowerMap LOWER_OPS[] = {
     {Decoder::Opcode::VCmpNeU32, Opcode::CompareNeU32},
     {Decoder::Opcode::VCmpGeU32, Opcode::CompareGeU32},
     {Decoder::Opcode::VCmpTU32, Opcode::CompareTrue},
+    {Decoder::Opcode::VCmpEqI64, Opcode::CompareEqU64},
     {Decoder::Opcode::VCmpNeU64, Opcode::CompareNeU64},
     {Decoder::Opcode::VCmpxLtU32, Opcode::CompareMaskLtU32},
     {Decoder::Opcode::VCmpxEqU32, Opcode::CompareMaskEqU32},
@@ -350,6 +352,8 @@ constexpr LowerMap LOWER_OPS[] = {
     {Decoder::Opcode::BufferAtomicAnd, Opcode::AtomicAndU32},
     {Decoder::Opcode::BufferAtomicOr, Opcode::AtomicOrU32},
     {Decoder::Opcode::BufferAtomicXor, Opcode::AtomicXorU32},
+    {Decoder::Opcode::BufferAtomicFMin, Opcode::AtomicFMinF32},
+    {Decoder::Opcode::BufferAtomicFMax, Opcode::AtomicFMaxF32},
     {Decoder::Opcode::FlatLoadUbyte, Opcode::FlatLoadUbyte},
     {Decoder::Opcode::FlatLoadSbyte, Opcode::FlatLoadSbyte},
     {Decoder::Opcode::FlatLoadSshort, Opcode::FlatLoadSshort},
@@ -432,22 +436,13 @@ void SetError(std::string* error, const char* message) {
 	}
 }
 
-Opcode LookupIrOpcode(Decoder::Opcode opcode) {
+std::optional<Opcode> LookupIrOpcode(Decoder::Opcode opcode) {
 	for (const auto& op: LOWER_OPS) {
 		if (op.decoded == opcode) {
 			return op.ir;
 		}
 	}
-	return Opcode::MoveU32;
-}
-
-bool IsImplemented(Decoder::Opcode opcode) {
-	for (const auto& op: LOWER_OPS) {
-		if (op.decoded == opcode) {
-			return true;
-		}
-	}
-	return false;
+	return std::nullopt;
 }
 
 bool IsReversedBinary(Decoder::Opcode opcode) {

src/graphics/shader/recompiler/ir/ShaderIROpcodes.inc

@@ -0,0 +1,342 @@
+// Central IR opcode catalog. Keep semantic categories here so enum identity, logging,
+// and generic analysis cannot drift apart.
+IR_OPCODE(ControlNop, General)
+IR_OPCODE(Waitcnt, General)
+IR_OPCODE(Barrier, General)
+IR_OPCODE(Sendmsg, General)
+IR_OPCODE(TtraceData, General)
+IR_OPCODE(InstPrefetch, General)
+IR_OPCODE(MoveU32, General)
+IR_OPCODE(MoveF32Bits, General)
+IR_OPCODE(MoveRelDestU32, General)
+IR_OPCODE(MoveRelSourceU32, General)
+IR_OPCODE(MoveU64, General)
+IR_OPCODE(WqmB64, General)
+IR_OPCODE(SaveexecB32, General)
+IR_OPCODE(SaveexecB64, General)
+IR_OPCODE(ReadFirstLaneU32, General)
+IR_OPCODE(ReadLaneU32, General)
+IR_OPCODE(WriteLaneU32, General)
+IR_OPCODE(Permlane16B32, General)
+IR_OPCODE(Permlanex16B32, General)
+IR_OPCODE(AbsI32, General)
+IR_OPCODE(IAddU32, General)
+IR_OPCODE(IAddCarryU32, General)
+IR_OPCODE(ISubBorrowU32, General)
+IR_OPCODE(ScalarAddCarryU32, General)
+IR_OPCODE(ScalarSubBorrowU32, General)
+IR_OPCODE(ScalarSubBorrowCarryU32, General)
+IR_OPCODE(ScalarSignedAddOverflowI32, General)
+IR_OPCODE(ScalarSignedSubOverflowI32, General)
+IR_OPCODE(ScalarShiftLeftAddCarryU32, General)
+IR_OPCODE(ISubU32, General)
+IR_OPCODE(IMulU32, General)
+IR_OPCODE(UMulHighU32, General)
+IR_OPCODE(SMulHighI32, General)
+IR_OPCODE(IMadI24U32, General)
+IR_OPCODE(UMadU24U32, General)
+IR_OPCODE(UMadU64U32, General)
+IR_OPCODE(SadU32, General)
+IR_OPCODE(IAdd3U32, General)
+IR_OPCODE(IMulI24U32, General)
+IR_OPCODE(UMulU24U32, General)
+IR_OPCODE(IMinI32, General)
+IR_OPCODE(IMaxI32, General)
+IR_OPCODE(IMin3I32, General)
+IR_OPCODE(IMax3I32, General)
+IR_OPCODE(IMed3I32, General)
+IR_OPCODE(UMinU32, General)
+IR_OPCODE(UMaxU32, General)
+IR_OPCODE(UMin3U32, General)
+IR_OPCODE(UMax3U32, General)
+IR_OPCODE(UMed3U32, General)
+IR_OPCODE(BitwiseAndU32, General)
+IR_OPCODE(BitwiseAndU64, General)
+IR_OPCODE(BitwiseAndNotU32, General)
+IR_OPCODE(BitwiseAndNotU64, General)
+IR_OPCODE(BitwiseOrU32, General)
+IR_OPCODE(BitwiseOrU64, General)
+IR_OPCODE(BitwiseOrNotU32, General)
+IR_OPCODE(BitwiseOrNotU64, General)
+IR_OPCODE(BitwiseAndOrU32, General)
+IR_OPCODE(BitwiseOr3U32, General)
+IR_OPCODE(BitwiseXorU32, General)
+IR_OPCODE(BitwiseXorU64, General)
+IR_OPCODE(BitwiseXor3U32, General)
+IR_OPCODE(BitwiseNandU32, General)
+IR_OPCODE(BitwiseNandU64, General)
+IR_OPCODE(BitwiseNorU32, General)
+IR_OPCODE(BitwiseNorU64, General)
+IR_OPCODE(BitwiseXnorU32, General)
+IR_OPCODE(BitwiseXnorU64, General)
+IR_OPCODE(BitwiseNotU32, General)
+IR_OPCODE(BitwiseNotU64, General)
+IR_OPCODE(BitClearU32, General)
+IR_OPCODE(BitSetU32, General)
+IR_OPCODE(BitReverseU32, General)
+IR_OPCODE(BitCountU32, General)
+IR_OPCODE(BitCountU64, General)
+IR_OPCODE(BitReplicateB64B32, General)
+IR_OPCODE(BitCountAddU32, General)
+IR_OPCODE(MaskedBitCountLowU32, General)
+IR_OPCODE(MaskedBitCountHighU32, General)
+IR_OPCODE(FindLsbU32, General)
+IR_OPCODE(FindMsbFromHighU32, General)
+IR_OPCODE(FindMsbFromHighU64, General)
+IR_OPCODE(BitFieldMaskU32, General)
+IR_OPCODE(BitFieldMaskU64, General)
+IR_OPCODE(BitFieldExtractU32, General)
+IR_OPCODE(BitFieldExtractU64, General)
+IR_OPCODE(BitFieldExtract3U32, General)
+IR_OPCODE(BitFieldExtract3I32, General)
+IR_OPCODE(BitFieldInsertSelectU32, General)
+IR_OPCODE(BitCompare0B32, General)
+IR_OPCODE(BitCompare1B32, General)
+IR_OPCODE(AlignBitU32, General)
+IR_OPCODE(ShiftLeftAddU32, General)
+IR_OPCODE(AddShiftLeftU32, General)
+IR_OPCODE(XorAddU32, General)
+IR_OPCODE(ShiftLeftOrU32, General)
+IR_OPCODE(ShiftLeftLogicalU32, General)
+IR_OPCODE(ShiftLeftLogicalU64, General)
+IR_OPCODE(ShiftLeftLogicalU16, General)
+IR_OPCODE(ShiftRightLogicalU32, General)
+IR_OPCODE(ShiftRightLogicalU64, General)
+IR_OPCODE(ShiftRightLogicalU16, General)
+IR_OPCODE(ShiftRightArithmeticI32, General)
+IR_OPCODE(ShiftRightArithmeticI16, General)
+IR_OPCODE(SelectU32, General)
+IR_OPCODE(SelectMaskU32, General)
+IR_OPCODE(SelectF32Bits, General)
+IR_OPCODE(SelectMaskF32Bits, General)
+IR_OPCODE(SelectU64, General)
+IR_OPCODE(PackLowLowU16, General)
+IR_OPCODE(PackLowHighU16, General)
+IR_OPCODE(PackHighHighU16, General)
+IR_OPCODE(CompareFalse, Compare)
+IR_OPCODE(CompareTrue, Compare)
+IR_OPCODE(CompareEqU32, Compare)
+IR_OPCODE(CompareNeU32, Compare)
+IR_OPCODE(CompareGtU32, Compare)
+IR_OPCODE(CompareGeU32, Compare)
+IR_OPCODE(CompareLtU32, Compare)
+IR_OPCODE(CompareLeU32, Compare)
+IR_OPCODE(CompareEqU64, Compare64)
+IR_OPCODE(CompareNeU64, Compare64)
+IR_OPCODE(CompareMaskEqU32, Compare)
+IR_OPCODE(CompareMaskNeU32, Compare)
+IR_OPCODE(CompareMaskGtU32, Compare)
+IR_OPCODE(CompareMaskGeU32, Compare)
+IR_OPCODE(CompareMaskLtU32, Compare)
+IR_OPCODE(CompareMaskLeU32, Compare)
+IR_OPCODE(CompareEqI32, Compare)
+IR_OPCODE(CompareNeI32, Compare)
+IR_OPCODE(CompareGtI32, Compare)
+IR_OPCODE(CompareGeI32, Compare)
+IR_OPCODE(CompareLtI32, Compare)
+IR_OPCODE(CompareLeI32, Compare)
+IR_OPCODE(CompareEqI16, Compare)
+IR_OPCODE(CompareNeI16, Compare)
+IR_OPCODE(CompareGtI16, Compare)
+IR_OPCODE(CompareGeI16, Compare)
+IR_OPCODE(CompareLtI16, Compare)
+IR_OPCODE(CompareLeI16, Compare)
+IR_OPCODE(CompareMaskEqI32, Compare)
+IR_OPCODE(CompareMaskNeI32, Compare)
+IR_OPCODE(CompareMaskGtI32, Compare)
+IR_OPCODE(CompareMaskGeI32, Compare)
+IR_OPCODE(CompareMaskLtI32, Compare)
+IR_OPCODE(CompareMaskLeI32, Compare)
+IR_OPCODE(CompareEqU16, Compare)
+IR_OPCODE(CompareNeU16, Compare)
+IR_OPCODE(CompareGtU16, Compare)
+IR_OPCODE(CompareGeU16, Compare)
+IR_OPCODE(CompareLtU16, Compare)
+IR_OPCODE(CompareLeU16, Compare)
+IR_OPCODE(CompareEqF32, Compare)
+IR_OPCODE(CompareNeF32, Compare)
+IR_OPCODE(CompareGtF32, Compare)
+IR_OPCODE(CompareGeF32, Compare)
+IR_OPCODE(CompareLtF32, Compare)
+IR_OPCODE(CompareLeF32, Compare)
+IR_OPCODE(CompareOrderedF32, Compare)
+IR_OPCODE(CompareUnorderedF32, Compare)
+IR_OPCODE(CompareUnordEqF32, Compare)
+IR_OPCODE(CompareUnordNeF32, Compare)
+IR_OPCODE(CompareUnordGtF32, Compare)
+IR_OPCODE(CompareUnordGeF32, Compare)
+IR_OPCODE(CompareUnordLtF32, Compare)
+IR_OPCODE(CompareUnordLeF32, Compare)
+IR_OPCODE(CompareClassF32, Compare)
+IR_OPCODE(CompareEqF16, Compare)
+IR_OPCODE(CompareNeF16, Compare)
+IR_OPCODE(CompareGtF16, Compare)
+IR_OPCODE(CompareGeF16, Compare)
+IR_OPCODE(CompareLtF16, Compare)
+IR_OPCODE(CompareLeF16, Compare)
+IR_OPCODE(CompareUnordNeF16, Compare)
+IR_OPCODE(CompareMaskEqF16, Compare)
+IR_OPCODE(CompareMaskNeF16, Compare)
+IR_OPCODE(CompareMaskGtF16, Compare)
+IR_OPCODE(CompareMaskGeF16, Compare)
+IR_OPCODE(CompareMaskLtF16, Compare)
+IR_OPCODE(CompareMaskLeF16, Compare)
+IR_OPCODE(CompareMaskUnordNeF16, Compare)
+IR_OPCODE(CompareMaskUnordGeF16, Compare)
+IR_OPCODE(CompareMaskEqF32, Compare)
+IR_OPCODE(CompareMaskNeF32, Compare)
+IR_OPCODE(CompareMaskGtF32, Compare)
+IR_OPCODE(CompareMaskGeF32, Compare)
+IR_OPCODE(CompareMaskLtF32, Compare)
+IR_OPCODE(CompareMaskLeF32, Compare)
+IR_OPCODE(CompareMaskUnordEqF32, Compare)
+IR_OPCODE(CompareMaskUnordNeF32, Compare)
+IR_OPCODE(CompareMaskUnordGtF32, Compare)
+IR_OPCODE(CompareMaskUnordGeF32, Compare)
+IR_OPCODE(CompareMaskUnordLtF32, Compare)
+IR_OPCODE(CompareMaskUnordLeF32, Compare)
+IR_OPCODE(ConvertByteU32ToF32, General)
+IR_OPCODE(ConvertU32ToF32, General)
+IR_OPCODE(ConvertI32ToF32, General)
+IR_OPCODE(ConvertF32ToU32, General)
+IR_OPCODE(ConvertF32ToI32, General)
+IR_OPCODE(ConvertF32ToF16, General)
+IR_OPCODE(ConvertF16ToF32, General)
+IR_OPCODE(ConvertU16ToF16, General)
+IR_OPCODE(ConvertF16ToU16, General)
+IR_OPCODE(ConvertI16ToF16, General)
+IR_OPCODE(ConvertF16ToI16, General)
+IR_OPCODE(ConvertRoundPlusInfF32ToI32, General)
+IR_OPCODE(ConvertFloorF32ToI32, General)
+IR_OPCODE(ConvertI4ToOffsetF32, General)
+IR_OPCODE(LdexpF32, General)
+IR_OPCODE(PackF32ToF16Rtz, General)
+IR_OPCODE(PackSnorm2x16F32, General)
+IR_OPCODE(PackUnorm2x16F32, General)
+IR_OPCODE(PackU16U32, General)
+IR_OPCODE(PackU8F32, General)
+IR_OPCODE(PackB32F16, General)
+IR_OPCODE(PackedMadI16, General)
+IR_OPCODE(PackedMulLoU16, General)
+IR_OPCODE(PackedAddI16, General)
+IR_OPCODE(PackedSubI16, General)
+IR_OPCODE(PackedLshlrevB16, General)
+IR_OPCODE(PackedLshrrevB16, General)
+IR_OPCODE(PackedAshrrevI16, General)
+IR_OPCODE(PackedMaxI16, General)
+IR_OPCODE(PackedMinI16, General)
+IR_OPCODE(PackedMadU16, General)
+IR_OPCODE(PackedAddU16, General)
+IR_OPCODE(PackedSubU16, General)
+IR_OPCODE(PackedMaxU16, General)
+IR_OPCODE(PackedMinU16, General)
+IR_OPCODE(PackedAddF16, General)
+IR_OPCODE(PackedMulF16, General)
+IR_OPCODE(PackedMinF16, General)
+IR_OPCODE(PackedMaxF16, General)
+IR_OPCODE(PackedFmaF16, General)
+IR_OPCODE(AddF16, General)
+IR_OPCODE(SubF16, General)
+IR_OPCODE(MulF16, General)
+IR_OPCODE(MinF16, General)
+IR_OPCODE(MaxF16, General)
+IR_OPCODE(FmaF16, General)
+IR_OPCODE(MadMixF16, General)
+IR_OPCODE(IAddU16, General)
+IR_OPCODE(ISubI16, General)
+IR_OPCODE(IMinI16, General)
+IR_OPCODE(IMaxI16, General)
+IR_OPCODE(UMinU16, General)
+IR_OPCODE(UMaxU16, General)
+IR_OPCODE(RcpF32, General)
+IR_OPCODE(FractF32, General)
+IR_OPCODE(TruncF32, General)
+IR_OPCODE(CeilF32, General)
+IR_OPCODE(RoundEvenF32, General)
+IR_OPCODE(FloorF32, General)
+IR_OPCODE(Exp2F32, General)
+IR_OPCODE(Log2F32, General)
+IR_OPCODE(InverseSqrtF32, General)
+IR_OPCODE(SqrtF32, General)
+IR_OPCODE(RcpF16, General)
+IR_OPCODE(SqrtF16, General)
+IR_OPCODE(InverseSqrtF16, General)
+IR_OPCODE(Log2F16, General)
+IR_OPCODE(Exp2F16, General)
+IR_OPCODE(FloorF16, General)
+IR_OPCODE(CeilF16, General)
+IR_OPCODE(TruncF16, General)
+IR_OPCODE(RoundEvenF16, General)
+IR_OPCODE(SinF32, General)
+IR_OPCODE(CosF32, General)
+IR_OPCODE(CubeIdF32, General)
+IR_OPCODE(CubeScF32, General)
+IR_OPCODE(CubeTcF32, General)
+IR_OPCODE(CubeMaF32, General)
+IR_OPCODE(FAddF32, General)
+IR_OPCODE(FSubF32, General)
+IR_OPCODE(FMulF32, General)
+IR_OPCODE(FMinF32, General)
+IR_OPCODE(FMaxF32, General)
+IR_OPCODE(FMadF32, General)
+IR_OPCODE(Dot2AccF32F16, General)
+IR_OPCODE(FMin3F32, General)
+IR_OPCODE(FMax3F32, General)
+IR_OPCODE(FMed3F32, General)
+IR_OPCODE(Min3F16, General)
+IR_OPCODE(Max3F16, General)
+IR_OPCODE(Med3F16, General)
+IR_OPCODE(LoadSrtDword, General)
+IR_OPCODE(SLoadDword, General)
+IR_OPCODE(SBufferLoadDword, General)
+IR_OPCODE(BufferLoadUbyte, General)
+IR_OPCODE(BufferLoadSbyte, General)
+IR_OPCODE(BufferLoadUshort, General)
+IR_OPCODE(BufferLoadSshort, General)
+IR_OPCODE(BufferLoadDword, General)
+IR_OPCODE(BufferStoreByte, General)
+IR_OPCODE(BufferStoreShort, General)
+IR_OPCODE(BufferStoreDword, General)
+IR_OPCODE(AtomicSwapU32, General)
+IR_OPCODE(AtomicAddU32, General)
+IR_OPCODE(AtomicSubU32, General)
+IR_OPCODE(AtomicSMinI32, General)
+IR_OPCODE(AtomicUMinU32, General)
+IR_OPCODE(AtomicSMaxI32, General)
+IR_OPCODE(AtomicUMaxU32, General)
+IR_OPCODE(AtomicAndU32, General)
+IR_OPCODE(AtomicOrU32, General)
+IR_OPCODE(AtomicXorU32, General)
+IR_OPCODE(AtomicFMinF32, General)
+IR_OPCODE(AtomicFMaxF32, General)
+IR_OPCODE(FlatLoadUbyte, General)
+IR_OPCODE(FlatLoadSbyte, General)
+IR_OPCODE(FlatLoadUshort, General)
+IR_OPCODE(FlatLoadSshort, General)
+IR_OPCODE(FlatLoadDword, General)
+IR_OPCODE(FlatStoreByte, General)
+IR_OPCODE(FlatStoreShort, General)
+IR_OPCODE(FlatStoreDword, General)
+IR_OPCODE(DsReadUbyte, General)
+IR_OPCODE(DsReadSbyte, General)
+IR_OPCODE(DsReadUshort, General)
+IR_OPCODE(DsReadSshort, General)
+IR_OPCODE(DsReadB32, General)
+IR_OPCODE(DsWriteByte, General)
+IR_OPCODE(DsWriteShort, General)
+IR_OPCODE(DsWriteB32, General)
+IR_OPCODE(DsMinF32, General)
+IR_OPCODE(DsMaxF32, General)
+IR_OPCODE(DsSwizzleB32, General)
+IR_OPCODE(DsConsume, General)
+IR_OPCODE(DsAppend, General)
+IR_OPCODE(DsWriteAddtidB32, General)
+IR_OPCODE(DsReadAddtidB32, General)
+IR_OPCODE(ImageGetResinfo, General)
+IR_OPCODE(ImageGetLod, General)
+IR_OPCODE(ImageLoad, General)
+IR_OPCODE(ImageStore, General)
+IR_OPCODE(ImageSample, General)
+IR_OPCODE(ImageGather4, General)
+IR_OPCODE(LoadInputF32, General)
+IR_OPCODE(Export, General)

src/kernel/fileSystem.cpp

@@ -64,6 +64,7 @@ struct File {
 	std::filesystem::path               real_name;
 	std::atomic_bool                    opened;
 	std::atomic_bool                    directory;
+	std::atomic_bool                    writable;
 	std::atomic_bool                    append;
 	std::atomic_bool                    sync_writes;
 	SpecialFile                         special;
@@ -129,6 +130,7 @@ int FileDescriptors::CreateDescriptor() {
 	auto* file        = new File {};
 	file->opened      = false;
 	file->directory   = false;
+	file->writable    = false;
 	file->append      = false;
 	file->sync_writes = false;
 	file->special     = SpecialFile::None;
@@ -274,6 +276,10 @@ static std::filesystem::path ResolvePathIgnoringCase(const std::filesystem::path
 
 	return resolved;
 }
+#else
+static bool HasWindowsForbiddenFilenameCharacter(const std::string& relative_path) {
+	return relative_path.find_first_of("<>:\"|?*") != std::string::npos;
+}
 #endif
 
 std::filesystem::path MountPoints::GetRealFilename(const std::string& mounted_file_name) {
@@ -293,6 +299,10 @@ std::filesystem::path MountPoints::GetRealFilename(const std::string& mounted_fi
 			rel_path = Common::RemoveFirst(rel_path, 1);
 		}
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+		if (HasWindowsForbiddenFilenameCharacter(rel_path)) {
+			::printf("FileSystem: Windows-incompatible guest filename: %s\n",
+			         mounted_file_name.c_str());
+		}
 		return p.dir / rel_path;
 #else
 		return ResolvePathIgnoringCase(p.dir / rel_path);
@@ -408,6 +418,7 @@ int KYTY_SYSV_ABI KernelOpen(const char* path, int flags, uint16_t mode) {
 	EXIT_IF(file == nullptr || file->opened || file->directory);
 
 	file->name        = path;
+	file->writable    = rw_mode != Common::File::Mode::Read;
 	file->append      = append;
 	file->sync_writes = fsync || sync || dsync;
 
@@ -792,7 +803,7 @@ int64_t KYTY_SYSV_ABI KernelLseek(int d, int64_t offset, int whence) {
 		return KERNEL_ERROR_ESPIPE;
 	}
 
-	file->mutex.Lock();
+	Common::LockGuard lock(file->mutex);
 
 	bool is_invalid = file->f.IsInvalid();
 
@@ -817,8 +828,6 @@ int64_t KYTY_SYSV_ABI KernelLseek(int d, int64_t offset, int whence) {
 
 	EXIT_IF(pos != offset);
 
-	file->mutex.Unlock();
-
 	if (is_invalid) {
 		LOGF("\tfile is invalid\n");
 		return KERNEL_ERROR_EIO;
@@ -953,6 +962,47 @@ int KYTY_SYSV_ABI KernelFstat(int d, FileStat* sb) {
 	return OK;
 }
 
+int KYTY_SYSV_ABI KernelFtruncate(int d, int64_t length) {
+	PRINT_NAME();
+
+	if (d < DESCRIPTOR_MIN) {
+		return KERNEL_ERROR_EBADF;
+	}
+
+	if (length < 0) {
+		return KERNEL_ERROR_EINVAL;
+	}
+
+	if (::Libs::Network::Net::IsSocket(d)) {
+		return KERNEL_ERROR_EINVAL;
+	}
+
+	auto* file = g_files->GetFile(d);
+
+	if (file == nullptr || !file->opened) {
+		return KERNEL_ERROR_EBADF;
+	}
+
+	if (!file->writable) {
+		return KERNEL_ERROR_EBADF;
+	}
+
+	if (file->directory || file->special != SpecialFile::None) {
+		return KERNEL_ERROR_EINVAL;
+	}
+
+	Common::LockGuard lock(file->mutex);
+
+	if (file->f.IsInvalid() || !file->f.Truncate(static_cast<uint64_t>(length))) {
+		return KERNEL_ERROR_EIO;
+	}
+
+	LOGF("\tFtruncate (size = %" PRId64 ") file: %s\n", length,
+	     Common::PathToString(file->real_name).c_str());
+
+	return OK;
+}
+
 int KYTY_SYSV_ABI KernelUnlink(const char* path) {
 	PRINT_NAME();
 

src/kernel/fileSystem.h

@@ -48,6 +48,7 @@ int64_t KYTY_SYSV_ABI KernelPwrite(int d, const void* buf, size_t nbytes, int64_
 int64_t KYTY_SYSV_ABI KernelLseek(int d, int64_t offset, int whence);
 int KYTY_SYSV_ABI     KernelStat(const char* path, FileStat* sb);
 int KYTY_SYSV_ABI     KernelFstat(int d, FileStat* sb);
+int KYTY_SYSV_ABI     KernelFtruncate(int d, int64_t length);
 int KYTY_SYSV_ABI     KernelUnlink(const char* path);
 int KYTY_SYSV_ABI     KernelRename(const char* from, const char* to);
 int KYTY_SYSV_ABI     KernelGetdirentries(int fd, char* buf, int nbytes, int64_t* basep);

src/kernel/memory.cpp

@@ -65,7 +65,7 @@ constexpr uint64_t PAGE_TABLE_POOL_SIZE   = 4ull * 1024ull * 1024ull * 1024ull;
 constexpr uint64_t PAGE_TABLE_GRANULARITY = 2ull * 1024ull * 1024ull;
 constexpr int      PAGE_TABLE_POOL_ENTRIES =
     static_cast<int>(PAGE_TABLE_POOL_SIZE / PAGE_TABLE_GRANULARITY);
-constexpr uint64_t DEFAULT_FLEXIBLE_MEMORY_SIZE = 4ull * 1024ull * 1024ull * 1024ull;
+constexpr uint64_t DEFAULT_FLEXIBLE_MEMORY_SIZE = 1ull * 1024ull * 1024ull * 1024ull;
 
 static uint64_t                      g_flexible_memory_size        = DEFAULT_FLEXIBLE_MEMORY_SIZE;
 static bool                          g_flexible_memory_size_frozen = false;

src/kernel/pthread.cpp

@@ -365,6 +365,7 @@ struct PthreadAttrPrivate {
 	uint64_t       stack_map_addr;
 	size_t         stack_map_size;
 	int            policy;
+	int            guest_priority;
 	int            inherit_sched;
 	int            solosched;
 	bool           detached;
@@ -875,9 +876,11 @@ bool TestGuestStackOwnerLifecycle(uint64_t* first_address, uint64_t* second_addr
 
 static KYTY_SYSV_ABI void* RunOnGuestStack(void* arg, pthread_entry_func_t func, void* stack_top) {
 #if defined(__x86_64__) || defined(_M_X64)
-	void*      ret       = nullptr;
-	const auto guest_rsp = reinterpret_cast<uintptr_t>(stack_top) & ~static_cast<uintptr_t>(0x0f);
-	const auto guest_rbp = guest_rsp - 4u * sizeof(uint64_t);
+	void*      ret = nullptr;
+	const auto aligned_stack_top =
+	    reinterpret_cast<uintptr_t>(stack_top) & ~static_cast<uintptr_t>(0x0f);
+	const auto guest_rsp = aligned_stack_top - 2u * sizeof(uintptr_t);
+	const auto guest_rbp = guest_rsp;
 
 	auto* guest_root_frame = reinterpret_cast<uintptr_t*>(guest_rbp);
 	guest_root_frame[0]    = 0;
@@ -2128,13 +2131,8 @@ int KYTY_SYSV_ABI PthreadAttrGetschedparam(const PthreadAttr* attr, KernelSchedP
 
 	int result = pthread_attr_getschedparam(&(*attr)->p, param);
 
-	if (param->sched_priority <= -2) {
-		param->sched_priority = 767;
-	} else if (param->sched_priority >= +2) {
-		param->sched_priority = 256;
-	} else {
-		param->sched_priority = 700;
-	}
+	// Host priority mapping is lossy; return the exact guest value.
+	param->sched_priority = (*attr)->guest_priority;
 
 	if (result == 0) {
 		return OK;
@@ -2298,6 +2296,7 @@ int KYTY_SYSV_ABI PthreadAttrSetschedparam(PthreadAttr* attr, const KernelSchedP
 		return KERNEL_ERROR_EINVAL;
 	}
 
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	KernelSchedParam pparam {};
 	if (param->sched_priority <= 478) {
 		pparam.sched_priority = +2;
@@ -2307,12 +2306,13 @@ int KYTY_SYSV_ABI PthreadAttrSetschedparam(PthreadAttr* attr, const KernelSchedP
 		pparam.sched_priority = 0;
 	}
 
-	int result = pthread_attr_setschedparam(&attr_value->p, &pparam);
-
-	if (result == 0) {
-		return OK;
+	if (pthread_attr_setschedparam(&attr_value->p, &pparam) != 0) {
+		return KERNEL_ERROR_EINVAL;
 	}
-	return KERNEL_ERROR_EINVAL;
+#endif
+
+	attr_value->guest_priority = param->sched_priority;
+	return OK;
 }
 
 int KYTY_SYSV_ABI PthreadAttrSetschedpolicy(PthreadAttr* attr, int policy) {
@@ -3639,26 +3639,15 @@ int KYTY_SYSV_ABI PthreadGetprio(Pthread thread, int* prio) {
 
 	EXIT_NOT_IMPLEMENTED(prio == nullptr);
 
-	sched_param param {};
-	int         pol = 0;
-
-	int result = pthread_getschedparam(thread->p, &pol, &param);
-
-	if (result == 0) {
-		if (param.sched_priority <= -2) {
-			*prio = 767;
-		} else if (param.sched_priority >= +2) {
-			*prio = 256;
-		} else {
-			*prio = 700;
-		}
-
-		LOGF("\t PthreadGetprio: %d, %d\n", thread->unique_id, *prio);
-
-		return OK;
+	sched_param native_param {};
+	int         native_policy = 0;
+	if (pthread_getschedparam(thread->p, &native_policy, &native_param) != 0) {
+		return KERNEL_ERROR_EINVAL;
 	}
 
-	return KERNEL_ERROR_EINVAL;
+	*prio = thread->attr->guest_priority;
+	LOGF("\t PthreadGetprio: %d, %d\n", thread->unique_id, *prio);
+	return OK;
 }
 
 int KYTY_SYSV_ABI PthreadSetprio(Pthread thread, int prio) {
@@ -3673,25 +3662,27 @@ int KYTY_SYSV_ABI PthreadSetprio(Pthread thread, int prio) {
 
 	int result = pthread_getschedparam(thread->p, &pol, &param);
 
-	if (result == 0) {
-		if (prio <= 478) {
-			param.sched_priority = +2;
-		} else if (prio >= 733) {
-			param.sched_priority = -2;
-		} else {
-			param.sched_priority = 0;
-		}
-
-		result = pthread_setschedparam(thread->p, pol, &param);
-
-		if (result == 0) {
-			LOGF("\t PthreadSetprio: %d, %d\n", thread->unique_id, prio);
-
-			return OK;
-		}
+	if (result != 0) {
+		return KERNEL_ERROR_EINVAL;
 	}
 
-	return KERNEL_ERROR_EINVAL;
+#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
+	if (prio <= 478) {
+		param.sched_priority = +2;
+	} else if (prio >= 733) {
+		param.sched_priority = -2;
+	} else {
+		param.sched_priority = 0;
+	}
+
+	if (pthread_setschedparam(thread->p, pol, &param) != 0) {
+		return KERNEL_ERROR_EINVAL;
+	}
+#endif
+
+	thread->attr->guest_priority = prio;
+	LOGF("\t PthreadSetprio: %d, %d\n", thread->unique_id, prio);
+	return OK;
 }
 
 void KYTY_SYSV_ABI PthreadTestcancel() {

src/kernel/syncOnAddress.cpp

@@ -0,0 +1,287 @@
+#include "kernel/syncOnAddress.h"
+
+#include "common/threads.h"
+#include "libs/errno.h"
+
+#include <algorithm>
+#include <chrono>
+#include <climits>
+#include <cstdint>
+#include <list>
+#include <memory>
+#include <mutex>
+#include <unordered_map>
+
+#if KYTY_PLATFORM == KYTY_PLATFORM_LINUX && !defined(__APPLE__)
+#include <cerrno>
+#include <linux/futex.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+#endif
+
+namespace Libs::LibKernel::SyncOnAddress {
+
+namespace {
+
+constexpr uint32_t SIGNAL_POLL_MICROS = 10000;
+
+using Clock = std::chrono::steady_clock;
+
+template <typename T>
+[[nodiscard]] bool IsValidWaitAddress(const volatile T* address) {
+	return address != nullptr && (reinterpret_cast<uintptr_t>(address) & (alignof(T) - 1u)) == 0;
+}
+
+[[nodiscard]] bool IsValidWakeAddress(const volatile void* address) {
+	return address != nullptr &&
+	       (reinterpret_cast<uintptr_t>(address) & (alignof(uint32_t) - 1u)) == 0;
+}
+
+template <typename T>
+[[nodiscard]] T ReadWord(const volatile T* address) {
+	return __atomic_load_n(address, __ATOMIC_ACQUIRE);
+}
+
+struct WaitDeadline {
+	bool              finite = false;
+	Clock::time_point end {};
+};
+
+[[nodiscard]] WaitDeadline MakeDeadline(const uint32_t* timeout_micros) {
+	if (timeout_micros == nullptr) {
+		return {};
+	}
+	return {true, Clock::now() + std::chrono::microseconds(*timeout_micros)};
+}
+
+[[nodiscard]] uint32_t GetWaitSliceMicros(const WaitDeadline& deadline, bool first_wait) {
+	if (!deadline.finite) {
+		return SIGNAL_POLL_MICROS;
+	}
+
+	const auto now = Clock::now();
+	if (now >= deadline.end) {
+		return first_wait ? 0u : UINT32_MAX;
+	}
+
+	const auto remaining =
+	    std::chrono::duration_cast<std::chrono::microseconds>(deadline.end - now).count();
+	return static_cast<uint32_t>(std::min<int64_t>(remaining, SIGNAL_POLL_MICROS));
+}
+
+void PollSignals(signal_poll_func_t signal_poll) {
+	if (signal_poll != nullptr) {
+		signal_poll();
+	}
+}
+
+#if KYTY_PLATFORM == KYTY_PLATFORM_LINUX && !defined(__APPLE__)
+
+template <typename T>
+int WaitLinux(volatile T* address, T expected, const uint32_t* timeout_micros,
+              signal_poll_func_t signal_poll) {
+	const auto deadline   = MakeDeadline(timeout_micros);
+	bool       first_wait = true;
+
+	for (;;) {
+		if (ReadWord(address) != expected) {
+			return OK;
+		}
+		const auto slice_micros = GetWaitSliceMicros(deadline, first_wait);
+		if (slice_micros == UINT32_MAX) {
+			return ReadWord(address) == expected ? KERNEL_ERROR_ETIMEDOUT : OK;
+		}
+		const timespec timeout = {
+		    .tv_sec  = static_cast<time_t>(slice_micros / 1000000u),
+		    .tv_nsec = static_cast<long>(slice_micros % 1000000u) * 1000L,
+		};
+
+		long result     = 0;
+		int  wait_error = 0;
+		result          = syscall(SYS_futex, const_cast<T*>(address), FUTEX_WAIT_PRIVATE,
+		                          static_cast<uint32_t>(expected), &timeout, nullptr, 0);
+		if (result != 0) {
+			wait_error = errno;
+		}
+		if (result == 0 || wait_error == EAGAIN) {
+			return OK;
+		}
+		if (wait_error != ETIMEDOUT && wait_error != EINTR) {
+			return KERNEL_ERROR_EINVAL;
+		}
+
+		PollSignals(signal_poll);
+		if (deadline.finite && Clock::now() >= deadline.end) {
+			return ReadWord(address) == expected ? KERNEL_ERROR_ETIMEDOUT : OK;
+		}
+		first_wait = false;
+	}
+}
+
+int WakeLinux(volatile void* address, int32_t count) {
+	const auto result = syscall(SYS_futex, const_cast<void*>(address), FUTEX_WAKE_PRIVATE, count,
+	                            nullptr, nullptr, 0);
+	return result < 0 ? KERNEL_ERROR_EINVAL : OK;
+}
+
+#endif
+
+struct PortableWaiter {
+	Common::CondVar condition;
+	bool            wake_requested = false;
+};
+
+struct PortableAddressEntry {
+	Common::Mutex              mutex;
+	std::list<PortableWaiter*> waiters;
+};
+
+struct PortableAddressRegistry {
+	std::mutex                                                           mutex;
+	std::unordered_map<uintptr_t, std::shared_ptr<PortableAddressEntry>> entries;
+};
+
+PortableAddressRegistry& GetPortableRegistry() {
+	static PortableAddressRegistry registry;
+	return registry;
+}
+
+std::shared_ptr<PortableAddressEntry> RegisterPortableWaiter(volatile void*  address,
+                                                             PortableWaiter* waiter) {
+	auto&           registry = GetPortableRegistry();
+	std::lock_guard registry_lock(registry.mutex);
+	auto&           entry = registry.entries[reinterpret_cast<uintptr_t>(address)];
+	if (!entry) {
+		entry = std::make_shared<PortableAddressEntry>();
+	}
+	entry->mutex.Lock();
+	entry->waiters.push_back(waiter);
+	return entry;
+}
+
+void UnregisterPortableWaiter(volatile void*                               address,
+                              const std::shared_ptr<PortableAddressEntry>& entry,
+                              PortableWaiter*                              waiter) {
+	entry->waiters.remove(waiter);
+	const bool empty = entry->waiters.empty();
+	entry->mutex.Unlock();
+	if (!empty) {
+		return;
+	}
+
+	auto&           registry = GetPortableRegistry();
+	std::lock_guard registry_lock(registry.mutex);
+	entry->mutex.Lock();
+	const auto it = registry.entries.find(reinterpret_cast<uintptr_t>(address));
+	if (it != registry.entries.end() && it->second == entry && entry->waiters.empty()) {
+		registry.entries.erase(it);
+	}
+	entry->mutex.Unlock();
+}
+
+template <typename T>
+int WaitPortable(volatile T* address, T expected, const uint32_t* timeout_micros,
+                 signal_poll_func_t signal_poll) {
+	PortableWaiter waiter;
+	auto           entry      = RegisterPortableWaiter(address, &waiter);
+	const auto     deadline   = MakeDeadline(timeout_micros);
+	bool           first_wait = true;
+	int            result     = OK;
+
+	while (ReadWord(address) == expected && !waiter.wake_requested) {
+		const auto slice_micros = GetWaitSliceMicros(deadline, first_wait);
+		if (slice_micros == UINT32_MAX) {
+			result = KERNEL_ERROR_ETIMEDOUT;
+			break;
+		}
+		if (slice_micros == 0) {
+			result = KERNEL_ERROR_ETIMEDOUT;
+			break;
+		}
+
+		(void)waiter.condition.WaitFor(&entry->mutex, slice_micros);
+		entry->mutex.Unlock();
+		PollSignals(signal_poll);
+		entry->mutex.Lock();
+
+		if (deadline.finite && Clock::now() >= deadline.end && ReadWord(address) == expected &&
+		    !waiter.wake_requested) {
+			result = KERNEL_ERROR_ETIMEDOUT;
+			break;
+		}
+		first_wait = false;
+	}
+
+	UnregisterPortableWaiter(address, entry, &waiter);
+	return result;
+}
+
+int WakePortable(volatile void* address, int32_t count) {
+	if (count == 0) {
+		return OK;
+	}
+	auto&            registry = GetPortableRegistry();
+	std::unique_lock registry_lock(registry.mutex);
+	const auto       it = registry.entries.find(reinterpret_cast<uintptr_t>(address));
+	if (it == registry.entries.end()) {
+		return OK;
+	}
+	auto entry = it->second;
+	entry->mutex.Lock();
+	registry_lock.unlock();
+
+	int32_t remaining = count;
+	for (auto* waiter: entry->waiters) {
+		if (!waiter->wake_requested) {
+			waiter->wake_requested = true;
+			waiter->condition.Signal();
+			if (remaining != INT_MAX && --remaining == 0) {
+				break;
+			}
+		}
+	}
+	entry->mutex.Unlock();
+	return OK;
+}
+
+template <typename T>
+int WaitImpl(volatile T* address, T expected, const uint32_t* timeout_micros,
+             signal_poll_func_t signal_poll) {
+	if (!IsValidWaitAddress(address)) {
+		return KERNEL_ERROR_EINVAL;
+	}
+
+	int result = OK;
+#if KYTY_PLATFORM == KYTY_PLATFORM_LINUX && !defined(__APPLE__)
+	result = WaitLinux(address, expected, timeout_micros, signal_poll);
+#else
+	result = WaitPortable(address, expected, timeout_micros, signal_poll);
+#endif
+	PollSignals(signal_poll);
+	return result;
+}
+
+} // namespace
+
+int Wait32(volatile uint32_t* address, uint32_t expected, const uint32_t* timeout_micros,
+           signal_poll_func_t signal_poll) {
+	return WaitImpl(address, expected, timeout_micros, signal_poll);
+}
+
+int Wait64(volatile uint64_t* address, uint64_t expected, const uint32_t* timeout_micros,
+           signal_poll_func_t signal_poll) {
+	return WaitImpl(address, expected, timeout_micros, signal_poll);
+}
+
+int Wake(volatile void* address, int32_t count) {
+	if (!IsValidWakeAddress(address) || count < 0) {
+		return KERNEL_ERROR_EINVAL;
+	}
+
+#if KYTY_PLATFORM == KYTY_PLATFORM_LINUX && !defined(__APPLE__)
+	return WakeLinux(address, count);
+#endif
+	return WakePortable(address, count);
+}
+
+} // namespace Libs::LibKernel::SyncOnAddress

src/kernel/syncOnAddress.h

@@ -0,0 +1,19 @@
+#ifndef EMULATOR_INCLUDE_EMULATOR_KERNEL_SYNC_ON_ADDRESS_H_
+#define EMULATOR_INCLUDE_EMULATOR_KERNEL_SYNC_ON_ADDRESS_H_
+
+#include "common/abi.h"
+#include "common/common.h"
+
+namespace Libs::LibKernel::SyncOnAddress {
+
+using signal_poll_func_t = void (*)();
+
+int Wait32(volatile uint32_t* address, uint32_t expected, const uint32_t* timeout_micros,
+           signal_poll_func_t signal_poll = nullptr);
+int Wait64(volatile uint64_t* address, uint64_t expected, const uint32_t* timeout_micros,
+           signal_poll_func_t signal_poll = nullptr);
+int Wake(volatile void* address, int32_t count);
+
+} // namespace Libs::LibKernel::SyncOnAddress
+
+#endif /* EMULATOR_INCLUDE_EMULATOR_KERNEL_SYNC_ON_ADDRESS_H_ */

src/kytyGitVersion.h.in

@@ -1 +1,2 @@
-#define KYTY_GIT_VERSION "@KYTY_GIT_VERSION@"
+#define KYTY_GIT_VERSION "@KYTY_GIT_VERSION@"
+#define KYTY_GIT_HASH "@KYTY_GIT_HASH@"

src/launcher/CMakeLists.txt

@@ -16,6 +16,7 @@ file(GLOB launcher_forms
 add_executable(launcher WIN32
 	${launcher_src}
 	${launcher_forms}
+	resources.qrc
 )
 
 
@@ -37,7 +38,6 @@ elseif(LINUX)
 	set_target_properties(launcher PROPERTIES LINK_FLAGS "${KYTY_LD_OPTIONS}")
 endif()
 
-add_dependencies(launcher KytyGitVersion)  
 add_dependencies(launcher kyty_emulator)
 
 if(KYTY_CLANG_CL)

src/launcher/forms/configuration_edit_dialog.ui

@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>560</width>
-    <height>420</height>
+    <height>450</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -78,6 +78,16 @@
            </property>
           </widget>
          </item>
+         <item row="2" column="0">
+          <widget class="QCheckBox" name="checkBox_fullscreen">
+           <property name="toolTip">
+            <string>Run in borderless desktop fullscreen</string>
+           </property>
+           <property name="text">
+            <string>Fullscreen</string>
+           </property>
+          </widget>
+         </item>
         </layout>
        </widget>
       </item>
@@ -119,41 +129,55 @@
        </widget>
       </item>
       <item row="3" column="0">
+       <widget class="QLabel" name="label_console_language">
+        <property name="text">
+         <string>Console language:</string>
+        </property>
+       </widget>
+      </item>
+      <item row="3" column="1">
+       <widget class="QComboBox" name="comboBox_console_language">
+        <property name="toolTip">
+         <string>Language</string>
+        </property>
+       </widget>
+      </item>
+      <item row="4" column="0">
        <widget class="QLabel" name="label_20">
         <property name="text">
          <string>Shader optimization type:</string>
         </property>
        </widget>
       </item>
-      <item row="3" column="1">
+      <item row="4" column="1">
        <widget class="QComboBox" name="comboBox_shader_optimization_type">
         <property name="toolTip">
          <string>Optimize shaders for code size or performance</string>
         </property>
        </widget>
       </item>
-      <item row="4" column="0">
+      <item row="5" column="0">
        <widget class="QLabel" name="label_21">
         <property name="text">
          <string>Shader log direction:</string>
         </property>
        </widget>
       </item>
-      <item row="4" column="1">
+      <item row="5" column="1">
        <widget class="QComboBox" name="comboBox_shader_log_direction">
         <property name="toolTip">
          <string>Dump shaders to file or console window. If enabled may decrease emulator performance</string>
         </property>
        </widget>
       </item>
-      <item row="5" column="0">
+      <item row="6" column="0">
        <widget class="QLabel" name="label_22">
         <property name="text">
          <string>Shader log folder:</string>
         </property>
        </widget>
       </item>
-      <item row="5" column="1">
+      <item row="6" column="1">
        <widget class="MandatoryLineEdit" name="lineEdit_shader_log_folder">
         <property name="toolTip">
          <string>Specify directory to dump shaders</string>
@@ -163,14 +187,14 @@
         </property>
        </widget>
       </item>
-      <item row="6" column="0">
+      <item row="7" column="0">
        <widget class="QLabel" name="label_24">
         <property name="text">
          <string>Command buffer dump folder:</string>
         </property>
        </widget>
       </item>
-      <item row="6" column="1">
+      <item row="7" column="1">
        <widget class="MandatoryLineEdit" name="lineEdit_cmd_dump_folder">
         <property name="toolTip">
          <string>Specify directory to dump command buffers</string>
@@ -180,28 +204,28 @@
         </property>
        </widget>
       </item>
-      <item row="7" column="0">
+      <item row="8" column="0">
        <widget class="QLabel" name="label_25">
         <property name="text">
          <string>Printf direction:</string>
         </property>
        </widget>
       </item>
-      <item row="7" column="1">
+      <item row="8" column="1">
        <widget class="QComboBox" name="comboBox_printf_direction">
         <property name="toolTip">
          <string>Print logs to file or console window. If enabled may decrease emulator performance</string>
         </property>
        </widget>
       </item>
-      <item row="8" column="0">
+      <item row="9" column="0">
        <widget class="QLabel" name="label_26">
         <property name="text">
          <string>Printf output file:</string>
         </property>
        </widget>
       </item>
-      <item row="8" column="1">
+      <item row="9" column="1">
        <widget class="MandatoryLineEdit" name="lineEdit_printf_file">
         <property name="toolTip">
          <string>Specify file to dump logs</string>
@@ -211,14 +235,14 @@
         </property>
        </widget>
       </item>
-      <item row="9" column="0">
+      <item row="10" column="0">
        <widget class="QLabel" name="label_27">
         <property name="text">
          <string>Profiler direction:</string>
         </property>
        </widget>
       </item>
-      <item row="9" column="1">
+      <item row="10" column="1">
        <widget class="QComboBox" name="comboBox_profiler_direction">
         <property name="toolTip">
          <string>Enable or disable profiler. If enabled may decrease emulator performance</string>

src/launcher/forms/configuration_list_widget.ui

@@ -69,6 +69,31 @@
            </property>
           </widget>
          </item>
+         <item>
+          <widget class="QToolButton" name="input_mapping_button">
+           <property name="minimumSize">
+            <size>
+             <width>36</width>
+             <height>36</height>
+            </size>
+           </property>
+           <property name="toolTip">
+            <string>Edit input mapping</string>
+           </property>
+           <property name="text">
+            <string/>
+           </property>
+           <property name="iconSize">
+            <size>
+             <width>32</width>
+             <height>32</height>
+            </size>
+           </property>
+           <property name="autoRaise">
+            <bool>true</bool>
+           </property>
+          </widget>
+         </item>
          <item>
           <widget class="QToolButton" name="edit_button">
            <property name="minimumSize">

src/launcher/icons/edit-configuration.svg

@@ -0,0 +1,7 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <g fill="none" stroke="#e8f1ff" stroke-linecap="round" stroke-linejoin="round" stroke-width="2">
+    <path d="M8 4h11l5 5v7M24 9h-5V4M16 27H8a2 2 0 0 1-2-2V6a2 2 0 0 1 2-2"/>
+    <path d="m15 24 1-4 8-8 4 4-8 8-4 1Z"/>
+    <path d="m22 14 4 4" opacity=".8"/>
+  </g>
+</svg>

src/launcher/icons/global-settings.svg

@@ -0,0 +1,8 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <g fill="none" stroke="#e8f1ff" stroke-linecap="round" stroke-linejoin="round" stroke-width="2">
+    <path d="M5 8h3M14 8h13M5 16h13M24 16h3M5 24h6M17 24h10"/>
+    <circle cx="11" cy="8" r="3"/>
+    <circle cx="21" cy="16" r="3"/>
+    <circle cx="14" cy="24" r="3"/>
+  </g>
+</svg>

src/launcher/icons/input-mapping.svg

@@ -0,0 +1,9 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <g fill="none" stroke="#e8f1ff" stroke-linecap="round" stroke-linejoin="round" stroke-width="2">
+    <path d="M10 10h12c3.6 0 5.8 2.3 6.6 6.8l.9 5.1c.4 2.4-.8 4.1-2.8 4.1-1.4 0-2.5-.7-3.6-2.3L21.3 21H10.7l-1.8 2.7C7.8 25.3 6.7 26 5.3 26c-2 0-3.2-1.7-2.8-4.1l.9-5.1C4.2 12.3 6.4 10 10 10Z"/>
+    <path d="M8 16h6M11 13v6"/>
+    <circle cx="22" cy="15" r="1" fill="#e8f1ff" stroke="none"/>
+    <circle cx="25" cy="18" r="1" fill="#e8f1ff" stroke="none"/>
+    <path d="M13 7h6M16 4v6" opacity=".8"/>
+  </g>
+</svg>

src/launcher/icons/remove-configuration.svg

@@ -0,0 +1,6 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 32 32">
+  <g fill="none" stroke="#e8f1ff" stroke-linecap="round" stroke-linejoin="round" stroke-width="2">
+    <path d="M6 9h20M12 9V5h8v4M9 9l1 18h12l1-18"/>
+    <path d="M14 14v8M18 14v8" opacity=".8"/>
+  </g>
+</svg>

src/launcher/include/configuration.h

@@ -48,6 +48,9 @@ class Configuration: public QObject {
 	Q_OBJECT
 
 public:
+	static constexpr int DEFAULT_CONSOLE_LANGUAGE = 1;
+	static constexpr int MAX_CONSOLE_LANGUAGE     = 29;
+
 	enum class Resolution {
 		R1280X720,
 		R1920X1080,
@@ -82,8 +85,10 @@ public:
 	QString    game_comment;
 
 	Resolution             screen_resolution           = Resolution::R1280X720;
+	bool                   fullscreen_enabled          = false;
 	int                    vblank_frequency            = 60;
-	bool                   vulkan_validation_enabled   = true;
+	int                    console_language            = DEFAULT_CONSOLE_LANGUAGE;
+	bool                   vulkan_validation_enabled   = false;
 	bool                   shader_validation_enabled   = true;
 	ShaderOptimizationType shader_optimization_type    = ShaderOptimizationType::Performance;
 	ShaderLogDirection     shader_log_direction        = ShaderLogDirection::Silent;
@@ -94,12 +99,15 @@ public:
 	QString                printf_output_file          = "_kyty.txt";
 	ProfilerDirection      profiler_direction          = ProfilerDirection::None;
 	bool                   renderdoc_enabled           = false;
+	QStringList            host_input_mapping;
 
 	QString elf = QStringLiteral("eboot.bin");
 
 	void CopyEmulatorSettingsFrom(const Configuration& other) {
 		screen_resolution           = other.screen_resolution;
+		fullscreen_enabled          = other.fullscreen_enabled;
 		vblank_frequency            = other.vblank_frequency;
+		console_language            = other.console_language;
 		vulkan_validation_enabled   = other.vulkan_validation_enabled;
 		shader_validation_enabled   = other.shader_validation_enabled;
 		shader_optimization_type    = other.shader_optimization_type;
@@ -111,6 +119,7 @@ public:
 		printf_output_file          = other.printf_output_file;
 		profiler_direction          = other.profiler_direction;
 		renderdoc_enabled           = other.renderdoc_enabled;
+		host_input_mapping          = other.host_input_mapping;
 	}
 
 	void CopyFrom(const Configuration& other) {
@@ -133,7 +142,9 @@ public:
 		KYTY_CFG_SET(game_path);
 		KYTY_CFG_SET(custom_settings);
 		KYTY_CFG_SET(screen_resolution);
+		KYTY_CFG_SET(fullscreen_enabled);
 		KYTY_CFG_SET(vblank_frequency);
+		KYTY_CFG_SET(console_language);
 		KYTY_CFG_SET(vulkan_validation_enabled);
 		KYTY_CFG_SET(shader_validation_enabled);
 		KYTY_CFG_SET(shader_optimization_type);
@@ -145,6 +156,7 @@ public:
 		KYTY_CFG_SET(printf_output_file);
 		KYTY_CFG_SET(profiler_direction);
 		KYTY_CFG_SET(renderdoc_enabled);
+		s->setValue("host_input_mapping", host_input_mapping);
 		KYTY_CFG_SET(elf);
 	}
 
@@ -154,7 +166,12 @@ public:
 		KYTY_CFG_GET(game_path);
 		KYTY_CFG_GET(custom_settings);
 		KYTY_CFG_GET(screen_resolution);
+		KYTY_CFG_GET(fullscreen_enabled);
 		vblank_frequency = s->value("vblank_frequency", vblank_frequency).toInt();
+		console_language = s->value("console_language", console_language).toInt();
+		if (console_language < 0 || console_language > MAX_CONSOLE_LANGUAGE) {
+			console_language = DEFAULT_CONSOLE_LANGUAGE;
+		}
 		KYTY_CFG_GET(vulkan_validation_enabled);
 		KYTY_CFG_GET(shader_validation_enabled);
 		KYTY_CFG_GET(shader_optimization_type);
@@ -166,7 +183,8 @@ public:
 		KYTY_CFG_GET(printf_output_file);
 		KYTY_CFG_GET(profiler_direction);
 		KYTY_CFG_GET(renderdoc_enabled);
-		elf = s->value("elf", elf).toString();
+		host_input_mapping = s->value("host_input_mapping", host_input_mapping).toStringList();
+		elf                = s->value("elf", elf).toString();
 	}
 };
 

src/launcher/include/configurationListWidget.h

@@ -38,7 +38,10 @@ public:
 
 	[[nodiscard]] const QString&     GetSettingsFile() const { return m_settings_file; }
 	[[nodiscard]] const QStringList& GetGameDirectories() const { return m_game_dirs; }
-	[[nodiscard]] bool               CanViewSelectedTrophies() const;
+	[[nodiscard]] const QStringList& GetHostInputMapping() const {
+		return m_global_info.host_input_mapping;
+	}
+	[[nodiscard]] bool CanViewSelectedTrophies() const;
 
 	bool EnsureGameDirectory();
 	void ScanGameDirectory();
@@ -58,6 +61,7 @@ protected slots:
 	void edit_configuration();
 	void delete_configuartion();
 	void edit_global_settings();
+	void edit_input_mapping();
 	void run_configuration();
 	void list_currentItemChanged(QTreeWidgetItem* current, QTreeWidgetItem* previous);
 	void list_itemDoubleClicked(QTreeWidgetItem* witem, int column);

src/launcher/include/inputMappingDialog.h

@@ -0,0 +1,31 @@
+#ifndef LAUNCHER_INCLUDE_INPUT_MAPPING_DIALOG_H_
+#define LAUNCHER_INCLUDE_INPUT_MAPPING_DIALOG_H_
+
+#include <QDialog>
+#include <QStringList>
+
+class QPushButton;
+class QTreeWidget;
+class QTreeWidgetItem;
+class QWidget;
+
+class InputMappingDialog final: public QDialog {
+public:
+	explicit InputMappingDialog(const QStringList& mapping, QWidget* parent = nullptr);
+
+	[[nodiscard]] QStringList Mapping() const;
+
+private:
+	void ChangeBinding();
+	void ClearBinding();
+	void RestoreDefaults();
+	void SetBinding(QTreeWidgetItem* item, const QString& binding);
+	void UpdateButtons();
+
+	QTreeWidget* m_bindings      = nullptr;
+	QPushButton* m_change_button = nullptr;
+	QPushButton* m_clear_button  = nullptr;
+	bool         m_customized    = false;
+};
+
+#endif /* LAUNCHER_INCLUDE_INPUT_MAPPING_DIALOG_H_ */

src/launcher/resources.qrc

@@ -0,0 +1,8 @@
+<RCC>
+ <qresource prefix="/icons">
+  <file alias="edit-configuration.svg">icons/edit-configuration.svg</file>
+  <file alias="global-settings.svg">icons/global-settings.svg</file>
+  <file alias="input-mapping.svg">icons/input-mapping.svg</file>
+  <file alias="remove-configuration.svg">icons/remove-configuration.svg</file>
+ </qresource>
+</RCC>

src/launcher/src/configurationEditDialog.cpp

@@ -30,6 +30,39 @@ constexpr char SETTINGS_CFG_DIALOG[]               = "ConfigurationEditDialog";
 constexpr char SETTINGS_CFG_LAST_GEOMETRY[]        = "geometry";
 constexpr int  GLOBAL_SETTINGS_GAME_DIRS_MIN_WIDTH = 560;
 
+const QStringList CONSOLE_LANGUAGE_NAMES = {
+    "Japanese",
+    "English (United States)",
+    "French (France)",
+    "Spanish (Spain)",
+    "German",
+    "Italian",
+    "Dutch",
+    "Portuguese (Portugal)",
+    "Russian",
+    "Korean",
+    "Chinese (Traditional)",
+    "Chinese (Simplified)",
+    "Finnish",
+    "Swedish",
+    "Danish",
+    "Norwegian",
+    "Polish",
+    "Portuguese (Brazil)",
+    "English (United Kingdom)",
+    "Turkish",
+    "Spanish (Latin America)",
+    "Arabic",
+    "French (Canada)",
+    "Czech",
+    "Hungarian",
+    "Greek",
+    "Romanian",
+    "Thai",
+    "Vietnamese",
+    "Indonesian",
+};
+
 static QString NormalizeGameDirectory(const QString& dir) {
 	const auto trimmed = dir.trimmed();
 	if (trimmed.isEmpty()) {
@@ -120,7 +153,14 @@ static void ListInit(QComboBox* combo, T value) {
 
 void ConfigurationEditDialog::Init(const Configuration& info) {
 	ListInit(m_ui->comboBox_screen_resolution, info.screen_resolution);
+	m_ui->checkBox_fullscreen->setChecked(info.fullscreen_enabled);
 	m_ui->spinBox_vblank_frequency->setValue(info.vblank_frequency);
+	m_ui->comboBox_console_language->clear();
+	m_ui->comboBox_console_language->addItems(CONSOLE_LANGUAGE_NAMES);
+	m_ui->comboBox_console_language->setCurrentIndex(
+	    info.console_language >= 0 && info.console_language < CONSOLE_LANGUAGE_NAMES.size()
+	        ? info.console_language
+	        : Configuration::DEFAULT_CONSOLE_LANGUAGE);
 	m_ui->checkBox_shader_validation->setChecked(info.shader_validation_enabled);
 	m_ui->checkBox_vulkan_validation->setChecked(info.vulkan_validation_enabled);
 	m_ui->checkBox_renderdoc_capture->setChecked(info.renderdoc_enabled);
@@ -240,7 +280,9 @@ void ConfigurationEditDialog::moveEvent(QMoveEvent* event) {
 static void UpdateInfo(Configuration& info, Ui::ConfigurationEditDialog& ui) {
 	info.screen_resolution =
 	    TextToEnum<Configuration::Resolution>(ui.comboBox_screen_resolution->currentText());
+	info.fullscreen_enabled        = ui.checkBox_fullscreen->isChecked();
 	info.vblank_frequency          = ui.spinBox_vblank_frequency->value();
+	info.console_language          = ui.comboBox_console_language->currentIndex();
 	info.vulkan_validation_enabled = ui.checkBox_vulkan_validation->isChecked();
 	info.shader_validation_enabled = ui.checkBox_shader_validation->isChecked();
 	info.renderdoc_enabled         = ui.checkBox_renderdoc_capture->isChecked();

src/launcher/src/configurationListWidget.cpp

@@ -6,6 +6,7 @@
 #include "configurationEditDialog.h"
 #include "configurationItem.h"
 #include "gameListTreeWidget.h"
+#include "inputMappingDialog.h"
 #include "mainDialog.h"
 #include "patchesDialog.h"
 #include "trophyViewerDialog.h"
@@ -169,6 +170,7 @@ static void ApplyGameListStyle(Ui::ConfigurationListWidget* ui) {
 	    "QToolButton:disabled { background: transparent; }"));
 	ui->edit_button->setStyleSheet(ui->global_settings_button->styleSheet());
 	ui->delete_button->setStyleSheet(ui->global_settings_button->styleSheet());
+	ui->input_mapping_button->setStyleSheet(ui->global_settings_button->styleSheet());
 }
 
 static void AddSaveDataDir(QStringList* dirs, QSet<QString>* seen, const QString& root,
@@ -226,10 +228,12 @@ ConfigurationListWidget::ConfigurationListWidget(QWidget* parent)
 	m_ui->setupUi(this);
 	ApplyGameListStyle(m_ui);
 
-	m_ui->global_settings_button->setIcon(style()->standardIcon(QStyle::SP_FileDialogDetailedView));
+	m_ui->global_settings_button->setIcon(QIcon(QStringLiteral(":/icons/global-settings.svg")));
 	m_ui->global_settings_button->setToolTip(tr("Edit global settings and game folders"));
-	m_ui->edit_button->setIcon(style()->standardIcon(QStyle::SP_FileIcon));
-	m_ui->delete_button->setIcon(style()->standardIcon(QStyle::SP_DialogDiscardButton));
+	m_ui->input_mapping_button->setIcon(QIcon(QStringLiteral(":/icons/input-mapping.svg")));
+	m_ui->input_mapping_button->setToolTip(tr("Edit global input mapping"));
+	m_ui->edit_button->setIcon(QIcon(QStringLiteral(":/icons/edit-configuration.svg")));
+	m_ui->delete_button->setIcon(QIcon(QStringLiteral(":/icons/remove-configuration.svg")));
 
 	m_ui->delete_button->setEnabled(false);
 	m_ui->edit_button->setEnabled(false);
@@ -249,6 +253,8 @@ ConfigurationListWidget::ConfigurationListWidget(QWidget* parent)
 
 	connect(m_ui->global_settings_button, &QToolButton::clicked, this,
 	        &ConfigurationListWidget::edit_global_settings);
+	connect(m_ui->input_mapping_button, &QToolButton::clicked, this,
+	        &ConfigurationListWidget::edit_input_mapping);
 	connect(m_ui->edit_button, &QToolButton::clicked, this,
 	        &ConfigurationListWidget::edit_configuration);
 	connect(m_ui->delete_button, &QToolButton::clicked, this,
@@ -717,6 +723,14 @@ void ConfigurationListWidget::edit_global_settings() {
 	}
 }
 
+void ConfigurationListWidget::edit_input_mapping() {
+	InputMappingDialog dialog(m_global_info.host_input_mapping, this);
+	if (dialog.exec() == QDialog::Accepted) {
+		m_global_info.host_input_mapping = dialog.Mapping();
+		WriteSettings();
+	}
+}
+
 void ConfigurationListWidget::ClearCustomSettings(ConfigurationItem* item) {
 	delete m_custom_infos.take(item->GetInfo().game_path);
 }

src/launcher/src/inputMappingDialog.cpp

@@ -0,0 +1,311 @@
+#include "inputMappingDialog.h"
+
+#include <QAbstractItemView>
+#include <QDialogButtonBox>
+#include <QHBoxLayout>
+#include <QHash>
+#include <QHeaderView>
+#include <QKeyEvent>
+#include <QKeySequence>
+#include <QLabel>
+#include <QMouseEvent>
+#include <QPushButton>
+#include <QStringList>
+#include <QTreeWidget>
+#include <QVBoxLayout>
+
+namespace {
+
+constexpr int BINDING_COLUMN = 1;
+
+struct PadButton {
+	const char* id;
+	const char* label;
+	const char* default_binding;
+};
+
+constexpr PadButton PAD_BUTTONS[] = {
+    {"Up", "D-pad Up", "Up"},
+    {"Down", "D-pad Down", "Down"},
+    {"Left", "D-pad Left", "Left"},
+    {"Right", "D-pad Right", "Right"},
+    {"Triangle", "Triangle", "I"},
+    {"Circle", "Circle", "L"},
+    {"Cross", "Cross", "J"},
+    {"Square", "Square", "K"},
+    {"L1", "L1", "Q"},
+    {"R1", "R1", "E"},
+    {"L2", "L2", ""},
+    {"R2", "R2", ""},
+    {"L3", "L3", "Left Shift"},
+    {"R3", "R3", "Left Ctrl"},
+    {"Options", "Options", "Return"},
+    {"TouchPad", "Touch pad", "Backspace"},
+};
+
+QString KeypadName(int key) {
+	if (key >= Qt::Key_0 && key <= Qt::Key_9) {
+		return QStringLiteral("Keypad %1").arg(key - Qt::Key_0);
+	}
+
+	switch (key) {
+		case Qt::Key_Return:
+		case Qt::Key_Enter: return QStringLiteral("Keypad Enter");
+		case Qt::Key_Slash: return QStringLiteral("Keypad /");
+		case Qt::Key_Asterisk: return QStringLiteral("Keypad *");
+		case Qt::Key_Minus: return QStringLiteral("Keypad -");
+		case Qt::Key_Plus: return QStringLiteral("Keypad +");
+		case Qt::Key_Period: return QStringLiteral("Keypad .");
+		case Qt::Key_Equal: return QStringLiteral("Keypad =");
+		case Qt::Key_Comma: return QStringLiteral("Keypad ,");
+		default: return {};
+	}
+}
+
+QString KeyName(const QKeyEvent& event) {
+	const int key = event.key();
+	if (event.modifiers().testFlag(Qt::KeypadModifier)) {
+		return KeypadName(key);
+	}
+	if (key >= Qt::Key_A && key <= Qt::Key_Z) {
+		return QChar(key);
+	}
+	if (key >= Qt::Key_0 && key <= Qt::Key_9) {
+		return QChar(key);
+	}
+	if (key >= Qt::Key_F1 && key <= Qt::Key_F24) {
+		return QStringLiteral("F%1").arg(key - Qt::Key_F1 + 1);
+	}
+
+	switch (key) {
+		case Qt::Key_Return:
+		case Qt::Key_Enter: return QStringLiteral("Return");
+		case Qt::Key_Backspace: return QStringLiteral("Backspace");
+		case Qt::Key_Tab: return QStringLiteral("Tab");
+		case Qt::Key_Shift: return QStringLiteral("Left Shift");
+		case Qt::Key_Control: return QStringLiteral("Left Ctrl");
+		case Qt::Key_Alt: return QStringLiteral("Left Alt");
+		case Qt::Key_Meta: return QStringLiteral("Left GUI");
+		case Qt::Key_Insert: return QStringLiteral("Insert");
+		case Qt::Key_Delete: return QStringLiteral("Delete");
+		case Qt::Key_Home: return QStringLiteral("Home");
+		case Qt::Key_End: return QStringLiteral("End");
+		case Qt::Key_PageUp: return QStringLiteral("PageUp");
+		case Qt::Key_PageDown: return QStringLiteral("PageDown");
+		case Qt::Key_Left: return QStringLiteral("Left");
+		case Qt::Key_Right: return QStringLiteral("Right");
+		case Qt::Key_Up: return QStringLiteral("Up");
+		case Qt::Key_Down: return QStringLiteral("Down");
+		case Qt::Key_CapsLock: return QStringLiteral("CapsLock");
+		case Qt::Key_NumLock: return QStringLiteral("Numlock");
+		case Qt::Key_ScrollLock: return QStringLiteral("ScrollLock");
+		case Qt::Key_Pause: return QStringLiteral("Pause");
+		case Qt::Key_Print: return QStringLiteral("PrintScreen");
+		default: break;
+	}
+
+	if (event.modifiers() != Qt::NoModifier) {
+		return {};
+	}
+	const auto name = QKeySequence(key).toString(QKeySequence::PortableText);
+	return name.size() == 1 ? name : QString();
+}
+
+class InputCaptureDialog final: public QDialog {
+public:
+	explicit InputCaptureDialog(QWidget* parent): QDialog(parent) {
+		setWindowTitle(tr("Set Binding"));
+		setModal(true);
+		setMinimumWidth(360);
+
+		auto* layout = new QVBoxLayout(this);
+		m_label      = new QLabel(
+		    tr("Press a key or mouse button.\nSpace and F1 are reserved; Esc cancels."), this);
+		m_label->setAlignment(Qt::AlignCenter);
+		layout->addWidget(m_label);
+	}
+
+	[[nodiscard]] const QString& Binding() const { return m_binding; }
+
+protected:
+	void keyPressEvent(QKeyEvent* event) override {
+		if (event->isAutoRepeat()) {
+			return;
+		}
+		if (event->key() == Qt::Key_Escape) {
+			reject();
+			return;
+		}
+		if (event->key() == Qt::Key_Space || event->key() == Qt::Key_F1) {
+			m_label->setText(tr("That key is reserved by the emulator."));
+			return;
+		}
+
+		m_binding = KeyName(*event);
+		if (!m_binding.isEmpty()) {
+			accept();
+		} else {
+			m_label->setText(tr("That key is not supported."));
+		}
+	}
+
+	void mousePressEvent(QMouseEvent* event) override {
+		switch (event->button()) {
+			case Qt::LeftButton: m_binding = QStringLiteral("Mouse:Left"); break;
+			case Qt::RightButton: m_binding = QStringLiteral("Mouse:Right"); break;
+			case Qt::MiddleButton: m_binding = QStringLiteral("Mouse:Middle"); break;
+			case Qt::BackButton: m_binding = QStringLiteral("Mouse:X1"); break;
+			case Qt::ForwardButton: m_binding = QStringLiteral("Mouse:X2"); break;
+			default: return;
+		}
+		accept();
+	}
+
+private:
+	QLabel* m_label = nullptr;
+	QString m_binding;
+};
+
+QHash<QString, QString> ParseMapping(const QStringList& mapping) {
+	QHash<QString, QString> result;
+	for (const auto& entry: mapping) {
+		const auto separator = entry.indexOf(QLatin1Char('='));
+		if (separator > 0 && separator + 1 < entry.size()) {
+			const auto binding = entry.mid(separator + 1);
+			for (auto item = result.begin(); item != result.end();) {
+				if (item.value().compare(binding, Qt::CaseInsensitive) == 0) {
+					item = result.erase(item);
+				} else {
+					++item;
+				}
+			}
+			result.insert(entry.left(separator), binding);
+		}
+	}
+	return result;
+}
+
+} // namespace
+
+InputMappingDialog::InputMappingDialog(const QStringList& mapping, QWidget* parent)
+    : QDialog(parent), m_customized(!mapping.isEmpty()) {
+	setWindowTitle(tr("Input Mapping"));
+	resize(440, 520);
+
+	auto* layout = new QVBoxLayout(this);
+	layout->addWidget(new QLabel(tr("Map keyboard or mouse input to DualSense buttons.\n"
+	                                "Defaults: left stick W/A/S/D, right stick T/F/G/H."),
+	                             this));
+
+	m_bindings = new QTreeWidget(this);
+	m_bindings->setColumnCount(2);
+	m_bindings->setHeaderLabels({tr("DualSense button"), tr("Host input")});
+	m_bindings->setRootIsDecorated(false);
+	m_bindings->setSelectionMode(QAbstractItemView::SingleSelection);
+	m_bindings->header()->setSectionResizeMode(0, QHeaderView::Stretch);
+	m_bindings->header()->setSectionResizeMode(1, QHeaderView::Stretch);
+	layout->addWidget(m_bindings);
+
+	const auto parsed = ParseMapping(mapping);
+	for (const auto& button: PAD_BUTTONS) {
+		auto* item = new QTreeWidgetItem(m_bindings);
+		item->setText(0, tr(button.label));
+		item->setData(0, Qt::UserRole, QString::fromLatin1(button.id));
+		SetBinding(item, m_customized ? parsed.value(QString::fromLatin1(button.id))
+		                              : QString::fromLatin1(button.default_binding));
+	}
+	m_bindings->setCurrentItem(m_bindings->topLevelItem(0));
+
+	auto* controls  = new QHBoxLayout;
+	m_change_button = new QPushButton(tr("Change..."), this);
+	m_clear_button  = new QPushButton(tr("Clear"), this);
+	auto* defaults  = new QPushButton(tr("Defaults"), this);
+	controls->addWidget(m_change_button);
+	controls->addWidget(m_clear_button);
+	controls->addWidget(defaults);
+	controls->addStretch();
+	layout->addLayout(controls);
+
+	auto* buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, this);
+	layout->addWidget(buttons);
+
+	connect(m_bindings, &QTreeWidget::itemDoubleClicked, this,
+	        [this](QTreeWidgetItem*, int) { ChangeBinding(); });
+	connect(m_bindings, &QTreeWidget::itemSelectionChanged, this, [this]() { UpdateButtons(); });
+	connect(m_change_button, &QPushButton::clicked, this, [this]() { ChangeBinding(); });
+	connect(m_clear_button, &QPushButton::clicked, this, [this]() { ClearBinding(); });
+	connect(defaults, &QPushButton::clicked, this, [this]() { RestoreDefaults(); });
+	connect(buttons, &QDialogButtonBox::accepted, this, &QDialog::accept);
+	connect(buttons, &QDialogButtonBox::rejected, this, &QDialog::reject);
+	UpdateButtons();
+}
+
+QStringList InputMappingDialog::Mapping() const {
+	QStringList result;
+	if (!m_customized) {
+		return result;
+	}
+	for (int index = 0; index < m_bindings->topLevelItemCount(); index++) {
+		const auto* item    = m_bindings->topLevelItem(index);
+		const auto  binding = item->data(BINDING_COLUMN, Qt::UserRole).toString();
+		if (!binding.isEmpty()) {
+			result.append(item->data(0, Qt::UserRole).toString() + QLatin1Char('=') + binding);
+		}
+	}
+	return result;
+}
+
+void InputMappingDialog::ChangeBinding() {
+	auto* item = m_bindings->currentItem();
+	if (item == nullptr) {
+		return;
+	}
+
+	InputCaptureDialog dialog(this);
+	if (dialog.exec() != QDialog::Accepted) {
+		return;
+	}
+
+	for (int index = 0; index < m_bindings->topLevelItemCount(); index++) {
+		auto* other = m_bindings->topLevelItem(index);
+		if (other != item && other->data(BINDING_COLUMN, Qt::UserRole)
+		                             .toString()
+		                             .compare(dialog.Binding(), Qt::CaseInsensitive) == 0) {
+			SetBinding(other, {});
+		}
+	}
+	SetBinding(item, dialog.Binding());
+	m_customized = true;
+}
+
+void InputMappingDialog::ClearBinding() {
+	SetBinding(m_bindings->currentItem(), {});
+	m_customized = true;
+}
+
+void InputMappingDialog::RestoreDefaults() {
+	for (int index = 0; index < m_bindings->topLevelItemCount(); index++) {
+		SetBinding(m_bindings->topLevelItem(index),
+		           QString::fromLatin1(PAD_BUTTONS[index].default_binding));
+	}
+	m_customized = false;
+}
+
+void InputMappingDialog::SetBinding(QTreeWidgetItem* item, const QString& binding) {
+	if (item == nullptr) {
+		return;
+	}
+	item->setData(BINDING_COLUMN, Qt::UserRole, binding);
+	item->setText(BINDING_COLUMN, binding.isEmpty() ? tr("None") : binding);
+	UpdateButtons();
+}
+
+void InputMappingDialog::UpdateButtons() {
+	if (m_change_button == nullptr) {
+		return;
+	}
+	const auto* item = m_bindings->currentItem();
+	m_change_button->setEnabled(item != nullptr);
+	m_clear_button->setEnabled(item != nullptr &&
+	                           !item->data(BINDING_COLUMN, Qt::UserRole).toString().isEmpty());
+}

src/launcher/src/mainDialog.cpp

@@ -204,7 +204,11 @@ static QStringList CreateEmulatorArgs(const Configuration& info) {
 
 	args << "--screen-width" << r.at(0);
 	args << "--screen-height" << r.at(1);
+	if (info.fullscreen_enabled) {
+		args << "--fullscreen";
+	}
 	args << "--vblank-frequency" << QString::number(info.vblank_frequency);
+	args << "--console-language" << QString::number(info.console_language);
 	args << "--vulkan-validation" << BoolArg(info.vulkan_validation_enabled);
 	args << "--shader-validation" << BoolArg(info.shader_validation_enabled);
 	args << "--shader-optimization-type" << EnumToText(info.shader_optimization_type);
@@ -216,6 +220,9 @@ static QStringList CreateEmulatorArgs(const Configuration& info) {
 	args << "--printf-output-file" << info.printf_output_file;
 	args << "--profiler-direction" << EnumToText(info.profiler_direction);
 	args << "--spirv-debug-printf" << "false";
+	for (const auto& binding: info.host_input_mapping) {
+		args << "--keymap" << binding;
+	}
 	if (info.renderdoc_enabled) {
 		args << "--rd";
 	}
@@ -434,7 +441,10 @@ void MainDialogPrivate::Run() {
 
 	m_running_item->SetRunning(true);
 
-	m_main_dialog->RunInterpreter(&m_process, m_running_item->GetInfo());
+	Configuration info;
+	info.CopyFrom(m_running_item->GetInfo());
+	info.host_input_mapping = m_ui->widget->GetHostInputMapping();
+	m_main_dialog->RunInterpreter(&m_process, info);
 
 	Update();
 }

src/libs/agc.cpp

@@ -6,6 +6,7 @@
 #include "common/logging/log.h"
 #include "common/stringUtils.h"
 #include "common/virtualMemory.h"
+#include "graphics/guest_gpu/command_processor/commandProcessor.h"
 #include "graphics/guest_gpu/gpu_defs.h"
 #include "graphics/guest_gpu/graphicsRun.h"
 #include "graphics/guest_gpu/hardwareContext.h"
@@ -1444,29 +1445,72 @@ int KYTY_SYSV_ABI GraphicsSuspendPoint() {
 	return OK;
 }
 
-uint32_t* KYTY_SYSV_ABI GraphicsUnknownQj7QZpgr9Uw(CommandBuffer* buf, uint32_t mode,
-                                                   uint32_t value) {
-	PRINT_NAME();
-	// ResetContextState?
-	LOGF("\t mode  = 0x%08" PRIx32 "\n"
-	     "\t value = 0x%08" PRIx32 "\n",
-	     mode, value);
+[[nodiscard]] static constexpr uint32_t context_state_op_size_dw(uint32_t operation) {
+	switch (static_cast<ContextStateOperation>(operation)) {
+		case ContextStateOperation::Clear: return 5;
+		case ContextStateOperation::Push:
+		case ContextStateOperation::Pop: return 27;
+		case ContextStateOperation::PushClear: return 32;
+		default: return 0;
+	}
+}
 
-	if (buf == nullptr) {
+uint32_t* KYTY_SYSV_ABI GraphicsDcbContextStateOp(CommandBuffer* buf, uint32_t operation) {
+	PRINT_NAME();
+	LOGF("\t operation = 0x%08" PRIx32 "\n", operation);
+
+	const auto size_dw = context_state_op_size_dw(operation);
+	if (buf == nullptr || size_dw == 0) {
 		return nullptr;
 	}
 
 	buf->DbgDump();
 
-	auto* cmd = buf->AllocateDW(1);
+	uint32_t* first = nullptr;
+	const auto append = [&](uint32_t segment_size_dw) {
+		auto* segment = buf->AllocateDW(segment_size_dw);
+		if (segment == nullptr) {
+			return false;
+		}
+		std::fill_n(segment, segment_size_dw, 0u);
+		if (first == nullptr) {
+			first      = segment;
+			segment[0] = KYTY_PM4(segment_size_dw, Pm4::IT_NOP, Pm4::R_CONTEXT_STATE);
+			segment[1] = operation;
+		} else {
+			segment[0] = KYTY_PM4(segment_size_dw, Pm4::IT_NOP, Pm4::R_ZERO);
+		}
+		return true;
+	};
+	const auto append_save_restore = [&] {
+		// The native helper reserves 22 dwords, then emits 5-, 8-, and 9-dword packets.
+		return buf->ReserveDW(22) && append(5) && append(8) && append(9);
+	};
 
-	if (cmd == nullptr) {
-		return nullptr;
+	// Preserve native packet sizes, allocation boundaries, Push/Pop ordering, and
+	// returned first-packet address. The native packets reference process-private state buffers,
+	// so their net Cx operation is represented by the first HLE packet and type-3 NOPs.
+	bool complete = false;
+	switch (static_cast<ContextStateOperation>(operation)) {
+		case ContextStateOperation::Clear: complete = append(5); break;
+		case ContextStateOperation::Push:
+			complete = append_save_restore() && append(3) && append(2);
+			break;
+		case ContextStateOperation::Pop:
+			complete = append(3) && append_save_restore() && append(2);
+			break;
+		case ContextStateOperation::PushClear:
+			complete = append_save_restore() && append(3) && append(2) && append(5);
+			break;
+		default: break;
 	}
 
-	cmd[0] = 0x80000000u;
+	return complete ? first : nullptr;
+}
 
-	return cmd;
+uint64_t KYTY_SYSV_ABI GraphicsDcbContextStateOpGetSize(uint32_t operation) {
+	PRINT_NAME();
+	return static_cast<uint64_t>(context_state_op_size_dw(operation)) * sizeof(uint32_t);
 }
 
 uint64_t KYTY_SYSV_ABI GraphicsGetIsTrinityMode() {

src/libs/agc.h

@@ -67,8 +67,8 @@ int KYTY_SYSV_ABI GraphicsUnknownJumpPatchSetTarget(uint32_t* cmd, const volatil
 int KYTY_SYSV_ABI GraphicsJumpPatchSetTarget(uint32_t* cmd, const volatile uint32_t* target,
                                              uint32_t size_in_dwords);
 int KYTY_SYSV_ABI GraphicsSuspendPoint();
-uint32_t* KYTY_SYSV_ABI GraphicsUnknownQj7QZpgr9Uw(CommandBuffer* buf, uint32_t mode,
-                                                   uint32_t value);
+uint32_t* KYTY_SYSV_ABI GraphicsDcbContextStateOp(CommandBuffer* buf, uint32_t operation);
+uint64_t KYTY_SYSV_ABI  GraphicsDcbContextStateOpGetSize(uint32_t operation);
 uint64_t KYTY_SYSV_ABI  GraphicsGetIsTrinityMode();
 
 uint32_t KYTY_SYSV_ABI GraphicsDriverGetDefaultOwner();

src/libs/audio.cpp

@@ -82,6 +82,7 @@ public:
 	Id       AudioOutOpen(int type, uint32_t samples_num, uint32_t freq, Format format);
 	bool     AudioOutClose(Id handle);
 	bool     AudioOutValid(Id handle);
+	bool     AudioOutHasDevice(Id handle);
 	bool     AudioOutSetVolume(Id handle, uint32_t bitflag, const int* volume);
 	uint32_t AudioOutOutputs(OutputParam* params, uint32_t num, bool blocking = true);
 	bool     AudioOutGetStatus(Id handle, int* type, int* channels_num);
@@ -152,6 +153,10 @@ void AudioOutClose(int handle) {
 	}
 }
 
+bool AudioOutHasDevice(int handle) {
+	return g_audio != nullptr && handle > 0 && g_audio->AudioOutHasDevice(Audio::Id(handle));
+}
+
 uint32_t AudioOutOutputs(const OutputParam* params, uint32_t num, bool blocking) {
 	if (g_audio == nullptr || params == nullptr || num == 0) {
 		return 0;
@@ -451,6 +456,13 @@ bool Audio::AudioOutValid(Id handle) {
 	        m_out_ports[handle.GetId()].used);
 }
 
+bool Audio::AudioOutHasDevice(Id handle) {
+	Common::LockGuard lock(m_mutex);
+
+	return (handle.GetId() >= 0 && handle.GetId() < OUT_PORTS_MAX &&
+	        m_out_ports[handle.GetId()].used && m_out_ports[handle.GetId()].audio_device != 0);
+}
+
 bool Audio::AudioOutGetStatus(Id handle, int* type, int* channels_num) {
 	Common::LockGuard lock(m_mutex);
 
@@ -516,16 +528,18 @@ uint32_t Audio::AudioOutOutputs(OutputParam* params, uint32_t num, bool blocking
 		max_wait_time      = (wait_time > max_wait_time ? wait_time : max_wait_time);
 	}
 
-	bool all_ports_have_device = true;
+	bool any_port_has_device = false;
 	for (uint32_t i = 0; i < num; i++) {
-		if (m_out_ports[params[i].handle.GetId()].audio_device == 0) {
-			all_ports_have_device = false;
+		if (m_out_ports[params[i].handle.GetId()].audio_device != 0) {
+			any_port_has_device = true;
 			break;
 		}
 	}
 
-	// Device-backed ports are paced by the SDL queue above.
-	if (blocking && max_wait_time != 0 && !all_ports_have_device) {
+	// One real output device is enough to pace the whole synchronized batch. Applying the fallback
+	// when a vibration port is present would rate-limit the device-backed ports to exactly 1x and
+	// prevent their SDL queues from building an underrun cushion.
+	if (blocking && max_wait_time != 0 && !any_port_has_device) {
 		Common::Thread::SleepMicro(max_wait_time);
 	}
 

src/libs/audio_internal.h

@@ -26,6 +26,7 @@ static constexpr int OUT_PORTS_MAX = 32;
 
 int      AudioOutOpen(int type, uint32_t samples_num, uint32_t freq, Format format);
 void     AudioOutClose(int handle);
+bool     AudioOutHasDevice(int handle);
 uint32_t AudioOutOutputs(const OutputParam* params, uint32_t num, bool blocking = true);
 
 } // namespace Libs::Audio::AudioInternal

src/libs/controller.cpp

@@ -56,6 +56,7 @@ public:
 	void Disconnect(int id);
 	void Button(int id, uint32_t button, bool down);
 	void Axis(int id, Axis axis, int value);
+	void ResetInputState();
 	void GetConnectionInfo(bool* flag, int* count);
 	void ReadState(ControllerState* state, bool* flag, int* count);
 	int  ReadStates(ControllerState* states, int states_num, bool* flag, int* count);
@@ -85,8 +86,6 @@ private:
 
 static GameController* g_controller = nullptr;
 
-static constexpr int KEYBOARD_CONTROLLER_ID = -1000;
-
 static uint8_t pad_connected_count_to_u8(int connected_count) {
 	return static_cast<uint8_t>(connected_count > 255 ? 255 : connected_count);
 }
@@ -117,7 +116,7 @@ KYTY_SUBSYSTEM_INIT(Controller) {
 	EXIT_IF(g_controller != nullptr);
 
 	g_controller = new GameController;
-	g_controller->Connect(KEYBOARD_CONTROLLER_ID);
+	g_controller->Connect(HOST_INPUT_CONTROLLER_ID);
 }
 
 KYTY_SUBSYSTEM_UNEXPECTED_SHUTDOWN(Controller) {}
@@ -155,7 +154,7 @@ void GameController::CheckActive() {
 	if (!m_connected_ids.empty()) {
 		new_active_id = m_connected_ids[0];
 		for (const auto id: m_connected_ids) {
-			if (id != KEYBOARD_CONTROLLER_ID) {
+			if (id != HOST_INPUT_CONTROLLER_ID) {
 				new_active_id = id;
 				break;
 			}
@@ -258,6 +257,15 @@ void GameController::Axis(int id, Controller::Axis axis, int value) {
 	}
 }
 
+void GameController::ResetInputState() {
+	Common::LockGuard lock(m_mutex);
+	ControllerState   state {};
+	state.time    = LibKernel::KernelGetProcessTime();
+	m_states_num  = 0;
+	m_first_state = 0;
+	AddState(state);
+}
+
 void GameController::GetConnectionInfo(bool* flag, int* count) {
 	EXIT_IF(flag == nullptr);
 	EXIT_IF(count == nullptr);
@@ -336,6 +344,11 @@ void ControllerAxis(int id, Axis axis, int value) {
 	g_controller->Axis(id, axis, value);
 }
 
+void ControllerResetInputState() {
+	EXIT_IF(g_controller == nullptr);
+	g_controller->ResetInputState();
+}
+
 int KYTY_SYSV_ABI PadInit() {
 	PRINT_NAME();
 

src/libs/controller.h

@@ -9,6 +9,8 @@ namespace Libs::Controller {
 
 KYTY_SUBSYSTEM_DEFINE(Controller);
 
+constexpr int HOST_INPUT_CONTROLLER_ID = -1000;
+
 constexpr uint32_t PAD_BUTTON_L3        = 0x00000002;
 constexpr uint32_t PAD_BUTTON_R3        = 0x00000004;
 constexpr uint32_t PAD_BUTTON_OPTIONS   = 0x00000008;
@@ -51,6 +53,7 @@ void ControllerConnect(int id);
 void ControllerDisconnect(int id);
 void ControllerButton(int id, uint32_t button, bool down);
 void ControllerAxis(int id, Axis axis, int value);
+void ControllerResetInputState();
 
 int KYTY_SYSV_ABI PadInit();
 int KYTY_SYSV_ABI PadOpen(int user_id, int type, int index, const void* param);

src/libs/dialog.cpp

@@ -23,20 +23,6 @@ int KYTY_SYSV_ABI CommonDialogInitialize() {
 
 } // namespace CommonDialog
 
-namespace ImeDialog {
-
-LIB_NAME("ImeDialog", "ImeDialog");
-
-constexpr int IME_STATUS_NONE = 0;
-
-int KYTY_SYSV_ABI ImeDialogGetStatus() {
-	PRINT_NAME();
-
-	return IME_STATUS_NONE;
-}
-
-} // namespace ImeDialog
-
 namespace LoginDialog {
 
 LIB_NAME("LoginDialog", "LoginDialog");

src/libs/dialog.h

@@ -12,12 +12,6 @@ int KYTY_SYSV_ABI CommonDialogInitialize();
 
 } // namespace CommonDialog
 
-namespace ImeDialog {
-
-int KYTY_SYSV_ABI ImeDialogGetStatus();
-
-} // namespace ImeDialog
-
 namespace LoginDialog {
 
 int KYTY_SYSV_ABI  LoginDialogInitialize();

src/libs/imeDialog.cpp

@@ -0,0 +1,781 @@
+#include "libs/imeDialog.h"
+
+#include "libs/errno.h"
+
+#include <algorithm>
+#include <atomic>
+#include <cmath>
+#include <cstring>
+#include <mutex>
+#include <vector>
+
+namespace Libs::Dialog::ImeDialog {
+
+namespace {
+
+constexpr int Error(uint32_t value) {
+	return static_cast<int32_t>(value);
+}
+
+constexpr int ERROR_BUSY                    = Error(0x80bc0001);
+constexpr int ERROR_INVALID_USER_ID         = Error(0x80bc0010);
+constexpr int ERROR_INVALID_TYPE            = Error(0x80bc0011);
+constexpr int ERROR_INVALID_LANGUAGES       = Error(0x80bc0012);
+constexpr int ERROR_INVALID_ENTER_LABEL     = Error(0x80bc0013);
+constexpr int ERROR_INVALID_INPUT_METHOD    = Error(0x80bc0014);
+constexpr int ERROR_INVALID_OPTION          = Error(0x80bc0015);
+constexpr int ERROR_INVALID_MAX_TEXT_LENGTH = Error(0x80bc0016);
+constexpr int ERROR_INVALID_TEXT_BUFFER     = Error(0x80bc0017);
+constexpr int ERROR_INVALID_POSX            = Error(0x80bc0018);
+constexpr int ERROR_INVALID_POSY            = Error(0x80bc0019);
+constexpr int ERROR_INVALID_HALIGN          = Error(0x80bc001a);
+constexpr int ERROR_INVALID_VALIGN          = Error(0x80bc001b);
+constexpr int ERROR_INVALID_EXTENDED        = Error(0x80bc001c);
+constexpr int ERROR_INVALID_PARAM           = Error(0x80bc0030);
+constexpr int ERROR_INVALID_ADDRESS         = Error(0x80bc0031);
+constexpr int ERROR_INVALID_RESERVED        = Error(0x80bc0032);
+constexpr int ERROR_INVALID_TITLE           = Error(0x80bc0101);
+constexpr int ERROR_NOT_RUNNING             = Error(0x80bc0105);
+constexpr int ERROR_NOT_FINISHED            = Error(0x80bc0106);
+constexpr int ERROR_NOT_IN_USE              = Error(0x80bc0107);
+
+constexpr uint32_t VALID_OPTIONS           = 0x00007bff;
+constexpr uint32_t VALID_EXTENDED_OPTIONS  = 0x00005fde;
+constexpr uint32_t VALID_EXT_KEYBOARD_MODE = 0x1c000003;
+constexpr uint64_t VALID_LANGUAGES         = 0x00000001ff1fffffULL;
+
+struct State {
+	Status                     status     = Status::None;
+	EndStatus                  end_status = EndStatus::Ok;
+	uint64_t                   generation = 0;
+	uint64_t                   revision   = 0;
+	Param                      param {};
+	ExtendedParam              extended {};
+	bool                       input_changed  = false;
+	bool                       commit_pending = false;
+	uint32_t                   cursor         = 0;
+	std::u16string             original_text;
+	std::u16string             current_text;
+	std::u16string             title;
+	std::u16string             placeholder;
+	std::vector<ExternalInput> external_inputs;
+};
+
+std::mutex                      g_mutex;
+State                           g_state;
+std::atomic<Status>             g_status {Status::None};
+std::atomic<uint64_t>           g_revision {0};
+std::atomic<VisibilityCallback> g_visibility_callback {nullptr};
+
+bool AllZero(const int8_t* data, size_t size) {
+	return std::all_of(data, data + size, [](int8_t value) { return value == 0; });
+}
+
+bool IsValidUtf16(std::u16string_view text);
+
+bool ReadBounded(const char16_t* text, uint32_t limit, std::u16string* out) {
+	out->clear();
+	if (text == nullptr) {
+		return true;
+	}
+	out->reserve(limit);
+	for (uint32_t i = 0; i <= limit; ++i) {
+		const char16_t value = text[i];
+		if (value == u'\0') {
+			return IsValidUtf16(*out);
+		}
+		if (i == limit) {
+			return false;
+		}
+		out->push_back(value);
+	}
+	return false;
+}
+
+bool IsValidUtf16(std::u16string_view text) {
+	for (size_t i = 0; i < text.size(); i++) {
+		const char16_t current = text[i];
+		if (current >= 0xd800 && current <= 0xdbff) {
+			if (++i >= text.size() || text[i] < 0xdc00 || text[i] > 0xdfff) {
+				return false;
+			}
+		} else if (current >= 0xdc00 && current <= 0xdfff) {
+			return false;
+		}
+	}
+	return true;
+}
+
+bool IsAllowedInput(char16_t value, Type type, uint32_t option) {
+	if (value == u'\r') {
+		return false;
+	}
+	if (value == u'\n') {
+		return (option & OPTION_MULTILINE) != 0;
+	}
+	if (value == u'\0') {
+		return false;
+	}
+	if (type == Type::Number) {
+		return (value >= u'0' && value <= u'9') || value == u',' || value == u'-' || value == u'.';
+	}
+	if (type == Type::BasicLatin) {
+		return value >= u' ' && value <= u'~';
+	}
+	return true;
+}
+
+char16_t HidCharacter(uint16_t keycode, uint32_t status) {
+	const bool shift = (status & 0x00002200) != 0;
+	const bool caps  = (status & 0x00020000) != 0;
+	if (keycode >= 4 && keycode <= 29) {
+		const bool upper = shift != caps;
+		return static_cast<char16_t>((upper ? u'A' : u'a') + keycode - 4);
+	}
+	if (keycode >= 30 && keycode <= 39) {
+		static constexpr char16_t plain[]   = u"1234567890";
+		static constexpr char16_t shifted[] = u"!@#$%^&*()";
+		return (shift ? shifted : plain)[keycode - 30];
+	}
+	if (keycode == 44) {
+		return u' ';
+	}
+	if (keycode >= 45 && keycode <= 56) {
+		static constexpr char16_t plain[]   = u"-=[]\\#;'`,./";
+		static constexpr char16_t shifted[] = u"_+{}|~:\"~<>?";
+		return (shift ? shifted : plain)[keycode - 45];
+	}
+	if (keycode >= 89 && keycode <= 98) {
+		static constexpr char16_t keypad[] = u"1234567890";
+		return keypad[keycode - 89];
+	}
+	if (keycode == 99) {
+		return u'.';
+	}
+	return u'\0';
+}
+
+bool ApplyKeyboardFilterOutput(ExternalInput* input, uint16_t keycode, uint32_t status,
+                               bool multiline) {
+	constexpr uint32_t KEYCODE_VALID   = 0x00000001;
+	constexpr uint32_t CHARACTER_VALID = 0x00000002;
+	if (keycode == input->key.keycode && status == input->key.status) {
+		return true;
+	}
+	if ((status & KEYCODE_VALID) == 0 || keycode == 0) {
+		return input->action == ExternalAction::Text && (status & CHARACTER_VALID) != 0;
+	}
+	input->key.keycode = keycode;
+	input->key.status  = status;
+	input->text.clear();
+	switch (keycode) {
+		case 40:
+		case 88:
+		case 158:
+			input->action = multiline ? ExternalAction::Newline : ExternalAction::Accept;
+			break;
+		case 41: input->action = ExternalAction::Cancel; break;
+		case 42:
+		case 187: input->action = ExternalAction::Backspace; break;
+		case 43:
+		case 186: input->action = ExternalAction::None; break;
+		case 79: input->action = ExternalAction::MoveRight; break;
+		case 80: input->action = ExternalAction::MoveLeft; break;
+		default: {
+			const char16_t character = HidCharacter(keycode, status);
+			if (character == u'\0') {
+				return false;
+			}
+			input->action        = ExternalAction::Text;
+			input->key.character = character;
+			input->text.push_back(character);
+			break;
+		}
+	}
+	return true;
+}
+
+void ClampText(std::u16string* text, uint32_t limit) {
+	if (text->size() <= limit) {
+		return;
+	}
+	text->resize(limit);
+	if (!text->empty() && text->back() >= 0xd800 && text->back() <= 0xdbff) {
+		text->pop_back();
+	}
+}
+
+uint32_t NormalizeCursor(std::u16string_view text, uint32_t cursor) {
+	cursor = std::min<uint32_t>(cursor, static_cast<uint32_t>(text.size()));
+	if (cursor > 0 && cursor < text.size() && text[cursor - 1] >= 0xd800 &&
+	    text[cursor - 1] <= 0xdbff && text[cursor] >= 0xdc00 && text[cursor] <= 0xdfff) {
+		cursor++;
+	}
+	return cursor;
+}
+
+void WriteGuestText(const State& state, const std::u16string& text) {
+	if (state.param.input_text_buffer == nullptr) {
+		return;
+	}
+	const size_t size = std::min<size_t>(text.size(), state.param.max_text_length);
+	std::memcpy(state.param.input_text_buffer, text.data(), size * sizeof(char16_t));
+	state.param.input_text_buffer[size] = u'\0';
+}
+
+void NotifyVisibility(bool visible, uint64_t generation) {
+	if (const auto callback = g_visibility_callback.load(std::memory_order_acquire);
+	    callback != nullptr) {
+		callback(visible, generation);
+	}
+}
+
+int ValidateExtended(const ExtendedParam* extended) {
+	if (extended == nullptr) {
+		return OK;
+	}
+	if ((extended->option & ~VALID_EXTENDED_OPTIONS) != 0 ||
+	    ((extended->option & 0x00004000) != 0 && (extended->option & 0x00000080) == 0) ||
+	    extended->priority > 3 || extended->disable_device > 7 ||
+	    (extended->ext_keyboard_mode & ~VALID_EXT_KEYBOARD_MODE) != 0 ||
+	    !AllZero(extended->reserved, sizeof(extended->reserved))) {
+		return ERROR_INVALID_EXTENDED;
+	}
+	return OK;
+}
+
+int ValidateParam(const Param* param, const ExtendedParam* extended, std::u16string* initial,
+                  std::u16string* title, std::u16string* placeholder) {
+	if (param == nullptr) {
+		return ERROR_INVALID_ADDRESS;
+	}
+	if (static_cast<uint32_t>(param->type) > static_cast<uint32_t>(Type::Number)) {
+		return ERROR_INVALID_TYPE;
+	}
+	if ((param->option & ~VALID_OPTIONS) != 0) {
+		return ERROR_INVALID_OPTION;
+	}
+	if ((param->supported_languages & ~VALID_LANGUAGES) != 0) {
+		return ERROR_INVALID_LANGUAGES;
+	}
+	const bool  over_2k = (param->option & OPTION_USE_OVER_2K) != 0;
+	const float max_x   = over_2k ? 3840.0f : 1920.0f;
+	const float max_y   = over_2k ? 2160.0f : 1080.0f;
+	if (!std::isfinite(param->posx) || param->posx < 0.0f || param->posx >= max_x) {
+		return ERROR_INVALID_POSX;
+	}
+	if (!std::isfinite(param->posy) || param->posy < 0.0f || param->posy >= max_y) {
+		return ERROR_INVALID_POSY;
+	}
+	if (static_cast<uint32_t>(param->horizontal_alignment) > 2) {
+		return ERROR_INVALID_HALIGN;
+	}
+	if (static_cast<uint32_t>(param->vertical_alignment) > 2) {
+		return ERROR_INVALID_VALIGN;
+	}
+	const bool multiline = (param->option & OPTION_MULTILINE) != 0;
+	const bool password  = (param->option & OPTION_PASSWORD) != 0;
+	if ((multiline && password) ||
+	    (multiline && param->type != Type::Default && param->type != Type::BasicLatin) ||
+	    (password && param->type != Type::BasicLatin && param->type != Type::Number)) {
+		return ERROR_INVALID_PARAM;
+	}
+	if (param->user_id < 0 || param->user_id == 0xff) {
+		return ERROR_INVALID_USER_ID;
+	}
+	if (!AllZero(param->reserved, sizeof(param->reserved))) {
+		return ERROR_INVALID_RESERVED;
+	}
+	if (param->input_text_buffer == nullptr) {
+		return ERROR_INVALID_TEXT_BUFFER;
+	}
+	const int extended_result = ValidateExtended(extended);
+	if (extended_result != OK) {
+		return extended_result;
+	}
+	if (static_cast<uint32_t>(param->enter_label) > static_cast<uint32_t>(EnterLabel::Go)) {
+		return ERROR_INVALID_ENTER_LABEL;
+	}
+	if (param->input_method != 0) {
+		return ERROR_INVALID_INPUT_METHOD;
+	}
+	if (param->max_text_length == 0 || param->max_text_length > IME_DIALOG_MAX_TEXT_LENGTH) {
+		return ERROR_INVALID_MAX_TEXT_LENGTH;
+	}
+	if (!ReadBounded(param->input_text_buffer, param->max_text_length, initial)) {
+		return ERROR_INVALID_TEXT_BUFFER;
+	}
+	if (!ReadBounded(param->title, IME_DIALOG_MAX_TITLE_LENGTH, title)) {
+		return ERROR_INVALID_TITLE;
+	}
+	if (!ReadBounded(param->placeholder, IME_DIALOG_MAX_PLACEHOLDER_LENGTH, placeholder)) {
+		return ERROR_INVALID_PARAM;
+	}
+	return OK;
+}
+
+void ComputePanelSize(const Param& param, const ExtendedParam* extended, uint32_t* width,
+                      uint32_t* height) {
+	const bool multiline     = (param.option & OPTION_MULTILINE) != 0;
+	const bool hide_keyboard = extended != nullptr && (param.option & OPTION_EXT_KEYBOARD) != 0 &&
+	                           (extended->option & 0x00000400) != 0;
+	if (param.type == Type::Number) {
+		*width  = 370;
+		*height = hide_keyboard ? 102 : 522;
+	} else if (param.type == Type::BasicLatin) {
+		*width = 793;
+		if (hide_keyboard) {
+			*height = multiline ? 203 : 103;
+		} else {
+			*height = multiline ? 628 : 528;
+		}
+	} else {
+		*width = 793;
+		if (hide_keyboard) {
+			*height = multiline ? 268 : 168;
+		} else {
+			*height = multiline ? 628 : 528;
+		}
+	}
+	if ((param.option & OPTION_USE_OVER_2K) != 0) {
+		*width *= 2;
+		*height *= 2;
+	}
+}
+
+void ApplyFilterAndCommit() {
+	TextFilter     filter = nullptr;
+	std::u16string source;
+	uint32_t       max_length = 0;
+	uint64_t       generation = 0;
+	uint64_t       revision   = 0;
+	{
+		std::scoped_lock lock(g_mutex);
+		if (g_state.status == Status::None || (!g_state.input_changed && !g_state.commit_pending)) {
+			return;
+		}
+		filter                = g_state.input_changed ? g_state.param.filter : nullptr;
+		source                = g_state.current_text;
+		max_length            = g_state.param.max_text_length;
+		generation            = g_state.generation;
+		revision              = g_state.revision;
+		g_state.input_changed = false;
+	}
+
+	if (filter != nullptr) {
+		std::vector<char16_t> output(IME_DIALOG_MAX_TEXT_LENGTH + 1, u'\0');
+		uint32_t              output_length = IME_DIALOG_MAX_TEXT_LENGTH;
+		if (filter(output.data(), &output_length, source.c_str(),
+		           static_cast<uint32_t>(source.size())) == 0 &&
+		    output_length <= IME_DIALOG_MAX_TEXT_LENGTH &&
+		    IsValidUtf16(std::u16string_view(output.data(), output_length))) {
+			source.assign(output.data(), output.data() + output_length);
+			ClampText(&source, max_length);
+		}
+	}
+
+	std::scoped_lock lock(g_mutex);
+	if (g_state.generation != generation || g_state.revision != revision ||
+	    g_state.status == Status::None) {
+		if (g_state.generation == generation &&
+		    (g_state.status == Status::Running ||
+		     (g_state.status == Status::Finished && g_state.end_status == EndStatus::Ok))) {
+			g_state.input_changed  = true;
+			g_state.commit_pending = true;
+		}
+		return;
+	}
+	if (!g_state.input_changed) {
+		g_state.current_text = std::move(source);
+		g_state.cursor       = NormalizeCursor(g_state.current_text, g_state.cursor);
+	}
+	const auto& committed =
+	    g_state.status == Status::Finished && g_state.end_status != EndStatus::Ok
+	        ? g_state.original_text
+	        : g_state.current_text;
+	WriteGuestText(g_state, committed);
+	g_state.commit_pending = false;
+}
+
+bool MatchRunningGeneration(uint64_t generation) {
+	return g_state.status == Status::Running && g_state.generation == generation;
+}
+
+bool FinishFromHost(uint64_t generation, EndStatus end_status) {
+	uint64_t notify_generation = 0;
+	{
+		std::scoped_lock lock(g_mutex);
+		if (!MatchRunningGeneration(generation)) {
+			return false;
+		}
+		g_state.status         = Status::Finished;
+		g_state.end_status     = end_status;
+		g_state.commit_pending = true;
+		g_state.revision++;
+		notify_generation = g_state.generation;
+		g_status.store(Status::Finished, std::memory_order_release);
+		g_revision.store(g_state.revision, std::memory_order_release);
+	}
+	NotifyVisibility(false, notify_generation);
+	return true;
+}
+
+void ApplyExternalInputs() {
+	std::vector<ExternalInput> inputs;
+	ExtKeyboardFilter          filter     = nullptr;
+	uint64_t                   generation = 0;
+	int32_t                    user_id    = 0;
+	bool                       multiline  = false;
+	{
+		std::scoped_lock lock(g_mutex);
+		if (g_state.status != Status::Running || g_state.external_inputs.empty()) {
+			return;
+		}
+		inputs.swap(g_state.external_inputs);
+		filter     = g_state.extended.ext_keyboard_filter;
+		generation = g_state.generation;
+		user_id    = g_state.param.user_id;
+		multiline  = (g_state.param.option & OPTION_MULTILINE) != 0;
+	}
+
+	for (auto& input: inputs) {
+		{
+			std::scoped_lock lock(g_mutex);
+			if (!MatchRunningGeneration(generation)) {
+				break;
+			}
+		}
+		input.key.user_id = user_id;
+		bool accepted     = true;
+		if (filter != nullptr) {
+			uint16_t output_keycode = input.key.keycode;
+			uint32_t output_status  = input.key.status;
+			if (filter(&input.key, &output_keycode, &output_status, nullptr) == 0) {
+				accepted =
+				    ApplyKeyboardFilterOutput(&input, output_keycode, output_status, multiline);
+			}
+		}
+		if (!accepted) {
+			continue;
+		}
+		switch (input.action) {
+			case ExternalAction::None: break;
+			case ExternalAction::Text: HostInsertText(generation, input.text); break;
+			case ExternalAction::Backspace: HostBackspace(generation); break;
+			case ExternalAction::MoveLeft: HostMoveCursor(generation, -1); break;
+			case ExternalAction::MoveRight: HostMoveCursor(generation, 1); break;
+			case ExternalAction::Cancel: HostCancel(generation); break;
+			case ExternalAction::Accept: HostAccept(generation); break;
+			case ExternalAction::Newline: HostInsertText(generation, u"\n"); break;
+		}
+	}
+}
+
+} // namespace
+
+int KYTY_SYSV_ABI ImeDialogGetPanelSize(const Param* param, uint32_t* width, uint32_t* height) {
+	return ImeDialogGetPanelSizeExtended(param, nullptr, width, height);
+}
+
+int KYTY_SYSV_ABI ImeDialogGetPanelSizeExtended(const Param* param, const ExtendedParam* extended,
+                                                uint32_t* width, uint32_t* height) {
+	if (param == nullptr || width == nullptr || height == nullptr) {
+		return ERROR_INVALID_ADDRESS;
+	}
+	if (static_cast<uint32_t>(param->type) > static_cast<uint32_t>(Type::Number)) {
+		return ERROR_INVALID_TYPE;
+	}
+	if ((param->option & ~VALID_OPTIONS) != 0) {
+		return ERROR_INVALID_OPTION;
+	}
+	if ((param->supported_languages & ~VALID_LANGUAGES) != 0) {
+		return ERROR_INVALID_LANGUAGES;
+	}
+	const int extended_result = ValidateExtended(extended);
+	if (extended_result != OK) {
+		return extended_result;
+	}
+	ComputePanelSize(*param, extended, width, height);
+	return OK;
+}
+
+int KYTY_SYSV_ABI ImeDialogInit(const Param* param, const ExtendedParam* extended) {
+	if (g_status.load(std::memory_order_acquire) != Status::None) {
+		return ERROR_BUSY;
+	}
+
+	std::u16string initial;
+	std::u16string title;
+	std::u16string placeholder;
+	const int      validation = ValidateParam(param, extended, &initial, &title, &placeholder);
+	if (validation != OK) {
+		return validation;
+	}
+
+	uint64_t generation = 0;
+	{
+		std::scoped_lock lock(g_mutex);
+		if (g_state.status != Status::None) {
+			return ERROR_BUSY;
+		}
+		const uint64_t next_generation = g_state.generation + 1;
+		const uint64_t next_revision   = g_state.revision + 1;
+		g_state                        = {};
+		g_state.status                 = Status::Running;
+		g_state.generation             = next_generation;
+		g_state.revision               = next_revision;
+		g_state.param                  = *param;
+		if (extended != nullptr) {
+			g_state.extended = *extended;
+		}
+		g_state.original_text  = initial;
+		g_state.current_text   = std::move(initial);
+		g_state.cursor         = static_cast<uint32_t>(g_state.current_text.size());
+		g_state.title          = std::move(title);
+		g_state.placeholder    = std::move(placeholder);
+		g_state.commit_pending = true;
+		generation             = g_state.generation;
+		g_status.store(Status::Running, std::memory_order_release);
+		g_revision.store(g_state.revision, std::memory_order_release);
+	}
+	NotifyVisibility(true, generation);
+	return OK;
+}
+
+int KYTY_SYSV_ABI ImeDialogGetStatus() {
+	ApplyExternalInputs();
+	ApplyFilterAndCommit();
+	return static_cast<int>(g_status.load(std::memory_order_acquire));
+}
+
+int KYTY_SYSV_ABI ImeDialogAbort() {
+	uint64_t generation = 0;
+	{
+		std::scoped_lock lock(g_mutex);
+		if (g_state.status == Status::None) {
+			return ERROR_NOT_IN_USE;
+		}
+		if (g_state.status != Status::Running) {
+			return ERROR_NOT_RUNNING;
+		}
+		generation = g_state.generation;
+	}
+	if (!FinishFromHost(generation, EndStatus::Aborted)) {
+		return ERROR_NOT_RUNNING;
+	}
+	ApplyFilterAndCommit();
+	return OK;
+}
+
+int KYTY_SYSV_ABI ImeDialogGetResult(Result* result) {
+	{
+		std::scoped_lock lock(g_mutex);
+		if (g_state.status == Status::None) {
+			return ERROR_NOT_IN_USE;
+		}
+	}
+	if (result == nullptr) {
+		return ERROR_INVALID_ADDRESS;
+	}
+	if (!AllZero(result->reserved, sizeof(result->reserved))) {
+		return ERROR_INVALID_RESERVED;
+	}
+	{
+		std::scoped_lock lock(g_mutex);
+		if (g_state.status != Status::Finished) {
+			return ERROR_NOT_FINISHED;
+		}
+	}
+	ApplyFilterAndCommit();
+	std::scoped_lock lock(g_mutex);
+	if (g_state.status == Status::None) {
+		return ERROR_NOT_IN_USE;
+	}
+	if (g_state.status != Status::Finished) {
+		return ERROR_NOT_FINISHED;
+	}
+	result->endstatus = g_state.end_status;
+	return OK;
+}
+
+int KYTY_SYSV_ABI ImeDialogTerm() {
+	{
+		std::scoped_lock lock(g_mutex);
+		if (g_state.status == Status::None) {
+			return ERROR_NOT_IN_USE;
+		}
+		if (g_state.status != Status::Finished) {
+			return ERROR_NOT_FINISHED;
+		}
+	}
+	ApplyFilterAndCommit();
+	std::scoped_lock lock(g_mutex);
+	if (g_state.status == Status::None) {
+		return ERROR_NOT_IN_USE;
+	}
+	if (g_state.status != Status::Finished) {
+		return ERROR_NOT_FINISHED;
+	}
+	const uint64_t generation = g_state.generation;
+	const uint64_t revision   = g_state.revision;
+	g_state                   = {};
+	g_state.generation        = generation;
+	g_state.revision          = revision;
+	g_status.store(Status::None, std::memory_order_release);
+	return OK;
+}
+
+int KYTY_SYSV_ABI ImeDialogGetPanelPositionAndForm(PositionAndForm* form) {
+	std::scoped_lock lock(g_mutex);
+	if (g_state.status == Status::None) {
+		return ERROR_NOT_IN_USE;
+	}
+	if (form == nullptr) {
+		return ERROR_INVALID_ADDRESS;
+	}
+	form->type                 = 2;
+	form->posx                 = g_state.param.posx;
+	form->posy                 = g_state.param.posy;
+	form->horizontal_alignment = g_state.param.horizontal_alignment;
+	form->vertical_alignment   = g_state.param.vertical_alignment;
+	ComputePanelSize(g_state.param, &g_state.extended, &form->width, &form->height);
+	return OK;
+}
+
+VisualState GetVisualState() noexcept {
+	return {g_status.load(std::memory_order_acquire) == Status::Running,
+	        g_revision.load(std::memory_order_acquire)};
+}
+
+void SetVisibilityCallback(VisibilityCallback callback) noexcept {
+	g_visibility_callback.store(callback, std::memory_order_release);
+}
+
+bool GetHostSnapshot(HostSnapshot* snapshot) {
+	if (snapshot == nullptr) {
+		return false;
+	}
+	std::scoped_lock lock(g_mutex);
+	if (g_state.status != Status::Running) {
+		return false;
+	}
+	snapshot->generation           = g_state.generation;
+	snapshot->type                 = g_state.param.type;
+	snapshot->enter_label          = g_state.param.enter_label;
+	snapshot->option               = g_state.param.option;
+	snapshot->max_text_length      = g_state.param.max_text_length;
+	snapshot->cursor               = g_state.cursor;
+	snapshot->disable_device       = g_state.extended.disable_device;
+	snapshot->key_panel_visible    = (g_state.param.option & OPTION_EXT_KEYBOARD) == 0 ||
+	                                 (g_state.extended.option & 0x00000400) == 0;
+	snapshot->posx                 = g_state.param.posx;
+	snapshot->posy                 = g_state.param.posy;
+	snapshot->horizontal_alignment = g_state.param.horizontal_alignment;
+	snapshot->vertical_alignment   = g_state.param.vertical_alignment;
+	ComputePanelSize(g_state.param, &g_state.extended, &snapshot->panel_width,
+	                 &snapshot->panel_height);
+	snapshot->text        = g_state.current_text;
+	snapshot->title       = g_state.title;
+	snapshot->placeholder = g_state.placeholder;
+	return true;
+}
+
+bool HostInsertText(uint64_t generation, std::u16string_view text) {
+	std::scoped_lock lock(g_mutex);
+	if (!MatchRunningGeneration(generation) || text.empty()) {
+		return false;
+	}
+	if (!IsValidUtf16(text)) {
+		return false;
+	}
+	std::u16string allowed;
+	allowed.reserve(text.size());
+	for (const char16_t value: text) {
+		if (IsAllowedInput(value, g_state.param.type, g_state.param.option)) {
+			allowed.push_back(value);
+		}
+	}
+	if (allowed.empty()) {
+		return false;
+	}
+	const size_t available = g_state.param.max_text_length - g_state.current_text.size();
+	if (available == 0) {
+		return false;
+	}
+	std::u16string insertion(std::u16string_view(allowed).substr(0, available));
+	if (insertion.size() < allowed.size() && !insertion.empty() && insertion.back() >= 0xd800 &&
+	    insertion.back() <= 0xdbff) {
+		insertion.pop_back();
+	}
+	if (insertion.empty()) {
+		return false;
+	}
+	std::u16string candidate = g_state.current_text;
+	candidate.insert(g_state.cursor, insertion);
+	g_state.current_text = std::move(candidate);
+	g_state.cursor += static_cast<uint32_t>(insertion.size());
+	g_state.input_changed  = true;
+	g_state.commit_pending = true;
+	return true;
+}
+
+bool HostBackspace(uint64_t generation) {
+	std::scoped_lock lock(g_mutex);
+	if (!MatchRunningGeneration(generation) || g_state.cursor == 0) {
+		return false;
+	}
+	uint32_t first = g_state.cursor - 1;
+	if (first > 0 && g_state.current_text[first] >= 0xdc00 &&
+	    g_state.current_text[first] <= 0xdfff && g_state.current_text[first - 1] >= 0xd800 &&
+	    g_state.current_text[first - 1] <= 0xdbff) {
+		first--;
+	}
+	g_state.current_text.erase(first, g_state.cursor - first);
+	g_state.cursor         = first;
+	g_state.input_changed  = true;
+	g_state.commit_pending = true;
+	return true;
+}
+
+bool HostMoveCursor(uint64_t generation, int delta) {
+	std::scoped_lock lock(g_mutex);
+	if (!MatchRunningGeneration(generation) || delta == 0) {
+		return false;
+	}
+	int next = std::clamp(static_cast<int>(g_state.cursor) + delta, 0,
+	                      static_cast<int>(g_state.current_text.size()));
+	if (delta < 0 && next > 0 && next < static_cast<int>(g_state.current_text.size()) &&
+	    g_state.current_text[next] >= 0xdc00 && g_state.current_text[next] <= 0xdfff &&
+	    g_state.current_text[next - 1] >= 0xd800 && g_state.current_text[next - 1] <= 0xdbff) {
+		next--;
+	} else if (delta > 0 && next > 0 && next < static_cast<int>(g_state.current_text.size()) &&
+	           g_state.current_text[next - 1] >= 0xd800 &&
+	           g_state.current_text[next - 1] <= 0xdbff && g_state.current_text[next] >= 0xdc00 &&
+	           g_state.current_text[next] <= 0xdfff) {
+		next++;
+	}
+	if (next == static_cast<int>(g_state.cursor)) {
+		return false;
+	}
+	g_state.cursor = static_cast<uint32_t>(next);
+	return true;
+}
+
+bool HostAccept(uint64_t generation) {
+	return FinishFromHost(generation, EndStatus::Ok);
+}
+
+bool HostCancel(uint64_t generation) {
+	return FinishFromHost(generation, EndStatus::UserCanceled);
+}
+
+bool HostQueueExternalInput(uint64_t generation, ExternalInput input) {
+	std::scoped_lock lock(g_mutex);
+	if (!MatchRunningGeneration(generation) || g_state.external_inputs.size() >= 128) {
+		return false;
+	}
+	g_state.external_inputs.push_back(std::move(input));
+	return true;
+}
+
+} // namespace Libs::Dialog::ImeDialog

src/libs/imeDialog.h

@@ -0,0 +1,199 @@
+#ifndef EMULATOR_INCLUDE_EMULATOR_LIBS_IMEDIALOG_H_
+#define EMULATOR_INCLUDE_EMULATOR_LIBS_IMEDIALOG_H_
+
+#include "common/abi.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <string_view>
+
+namespace Libs::Dialog::ImeDialog {
+
+constexpr uint32_t IME_DIALOG_MAX_TEXT_LENGTH        = 2048;
+constexpr uint32_t IME_DIALOG_MAX_TITLE_LENGTH       = 128;
+constexpr uint32_t IME_DIALOG_MAX_PLACEHOLDER_LENGTH = 64;
+
+enum class Status : uint32_t { None = 0, Running = 1, Finished = 2 };
+enum class EndStatus : uint32_t { Ok = 0, UserCanceled = 1, Aborted = 2 };
+enum class Type : uint32_t { Default = 0, BasicLatin = 1, Url = 2, Mail = 3, Number = 4 };
+enum class EnterLabel : uint32_t { Default = 0, Send = 1, Search = 2, Go = 3 };
+enum class Alignment : uint32_t { Start = 0, Center = 1, End = 2 };
+
+enum Option : uint32_t {
+	OPTION_MULTILINE            = 0x00000001,
+	OPTION_NO_AUTO_CAPITALIZE   = 0x00000002,
+	OPTION_PASSWORD             = 0x00000004,
+	OPTION_LANGUAGES_FORCED     = 0x00000008,
+	OPTION_EXT_KEYBOARD         = 0x00000010,
+	OPTION_NO_LEARNING          = 0x00000020,
+	OPTION_FIXED_POSITION       = 0x00000040,
+	OPTION_DISABLE_COPY_PASTE   = 0x00000080,
+	OPTION_DISABLE_RESUME       = 0x00000100,
+	OPTION_DISABLE_AUTO_SPACE   = 0x00000200,
+	OPTION_DISABLE_POSITION_ADJ = 0x00000800,
+	OPTION_EXPANDED_PREEDIT     = 0x00001000,
+	OPTION_JAPANESE_CAPS_LOCK   = 0x00002000,
+	OPTION_USE_OVER_2K          = 0x00004000,
+};
+
+enum DisableDevice : uint32_t {
+	DISABLE_DEVICE_CONTROLLER   = 0x00000001,
+	DISABLE_DEVICE_EXT_KEYBOARD = 0x00000002,
+	DISABLE_DEVICE_REMOTE_OSK   = 0x00000004,
+};
+
+struct Color {
+	uint8_t r;
+	uint8_t g;
+	uint8_t b;
+	uint8_t a;
+};
+
+struct Keycode;
+
+using TextFilter        = int32_t(KYTY_SYSV_ABI*)(char16_t* out_text, uint32_t* out_text_length,
+                                                  const char16_t* source_text,
+                                                  uint32_t        source_text_length);
+using ExtKeyboardFilter = int(KYTY_SYSV_ABI*)(const Keycode* source_keycode, uint16_t* out_keycode,
+                                              uint32_t* out_status, void* reserved);
+
+struct Param {
+	int32_t         user_id;
+	Type            type;
+	uint64_t        supported_languages;
+	EnterLabel      enter_label;
+	uint32_t        input_method;
+	TextFilter      filter;
+	uint32_t        option;
+	uint32_t        max_text_length;
+	char16_t*       input_text_buffer;
+	float           posx;
+	float           posy;
+	Alignment       horizontal_alignment;
+	Alignment       vertical_alignment;
+	const char16_t* placeholder;
+	const char16_t* title;
+	int8_t          reserved[16];
+};
+
+struct Result {
+	EndStatus endstatus;
+	int8_t    reserved[12];
+};
+
+struct ExtendedParam {
+	uint32_t          option;
+	Color             color_base;
+	Color             color_line;
+	Color             color_text_field;
+	Color             color_preedit;
+	Color             color_button_default;
+	Color             color_button_function;
+	Color             color_button_symbol;
+	Color             color_text;
+	Color             color_special;
+	uint32_t          priority;
+	const char*       additional_dictionary_path;
+	ExtKeyboardFilter ext_keyboard_filter;
+	uint32_t          disable_device;
+	uint32_t          ext_keyboard_mode;
+	int8_t            reserved[60];
+};
+
+struct PositionAndForm {
+	uint32_t  type;
+	float     posx;
+	float     posy;
+	Alignment horizontal_alignment;
+	Alignment vertical_alignment;
+	uint32_t  width;
+	uint32_t  height;
+};
+
+struct Keycode {
+	uint16_t keycode;
+	char16_t character;
+	uint32_t status;
+	uint32_t type;
+	int32_t  user_id;
+	uint32_t resource_id;
+	uint64_t timestamp;
+};
+
+enum class ExternalAction : uint8_t {
+	None,
+	Text,
+	Backspace,
+	MoveLeft,
+	MoveRight,
+	Cancel,
+	Accept,
+	Newline,
+};
+
+struct ExternalInput {
+	Keycode        key;
+	ExternalAction action;
+	std::u16string text;
+};
+
+static_assert(sizeof(Param) == 0x60);
+static_assert(offsetof(Param, input_text_buffer) == 0x28);
+static_assert(offsetof(Param, title) == 0x48);
+static_assert(sizeof(Result) == 0x10);
+static_assert(sizeof(ExtendedParam) == 0x88);
+static_assert(offsetof(ExtendedParam, additional_dictionary_path) == 0x30);
+static_assert(sizeof(PositionAndForm) == 0x1c);
+static_assert(sizeof(Keycode) == 0x20);
+
+struct VisualState {
+	bool     active;
+	uint64_t revision;
+};
+
+struct HostSnapshot {
+	uint64_t       generation;
+	Type           type;
+	EnterLabel     enter_label;
+	uint32_t       option;
+	uint32_t       max_text_length;
+	uint32_t       cursor;
+	uint32_t       disable_device;
+	bool           key_panel_visible;
+	float          posx;
+	float          posy;
+	Alignment      horizontal_alignment;
+	Alignment      vertical_alignment;
+	uint32_t       panel_width;
+	uint32_t       panel_height;
+	std::u16string text;
+	std::u16string title;
+	std::u16string placeholder;
+};
+
+using VisibilityCallback = void (*)(bool visible, uint64_t generation);
+
+int KYTY_SYSV_ABI ImeDialogGetPanelSize(const Param* param, uint32_t* width, uint32_t* height);
+int KYTY_SYSV_ABI ImeDialogGetPanelSizeExtended(const Param* param, const ExtendedParam* extended,
+                                                uint32_t* width, uint32_t* height);
+int KYTY_SYSV_ABI ImeDialogInit(const Param* param, const ExtendedParam* extended);
+int KYTY_SYSV_ABI ImeDialogGetStatus();
+int KYTY_SYSV_ABI ImeDialogAbort();
+int KYTY_SYSV_ABI ImeDialogGetResult(Result* result);
+int KYTY_SYSV_ABI ImeDialogTerm();
+int KYTY_SYSV_ABI ImeDialogGetPanelPositionAndForm(PositionAndForm* form);
+
+VisualState GetVisualState() noexcept;
+void        SetVisibilityCallback(VisibilityCallback callback) noexcept;
+bool        GetHostSnapshot(HostSnapshot* snapshot);
+bool        HostInsertText(uint64_t generation, std::u16string_view text);
+bool        HostBackspace(uint64_t generation);
+bool        HostMoveCursor(uint64_t generation, int delta);
+bool        HostAccept(uint64_t generation);
+bool        HostCancel(uint64_t generation);
+bool        HostQueueExternalInput(uint64_t generation, ExternalInput input);
+
+} // namespace Libs::Dialog::ImeDialog
+
+#endif // EMULATOR_INCLUDE_EMULATOR_LIBS_IMEDIALOG_H_

src/libs/libAudio2.cpp

@@ -336,6 +336,17 @@ static AudioOut2PortStateEntry* audioout2_find_port_locked(AudioOut2PortHandle p
 	return nullptr;
 }
 
+static bool audioout2_context_has_queueable_device(AudioOut2ContextHandle ctx) {
+	Common::LockGuard lock(g_audioout2_port_mutex);
+	for (const auto& state: g_audioout2_ports) {
+		if (state.used && state.context == ctx && state.audio_handle > 0 &&
+		    state.pcm_data != nullptr && AudioInternal::AudioOutHasDevice(state.audio_handle)) {
+			return true;
+		}
+	}
+	return false;
+}
+
 static void audioout2_queue_context_audio(AudioOut2ContextHandle ctx, bool blocking) {
 	std::vector<AudioInternal::OutputParam> params;
 	params.reserve(AudioInternal::OUT_PORTS_MAX);
@@ -493,15 +504,23 @@ int KYTY_SYSV_ABI AudioOut2ContextPush(AudioOut2ContextHandle ctx, uint32_t bloc
 	uint32_t sleep_micros = audioout2_grain_micros(512);
 
 	for (;;) {
+		// Only a synchronous submission carrying PCM to a real device can rely on the SDL queue for
+		// pacing. Async pushes must retain queue-depth backpressure, and a handle without PCM (or a
+		// vibration/failed-open handle) has no downstream operation that can block this call.
+		const bool use_device_clock =
+		    blocking != 0 && audioout2_context_has_queueable_device(ctx);
+
 		g_audioout2_context_mutex.Lock();
 		if (auto* state = audioout2_find_context_locked(ctx); state != nullptr) {
 			audioout2_update_context_locked(state);
 			sleep_micros = audioout2_grain_micros(state->num_grains);
-			if (state->queued < state->queue_depth) {
+			if (state->queued < state->queue_depth || use_device_clock) {
 				if (state->queued == 0) {
 					state->last_update = LibKernel::KernelGetProcessTime();
 				}
-				state->queued++;
+				if (state->queued < state->queue_depth) {
+					state->queued++;
+				}
 				g_audioout2_context_mutex.Unlock();
 				audioout2_queue_context_audio(ctx, blocking != 0);
 				return OK;

src/libs/libDialog.cpp

@@ -1,5 +1,6 @@
 #include "common/abi.h"
 #include "libs/dialog.h"
+#include "libs/imeDialog.h"
 #include "libs/libs.h"
 #include "loader/symbolDatabase.h"
 
@@ -24,7 +25,14 @@ LIB_VERSION("ImeDialog", 1, "ImeDialog", 1, 1);
 namespace ImeDialog = Dialog::ImeDialog;
 
 LIB_DEFINE(InitDialog_1_ImeDialog) {
+	LIB_FUNC("CRD+jSErEJQ", ImeDialog::ImeDialogGetPanelSizeExtended);
 	LIB_FUNC("IADmD4tScBY", ImeDialog::ImeDialogGetStatus);
+	LIB_FUNC("gyTyVn+bXMw", ImeDialog::ImeDialogTerm);
+	LIB_FUNC("x01jxu+vxlc", ImeDialog::ImeDialogGetResult);
+	LIB_FUNC("wqsJvRXwl58", ImeDialog::ImeDialogGetPanelSize);
+	LIB_FUNC("NUeBrN7hzf0", ImeDialog::ImeDialogInit);
+	LIB_FUNC("oBmw4xrmfKs", ImeDialog::ImeDialogAbort);
+	LIB_FUNC("8jqzzPioYl8", ImeDialog::ImeDialogGetPanelPositionAndForm);
 }
 
 } // namespace LibImeDialog

src/libs/libGraphicsDriver.cpp

@@ -178,7 +178,8 @@ LIB_DEFINE(InitGraphicsDriver_1) {
 	LIB_FUNC("bxca0BK4FNg", Gen5::GraphicsUnknownJumpPatchSetTarget);
 	LIB_FUNC("2BS4EtAaF28", Gen5::GraphicsJumpPatchSetTarget);
 	LIB_FUNC("h9z6+0hEydk", Gen5::GraphicsSuspendPoint);
-	LIB_FUNC("qj7QZpgr9Uw", Gen5::GraphicsUnknownQj7QZpgr9Uw);
+	LIB_FUNC("qj7QZpgr9Uw", Gen5::GraphicsDcbContextStateOp);
+	LIB_FUNC("H6vHS5cidSA", Gen5::GraphicsDcbContextStateOpGetSize);
 	LIB_FUNC("BfBDZGbti7A", Gen5::GraphicsGetIsTrinityMode);
 	LIB_FUNC("dbOlWdppb4o", LibGen5::Graphics5UnknownDb);
 

src/libs/libKernel.cpp

@@ -13,6 +13,7 @@
 #include "kernel/memory.h"
 #include "kernel/pthread.h"
 #include "kernel/semaphore.h"
+#include "kernel/syncOnAddress.h"
 #include "libs/errno.h"
 #include "libs/libs.h"
 #include "libs/network.h"
@@ -2021,6 +2022,12 @@ int64_t KYTY_SYSV_ABI fstat(int d, LibKernel::FileSystem::FileStat* sb) {
 	return POSIX_N_CALL(LibKernel::FileSystem::KernelFstat(d, sb));
 }
 
+int KYTY_SYSV_ABI ftruncate(int d, int64_t length) {
+	PRINT_NAME();
+
+	return POSIX_CALL(LibKernel::FileSystem::KernelFtruncate(d, length));
+}
+
 int KYTY_SYSV_ABI socket(int family, int type, int protocol) {
 	PRINT_NAME();
 	return Network::Net::Socket(family, type, protocol);
@@ -2128,26 +2135,37 @@ uint64_t KYTY_SYSV_ABI cfwBSQyr5Ys(uint64_t a1, uint64_t a2, uint64_t a3, uint64
 	return 0;
 }
 
-uint64_t KYTY_SYSV_ABI KernelSyncOnAddressV1(uint64_t op, uint64_t address, uint64_t value,
-                                             uint64_t size, uint64_t timeout, uint64_t flags) {
-	static std::atomic_uint32_t log_count = 0;
-	const auto                  index     = log_count.fetch_add(1, std::memory_order_relaxed);
-
-	if (index < 16) {
-		LOGF("\t libkernel_sync_on_address_v1: op=0x%016" PRIx64 ", address=0x%016" PRIx64
-		     ", value=0x%016" PRIx64 ", size=0x%016" PRIx64 ", timeout=0x%016" PRIx64
-		     ", flags=0x%016" PRIx64 "\n",
-		     op, address, value, size, timeout, flags);
+static void LogExperimentalSyncOnAddress(std::atomic_bool& logged, const char* function_name) {
+	if (!logged.exchange(true, std::memory_order_relaxed)) {
+		::printf("WARNING: %s is experimental\n", function_name);
+		LOGF("WARNING: %s is experimental\n", function_name);
 	}
+}
 
-	if (op != 0 && address == 0 && value == 0 && size == 0) {
-		// This unsupported form is used as a yield/wait by some Unity jobs.
-		// SleepMicro() uses a sub-millisecond busy wait on Windows, which can
-		// pin every worker thread when the guest polls this path.
-		Common::Thread::Sleep(timeout == 0 ? 1 : 2);
-	}
+int KYTY_SYSV_ABI KernelSyncOnAddressWait(volatile uint32_t* address, uint32_t expected,
+                                          const uint32_t* timeout_micros) {
+	return LibKernel::SyncOnAddress::Wait32(address, expected, timeout_micros,
+	                                        LibKernel::KernelDispatchPendingSignalForCurrentThread);
+}
 
-	return 0;
+int KYTY_SYSV_ABI KernelSyncOnAddressWait32(volatile uint32_t* address, uint32_t expected,
+                                            const uint32_t* timeout_micros) {
+	static std::atomic_bool logged {false};
+	LogExperimentalSyncOnAddress(logged, "sceKernelSyncOnAddressWait32");
+	return LibKernel::SyncOnAddress::Wait32(address, expected, timeout_micros,
+	                                        LibKernel::KernelDispatchPendingSignalForCurrentThread);
+}
+
+int KYTY_SYSV_ABI KernelSyncOnAddressWait64(volatile uint64_t* address, uint64_t expected,
+                                            const uint32_t* timeout_micros) {
+	static std::atomic_bool logged {false};
+	LogExperimentalSyncOnAddress(logged, "sceKernelSyncOnAddressWait64");
+	return LibKernel::SyncOnAddress::Wait64(address, expected, timeout_micros,
+	                                        LibKernel::KernelDispatchPendingSignalForCurrentThread);
+}
+
+int KYTY_SYSV_ABI KernelSyncOnAddressWake(volatile void* address, int32_t count) {
+	return LibKernel::SyncOnAddress::Wake(address, count);
 }
 
 LIB_DEFINE(InitLibKernel_1_Posix) {
@@ -2159,6 +2177,7 @@ LIB_DEFINE(InitLibKernel_1_Posix) {
 	LIB_FUNC("yS8U2TGCe1A", nanosleep);
 	LIB_FUNC("E6ao34wPw+U", stat);
 	LIB_FUNC("JGMio+21L4c", mkdir);
+	LIB_FUNC("ih4CD9-gghM", Posix::ftruncate);
 	LIB_FUNC("pDuPEf3m4fI", Posix::sem_init);
 	LIB_FUNC("cDW233RAwWo", Posix::sem_destroy);
 	LIB_FUNC("YCV5dGGBcCo", Posix::sem_wait);
@@ -3398,8 +3417,10 @@ LIB_DEFINE(InitLibKernel_1) {
 	LIB_FUNC("Xjoosiw+XPI", LibKernel::KernelUuidCreate);
 	LIB_FUNC("DLORcroUqbc", LibKernel::KernelGetOpenPsId);
 	LIB_FUNC("zE-wXIZjLoM", LibKernel::KernelDebugRaiseExceptionOnReleaseMode);
-	LIB_FUNC("Hc4CaR6JBL0", Posix::KernelSyncOnAddressV1);
-	LIB_FUNC("q2y-wDIVWZA", Posix::KernelSyncOnAddressV1);
+	LIB_FUNC("Hc4CaR6JBL0", Posix::KernelSyncOnAddressWait);
+	LIB_FUNC("B2n8aDorSH4", Posix::KernelSyncOnAddressWait32);
+	LIB_FUNC("PZQhiiLXRFs", Posix::KernelSyncOnAddressWait64);
+	LIB_FUNC("q2y-wDIVWZA", Posix::KernelSyncOnAddressWake);
 
 	AddLibkernelUnityFunc(s, "Qhv5ARAoOEc",
 	                      reinterpret_cast<uint64_t>(LibKernel::KernelRemoveExceptionHandler),

src/libs/libSystemService.cpp

@@ -1,6 +1,7 @@
 #include "common/abi.h"
 #include "common/assert.h"
 #include "common/common.h"
+#include "common/emulatorConfig.h"
 #include "common/logging/log.h"
 #include "common/stringUtils.h"
 #include "libs/errno.h"
@@ -25,37 +26,6 @@ namespace SystemService {
 [[maybe_unused]] constexpr int PARAM_ID_SCREEN_READER       = 208;
 [[maybe_unused]] constexpr int PARAM_ID_ENTER_BUTTON_ASSIGN = 1000;
 
-[[maybe_unused]] constexpr int PARAM_LANG_JAPANESE      = 0;
-[[maybe_unused]] constexpr int PARAM_LANG_ENGLISH_US    = 1;
-[[maybe_unused]] constexpr int PARAM_LANG_FRENCH        = 2;
-[[maybe_unused]] constexpr int PARAM_LANG_SPANISH       = 3;
-[[maybe_unused]] constexpr int PARAM_LANG_GERMAN        = 4;
-[[maybe_unused]] constexpr int PARAM_LANG_ITALIAN       = 5;
-[[maybe_unused]] constexpr int PARAM_LANG_DUTCH         = 6;
-[[maybe_unused]] constexpr int PARAM_LANG_PORTUGUESE_PT = 7;
-[[maybe_unused]] constexpr int PARAM_LANG_RUSSIAN       = 8;
-[[maybe_unused]] constexpr int PARAM_LANG_KOREAN        = 9;
-[[maybe_unused]] constexpr int PARAM_LANG_CHINESE_T     = 10;
-[[maybe_unused]] constexpr int PARAM_LANG_CHINESE_S     = 11;
-[[maybe_unused]] constexpr int PARAM_LANG_FINNISH       = 12;
-[[maybe_unused]] constexpr int PARAM_LANG_SWEDISH       = 13;
-[[maybe_unused]] constexpr int PARAM_LANG_DANISH        = 14;
-[[maybe_unused]] constexpr int PARAM_LANG_NORWEGIAN     = 15;
-[[maybe_unused]] constexpr int PARAM_LANG_POLISH        = 16;
-[[maybe_unused]] constexpr int PARAM_LANG_PORTUGUESE_BR = 17;
-[[maybe_unused]] constexpr int PARAM_LANG_ENGLISH_GB    = 18;
-[[maybe_unused]] constexpr int PARAM_LANG_TURKISH       = 19;
-[[maybe_unused]] constexpr int PARAM_LANG_SPANISH_LA    = 20;
-[[maybe_unused]] constexpr int PARAM_LANG_ARABIC        = 21;
-[[maybe_unused]] constexpr int PARAM_LANG_FRENCH_CA     = 22;
-[[maybe_unused]] constexpr int PARAM_LANG_CZECH         = 23;
-[[maybe_unused]] constexpr int PARAM_LANG_HUNGARIAN     = 24;
-[[maybe_unused]] constexpr int PARAM_LANG_GREEK         = 25;
-[[maybe_unused]] constexpr int PARAM_LANG_ROMANIAN      = 26;
-[[maybe_unused]] constexpr int PARAM_LANG_THAI          = 27;
-[[maybe_unused]] constexpr int PARAM_LANG_VIETNAMESE    = 28;
-[[maybe_unused]] constexpr int PARAM_LANG_INDONESIAN    = 29;
-
 [[maybe_unused]] constexpr int PARAM_DATE_FORMAT_YYYYMMDD = 0;
 [[maybe_unused]] constexpr int PARAM_DATE_FORMAT_DDMMYYYY = 1;
 [[maybe_unused]] constexpr int PARAM_DATE_FORMAT_MMDDYYYY = 2;
@@ -121,7 +91,7 @@ static int KYTY_SYSV_ABI SystemServiceParamGetInt(int param_id, int* value) {
 	int v = 0;
 
 	switch (param_id) {
-		case PARAM_ID_LANG: v = PARAM_LANG_ENGLISH_US; break;
+		case PARAM_ID_LANG: v = static_cast<int>(Config::GetConsoleLanguage()); break;
 		case PARAM_ID_DATE_FORMAT: v = PARAM_DATE_FORMAT_DDMMYYYY; break;
 		case PARAM_ID_TIME_FORMAT: v = PARAM_TIME_FORMAT_24HOUR; break;
 		case PARAM_ID_TIME_ZONE: v = +180; break;

src/loader/runtimeLinker.cpp

@@ -360,9 +360,10 @@ static KYTY_SYSV_ABI void RunEntry(uint64_t addr, EntryParams* params, atexit_fu
 	auto* func = reinterpret_cast<entry_func_t>(addr);
 
 	if (stack_top != nullptr) {
-		const auto guest_rsp =
+		const auto aligned_stack_top =
 		    reinterpret_cast<uintptr_t>(stack_top) & ~static_cast<uintptr_t>(0x0f);
-		const auto guest_rbp = guest_rsp - 4u * sizeof(uint64_t);
+		const auto guest_rsp = aligned_stack_top - 2u * sizeof(uintptr_t);
+		const auto guest_rbp = guest_rsp;
 
 		auto* guest_root_frame = reinterpret_cast<uintptr_t*>(guest_rbp);
 		guest_root_frame[0]    = 0;
@@ -507,6 +508,13 @@ struct MainEntryStackTestState {
 static KYTY_SYSV_ABI void TestMainEntryStackCallback(EntryParams* params,
                                                      atexit_func_t /*atexit_func*/) {
 	auto* state = reinterpret_cast<MainEntryStackTestState*>(const_cast<char*>(params->argv[0]));
+	asm volatile("pushq %%r15\n\t"
+	             "pushq %%r14\n\t"
+	             "popq %%r14\n\t"
+	             "popq %%r15\n\t"
+	             :
+	             :
+	             : "memory");
 	asm volatile("movq %%rsp, %0" : "=r"(state->rsp) : : "memory");
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	asm volatile("movq %%gs:0x08, %0\n\t"
@@ -529,6 +537,8 @@ bool TestMainEntryUsesGuestStack() {
 	MainEntryStackTestState state {};
 	EntryParams             params {};
 	params.argv[0] = reinterpret_cast<const char*>(&state);
+	std::memset(reinterpret_cast<void*>(stack_base), 0xcd, stack_size);
+	auto* root_frame = reinterpret_cast<const uintptr_t*>(stack_base + stack_size) - 2;
 
 #if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
 	uintptr_t original_teb_stack_base  = 0;
@@ -558,9 +568,10 @@ bool TestMainEntryUsesGuestStack() {
 	constexpr bool teb_ok = true;
 #endif
 
-	const bool rsp_ok = state.rsp >= stack_base && state.rsp < stack_base + stack_size;
-	const bool freed  = Libs::LibKernel::Memory::FreeGuestMemory(stack_base, stack_size);
-	return state.called && rsp_ok && teb_ok && freed;
+	const bool rsp_ok  = state.rsp >= stack_base && state.rsp < stack_base + stack_size;
+	const bool root_ok = root_frame[0] == 0 && root_frame[1] == 0;
+	const bool freed   = Libs::LibKernel::Memory::FreeGuestMemory(stack_base, stack_size);
+	return state.called && rsp_ok && root_ok && teb_ok && freed;
 }
 
 bool TestModuleRelocationUsesWritableHostMapping() {