[dynarmic] backport WAITPKG based spinlocks

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

.ci/windows/install-msvc.ps1

@@ -10,7 +10,7 @@ if (-not ([bool](net session 2>$null))) {
 }
 
 $VSVer = "17"
-$ExeFile = "vs_BuildTools.exe"
+$ExeFile = "vs_community.exe"
 $Uri = "https://aka.ms/vs/$VSVer/release/$ExeFile"
 $Destination = "./$ExeFile"
 
@@ -19,21 +19,39 @@ $WebClient = New-Object System.Net.WebClient
 $WebClient.DownloadFile($Uri, $Destination)
 Write-Host "Finished downloading $ExeFile"
 
-$VSROOT = "C:/VSBuildTools/$VSVer"
 $Arguments = @(
-    "--installPath `"$VSROOT`"",                               # set custom installation path
-    "--quiet",                                                  # suppress UI
-    "--wait",                                                   # wait for installation to complete
-    "--norestart",                                              # prevent automatic restart
-    "--add Microsoft.VisualStudio.Workload.VCTools",            # add C++ build tools workload
-    "--add Microsoft.VisualStudio.Component.VC.Tools.x86.x64",  # add core x86/x64 C++ tools
-    "--add Microsoft.VisualStudio.Component.Windows10SDK.19041" # add specific Windows SDK
+    "--quiet",                                                  # Suppress installer UI
+    "--wait",                                                   # Wait for installation to complete
+    "--norestart",                                              # Prevent automatic restart
+    "--force",                                                  # Force installation even if components are already installed
+    "--add Microsoft.VisualStudio.Workload.NativeDesktop",      # Desktop development with C++
+    "--add Microsoft.VisualStudio.Component.VC.Tools.x86.x64",  # Core C++ compiler/tools for x86/x64
+    "--add Microsoft.VisualStudio.Component.Windows11SDK.26100",# Windows 11 SDK (26100)
+    "--add Microsoft.VisualStudio.Component.Windows10SDK.19041",# Windows 10 SDK (19041)
+    "--add Microsoft.VisualStudio.Component.VC.Llvm.Clang",     # LLVM Clang compiler
+    "--add Microsoft.VisualStudio.Component.VC.Llvm.ClangToolset", # LLVM Clang integration toolset
+    "--add Microsoft.VisualStudio.Component.Windows11SDK.22621",# Windows 11 SDK (22621)
+    "--add Microsoft.VisualStudio.Component.VC.CMake.Project",  # CMake project support
+    "--add Microsoft.VisualStudio.ComponentGroup.VC.Tools.142.x86.x64", # VC++ 14.2 toolset
+    "--add Microsoft.VisualStudio.ComponentGroup.NativeDesktop.Llvm.Clang" # LLVM Clang for native desktop
 )
 
 Write-Host "Installing Visual Studio Build Tools"
-$InstallProcess = Start-Process -FilePath $Destination -NoNewWindow -PassThru -Wait -ArgumentList $Arguments
-$ExitCode = $InstallProcess.ExitCode
+$InstallProcess = Start-Process -FilePath $Destination -NoNewWindow -PassThru -ArgumentList $Arguments
 
+# Spinner while installing
+$Spinner = "|/-\"
+$i = 0
+while (-not $InstallProcess.HasExited) {
+    Write-Host -NoNewline ("`rInstalling... " + $Spinner[$i % $Spinner.Length])
+    Start-Sleep -Milliseconds 250
+    $i++
+}
+
+# Clear spinner line
+Write-Host "`rSetup completed!           "
+
+$ExitCode = $InstallProcess.ExitCode
 if ($ExitCode -ne 0) {
     Write-Host "Error installing Visual Studio Build Tools (Error: $ExitCode)"
     Exit $ExitCode

CMakeLists.txt

@@ -895,13 +895,13 @@ if (MSVC AND CXX_CLANG)
 endif()
 
 if (YUZU_USE_FASTER_LD)
+    # fallback if everything fails (bfd)
+    set(LINKER bfd)
     # clang should always use lld
     find_program(LLD lld)
-
     if (LLD)
         set(LINKER lld)
     endif()
-
     # GNU appears to work better with mold
     # TODO: mold has been slow lately, see if better options exist (search for gold?)
     if (CXX_GCC)
@@ -910,7 +910,6 @@ if (YUZU_USE_FASTER_LD)
             set(LINKER mold)
         endif()
     endif()
-
     message(NOTICE "Selecting ${LINKER} as linker")
     add_link_options("-fuse-ld=${LINKER}")
 endif()

docs/Deps.md

@@ -4,8 +4,8 @@ To build Eden, you MUST have a C++ compiler.
 * On Linux, this is usually [GCC](https://gcc.gnu.org/) 11+ or [Clang](https://clang.llvm.org/) v14+
   - GCC 12 also requires Clang 14+
 * On Windows, this is either:
-  - **[MSVC](https://visualstudio.microsoft.com/downloads/)**,
-    * *A convenience script to install the **minimal** version (Visual Build Tools) is provided in `.ci/windows/install-msvc.ps1`*
+  - **[MSVC](https://visualstudio.microsoft.com/downloads/)** (you should select *Community* option),
+    * *A convenience script to install the Visual Community Studio 2022 with necessary tools is provided in `.ci/windows/install-msvc.ps1`*
   - clang-cl - can be downloaded from the MSVC installer,
   - or **[MSYS2](https://www.msys2.org)**
 * On macOS, this is Apple Clang
@@ -211,4 +211,4 @@ Then install the libraries: `sudo pkg install qt6 boost glslang libzip library/l
 
 ## All Done
 
-You may now return to the **[root build guide](Build.md)**.
+You may now return to the **[root build guide](Build.md)**.

src/common/settings.h

@@ -178,7 +178,7 @@ struct Values {
     SwitchableSetting<std::string> audio_input_device_id{
                                                          linkage, "auto", "input_device", Category::Audio, Specialization::RuntimeList};
     SwitchableSetting<AudioMode, true> sound_index{
-                                                   linkage,       AudioMode::Stereo,     AudioMode::Mono,         AudioMode::Surround,
+                                                   linkage,       AudioMode::Stereo,
                                                    "sound_index", Category::SystemAudio, Specialization::Default, true,
                                                    true};
     SwitchableSetting<u8, true> volume{linkage,
@@ -199,8 +199,6 @@ struct Values {
     SwitchableSetting<bool> use_multi_core{linkage, true, "use_multi_core", Category::Core};
     SwitchableSetting<MemoryLayout, true> memory_layout_mode{linkage,
                                                              MemoryLayout::Memory_4Gb,
-                                                             MemoryLayout::Memory_4Gb,
-                                                             MemoryLayout::Memory_12Gb,
                                                              "memory_layout_mode",
                                                              Category::Core,
                                                              Specialization::Default,
@@ -240,9 +238,8 @@ struct Values {
 #endif
                                                     "cpu_backend",
                                                     Category::Cpu};
-    SwitchableSetting<CpuAccuracy, true> cpu_accuracy{linkage,           CpuAccuracy::Auto,
-                                                      CpuAccuracy::Auto, CpuAccuracy::Paranoid,
-                                                      "cpu_accuracy",    Category::Cpu};
+    SwitchableSetting<CpuAccuracy, true> cpu_accuracy{linkage, CpuAccuracy::Auto,
+                                                      "cpu_accuracy", Category::Cpu};
 
     SwitchableSetting<bool> use_fast_cpu_time{linkage,
                                               false,
@@ -324,10 +321,10 @@ struct Values {
 
     // Renderer
     SwitchableSetting<RendererBackend, true> renderer_backend{
-                                                              linkage,   RendererBackend::Vulkan, RendererBackend::OpenGL, RendererBackend::Null,
+                                                              linkage, RendererBackend::Vulkan,
                                                               "backend", Category::Renderer};
     SwitchableSetting<ShaderBackend, true> shader_backend{
-                                                          linkage,          ShaderBackend::SpirV, ShaderBackend::Glsl,        ShaderBackend::SpirV,
+                                                          linkage, ShaderBackend::SpirV,
                                                           "shader_backend", Category::Renderer,  Specialization::RuntimeList};
     SwitchableSetting<int> vulkan_device{linkage, 0, "vulkan_device", Category::Renderer,
                                          Specialization::RuntimeList};
@@ -342,8 +339,6 @@ struct Values {
                                                   Category::Renderer};
     SwitchableSetting<SpirvOptimizeMode, true> optimize_spirv_output{linkage,
                                                                      SpirvOptimizeMode::Never,
-                                                                     SpirvOptimizeMode::Never,
-                                                                     SpirvOptimizeMode::Always,
                                                                      "optimize_spirv_output",
                                                                      Category::Renderer};
     SwitchableSetting<bool> use_asynchronous_gpu_emulation{
@@ -354,12 +349,10 @@ struct Values {
 #else
                                                             AstcDecodeMode::Gpu,
 #endif
-                                                            AstcDecodeMode::Cpu,
-                                                            AstcDecodeMode::CpuAsynchronous,
                                                             "accelerate_astc",
                                                             Category::Renderer};
     SwitchableSetting<VSyncMode, true> vsync_mode{
-                                                  linkage,     VSyncMode::Fifo,    VSyncMode::Immediate,        VSyncMode::FifoRelaxed,
+                                                  linkage,     VSyncMode::Fifo,
                                                   "use_vsync", Category::Renderer, Specialization::RuntimeList, true,
                                                   true};
     SwitchableSetting<NvdecEmulation> nvdec_emulation{linkage, NvdecEmulation::Gpu,
@@ -372,8 +365,6 @@ struct Values {
 #else
                                                             FullscreenMode::Exclusive,
 #endif
-                                                            FullscreenMode::Borderless,
-                                                            FullscreenMode::Exclusive,
                                                             "fullscreen_mode",
                                                             Category::Renderer,
                                                             Specialization::Default,
@@ -381,8 +372,6 @@ struct Values {
                                                             true};
     SwitchableSetting<AspectRatio, true> aspect_ratio{linkage,
                                                       AspectRatio::R16_9,
-                                                      AspectRatio::R16_9,
-                                                      AspectRatio::Stretch,
                                                       "aspect_ratio",
                                                       Category::Renderer,
                                                       Specialization::Default,
@@ -430,8 +419,6 @@ struct Values {
 #else
                                                       GpuAccuracy::High,
 #endif
-                                                      GpuAccuracy::Normal,
-                                                      GpuAccuracy::Extreme,
                                                       "gpu_accuracy",
                                                       Category::RendererAdvanced,
                                                       Specialization::Default,
@@ -442,8 +429,6 @@ struct Values {
 
     SwitchableSetting<DmaAccuracy, true> dma_accuracy{linkage,
                                                       DmaAccuracy::Default,
-                                                      DmaAccuracy::Default,
-                                                      DmaAccuracy::Safe,
                                                       "dma_accuracy",
                                                       Category::RendererAdvanced,
                                                       Specialization::Default,
@@ -456,20 +441,14 @@ struct Values {
 #else
                                                            AnisotropyMode::Automatic,
 #endif
-                                                           AnisotropyMode::Automatic,
-                                                           AnisotropyMode::X16,
                                                            "max_anisotropy",
                                                            Category::RendererAdvanced};
     SwitchableSetting<AstcRecompression, true> astc_recompression{linkage,
                                                                   AstcRecompression::Uncompressed,
-                                                                  AstcRecompression::Uncompressed,
-                                                                  AstcRecompression::Bc3,
                                                                   "astc_recompression",
                                                                   Category::RendererAdvanced};
     SwitchableSetting<VramUsageMode, true> vram_usage_mode{linkage,
                                                            VramUsageMode::Conservative,
-                                                           VramUsageMode::Conservative,
-                                                           VramUsageMode::Aggressive,
                                                            "vram_usage_mode",
                                                            Category::RendererAdvanced};
     SwitchableSetting<bool> skip_cpu_inner_invalidation{linkage,
@@ -595,14 +574,10 @@ struct Values {
     // System
     SwitchableSetting<Language, true> language_index{linkage,
                                                      Language::EnglishAmerican,
-                                                     Language::Japanese,
-                                                     Language::Serbian,
                                                      "language_index",
                                                      Category::System};
-    SwitchableSetting<Region, true> region_index{linkage,        Region::Usa,    Region::Japan,
-                                                 Region::Taiwan, "region_index", Category::System};
-    SwitchableSetting<TimeZone, true> time_zone_index{linkage,           TimeZone::Auto,
-                                                      TimeZone::Auto,    TimeZone::Zulu,
+    SwitchableSetting<Region, true> region_index{linkage, Region::Usa, "region_index", Category::System};
+    SwitchableSetting<TimeZone, true> time_zone_index{linkage, TimeZone::Auto,
                                                       "time_zone_index", Category::System};
     // Measured in seconds since epoch
     SwitchableSetting<bool> custom_rtc_enabled{

src/common/settings_enums.h

@@ -10,6 +10,7 @@
 #pragma once
 
 #include <string>
+#include <string_view>
 #include <utility>
 #include <vector>
 #include "common/common_types.h"
@@ -18,8 +19,10 @@ namespace Settings {
 
 template <typename T>
 struct EnumMetadata {
-    static std::vector<std::pair<std::string, T>> Canonicalizations();
+    static std::vector<std::pair<std::string_view, T>> Canonicalizations();
     static u32 Index();
+    static constexpr T GetFirst();
+    static constexpr T GetLast();
 };
 
 #define PAIR_45(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_46(N, __VA_ARGS__))
@@ -69,138 +72,101 @@ struct EnumMetadata {
 #define PAIR_1(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_2(N, __VA_ARGS__))
 #define PAIR(N, X, ...) {#X, N::X} __VA_OPT__(, PAIR_1(N, __VA_ARGS__))
 
-#define ENUM(NAME, ...)                                                                            \
-    enum class NAME : u32 { __VA_ARGS__ };                                                         \
-    template <>                                                                                    \
-    inline std::vector<std::pair<std::string, NAME>> EnumMetadata<NAME>::Canonicalizations() {     \
-        return {PAIR(NAME, __VA_ARGS__)};                                                          \
-    }                                                                                              \
-    template <>                                                                                    \
-    inline u32 EnumMetadata<NAME>::Index() {                                                       \
-        return __COUNTER__;                                                                        \
+#define PP_HEAD(A, ...) A
+
+#define ENUM(NAME, ...) \
+    enum class NAME : u32 { __VA_ARGS__ }; \
+    template<> inline std::vector<std::pair<std::string_view, NAME>> EnumMetadata<NAME>::Canonicalizations() { \
+        return {PAIR(NAME, __VA_ARGS__)}; \
+    } \
+    template<> inline u32 EnumMetadata<NAME>::Index() { \
+        return __COUNTER__; \
+    } \
+    template<> inline constexpr NAME EnumMetadata<NAME>::GetFirst() { \
+        return NAME::PP_HEAD(__VA_ARGS__); \
+    } \
+    template<> inline constexpr NAME EnumMetadata<NAME>::GetLast() { \
+        return (std::vector<std::pair<std::string_view, NAME>>{PAIR(NAME, __VA_ARGS__)}).back().second; \
     }
 
 // AudioEngine must be specified discretely due to having existing but slightly different
 // canonicalizations
 // TODO (lat9nq): Remove explicit definition of AudioEngine/sink_id
-enum class AudioEngine : u32 {
-    Auto,
-    Cubeb,
-    Sdl2,
-    Null,
-    Oboe,
-};
-
-template <>
-inline std::vector<std::pair<std::string, AudioEngine>>
-EnumMetadata<AudioEngine>::Canonicalizations() {
+enum class AudioEngine : u32 { Auto, Cubeb, Sdl2, Null, Oboe, };
+template<>
+inline std::vector<std::pair<std::string_view, AudioEngine>> EnumMetadata<AudioEngine>::Canonicalizations() {
     return {
         {"auto", AudioEngine::Auto}, {"cubeb", AudioEngine::Cubeb}, {"sdl2", AudioEngine::Sdl2},
         {"null", AudioEngine::Null}, {"oboe", AudioEngine::Oboe},
     };
 }
-
-template <>
+/// @brief This is just a sufficiently large number that is more than the number of other enums declared here
+template<>
 inline u32 EnumMetadata<AudioEngine>::Index() {
-    // This is just a sufficiently large number that is more than the number of other enums declared
-    // here
     return 100;
 }
+template<>
+inline constexpr AudioEngine EnumMetadata<AudioEngine>::GetFirst() {
+    return AudioEngine::Auto;
+}
+template<>
+inline constexpr AudioEngine EnumMetadata<AudioEngine>::GetLast() {
+    return AudioEngine::Oboe;
+}
 
 ENUM(AudioMode, Mono, Stereo, Surround);
+static_assert(EnumMetadata<AudioMode>::GetFirst() == AudioMode::Mono);
+static_assert(EnumMetadata<AudioMode>::GetLast() == AudioMode::Surround);
 
 ENUM(Language, Japanese, EnglishAmerican, French, German, Italian, Spanish, Chinese, Korean, Dutch,
      Portuguese, Russian, Taiwanese, EnglishBritish, FrenchCanadian, SpanishLatin,
      ChineseSimplified, ChineseTraditional, PortugueseBrazilian, Serbian);
-
 ENUM(Region, Japan, Usa, Europe, Australia, China, Korea, Taiwan);
-
 ENUM(TimeZone, Auto, Default, Cet, Cst6Cdt, Cuba, Eet, Egypt, Eire, Est, Est5Edt, Gb, GbEire, Gmt,
-     GmtPlusZero, GmtMinusZero, GmtZero, Greenwich, Hongkong, Hst, Iceland, Iran, Israel, Jamaica,
-     Japan, Kwajalein, Libya, Met, Mst, Mst7Mdt, Navajo, Nz, NzChat, Poland, Portugal, Prc, Pst8Pdt,
-     Roc, Rok, Singapore, Turkey, Uct, Universal, Utc, WSu, Wet, Zulu);
-
+    GmtPlusZero, GmtMinusZero, GmtZero, Greenwich, Hongkong, Hst, Iceland, Iran, Israel, Jamaica,
+    Japan, Kwajalein, Libya, Met, Mst, Mst7Mdt, Navajo, Nz, NzChat, Poland, Portugal, Prc, Pst8Pdt,
+    Roc, Rok, Singapore, Turkey, Uct, Universal, Utc, WSu, Wet, Zulu);
 ENUM(AnisotropyMode, Automatic, Default, X2, X4, X8, X16);
-
 ENUM(AstcDecodeMode, Cpu, Gpu, CpuAsynchronous);
-
 ENUM(AstcRecompression, Uncompressed, Bc1, Bc3);
-
 ENUM(VSyncMode, Immediate, Mailbox, Fifo, FifoRelaxed);
-
 ENUM(VramUsageMode, Conservative, Aggressive);
-
 ENUM(RendererBackend, OpenGL, Vulkan, Null);
-
 ENUM(ShaderBackend, Glsl, Glasm, SpirV);
-
 ENUM(GpuAccuracy, Normal, High, Extreme);
-
 ENUM(DmaAccuracy, Default, Unsafe, Safe);
-
 ENUM(CpuBackend, Dynarmic, Nce);
-
 ENUM(CpuAccuracy, Auto, Accurate, Unsafe, Paranoid);
-
 ENUM(CpuClock, Boost, Fast)
-
 ENUM(MemoryLayout, Memory_4Gb, Memory_6Gb, Memory_8Gb, Memory_10Gb, Memory_12Gb);
-
 ENUM(ConfirmStop, Ask_Always, Ask_Based_On_Game, Ask_Never);
-
 ENUM(FullscreenMode, Borderless, Exclusive);
-
 ENUM(NvdecEmulation, Off, Cpu, Gpu);
-
-ENUM(ResolutionSetup,
-     Res1_4X,
-     Res1_2X,
-     Res3_4X,
-     Res1X,
-     Res3_2X,
-     Res2X,
-     Res3X,
-     Res4X,
-     Res5X,
-     Res6X,
-     Res7X,
-     Res8X);
-
+ENUM(ResolutionSetup, Res1_4X, Res1_2X, Res3_4X, Res1X, Res3_2X, Res2X, Res3X, Res4X, Res5X, Res6X, Res7X, Res8X);
 ENUM(ScalingFilter, NearestNeighbor, Bilinear, Bicubic, Spline1, Gaussian, Lanczos, ScaleForce, Fsr, Area, MaxEnum);
-
 ENUM(AntiAliasing, None, Fxaa, Smaa, MaxEnum);
-
 ENUM(AspectRatio, R16_9, R4_3, R21_9, R16_10, Stretch);
-
 ENUM(ConsoleMode, Handheld, Docked);
-
 ENUM(AppletMode, HLE, LLE);
-
 ENUM(SpirvOptimizeMode, Never, OnLoad, Always);
-
 ENUM(GpuOverclock, Low, Medium, High)
-
 ENUM(TemperatureUnits, Celsius, Fahrenheit)
 
 template <typename Type>
-inline std::string CanonicalizeEnum(Type id) {
+inline std::string_view CanonicalizeEnum(Type id) {
     const auto group = EnumMetadata<Type>::Canonicalizations();
-    for (auto& [name, value] : group) {
-        if (value == id) {
+    for (auto& [name, value] : group)
+        if (value == id)
             return name;
-        }
-    }
     return "unknown";
 }
 
 template <typename Type>
 inline Type ToEnum(const std::string& canonicalization) {
     const auto group = EnumMetadata<Type>::Canonicalizations();
-    for (auto& [name, value] : group) {
-        if (name == canonicalization) {
+    for (auto& [name, value] : group)
+        if (name == canonicalization)
             return value;
-        }
-    }
     return {};
 }
 } // namespace Settings

src/common/settings_setting.h

@@ -72,10 +72,17 @@ public:
                      u32 specialization_ = Specialization::Default, bool save_ = true,
                      bool runtime_modifiable_ = false, BasicSetting* other_setting_ = nullptr)
         requires(ranged)
-        : BasicSetting(linkage, name, category_, save_, runtime_modifiable_, specialization_,
-                       other_setting_),
+        : BasicSetting(linkage, name, category_, save_, runtime_modifiable_, specialization_, other_setting_),
           value{default_val}, default_value{default_val}, maximum{max_val}, minimum{min_val} {}
 
+    explicit Setting(Linkage& linkage, const Type& default_val,
+                     const std::string& name, Category category_,
+                     u32 specialization_ = Specialization::Default, bool save_ = true,
+                     bool runtime_modifiable_ = false, BasicSetting* other_setting_ = nullptr)
+        requires(ranged && std::is_enum_v<Type>)
+        : BasicSetting(linkage, name, category_, save_, runtime_modifiable_, specialization_, other_setting_),
+          value{default_val}, default_value{default_val}, maximum{EnumMetadata<Type>::GetLast()}, minimum{EnumMetadata<Type>::GetFirst()} {}
+
     /**
      *  Returns a reference to the setting's value.
      *
@@ -119,9 +126,6 @@ protected:
             return value_.has_value() ? std::to_string(*value_) : "none";
         } else if constexpr (std::is_same_v<Type, bool>) {
             return value_ ? "true" : "false";
-        } else if constexpr (std::is_same_v<Type, AudioEngine>) {
-            // Compatibility with old AudioEngine setting being a string
-            return CanonicalizeEnum(value_);
         } else if constexpr (std::is_floating_point_v<Type>) {
             return fmt::format("{:f}", value_);
         } else if constexpr (std::is_enum_v<Type>) {
@@ -207,7 +211,7 @@ public:
 
     [[nodiscard]] std::string Canonicalize() const override final {
         if constexpr (std::is_enum_v<Type>) {
-            return CanonicalizeEnum(this->GetValue());
+            return std::string{CanonicalizeEnum(this->GetValue())};
         } else {
             return ToString(this->GetValue());
         }
@@ -288,41 +292,32 @@ public:
      * @param other_setting_ A second Setting to associate to this one in metadata
      */
     template <typename T = BasicSetting>
-    explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const std::string& name,
-                               Category category_, u32 specialization_ = Specialization::Default,
-                               bool save_ = true, bool runtime_modifiable_ = false,
-                               typename std::enable_if<!ranged, T*>::type other_setting_ = nullptr)
-        : Setting<Type, false>{
-              linkage, default_val,         name,          category_, specialization_,
-              save_,   runtime_modifiable_, other_setting_} {
+    explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const std::string& name, Category category_, u32 specialization_ = Specialization::Default, bool save_ = true, bool runtime_modifiable_ = false, T* other_setting_ = nullptr) requires(!ranged)
+        : Setting<Type, false>{ linkage, default_val, name, category_, specialization_, save_, runtime_modifiable_, other_setting_} {
         linkage.restore_functions.emplace_back([this]() { this->SetGlobal(true); });
     }
     virtual ~SwitchableSetting() = default;
 
-    /**
-     * Sets a default value, minimum value, maximum value, and label.
-     *
-     * @param linkage Setting registry
-     * @param default_val Initial value of the setting, and default value of the setting
-     * @param min_val Sets the minimum allowed value of the setting
-     * @param max_val Sets the maximum allowed value of the setting
-     * @param name Label for the setting
-     * @param category_ Category of the setting AKA INI group
-     * @param specialization_ Suggestion for how frontend implementations represent this in a config
-     * @param save_ Suggests that this should or should not be saved to a frontend config file
-     * @param runtime_modifiable_ Suggests whether this is modifiable while a guest is loaded
-     * @param other_setting_ A second Setting to associate to this one in metadata
-     */
+    /// @brief Sets a default value, minimum value, maximum value, and label.
+    /// @param linkage Setting registry
+    /// @param default_val Initial value of the setting, and default value of the setting
+    /// @param min_val Sets the minimum allowed value of the setting
+    /// @param max_val Sets the maximum allowed value of the setting
+    /// @param name Label for the setting
+    /// @param category_ Category of the setting AKA INI group
+    /// @param specialization_ Suggestion for how frontend implementations represent this in a config
+    /// @param save_ Suggests that this should or should not be saved to a frontend config file
+    /// @param runtime_modifiable_ Suggests whether this is modifiable while a guest is loaded
+    /// @param other_setting_ A second Setting to associate to this one in metadata
     template <typename T = BasicSetting>
-    explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const Type& min_val,
-                               const Type& max_val, const std::string& name, Category category_,
-                               u32 specialization_ = Specialization::Default, bool save_ = true,
-                               bool runtime_modifiable_ = false,
-                               typename std::enable_if<ranged, T*>::type other_setting_ = nullptr)
-        : Setting<Type, true>{linkage,         default_val, min_val,
-                              max_val,         name,        category_,
-                              specialization_, save_,       runtime_modifiable_,
-                              other_setting_} {
+    explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const Type& min_val, const Type& max_val, const std::string& name, Category category_, u32 specialization_ = Specialization::Default, bool save_ = true, bool runtime_modifiable_ = false, T* other_setting_ = nullptr) requires(ranged)
+        : Setting<Type, true>{linkage, default_val, min_val, max_val, name, category_, specialization_, save_, runtime_modifiable_, other_setting_} {
+        linkage.restore_functions.emplace_back([this]() { this->SetGlobal(true); });
+    }
+
+    template <typename T = BasicSetting>
+    explicit SwitchableSetting(Linkage& linkage, const Type& default_val, const std::string& name, Category category_, u32 specialization_ = Specialization::Default, bool save_ = true, bool runtime_modifiable_ = false, T* other_setting_ = nullptr) requires(ranged)
+        : Setting<Type, true>{linkage, default_val, EnumMetadata<Type>::GetFirst(), EnumMetadata<Type>::GetLast(), name, category_, specialization_, save_, runtime_modifiable_, other_setting_} {
         linkage.restore_functions.emplace_back([this]() { this->SetGlobal(true); });
     }
 

src/dynarmic/tests/CMakeLists.txt

@@ -135,6 +135,8 @@ target_include_directories(dynarmic_tests PRIVATE . ../src)
 target_compile_options(dynarmic_tests PRIVATE ${DYNARMIC_CXX_FLAGS})
 target_compile_definitions(dynarmic_tests PRIVATE FMT_USE_USER_DEFINED_LITERALS=1)
 
-target_compile_options(dynarmic_tests PRIVATE -mavx2)
+if ("x86_64" IN_LIST ARCHITECTURE)
+    target_compile_options(dynarmic_tests PRIVATE -mavx2)
+endif()
 
 add_test(dynarmic_tests dynarmic_tests --durations yes)

src/yuzu/Info.plist

@@ -45,9 +45,31 @@ SPDX-License-Identifier: GPL-2.0-or-later
     <true/>
     <key>NSHumanReadableCopyright</key>
     <string></string>
+    <!-- Fixed -->
+    <key>LSApplicationCategoryType</key>
+    <string>public.app-category.games</string>
+    <key>CFBundleDocumentTypes</key>
+    <array>
+        <dict>
+            <key>CFBundleTypeExtensions</key>
+            <array>
+                <string>nsp</string>
+                <string>xci</string>
+                <string>nro</string>
+            </array>
+            <key>CFBundleTypeName</key>
+            <string>Switch File</string>
+            <key>CFBundleTypeRole</key>
+            <string>Viewer</string>
+            <key>LSHandlerRank</key>
+            <string>Default</string>
+        </dict>
+    </array>
     <key>NSPrincipalClass</key>
     <string>NSApplication</string>
     <key>NSHighResolutionCapable</key>
     <string>True</string>
+    <key>UIDesignRequiresCompatibility</key>
+    <true/> <!-- https://bugreports.qt.io/browse/QTBUG-138942 -->
 </dict>
 </plist>

src/yuzu/configuration/configure_audio.cpp

@@ -270,10 +270,8 @@ void ConfigureAudio::UpdateAudioDevices(int sink_index) {
 void ConfigureAudio::InitializeAudioSinkComboBox() {
     sink_combo_box->clear();
     sink_combo_box->addItem(QString::fromUtf8(AudioCore::Sink::auto_device_name));
-
-    for (const auto& id : AudioCore::Sink::GetSinkIDs()) {
-        sink_combo_box->addItem(QString::fromStdString(Settings::CanonicalizeEnum(id)));
-    }
+    for (const auto& id : AudioCore::Sink::GetSinkIDs())
+        sink_combo_box->addItem(QString::fromStdString(std::string{Settings::CanonicalizeEnum(id)}));
 }
 
 void ConfigureAudio::RetranslateUI() {

src/yuzu/configuration/shared_widget.h

@@ -13,6 +13,7 @@
 #include <QString>
 #include <QStringLiteral>
 #include <QWidget>
+#include <QObject>
 #include <qobjectdefs.h>
 #include "qt_common/shared_translation.h"
 

src/yuzu/game_list.h

@@ -58,11 +58,11 @@ class GameList : public QWidget {
 public:
     enum {
         COLUMN_NAME,
-        COLUMN_COMPATIBILITY,
-        COLUMN_ADD_ONS,
         COLUMN_FILE_TYPE,
         COLUMN_SIZE,
         COLUMN_PLAY_TIME,
+        COLUMN_ADD_ONS,
+        COLUMN_COMPATIBILITY,
         COLUMN_COUNT, // Number of columns
     };
 

src/yuzu/game_list_worker.cpp

@@ -204,36 +204,24 @@ QList<QStandardItem*> MakeGameListEntry(const std::string& path,
                                         const PlayTime::PlayTimeManager& play_time_manager,
                                         const FileSys::PatchManager& patch)
 {
-    const auto it = FindMatchingCompatibilityEntry(compatibility_list, program_id);
+    auto const it = FindMatchingCompatibilityEntry(compatibility_list, program_id);
+    // The game list uses 99 as compatibility number for untested games
+    QString compatibility = it != compatibility_list.end() ? it->second.first : QStringLiteral("99");
 
-    // The game list uses this as compatibility number for untested games
-    QString compatibility{QStringLiteral("99")};
-    if (it != compatibility_list.end()) {
-        compatibility = it->second.first;
-    }
+    auto const file_type = loader.GetFileType();
+    auto const file_type_string = QString::fromStdString(Loader::GetFileTypeString(file_type));
 
-    const auto file_type = loader.GetFileType();
-    const auto file_type_string = QString::fromStdString(Loader::GetFileTypeString(file_type));
-
-    QList<QStandardItem*> list{
-        new GameListItemPath(FormatGameName(path), icon, QString::fromStdString(name),
-                             file_type_string, program_id),
-        new GameListItemCompat(compatibility),
+    QString patch_versions = GetGameListCachedObject(fmt::format("{:016X}", patch.GetTitleID()), "pv.txt", [&patch, &loader] {
+        return FormatPatchNameVersions(patch, loader, loader.IsRomFSUpdatable());
+    });
+    return QList<QStandardItem*>{
+        new GameListItemPath(FormatGameName(path), icon, QString::fromStdString(name), file_type_string, program_id),
         new GameListItem(file_type_string),
         new GameListItemSize(size),
         new GameListItemPlayTime(play_time_manager.GetPlayTime(program_id)),
+        new GameListItem(patch_versions),
+        new GameListItemCompat(compatibility),
     };
-
-    QString patch_versions;
-
-    patch_versions = GetGameListCachedObject(
-        fmt::format("{:016X}", patch.GetTitleID()), "pv.txt", [&patch, &loader] {
-            return FormatPatchNameVersions(patch, loader, loader.IsRomFSUpdatable());
-        });
-
-    list.insert(2, new GameListItem(patch_versions));
-
-    return list;
 }
 } // Anonymous namespace