license

Signed-off-by: lizzie <lizzie@eden-emu.dev>

CMakeLists.txt

@@ -143,8 +143,8 @@ if (MSVC AND ARCHITECTURE_x86)
 endif()
 
 if (CXX_CLANG_CL)
-    # clang-cl prints literally 10000+ warnings without this
     add_compile_options(
+        # clang-cl prints literally 10000+ warnings without this
         $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-unused-command-line-argument>
         $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-unsafe-buffer-usage>
         $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-unused-value>
@@ -154,6 +154,7 @@ if (CXX_CLANG_CL)
         $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-deprecated-declarations>
         $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-cast-function-type-mismatch>
         $<$<COMPILE_LANGUAGE:C,CXX>:/EHsc>)
+
     # REQUIRED CPU features IN Windows-amd64
     if (ARCHITECTURE_x86_64)
         add_compile_options(
@@ -394,14 +395,13 @@ if (Boost_ADDED)
     if (NOT MSVC OR CXX_CLANG)
         # boost sucks
         if (PLATFORM_SUN)
-            add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-pthreads>)
+            set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -pthreads")
+            set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pthreads")
         endif()
 
-        target_compile_options(boost_heap INTERFACE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-shadow>)
-        target_compile_options(boost_icl INTERFACE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-shadow>)
-        target_compile_options(boost_asio INTERFACE
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-conversion>
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-fallthrough>)
+        target_compile_options(boost_heap INTERFACE -Wno-shadow)
+        target_compile_options(boost_icl INTERFACE -Wno-shadow)
+        target_compile_options(boost_asio INTERFACE -Wno-conversion -Wno-implicit-fallthrough)
     endif()
 endif()
 
@@ -439,7 +439,9 @@ if (NOT YUZU_STATIC_ROOM)
 
     if (Opus_ADDED)
         if (MSVC AND CXX_CLANG)
-            target_compile_options(opus PRIVATE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-function-declaration>)
+            target_compile_options(opus PRIVATE
+                -Wno-implicit-function-declaration
+            )
         endif()
     endif()
 

externals/CMakeLists.txt

@@ -109,15 +109,16 @@ if(ENABLE_CUBEB)
     if (cubeb_ADDED)
         if (NOT MSVC)
             if (TARGET speex)
-                target_compile_options(speex PRIVATE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-sign-compare>)
+                target_compile_options(speex PRIVATE -Wno-sign-compare)
             endif()
+
             set_target_properties(cubeb PROPERTIES COMPILE_OPTIONS "")
             target_compile_options(cubeb INTERFACE
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-implicit-const-int-float-conversion>
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-shadow>
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-missing-declarations>
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-return-type>
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-uninitialized>
+                -Wno-implicit-const-int-float-conversion
+                -Wno-shadow
+                -Wno-missing-declarations
+                -Wno-return-type
+                -Wno-uninitialized
             )
         else()
             target_compile_options(cubeb PRIVATE
@@ -183,9 +184,7 @@ if (YUZU_USE_BUNDLED_SIRIT)
 else()
     AddJsonPackage(sirit)
     if(MSVC AND CXX_CLANG)
-        target_compile_options(siritobj PRIVATE
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-error=unused-command-line-argument>
-        )
+        target_compile_options(siritobj PRIVATE -Wno-error=unused-command-line-argument)
     endif()
 endif()
 
@@ -221,7 +220,7 @@ AddJsonPackage(vulkan-memory-allocator)
 if (VulkanMemoryAllocator_ADDED)
     if (CXX_CLANG)
         target_compile_options(VulkanMemoryAllocator INTERFACE
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-unused-variable>
+            -Wno-unused-variable
         )
     elseif(MSVC)
         target_compile_options(VulkanMemoryAllocator INTERFACE

externals/libusb/CMakeLists.txt

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 # SPDX-FileCopyrightText: 2020 yuzu Emulator Project
@@ -232,7 +232,7 @@ else() # MINGW OR (${CMAKE_SYSTEM_NAME} MATCHES "Linux")
         )
         find_package(Threads REQUIRED)
         if(THREADS_HAVE_PTHREAD_ARG)
-          target_compile_options(usb PUBLIC $<$<COMPILE_LANGUAGE:C,CXX>:-pthread>)
+          target_compile_options(usb PUBLIC "-pthread")
         endif()
         if(CMAKE_THREAD_LIBS_INIT)
           target_link_libraries(usb PRIVATE "${CMAKE_THREAD_LIBS_INIT}")

src/CMakeLists.txt

@@ -118,42 +118,47 @@ if (MSVC AND NOT CXX_CLANG)
 else()
     if (NOT MSVC)
         add_compile_options(
-            $<$<COMPILE_LANGUAGE:C,CXX>:-fwrapv>
-            $<$<COMPILE_LANGUAGE:C,CXX>:-pipe>
-            # Disable RTTI (C++ only)
-            $<$<COMPILE_LANGUAGE:CXX>:-fno-rtti>)
+            -fwrapv
+            -fno-rtti # Disable RTTI
+            -pipe
+        )
     endif()
 
     add_compile_options(
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=all>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=extra>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=missing-declarations>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=shadow>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=unused>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-attributes>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-invalid-offsetof>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-unused-parameter>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-missing-field-initializers>)
+        -Werror=all
+        -Werror=extra
+        -Werror=missing-declarations
+        -Werror=shadow
+        -Werror=unused
+
+        -Wno-attributes
+        -Wno-invalid-offsetof
+        -Wno-unused-parameter
+        -Wno-missing-field-initializers
+    )
 
     if (CXX_CLANG OR CXX_ICC OR CXX_APPLE) # Clang, AppleClang, or Intel C++
         if (NOT MSVC)
             add_compile_options(
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=shadow-uncaptured-local>
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=implicit-fallthrough>
-                $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=type-limits>)
+                -Werror=shadow-uncaptured-local
+                -Werror=implicit-fallthrough
+                -Werror=type-limits
+            )
         endif()
