BufferCache: Supports access to out-of-bounds storage buffers.

BufferCache: Supports access to out-of-bounds SSBOs.

src/common/settings.cpp

@@ -167,7 +167,6 @@ void RestoreGlobalState(bool is_powered_on) {
 
     // Core
     values.use_multi_core.SetGlobal(true);
-    values.use_extended_memory_layout.SetGlobal(true);
 
     // CPU
     values.cpu_accuracy.SetGlobal(true);
@@ -176,7 +175,6 @@ void RestoreGlobalState(bool is_powered_on) {
     values.cpuopt_unsafe_ignore_standard_fpcr.SetGlobal(true);
     values.cpuopt_unsafe_inaccurate_nan.SetGlobal(true);
     values.cpuopt_unsafe_fastmem_check.SetGlobal(true);
-    values.cpuopt_unsafe_ignore_global_monitor.SetGlobal(true);
 
     // Renderer
     values.renderer_backend.SetGlobal(true);

src/common/settings.h

@@ -466,7 +466,6 @@ struct Values {
 
     // Core
     Setting<bool> use_multi_core{true, "use_multi_core"};
-    Setting<bool> use_extended_memory_layout{false, "use_extended_memory_layout"};
 
     // Cpu
     RangedSetting<CPUAccuracy> cpu_accuracy{CPUAccuracy::Auto, CPUAccuracy::Auto,
@@ -484,15 +483,12 @@ struct Values {
     BasicSetting<bool> cpuopt_misc_ir{true, "cpuopt_misc_ir"};
     BasicSetting<bool> cpuopt_reduce_misalign_checks{true, "cpuopt_reduce_misalign_checks"};
     BasicSetting<bool> cpuopt_fastmem{true, "cpuopt_fastmem"};
-    BasicSetting<bool> cpuopt_fastmem_exclusives{true, "cpuopt_fastmem_exclusives"};
-    BasicSetting<bool> cpuopt_recompile_exclusives{true, "cpuopt_recompile_exclusives"};
 
     Setting<bool> cpuopt_unsafe_unfuse_fma{true, "cpuopt_unsafe_unfuse_fma"};
     Setting<bool> cpuopt_unsafe_reduce_fp_error{true, "cpuopt_unsafe_reduce_fp_error"};
     Setting<bool> cpuopt_unsafe_ignore_standard_fpcr{true, "cpuopt_unsafe_ignore_standard_fpcr"};
     Setting<bool> cpuopt_unsafe_inaccurate_nan{true, "cpuopt_unsafe_inaccurate_nan"};
     Setting<bool> cpuopt_unsafe_fastmem_check{true, "cpuopt_unsafe_fastmem_check"};
-    Setting<bool> cpuopt_unsafe_ignore_global_monitor{true, "cpuopt_unsafe_ignore_global_monitor"};
 
     // Renderer
     RangedSetting<RendererBackend> renderer_backend{

src/core/arm/dynarmic/arm_dynarmic_32.cpp

@@ -137,8 +137,6 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
     config.page_table_pointer_mask_bits = Common::PageTable::ATTRIBUTE_BITS;
     config.detect_misaligned_access_via_page_table = 16 | 32 | 64 | 128;
     config.only_detect_misalignment_via_page_table_on_page_boundary = true;
-    config.fastmem_exclusive_access = true;
-    config.recompile_on_exclusive_fastmem_failure = true;
 
     // Multi-process state
     config.processor_id = core_index;
@@ -180,12 +178,6 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
         if (!Settings::values.cpuopt_fastmem) {
             config.fastmem_pointer = nullptr;
         }
-        if (!Settings::values.cpuopt_fastmem_exclusives) {
-            config.fastmem_exclusive_access = false;
-        }
-        if (!Settings::values.cpuopt_recompile_exclusives) {
-            config.recompile_on_exclusive_fastmem_failure = false;
-        }
     }
 
     // Unsafe optimizations
@@ -203,9 +195,6 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
         if (Settings::values.cpuopt_unsafe_inaccurate_nan) {
             config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
         }
-        if (Settings::values.cpuopt_unsafe_ignore_global_monitor) {
-            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreGlobalMonitor;
-        }
     }
 
     // Curated optimizations
@@ -214,7 +203,6 @@ std::shared_ptr<Dynarmic::A32::Jit> ARM_Dynarmic_32::MakeJit(Common::PageTable*
         config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
         config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreStandardFPCRValue;
         config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
-        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreGlobalMonitor;
     }
 
     return std::make_unique<Dynarmic::A32::Jit>(config);

src/core/arm/dynarmic/arm_dynarmic_64.cpp

@@ -185,9 +185,6 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         config.fastmem_pointer = page_table->fastmem_arena;
         config.fastmem_address_space_bits = address_space_bits;
         config.silently_mirror_fastmem = false;
-
-        config.fastmem_exclusive_access = true;
-        config.recompile_on_exclusive_fastmem_failure = true;
     }
 
     // Multi-process state
@@ -240,12 +237,6 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         if (!Settings::values.cpuopt_fastmem) {
             config.fastmem_pointer = nullptr;
         }
-        if (!Settings::values.cpuopt_fastmem_exclusives) {
-            config.fastmem_exclusive_access = false;
-        }
-        if (!Settings::values.cpuopt_recompile_exclusives) {
-            config.recompile_on_exclusive_fastmem_failure = false;
-        }
     }
 
     // Unsafe optimizations
@@ -263,9 +254,6 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         if (Settings::values.cpuopt_unsafe_fastmem_check) {
             config.fastmem_address_space_bits = 64;
         }
-        if (Settings::values.cpuopt_unsafe_ignore_global_monitor) {
-            config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreGlobalMonitor;
-        }
     }
 
     // Curated optimizations
@@ -274,7 +262,6 @@ std::shared_ptr<Dynarmic::A64::Jit> ARM_Dynarmic_64::MakeJit(Common::PageTable*
         config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_UnfuseFMA;
         config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_InaccurateNaN;
         config.fastmem_address_space_bits = 64;
-        config.optimizations |= Dynarmic::OptimizationFlag::Unsafe_IgnoreGlobalMonitor;
     }
 
     return std::make_shared<Dynarmic::A64::Jit>(config);

src/core/arm/dynarmic/arm_exclusive_monitor.cpp

@@ -37,8 +37,8 @@ u128 DynarmicExclusiveMonitor::ExclusiveRead128(std::size_t core_index, VAddr ad
     });
 }
 
