debian fixes v2

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

src/common/slot_vector.h

@@ -33,7 +33,7 @@ struct SlotId {
 
 template <class T>
 // TODO: More "stable" debian fixes... wohoo
-#if __GNUC__ <= 12
+#if __GNUC__ > 12
     requires std::is_nothrow_move_assignable_v<T> && std::is_nothrow_move_constructible_v<T>
 #endif
 class SlotVector {

src/video_core/buffer_cache/buffer_cache.h

@@ -14,6 +14,7 @@
 #include "video_core/buffer_cache/buffer_cache_base.h"
 #include "video_core/guest_memory.h"
 #include "video_core/host1x/gpu_device_memory_manager.h"
+#include "video_core/texture_cache/util.h"
 
 namespace VideoCommon {
 

src/video_core/dma_pusher.cpp

@@ -12,6 +12,7 @@
 #include "video_core/guest_memory.h"
 #include "video_core/memory_manager.h"
 #include "video_core/rasterizer_interface.h"
+#include "video_core/texture_cache/util.h"
 
 namespace Tegra {
 
@@ -59,7 +60,7 @@ bool DmaPusher::Step() {
 
     if (command_list.prefetch_command_list.size()) {
         // Prefetched command list from nvdrv, used for things like synchronization
-        ProcessCommands(FixSmallVectorADL(command_list.prefetch_command_list));
+        ProcessCommands(VideoCommon::FixSmallVectorADL(command_list.prefetch_command_list));
         dma_pushbuffer.pop();
     } else {
         const CommandListHeader command_list_header{

src/video_core/memory_manager.cpp

@@ -12,12 +12,14 @@
 #include "core/core.h"
 #include "core/hle/kernel/k_page_table.h"
 #include "core/hle/kernel/k_process.h"
+#include "memory_manager.h"
 #include "video_core/guest_memory.h"
 #include "video_core/host1x/host1x.h"
 #include "video_core/invalidation_accumulator.h"
 #include "video_core/memory_manager.h"
 #include "video_core/rasterizer_interface.h"
 #include "video_core/renderer_base.h"
+#include "video_core/texture_cache/util.h"
 
 namespace Tegra {
 using Tegra::Memory::GuestMemoryFlags;
@@ -760,7 +762,7 @@ void MemoryManager::FlushCaching() {
     accumulator->Callback([this](GPUVAddr addr, size_t size) {
         GetSubmappedRangeImpl<false>(addr, size, page_stash2);
     });
-    rasterizer->InnerInvalidation(FixSmallVectorADL(page_stash2));
+    rasterizer->InnerInvalidation(VideoCommon::FixSmallVectorADL(page_stash2));
     page_stash2.clear();
     accumulator->Clear();
 }

src/video_core/renderer_vulkan/vk_buffer_cache.cpp

@@ -19,6 +19,7 @@
 #include "video_core/vulkan_common/vulkan_device.h"
 #include "video_core/vulkan_common/vulkan_memory_allocator.h"
 #include "video_core/vulkan_common/vulkan_wrapper.h"
+#include "video_core/texture_cache/util.h"
 
 namespace Vulkan {
 namespace {
@@ -459,7 +460,7 @@ void BufferCacheRuntime::CopyBuffer(VkBuffer dst_buffer, VkBuffer src_buffer,
     if (src_buffer == staging_pool.StreamBuf() && can_reorder_upload) {
         scheduler.RecordWithUploadBuffer([src_buffer, dst_buffer, vk_copies](
                                              vk::CommandBuffer, vk::CommandBuffer upload_cmdbuf) {
-            upload_cmdbuf.CopyBuffer(src_buffer, dst_buffer, vk_copies);
+            upload_cmdbuf.CopyBuffer(src_buffer, dst_buffer, FixSmallVectorADL(vk_copies));
         });
         return;
     }
@@ -470,7 +471,7 @@ void BufferCacheRuntime::CopyBuffer(VkBuffer dst_buffer, VkBuffer src_buffer,
             cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_ALL_COMMANDS_BIT,
                                    VK_PIPELINE_STAGE_TRANSFER_BIT, 0, READ_BARRIER);
         }
-        cmdbuf.CopyBuffer(src_buffer, dst_buffer, vk_copies);
+        cmdbuf.CopyBuffer(src_buffer, dst_buffer, FixSmallVectorADL(vk_copies));
         if (barrier) {
             cmdbuf.PipelineBarrier(VK_PIPELINE_STAGE_TRANSFER_BIT,
                                    VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, WRITE_BARRIER);

src/video_core/renderer_vulkan/vk_texture_cache.cpp

@@ -1473,7 +1473,7 @@ void TextureCacheRuntime::CopyImage(Image& dst, Image& src,
                 VK_PIPELINE_STAGE_TRANSFER_BIT,
                 0, nullptr, nullptr, pre_barriers);
         cmdbuf.CopyImage(src_image, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, dst_image,
-                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, vk_copies);
+                         VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL, VideoCommon::FixSmallVectorADL(vk_copies));
         cmdbuf.PipelineBarrier(
                 VK_PIPELINE_STAGE_TRANSFER_BIT,
                 VK_PIPELINE_STAGE_LATE_FRAGMENT_TESTS_BIT | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT |
@@ -1602,7 +1602,7 @@ void Image::UploadMemory(VkBuffer buffer, VkDeviceSize offset,
 
         scheduler->Record([src_buffer, temp_vk_image, vk_aspect_mask, vk_copies,
                            keep = temp_wrapper](vk::CommandBuffer cmdbuf) {
-            CopyBufferToImage(cmdbuf, src_buffer, temp_vk_image, vk_aspect_mask, false, vk_copies);
+            CopyBufferToImage(cmdbuf, src_buffer, temp_vk_image, vk_aspect_mask, false, VideoCommon::FixSmallVectorADL(vk_copies));
         });
 
         // Use MSAACopyPass to convert from non-MSAA to MSAA
@@ -1641,7 +1641,7 @@ void Image::UploadMemory(VkBuffer buffer, VkDeviceSize offset,
 
     scheduler->Record([src_buffer, vk_image, vk_aspect_mask, was_initialized,
                        vk_copies](vk::CommandBuffer cmdbuf) {
-        CopyBufferToImage(cmdbuf, src_buffer, vk_image, vk_aspect_mask, was_initialized, vk_copies);
+        CopyBufferToImage(cmdbuf, src_buffer, vk_image, vk_aspect_mask, was_initialized, VideoCommon::FixSmallVectorADL(vk_copies));
     });
 
     if (is_rescaled) {

src/video_core/shader_cache.cpp

@@ -4,6 +4,7 @@
 #include <algorithm>
 #include <array>
 #include <vector>
+#include <boost/container/small_vector.hpp>
 
 #include "common/assert.h"
 #include "shader_recompiler/frontend/maxwell/control_flow.h"
@@ -16,6 +17,7 @@
 #include "video_core/memory_manager.h"
 #include "video_core/shader_cache.h"
 #include "video_core/shader_environment.h"
+#include "video_core/texture_cache/util.h"
 
 namespace VideoCommon {
 
@@ -157,21 +159,22 @@ void ShaderCache::RemovePendingShaders() {
     std::ranges::sort(marked_for_removal);
     marked_for_removal.erase(std::unique(marked_for_removal.begin(), marked_for_removal.end()),
                              marked_for_removal.end());
-
+    // Linear growth anyways - maybe consider static_vector instead?
     boost::container::small_vector<ShaderInfo*, 16> removed_shaders;
-
     std::scoped_lock lock{lookup_mutex};
     for (Entry* const entry : marked_for_removal) {
         removed_shaders.push_back(entry->data);
-
-        const auto it = lookup_cache.find(entry->addr_start);
+        auto const it = lookup_cache.find(entry->addr_start);
         ASSERT(it != lookup_cache.end());
         lookup_cache.erase(it);
     }
     marked_for_removal.clear();
 
     if (!removed_shaders.empty()) {
-        RemoveShadersFromStorage(removed_shaders);
+        // Remove the given shaders from the cache
+        std::erase_if(storage, [&removed_shaders](const std::unique_ptr<ShaderInfo>& shader) {
+            return std::ranges::find(removed_shaders, shader.get()) != removed_shaders.end();
+        });
     }
 }
 
@@ -214,13 +217,6 @@ void ShaderCache::UnmarkMemory(Entry* entry) {
     device_memory.UpdatePagesCachedCount(addr, size, -1);
 }
 
-void ShaderCache::RemoveShadersFromStorage(std::span<ShaderInfo*> removed_shaders) {
-    // Remove them from the cache
-    std::erase_if(storage, [&removed_shaders](const std::unique_ptr<ShaderInfo>& shader) {
-        return std::ranges::find(removed_shaders, shader.get()) != removed_shaders.end();
-    });
-}
-
 ShaderCache::Entry* ShaderCache::NewEntry(VAddr addr, VAddr addr_end, ShaderInfo* data) {
     auto entry = std::make_unique<Entry>(Entry{addr, addr_end, data});
     Entry* const entry_pointer = entry.get();

src/video_core/shader_cache.h

@@ -136,12 +136,6 @@ private:
     /// @param entry Entry to unmark from memory
     void UnmarkMemory(Entry* entry);
 
-    /// @brief Removes a vector of shaders from a list
-    /// @param removed_shaders Shaders to be removed from the storage
-    /// @pre invalidation_mutex is locked
-    /// @pre lookup_mutex is locked
-    void RemoveShadersFromStorage(std::span<ShaderInfo*> removed_shaders);
-
     /// @brief Creates a new entry in the lookup cache and returns its pointer
     /// @pre lookup_mutex is locked
     Entry* NewEntry(VAddr addr, VAddr addr_end, ShaderInfo* data);

src/video_core/texture_cache/texture_cache.h

@@ -829,7 +829,7 @@ void TextureCache<P>::CommitAsyncFlushes() {
             for (const PendingDownload& download_info : download_ids) {
                 if (download_info.is_swizzle) {
                     Image& image = slot_images[download_info.object_id];
-                    const auto copies = FullDownloadCopies(image.info);
+                    const auto copies = FixSmallVectorADL(FullDownloadCopies(image.info));
                     image.DownloadMemory(download_map, copies);
                     download_map.offset += Common::AlignUp(image.unswizzled_size_bytes, 64);
                 }
@@ -862,11 +862,11 @@ void TextureCache<P>::PopAsyncFlushes() {
             auto& download_buffer = download_map[download_info.async_buffer_id];
             if (download_info.is_swizzle) {
                 const ImageBase& image = slot_images[download_info.object_id];
-                const auto copies = FullDownloadCopies(image.info);
+                const auto copies = FixSmallVectorADL(FullDownloadCopies(image.info));
                 download_buffer.offset -= Common::AlignUp(image.unswizzled_size_bytes, 64);
                 std::span<u8> download_span =
                     download_buffer.mapped_span.subspan(download_buffer.offset);
-                SwizzleImage(*gpu_memory, image.gpu_addr, image.info, FixSmallVectorADL(copies), download_span, swizzle_data_buffer);
+                SwizzleImage(*gpu_memory, image.gpu_addr, image.info, copies, download_span, swizzle_data_buffer);
             } else {
                 const BufferDownload& buffer_info = slot_buffer_downloads[download_info.object_id];
                 std::span<u8> download_span =
@@ -900,7 +900,7 @@ void TextureCache<P>::PopAsyncFlushes() {
                 continue;
             }
             Image& image = slot_images[download_info.object_id];
-            const auto copies = FullDownloadCopies(image.info);
+            const auto copies = FixSmallVectorADL(FullDownloadCopies(image.info));
             image.DownloadMemory(download_map, copies);
             download_map.offset += image.unswizzled_size_bytes;
         }
@@ -913,8 +913,8 @@ void TextureCache<P>::PopAsyncFlushes() {
                 continue;
             }
             const ImageBase& image = slot_images[download_info.object_id];
-            const auto copies = FullDownloadCopies(image.info);
-            SwizzleImage(*gpu_memory, image.gpu_addr, image.info, FixSmallVectorADL(copies), download_span, swizzle_data_buffer);
+            const auto copies = FixSmallVectorADL(FullDownloadCopies(image.info));
+            SwizzleImage(*gpu_memory, image.gpu_addr, image.info, copies, download_span, swizzle_data_buffer);
             download_map.offset += image.unswizzled_size_bytes;
             download_span = download_span.subspan(image.unswizzled_size_bytes);
         }
@@ -1324,7 +1324,7 @@ void TextureCache<P>::TickAsyncDecode() {
         auto staging = runtime.UploadStagingBuffer(MapSizeBytes(image));
         std::memcpy(staging.mapped_span.data(), async_decode->decoded_data.data(),
                     async_decode->decoded_data.size());
-        image.UploadMemory(staging, async_decode->copies);
+        image.UploadMemory(staging, FixSmallVectorADL(async_decode->copies));
         image.flags &= ~ImageFlagBits::IsDecoding;
         has_uploads = true;
         i = async_decodes.erase(i);

src/video_core/texture_cache/util.h

@@ -123,13 +123,17 @@ void DeduceBlitImages(ImageInfo& dst_info, ImageInfo& src_info, const ImageBase*
 [[nodiscard]] u32 MapSizeBytes(const ImageBase& image);
 
 // TODO: Remove once Debian STABLE no longer has such outdated boost
+// This is a gcc bug where ADL lookup fails for range niebloids of std::span<T>
+// for any given type of the static_vector/small_vector, etc which makes a whole mess
+// for anything using std::span<T> so we just do this terrible hack on older versions of
+// GCC12 because people actually still use stable debian so... yeah
 template<typename T, size_t N>
-#if BOOST_VERSION >= 108200
-[[nodiscard]] boost::container::small_vector<T, N> FixSmallVectorADL(const boost::container::small_vector<T, N>&& v) {
+#if BOOST_VERSION >= 108100 || __GNUC__ > 12
+[[nodiscard]] boost::container::small_vector<T, N> FixSmallVectorADL(const boost::container::small_vector<T, N>& v) {
     return v;
 }
 #else
-[[nodiscard]] std::vector<T> FixSmallVectorADL(const boost::container::small_vector<T, N>&& v) {
+[[nodiscard]] std::vector<T> FixSmallVectorADL(const boost::container::small_vector<T, N>& v) {
     std::vector<T> u;
     for (auto const& e : v)
         u.push_back(e);