+
         add_compile_options(
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-braced-scalar-init>
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-unused-private-field>
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-nullability-completeness>)
+            -Wno-braced-scalar-init
+            -Wno-unused-private-field
+            -Wno-nullability-completeness
+        )
     endif()
 
     if (ARCHITECTURE_x86_64)
-        add_compile_options(-mcx16)
+        add_compile_options("-mcx16")
     endif()
 
     if (APPLE AND CXX_CLANG)
-        add_compile_options($<$<COMPILE_LANGUAGE:C,CXX>:-stdlib=libc++>)
+        add_compile_options("-stdlib=libc++")
     endif()
 
     # GCC bugs
@@ -161,9 +166,10 @@ else()
         # These diagnostics would be great if they worked, but are just completely broken
         # and produce bogus errors on external libraries like fmt.
         add_compile_options(
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-array-bounds>
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-stringop-overread>
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-stringop-overflow>)
+            -Wno-array-bounds
+            -Wno-stringop-overread
+            -Wno-stringop-overflow
+        )
     endif()
 
     # Set file offset size to 64 bits.

src/android/app/src/main/java/org/yuzu/yuzu_emu/fragments/DriverManagerFragment.kt

@@ -29,6 +29,7 @@ import org.yuzu.yuzu_emu.databinding.FragmentDriverManagerBinding
 import org.yuzu.yuzu_emu.features.settings.model.Settings
 import org.yuzu.yuzu_emu.features.settings.model.StringSetting
 import org.yuzu.yuzu_emu.features.settings.ui.SettingsSubscreen
+import org.yuzu.yuzu_emu.model.Driver.Companion.toDriver
 import org.yuzu.yuzu_emu.model.DriverViewModel
 import org.yuzu.yuzu_emu.model.HomeViewModel
 import org.yuzu.yuzu_emu.utils.FileUtil