-void DynarmicExclusiveMonitor::ClearExclusive(std::size_t core_index) {
-    monitor.ClearProcessor(core_index);
+void DynarmicExclusiveMonitor::ClearExclusive() {
+    monitor.Clear();
 }
 
 bool DynarmicExclusiveMonitor::ExclusiveWrite8(std::size_t core_index, VAddr vaddr, u8 value) {

src/core/arm/dynarmic/arm_exclusive_monitor.h

@@ -29,7 +29,7 @@ public:
     u32 ExclusiveRead32(std::size_t core_index, VAddr addr) override;
     u64 ExclusiveRead64(std::size_t core_index, VAddr addr) override;
     u128 ExclusiveRead128(std::size_t core_index, VAddr addr) override;
-    void ClearExclusive(std::size_t core_index) override;
+    void ClearExclusive() override;
 
     bool ExclusiveWrite8(std::size_t core_index, VAddr vaddr, u8 value) override;
     bool ExclusiveWrite16(std::size_t core_index, VAddr vaddr, u16 value) override;

src/core/arm/exclusive_monitor.h

@@ -23,7 +23,7 @@ public:
     virtual u32 ExclusiveRead32(std::size_t core_index, VAddr addr) = 0;
     virtual u64 ExclusiveRead64(std::size_t core_index, VAddr addr) = 0;
     virtual u128 ExclusiveRead128(std::size_t core_index, VAddr addr) = 0;
-    virtual void ClearExclusive(std::size_t core_index) = 0;
+    virtual void ClearExclusive() = 0;
 
     virtual bool ExclusiveWrite8(std::size_t core_index, VAddr vaddr, u8 value) = 0;
     virtual bool ExclusiveWrite16(std::size_t core_index, VAddr vaddr, u16 value) = 0;

src/core/core.cpp

@@ -28,9 +28,7 @@
 #include "core/file_sys/vfs_real.h"
 #include "core/hardware_interrupt_manager.h"
 #include "core/hid/hid_core.h"
-#include "core/hle/kernel/k_memory_manager.h"
 #include "core/hle/kernel/k_process.h"
-#include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/k_scheduler.h"
 #include "core/hle/kernel/kernel.h"
 #include "core/hle/kernel/physical_core.h"
@@ -254,16 +252,9 @@ struct System::Impl {
         }
 
         telemetry_session->AddInitialInfo(*app_loader, fs_controller, *content_provider);
-
-        // Create a resource limit for the process.
-        const auto physical_memory_size =
-            kernel.MemoryManager().GetSize(Kernel::KMemoryManager::Pool::Application);
-        auto* resource_limit = Kernel::CreateResourceLimitForProcess(system, physical_memory_size);
-
-        // Create the process.
         auto main_process = Kernel::KProcess::Create(system.Kernel());
         ASSERT(Kernel::KProcess::Initialize(main_process, system, "main",
-                                            Kernel::KProcess::ProcessType::Userland, resource_limit)
+                                            Kernel::KProcess::ProcessType::Userland)
                    .IsSuccess());
         const auto [load_result, load_parameters] = app_loader->Load(*main_process, system);
         if (load_result != Loader::ResultStatus::Success) {

src/core/device_memory.cpp

@@ -3,13 +3,10 @@
 // Refer to the license.txt file included.
 
 #include "core/device_memory.h"
-#include "hle/kernel/board/nintendo/nx/k_system_control.h"
 
 namespace Core {
 
-DeviceMemory::DeviceMemory()
-    : buffer{Kernel::Board::Nintendo::Nx::KSystemControl::Init::GetIntendedMemorySize(),
-             1ULL << 39} {}
+DeviceMemory::DeviceMemory() : buffer{DramMemoryMap::Size, 1ULL << 39} {}
 DeviceMemory::~DeviceMemory() = default;
 
 } // namespace Core

src/core/device_memory.h

@@ -12,8 +12,12 @@ namespace Core {
 namespace DramMemoryMap {
 enum : u64 {
     Base = 0x80000000ULL,
+    Size = 0x100000000ULL,
+    End = Base + Size,
     KernelReserveBase = Base + 0x60000,
     SlabHeapBase = KernelReserveBase + 0x85000,
+    SlapHeapSize = 0xa21000,
+    SlabHeapEnd = SlabHeapBase + SlapHeapSize,
 };
 }; // namespace DramMemoryMap
 

src/core/hle/kernel/board/nintendo/nx/k_system_control.cpp

@@ -5,7 +5,6 @@
 #include <random>
 
 #include "common/literals.h"
-#include "common/settings.h"
 
 #include "core/hle/kernel/board/nintendo/nx/k_system_control.h"
 #include "core/hle/kernel/board/nintendo/nx/secure_monitor.h"
@@ -29,13 +28,30 @@ namespace {
 
 using namespace Common::Literals;
 
+u32 GetMemoryModeForInit() {
+    return 0x01;
+}
+
 u32 GetMemorySizeForInit() {
-    return Settings::values.use_extended_memory_layout ? Smc::MemorySize_6GB : Smc::MemorySize_4GB;
+    return 0;
 }
 
 Smc::MemoryArrangement GetMemoryArrangeForInit() {
-    return Settings::values.use_extended_memory_layout ? Smc::MemoryArrangement_6GB
-                                                       : Smc::MemoryArrangement_4GB;
+    switch (GetMemoryModeForInit() & 0x3F) {
+    case 0x01:
+    default:
+        return Smc::MemoryArrangement_4GB;
+    case 0x02:
+        return Smc::MemoryArrangement_4GBForAppletDev;
+    case 0x03:
+        return Smc::MemoryArrangement_4GBForSystemDev;
+    case 0x11:
+        return Smc::MemoryArrangement_6GB;
+    case 0x12:
+        return Smc::MemoryArrangement_6GBForAppletDev;
+    case 0x21:
+        return Smc::MemoryArrangement_8GB;
+    }
 }
 } // namespace
 

src/core/hle/kernel/k_address_arbiter.cpp

@@ -49,7 +49,7 @@ bool DecrementIfLessThan(Core::System& system, s32* out, VAddr address, s32 valu
         }
     } else {
         // Otherwise, clear our exclusive hold and finish
-        monitor.ClearExclusive(current_core);
+        monitor.ClearExclusive();
     }
 
     // We're done.
@@ -78,7 +78,7 @@ bool UpdateIfEqual(Core::System& system, s32* out, VAddr address, s32 value, s32
         }
     } else {
         // Otherwise, clear our exclusive hold and finish.
-        monitor.ClearExclusive(current_core);
+        monitor.ClearExclusive();
     }
 
     // We're done.

src/core/hle/kernel/k_event.cpp

@@ -14,7 +14,7 @@ KEvent::KEvent(KernelCore& kernel_)
 
 KEvent::~KEvent() = default;
 
-void KEvent::Initialize(std::string&& name_, KProcess* owner_) {
+void KEvent::Initialize(std::string&& name_) {
     // Increment reference count.
     // Because reference count is one on creation, this will result
     // in a reference count of two. Thus, when both readable and
@@ -30,8 +30,10 @@ void KEvent::Initialize(std::string&& name_, KProcess* owner_) {
     writable_event.Initialize(this, name_ + ":Writable");
 
     // Set our owner process.
-    owner = owner_;
-    owner->Open();
+    owner = kernel.CurrentProcess();
+    if (owner) {
+        owner->Open();
+    }
 
     // Mark initialized.
     name = std::move(name_);
@@ -45,8 +47,10 @@ void KEvent::Finalize() {
 void KEvent::PostDestroy(uintptr_t arg) {
     // Release the event count resource the owner process holds.
     KProcess* owner = reinterpret_cast<KProcess*>(arg);
-    owner->GetResourceLimit()->Release(LimitableResource::Events, 1);
-    owner->Close();
+    if (owner) {
+        owner->GetResourceLimit()->Release(LimitableResource::Events, 1);
+        owner->Close();
+    }
 }
 
 } // namespace Kernel

src/core/hle/kernel/k_event.h

@@ -22,7 +22,7 @@ public:
     explicit KEvent(KernelCore& kernel_);
     ~KEvent() override;
 
-    void Initialize(std::string&& name, KProcess* owner_);
+    void Initialize(std::string&& name);
 
     void Finalize() override;
 

src/core/hle/kernel/k_process.cpp

@@ -123,11 +123,12 @@ private:
 };
 
 ResultCode KProcess::Initialize(KProcess* process, Core::System& system, std::string process_name,
-                                ProcessType type, KResourceLimit* res_limit) {
+                                ProcessType type) {
     auto& kernel = system.Kernel();
 
     process->name = std::move(process_name);
-    process->resource_limit = res_limit;
+
+    process->resource_limit = kernel.GetSystemResourceLimit();
     process->status = ProcessStatus::Created;
     process->program_id = 0;
     process->process_id = type == ProcessType::KernelInternal ? kernel.CreateNewKernelProcessID()
@@ -142,6 +143,9 @@ ResultCode KProcess::Initialize(KProcess* process, Core::System& system, std::st
 
     kernel.AppendNewProcess(process);
 
+    // Open a reference to the resource limit.
+    process->resource_limit->Open();
+
     // Clear remaining fields.
     process->num_running_threads = 0;
     process->is_signaled = false;
@@ -149,9 +153,6 @@ ResultCode KProcess::Initialize(KProcess* process, Core::System& system, std::st
     process->is_suspended = false;
     process->schedule_count = 0;
 
-    // Open a reference to the resource limit.
-    process->resource_limit->Open();
-
     return ResultSuccess;
 }
 

src/core/hle/kernel/k_process.h

@@ -91,7 +91,7 @@ public:
     static constexpr std::size_t RANDOM_ENTROPY_SIZE = 4;
 
     static ResultCode Initialize(KProcess* process, Core::System& system, std::string process_name,
-                                 ProcessType type, KResourceLimit* res_limit);
+                                 ProcessType type);
 
     /// Gets a reference to the process' page table.
     KPageTable& PageTable() {

src/core/hle/kernel/k_resource_limit.cpp

@@ -3,7 +3,6 @@
 // Refer to the license.txt file included.
 
 #include "common/assert.h"
-#include "core/core.h"
 #include "core/core_timing.h"
 #include "core/hle/kernel/k_resource_limit.h"
 #include "core/hle/kernel/svc_results.h"
@@ -152,22 +151,4 @@ void KResourceLimit::Release(LimitableResource which, s64 value, s64 hint) {
     }
 }
 
-KResourceLimit* CreateResourceLimitForProcess(Core::System& system, s64 physical_memory_size) {
-    auto* resource_limit = KResourceLimit::Create(system.Kernel());
-    resource_limit->Initialize(&system.CoreTiming());
-
-    // Initialize default resource limit values.
-    // TODO(bunnei): These values are the system defaults, the limits for service processes are
-    // lower. These should use the correct limit values.
-
-    ASSERT(resource_limit->SetLimitValue(LimitableResource::PhysicalMemory, physical_memory_size)
-               .IsSuccess());
-    ASSERT(resource_limit->SetLimitValue(LimitableResource::Threads, 800).IsSuccess());
-    ASSERT(resource_limit->SetLimitValue(LimitableResource::Events, 900).IsSuccess());
-    ASSERT(resource_limit->SetLimitValue(LimitableResource::TransferMemory, 200).IsSuccess());
-    ASSERT(resource_limit->SetLimitValue(LimitableResource::Sessions, 1133).IsSuccess());
-
-    return resource_limit;
-}
-
 } // namespace Kernel

src/core/hle/kernel/k_resource_limit.h

@@ -67,7 +67,4 @@ private:
     KLightConditionVariable cond_var;
     const Core::Timing::CoreTiming* core_timing{};
 };
-
-KResourceLimit* CreateResourceLimitForProcess(Core::System& system, s64 physical_memory_size);
-
 } // namespace Kernel

src/core/hle/kernel/kernel.cpp

@@ -240,6 +240,13 @@ struct KernelCore::Impl {
         constexpr u64 secure_applet_memory_size{4_MiB};
         ASSERT(system_resource_limit->Reserve(LimitableResource::PhysicalMemory,
                                               secure_applet_memory_size));
+
+        // This memory seems to be reserved on hardware, but is not reserved/used by yuzu.
+        // Likely Horizon OS reserved memory
+        // TODO(ameerj): Derive the memory rather than hardcode it.
+        constexpr u64 unknown_reserved_memory{0x2f896000};
+        ASSERT(system_resource_limit->Reserve(LimitableResource::PhysicalMemory,
+                                              unknown_reserved_memory));
     }
 
     void InitializePreemption(KernelCore& kernel) {

src/core/hle/kernel/svc.cpp

@@ -2332,7 +2332,7 @@ static ResultCode CreateEvent(Core::System& system, Handle* out_write, Handle* o
     R_UNLESS(event != nullptr, ResultOutOfResource);
 
     // Initialize the event.
-    event->Initialize("CreateEvent", kernel.CurrentProcess());
+    event->Initialize("CreateEvent");
 
     // Commit the thread reservation.
     event_reservation.Commit();

src/core/hle/service/kernel_helpers.cpp

@@ -3,9 +3,7 @@
 // Refer to the license.txt file included.
 
 #include "core/core.h"
-#include "core/core_timing.h"
 #include "core/hle/kernel/k_event.h"
-#include "core/hle/kernel/k_memory_manager.h"
 #include "core/hle/kernel/k_process.h"
 #include "core/hle/kernel/k_readable_event.h"
 #include "core/hle/kernel/k_resource_limit.h"
@@ -17,21 +15,10 @@ namespace Service::KernelHelpers {
 
 ServiceContext::ServiceContext(Core::System& system_, std::string name_)
     : kernel(system_.Kernel()) {
-
-    // Create a resource limit for the process.
-    const auto physical_memory_size =
-        kernel.MemoryManager().GetSize(Kernel::KMemoryManager::Pool::System);
-    auto* resource_limit = Kernel::CreateResourceLimitForProcess(system_, physical_memory_size);
-
-    // Create the process.
     process = Kernel::KProcess::Create(kernel);
     ASSERT(Kernel::KProcess::Initialize(process, system_, std::move(name_),
-                                        Kernel::KProcess::ProcessType::KernelInternal,
-                                        resource_limit)
+                                        Kernel::KProcess::ProcessType::Userland)
                .IsSuccess());
-
-    // Close reference to our resource limit, as the process opens one.
-    resource_limit->Close();
 }
 
 ServiceContext::~ServiceContext() {
@@ -56,7 +43,7 @@ Kernel::KEvent* ServiceContext::CreateEvent(std::string&& name) {
     }
 
     // Initialize the event.
-    event->Initialize(std::move(name), process);
+    event->Initialize(std::move(name));
 
     // Commit the thread reservation.
     event_reservation.Commit();

src/core/memory.cpp

@@ -39,7 +39,8 @@ struct Memory::Impl {
     void MapMemoryRegion(Common::PageTable& page_table, VAddr base, u64 size, PAddr target) {
         ASSERT_MSG((size & PAGE_MASK) == 0, "non-page aligned size: {:016X}", size);
         ASSERT_MSG((base & PAGE_MASK) == 0, "non-page aligned base: {:016X}", base);
-        ASSERT_MSG(target >= DramMemoryMap::Base, "Out of bounds target: {:016X}", target);
+        ASSERT_MSG(target >= DramMemoryMap::Base && target < DramMemoryMap::End,
+                   "Out of bounds target: {:016X}", target);
         MapPages(page_table, base / PAGE_SIZE, size / PAGE_SIZE, target, Common::PageType::Memory);
 
         if (Settings::IsFastmemEnabled()) {

src/video_core/buffer_cache/buffer_cache.h

@@ -1093,10 +1093,10 @@ void BufferCache<P>::BindHostGraphicsStorageBuffers(size_t stage) {
         const Binding& binding = storage_buffers[stage][index];
         Buffer& buffer = slot_buffers[binding.buffer_id];
         TouchBuffer(buffer, binding.buffer_id);
-        const u32 size = binding.size;
+        const u32 offset = buffer.Offset(binding.cpu_addr);
+        const u32 size = static_cast<u32>(buffer.SizeBytes()) - offset;
         SynchronizeBuffer(buffer, binding.cpu_addr, size);
 
-        const u32 offset = buffer.Offset(binding.cpu_addr);
         const bool is_written = ((written_storage_buffers[stage] >> index) & 1) != 0;
         if constexpr (NEEDS_BIND_STORAGE_INDEX) {
             runtime.BindStorageBuffer(stage, binding_index, buffer, offset, size, is_written);
@@ -1178,10 +1178,10 @@ void BufferCache<P>::BindHostComputeStorageBuffers() {
         const Binding& binding = compute_storage_buffers[index];
         Buffer& buffer = slot_buffers[binding.buffer_id];
         TouchBuffer(buffer, binding.buffer_id);
-        const u32 size = binding.size;
+        const u32 offset = buffer.Offset(binding.cpu_addr);
+        const u32 size = static_cast<u32>(buffer.SizeBytes()) - offset;
         SynchronizeBuffer(buffer, binding.cpu_addr, size);
 
-        const u32 offset = buffer.Offset(binding.cpu_addr);
         const bool is_written = ((written_compute_storage_buffers >> index) & 1) != 0;
         if constexpr (NEEDS_BIND_STORAGE_INDEX) {
             runtime.BindComputeStorageBuffer(binding_index, buffer, offset, size, is_written);

src/video_core/renderer_opengl/maxwell_to_gl.h

@@ -184,8 +184,6 @@ inline GLenum VertexFormat(Maxwell::VertexAttribute attrib) {
         case Maxwell::VertexAttribute::Size::Size_32_32_32:
         case Maxwell::VertexAttribute::Size::Size_32_32_32_32:
             return GL_FLOAT;
-        case Maxwell::VertexAttribute::Size::Size_11_11_10:
-            return GL_UNSIGNED_INT_10F_11F_11F_REV;
         default:
             break;
         }

src/video_core/renderer_vulkan/maxwell_to_vk.cpp

@@ -495,8 +495,6 @@ VkFormat VertexFormat(Maxwell::VertexAttribute::Type type, Maxwell::VertexAttrib
             return VK_FORMAT_R32G32B32_SFLOAT;
         case Maxwell::VertexAttribute::Size::Size_32_32_32_32:
             return VK_FORMAT_R32G32B32A32_SFLOAT;
-        case Maxwell::VertexAttribute::Size::Size_11_11_10:
-            return VK_FORMAT_B10G11R11_UFLOAT_PACK32;
         default:
             break;
         }

src/video_core/renderer_vulkan/vk_blit_screen.cpp

@@ -100,8 +100,6 @@ VkFormat GetFormat(const Tegra::FramebufferConfig& framebuffer) {
         return VK_FORMAT_A8B8G8R8_UNORM_PACK32;
     case Tegra::FramebufferConfig::PixelFormat::RGB565_UNORM:
         return VK_FORMAT_R5G6B5_UNORM_PACK16;
-    case Tegra::FramebufferConfig::PixelFormat::B8G8R8A8_UNORM:
-        return VK_FORMAT_B8G8R8A8_UNORM;
     default:
         UNIMPLEMENTED_MSG("Unknown framebuffer pixel format: {}",
                           static_cast<u32>(framebuffer.pixel_format));

src/video_core/vulkan_common/vulkan_device.cpp

@@ -231,14 +231,9 @@ std::vector<std::string> GetSupportedExtensions(vk::PhysicalDevice physical) {
     return supported_extensions;
 }
 
-bool IsExtensionSupported(std::span<const std::string> supported_extensions,
-                          std::string_view extension) {
-    return std::ranges::find(supported_extensions, extension) != supported_extensions.end();
-}
-
 NvidiaArchitecture GetNvidiaArchitecture(vk::PhysicalDevice physical,
                                          std::span<const std::string> exts) {
-    if (IsExtensionSupported(exts, VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME)) {
+    if (std::ranges::find(exts, VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME) != exts.end()) {
         VkPhysicalDeviceFragmentShadingRatePropertiesKHR shading_rate_props{};
         shading_rate_props.sType =
             VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADING_RATE_PROPERTIES_KHR;
@@ -251,7 +246,7 @@ NvidiaArchitecture GetNvidiaArchitecture(vk::PhysicalDevice physical,
             return NvidiaArchitecture::AmpereOrNewer;
         }
     }
-    if (IsExtensionSupported(exts, VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME)) {
+    if (std::ranges::find(exts, VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME) != exts.end()) {
         return NvidiaArchitecture::Turing;
     }
     return NvidiaArchitecture::VoltaOrOlder;
@@ -616,8 +611,7 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             break;
         }
     }
-    const bool is_radv = driver_id == VK_DRIVER_ID_MESA_RADV;
-    if (ext_extended_dynamic_state && is_radv) {
+    if (ext_extended_dynamic_state && driver_id == VK_DRIVER_ID_MESA_RADV) {
         // Mask driver version variant
         const u32 version = (properties.driverVersion << 3) >> 3;
         if (version < VK_MAKE_API_VERSION(0, 21, 2, 0)) {
@@ -626,17 +620,6 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             ext_extended_dynamic_state = false;
         }
     }
-    if (ext_vertex_input_dynamic_state && is_radv) {
-        // TODO(ameerj): Blacklist only offending driver versions
-        // TODO(ameerj): Confirm if RDNA1 is affected
-        const bool is_rdna2 =
-            IsExtensionSupported(supported_extensions, VK_KHR_FRAGMENT_SHADING_RATE_EXTENSION_NAME);
-        if (is_rdna2) {
-            LOG_WARNING(Render_Vulkan,
-                        "RADV has broken VK_EXT_vertex_input_dynamic_state on RDNA2 hardware");
-            ext_vertex_input_dynamic_state = false;
-        }
-    }
     sets_per_pool = 64;
 
     const bool is_amd =
@@ -652,7 +635,7 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
             has_broken_cube_compatibility = true;
         }
     }
-    const bool is_amd_or_radv = is_amd || is_radv;
+    const bool is_amd_or_radv = is_amd || driver_id == VK_DRIVER_ID_MESA_RADV;
     if (ext_sampler_filter_minmax && is_amd_or_radv) {
         // Disable ext_sampler_filter_minmax on AMD GCN4 and lower as it is broken.
         if (!is_float16_supported) {

src/yuzu/configuration/config.cpp

@@ -445,7 +445,6 @@ void Config::ReadCoreValues() {
     qt_config->beginGroup(QStringLiteral("Core"));
 
     ReadGlobalSetting(Settings::values.use_multi_core);
-    ReadGlobalSetting(Settings::values.use_extended_memory_layout);
 
     qt_config->endGroup();
 }
@@ -609,7 +608,6 @@ void Config::ReadCpuValues() {
     ReadGlobalSetting(Settings::values.cpuopt_unsafe_ignore_standard_fpcr);
     ReadGlobalSetting(Settings::values.cpuopt_unsafe_inaccurate_nan);
     ReadGlobalSetting(Settings::values.cpuopt_unsafe_fastmem_check);
-    ReadGlobalSetting(Settings::values.cpuopt_unsafe_ignore_global_monitor);
 
     if (global) {
         ReadBasicSetting(Settings::values.cpu_debug_mode);
@@ -622,8 +620,6 @@ void Config::ReadCpuValues() {
         ReadBasicSetting(Settings::values.cpuopt_misc_ir);
         ReadBasicSetting(Settings::values.cpuopt_reduce_misalign_checks);
         ReadBasicSetting(Settings::values.cpuopt_fastmem);
-        ReadBasicSetting(Settings::values.cpuopt_fastmem_exclusives);
-        ReadBasicSetting(Settings::values.cpuopt_recompile_exclusives);
     }
 
     qt_config->endGroup();
@@ -1023,7 +1019,6 @@ void Config::SaveCoreValues() {
     qt_config->beginGroup(QStringLiteral("Core"));
 
     WriteGlobalSetting(Settings::values.use_multi_core);
-    WriteGlobalSetting(Settings::values.use_extended_memory_layout);
 
     qt_config->endGroup();
 }
@@ -1142,7 +1137,6 @@ void Config::SaveCpuValues() {
     WriteGlobalSetting(Settings::values.cpuopt_unsafe_ignore_standard_fpcr);
     WriteGlobalSetting(Settings::values.cpuopt_unsafe_inaccurate_nan);
     WriteGlobalSetting(Settings::values.cpuopt_unsafe_fastmem_check);
-    WriteGlobalSetting(Settings::values.cpuopt_unsafe_ignore_global_monitor);
 
     if (global) {
         WriteBasicSetting(Settings::values.cpu_debug_mode);

src/yuzu/configuration/configure_cpu.cpp

@@ -36,7 +36,6 @@ void ConfigureCpu::SetConfiguration() {
     ui->cpuopt_unsafe_ignore_standard_fpcr->setEnabled(runtime_lock);
     ui->cpuopt_unsafe_inaccurate_nan->setEnabled(runtime_lock);
     ui->cpuopt_unsafe_fastmem_check->setEnabled(runtime_lock);
-    ui->cpuopt_unsafe_ignore_global_monitor->setEnabled(runtime_lock);
 
     ui->cpuopt_unsafe_unfuse_fma->setChecked(Settings::values.cpuopt_unsafe_unfuse_fma.GetValue());
     ui->cpuopt_unsafe_reduce_fp_error->setChecked(
@@ -47,8 +46,6 @@ void ConfigureCpu::SetConfiguration() {
         Settings::values.cpuopt_unsafe_inaccurate_nan.GetValue());
     ui->cpuopt_unsafe_fastmem_check->setChecked(
         Settings::values.cpuopt_unsafe_fastmem_check.GetValue());
-    ui->cpuopt_unsafe_ignore_global_monitor->setChecked(
-        Settings::values.cpuopt_unsafe_ignore_global_monitor.GetValue());
 
     if (Settings::IsConfiguringGlobal()) {
         ui->accuracy->setCurrentIndex(static_cast<int>(Settings::values.cpu_accuracy.GetValue()));
@@ -85,9 +82,6 @@ void ConfigureCpu::ApplyConfiguration() {
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.cpuopt_unsafe_fastmem_check,
                                              ui->cpuopt_unsafe_fastmem_check,
                                              cpuopt_unsafe_fastmem_check);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.cpuopt_unsafe_ignore_global_monitor,
-                                             ui->cpuopt_unsafe_ignore_global_monitor,
-                                             cpuopt_unsafe_ignore_global_monitor);
 }
 
 void ConfigureCpu::changeEvent(QEvent* event) {
@@ -126,7 +120,4 @@ void ConfigureCpu::SetupPerGameUI() {
     ConfigurationShared::SetColoredTristate(ui->cpuopt_unsafe_fastmem_check,
                                             Settings::values.cpuopt_unsafe_fastmem_check,
                                             cpuopt_unsafe_fastmem_check);
-    ConfigurationShared::SetColoredTristate(ui->cpuopt_unsafe_ignore_global_monitor,
-                                            Settings::values.cpuopt_unsafe_ignore_global_monitor,
-                                            cpuopt_unsafe_ignore_global_monitor);
 }

src/yuzu/configuration/configure_cpu.h

@@ -45,7 +45,6 @@ private:
     ConfigurationShared::CheckState cpuopt_unsafe_ignore_standard_fpcr;
     ConfigurationShared::CheckState cpuopt_unsafe_inaccurate_nan;
     ConfigurationShared::CheckState cpuopt_unsafe_fastmem_check;
-    ConfigurationShared::CheckState cpuopt_unsafe_ignore_global_monitor;
 
     const Core::System& system;
 };

src/yuzu/configuration/configure_cpu.ui

@@ -150,18 +150,6 @@
           </property>
          </widget>
         </item>
-        <item>
-         <widget class="QCheckBox" name="cpuopt_unsafe_ignore_global_monitor">
-          <property name="toolTip">
-           <string>
-            &lt;div&gt;This option improves speed by relying only on the semantics of cmpxchg to ensure safety of exclusive access instructions. Please note this may result in deadlocks and other race conditions.&lt;/div&gt;
-           </string>
-          </property>
-          <property name="text">
-           <string>Ignore global monitor</string>
-          </property>
-         </widget>
-        </item>
        </layout>
       </widget>
      </item>

src/yuzu/configuration/configure_cpu_debug.cpp

@@ -44,12 +44,6 @@ void ConfigureCpuDebug::SetConfiguration() {
         Settings::values.cpuopt_reduce_misalign_checks.GetValue());
     ui->cpuopt_fastmem->setEnabled(runtime_lock);
     ui->cpuopt_fastmem->setChecked(Settings::values.cpuopt_fastmem.GetValue());
-    ui->cpuopt_fastmem_exclusives->setEnabled(runtime_lock);
-    ui->cpuopt_fastmem_exclusives->setChecked(
-        Settings::values.cpuopt_fastmem_exclusives.GetValue());
-    ui->cpuopt_recompile_exclusives->setEnabled(runtime_lock);
-    ui->cpuopt_recompile_exclusives->setChecked(
-        Settings::values.cpuopt_recompile_exclusives.GetValue());
 }
 
 void ConfigureCpuDebug::ApplyConfiguration() {
@@ -62,8 +56,6 @@ void ConfigureCpuDebug::ApplyConfiguration() {
     Settings::values.cpuopt_misc_ir = ui->cpuopt_misc_ir->isChecked();
     Settings::values.cpuopt_reduce_misalign_checks = ui->cpuopt_reduce_misalign_checks->isChecked();
     Settings::values.cpuopt_fastmem = ui->cpuopt_fastmem->isChecked();
-    Settings::values.cpuopt_fastmem_exclusives = ui->cpuopt_fastmem_exclusives->isChecked();
-    Settings::values.cpuopt_recompile_exclusives = ui->cpuopt_recompile_exclusives->isChecked();
 }
 
 void ConfigureCpuDebug::changeEvent(QEvent* event) {

src/yuzu/configuration/configure_cpu_debug.ui

@@ -144,34 +144,7 @@
            </string>
           </property>
           <property name="text">
-           <string>Enable Host MMU Emulation (general memory instructions)</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QCheckBox" name="cpuopt_fastmem_exclusives">
-          <property name="toolTip">
-           <string>
-            &lt;div style=&quot;white-space: nowrap&quot;&gt;This optimization speeds up exclusive memory accesses by the guest program.&lt;/div&gt;
-            &lt;div style=&quot;white-space: nowrap&quot;&gt;Enabling it causes guest exclusive memory reads/writes to be done directly into memory and make use of Host's MMU.&lt;/div&gt;
-            &lt;div style=&quot;white-space: nowrap&quot;&gt;Disabling this forces all exclusive memory accesses to use Software MMU Emulation.&lt;/div&gt;
-           </string>
-          </property>
-          <property name="text">
-           <string>Enable Host MMU Emulation (exclusive memory instructions)</string>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QCheckBox" name="cpuopt_recompile_exclusives">
-          <property name="toolTip">
-           <string>
-            &lt;div style=&quot;white-space: nowrap&quot;&gt;This optimization speeds up exclusive memory accesses by the guest program.&lt;/div&gt;
-            &lt;div style=&quot;white-space: nowrap&quot;&gt;Enabling it reduces the overhead of fastmem failure of exclusive memory accesses.&lt;/div&gt;
-           </string>
-          </property>
-          <property name="text">
-           <string>Enable recompilation of exclusive memory instructions</string>
+           <string>Enable Host MMU Emulation</string>
           </property>
          </widget>
         </item>

src/yuzu/configuration/configure_general.cpp

@@ -42,9 +42,6 @@ void ConfigureGeneral::SetConfiguration() {
 
     ui->use_multi_core->setEnabled(runtime_lock);
     ui->use_multi_core->setChecked(Settings::values.use_multi_core.GetValue());
-    ui->use_extended_memory_layout->setEnabled(runtime_lock);
-    ui->use_extended_memory_layout->setChecked(
-        Settings::values.use_extended_memory_layout.GetValue());
 
     ui->toggle_check_exit->setChecked(UISettings::values.confirm_before_closing.GetValue());
     ui->toggle_user_on_boot->setChecked(UISettings::values.select_user_on_boot.GetValue());
@@ -94,9 +91,6 @@ void ConfigureGeneral::ResetDefaults() {
 void ConfigureGeneral::ApplyConfiguration() {
     ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_multi_core, ui->use_multi_core,
                                              use_multi_core);
-    ConfigurationShared::ApplyPerGameSetting(&Settings::values.use_extended_memory_layout,
-                                             ui->use_extended_memory_layout,
-                                             use_extended_memory_layout);
 
     if (Settings::IsConfiguringGlobal()) {
         UISettings::values.confirm_before_closing = ui->toggle_check_exit->isChecked();
@@ -166,9 +160,6 @@ void ConfigureGeneral::SetupPerGameUI() {
                                             Settings::values.use_speed_limit, use_speed_limit);
     ConfigurationShared::SetColoredTristate(ui->use_multi_core, Settings::values.use_multi_core,
                                             use_multi_core);
-    ConfigurationShared::SetColoredTristate(ui->use_extended_memory_layout,
-                                            Settings::values.use_extended_memory_layout,
-                                            use_extended_memory_layout);
 
     connect(ui->toggle_speed_limit, &QCheckBox::clicked, ui->speed_limit, [this]() {
         ui->speed_limit->setEnabled(ui->toggle_speed_limit->isChecked() &&

src/yuzu/configuration/configure_general.h

@@ -48,7 +48,6 @@ private:
 
     ConfigurationShared::CheckState use_speed_limit;
     ConfigurationShared::CheckState use_multi_core;
-    ConfigurationShared::CheckState use_extended_memory_layout;
 
     const Core::System& system;
 };

src/yuzu/configuration/configure_general.ui

@@ -142,13 +142,6 @@
             </property>
            </widget>
           </item>
-          <item>
-           <widget class="QCheckBox" name="use_extended_memory_layout">
-            <property name="text">
-             <string>Extended memory layout (6GB DRAM)</string>
-            </property>
-           </widget>
-          </item>
           <item>
            <widget class="QCheckBox" name="toggle_check_exit">
             <property name="text">

src/yuzu/main.cpp

@@ -2937,7 +2937,6 @@ void GMainWindow::OnLoadAmiibo() {
     if (nfc_state == Service::NFP::DeviceState::TagFound ||
         nfc_state == Service::NFP::DeviceState::TagMounted) {
         nfc->CloseAmiibo();
-        QMessageBox::warning(this, tr("Amiibo"), tr("The current amiibo has been removed"));
         return;
     }
 
@@ -2966,15 +2965,6 @@ void GMainWindow::LoadAmiibo(const QString& filename) {
         return;
     }
 
-    // Remove amiibo if one is connected
-    const auto nfc_state = nfc->GetCurrentState();
-    if (nfc_state == Service::NFP::DeviceState::TagFound ||
-        nfc_state == Service::NFP::DeviceState::TagMounted) {
-        nfc->CloseAmiibo();
-        QMessageBox::warning(this, tr("Amiibo"), tr("The current amiibo has been removed"));
-        return;
-    }
-
     QFile nfc_file{filename};
     if (!nfc_file.open(QIODevice::ReadOnly)) {
         QMessageBox::warning(this, tr("Error opening Amiibo data file"),

src/yuzu_cmd/config.cpp

@@ -266,7 +266,6 @@ void Config::ReadValues() {
 
     // Core
     ReadSetting("Core", Settings::values.use_multi_core);
-    ReadSetting("Core", Settings::values.use_extended_memory_layout);
 
     // Cpu
     ReadSetting("Cpu", Settings::values.cpu_accuracy);
@@ -280,14 +279,11 @@ void Config::ReadValues() {
     ReadSetting("Cpu", Settings::values.cpuopt_misc_ir);
     ReadSetting("Cpu", Settings::values.cpuopt_reduce_misalign_checks);
     ReadSetting("Cpu", Settings::values.cpuopt_fastmem);
-    ReadSetting("Cpu", Settings::values.cpuopt_fastmem_exclusives);
-    ReadSetting("Cpu", Settings::values.cpuopt_recompile_exclusives);
     ReadSetting("Cpu", Settings::values.cpuopt_unsafe_unfuse_fma);
     ReadSetting("Cpu", Settings::values.cpuopt_unsafe_reduce_fp_error);
     ReadSetting("Cpu", Settings::values.cpuopt_unsafe_ignore_standard_fpcr);
     ReadSetting("Cpu", Settings::values.cpuopt_unsafe_inaccurate_nan);
     ReadSetting("Cpu", Settings::values.cpuopt_unsafe_fastmem_check);
-    ReadSetting("Cpu", Settings::values.cpuopt_unsafe_ignore_global_monitor);
 
     // Renderer
     ReadSetting("Renderer", Settings::values.renderer_backend);

src/yuzu_cmd/default_ini.h

@@ -174,14 +174,6 @@ cpuopt_reduce_misalign_checks =
 # 0: Disabled, 1 (default): Enabled
 cpuopt_fastmem =
 
-# Enable Host MMU Emulation for exclusive memory instructions (faster guest memory access)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_fastmem_exclusives =
-
-# Enable fallback on failure of fastmem of exclusive memory instructions (faster guest memory access)
-# 0: Disabled, 1 (default): Enabled
-cpuopt_recompile_exclusives =
-
 # Enable unfuse FMA (improve performance on CPUs without FMA)
 # Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.
 # 0: Disabled, 1 (default): Enabled
@@ -207,11 +199,6 @@ cpuopt_unsafe_inaccurate_nan =
 # 0: Disabled, 1 (default): Enabled
 cpuopt_unsafe_fastmem_check =
 
-# Enable faster exclusive instructions
-# Only enabled if cpu_accuracy is set to Unsafe. Automatically chosen with cpu_accuracy = Auto-select.
-# 0: Disabled, 1 (default): Enabled
-cpuopt_unsafe_ignore_global_monitor =
-
 [Renderer]
 # Which backend API to use.
 # 0 (default): OpenGL, 1: Vulkan