[dynarmic] optimise BlockOfCode to use less memory

Signed-off-by: lizzie <lizzie@eden-emu.dev>
2026-08-25 16:54:41 +00:00 · 2026-08-25 15:42:22 +00:00
26 changed files with 358 additions and 469 deletions
@@ -340,10 +340,10 @@
        "version": "vulkan-sdk-%NUMERIC_VERSION%"
    },
    "xbyak": {
-        "hash": "b6475276b2faaeb315734ea8f4f8bd87ededcee768961b39679bee547e7f3e98884d8b7851e176d861dab30a80a76e6ea302f8c111483607dde969b4797ea95a",
+        "hash": "e0aa0a603dd3ac1a39d82213df1e73c042831aec2d6b2fe382c899651eaae4ed7e8aeb6be9c41ea0097087c9d091961ab18f313cd6a9e10d621715ffd49bfe36",
        "package": "xbyak",
        "repo": "herumi/xbyak",
-        "version": "v7.35.2"
+        "version": "v7.40.1"
    },
    "zlib": {
        "hash": "16fea4df307a68cf0035858abe2fd550250618a97590e202037acd18a666f57afc10f8836cbbd472d54a0e76539d0e558cb26f059d53de52ff90634bbf4f47d4",
@@ -247,7 +247,7 @@ void A32EmitX64::GenTerminalHandlers() {
    calculate_location_descriptor();
    code.mov(eax, dword[code.ABI_JIT_PTR + offsetof(A32JitState, rsb_ptr)]);
    code.sub(eax, 1);
-    code.and_(eax, u32(A32JitState::RSBPtrMask));
+    code.and_(eax, u32(A32JitState::RSB_PTR_MASK));
    code.mov(dword[code.ABI_JIT_PTR + offsetof(A32JitState, rsb_ptr)], eax);
    code.cmp(rbx, qword[code.ABI_JIT_PTR + offsetof(A32JitState, rsb_location_descriptors) + rax * sizeof(u64)]);
    if (conf.HasOptimization(OptimizationFlag::FastDispatch)) {
@@ -37,9 +37,9 @@ using namespace Backend::X64;

 static RunCodeCallbacks GenRunCodeCallbacks(A32::UserCallbacks* cb, CodePtr (*LookupBlock)(void* lookup_block_arg), void* arg, const A32::UserConfig& conf) {
    return RunCodeCallbacks{
-        std::make_unique<ArgCallback>(LookupBlock, reinterpret_cast<u64>(arg)),
-        std::make_unique<ArgCallback>(Devirtualize<&A32::UserCallbacks::AddTicks>(cb)),
-        std::make_unique<ArgCallback>(Devirtualize<&A32::UserCallbacks::GetTicksRemaining>(cb)),
+        ArgCallback(LookupBlock, reinterpret_cast<u64>(arg)),
+        ArgCallback(Devirtualize<&A32::UserCallbacks::AddTicks>(cb)),
+        ArgCallback(Devirtualize<&A32::UserCallbacks::GetTicksRemaining>(cb)),
        conf.enable_cycle_counting,
    };
 }
@@ -79,7 +79,7 @@ struct Jit::Impl {
        jit_interface->is_executing = true;
        const CodePtr current_codeptr = [this] {
            // RSB optimization
-            const u32 new_rsb_ptr = (jit_state.rsb_ptr - 1) & A32JitState::RSBPtrMask;
+            const u32 new_rsb_ptr = (jit_state.rsb_ptr - 1) & A32JitState::RSB_PTR_MASK;
            if (jit_state.GetUniqueHash() == jit_state.rsb_location_descriptors[new_rsb_ptr]) {
                jit_state.rsb_ptr = new_rsb_ptr;
                return reinterpret_cast<CodePtr>(jit_state.rsb_codeptrs[new_rsb_ptr]);
@@ -27,6 +27,9 @@ struct A32JitState {

    A32JitState() { ResetRSB(); }

+    static constexpr std::size_t RSB_SIZE = 8;  // MUST be a power of 2.
+    static constexpr std::size_t RSB_PTR_MASK = RSB_SIZE - 1;
+
    std::array<u32, 16> Reg{};  // Current register file.
    // TODO: Mode-specific register sets unimplemented.

@@ -36,8 +39,9 @@ struct A32JitState {
    u32 cpsr_q = 0;
    u32 cpsr_nzcv = 0;
    u32 cpsr_jaifm = 0;
-    u32 Cpsr() const;
-    void SetCpsr(u32 cpsr);
+    u32 fpsr_exc = 0;
+    u32 fpsr_qc = 0;
+    u32 fpsr_nzcv = 0;

    alignas(16) std::array<u32, 64> ExtReg{};  // Extension registers.

@@ -49,21 +53,19 @@ struct A32JitState {
    // Exclusive state
    u32 exclusive_state = 0;

-    static constexpr std::size_t RSBSize = 8;  // MUST be a power of 2.
-    static constexpr std::size_t RSBPtrMask = RSBSize - 1;
    u32 rsb_ptr = 0;
-    std::array<u64, RSBSize> rsb_location_descriptors;
-    std::array<u64, RSBSize> rsb_codeptrs;
-    void ResetRSB();
+    std::array<u64, RSB_SIZE> rsb_location_descriptors;
+    std::array<u64, RSB_SIZE> rsb_codeptrs;

-    u32 fpsr_exc = 0;
-    u32 fpsr_qc = 0;
-    u32 fpsr_nzcv = 0;
+    u32 Cpsr() const;
+    void SetCpsr(u32 cpsr);
+
+    void ResetRSB();
    u32 Fpscr() const;
    void SetFpscr(u32 FPSCR);

    u64 GetUniqueHash() const noexcept {
-        return (static_cast<u64>(upper_location_descriptor) << 32) | (static_cast<u64>(Reg[15]));
+        return (u64(upper_location_descriptor) << 32) | (u64(Reg[15]));
    }

    void TransferJitState(const A32JitState& src, bool reset_rsb) {
@@ -208,7 +208,7 @@ void A64EmitX64::GenTerminalHandlers() {
    calculate_location_descriptor();
    code.mov(eax, dword[code.ABI_JIT_PTR + offsetof(A64JitState, rsb_ptr)]);
    code.sub(eax, 1);
-    code.and_(eax, u32(A64JitState::RSBPtrMask));
+    code.and_(eax, u32(A64JitState::RSB_PTR_MASK));
    code.mov(dword[code.ABI_JIT_PTR + offsetof(A64JitState, rsb_ptr)], eax);
    code.cmp(rbx, qword[code.ABI_JIT_PTR + offsetof(A64JitState, rsb_location_descriptors) + rax * sizeof(u64)]);
    if (conf.HasOptimization(OptimizationFlag::FastDispatch)) {
@@ -33,9 +33,9 @@ using namespace Backend::X64;

 static RunCodeCallbacks GenRunCodeCallbacks(A64::UserCallbacks* cb, CodePtr (*LookupBlock)(void* lookup_block_arg), void* arg, const A64::UserConfig& conf) {
    return RunCodeCallbacks{
-        std::make_unique<ArgCallback>(LookupBlock, reinterpret_cast<u64>(arg)),
-        std::make_unique<ArgCallback>(Devirtualize<&A64::UserCallbacks::AddTicks>(cb)),
-        std::make_unique<ArgCallback>(Devirtualize<&A64::UserCallbacks::GetTicksRemaining>(cb)),
+        ArgCallback(LookupBlock, reinterpret_cast<u64>(arg)),
+        ArgCallback(Devirtualize<&A64::UserCallbacks::AddTicks>(cb)),
+        ArgCallback(Devirtualize<&A64::UserCallbacks::GetTicksRemaining>(cb)),
        conf.enable_cycle_counting,
    };
 }
@@ -78,7 +78,7 @@ public:
        // TODO: Check code alignment
        const CodePtr current_code_ptr = [this] {
            // RSB optimization
-            const u32 new_rsb_ptr = (jit_state.rsb_ptr - 1) & A64JitState::RSBPtrMask;
+            const u32 new_rsb_ptr = (jit_state.rsb_ptr - 1) & A64JitState::RSB_PTR_MASK;
            if (jit_state.GetUniqueHash() == jit_state.rsb_location_descriptors[new_rsb_ptr]) {
                jit_state.rsb_ptr = new_rsb_ptr;
                return CodePtr(jit_state.rsb_codeptrs[new_rsb_ptr]);
@@ -29,18 +29,19 @@ struct A64JitState {

    A64JitState() { ResetRSB(); }

+    // Exclusive state stuff
+    static constexpr u64 RESERVATION_GRANULE_MASK = 0xFFFF'FFFF'FFFF'FFF0ull;
+    // Return stack buffer
+    static constexpr size_t RSB_SIZE = 8;  // MUST be a power of 2.
+    static constexpr size_t RSB_PTR_MASK = RSB_SIZE - 1;
+
    std::array<u64, 31> reg{};
    u64 sp = 0;
    u64 pc = 0;
-
    u32 cpsr_nzcv = 0;
-
-    u32 GetPstate() const {
-        return NZCV::FromX64(cpsr_nzcv);
-    }
-    void SetPstate(u32 new_pstate) {
-        cpsr_nzcv = NZCV::ToX64(new_pstate);
-    }
+    u32 fpsr_exc = 0;
+    u32 fpsr_qc = 0;
+    u32 fpcr = 0;

    alignas(16) std::array<u64, 64> vec{};  // Extension registers.

@@ -50,29 +51,31 @@ struct A64JitState {
    volatile u32 halt_reason = 0;

    // Exclusive state
-    static constexpr u64 RESERVATION_GRANULE_MASK = 0xFFFF'FFFF'FFFF'FFF0ull;
    u8 exclusive_state = 0;
-
-    static constexpr size_t RSBSize = 8;  // MUST be a power of 2.
-    static constexpr size_t RSBPtrMask = RSBSize - 1;
    u32 rsb_ptr = 0;
-    std::array<u64, RSBSize> rsb_location_descriptors;
-    std::array<u64, RSBSize> rsb_codeptrs;
+    std::array<u64, RSB_SIZE> rsb_location_descriptors;
+    std::array<u64, RSB_SIZE> rsb_codeptrs;
+
+    u32 GetPstate() const {
+        return NZCV::FromX64(cpsr_nzcv);
+    }
+
+    void SetPstate(u32 new_pstate) {
+        cpsr_nzcv = NZCV::ToX64(new_pstate);
+    }
+
    void ResetRSB() {
        rsb_location_descriptors.fill(0xFFFFFFFFFFFFFFFFull);
        rsb_codeptrs.fill(0);
    }

-    u32 fpsr_exc = 0;
-    u32 fpsr_qc = 0;
-    u32 fpcr = 0;
    u32 GetFpcr() const;
    u32 GetFpsr() const;
    void SetFpcr(u32 value);
    void SetFpsr(u32 value);

    u64 GetUniqueHash() const noexcept {
-        const u64 fpcr_u64 = static_cast<u64>(fpcr & A64::LocationDescriptor::fpcr_mask) << A64::LocationDescriptor::fpcr_shift;
+        const u64 fpcr_u64 = u64(fpcr & A64::LocationDescriptor::fpcr_mask) << A64::LocationDescriptor::fpcr_shift;
        const u64 pc_u64 = pc & A64::LocationDescriptor::pc_mask;
        return pc_u64 | fpcr_u64;
    }
@@ -145,11 +145,9 @@ void ProtectMemory(const void* base, size_t size, bool is_executable) {

 HostFeature GetHostFeatures() {
    HostFeature features = {};
-
 #ifdef DYNARMIC_ENABLE_CPU_FEATURE_DETECTION
    using Cpu = Xbyak::util::Cpu;
-    Xbyak::util::Cpu cpu_info;
-
+    Xbyak::util::Cpu cpu_info{};
    if (cpu_info.has(Cpu::tSSSE3))
        features |= HostFeature::SSSE3;
    if (cpu_info.has(Cpu::tSSE41))
@@ -196,7 +194,6 @@ HostFeature GetHostFeatures() {
        features |= HostFeature::GFNI;
    if (cpu_info.has(Cpu::tWAITPKG))
        features |= HostFeature::WAITPKG;
-
    if (cpu_info.has(Cpu::tBMI2)) {
        // BMI2 instructions such as pdep and pext have been very slow up until Zen 3.
        // Check for Zen 3 or newer by its family (0x19).
@@ -214,7 +211,6 @@ HostFeature GetHostFeatures() {
        }
    }
 #endif
-
    return features;
 }

@@ -233,23 +229,27 @@ bool IsUnderRosetta() {

 }  // anonymous namespace

-#ifdef DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT
-static const auto default_cg_mode = Xbyak::DontSetProtectRWE;
-#else
-static const auto default_cg_mode = nullptr; //Allow RWE
-#endif
-
 BlockOfCode::BlockOfCode(RunCodeCallbacks cb, JitStateInfo jsi, size_t total_code_size, std::function<void(BlockOfCode&)> rcp)
-        : Xbyak::CodeGenerator(total_code_size, default_cg_mode, &s_allocator)
-        , cb(std::move(cb))
-        , jsi(jsi)
-        , constant_pool(*this, CONSTANT_POOL_SIZE)
-        , host_features(GetHostFeatures()) {
+    : Xbyak::CodeGenerator(total_code_size
+#ifdef DYNARMIC_ENABLE_NO_EXECUTE_SUPPORT
+        , Xbyak::DontSetProtectRWE
+#else
+        , nullptr //Allow RWE
+#endif
+        , &s_allocator)
+    , constant_pool(*this, CONSTANT_POOL_SIZE)
+    , jsi(jsi)
+    , cb(std::move(cb))
+{
    EnableWriting();
    EnsureMemoryCommitted(PRELUDE_COMMIT_SIZE);
    GenRunCode(rcp);
 }

+bool BlockOfCode::HasHostFeature(HostFeature feature) const noexcept {
+    return (GetHostFeatures() & feature) == feature;
+}
+
 void BlockOfCode::PreludeComplete() {
    prelude_complete = true;
    code_begin = getCurr();
@@ -341,7 +341,7 @@ void BlockOfCode::GenRunCode(std::function<void(BlockOfCode&)> rcp) {
    mov(rbx, ABI_PARAM2); // save temporarily in non-volatile register

    if (cb.enable_cycle_counting) {
-        cb.GetTicksRemaining->EmitCall(*this);
+        cb.GetTicksRemaining.EmitCall(*this);
        mov(qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_to_run)], ABI_RETURN);
        mov(qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_remaining)], ABI_RETURN);
    }
@@ -388,7 +388,7 @@ void BlockOfCode::GenRunCode(std::function<void(BlockOfCode&)> rcp) {
        cmp(qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_remaining)], 0);
        jng(return_to_caller);
    }
-    cb.LookupBlock->EmitCall(*this);
+    cb.LookupBlock.EmitCall(*this);
    jmp(ABI_RETURN);

    align();
@@ -401,7 +401,7 @@ void BlockOfCode::GenRunCode(std::function<void(BlockOfCode&)> rcp) {
        jng(return_to_caller_mxcsr_already_exited);
    }
    SwitchMxcsrOnEntry();
-    cb.LookupBlock->EmitCall(*this);
+    cb.LookupBlock.EmitCall(*this);
    jmp(ABI_RETURN);

    align();
@@ -415,7 +415,7 @@ void BlockOfCode::GenRunCode(std::function<void(BlockOfCode&)> rcp) {
    L(return_to_caller_mxcsr_already_exited);

    if (cb.enable_cycle_counting) {
-        cb.AddTicks->EmitCall(*this, [this](RegList param) {
+        cb.AddTicks.EmitCall(*this, [this](RegList param) {
            mov(param[0], qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_to_run)]);
            sub(param[0], qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_remaining)]);
        });
@@ -455,18 +455,18 @@ void BlockOfCode::UpdateTicks() {
        return;
    }

-    cb.AddTicks->EmitCall(*this, [this](RegList param) {
+    cb.AddTicks.EmitCall(*this, [this](RegList param) {
        mov(param[0], qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_to_run)]);
        sub(param[0], qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_remaining)]);
    });

-    cb.GetTicksRemaining->EmitCall(*this);
+    cb.GetTicksRemaining.EmitCall(*this);
    mov(qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_to_run)], ABI_RETURN);
    mov(qword[rsp + ABI_SHADOW_SPACE + offsetof(StackLayout, cycles_remaining)], ABI_RETURN);
 }

 void BlockOfCode::LookupBlock() {
-    cb.LookupBlock->EmitCall(*this);
+    cb.LookupBlock.EmitCall(*this);
 }

 void BlockOfCode::LoadRequiredFlagsForCondFromRax(IR::Cond cond) {
@@ -520,7 +520,7 @@ void BlockOfCode::LoadRequiredFlagsForCondFromRax(IR::Cond cond) {
 }

 Xbyak::Address BlockOfCode::Const(const Xbyak::AddressFrame& frame, u64 lower, u64 upper) {
-    return constant_pool.GetConstant(frame, lower, upper);
+    return constant_pool.GetConstant(*this, frame, lower, upper);
 }

 CodePtr BlockOfCode::GetCodeBegin() const {
@@ -31,9 +31,9 @@ namespace Dynarmic::Backend::X64 {
 using CodePtr = const void*;

 struct RunCodeCallbacks {
-    std::unique_ptr<Callback> LookupBlock;
-    std::unique_ptr<Callback> AddTicks;
-    std::unique_ptr<Callback> GetTicksRemaining;
+    ArgCallback LookupBlock;
+    ArgCallback AddTicks;
+    ArgCallback GetTicksRemaining;
    bool enable_cycle_counting;
 };

@@ -166,27 +166,24 @@ public:

    JitStateInfo GetJitStateInfo() const { return jsi; }

-    bool HasHostFeature(HostFeature feature) const {
-        return (host_features & feature) == feature;
-    }
+    bool HasHostFeature(HostFeature feature) const noexcept;

 private:
    using RunCodeFuncType = HaltReason (*)(void*, CodePtr);
    static constexpr size_t MXCSR_ALREADY_EXITED = 1 << 0;
    static constexpr size_t FORCE_RETURN = 1 << 1;

-    RunCodeCallbacks cb;
+    ConstantPool constant_pool;
    JitStateInfo jsi;
+    std::array<const void*, 4> return_from_run_code;
+    RunCodeCallbacks cb;
    CodePtr code_begin = nullptr;
+    RunCodeFuncType run_code = nullptr;
+    RunCodeFuncType step_code = nullptr;
 #ifdef _WIN32
    size_t committed_size = 0;
 #endif
-    ConstantPool constant_pool;
-    RunCodeFuncType run_code = nullptr;
-    RunCodeFuncType step_code = nullptr;
-    std::array<const void*, 4> return_from_run_code;
    bool prelude_complete = false;
-    const HostFeature host_features;

    void GenRunCode(std::function<void(BlockOfCode&)> rcp);
 };
@@ -16,8 +16,7 @@
 namespace Dynarmic::Backend::X64 {

 ConstantPool::ConstantPool(BlockOfCode& code, size_t size)
-    : code(code)
-    , insertion_point(0)
+    : insertion_point(0)
 {
    code.EnsureMemoryCommitted(align_size + size);
    code.int3();
@@ -25,17 +24,17 @@ ConstantPool::ConstantPool(BlockOfCode& code, size_t size)
    pool = std::span<ConstantT>(reinterpret_cast<ConstantT*>(code.AllocateFromCodeSpace(size)), size / align_size);
 }

-Xbyak::Address ConstantPool::GetConstant(const Xbyak::AddressFrame& frame, u64 lower, u64 upper) {
+Xbyak::Address ConstantPool::GetConstant(BlockOfCode& code, const Xbyak::AddressFrame& frame, u64 lower, u64 upper) {
    const auto constant = ConstantT(lower, upper);
-    auto iter = constant_info.find(constant);
-    if (iter == constant_info.end()) {
+    auto it = constant_info.find(constant);
+    if (it == constant_info.end()) {
        ASSERT(insertion_point < pool.size());
        ConstantT& target_constant = pool[insertion_point];
        target_constant = constant;
-        iter = constant_info.insert({constant, &target_constant}).first;
+        it = constant_info.insert({constant, &target_constant}).first;
        ++insertion_point;
    }
-    return frame[code.rip + iter->second];
+    return frame[code.rip + it->second];
 }

 }  // namespace Dynarmic::Backend::X64
@@ -29,7 +29,7 @@ class ConstantPool final {
 public:
    ConstantPool(BlockOfCode& code, size_t size);

-    Xbyak::Address GetConstant(const Xbyak::AddressFrame& frame, u64 lower, u64 upper = 0);
+    Xbyak::Address GetConstant(BlockOfCode& code, const Xbyak::AddressFrame& frame, u64 lower, u64 upper = 0);

 private:
    static constexpr size_t align_size = 16;  // bytes
@@ -45,7 +45,6 @@ private:

    ankerl::unordered_dense::map<ConstantT, void*, ConstantHash> constant_info;
    std::span<ConstantT> pool;
-    BlockOfCode& code;
    std::size_t insertion_point;
 };

@@ -12,7 +12,7 @@

 namespace Dynarmic::Backend::X64 {

-enum class HostFeature : u64 {
+enum class HostFeature : u32 {
    SSSE3 = 1ULL << 0,
    SSE41 = 1ULL << 1,
    SSE42 = 1ULL << 2,
@@ -1,3 +1,6 @@
+// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
+// SPDX-License-Identifier: GPL-3.0-or-later
+
 /* This file is part of the dynarmic project.
 * Copyright (c) 2016 MerryMage
 * SPDX-License-Identifier: 0BSD
@@ -15,7 +18,7 @@ struct JitStateInfo {
            : offsetof_guest_MXCSR(offsetof(JitStateType, guest_MXCSR))
            , offsetof_asimd_MXCSR(offsetof(JitStateType, asimd_MXCSR))
            , offsetof_rsb_ptr(offsetof(JitStateType, rsb_ptr))
-            , rsb_ptr_mask(JitStateType::RSBPtrMask)
+            , rsb_ptr_mask(JitStateType::RSB_PTR_MASK)
            , offsetof_rsb_location_descriptors(offsetof(JitStateType, rsb_location_descriptors))
            , offsetof_rsb_codeptrs(offsetof(JitStateType, rsb_codeptrs))
            , offsetof_cpsr_nzcv(offsetof(JitStateType, cpsr_nzcv))
@@ -335,7 +335,7 @@ void SetupDenormControl(const Profile& profile, const IR::Program& program, Emit
    if (info.uses_fp32_denorms_flush && info.uses_fp32_denorms_preserve) {
        LOG_DEBUG(Shader_SPIRV, "Fp32 denorm flush and preserve on the same shader");
    } else if (info.uses_fp32_denorms_flush) {
-        if (profile.support_fp32_denorm_flush && !profile.has_broken_fp32_denorm_flush) {
+        if (profile.support_fp32_denorm_flush) {
            ctx.AddCapability(spv::Capability::DenormFlushToZero);
            ctx.AddExecutionMode(main_func, spv::ExecutionMode::DenormFlushToZero, 32U);
        } else {
@@ -86,8 +86,6 @@ struct Profile {
    bool has_broken_signed_operations{};
    /// Float controls break when fp16 is enabled
    bool has_broken_fp16_float_controls{};
-    /// Declaring fp32 denorm flush to zero miscompiles on some drivers
-    bool has_broken_fp32_denorm_flush{};
    /// Dynamic vec4 indexing is broken on some OpenGL drivers
    bool has_gl_component_indexing_bug{};
    /// The precise type qualifier is broken in the fragment stage of some drivers
@@ -231,7 +231,6 @@ ShaderCache::ShaderCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
          .has_broken_unsigned_image_offsets = true,
          .has_broken_signed_operations = true,
          .has_broken_fp16_float_controls = false,
-          .has_broken_fp32_denorm_flush = false,
          .has_gl_component_indexing_bug = device.HasComponentIndexingBug(),
          .has_gl_precise_bug = device.HasPreciseBug(),
          .has_gl_cbuf_ftou_bug = device.HasCbufFtouBug(),
@@ -370,9 +370,20 @@ inline void PushImageDescriptors(TextureCache& texture_cache,
                const VkImageView null_image_view{texture_cache.GetImageView(VideoCommon::NULL_IMAGE_VIEW_ID).Handle(desc.type)};
                if (null_image_view != VK_NULL_HANDLE) vk_image_view = null_image_view;
            }
-            Sampler& sampler{texture_cache.GetSampler(sampler_id)};
-            guest_descriptor_queue.AddSampledImage(vk_image_view,
-                                                   sampler.HandleFor(image_view, desc.is_depth));
+            const Sampler& sampler{texture_cache.GetSampler(sampler_id)};
+            const bool use_fallback_sampler{sampler.HasAddedAnisotropy() &&
+                                            !image_view.SupportsAnisotropy()};
+            VkSampler vk_sampler{use_fallback_sampler ? sampler.HandleWithDefaultAnisotropy()
+                                                      : sampler.Handle()};
+            if (sampler.HasLinearFiltering() &&
+                VideoCore::Surface::IsPixelFormatInteger(image_view.format)) {
+                vk_sampler = sampler.HandleWithNearestFilter();
+            }
+            if (desc.is_depth && sampler.HasDepthComparison() &&
+                !image_view.SupportsDepthComparison()) {
+                vk_sampler = sampler.HandleWithoutDepthComparison();
+            }
+            guest_descriptor_queue.AddSampledImage(vk_image_view, vk_sampler);
            const bool element_rescaled{texture_cache.IsRescaling(image_view)};
            is_rescaled |= element_rescaled;
        }
@@ -444,7 +444,6 @@ PipelineCache::PipelineCache(Tegra::MaxwellDeviceMemoryManager& device_memory_,
        .has_broken_unsigned_image_offsets = false,
        .has_broken_signed_operations = false,
        .has_broken_fp16_float_controls = driver_id == VK_DRIVER_ID_NVIDIA_PROPRIETARY,
-        .has_broken_fp32_denorm_flush = driver_id == VK_DRIVER_ID_QUALCOMM_PROPRIETARY,
        .ignore_nan_fp_comparisons = false,
        .has_broken_spirv_subgroup_mask_vector_extract_dynamic = false,
        .has_broken_robust =
@@ -51,7 +51,6 @@ using VideoCore::Surface::BytesPerBlock;
 using VideoCore::Surface::HasAlpha;
 using VideoCore::Surface::IsPixelFormatASTC;
 using VideoCore::Surface::IsPixelFormatInteger;
-using VideoCore::Surface::IsPixelFormatSRGB;
 using VideoCore::Surface::SurfaceType;

 namespace {
@@ -60,17 +59,6 @@ constexpr bool ENABLE_MSAA_RESOLVE_CONSUME = true;
 constexpr bool ENABLE_MSAA_COLOR_DISCARD = true;
 constexpr bool ENABLE_MSAA_DEPTH_STENCIL_DISCARD = true;

-[[nodiscard]] constexpr bool NeedsExplicitBorderColorFormat(VkFormat format) {
-    switch (format) {
-    case VK_FORMAT_B4G4R4A4_UNORM_PACK16:
-    case VK_FORMAT_B5G6R5_UNORM_PACK16:
-    case VK_FORMAT_B5G5R5A1_UNORM_PACK16:
-        return true;
-    default:
-        return false;
-    }
-}
-
 constexpr VkBorderColor ConvertBorderColor(const std::array<float, 4>& color) {
    if (color == std::array<float, 4>{0, 0, 0, 0}) {
        return VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK;
@@ -1814,6 +1802,10 @@ bool TextureCacheRuntime::CanReportMemoryUsage() const {
    return device.CanReportMemoryUsage();
 }

+std::optional<size_t> TextureCacheRuntime::GetSamplerHeapBudget() const {
+    return device.GetSamplerHeapBudget();
+}
+
 void TextureCacheRuntime::FlushDeferredClear() {
    scheduler.FlushDeferredClear();
 }
@@ -2525,23 +2517,9 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
        supports_depth_comparison =
            (properties3.optimalTilingFeatures &
             VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_DEPTH_COMPARISON_BIT) != 0;
-        supports_minmax_filter = (properties3.optimalTilingFeatures &
-                                  VK_FORMAT_FEATURE_2_SAMPLED_IMAGE_FILTER_MINMAX_BIT) != 0;
    } else {
        supports_depth_comparison = true;
-        supports_minmax_filter =
-            (device->GetPhysical().GetFormatProperties(format_info.format).optimalTilingFeatures &
-             VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT) != 0;
    }
-    requires_border_color_format = NeedsExplicitBorderColorFormat(format_info.format);
-    swizzle_mapping = VkComponentMapping{
-        .r = ComponentSwizzle(swizzle[0]),
-        .g = ComponentSwizzle(swizzle[1]),
-        .b = ComponentSwizzle(swizzle[2]),
-        .a = ComponentSwizzle(swizzle[3]),
-    };
-    has_identity_swizzle = swizzle[0] == SwizzleSource::R && swizzle[1] == SwizzleSource::G &&
-                           swizzle[2] == SwizzleSource::B && swizzle[3] == SwizzleSource::A;
    const VkImageUsageFlags requested_view_usage = ImageUsageFlags(format_info, format);
    const VkImageUsageFlags image_usage = image.UsageFlags();
    const VkImageUsageFlags clamped_view_usage = requested_view_usage & image_usage;
@@ -2566,7 +2544,12 @@ ImageView::ImageView(TextureCacheRuntime& runtime, const VideoCommon::ImageViewI
        .image = image.Handle(),
        .viewType = VkImageViewType{},
        .format = format_info.format,
-        .components = swizzle_mapping,
+        .components{
+            .r = ComponentSwizzle(swizzle[0]),
+            .g = ComponentSwizzle(swizzle[1]),
+            .b = ComponentSwizzle(swizzle[2]),
+            .a = ComponentSwizzle(swizzle[3]),
+        },
        .subresourceRange = MakeSubresourceRange(aspect_mask, info.range),
    };
    const auto create = [&](TextureType tex_type, std::optional<u32> num_layers) {
@@ -2735,223 +2718,92 @@ vk::ImageView ImageView::MakeView(VkFormat vk_format, VkImageAspectFlags aspect_
    });
 }

-CustomBorderColorBudget::~CustomBorderColorBudget() {
-    Release();
-}
-
-CustomBorderColorBudget::CustomBorderColorBudget(CustomBorderColorBudget&& rhs) noexcept
-    : device_ptr{std::exchange(rhs.device_ptr, nullptr)}, held{std::exchange(rhs.held, 0)} {}
-
-CustomBorderColorBudget& CustomBorderColorBudget::operator=(
-    CustomBorderColorBudget&& rhs) noexcept {
-    if (this != &rhs) {
-        Release();
-        device_ptr = std::exchange(rhs.device_ptr, nullptr);
-        held = std::exchange(rhs.held, 0);
-    }
-    return *this;
-}
-
-bool CustomBorderColorBudget::TryAcquire(const Device& device, size_t count) {
-    if (!device.TryReserveCustomBorderColorSamplers(count)) {
-        return false;
-    }
-    device_ptr = &device;
-    held += count;
-    return true;
-}
-
-void CustomBorderColorBudget::Release() noexcept {
-    if (device_ptr != nullptr) {
-        device_ptr->ReleaseCustomBorderColorSamplers(held);
-    }
-    device_ptr = nullptr;
-    held = 0;
-}
-
 Sampler::Sampler(TextureCacheRuntime& runtime, const Tegra::Texture::TSCEntry& tsc) {
    const auto& device = runtime.device;
-    device_ptr = &device;
-    border_color = tsc.BorderColor();
-    srgb_border_color = tsc.SrgbBorderColor();
+    const bool has_custom_border_extension = runtime.device.IsExtCustomBorderColorSupported();
+    const bool has_format_undefined =
+        has_custom_border_extension && runtime.device.IsCustomBorderColorWithoutFormatSupported();
+    const bool has_custom_border_colors =
+        has_format_undefined && runtime.device.IsCustomBorderColorsSupported();
+    const auto color = tsc.BorderColor();

-    const f32 max_anisotropy = std::clamp(tsc.MaxAnisotropy(), 1.0f, 16.0f);
-    default_anisotropy = static_cast<f32>(1U << tsc.max_anisotropy);
-
-    const VkFilter mag_filter{MaxwellToVK::Sampler::Filter(tsc.mag_filter)};
-    const VkFilter min_filter{MaxwellToVK::Sampler::Filter(tsc.min_filter)};
-    const VkSamplerMipmapMode mipmap_mode{MaxwellToVK::Sampler::MipmapMode(tsc.mipmap_filter)};
-
-    const VkSamplerAddressMode wrap_u{
-        MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_u, tsc.mag_filter)};
-    const VkSamplerAddressMode wrap_v{
-        MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_v, tsc.mag_filter)};
-    const VkSamplerAddressMode wrap_p{
-        MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_p, tsc.mag_filter)};
-    const bool samples_border = wrap_u == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER ||
-                                wrap_v == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER ||
-                                wrap_p == VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_BORDER;
-
-    reduction_mode = MaxwellToVK::SamplerReduction(tsc.reduction_filter);
-
-    has_added_anisotropy = max_anisotropy > default_anisotropy;
-    has_linear_filtering = mag_filter == VK_FILTER_LINEAR || min_filter == VK_FILTER_LINEAR ||
-                           mipmap_mode == VK_SAMPLER_MIPMAP_MODE_LINEAR;
-    has_depth_comparison = tsc.depth_compare_enabled != 0;
-    has_minmax_reduction = reduction_mode != VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT;
-    has_srgb_border_color = tsc.srgb_conversion != 0 && srgb_border_color != border_color;
-    if (has_minmax_reduction && !device.IsExtSamplerFilterMinmaxSupported()) {
-        LOG_WARNING(Render_Vulkan, "VK_EXT_sampler_filter_minmax is required");
-        has_minmax_reduction = false;
-    }
-    has_custom_border_colors = samples_border && device.IsCustomBorderColorUsable();
-    needs_swizzle_mapping = has_custom_border_colors && device.NeedsBorderColorSwizzleMapping();
-
-    if (has_custom_border_colors && GPU::Logging::IsActive()) {
-        GPU::Logging::GPULogger::GetInstance().LogExtensionUsage(
-            "VK_EXT_custom_border_color", "Sampler::Sampler");
-    }
-    if (device.IsExtBorderColorSwizzleSupported() && GPU::Logging::IsActive()) {
-        GPU::Logging::GPULogger::GetInstance().LogExtensionUsage(
-            "VK_EXT_border_color_swizzle", "Sampler::Sampler");
-    }
-
-    f32 min_lod = 0.0f;
-    f32 max_lod = 0.25f;
-    if (tsc.mipmap_filter != TextureMipmapFilter::None) {
-        min_lod = tsc.MinLod();
-        max_lod = tsc.MaxLod();
-    }
-    base_ci = VkSamplerCreateInfo{
-        .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
-        .pNext = nullptr,
-        .flags = 0,
-        .magFilter = mag_filter,
-        .minFilter = min_filter,
-        .mipmapMode = mipmap_mode,
-        .addressModeU = wrap_u,
-        .addressModeV = wrap_v,
-        .addressModeW = wrap_p,
-        .mipLodBias = tsc.LodBias(),
-        .anisotropyEnable = static_cast<VkBool32>(max_anisotropy > 1.0f),
-        .maxAnisotropy = max_anisotropy,
-        .compareEnable = static_cast<VkBool32>(tsc.depth_compare_enabled),
-        .compareOp = MaxwellToVK::Sampler::DepthCompareFunction(tsc.depth_compare_func),
-        .minLod = min_lod,
-        .maxLod = max_lod,
-        .borderColor = VK_BORDER_COLOR_FLOAT_CUSTOM_EXT,
-        .unnormalizedCoordinates = VK_FALSE,
-    };
-    variants.reserve(1);
-    Emplace(VariantKey{});
-}
-
-Sampler::VariantKey Sampler::MakeKey(const ImageView& image_view, bool is_depth) const noexcept {
-    VariantKey key{};
-    key.reduce_anisotropy = has_added_anisotropy && !image_view.SupportsAnisotropy();
-    key.force_nearest = has_linear_filtering && IsPixelFormatInteger(image_view.format);
-    key.drop_depth_comparison =
-        is_depth && has_depth_comparison && !image_view.SupportsDepthComparison();
-    key.drop_reduction = has_minmax_reduction && !image_view.SupportsMinmaxFilter();
-    key.drop_custom_border = has_custom_border_colors && image_view.RequiresBorderColorFormat();
-    key.srgb_border = has_srgb_border_color && IsPixelFormatSRGB(image_view.format);
-    if (needs_swizzle_mapping && !key.drop_custom_border && !image_view.HasIdentitySwizzle()) {
-        const VkComponentMapping& mapping = image_view.Swizzle();
-        key.swizzle = {mapping.r, mapping.g, mapping.b, mapping.a};
-    }
-    return key;
-}
-
-VkSampler Sampler::Find(const VariantKey& key) const noexcept {
-    const auto it = std::ranges::find(variants, key, &Variant::key);
-    if (it == variants.end()) {
-        return VK_NULL_HANDLE;
-    }
-    return *it->sampler;
-}
-
-VkSampler Sampler::Emplace(VariantKey key) {
-    bool custom_border = has_custom_border_colors && !key.drop_custom_border;
-    if (custom_border && !custom_border_color_budget.TryAcquire(*device_ptr, 1)) {
-        static bool warned_budget = false;
-        if (!warned_budget) {
-            warned_budget = true;
-        }
-        custom_border = false;
-        key.drop_custom_border = true;
-        key.swizzle = {};
-        if (const VkSampler existing = Find(key); existing != VK_NULL_HANDLE) {
-            return existing;
-        }
-    }
-
-    std::array<float, 4> color = border_color;
-    if (key.srgb_border) {
-        color = srgb_border_color;
-    }
    const VkSamplerCustomBorderColorCreateInfoEXT border_ci{
        .sType = VK_STRUCTURE_TYPE_SAMPLER_CUSTOM_BORDER_COLOR_CREATE_INFO_EXT,
        .pNext = nullptr,
        .customBorderColor = std::bit_cast<VkClearColorValue>(color),
        .format = VK_FORMAT_UNDEFINED,
    };
-    const VkSamplerBorderColorComponentMappingCreateInfoEXT mapping_ci{
-        .sType = VK_STRUCTURE_TYPE_SAMPLER_BORDER_COLOR_COMPONENT_MAPPING_CREATE_INFO_EXT,
-        .pNext = &border_ci,
-        .components{key.swizzle[0], key.swizzle[1], key.swizzle[2], key.swizzle[3]},
-        .srgb = VK_FALSE,
-    };
-    const void* chain = nullptr;
-    if (custom_border) {
-        chain = &border_ci;
-        if (key.HasSwizzle()) {
-            chain = &mapping_ci;
+    const void* pnext = nullptr;
+    if (has_custom_border_colors) {
+        pnext = &border_ci;
+        if (GPU::Logging::IsActive()) {
+            GPU::Logging::GPULogger::GetInstance().LogExtensionUsage(
+                "VK_EXT_custom_border_color", "Sampler::Sampler");
        }
    }
+    if (device.IsExtBorderColorSwizzleSupported() && GPU::Logging::IsActive()) {
+        GPU::Logging::GPULogger::GetInstance().LogExtensionUsage(
+            "VK_EXT_border_color_swizzle", "Sampler::Sampler");
+    }
    const VkSamplerReductionModeCreateInfoEXT reduction_ci{
        .sType = VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT,
-        .pNext = chain,
-        .reductionMode = reduction_mode,
+        .pNext = pnext,
+        .reductionMode = MaxwellToVK::SamplerReduction(tsc.reduction_filter),
    };
-    if (has_minmax_reduction && !key.drop_reduction) {
-        chain = &reduction_ci;
+    if (runtime.device.IsExtSamplerFilterMinmaxSupported()) {
+        pnext = &reduction_ci;
+    } else if (reduction_ci.reductionMode != VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT) {
+        LOG_WARNING(Render_Vulkan, "VK_EXT_sampler_filter_minmax is required");
    }
+    // Some games have samplers with garbage. Sanitize them here.
+    const f32 max_anisotropy = std::clamp(tsc.MaxAnisotropy(), 1.0f, 16.0f);

-    VkSamplerCreateInfo create_info = base_ci;
-    create_info.pNext = chain;
-    if (key.force_nearest) {
-        create_info.magFilter = VK_FILTER_NEAREST;
-        create_info.minFilter = VK_FILTER_NEAREST;
-        create_info.mipmapMode = VK_SAMPLER_MIPMAP_MODE_NEAREST;
-        create_info.anisotropyEnable = VK_FALSE;
-        create_info.maxAnisotropy = 1.0f;
-    } else if (key.reduce_anisotropy) {
-        create_info.anisotropyEnable = static_cast<VkBool32>(default_anisotropy > 1.0f);
-        create_info.maxAnisotropy = default_anisotropy;
-    }
-    if (key.drop_depth_comparison) {
-        create_info.compareEnable = VK_FALSE;
-    }
-    if (!custom_border) {
-        create_info.borderColor = ConvertBorderColor(color);
-    }
-    variants.push_back(Variant{
-        .key = key,
-        .sampler = device_ptr->GetLogical().CreateSampler(create_info),
-    });
-    return *variants.back().sampler;
-}
+    const VkFilter mag_filter{MaxwellToVK::Sampler::Filter(tsc.mag_filter)};
+    const VkFilter min_filter{MaxwellToVK::Sampler::Filter(tsc.min_filter)};
+    const VkSamplerMipmapMode mipmap_mode{MaxwellToVK::Sampler::MipmapMode(tsc.mipmap_filter)};
+    const bool has_linear_filtering{mag_filter == VK_FILTER_LINEAR ||
+                                    min_filter == VK_FILTER_LINEAR ||
+                                    mipmap_mode == VK_SAMPLER_MIPMAP_MODE_LINEAR};

-VkSampler Sampler::HandleFor(const ImageView& image_view, bool is_depth) {
-    VariantKey key = MakeKey(image_view, is_depth);
-    if (variants.size() >= MAX_VARIANTS) {
-        key.srgb_border = false;
-        key.swizzle = {};
+    const auto create_sampler = [&](const f32 anisotropy, bool force_nearest,
+                                    bool disable_compare = false) {
+        return device.GetLogical().CreateSampler(VkSamplerCreateInfo{
+            .sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
+            .pNext = pnext,
+            .flags = 0,
+            .magFilter = force_nearest ? VK_FILTER_NEAREST : mag_filter,
+            .minFilter = force_nearest ? VK_FILTER_NEAREST : min_filter,
+            .mipmapMode = force_nearest ? VK_SAMPLER_MIPMAP_MODE_NEAREST : mipmap_mode,
+            .addressModeU = MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_u, tsc.mag_filter),
+            .addressModeV = MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_v, tsc.mag_filter),
+            .addressModeW = MaxwellToVK::Sampler::WrapMode(device, tsc.wrap_p, tsc.mag_filter),
+            .mipLodBias = tsc.LodBias(),
+            .anisotropyEnable =
+                static_cast<VkBool32>(!force_nearest && anisotropy > 1.0f ? VK_TRUE : VK_FALSE),
+            .maxAnisotropy = force_nearest ? 1.0f : anisotropy,
+            .compareEnable = disable_compare ? VK_FALSE
+                                             : static_cast<VkBool32>(tsc.depth_compare_enabled),
+            .compareOp = MaxwellToVK::Sampler::DepthCompareFunction(tsc.depth_compare_func),
+            .minLod = tsc.mipmap_filter == TextureMipmapFilter::None ? 0.0f : tsc.MinLod(),
+            .maxLod = tsc.mipmap_filter == TextureMipmapFilter::None ? 0.25f : tsc.MaxLod(),
+            .borderColor = has_custom_border_colors ? VK_BORDER_COLOR_FLOAT_CUSTOM_EXT
+                                                    : ConvertBorderColor(color),
+            .unnormalizedCoordinates = VK_FALSE,
+        });
+    };
+
+    sampler = create_sampler(max_anisotropy, false);
+
+    const f32 max_anisotropy_default = static_cast<f32>(1U << tsc.max_anisotropy);
+    if (max_anisotropy > max_anisotropy_default) {
+        sampler_default_anisotropy = create_sampler(max_anisotropy_default, false);
    }
-    if (const VkSampler existing = Find(key); existing != VK_NULL_HANDLE) {
-        return existing;
+    if (has_linear_filtering) {
+        sampler_nearest = create_sampler(1.0f, true);
+    }
+    if (tsc.depth_compare_enabled) {
+        sampler_noncompare = create_sampler(max_anisotropy, false, true);
    }
-    return Emplace(key);
 }

 Framebuffer::Framebuffer(TextureCacheRuntime& runtime, std::span<ImageView*, NUM_RT> color_buffers,
@@ -68,6 +68,8 @@ public:

    bool CanReportMemoryUsage() const;

+    std::optional<size_t> GetSamplerHeapBudget() const;
+
    bool CanDownloadMsaa(const VideoCommon::ImageInfo& info) const;

    [[nodiscard]] VkImage AcquireMsaaScratchImage(const VkImageCreateInfo& image_ci);
@@ -444,22 +446,6 @@ public:
        return supports_depth_comparison;
    }

-    [[nodiscard]] bool RequiresBorderColorFormat() const noexcept {
-        return requires_border_color_format;
-    }
-
-    [[nodiscard]] bool SupportsMinmaxFilter() const noexcept {
-        return supports_minmax_filter;
-    }
-
-    [[nodiscard]] const VkComponentMapping& Swizzle() const noexcept {
-        return swizzle_mapping;
-    }
-
-    [[nodiscard]] bool HasIdentitySwizzle() const noexcept {
-        return has_identity_swizzle;
-    }
-
    [[nodiscard]] GPUVAddr GpuAddr() const noexcept {
        return gpu_addr;
    }
@@ -492,91 +478,48 @@ private:
    VkSampleCountFlagBits samples = VK_SAMPLE_COUNT_1_BIT;
    u32 buffer_size = 0;

-    VkComponentMapping swizzle_mapping{};
-
    bool supports_depth_comparison = false;
-    bool requires_border_color_format = false;
-    bool supports_minmax_filter = false;
-    bool has_identity_swizzle = true;
 };

 class ImageAlloc : public VideoCommon::ImageAllocBase {};

-class CustomBorderColorBudget {
-public:
-    CustomBorderColorBudget() = default;
-    ~CustomBorderColorBudget();
-
-    CustomBorderColorBudget(const CustomBorderColorBudget&) = delete;
-    CustomBorderColorBudget& operator=(const CustomBorderColorBudget&) = delete;
-
-    CustomBorderColorBudget(CustomBorderColorBudget&& rhs) noexcept;
-    CustomBorderColorBudget& operator=(CustomBorderColorBudget&& rhs) noexcept;
-
-    bool TryAcquire(const Device& device, size_t count);
-
-private:
-    void Release() noexcept;
-
-    const Device* device_ptr = nullptr;
-    size_t held = 0;
-};
-
 class Sampler {
 public:
    explicit Sampler(TextureCacheRuntime&, const Tegra::Texture::TSCEntry&);

    [[nodiscard]] VkSampler Handle() const noexcept {
-        return *variants.front().sampler;
+        return *sampler;
    }

-    [[nodiscard]] VkSampler HandleFor(const ImageView& image_view, bool is_depth);
+    [[nodiscard]] VkSampler HandleWithDefaultAnisotropy() const noexcept {
+        return *sampler_default_anisotropy;
+    }
+
+    [[nodiscard]] bool HasAddedAnisotropy() const noexcept {
+        return static_cast<bool>(sampler_default_anisotropy);
+    }
+
+    [[nodiscard]] VkSampler HandleWithNearestFilter() const noexcept {
+        return *sampler_nearest;
+    }
+
+    [[nodiscard]] bool HasLinearFiltering() const noexcept {
+        return static_cast<bool>(sampler_nearest);
+    }
+
+    [[nodiscard]] VkSampler HandleWithoutDepthComparison() const noexcept {
+        return *sampler_noncompare;
+    }
+
+    [[nodiscard]] bool HasDepthComparison() const noexcept {
+        return static_cast<bool>(sampler_noncompare);
+    }

 private:
-    struct VariantKey {
-        bool reduce_anisotropy;
-        bool force_nearest;
-        bool drop_depth_comparison;
-        bool drop_reduction;
-        bool drop_custom_border;
-        bool srgb_border;
-        std::array<VkComponentSwizzle, 4> swizzle;
-
-        bool operator==(const VariantKey&) const noexcept = default;
-
-        [[nodiscard]] bool HasSwizzle() const noexcept {
-            return swizzle != std::array<VkComponentSwizzle, 4>{};
-        }
-    };
-
-    struct Variant {
-        VariantKey key;
-        vk::Sampler sampler;
-    };
-
-    static constexpr size_t MAX_VARIANTS = 32;
-
-    [[nodiscard]] VariantKey MakeKey(const ImageView& image_view, bool is_depth) const noexcept;
-    [[nodiscard]] VkSampler Find(const VariantKey& key) const noexcept;
-    VkSampler Emplace(VariantKey key);
-
-    CustomBorderColorBudget custom_border_color_budget;
-    std::vector<Variant> variants;
-
-    const Device* device_ptr{nullptr};
-    VkSamplerCreateInfo base_ci{};
-    VkSamplerReductionModeEXT reduction_mode{VK_SAMPLER_REDUCTION_MODE_WEIGHTED_AVERAGE_EXT};
-    std::array<float, 4> border_color{};
-    std::array<float, 4> srgb_border_color{};
-    f32 default_anisotropy{1.0f};
-
-    bool has_added_anisotropy{};
-    bool has_linear_filtering{};
-    bool has_depth_comparison{};
-    bool has_minmax_reduction{};
-    bool has_custom_border_colors{};
-    bool has_srgb_border_color{};
-    bool needs_swizzle_mapping{};
+    vk::Sampler sampler;
+    vk::Sampler sampler_default_anisotropy;
+    vk::Sampler sampler_nearest;
+    vk::Sampler sampler_noncompare;
 };

 struct TextureCacheParams {
@@ -1896,10 +1896,67 @@ SamplerId TextureCache<P>::FindSampler(const TSCEntry& config, bool compute) {
    const auto [pair, is_new] = channel_state->samplers.try_emplace(config);
    if (is_new) {
        pair->second = slot_samplers.insert(runtime, config);
+        EnforceSamplerBudget();
    }
    return pair->second;
 }

+template <class P>
+std::optional<size_t> TextureCache<P>::QuerySamplerBudget() const {
+    if constexpr (requires { runtime.GetSamplerHeapBudget(); }) {
+        return runtime.GetSamplerHeapBudget();
+    } else {
+        return std::nullopt;
+    }
+}
+
+template <class P>
+void TextureCache<P>::EnforceSamplerBudget() {
+    if (auto const budget = QuerySamplerBudget(); budget) {
+        if (slot_samplers.size() < *budget) {
+            return;
+        }
+        if (!channel_state) {
+            return;
+        }
+        if (last_sampler_gc_frame == frame_tick) {
+            return;
+        }
+        last_sampler_gc_frame = frame_tick;
+        TrimInactiveSamplers(*budget);
+    }
+}
+
+template <class P>
+void TextureCache<P>::TrimInactiveSamplers(size_t budget) {
+    if (channel_state->samplers.size() > 0) {
+        constexpr size_t SAMPLER_GC_SLACK = 1024;
+        ankerl::unordered_dense::set<SamplerId> active_sampler_ids;
+        for (auto const& e : channel_state->sampler_ids)
+            active_sampler_ids.insert(e.second);
+        // Elements in the map must be necesarily valid
+        size_t removed = 0;
+        for (auto it = channel_state->samplers.begin(); it != channel_state->samplers.end();) {
+            const SamplerId sampler_id = it->second;
+            if (!sampler_id || sampler_id == CORRUPT_ID) {
+                it = channel_state->samplers.erase(it);
+            } else if (std::ranges::find(active_sampler_ids, sampler_id) != active_sampler_ids.end()) {
+                ++it;
+            } else {
+                slot_samplers.erase(sampler_id);
+                it = channel_state->samplers.erase(it);
+                ++removed;
+                if (slot_samplers.size() + SAMPLER_GC_SLACK <= budget) {
+                    break;
+                }
+            }
+        }
+        if (removed != 0) {
+            LOG_WARNING(HW_GPU, "Sampler cache exceeded {} entries on this driver; reclaimed {} inactive samplers", budget, removed);
+        }
+    }
+}
+
 template <class P>
 ImageViewId TextureCache<P>::FindColorBuffer(size_t index) {
    const auto& regs = maxwell3d->regs;
@@ -420,6 +420,9 @@ private:

    void QueueAsyncDecode(Image& image, ImageId image_id);
    void TickAsyncDecode();
+    void EnforceSamplerBudget();
+    void TrimInactiveSamplers(size_t budget);
+    std::optional<size_t> QuerySamplerBudget() const;

    void QueueAsyncUnswizzle(Image& image, ImageId image_id);
    void TickAsyncUnswizzle();
@@ -506,6 +509,7 @@ private:

    u64 modification_tick = 0;
    u64 frame_tick = 0;
+    u64 last_sampler_gc_frame = (std::numeric_limits<u64>::max)();

    Common::ThreadWorker texture_decode_worker{1, "TextureDecoder", {},
                                               Common::ThreadPlacement::Efficiency};
@@ -5,7 +5,6 @@
 // SPDX-License-Identifier: GPL-2.0-or-later

 #include <array>
-#include <cmath>

 #include "common/cityhash.h"
 #include "common/settings.h"
@@ -18,25 +17,53 @@ namespace Tegra::Texture {

 namespace {

-float SrgbToLinear(u32 value) {
-    const float encoded = static_cast<float>(value) / 255.0f;
-    if (encoded <= 0.04045f) {
-        return encoded / 12.92f;
-    }
-    return std::pow((encoded + 0.055f) / 1.055f, 2.4f);
-}
+[[maybe_unused]] constexpr std::array<float, 256> SRGB_CONVERSION_LUT = {
+    0.000000f, 0.000000f, 0.000000f, 0.000012f, 0.000021f, 0.000033f, 0.000046f, 0.000062f,
+    0.000081f, 0.000102f, 0.000125f, 0.000151f, 0.000181f, 0.000214f, 0.000251f, 0.000293f,
+    0.000338f, 0.000388f, 0.000443f, 0.000503f, 0.000568f, 0.000639f, 0.000715f, 0.000798f,
+    0.000887f, 0.000983f, 0.001085f, 0.001195f, 0.001312f, 0.001437f, 0.001569f, 0.001710f,
+    0.001860f, 0.002019f, 0.002186f, 0.002364f, 0.002551f, 0.002748f, 0.002955f, 0.003174f,
+    0.003403f, 0.003643f, 0.003896f, 0.004160f, 0.004436f, 0.004725f, 0.005028f, 0.005343f,
+    0.005672f, 0.006015f, 0.006372f, 0.006744f, 0.007130f, 0.007533f, 0.007950f, 0.008384f,
+    0.008834f, 0.009301f, 0.009785f, 0.010286f, 0.010805f, 0.011342f, 0.011898f, 0.012472f,
+    0.013066f, 0.013680f, 0.014313f, 0.014967f, 0.015641f, 0.016337f, 0.017054f, 0.017793f,
+    0.018554f, 0.019337f, 0.020144f, 0.020974f, 0.021828f, 0.022706f, 0.023609f, 0.024536f,
+    0.025489f, 0.026468f, 0.027473f, 0.028504f, 0.029563f, 0.030649f, 0.031762f, 0.032904f,
+    0.034074f, 0.035274f, 0.036503f, 0.037762f, 0.039050f, 0.040370f, 0.041721f, 0.043103f,
+    0.044518f, 0.045964f, 0.047444f, 0.048956f, 0.050503f, 0.052083f, 0.053699f, 0.055349f,
+    0.057034f, 0.058755f, 0.060513f, 0.062307f, 0.064139f, 0.066008f, 0.067915f, 0.069861f,
+    0.071845f, 0.073869f, 0.075933f, 0.078037f, 0.080182f, 0.082369f, 0.084597f, 0.086867f,
+    0.089180f, 0.091535f, 0.093935f, 0.096378f, 0.098866f, 0.101398f, 0.103977f, 0.106601f,
+    0.109271f, 0.111988f, 0.114753f, 0.117565f, 0.120426f, 0.123335f, 0.126293f, 0.129301f,
+    0.132360f, 0.135469f, 0.138629f, 0.141841f, 0.145105f, 0.148421f, 0.151791f, 0.155214f,
+    0.158691f, 0.162224f, 0.165810f, 0.169453f, 0.173152f, 0.176907f, 0.180720f, 0.184589f,
+    0.188517f, 0.192504f, 0.196549f, 0.200655f, 0.204820f, 0.209046f, 0.213334f, 0.217682f,
+    0.222093f, 0.226567f, 0.231104f, 0.235704f, 0.240369f, 0.245099f, 0.249894f, 0.254754f,
+    0.259681f, 0.264674f, 0.269736f, 0.274864f, 0.280062f, 0.285328f, 0.290664f, 0.296070f,
+    0.301546f, 0.307094f, 0.312713f, 0.318404f, 0.324168f, 0.330006f, 0.335916f, 0.341902f,
+    0.347962f, 0.354097f, 0.360309f, 0.366597f, 0.372961f, 0.379403f, 0.385924f, 0.392524f,
+    0.399202f, 0.405960f, 0.412798f, 0.419718f, 0.426719f, 0.433802f, 0.440967f, 0.448216f,
+    0.455548f, 0.462965f, 0.470465f, 0.478052f, 0.485725f, 0.493484f, 0.501329f, 0.509263f,
+    0.517285f, 0.525396f, 0.533595f, 0.541885f, 0.550265f, 0.558736f, 0.567299f, 0.575954f,
+    0.584702f, 0.593542f, 0.602477f, 0.611507f, 0.620632f, 0.629852f, 0.639168f, 0.648581f,
+    0.658092f, 0.667700f, 0.677408f, 0.687214f, 0.697120f, 0.707127f, 0.717234f, 0.727443f,
+    0.737753f, 0.748167f, 0.758685f, 0.769305f, 0.780031f, 0.790861f, 0.801798f, 0.812839f,
+    0.823989f, 0.835246f, 0.846611f, 0.858085f, 0.869668f, 0.881360f, 0.893164f, 0.905078f,
+    0.917104f, 0.929242f, 0.941493f, 0.953859f, 0.966338f, 1.000000f, 1.000000f, 1.000000f,
+};

 } // Anonymous namespace

 std::array<float, 4> TSCEntry::BorderColor() const noexcept {
+    // TODO: Handle SRGB correctly. Using this breaks shadows in some games (Xenoblade).
+    // if (!srgb_conversion) {
+    //    return border_color;
+    //}
+    // return {SRGB_CONVERSION_LUT[srgb_border_color_r], SRGB_CONVERSION_LUT[srgb_border_color_g],
+    //        SRGB_CONVERSION_LUT[srgb_border_color_b], border_color[3]};
    return border_color;
 }

-std::array<float, 4> TSCEntry::SrgbBorderColor() const noexcept {
-    return {SrgbToLinear(srgb_border_color_r), SrgbToLinear(srgb_border_color_g),
-            SrgbToLinear(srgb_border_color_b), border_color[3]};
-}
-
 float TSCEntry::MaxAnisotropy() const noexcept {
    const bool is_suitable_mipmap_filter = mipmap_filter != TextureMipmapFilter::None;
    const bool has_regular_lods = min_lod_clamp == 0 && max_lod_clamp >= 256;
@@ -1,6 +1,3 @@
-// SPDX-FileCopyrightText: Copyright 2026 Eden Emulator Project
-// SPDX-License-Identifier: GPL-3.0-or-later
-
 // SPDX-FileCopyrightText: Copyright 2018 yuzu Emulator Project
 // SPDX-License-Identifier: GPL-2.0-or-later

@@ -381,8 +378,6 @@ struct TSCEntry {

    std::array<float, 4> BorderColor() const noexcept;

-    std::array<float, 4> SrgbBorderColor() const noexcept;
-
    float MaxAnisotropy() const noexcept;

    float MinLod() const {
@@ -508,9 +508,17 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
        LOG_WARNING(Render_Vulkan, "Qualcomm drivers require scaled vertex format emulation.");
        has_broken_descriptor_aliasing = true;
        LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken descriptor aliasing.");
+        LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken custom border color.");
+        RemoveExtensionFeature(extensions.custom_border_color, features.custom_border_color,
+                               VK_EXT_CUSTOM_BORDER_COLOR_EXTENSION_NAME);
+        LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken border color swizzle.");
+        RemoveExtensionFeature(extensions.border_color_swizzle, features.border_color_swizzle,
+                               VK_EXT_BORDER_COLOR_SWIZZLE_EXTENSION_NAME);
        LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken color write enable.");
        RemoveExtensionFeature(extensions.color_write_enable, features.color_write_enable,
                               VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME);
+        LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken shader float controls.");
+        RemoveExtension(extensions.shader_float_controls, VK_KHR_SHADER_FLOAT_CONTROLS_EXTENSION_NAME);
        LOG_WARNING(Render_Vulkan, "Qualcomm drivers have broken shader atomic int64.");
        RemoveExtensionFeature(extensions.shader_atomic_int64, features.shader_atomic_int64,
                               VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME);
@@ -611,6 +619,21 @@ Device::Device(VkInstance instance_, vk::PhysicalDevice physical_, VkSurfaceKHR
        }
    }

+    if (is_qualcomm) {
+        const size_t sampler_limit = properties.properties.limits.maxSamplerAllocationCount;
+        if (sampler_limit > 0) {
+            constexpr size_t MIN_SAMPLER_BUDGET = 1024U;
+            const size_t reserved = sampler_limit / 4U;
+            const size_t derived_budget =
+                (std::max)(MIN_SAMPLER_BUDGET, sampler_limit - reserved);
+            sampler_heap_budget = derived_budget;
+            LOG_WARNING(Render_Vulkan,
+                        "Qualcomm driver reports max {} samplers; reserving {} (25%) and "
+                        "allowing Eden to use {} (75%) to avoid heap exhaustion",
+                        sampler_limit, reserved, sampler_heap_budget);
+        }
+    }
+
    if (extensions.sampler_filter_minmax && is_amd) {
        // Disable ext_sampler_filter_minmax on AMD GCN4 and lower as it is broken.
        if (!features.shader_float16_int8.shaderFloat16) {
@@ -1123,11 +1146,6 @@ bool Device::GetSuitability(bool requires_swapchain) {
            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MAINTENANCE_5_PROPERTIES_KHR;
        SetNext(next, properties.maintenance5);
    }
-    if (extensions.custom_border_color) {
-        properties.custom_border_color.sType =
-            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CUSTOM_BORDER_COLOR_PROPERTIES_EXT;
-        SetNext(next, properties.custom_border_color);
-    }

    // Perform the property fetch.
    physical.GetProperties2(properties2);
@@ -1224,7 +1242,9 @@ void Device::RemoveUnsuitableExtensions() {
    // VK_EXT_border_color_swizzle
    if (extensions.border_color_swizzle) {
        extensions.border_color_swizzle =
-            extensions.custom_border_color && features.border_color_swizzle.borderColorSwizzle;
+            extensions.custom_border_color &&
+            features.border_color_swizzle.borderColorSwizzle &&
+            features.border_color_swizzle.borderColorSwizzleFromImage;
    }
    RemoveExtensionFeatureIfUnsuitable(extensions.border_color_swizzle,
                                       features.border_color_swizzle,
@@ -1470,26 +1490,11 @@ void Device::SetupFamilies(VkSurfaceKHR surface) {
    }
 }

-bool Device::TryReserveCustomBorderColorSamplers(size_t count) const {
-    const size_t limit = properties.custom_border_color.maxCustomBorderColorSamplers;
-    if (limit == 0) {
-        return true;
+std::optional<size_t> Device::GetSamplerHeapBudget() const {
+    if (sampler_heap_budget == 0) {
+        return std::nullopt;
    }
-    size_t used = custom_border_color_samplers_used.load(std::memory_order_relaxed);
-    while (used + count <= limit) {
-        if (custom_border_color_samplers_used.compare_exchange_weak(
-                used, used + count, std::memory_order_relaxed, std::memory_order_relaxed)) {
-            return true;
-        }
-    }
-    return false;
-}
-
-void Device::ReleaseCustomBorderColorSamplers(size_t count) const {
-    if (count == 0) {
-        return;
-    }
-    custom_border_color_samplers_used.fetch_sub(count, std::memory_order_relaxed);
+    return sampler_heap_budget;
 }

 u64 Device::GetDeviceMemoryUsage() const {
@@ -6,7 +6,6 @@

 #pragma once

-#include <atomic>
 #include <optional>
 #include <set>
 #include <span>
@@ -700,18 +699,20 @@ FN_MAX_LIMIT_LIST
        return features.transform_feedback.geometryStreams;
    }

-    /// Returns true if custom border colors can be created without a format.
-    bool IsCustomBorderColorUsable() const {
-        return extensions.custom_border_color &&
-               features.custom_border_color.customBorderColors &&
-               features.custom_border_color.customBorderColorWithoutFormat;
+    /// Returns true if the device supports VK_EXT_custom_border_color.
+    bool IsExtCustomBorderColorSupported() const {
+        return extensions.custom_border_color;
    }

-    /// Takes budget for samplers carrying a custom border color, false when exhausted.
-    bool TryReserveCustomBorderColorSamplers(size_t count) const;
+    /// Returns true if customBorderColors feature is available.
+    bool IsCustomBorderColorsSupported() const {
+        return features.custom_border_color.customBorderColors;
+    }

-    /// Gives back budget taken by TryReserveCustomBorderColorSamplers.
-    void ReleaseCustomBorderColorSamplers(size_t count) const;
+    /// Returns true if customBorderColorWithoutFormat feature is available.
+    bool IsCustomBorderColorWithoutFormatSupported() const {
+        return features.custom_border_color.customBorderColorWithoutFormat;
+    }

    /// Returns true if the device supports VK_EXT_color_write_enable.
    bool IsExtColorWriteEnableSupported() const {
@@ -723,12 +724,6 @@ FN_MAX_LIMIT_LIST
        return extensions.border_color_swizzle;
    }

-    /// Returns true if samplers must be carried with border color swizzle mapping.
-    bool NeedsBorderColorSwizzleMapping() const {
-        return extensions.border_color_swizzle &&
-               !features.border_color_swizzle.borderColorSwizzleFromImage;
-    }
-
    /// Returns true if borderColorSwizzleFromImage is available.
    bool IsBorderColorSwizzleFromImageSupported() const {
        return features.border_color_swizzle.borderColorSwizzleFromImage;
@@ -924,6 +919,8 @@ FN_MAX_LIMIT_LIST
        return has_broken_parallel_compiling;
    }

+    std::optional<size_t> GetSamplerHeapBudget() const;
+
    /// Returns the vendor name reported from Vulkan.
    std::string_view GetVendorName() const {
        return properties.driver.driverName;
@@ -1176,7 +1173,6 @@ private:
        VkPhysicalDeviceTransformFeedbackPropertiesEXT transform_feedback{};
        VkPhysicalDeviceMaintenance5PropertiesKHR maintenance5{};
        VkPhysicalDeviceDepthStencilResolveProperties depth_stencil_resolve{};
-        VkPhysicalDeviceCustomBorderColorPropertiesEXT custom_border_color{};

        VkPhysicalDeviceProperties properties{};
    };
@@ -1215,7 +1211,7 @@ private:
    bool dynamic_state3_alpha_to_coverage{};
    bool dynamic_state3_alpha_to_one{};
    bool supports_conditional_barriers{};      ///< Allows barriers in conditional control flow.
-    mutable std::atomic<size_t> custom_border_color_samplers_used{};
+    size_t sampler_heap_budget{};              ///< Sampler budget for buggy drivers (0 = unlimited).
    u64 device_access_memory{};                ///< Total size of device local memory in bytes.
    u32 sets_per_pool{};                       ///< Sets per Description Pool
    NvidiaArchitecture nvidia_arch{NvidiaArchitecture::Arch_AmpereOrNewer};