@@ -215,23 +216,19 @@ class DriverManagerFragment : Fragment() {
 
                 val driverData = GpuDriverHelper.getMetadataFromZip(driverFile)
                 val driverInList =
-                    driverViewModel.driverData.firstOrNull {
-                        it.first == driverPath || it.second == driverData
-                    }
+                    driverViewModel.driverData.firstOrNull { it.second == driverData }
                 if (driverInList != null) {
                     return@newInstance getString(R.string.driver_already_installed)
                 } else {
                     driverViewModel.onDriverAdded(Pair(driverPath, driverData))
                     withContext(Dispatchers.Main) {
                         if (_binding != null) {
-                            refreshDriverList()
                             val adapter = binding.listDrivers.adapter as DriverAdapter
-                            val selectedPosition = adapter.currentList
-                                .indexOfFirst { it.selected }
-                                .let { if (it == -1) 0 else it }
+                            adapter.addItem(driverData.toDriver())
+                            adapter.selectItem(adapter.currentList.indices.last)
                             driverViewModel.showClearButton(!StringSetting.DRIVER_PATH.global)
                             binding.listDrivers
-                                .smoothScrollToPosition(selectedPosition)
+                                .smoothScrollToPosition(adapter.currentList.indices.last)
                         }
                     }
                 }

src/android/app/src/main/java/org/yuzu/yuzu_emu/model/DriverViewModel.kt

@@ -154,30 +154,15 @@ class DriverViewModel : ViewModel() {
     }
 
     fun onDriverRemoved(removedPosition: Int, selectedPosition: Int) {
-        val driverIndex = removedPosition - 1
-        if (driverIndex !in driverData.indices) {
-            updateDriverList()
-            return
-        }
-
-        driversToDelete.add(driverData[driverIndex].first)
-        driverData.removeAt(driverIndex)
-        val safeSelectedPosition = selectedPosition.coerceIn(0, driverData.size)
-        onDriverSelected(safeSelectedPosition)
+        driversToDelete.add(driverData[removedPosition - 1].first)
+        driverData.removeAt(removedPosition - 1)
+        onDriverSelected(selectedPosition)
     }
 
     fun onDriverAdded(driver: Pair<String, GpuDriverMetadata>) {
         if (driversToDelete.contains(driver.first)) {
             driversToDelete.remove(driver.first)
         }
-
-        val existingDriverIndex = driverData.indexOfFirst {
-            it.first == driver.first || it.second == driver.second
-        }
-        if (existingDriverIndex != -1) {
-            onDriverSelected(existingDriverIndex + 1)
-            return
-        }
         driverData.add(driver)
         onDriverSelected(driverData.size)
     }

src/audio_core/CMakeLists.txt

@@ -222,8 +222,10 @@ if (MSVC)
     )
 else()
     target_compile_options(audio_core PRIVATE
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-sign-conversion>)
+        -Werror=conversion
+
+        -Wno-sign-conversion
+    )
 endif()
 
 target_include_directories(audio_core PRIVATE ${OPUS_INCLUDE_DIRS})

src/common/CMakeLists.txt

@@ -225,9 +225,8 @@ else()
 endif()
 
 if(CXX_CLANG)
