Revert "[TEST] Another miscellaneous change 2"

src/shader_recompiler/environment.h

@@ -78,11 +78,6 @@ public:
 
     [[nodiscard]] virtual TextureType ReadTextureType(u32 raw_handle) = 0;
 
-    [[nodiscard]] virtual u32 ResolveBindlessHandle(u32 cbuf_index, u32 cbuf_offset,
-                                                    u32 raw_handle) {
-        return raw_handle;
-    }
-
     [[nodiscard]] virtual TexturePixelFormat ReadTexturePixelFormat(u32 raw_handle) = 0;
 
     [[nodiscard]] virtual bool IsTexturePixelFormatInteger(u32 raw_handle) = 0;

src/shader_recompiler/ir_opt/texture_pass.cpp

@@ -502,7 +502,7 @@ u32 GetTextureHandle(Environment& env, const ConstBufferAddr& cbuf) {
     const u32 lhs_raw{env.ReadCbufValue(cbuf.index, cbuf.offset) << cbuf.shift_left};
     const u32 rhs_raw{env.ReadCbufValue(secondary_index, secondary_offset)
                       << cbuf.secondary_shift_left};
-    return env.ResolveBindlessHandle(cbuf.index, cbuf.offset, lhs_raw | rhs_raw);
+    return lhs_raw | rhs_raw;
 }
 
 [[maybe_unused]] TextureType ReadTextureType(Environment& env, const ConstBufferAddr& cbuf) {

src/video_core/buffer_cache/buffer_cache.h

@@ -1504,9 +1504,8 @@ void BufferCache<P>::UpdateComputeUniformBuffers() {
         Binding& binding = channel_state->compute_uniform_buffers[index];
         binding = NULL_BINDING;
         const auto& launch_desc = kepler_compute->launch_description;
-        const u32 resolved_index = launch_desc.ResolveConstBufferIndex(index);
+        if (((launch_desc.const_buffer_enable_mask >> index) & 1) != 0) {
-        if (((launch_desc.const_buffer_enable_mask >> resolved_index) & 1) != 0) {
+            const auto& cbuf = launch_desc.const_buffer_config[index];
-            const auto& cbuf = launch_desc.const_buffer_config[resolved_index];
             const std::optional<DAddr> device_addr = gpu_memory->GpuToCpuAddress(cbuf.Address());
             if (device_addr) {
                 binding.device_addr = *device_addr;

src/video_core/engines/kepler_compute.h

@@ -171,22 +171,6 @@ public:
         };
         std::array<ConstBufferConfig, NumConstBuffers> const_buffer_config;
 
-        static constexpr u32 NvnShaderSlotBias = 2;
-
-        u32 ResolveConstBufferIndex(u32 shader_index) const {
-            const u32 mask = const_buffer_enable_mask.Value();
-            if (((mask >> shader_index) & 1) != 0) {
-                return shader_index;
-            }
-            if (shader_index >= NvnShaderSlotBias) {
-                const u32 biased = shader_index - NvnShaderSlotBias;
-                if (((mask >> biased) & 1) != 0) {
-                    return biased;
-                }
-            }
-            return shader_index;
-        }
-
         union {
             BitField<0, 20, u32> local_pos_alloc;
             BitField<27, 5, u32> barrier_alloc;

src/video_core/renderer_opengl/gl_compute_pipeline.cpp

@@ -10,7 +10,6 @@
 #include "common/cityhash.h"
 #include "common/settings.h"
 #include "video_core/renderer_opengl/gl_compute_pipeline.h"
-#include "video_core/shader_environment.h"
 #include "video_core/renderer_opengl/gl_shader_manager.h"
 #include "video_core/renderer_opengl/gl_shader_util.h"
 
@@ -105,36 +104,25 @@ void ComputePipeline::Configure() {
     const auto& qmd{kepler_compute->launch_description};
     const auto& cbufs{qmd.const_buffer_config};
     const bool via_header_index{qmd.linked_tsc != 0};
-    const u32 tic_limit{kepler_compute->regs.tic.limit};
     const auto read_handle{[&](const auto& desc, u32 index) {
-        const u32 resolved_index{qmd.ResolveConstBufferIndex(desc.cbuf_index)};
+        ASSERT(((qmd.const_buffer_enable_mask >> desc.cbuf_index) & 1) != 0);
-        ASSERT(((qmd.const_buffer_enable_mask >> resolved_index) & 1) != 0);
         const u32 index_offset{index << desc.size_shift};
         const u32 offset{desc.cbuf_offset + index_offset};
-        const GPUVAddr addr{cbufs[resolved_index].Address() + offset};
+        const GPUVAddr addr{cbufs[desc.cbuf_index].Address() + offset};
         if constexpr (std::is_same_v<decltype(desc), const Shader::TextureDescriptor&> ||
                       std::is_same_v<decltype(desc), const Shader::TextureBufferDescriptor&>) {
             if (desc.has_secondary) {
-                const u32 resolved_secondary{
+                ASSERT(((qmd.const_buffer_enable_mask >> desc.secondary_cbuf_index) & 1) != 0);
-                    qmd.ResolveConstBufferIndex(desc.secondary_cbuf_index)};
-                ASSERT(((qmd.const_buffer_enable_mask >> resolved_secondary) & 1) != 0);
                 const u32 secondary_offset{desc.secondary_cbuf_offset + index_offset};
-                const GPUVAddr separate_addr{cbufs[resolved_secondary].Address() +
+                const GPUVAddr separate_addr{cbufs[desc.secondary_cbuf_index].Address() +
                                              secondary_offset};
                 const u32 lhs_raw{gpu_memory->Read<u32>(addr) << desc.shift_left};
                 const u32 rhs_raw{gpu_memory->Read<u32>(separate_addr)
                                   << desc.secondary_shift_left};
-                const u32 combined{VideoCommon::ResolveBindlessHandleTable(
+                return TexturePair(lhs_raw | rhs_raw, via_header_index);
-                    *gpu_memory, addr, lhs_raw | rhs_raw,
-                    TexturePair(lhs_raw | rhs_raw, via_header_index).first, tic_limit)};
-                return TexturePair(combined, via_header_index);
             }
         }
-        const u32 single_raw{gpu_memory->Read<u32>(addr)};
+        return TexturePair(gpu_memory->Read<u32>(addr), via_header_index);
-        return TexturePair(VideoCommon::ResolveBindlessHandleTable(
-                               *gpu_memory, addr, single_raw,
-                               TexturePair(single_raw, via_header_index).first, tic_limit),
-                           via_header_index);
     }};
     const auto add_image{[&](const auto& desc, bool blacklist) {
         for (u32 index = 0; index < desc.count; ++index) {

src/video_core/renderer_vulkan/vk_compute_pipeline.cpp

@@ -14,7 +14,6 @@
 #include "video_core/renderer_vulkan/pipeline_statistics.h"
 #include "video_core/renderer_vulkan/vk_buffer_cache.h"
 #include "video_core/renderer_vulkan/vk_compute_pipeline.h"
-#include "video_core/shader_environment.h"
 #include "video_core/renderer_vulkan/vk_descriptor_pool.h"
 #include "video_core/renderer_vulkan/vk_pipeline_cache.h"
 #include "video_core/renderer_vulkan/vk_scheduler.h"
@@ -149,35 +148,24 @@ void ComputePipeline::Configure(Tegra::Engines::KeplerCompute& kepler_compute,
     const auto& qmd{kepler_compute.launch_description};
     const auto& cbufs{qmd.const_buffer_config};
     const bool via_header_index{qmd.linked_tsc != 0};
-    const u32 tic_limit{kepler_compute.regs.tic.limit};
     const auto read_handle{[&](const auto& desc, u32 index) {
-        const u32 resolved_index{qmd.ResolveConstBufferIndex(desc.cbuf_index)};
+        ASSERT(((qmd.const_buffer_enable_mask >> desc.cbuf_index) & 1) != 0);
-        ASSERT(((qmd.const_buffer_enable_mask >> resolved_index) & 1) != 0);
         const u32 index_offset{index << desc.size_shift};
         const u32 offset{desc.cbuf_offset + index_offset};
-        const GPUVAddr addr{cbufs[resolved_index].Address() + offset};
+        const GPUVAddr addr{cbufs[desc.cbuf_index].Address() + offset};
         if constexpr (std::is_same_v<decltype(desc), const Shader::TextureDescriptor&> ||
                       std::is_same_v<decltype(desc), const Shader::TextureBufferDescriptor&>) {
             if (desc.has_secondary) {
-                const u32 resolved_secondary{
+                ASSERT(((qmd.const_buffer_enable_mask >> desc.secondary_cbuf_index) & 1) != 0);
-                    qmd.ResolveConstBufferIndex(desc.secondary_cbuf_index)};
-                ASSERT(((qmd.const_buffer_enable_mask >> resolved_secondary) & 1) != 0);
                 const u32 secondary_offset{desc.secondary_cbuf_offset + index_offset};
-                const GPUVAddr separate_addr{cbufs[resolved_secondary].Address() +
+                const GPUVAddr separate_addr{cbufs[desc.secondary_cbuf_index].Address() +
                                              secondary_offset};
                 const u32 lhs_raw{gpu_memory.Read<u32>(addr) << desc.shift_left};
                 const u32 rhs_raw{gpu_memory.Read<u32>(separate_addr) << desc.secondary_shift_left};
-                const u32 combined{VideoCommon::ResolveBindlessHandleTable(
+                return TexturePair(lhs_raw | rhs_raw, via_header_index);
-                    gpu_memory, addr, lhs_raw | rhs_raw,
-                    TexturePair(lhs_raw | rhs_raw, via_header_index).first, tic_limit)};
-                return TexturePair(combined, via_header_index);
             }
         }
-        const u32 single_raw{gpu_memory.Read<u32>(addr)};
+        return TexturePair(gpu_memory.Read<u32>(addr), via_header_index);
-        return TexturePair(VideoCommon::ResolveBindlessHandleTable(
-                               gpu_memory, addr, single_raw,
-                               TexturePair(single_raw, via_header_index).first, tic_limit),
-                           via_header_index);
     }};
     const auto add_image{[&](const auto& desc, bool blacklist) {
         for (u32 index = 0; index < desc.count; ++index) {

src/video_core/shader_environment.cpp

@@ -281,34 +281,6 @@ std::optional<u64> GenericEnvironment::TryFindSize() {
     return std::nullopt;
 }
 
-u32 ResolveBindlessHandleTable(Tegra::MemoryManager& gpu_memory, GPUVAddr record_addr,
-                               u32 raw_handle, u32 tic_index, u32 tic_limit) {
-    static constexpr u32 HandleRecordSize = 16;
-    static constexpr u32 MaxHandleTableBytes = 64 * 1024;
-
-    if (tic_index <= tic_limit) {
-        return raw_handle;
-    }
-    const u32 addr_low{gpu_memory.Read<u32>(record_addr)};
-    const u32 addr_high{gpu_memory.Read<u32>(record_addr + 4)};
-    const u32 table_size{gpu_memory.Read<u32>(record_addr + 8)};
-    const GPUVAddr table_addr{(static_cast<GPUVAddr>(addr_high) << 32) |
-                              static_cast<GPUVAddr>(addr_low)};
-    if (table_addr == 0 || table_size < HandleRecordSize || table_size > MaxHandleTableBytes) {
-        return raw_handle;
-    }
-    const u32 count{table_size / HandleRecordSize};
-    for (u32 i = 0; i < count; ++i) {
-        const GPUVAddr entry_addr{table_addr + static_cast<GPUVAddr>(i) * HandleRecordSize};
-        const u32 handle{gpu_memory.Read<u32>(entry_addr)};
-        const u32 live{gpu_memory.Read<u32>(entry_addr + 4)};
-        if (live != 0 && handle != 0 && handle <= tic_limit) {
-            return handle;
-        }
-    }
-    return raw_handle;
-}
-
 Tegra::Texture::TICEntry GenericEnvironment::ReadTextureInfo(GPUVAddr tic_addr, u32 tic_limit,
                                                              bool via_header_index, u32 raw) {
     const auto handle{Tegra::Texture::TexturePair(raw, via_header_index)};
@@ -449,9 +421,8 @@ ComputeEnvironment::ComputeEnvironment(Tegra::Engines::KeplerCompute& kepler_com
 
 u32 ComputeEnvironment::ReadCbufValue(u32 cbuf_index, u32 cbuf_offset) {
     const auto& qmd{kepler_compute->launch_description};
-    const u32 resolved_index{qmd.ResolveConstBufferIndex(cbuf_index)};
+    ASSERT(((qmd.const_buffer_enable_mask.Value() >> cbuf_index) & 1) != 0);
-    ASSERT(((qmd.const_buffer_enable_mask.Value() >> resolved_index) & 1) != 0);
+    const auto& cbuf{qmd.const_buffer_config[cbuf_index]};
-    const auto& cbuf{qmd.const_buffer_config[resolved_index]};
     u32 value{};
     if (cbuf_offset < cbuf.size) {
         value = gpu_memory->Read<u32>(cbuf.Address() + cbuf_offset);
@@ -460,25 +431,6 @@ u32 ComputeEnvironment::ReadCbufValue(u32 cbuf_index, u32 cbuf_offset) {
     return value;
 }
 
-u32 ComputeEnvironment::ResolveBindlessHandle(u32 cbuf_index, u32 cbuf_offset, u32 raw_handle) {
-    const auto& regs{kepler_compute->regs};
-    const auto& qmd{kepler_compute->launch_description};
-    const auto pair{Tegra::Texture::TexturePair(raw_handle, qmd.linked_tsc != 0)};
-    if (pair.first <= regs.tic.limit) {
-        return raw_handle;
-    }
-    const u32 resolved_index{qmd.ResolveConstBufferIndex(cbuf_index)};
-    if (((qmd.const_buffer_enable_mask.Value() >> resolved_index) & 1) == 0) {
-        return raw_handle;
-    }
-    const auto& cbuf{qmd.const_buffer_config[resolved_index]};
-    if (cbuf_offset + 12 > cbuf.size) {
-        return raw_handle;
-    }
-    return ResolveBindlessHandleTable(*gpu_memory, cbuf.Address() + cbuf_offset, raw_handle,
-                                      pair.first, regs.tic.limit);
-}
-
 Shader::TextureType ComputeEnvironment::ReadTextureType(u32 handle) {
     const auto& regs{kepler_compute->regs};
     const auto& qmd{kepler_compute->launch_description};

src/video_core/shader_environment.h

@@ -29,9 +29,6 @@ class Memorymanager;
 
 namespace VideoCommon {
 
-[[nodiscard]] u32 ResolveBindlessHandleTable(Tegra::MemoryManager& gpu_memory, GPUVAddr record_addr,
-                                             u32 raw_handle, u32 tic_index, u32 tic_limit);
-
 class GenericEnvironment : public Shader::Environment {
 public:
     explicit GenericEnvironment() = default;
@@ -143,8 +140,6 @@ public:
 
     u32 ReadCbufValue(u32 cbuf_index, u32 cbuf_offset) override;
 
-    u32 ResolveBindlessHandle(u32 cbuf_index, u32 cbuf_offset, u32 raw_handle) override;
-
     Shader::TextureType ReadTextureType(u32 handle) override;
 
     Shader::TexturePixelFormat ReadTexturePixelFormat(u32 handle) override;