-    target_compile_options(common PRIVATE
-        $<$<COMPILE_LANGUAGE:C,CXX>:-fsized-deallocation>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=unreachable-code-aggressive>)
+    target_compile_options(common PRIVATE -fsized-deallocation
+        -Werror=unreachable-code-aggressive)
     target_compile_definitions(
         common
         PRIVATE

src/common/string_util.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 // SPDX-FileCopyrightText: 2013 Dolphin Emulator Project
@@ -116,20 +116,122 @@ std::string ReplaceAll(std::string result, const std::string& src, const std::st
 }
 
 std::string UTF16ToUTF8(std::u16string_view input) {
-    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
-    return convert.to_bytes(input.data(), input.data() + input.size());
+    std::string result;
+    result.reserve(input.size() * 4);
+    for (size_t i = 0; i < input.size(); ++i) {
+        uint32_t code = input[i];
+        // Handle surrogate pairs
+        if (code >= 0xD800 && code <= 0xDBFF) {
+            if (i + 1 < input.size()) {
+                uint32_t low = input[i + 1];
+                if (low >= 0xDC00 && low <= 0xDFFF) {
+                    code = ((code - 0xD800) << 10) + (low - 0xDC00) + 0x10000;
+                    ++i;
+                }
+            }
+        }
+        if (code <= 0x7F) {
+            result.push_back(char(code));
+        } else if (code <= 0x7FF) {
+            result.push_back(char(0xC0 | (code >> 6)));
+            result.push_back(char(0x80 | (code & 0x3F)));
+        } else if (code <= 0xFFFF) {
+            result.push_back(char(0xE0 | (code >> 12)));
+            result.push_back(char(0x80 | ((code >> 6) & 0x3F)));
+            result.push_back(char(0x80 | (code & 0x3F)));
+        } else {
+            result.push_back(char(0xF0 | (code >> 18)));
+            result.push_back(char(0x80 | ((code >> 12) & 0x3F)));
+            result.push_back(char(0x80 | ((code >> 6) & 0x3F)));
+            result.push_back(char(0x80 | (code & 0x3F)));
+        }
+    }
+    return result;
 }
 
 std::u16string UTF8ToUTF16(std::string_view input) {
-    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> convert;
-    return convert.from_bytes(input.data(), input.data() + input.size());
+    std::u16string result;
+    result.reserve(input.size() * 2);
+    for (size_t i = 0; i < input.size(); ) {
+        uint32_t code = 0;
+        unsigned char c = input[i];
+        size_t len = 0;
+        if ((c & 0x80) == 0) {
+            code = c;
+            len = 1;
+        } else if ((c & 0xE0) == 0xC0) {
+            code = c & 0x1F;
+            len = 2;
+        } else if ((c & 0xF0) == 0xE0) {
+            code = c & 0x0F;
+            len = 3;
+        } else if ((c & 0xF8) == 0xF0) {
+            code = c & 0x07;
+            len = 4;
+        } else {
+            ++i;
+            continue;
+        }
+        if (i + len - 1 >= input.size())
+            break;
+        for (size_t j = 1; j <= len - 1; ++j) {
+            if ((input[i + j] & 0xC0) != 0x80) {
+                code = 0xFFFD;
+                break;
+            }
+            code = (code << 6) | (input[i + j] & 0x3F);
+        }
+        if (code <= 0xFFFF) {
+            result.push_back(char16_t(code));
+        } else {
+            code -= 0x10000;
+            result.push_back(char16_t(0xD800 + (code >> 10)));
+            result.push_back(char16_t(0xDC00 + (code & 0x3FF)));
+        }
+        i += len;
+    }
+    return result;
 }
 
 std::u32string UTF8ToUTF32(std::string_view input) {
-    std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> convert;
-    return convert.from_bytes(input.data(), input.data() + input.size());
+    std::u32string result;
+    result.reserve(input.size());
+    for (size_t i = 0; i < input.size(); ) {
+        uint32_t code = 0;
+        unsigned char c = input[i];
+        size_t len = 0;
+        if ((c & 0x80) == 0) {
+            code = c;
+            len = 1;
+        } else if ((c & 0xE0) == 0xC0) {
+            code = c & 0x1F;
+            len = 2;
+        } else if ((c & 0xF0) == 0xE0) {
+            code = c & 0x0F;
+            len = 3;
+        } else if ((c & 0xF8) == 0xF0) {
+            code = c & 0x07;
+            len = 4;
+        } else {
+            ++i;
+            continue;
+        }
+        if (i + len - 1 >= input.size())
+            break;
+        for (size_t j = 1; j <= len - 1; ++j) {
+            if ((input[i + j] & 0xC0) != 0x80) {
+                code = 0xFFFD;
+                break;
+            }
+            code = (code << 6) | (input[i + j] & 0x3F);
+        }
+        result.push_back(code);
+        i += len;
+    }
+    return result;
 }
 
+
 #ifdef _WIN32
 static std::wstring CPToUTF16(u32 code_page, std::string_view input) {
     const auto size =

src/core/CMakeLists.txt

@@ -1195,13 +1195,13 @@ if (MSVC)
     )
 else()
     target_compile_options(core PRIVATE
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-sign-conversion>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-cast-function-type>
+        -Werror=conversion
+        -Wno-sign-conversion
+        -Wno-cast-function-type
         $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>)
     # pre-clang19 will spam with "OH DID YOU MEAN THIS?" otherwise...
     if (CXX_CLANG AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 19)
-        target_compile_options(core PRIVATE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-cast-function-type-mismatch>)
+        target_compile_options(core PRIVATE -Wno-cast-function-type-mismatch)
     endif()
 endif()
 

src/dynarmic/src/dynarmic/CMakeLists.txt

@@ -53,6 +53,7 @@ add_library(dynarmic STATIC
     common/fp/util.h
     common/llvm_disassemble.cpp
     common/llvm_disassemble.h
+    common/lut_from_list.h
     common/math_util.cpp
     common/math_util.h
     common/safe_ops.h
@@ -68,7 +69,6 @@ add_library(dynarmic STATIC
     frontend/decoder/matcher.h
     frontend/imm.cpp
     frontend/imm.h
-    interface/halt_reason.h
     interface/exclusive_monitor.h
     interface/optimization_flags.h
     ir/acc_type.h

src/dynarmic/src/dynarmic/backend/arm64/emit_arm64_vector_floating_point.cpp

@@ -1,4 +1,4 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 // SPDX-License-Identifier: GPL-3.0-or-later
 
 /* This file is part of the dynarmic project.
@@ -31,6 +31,7 @@
 #include "dynarmic/common/fp/info.h"
 #include "dynarmic/common/fp/op.h"
 #include "dynarmic/common/fp/rounding_mode.h"
+#include "dynarmic/common/lut_from_list.h"
 #include "dynarmic/ir/basic_block.h"
 #include "dynarmic/ir/microinstruction.h"
 #include "dynarmic/ir/opcodes.h"

src/dynarmic/src/dynarmic/backend/x64/emit_x64_floating_point.cpp

@@ -31,6 +31,7 @@
 #include "dynarmic/common/fp/info.h"
 #include "dynarmic/common/fp/op.h"
 #include "dynarmic/common/fp/rounding_mode.h"
+#include "dynarmic/common/lut_from_list.h"
 #include "dynarmic/interface/optimization_flags.h"
 #include "dynarmic/ir/basic_block.h"
 #include "dynarmic/ir/microinstruction.h"

src/dynarmic/src/dynarmic/backend/x64/emit_x64_vector_floating_point.cpp

@@ -31,6 +31,7 @@
 #include "dynarmic/common/fp/info.h"
 #include "dynarmic/common/fp/op.h"
 #include "dynarmic/common/fp/util.h"
+#include "dynarmic/common/lut_from_list.h"
 #include "dynarmic/interface/optimization_flags.h"
 #include "dynarmic/ir/basic_block.h"
 #include "dynarmic/ir/microinstruction.h"
@@ -2126,42 +2127,28 @@ void EmitFPVectorToFixed(BlockOfCode& code, EmitContext& ctx, IR::Inst* inst) {
         }
     }
 
-    using FPT = mcl::unsigned_integer_of_size<fsize>; // WORKAROUND: For issue 678 on MSVC
-    auto const func = [rounding]() -> void(*)(VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {
-        switch (rounding) {
-        case FP::RoundingMode::ToNearest_TieEven:
-            return [](VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {
+    using fbits_list = mp::lift_sequence<std::make_index_sequence<fsize + 1>>;
+    using rounding_list = mp::list<
+        mp::lift_value<FP::RoundingMode::ToNearest_TieEven>,
+        mp::lift_value<FP::RoundingMode::TowardsPlusInfinity>,
+        mp::lift_value<FP::RoundingMode::TowardsMinusInfinity>,
+        mp::lift_value<FP::RoundingMode::TowardsZero>,
+        mp::lift_value<FP::RoundingMode::ToNearest_TieAwayFromZero>>;
+
+    static const auto lut = Common::GenerateLookupTableFromList([]<typename I>(I) {
+        using FPT = mcl::unsigned_integer_of_size<fsize>;  // WORKAROUND: For issue 678 on MSVC
+        return std::pair{
+            mp::lower_to_tuple_v<I>,
+            Common::FptrCast([](VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {
+                constexpr size_t fbits = mp::get<0, I>::value;
+                constexpr FP::RoundingMode rounding_mode = mp::get<1, I>::value;
                 for (size_t i = 0; i < output.size(); ++i)
-                    output[i] = FPT(FP::FPToFixed<FPT>(fsize, input[i], fsize, unsigned_, fpcr, FP::RoundingMode::ToNearest_TieEven, fpsr));
-            };
-        case FP::RoundingMode::TowardsPlusInfinity:
-            return [](VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {
-                for (size_t i = 0; i < output.size(); ++i)
-                    output[i] = FPT(FP::FPToFixed<FPT>(fsize, input[i], fsize, unsigned_, fpcr, FP::RoundingMode::TowardsPlusInfinity, fpsr));
-            };
-        case FP::RoundingMode::TowardsMinusInfinity:
-            return [](VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {
-                for (size_t i = 0; i < output.size(); ++i)
-                    output[i] = FPT(FP::FPToFixed<FPT>(fsize, input[i], fsize, unsigned_, fpcr, FP::RoundingMode::TowardsMinusInfinity, fpsr));
-            };
-        case FP::RoundingMode::TowardsZero:
-            return [](VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {
-                for (size_t i = 0; i < output.size(); ++i)
-                    output[i] = FPT(FP::FPToFixed<FPT>(fsize, input[i], fsize, unsigned_, fpcr, FP::RoundingMode::TowardsZero, fpsr));
-            };
-        case FP::RoundingMode::ToNearest_TieAwayFromZero:
-            return [](VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {
-                for (size_t i = 0; i < output.size(); ++i)
-                    output[i] = FPT(FP::FPToFixed<FPT>(fsize, input[i], fsize, unsigned_, fpcr, FP::RoundingMode::ToNearest_TieAwayFromZero, fpsr));
-            };
-        case FP::RoundingMode::ToOdd:
-            return [](VectorArray<FPT>& output, const VectorArray<FPT>& input, FP::FPCR fpcr, FP::FPSR& fpsr) {
-                for (size_t i = 0; i < output.size(); ++i)
-                    output[i] = FPT(FP::FPToFixed<FPT>(fsize, input[i], fsize, unsigned_, fpcr, FP::RoundingMode::ToOdd, fpsr));
-            };
-        }
-    }();
-    EmitTwoOpFallback<3>(code, ctx, inst, func);
+                    output[i] = FPT(FP::FPToFixed<FPT>(fsize, input[i], fbits, unsigned_, fpcr, rounding_mode, fpsr));
+            })
+        };
+    }, mp::cartesian_product<fbits_list, rounding_list>{});
+
+    EmitTwoOpFallback<3>(code, ctx, inst, lut.at(std::make_tuple(fbits, rounding)));
 }
 
 void EmitX64::EmitFPVectorToSignedFixed16(EmitContext& ctx, IR::Inst* inst) {

src/dynarmic/src/dynarmic/common/lut_from_list.h

@@ -0,0 +1,55 @@
+// SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
+/* This file is part of the dynarmic project.
+ * Copyright (c) 2018 MerryMage
+ * SPDX-License-Identifier: 0BSD
+ */
+
+#pragma once
+
+#include <initializer_list>
+#include <map>
+#include <type_traits>
+
+#include <mcl/mp/metafunction/apply.hpp>
+#include <mcl/mp/typelist/list.hpp>
+#include <mcl/type_traits/is_instance_of_template.hpp>
+
+#ifdef _MSC_VER
+#    include <mcl/mp/typelist/head.hpp>
+#endif
+
+namespace Dynarmic::Common {
+
+// prevents this function from printing 56,000 character warning messages
+#ifdef __GNUC__
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wno-stack-usage"
+#endif
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wno-stack-usage"
+#endif
+
+template<typename Function, typename... Values>
+inline auto GenerateLookupTableFromList(Function f, mcl::mp::list<Values...>) {
+#ifdef _MSC_VER
+    using PairT = std::invoke_result_t<Function, mcl::mp::head<mcl::mp::list<Values...>>>;
+#else
+    using PairT = std::common_type_t<std::invoke_result_t<Function, Values>...>;
+#endif
+    using MapT = mcl::mp::apply<std::map, PairT>;
+    static_assert(mcl::is_instance_of_template_v<std::pair, PairT>);
+    const std::initializer_list<PairT> pair_array{f(Values{})...};
+    return MapT(pair_array.begin(), pair_array.end());
+}
+
+#ifdef __GNUC__
+#pragma GCC diagnostic pop
+#endif
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+}  // namespace Dynarmic::Common

src/hid_core/CMakeLists.txt

@@ -1,6 +1,3 @@
-# SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-# SPDX-License-Identifier: GPL-3.0-or-later
-
 # SPDX-FileCopyrightText: 2018 yuzu Emulator Project
 # SPDX-License-Identifier: GPL-2.0-or-later
 
@@ -151,10 +148,13 @@ if (MSVC)
     )
 else()
     target_compile_options(hid_core PRIVATE
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-sign-conversion>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-cast-function-type>
-        $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>)
+        -Werror=conversion
+
+        -Wno-sign-conversion
+        -Wno-cast-function-type
+
+        $<$<CXX_COMPILER_ID:Clang>:-fsized-deallocation>
+    )
 endif()
 
 create_target_directory_groups(hid_core)

src/input_common/CMakeLists.txt

@@ -44,7 +44,9 @@ if (MSVC)
         /we4800 # Implicit conversion from 'type' to bool. Possible information loss
     )
 else()
-    target_compile_options(input_common PRIVATE $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>)
+    target_compile_options(input_common PRIVATE
+        -Werror=conversion
+    )
 endif()
 
 if (ANDROID)

src/shader_recompiler/CMakeLists.txt

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 # SPDX-FileCopyrightText: 2018 yuzu Emulator Project
@@ -253,7 +253,8 @@ if (MSVC)
     )
 else()
     target_compile_options(shader_recompiler PRIVATE
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>
+        -Werror=conversion
+
         # Bracket depth determines maximum size of a fold expression in Clang since 9c9974c3ccb6.
         # And this in turns limits the size of a std::array.
         $<$<CXX_COMPILER_ID:Clang>:-fbracket-depth=1024>

src/tests/CMakeLists.txt

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 # SPDX-FileCopyrightText: 2018 yuzu Emulator Project
@@ -32,8 +32,8 @@ add_test(NAME tests COMMAND tests)
 # needed for vma
 if (NOT MSVC)
     target_compile_options(tests PRIVATE
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-conversion>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-unused-variable>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-unused-parameter>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-missing-field-initializers>)
+        -Wno-conversion
+        -Wno-unused-variable
+        -Wno-unused-parameter
+        -Wno-missing-field-initializers)
 endif()

src/video_core/CMakeLists.txt

@@ -363,14 +363,14 @@ else()
     if (APPLE)
         # error: declaration shadows a typedef in 'interval_base_set<SubType, DomainT, Compare, Interval, Alloc>'
         # error: implicit conversion loses integer precision: 'int' to 'boost::icl::bound_type' (aka 'unsigned char')
-        target_compile_options(video_core PRIVATE
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-shadow>
-            $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-unused-local-typedef>)
+        target_compile_options(video_core PRIVATE -Wno-shadow -Wno-unused-local-typedef)
     else()
-        target_compile_options(video_core PRIVATE $<$<COMPILE_LANGUAGE:C,CXX>:-Werror=conversion>)
+        target_compile_options(video_core PRIVATE -Werror=conversion)
     endif()
 
-    target_compile_options(video_core PRIVATE $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-sign-conversion>)
+    target_compile_options(video_core PRIVATE
+        -Wno-sign-conversion
+    )
 
     # xbyak
     set_source_files_properties(macro/macro_jit_x64.cpp PROPERTIES COMPILE_OPTIONS "-Wno-conversion;-Wno-shadow")

src/yuzu/CMakeLists.txt

@@ -443,10 +443,10 @@ endif()
 if (NOT MSVC AND (APPLE OR NOT YUZU_STATIC_BUILD))
     # needed for vma
     target_compile_options(yuzu PRIVATE
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-conversion>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-unused-variable>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-unused-parameter>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-missing-field-initializers>)
+        -Wno-conversion
+        -Wno-unused-variable
+        -Wno-unused-parameter
+        -Wno-missing-field-initializers)
 endif()
 
 # Remember that the linker is incredibly stupid.

src/yuzu/user_data_migration.h

@@ -8,7 +8,7 @@
 #pragma once
 
 #include <QMainWindow>
-#include "yuzu/migration_worker.h"
+#include "../yuzu/migration_worker.h"
 
 // TODO(crueter): Quick implementation
 class UserDataMigrator {

src/yuzu_cmd/CMakeLists.txt

@@ -1,4 +1,4 @@
-# SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+# SPDX-FileCopyrightText: Copyright 2025 Eden Emulator Project
 # SPDX-License-Identifier: GPL-3.0-or-later
 
 # SPDX-FileCopyrightText: 2018 yuzu Emulator Project
@@ -60,8 +60,8 @@ create_target_directory_groups(yuzu-cmd)
 # needed for vma
 if (NOT MSVC)
     target_compile_options(yuzu-cmd PRIVATE
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-conversion>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-unused-variable>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-unused-parameter>
-        $<$<COMPILE_LANGUAGE:C,CXX>:-Wno-missing-field-initializers>)
+        -Wno-conversion
+        -Wno-unused-variable
+        -Wno-unused-parameter
+        -Wno-missing-field-initializers)
 endif()