#include "common/assert.h"
#include "common/emulatorConfig.h"
#include "common/hostException.h"
#include "common/logging/log.h"
#include "common/subsystems.h"
#include "common/threads.h"
#include "gpu_test_shaders/gpu_test_ms_depth_spv.h"
#include "graphics/guest_gpu/command_processor/commandProcessor.h"
#include "graphics/guest_gpu/command_processor/pm4Dispatch.h"
#include "graphics/guest_gpu/gpu_defs.h"
#include "graphics/guest_gpu/gpu_format.h"
#include "graphics/guest_gpu/graphicsRun.h"
#include "graphics/guest_gpu/hardwareContext.h"
#include "graphics/guest_gpu/pm4.h"
#include "graphics/guest_gpu/tile.h"
#include "graphics/host_gpu/hostMemory.h"
#include "graphics/host_gpu/memoryTracker.h"
#include "graphics/host_gpu/pageManager.h"
#include "graphics/host_gpu/renderer/cache/bufferCache.h"
#include "graphics/host_gpu/renderer/cache/textureCache.h"
#include "graphics/host_gpu/renderer/colorRenderTarget.h"
#include "graphics/host_gpu/renderer/depthRenderTarget.h"
#include "graphics/host_gpu/renderer/image/blitHelper.h"
#include "graphics/host_gpu/renderer/image/image.h"
#include "graphics/host_gpu/renderer/image/imageView.h"
#include "graphics/host_gpu/renderer/image/textureCommon.h"
#include "graphics/host_gpu/renderer/image/tiler.h"
#include "graphics/host_gpu/renderer/pipeline/descriptors.h"
#include "graphics/host_gpu/renderer/pipeline/pipelineCache.h"
#include "graphics/host_gpu/renderer/debug.h"
#include "graphics/host_gpu/renderer/render.h"
#include "graphics/host_gpu/renderer/renderContext.h"
#include "graphics/host_gpu/renderer/renderDraw.h"
#include "graphics/host_gpu/renderer/renderTarget.h"
#include "graphics/host_gpu/renderer/sync.h"
#include "graphics/host_gpu/vulkanCommon.h"
#include "graphics/presentation/window/windowInternal.h"
#include "graphics/shader/recompiler/ShaderRecompiler.h"
#include "graphics/shader/recompiler/Tessellation.h"
#include "graphics/shader/recompiler/backend/spirv/SpirvBuilder.h"
#include "graphics/shader/recompiler/backend/spirv/SpirvEmitter.h"
#include "graphics/shader/recompiler/frontend/decode/ShaderDecoder.h"
#include "graphics/shader/recompiler/ir/ShaderIR.h"
#include "graphics/shader/recompiler/ir/passes/BindingLayout.h"
#include "graphics/shader/rectListShader.h"
#include "graphics/shader/shader.h"
#include "graphics/shader/shaderCompiler.h"
#include "kernel/eventQueue.h"
#include "kernel/memory.h"
#include "libs/agc.h"
#include "libs/dialog.h"
#include "libs/errno.h"
#include "spirv-tools/libspirv.hpp"

#if __has_include("graphics/host_gpu/renderer/renderTargetBarriers.h")
#error "legacy render-target barrier API must remain deleted"
#endif

#if __has_include("graphics/host_gpu/transfer.h")
#error "legacy transfer facade must remain deleted"
#endif

#if __has_include("graphics/host_gpu/renderer/framebufferCache.h")
#error "classic framebuffer/render-pass cache must remain deleted"
#endif

#include <algorithm>
#include <array>
#include <atomic>
#include <bit>
#include <chrono>
#include <cinttypes>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <initializer_list>
#include <limits>
#include <memory>
#include <mutex>
#include <numeric>
#include <optional>
#include <semaphore>
#include <set>
#include <span>
#include <sstream>
#include <string>
#include <string_view>
#include <vector>

#if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS
#include <cerrno>
#include <sys/wait.h>
#include <unistd.h>
#endif

#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
#ifndef NOMINMAX
#define NOMINMAX
#endif
#include <windows.h>
#undef min
#undef max
#endif

namespace Libs::Graphics {

template <typename Cache>
concept HasGetDownloadBuffer =
    requires(Cache &cache) { cache.GetDownloadBuffer(uint64_t{1}); };
static_assert(!HasGetDownloadBuffer<BufferCache>);
static_assert(std::same_as<decltype(&BufferCache::GetBuffer),
                           Buffer &(BufferCache::*)(BufferId)>);
static_assert(std::same_as<decltype(&TextureCache::GetImage),
                           Image &(TextureCache::*)(ImageId)>);

template <typename Cache>
concept HasSynchronizeImageToBuffer = requires(Cache &cache) {
  cache.SynchronizeImageToBuffer(uint64_t{1}, uint64_t{1});
};
template <typename Cache>
concept HasObtainBufferForImageCopy = requires(Cache &cache) {
  cache.ObtainBufferForImageCopy(uint64_t{1}, uint64_t{1});
};
template <typename Cache>
concept HasObtainBufferForImageWrite = requires(Cache &cache) {
  cache.ObtainBufferForImageWrite(uint64_t{1}, uint64_t{1});
};
template <typename Cache>
concept HasDiscardGpuDirtyBytes = requires(Cache &cache) {
  cache.DiscardGpuDirtyBytes(uint64_t{1}, uint64_t{1});
};
static_assert(!HasSynchronizeImageToBuffer<TextureCache>);
static_assert(!HasObtainBufferForImageCopy<BufferCache>);
static_assert(!HasObtainBufferForImageWrite<BufferCache>);
static_assert(!HasDiscardGpuDirtyBytes<BufferCache>);

template <typename Backing>
concept HasLegacyImageLayout = requires(Backing &backing) { backing.layout; };
static_assert(!HasLegacyImageLayout<VulkanImage>);

template <typename Manager>
concept HasPolicyDetileImage = requires { &Manager::DetileImage; };
template <typename Manager>
concept HasPolicyTileImageBacking = requires { &Manager::TileImageBacking; };
static_assert(!HasPolicyDetileImage<TileManager>);
static_assert(!HasPolicyTileImageBacking<TileManager>);
static_assert(BlitHelper::ColorToMsDepthLayout ==
              vk::ImageLayout::eDepthStencilAttachmentOptimal);

struct BufferCacheTestAccess {
  static_assert(std::same_as<decltype(BufferCache::m_slot_buffers),
                             Common::SlotVector<Buffer>>);

  static void SetGarbageCollectionThresholds(BufferCache &cache,
                                             uint64_t trigger,
                                             uint64_t critical) {
    cache.m_trigger_gc_memory = trigger;
    cache.m_critical_gc_memory = critical;
  }

  static StreamBuffer &DownloadBuffer(BufferCache &cache) {
    return cache.m_download_buffer;
  }

  static bool SynchronizeBufferFromImage(BufferCache &cache, Buffer &buffer,
                                         uint64_t address, uint64_t size) {
    return cache.SynchronizeBufferFromImage(buffer, address, size);
  }

  static BufferId PageOwner(const BufferCache &cache, uint64_t address) {
    const auto *owner = cache.m_page_table.Find(
        address >> BufferCache::PageTable::kPageBits);
    return owner == nullptr ? BufferId{} : *owner;
  }

  static bool IsBufferAllocated(const BufferCache &cache, BufferId id) {
    return cache.m_slot_buffers.is_allocated(id);
  }
};

struct StreamBufferTestAccess {
  static bool NormalizeReservation(bool coherent, uint64_t atom, uint64_t &size,
                                   uint64_t &alignment) {
    return StreamBuffer::NormalizeReservation(coherent, atom, size, alignment);
  }
};

struct ImageTestAccess {
  static uint32_t CopyRows(uint64_t row_size, uint32_t rows,
                           uint64_t capacity) {
    return Image::CopyRows(row_size, rows, capacity);
  }
};

struct TileManagerTestAccess {
  static uint32_t ConversionRows(uint64_t offset, uint64_t row_stride,
                                 uint64_t active, uint32_t remaining,
                                 uint64_t alignment, uint64_t max_range,
                                 uint32_t max_groups) {
    return TileManager::ConversionRows(offset, row_stride, active, remaining,
                                       alignment, max_range, max_groups);
  }
};

struct TextureCacheTestAccess {
  static_assert(std::same_as<decltype(TextureCache::m_slot_images),
                             Common::SlotVector<Image>>);
  static_assert(TextureCache::ImagePageTable::kPageBits == 20);
  static_assert(TextureCache::ImagePageTable::kAddressSpaceBits == 40);
  static_assert(TextureCache::ImagePageTable::kFirstLevelBits == 10);

  static std::unique_lock<TrackingSpinLock> Lock(TextureCache &cache) {
    return std::unique_lock(cache.m_lock);
  }

  static void ClearImage(TextureCache &cache, CommandBuffer &command, ImageId id,
                         const vk::ImageSubresourceRange &range,
                         const vk::ClearValue &clear) {
    auto lock = Lock(cache);
    cache.ClearImage(command, id, cache.GetImage(id).backing.format, range, clear);
  }

  static void ConfigureGarbageCollection(TextureCache &cache,
                                         std::span<const ImageId> oldest,
                                         uint64_t tick, uint64_t pressure) {
    cache.m_trigger_gc_memory = 0;
    cache.m_pressure_gc_memory = pressure;
    cache.m_critical_gc_memory = UINT64_MAX;
    cache.m_gc_tick = tick;
    std::vector<ImageId> live;
    cache.m_lru_cache = {};
    cache.m_slot_images.ForEach([&](ImageId id, Image &image) {
      if (image.registered) {
        image.tick_accessed_last = cache.m_scheduler.CurrentTick();
        live.push_back(id);
      }
    });
    for (const auto id : oldest) {
      const auto owner = cache.m_slot_images.try_get(id);
      if (owner != nullptr && owner->registered) {
        owner->tick_accessed_last = 0;
        owner->lru_id = cache.m_lru_cache.Insert(id, 0);
      }
    }
    for (const auto id : live) {
      if (std::ranges::find(oldest, id) == oldest.end()) {
        cache.m_slot_images[id].lru_id = cache.m_lru_cache.Insert(id, tick);
      }
    }
  }

  static bool Contains(const TextureCache &cache, ImageId id) {
    const auto owner = cache.m_slot_images.try_get(id);
    return owner != nullptr && owner->registered;
  }

  static std::vector<ImageId> FindImages(TextureCache &cache, uint64_t address,
                                         uint64_t size, bool page_overlap) {
    std::lock_guard lock(cache.m_lock);
    const auto found = cache.FindImagesInRegion(address, size, page_overlap);
    std::vector<ImageId> result;
    result.reserve(found.size());
    for (const auto id : found) {
      result.push_back(id);
    }
    return result;
  }

  static size_t PageOwnerCount(TextureCache &cache, uint64_t address) {
    std::lock_guard lock(cache.m_lock);
    const auto *owners = cache.m_image_page_table.Find(static_cast<size_t>(
        address >> TextureCache::ImagePageTable::kPageBits));
    return owners == nullptr ? 0 : owners->size();
  }

  static size_t OwnedPageCount(TextureCache &cache, uint64_t address,
                               uint64_t size, ImageId id) {
    std::lock_guard lock(cache.m_lock);
    TextureCache::ImagePageTable::PageRange pages{};
    if (!TextureCache::ImagePageTable::TryGetPageRange(address, size, pages)) {
      return 0;
    }
    size_t count = 0;
    for (size_t page = pages.first; page < pages.last_exclusive; ++page) {
      const auto *owners = cache.m_image_page_table.Find(page);
      count += owners != nullptr && owners->Contains(id) ? 1 : 0;
    }
    return count;
  }

  static void AddPageOwner(TextureCache &cache, uint64_t address, ImageId id) {
    std::lock_guard lock(cache.m_lock);
    cache
        .m_image_page_table[static_cast<size_t>(
            address >> TextureCache::ImagePageTable::kPageBits)]
        .push_back(id);
  }

  static bool RemovePageOwner(TextureCache &cache, uint64_t address,
                              ImageId id) {
    std::lock_guard lock(cache.m_lock);
    auto *owners = cache.m_image_page_table.Find(static_cast<size_t>(
        address >> TextureCache::ImagePageTable::kPageBits));
    return owners != nullptr && owners->Erase(id);
  }

  static void SetQueryEpoch(TextureCache &cache, uint32_t epoch) {
    std::lock_guard lock(cache.m_lock);
    cache.m_image_query_epoch = epoch;
  }

  static uint32_t QueryEpoch(TextureCache &cache) {
    std::lock_guard lock(cache.m_lock);
    return cache.m_image_query_epoch;
  }

  static ImageId InsertImage(TextureCache &cache, const ImageInfo &info) {
    std::lock_guard lock(cache.m_lock);
    return cache.InsertImage(info);
  }

  static void DeleteImage(TextureCache &cache, ImageId id) {
    std::lock_guard lock(cache.m_lock);
    cache.DeleteImage(id);
  }

  static const Image *Owner(const TextureCache &cache, ImageId id) {
    return cache.m_slot_images.try_get(id);
  }

  static bool PendingDownload(const TextureCache &cache, ImageId id) {
    return cache.m_download_images.contains(id);
  }

  static size_t NullImageCount(const TextureCache &cache) {
    return cache.m_null_images.size();
  }

  static void TrackDownload(TextureCache &cache, ImageId id) {
    std::lock_guard lock(cache.m_lock);
    cache.TrackImageDownload(id, cache.m_slot_images[id]);
  }

  static void AssociateStencil(TextureCache &cache, ImageId depth,
                               GuestRange stencil) {
    std::lock_guard lock(cache.m_lock);
    cache.AssociateStencil(depth, stencil);
  }

  static void SetLinearReadback(TextureCache &cache, bool enabled) {
    cache.m_readback_linear_images = enabled;
  }

  static std::pair<uint8_t *, uint64_t>
  MapDownload(TextureCache &cache, uint64_t size, uint64_t alignment) {
    auto &download =
        cache.m_buffer_cache.GetUtilityBuffer(MemoryUsage::Download);
    auto mapping = download.Map(size, std::max<uint64_t>(alignment, 4));
    if (mapping.first != nullptr) {
      download.Commit();
    }
    return mapping;
  }

  static bool TryDownload(TextureCache &cache, ImageId id) {
    return cache.DownloadImageMemory(id);
  }

  static void RegisterHtileMeta(TextureCache &cache, uint64_t address) {
    std::lock_guard lock(cache.m_lock);
    auto &metadata = cache.m_surface_metas[address];
    metadata.type = TextureCache::MetaDataInfo::Type::HTile;
    metadata.clear_mask = 0;
  }

  static TileManager &Tiler(TextureCache &cache) { return cache.m_tiler; }
};

struct RenderExecutorTestAccess {
  static void DrawAuto(RenderExecutor &executor, CommandBuffer &command,
                       const DrawAutoArgs &args) {
    executor.DrawAuto(0, command, args);
  }

  static bool TryConsumeComputeImageClear(RenderExecutor &executor,
      const ShaderComputeInputInfo &input, CommandBuffer &command,
      uint32_t x, uint32_t y, uint32_t z, uint32_t mode) {
    return executor.TryConsumeComputeImageClear(input, command, x, y, z, mode);
  }

  static bool TryConsumeComputeMetaClear(RenderExecutor &executor,
                                         const ShaderComputeInputInfo &input,
                                         const CommandBuffer &buffer) {
    return executor.TryConsumeComputeMetaClear(input, buffer);
  }

  static TextureBinding
  ResolveTexture(RenderExecutor &executor,
                 const ShaderRecompiler::IR::ImageResource &resource,
                 const ShaderRecompiler::IR::DescriptorValue &value) {
    return executor.ResolveTexture(resource, value);
  }

  static auto PrepareGraphicsBindings(RenderExecutor &executor,
                                      const ShaderStageRuntime &vertex,
                                      const ShaderStageRuntime &pixel,
                                      bool pixel_active) {
    RenderExecutor::GraphicsBindings result;
    result.vertex[0] = executor.PrepareBindings(vertex);
    std::array<PreparedBindings *, 2> stages{&result.vertex[0], nullptr};
    if (pixel_active) {
      result.pixel.emplace(executor.PrepareBindings(pixel));
      stages[1] = &*result.pixel;
    }
    executor.PrepareGraphicsBindings(
        std::span{stages.data(), pixel_active ? 2u : 1u}, {});
    return result;
  }

  static void PrepareGraphicsBindings(RenderExecutor &executor,
                                      std::span<PreparedBindings *const> stages,
                                      std::span<RenderColorInfo> colors) {
    executor.PrepareGraphicsBindings(stages, colors);
  }

  static PipelineCache::Pipeline
  CreateDescriptorPipeline(RenderExecutor &executor,
                           std::span<PreparedBindings *const> stages) {
    std::vector<vk::DescriptorSetLayoutBinding> layout_bindings;
    bool compute = false;
    for (const auto *prepared : stages) {
      const auto &program = *prepared->runtime->program;
      compute |= program.stage == ShaderType::Compute;
      const auto shader_stage = program.stage == ShaderType::Vertex
                                    ? vk::ShaderStageFlagBits::eVertex
                                : program.stage == ShaderType::Pixel
                                    ? vk::ShaderStageFlagBits::eFragment
                                    : vk::ShaderStageFlagBits::eCompute;
      for (const auto &binding : program.bindings.descriptors) {
        layout_bindings.push_back(
            {ShaderRecompiler::IR::NativeBinding(program.stage, binding.kind),
             NativeDescriptorType(binding.kind), NativeDescriptorCount(binding),
             shader_stage});
      }
    }
    vk::DescriptorSetLayoutCreateInfo descriptor_info{};
    descriptor_info.sType = vk::StructureType::eDescriptorSetLayoutCreateInfo;
    descriptor_info.flags =
        vk::DescriptorSetLayoutCreateFlagBits::ePushDescriptorKHR;
    descriptor_info.bindingCount =
        static_cast<uint32_t>(layout_bindings.size());
    descriptor_info.pBindings = layout_bindings.data();
    PipelineCache::Pipeline pipeline{};
    auto &device = executor.m_context.GetGraphics().device;
    EXIT_IF(device.createDescriptorSetLayout(&descriptor_info, nullptr,
                                             &pipeline.descriptor_set_layout) !=
            vk::Result::eSuccess);

    vk::PipelineLayoutCreateInfo pipeline_info{};
    pipeline_info.sType = vk::StructureType::ePipelineLayoutCreateInfo;
    pipeline_info.setLayoutCount = 1;
    pipeline_info.pSetLayouts = &pipeline.descriptor_set_layout;
    const vk::PushConstantRange push_range {
        compute ? vk::ShaderStageFlags {vk::ShaderStageFlagBits::eCompute}
                : vk::ShaderStageFlags {vk::ShaderStageFlagBits::eVertex |
                                       vk::ShaderStageFlagBits::eFragment},
        0, ShaderRecompiler::IR::NativePushConstantSize};
    pipeline_info.pushConstantRangeCount = 1;
    pipeline_info.pPushConstantRanges = &push_range;
    EXIT_IF(device.createPipelineLayout(&pipeline_info, nullptr,
                                        &pipeline.pipeline_layout) !=
            vk::Result::eSuccess);
    pipeline.uses_push_descriptors = true;
    return pipeline;
  }

  static PipelineCache::Pipeline CommitBindings(RenderExecutor &executor,
                                                CommandBuffer &buffer,
                                                PreparedBindings &bindings) {
    std::array<PreparedBindings *, 1> stages{&bindings};
    auto pipeline = CreateDescriptorPipeline(executor, stages);
    const auto bind_point = bindings.runtime->program->stage == ShaderType::Compute
                                ? vk::PipelineBindPoint::eCompute
                                : vk::PipelineBindPoint::eGraphics;
    executor.CommitBindings(buffer, bind_point, pipeline, stages);
    return pipeline;
  }

  static PipelineCache::Pipeline CommitBindings(RenderExecutor &executor,
                                                CommandBuffer &buffer,
                                                PreparedBindings &vertex,
                                                PreparedBindings &pixel) {
    std::array<PreparedBindings *, 2> stages{&vertex, &pixel};
    auto pipeline = CreateDescriptorPipeline(executor, stages);
    executor.CommitBindings(buffer, vk::PipelineBindPoint::eGraphics, pipeline,
                            stages);
    return pipeline;
  }

  static void CommitBindings(RenderExecutor &executor, CommandBuffer &buffer,
                             const PipelineCache::Pipeline &pipeline,
                             PreparedBindings &vertex, PreparedBindings &pixel) {
    std::array<PreparedBindings *, 2> stages{&vertex, &pixel};
    executor.CommitBindings(buffer, vk::PipelineBindPoint::eGraphics, pipeline,
                            stages);
  }

  static void DestroyDescriptorPipelines(
      RenderExecutor &executor,
      std::span<const PipelineCache::Pipeline> pipelines) {
    auto &device = executor.m_context.GetGraphics().device;
    for (const auto &pipeline : pipelines) {
      device.destroyPipelineLayout(pipeline.pipeline_layout, nullptr);
      device.destroyDescriptorSetLayout(pipeline.descriptor_set_layout,
                                        nullptr);
    }
  }

  static void ResolveRenderDepthTarget(RenderExecutor &executor,
                                       CommandBuffer &buffer,
                                       RenderDepthInfo &depth) {
    executor.ResolveRenderDepthTarget(buffer, depth);
  }

  static bool DepthStencilCopy(RenderExecutor &executor, CommandBuffer &buffer) {
    return executor.DepthStencilCopy(buffer);
  }

  static void ResolveRenderColorTarget(RenderExecutor &executor,
                                       CommandBuffer &buffer,
                                       RenderColorInfo &color, uint32_t slot) {
    executor.ResolveRenderColorTarget(buffer, color, 0, slot);
  }

  static void BindRenderTarget(RenderExecutor &executor, ImageId id) {
    executor.BindRenderTarget(id);
  }

  static RenderState AcquireRenderTargets(RenderExecutor &executor,
                                          CommandBuffer &buffer,
                                          RenderColorInfo *colors,
                                          uint32_t color_count,
                                          RenderDepthInfo &depth,
                                          const std::optional<PreparedBindings> &pixel = std::nullopt) {
    return executor.AcquireRenderTargets(buffer, colors, color_count, depth, pixel);
  }

  static void ResetBindings(RenderExecutor &executor) {
    executor.ResetBindings();
  }

  static bool BoundImagesInOrder(const RenderExecutor &executor, ImageId first,
                                 ImageId second) {
    return executor.m_bound_images.size() == 2 &&
           executor.m_bound_images[0] == first &&
           executor.m_bound_images[1] == second;
  }
};

namespace {

using u32 = uint32_t;
using BindingType = TextureCache::BindingType;
using ImageDesc = TextureCache::ImageDesc;
using ShaderOpcode = ShaderRecompiler::Decoder::Opcode;

constexpr u32 InlineU32(u32 value) { return 128u + value; }

constexpr u32 Vgpr(u32 reg) { return 256u + reg; }

constexpr u32 EncodeSMovB32(u32 dst, u32 src) {
  return 0x80000000u | (0x7du << 23u) | ((dst & 0x7fu) << 16u) | (0x03u << 8u) |
         (src & 0xffu);
}

constexpr u32 EncodeSop1(u32 opcode, u32 dst, u32 src) {
  return 0x80000000u | (0x7du << 23u) | ((dst & 0x7fu) << 16u) |
         ((opcode & 0xffu) << 8u) | (src & 0xffu);
}

constexpr u32 EncodeSop2(u32 opcode, u32 dst, u32 src0, u32 src1) {
  return 0x80000000u | ((opcode & 0x7fu) << 23u) | ((dst & 0x7fu) << 16u) |
         ((src1 & 0xffu) << 8u) | (src0 & 0xffu);
}

constexpr u32 EncodeSopc(u32 opcode, u32 src0, u32 src1) {
  return 0x80000000u | (0x7eu << 23u) | ((opcode & 0x7fu) << 16u) |
         ((src1 & 0xffu) << 8u) | (src0 & 0xffu);
}

constexpr u32 EncodeSopp(u32 opcode, u32 simm = 0) {
  return 0x80000000u | (0x7fu << 23u) | ((opcode & 0x7fu) << 16u) |
         (simm & 0xffffu);
}

constexpr u32 EncodeSopk(u32 opcode, u32 dst, u32 imm) {
  return 0x80000000u | (((opcode + 0x60u) & 0x7fu) << 23u) |
         ((dst & 0x7fu) << 16u) | (imm & 0xffffu);
}

constexpr u32 EncodeVop1(u32 opcode, u32 dst, u32 src0) {
  return (0x3fu << 25u) | ((dst & 0xffu) << 17u) | ((opcode & 0xffu) << 9u) |
         (src0 & 0x1ffu);
}

constexpr u32 EncodeVop1Sdwa(u32 src0, u32 dst_sel = 6, u32 dst_u = 0,
                             u32 src0_sel = 6, u32 src0_sext = 0,
                             u32 src0_neg = 0, u32 src0_abs = 0, u32 s0 = 0,
                             u32 clamp = 0, u32 omod = 0) {
  return (src0 & 0xffu) | ((dst_sel & 0x7u) << 8u) | ((dst_u & 0x3u) << 11u) |
         ((clamp & 0x1u) << 13u) | ((omod & 0x3u) << 14u) |
         ((src0_sel & 0x7u) << 16u) | ((src0_sext & 0x1u) << 19u) |
         ((src0_neg & 0x1u) << 20u) | ((src0_abs & 0x1u) << 21u) |
         ((s0 & 0x1u) << 23u);
}

constexpr u32 EncodeVop1Dpp(u32 src0, u32 dpp_ctrl = 0, u32 row_mask = 0xf,
                            u32 bank_mask = 0xf) {
  return (src0 & 0xffu) | ((dpp_ctrl & 0x1ffu) << 8u) |
         ((bank_mask & 0xfu) << 24u) | ((row_mask & 0xfu) << 28u);
}

constexpr u32 EncodeVop2(u32 opcode, u32 dst, u32 src0, u32 src1) {
  return ((opcode & 0x3fu) << 25u) | ((dst & 0xffu) << 17u) |
         ((src1 & 0xffu) << 9u) | (src0 & 0x1ffu);
}

constexpr u32 EncodeVop2Sdwa(u32 src0, u32 dst_sel = 6, u32 dst_u = 0,
                             u32 src0_sel = 6, u32 src1_sel = 6,
                             u32 src0_sext = 0, u32 src1_sext = 0,
                             u32 src0_neg = 0, u32 src0_abs = 0,
                             u32 src1_neg = 0, u32 src1_abs = 0, u32 s0 = 0,
                             u32 s1 = 0, u32 clamp = 0, u32 omod = 0) {
  return (src0 & 0xffu) | ((dst_sel & 0x7u) << 8u) | ((dst_u & 0x3u) << 11u) |
         ((clamp & 0x1u) << 13u) | ((omod & 0x3u) << 14u) |
         ((src0_sel & 0x7u) << 16u) | ((src0_sext & 0x1u) << 19u) |
         ((src0_neg & 0x1u) << 20u) | ((src0_abs & 0x1u) << 21u) |
         ((s0 & 0x1u) << 23u) | ((src1_sel & 0x7u) << 24u) |
         ((src1_sext & 0x1u) << 27u) | ((src1_neg & 0x1u) << 28u) |
         ((src1_abs & 0x1u) << 29u) | ((s1 & 0x1u) << 31u);
}

constexpr u32 EncodeVop2Dpp(u32 src0, u32 dpp_ctrl = 0, u32 row_mask = 0xf,
                            u32 bank_mask = 0xf, u32 src0_neg = 0,
                            u32 src0_abs = 0, u32 src1_neg = 0,
                            u32 src1_abs = 0) {
  return (src0 & 0xffu) | ((dpp_ctrl & 0x1ffu) << 8u) |
         ((src0_neg & 0x1u) << 20u) | ((src0_abs & 0x1u) << 21u) |
         ((src1_neg & 0x1u) << 22u) | ((src1_abs & 0x1u) << 23u) |
         ((bank_mask & 0xfu) << 24u) | ((row_mask & 0xfu) << 28u);
}

constexpr u32 EncodeVop3Word0(u32 opcode, u32 dst, u32 abs = 0, u32 op_sel = 0,
                              bool clamp = false) {
  return (0x35u << 26u) | ((opcode & 0x3ffu) << 16u) | ((abs & 0x7u) << 8u) |
         ((op_sel & 0xfu) << 11u) | (clamp ? (1u << 15u) : 0u) | (dst & 0xffu);
}

constexpr u32 EncodeVop3BWord0(u32 opcode, u32 vdst, u32 sdst) {
  return (0x35u << 26u) | ((opcode & 0x3ffu) << 16u) | ((sdst & 0x7fu) << 8u) |
         (vdst & 0xffu);
}

constexpr u32 EncodeVop3Word1(u32 src0, u32 src1, u32 src2 = 0, u32 omod = 0,
                              u32 neg = 0) {
  return (src0 & 0x1ffu) | ((src1 & 0x1ffu) << 9u) | ((src2 & 0x1ffu) << 18u) |
         ((omod & 0x3u) << 27u) | ((neg & 0x7u) << 29u);
}

constexpr u32 EncodeVop3pWord0(u32 opcode, u32 dst, u32 op_sel_hi = 0,
                               u32 op_sel = 0, u32 neg_hi = 0,
                               bool clamp = false) {
  return (0x33u << 26u) | ((opcode & 0x7fu) << 16u) | ((neg_hi & 0x7u) << 8u) |
         ((op_sel & 0x7u) << 11u) | (((op_sel_hi >> 2u) & 0x1u) << 14u) |
         (clamp ? (1u << 15u) : 0u) | (dst & 0xffu);
}

constexpr u32 EncodeVop3pWord1(u32 src0, u32 src1, u32 src2 = 0,
                               u32 op_sel_hi = 0, u32 neg = 0) {
  return (src0 & 0x1ffu) | ((src1 & 0x1ffu) << 9u) | ((src2 & 0x1ffu) << 18u) |
         ((op_sel_hi & 0x3u) << 27u) | ((neg & 0x7u) << 29u);
}

constexpr u32 EncodeVopc(u32 opcode, u32 src0, u32 src1) {
  return (0x3eu << 25u) | ((opcode & 0xffu) << 17u) | ((src1 & 0xffu) << 9u) |
         (src0 & 0x1ffu);
}

constexpr u32 EncodeVopcSdwa(u32 src0, u32 sdst = 0, u32 sd = 0,
                             u32 src0_sel = 6, u32 src1_sel = 6,
                             u32 src0_sext = 0, u32 src1_sext = 0,
                             u32 src0_neg = 0, u32 src0_abs = 0,
                             u32 src1_neg = 0, u32 src1_abs = 0, u32 s0 = 0,
                             u32 s1 = 0) {
  return (src0 & 0xffu) | ((sdst & 0x7fu) << 8u) | ((sd & 0x1u) << 15u) |
         ((src0_sel & 0x7u) << 16u) | ((src0_sext & 0x1u) << 19u) |
         ((src0_neg & 0x1u) << 20u) | ((src0_abs & 0x1u) << 21u) |
         ((s0 & 0x1u) << 23u) | ((src1_sel & 0x7u) << 24u) |
         ((src1_sext & 0x1u) << 27u) | ((src1_neg & 0x1u) << 28u) |
         ((src1_abs & 0x1u) << 29u) | ((s1 & 0x1u) << 31u);
}

constexpr u32 EncodeMubuf0(u32 opcode, u32 offset = 0, bool idxen = false,
                           bool offen = true, bool glc = false) {
  return (0x38u << 26u) | ((opcode & 0x7fu) << 18u) |
         (offen ? (1u << 12u) : 0u) | (idxen ? (1u << 13u) : 0u) |
         (glc ? (1u << 14u) : 0u) | (offset & 0xfffu);
}

constexpr u32 EncodeMubuf1(u32 vdata, u32 srsrc, u32 vaddr, u32 soffset = 128) {
  return ((soffset & 0xffu) << 24u) | ((srsrc & 0x1fu) << 16u) |
         ((vdata & 0xffu) << 8u) | (vaddr & 0xffu);
}

constexpr u32 EncodeMtbuf0(u32 opcode, u32 dfmt, u32 nfmt, u32 offset = 0,
                           bool idxen = false, bool offen = true) {
  return (0x3au << 26u) | (offset & 0xfffu) | (offen ? (1u << 12u) : 0u) |
         (idxen ? (1u << 13u) : 0u) | ((opcode & 0x7u) << 16u) |
         ((dfmt & 0xfu) << 19u) | ((nfmt & 0x7u) << 23u);
}

constexpr u32 EncodeMtbuf1(u32 opcode, u32 vdata, u32 srsrc, u32 vaddr,
                           u32 soffset = 128) {
  return (((opcode >> 3u) & 1u) << 21u) | ((soffset & 0xffu) << 24u) |
         ((srsrc & 0x1fu) << 16u) | ((vdata & 0xffu) << 8u) | (vaddr & 0xffu);
}

constexpr u32 EncodeSmem0(u32 opcode, u32 dst, u32 sbase = 0) {
  return (0x3du << 26u) | ((opcode & 0xffu) << 18u) | ((dst & 0x7fu) << 6u) |
         (sbase & 0x3fu);
}

constexpr u32 EncodeSmem1(u32 offset, u32 soffset = 0) {
  return (offset & 0x1fffffu) | ((soffset & 0x7fu) << 25u);
}

constexpr u32 EncodeMimg0(u32 opcode, u32 dmask, u32 nsa_dwords = 0,
                          bool glc = false, u32 dim = 1, bool r128 = false) {
  return (0x3cu << 26u) | ((opcode >> 7u) & 0x1u) |
         ((nsa_dwords & 0x3u) << 1u) | ((dim & 0x7u) << 3u) |
         ((dmask & 0xfu) << 8u) | (glc ? (1u << 13u) : 0u) |
         (r128 ? (1u << 15u) : 0u) | ((opcode & 0x7fu) << 18u);
}

constexpr u32 EncodeMimg1(u32 vdata, u32 vaddr, u32 srsrc = 0, u32 ssamp = 0,
                          bool a16 = false, bool d16 = false) {
  return ((ssamp & 0x1fu) << 21u) | ((srsrc & 0x1fu) << 16u) |
         ((vdata & 0xffu) << 8u) | (vaddr & 0xffu) | (a16 ? (1u << 30u) : 0u) |
         (d16 ? (1u << 31u) : 0u);
}

constexpr u32 EncodeVintrp(u32 opcode, u32 dst, u32 attr, u32 chan, u32 src) {
  return (0x32u << 26u) | ((dst & 0xffu) << 18u) | ((opcode & 0x3u) << 16u) |
         ((attr & 0x3fu) << 10u) | ((chan & 0x3u) << 8u) | (src & 0xffu);
}

constexpr u32 EncodeExp0(u32 target, u32 en, bool done = true,
                         bool compr = false, bool vm = false) {
  return (0x3eu << 26u) | ((target & 0x3fu) << 4u) | (en & 0xfu) |
         (compr ? (1u << 10u) : 0u) | (done ? (1u << 11u) : 0u) |
         (vm ? (1u << 12u) : 0u);
}

constexpr u32 EncodeExp1(u32 src0, u32 src1, u32 src2, u32 src3) {
  return (src0 & 0xffu) | ((src1 & 0xffu) << 8u) | ((src2 & 0xffu) << 16u) |
         ((src3 & 0xffu) << 24u);
}

constexpr u32 EncodeFlat0(u32 opcode, u32 segment, u32 offset = 0) {
  return (0x37u << 26u) | ((opcode & 0x7fu) << 18u) |
         ((segment & 0x3u) << 14u) | (offset & 0xfffu);
}

constexpr u32 EncodeFlat1(u32 vdst, u32 saddr, u32 data, u32 addr) {
  return ((vdst & 0xffu) << 24u) | ((saddr & 0x7fu) << 16u) |
         ((data & 0xffu) << 8u) | (addr & 0xffu);
}

constexpr u32 EncodeDs0(u32 opcode, u32 offset = 0, bool gds = false) {
  return (0x36u << 26u) | ((opcode & 0xffu) << 18u) | (gds ? (1u << 17u) : 0u) |
         (offset & 0xffffu);
}

constexpr u32 EncodeDs1Ex(u32 vdst, u32 data1, u32 data0, u32 addr) {
  return ((vdst & 0xffu) << 24u) | ((data1 & 0xffu) << 16u) |
         ((data0 & 0xffu) << 8u) | (addr & 0xffu);
}

constexpr u32 EncodeDs1(u32 vdst, u32 data0, u32 addr) {
  return EncodeDs1Ex(vdst, 0, data0, addr);
}

void AppendSMovLiteral(std::vector<u32> *code, u32 dst, u32 literal) {
  code->push_back(EncodeSMovB32(dst, 255u));
  code->push_back(literal);
}

void AppendVMovLiteral(std::vector<u32> *code, u32 dst, u32 literal) {
  code->push_back(EncodeVop1(0x01, dst, 255u));
  code->push_back(literal);
}

void AppendVMovU32(std::vector<u32> *code, u32 dst, u32 value) {
  if (value <= 64u) {
    code->push_back(EncodeVop1(0x01, dst, InlineU32(value)));
    return;
  }
  AppendVMovLiteral(code, dst, value);
}

void AppendVop3(std::vector<u32> *code, u32 opcode, u32 dst, u32 src0, u32 src1,
                u32 src2 = 0, u32 abs = 0, u32 op_sel = 0, bool clamp = false,
                u32 omod = 0, u32 neg = 0) {
  code->push_back(EncodeVop3Word0(opcode, dst, abs, op_sel, clamp));
  code->push_back(EncodeVop3Word1(src0, src1, src2, omod, neg));
}

void AppendVop3B(std::vector<u32> *code, u32 opcode, u32 vdst, u32 sdst,
                 u32 src0, u32 src1, u32 src2 = 0) {
  code->push_back(EncodeVop3BWord0(opcode, vdst, sdst));
  code->push_back(EncodeVop3Word1(src0, src1, src2));
}

void AppendVop3p(std::vector<u32> *code, u32 opcode, u32 dst, u32 src0,
                 u32 src1, u32 src2 = 0, u32 op_sel_hi = 0, u32 op_sel = 0,
                 u32 neg_hi = 0, u32 neg = 0) {
  code->push_back(EncodeVop3pWord0(opcode, dst, op_sel_hi, op_sel, neg_hi));
  code->push_back(EncodeVop3pWord1(src0, src1, src2, op_sel_hi, neg));
}

void AppendBufferLoadDword(std::vector<u32> *code, u32 dst_vgpr,
                           u32 address_vgpr) {
  code->push_back(EncodeMubuf0(0x0cu));
  code->push_back(EncodeMubuf1(dst_vgpr, 0, address_vgpr));
}

void AppendBufferLoadOpcode(std::vector<u32> *code, u32 opcode, u32 dst_vgpr,
                            u32 address_vgpr) {
  code->push_back(EncodeMubuf0(opcode));
  code->push_back(EncodeMubuf1(dst_vgpr, 0, address_vgpr));
}

void AppendBufferStoreDword(std::vector<u32> *code, u32 value_vgpr,
                            u32 address_vgpr) {
  code->push_back(EncodeMubuf0(0x1cu));
  code->push_back(EncodeMubuf1(value_vgpr, 12, address_vgpr));
}

void AppendBufferStoreOpcode(std::vector<u32> *code, u32 opcode, u32 value_vgpr,
                             u32 address_vgpr, bool glc = false) {
  code->push_back(EncodeMubuf0(opcode, 0, false, true, glc));
  code->push_back(EncodeMubuf1(value_vgpr, 12, address_vgpr));
}

void AppendTBufferLoadOpcode(std::vector<u32> *code, u32 opcode, u32 dst_vgpr,
                             u32 address_vgpr) {
  code->push_back(EncodeMtbuf0(opcode, 14, 7));
  code->push_back(EncodeMtbuf1(opcode, dst_vgpr, 0, address_vgpr));
}

constexpr u32 BufferFormat(Prospero::BufferFormat format) {
  return static_cast<uint32_t>(format);
}

void AppendTBufferLoadFormatOpcode(std::vector<u32> *code, u32 opcode,
                                   u32 dst_vgpr, u32 address_vgpr,
                                   Prospero::BufferFormat format) {
  const auto value = BufferFormat(format);
  code->push_back(EncodeMtbuf0(opcode, value & 0xfu, (value >> 4u) & 0x7u));
  code->push_back(EncodeMtbuf1(opcode, dst_vgpr, 0, address_vgpr));
}

void AppendTBufferStoreOpcode(std::vector<u32> *code, u32 opcode,
                              u32 value_vgpr, u32 address_vgpr) {
  code->push_back(EncodeMtbuf0(opcode, 14, 7));
  code->push_back(EncodeMtbuf1(opcode, value_vgpr, 0, address_vgpr));
}

void AppendSmemLoadOpcode(std::vector<u32> *code, u32 opcode, u32 dst_sgpr,
                          u32 byte_offset) {
  code->push_back(EncodeSmem0(opcode, dst_sgpr));
  code->push_back(EncodeSmem1(byte_offset));
}

void AppendStoreVgpr(std::vector<u32> *code, u32 value_vgpr, u32 dword_index) {
  AppendVMovU32(code, 31, dword_index * 4u);
  AppendBufferStoreDword(code, value_vgpr, 31);
}

void AppendStoreVgprAtLaneDwordOffset(std::vector<u32> *code, u32 value_vgpr,
                                      u32 lane_vgpr, u32 dword_offset) {
  if (dword_offset == 0u) {
    code->push_back(EncodeVop2(0x1a, 31, InlineU32(2), lane_vgpr));
  } else {
    AppendVMovU32(code, 31, dword_offset);
    code->push_back(EncodeVop2(0x25, 31, Vgpr(lane_vgpr), 31));
    code->push_back(EncodeVop2(0x1a, 31, InlineU32(2), 31));
  }
  AppendBufferStoreDword(code, value_vgpr, 31);
}

void AppendStoreSgpr(std::vector<u32> *code, u32 value_sgpr, u32 dword_index) {
  code->push_back(EncodeVop1(0x01, 30, value_sgpr));
  AppendStoreVgpr(code, 30, dword_index);
}

void AppendStoreSgprAtLaneDwordOffset(std::vector<u32> *code, u32 value_sgpr,
                                      u32 lane_vgpr, u32 dword_offset) {
  code->push_back(EncodeVop1(0x01, 30, value_sgpr));
  AppendStoreVgprAtLaneDwordOffset(code, 30, lane_vgpr, dword_offset);
}

void AppendStoreSgprPair(std::vector<u32> *code, u32 value_sgpr,
                         u32 first_dword_index) {
  AppendStoreSgpr(code, value_sgpr, first_dword_index);
  AppendStoreSgpr(code, value_sgpr + 1u, first_dword_index + 1u);
}

void AppendEnd(std::vector<u32> *code) { code->push_back(0xbf810000u); }

std::string Hex(u32 value) {
  char buffer[32] = {};
  std::snprintf(buffer, sizeof(buffer), "0x%08" PRIx32, value);
  return buffer;
}

[[noreturn]] void Fail(const char *shader_name, const char *stage,
                       const std::string &message) {
  std::fprintf(stderr, "ShaderRecompilerComputeTests: %s failed at %s: %s\n",
               shader_name, stage, message.c_str());
  std::abort();
}

void Require(const char *shader_name, const char *stage, bool value,
             const std::string &message);

void EnsureConfigInitialized() {
  static bool config_initialized = false;
  if (!config_initialized) {
    static Common::Subsystems subsystems;
    Common::InitializeThreads();
    subsystems.Initialize<Config::Lifecycle>();
    Config::ConfigOptions options;
    options.printf_direction = Config::LogDirection::Silent;
    Config::Load(options);
    subsystems.Initialize<Log::Lifecycle>();
    subsystems.Initialize<Libs::LibKernel::Memory::Lifecycle>();
    ShaderInit();
    config_initialized = true;
  }
}

void RequireVk(const char *shader_name, const char *stage, vk::Result result,
               const char *action) {
  if (result != vk::Result::eSuccess) {
    Fail(shader_name, stage,
         std::string(action) + " returned " + vk::to_string(result));
  }
}

void Require(const char *shader_name, const char *stage, bool value,
             const std::string &message) {
  if (!value) {
    Fail(shader_name, stage, message);
  }
}

void CheckErrorDialogLifecycle() {
  namespace ErrorDialog = Libs::Dialog::ErrorDialog;
  struct Param {
    int32_t size = 16;
    int32_t error_code = static_cast<int32_t>(0x80550006u);
    int32_t user_id = 1;
    int32_t reserved = 0;
  } param;
  static_assert(sizeof(Param) == 16);
  constexpr int invalid_state = static_cast<int>(0x80ed0005u);
  constexpr int invalid_param = static_cast<int>(0x80ed0003u);
  static std::vector<ErrorDialog::VisualState> notifications;
  notifications.clear();
  ErrorDialog::SetVisibilityCallback([] {
    const auto visual = ErrorDialog::GetVisualState();
    ErrorDialog::HostSnapshot snapshot{};
    Require("ErrorDialog", "callback reentry",
            ErrorDialog::GetHostSnapshot(&snapshot) == visual.active &&
                (ErrorDialog::ErrorDialogGetStatus() == 2) == visual.active,
            "visibility callback observed inconsistent dialog state");
    notifications.push_back(visual);
  });
  const auto initial_revision = ErrorDialog::GetVisualState().revision;
  const auto check_state = [&](const char *stage, int status,
                               size_t visibility_changes) {
    const auto visual = ErrorDialog::GetVisualState();
    ErrorDialog::HostSnapshot snapshot{};
    Require("ErrorDialog", stage,
            ErrorDialog::ErrorDialogGetStatus() == status &&
                ErrorDialog::ErrorDialogUpdateStatus() == status &&
                visual.active == (status == 2) &&
                ErrorDialog::GetHostSnapshot(&snapshot) == visual.active &&
                visual.revision == initial_revision + visibility_changes &&
                notifications.size() == visibility_changes &&
                (notifications.empty() ||
                 (notifications.back().active == visual.active &&
                  notifications.back().revision == visual.revision)),
            "status, host visibility, or visibility notification changed "
            "unexpectedly");
  };
  check_state("uninitialized", 0, 0);
  Require("ErrorDialog", "uninitialized operations",
          ErrorDialog::ErrorDialogTerminate() ==
                  static_cast<int>(0x80ed0001u) &&
              ErrorDialog::ErrorDialogClose() == invalid_state,
          "uninitialized dialog accepted termination or close");
  Require("ErrorDialog", "initialize",
          ErrorDialog::ErrorDialogInitialize() == 0 &&
              ErrorDialog::ErrorDialogInitialize() ==
                  static_cast<int>(0x80ed0002u),
          "initialization did not reject a second initialization");
  Param invalid = param;
  invalid.size--;
  Require("ErrorDialog", "invalid open",
          ErrorDialog::ErrorDialogOpen(nullptr) == invalid_param &&
              ErrorDialog::ErrorDialogOpen(&invalid) == invalid_param &&
              ErrorDialog::ErrorDialogClose() == invalid_state,
          "invalid parameters or close were accepted before opening");
  check_state("failed open preserves initialized state", 1, 0);
  Require("ErrorDialog", "open", ErrorDialog::ErrorDialogOpen(&param) == 0,
          "valid error dialog did not open");
  ErrorDialog::HostSnapshot first{};
  Require("ErrorDialog", "copied error code",
          ErrorDialog::GetHostSnapshot(&first) &&
              first.error_code == param.error_code,
          "host dialog did not expose the guest error code");
  param.error_code = static_cast<int32_t>(0x8055000au);
  for (int poll = 0; poll < 8; ++poll) {
    check_state("polling waits for acknowledgement", 2, 1);
  }
  Require(
      "ErrorDialog", "running failures",
      ErrorDialog::ErrorDialogOpen(&param) == invalid_state &&
          !ErrorDialog::HostAccept(first.generation + 1),
      "an invalid open or stale acknowledgement replaced the active dialog");
  ErrorDialog::HostSnapshot current{};
  Require("ErrorDialog", "failed open preserves active dialog",
          ErrorDialog::GetHostSnapshot(&current) &&
              current.generation == first.generation &&
              current.error_code == first.error_code,
          "active error code or generation changed after a failed open");
  check_state("failed operations preserve running state", 2, 1);
  Require("ErrorDialog", "acknowledge",
          ErrorDialog::HostAccept(first.generation),
          "current host acknowledgement did not finish the dialog");
  check_state("acknowledged", 3, 2);
  Require("ErrorDialog", "finished operations",
          !ErrorDialog::HostAccept(first.generation) &&
              ErrorDialog::ErrorDialogClose() == invalid_state &&
              ErrorDialog::ErrorDialogOpen(&invalid) == invalid_param,
          "finished dialog accepted duplicate completion or an invalid open");
  check_state("failed operations preserve finished state", 3, 2);
  Require("ErrorDialog", "reopen and stale acknowledgement",
          ErrorDialog::ErrorDialogOpen(&param) == 0 &&
              ErrorDialog::GetHostSnapshot(&current) &&
              current.generation != first.generation &&
              current.error_code == param.error_code &&
              !ErrorDialog::HostAccept(first.generation),
          "reopened dialog accepted acknowledgement from its predecessor");
  check_state("reopened", 2, 3);
  Require("ErrorDialog", "guest close", ErrorDialog::ErrorDialogClose() == 0,
          "guest close did not finish the running dialog");
  check_state("closed", 3, 4);
  Require("ErrorDialog", "terminate running dialog",
          ErrorDialog::ErrorDialogOpen(&param) == 0 &&
              ErrorDialog::GetHostSnapshot(&current) &&
              ErrorDialog::ErrorDialogTerminate() == 0 &&
              !ErrorDialog::HostAccept(current.generation),
          "termination failed to remove the active dialog");
  check_state("terminated", 0, 6);
  Require("ErrorDialog", "reinitialize and stale acknowledgement",
          ErrorDialog::ErrorDialogInitialize() == 0 &&
              ErrorDialog::ErrorDialogOpen(&param) == 0 &&
              !ErrorDialog::HostAccept(current.generation),
          "reinitialization reused an old dialog generation");
  check_state("reinitialized", 2, 7);
  Require("ErrorDialog", "final termination",
          ErrorDialog::ErrorDialogTerminate() == 0 &&
              ErrorDialog::ErrorDialogTerminate() ==
                  static_cast<int>(0x80ed0001u),
          "termination did not restore the uninitialized state");
  check_state("final state", 0, 8);
  ErrorDialog::SetVisibilityCallback(nullptr);
  Require("ErrorDialog", "lifecycle without a visibility listener",
          ErrorDialog::ErrorDialogInitialize() == 0 &&
              ErrorDialog::ErrorDialogOpen(&param) == 0 &&
              ErrorDialog::ErrorDialogClose() == 0 &&
              ErrorDialog::ErrorDialogTerminate() == 0 &&
              ErrorDialog::ErrorDialogGetStatus() == 0 &&
              !ErrorDialog::GetVisualState().active &&
              ErrorDialog::GetVisualState().revision == initial_revision + 10 &&
              notifications.size() == 8,
          "guest lifecycle depended on a registered host visibility listener");
  std::printf("[host]    %-32s ok\n", "ErrorDialogLifecycle");
}

#if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS
template <typename Function>
void ExpectFatal(const char *name, Function function) {
  const pid_t pid = ::fork();
  Require(name, "fatal subprocess", pid >= 0,
          "fork failed while starting fatal shader test");
  if (pid == 0) {
    function();
    ::_exit(0);
  }

  int status = 0;
  pid_t waited = -1;
  do {
    waited = ::waitpid(pid, &status, 0);
  } while (waited < 0 && errno == EINTR);
  Require(name, "fatal subprocess", waited == pid,
          "waitpid failed while collecting fatal shader test");
  Require(name, "fatal exit",
          WIFEXITED(status) && WEXITSTATUS(status) == (321 & 0xff),
          "fatal shader path did not terminate with status 321");
  std::printf("[host]    %-32s ok\n", name);
}
#endif

void CheckLeastRecentlyUsedCacheOrdering() {
  Common::LeastRecentlyUsedCache<uint32_t, uint64_t> cache;
  const auto first = cache.Insert(1, 1);
  const auto middle = cache.Insert(2, 2);
  const auto last = cache.Insert(3, 3);
  (void)first;
  (void)last;
  cache.Touch(middle, 4);
  std::vector<uint32_t> visited;
  cache.ForEachItemBelow(4, [&](uint32_t value) {
    visited.push_back(value);
    return visited.size() > 3;
  });
  Require("LeastRecentlyUsedCache", "non-tail touch traversal",
          visited == std::vector<uint32_t>{1, 3, 2},
          "touching a non-tail item left a cycle or changed LRU order");
  std::printf("[host]    %-32s ok\n", "LeastRecentlyUsedCache");
}

struct BdaMapping {
  uint64_t guest_base = 0;
  u32 backing_offset = 0;
};

struct TestCase {
  const char *name = "";
  std::vector<u32> code;
  std::vector<u32> initial;
  std::vector<u32> expected;
  std::vector<ShaderOpcode> opcodes;
  u32 image_width = 4;
  u32 image_height = 4;
  std::vector<u32> sampled_image_rgba;
  std::vector<std::vector<u32>> sampled_image_rgba_mips;
  vk::Format sampled_image_format = vk::Format::eR32G32B32A32Sfloat;
  u32 sampled_image_dwords_per_pixel = 4;
  vk::ImageType sampled_image_type = vk::ImageType::e2D;
  vk::ImageViewType sampled_image_view_type = vk::ImageViewType::e2D;
  u32 sampled_image_layers = 1;
  u32 sampled_image_view_base_layer = 0;
  u32 sampled_image_view_layers = 0;
  std::vector<u32> storage_image_rgba;
  std::vector<u32> expected_storage_image_rgba;
  vk::Format storage_image_format = vk::Format::eR32G32B32A32Sfloat;
  u32 storage_image_dwords_per_pixel = 4;
  std::vector<u32> storage_image_r32ui;
  std::vector<u32> expected_storage_image_r32ui;
  std::vector<std::string> required_spirv;
  std::vector<std::string> forbidden_spirv;
  ShaderComputeInputInfo compute_info = [] {
    ShaderComputeInputInfo info{};
    info.lds_size_dwords = 1024;
    return info;
  }();
  bool has_compute_info = false;
  u32 dispatch_x = 1;
  u32 dispatch_y = 1;
  u32 dispatch_z = 1;
  std::array<u32, 64> user_data{};
  bool has_user_data = false;
  u32 image_descriptor_swizzle = DstSel(4, 5, 6, 7);
  bool compile_only = false;
  size_t storage_buffer_range_dwords = 0;
  std::vector<u32> storage_buffer_offsets;
  std::vector<BdaMapping> bda_mappings;
  bool expand_shader_data_storage = false;
  bool expected_force_point_sampler = false;
  std::vector<u32> gds_initial;
  std::vector<u32> expected_gds;
  std::vector<std::pair<std::string, size_t>> decoded_counts;
  std::vector<std::pair<std::string, size_t>> ir_counts;
  u32 expected_storage_mip_descriptors = 0;
};

struct GraphicsCase {
  const char *name = "";
  std::vector<u32> fragment_code;
  std::vector<u32> expected_pixel;
  std::vector<ShaderOpcode> opcodes;
  std::array<u32, 64> user_data{};
  bool has_user_data = false;
  std::vector<u32> push_constants;
  std::vector<u32> pixel_interpolator_settings;
  bool pixel_no_perspective = false;
  std::vector<u32> vertices;
  bool pixel_ancillary = false;
  bool pixel_front_face = false;
  u32 layers = 1;
  vk::SampleCountFlagBits samples = vk::SampleCountFlagBits::e1;
  bool pixel_position_w = false;
  float vertex_clip_w = 1.0f;
  bool pixel_depth_export = false;
  u32 pixel_perspective_centroid_vgpr = UINT32_MAX;
  u32 pixel_custom_interpolation_mask = 0;
};

struct CompiledShader {
  std::vector<u32> spirv;
  ShaderRecompiler::IR::Program program;
  ShaderRecompiler::IR::ResourceSnapshot resources;
  std::vector<u32> packed_user_data;
};

std::array<u32, 64> MakeNativeUserData(const std::array<u32, 64> *source) {
  std::array<u32, 64> data{};
  data[50] = 1u << 20u;
  if (source != nullptr) {
    data = *source;
  }
  return data;
}

bool ReadTestMemory(void *userdata, uint64_t address, u32 *value) {
  const auto *data = static_cast<const std::vector<u32> *>(userdata);
  if (data == nullptr || value == nullptr || address % 4u != 0 ||
      address / 4u >= data->size()) {
    return false;
  }
  *value = (*data)[address / 4u];
  return true;
}

void ValidateSpirv(const char *shader_name, const std::vector<u32> &spirv) {
  spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_2);
  std::string messages;
  tools.SetMessageConsumer([&messages](spv_message_level_t, const char *,
                                       const spv_position_t &position,
                                       const char *message) {
    char buffer[1024] = {};
    std::snprintf(buffer, sizeof(buffer), "%zu:%zu: %s\n", position.line,
                  position.column, message);
    messages += buffer;
  });

  if (!tools.Validate(spirv)) {
    Fail(shader_name, "SPIR-V validation", messages);
  }
}

size_t CountText(const std::string &text, const std::string &needle) {
  size_t count = 0;
  for (size_t offset = 0;
       (offset = text.find(needle, offset)) != std::string::npos;
       offset += needle.size()) {
    count++;
  }
  return count;
}

void CheckPixelParameterAliases() {
  constexpr const char *name = "PixelParameterAliases";
  ShaderPixelInputInfo pixel{};
  pixel.input_num = 2;
  const std::array<uint32_t, 2> pair = {0, 1};
  for (const auto flat : {0u, 0x400u}) {
    pixel.interpolator_settings[0] = flat | 3u;
    pixel.interpolator_settings[1] = flat | 3u;
    Require(name, "same-mode nonidentity alias",
            ShaderPixelParameterLocation(pixel, pair, 0) == 3u &&
                ShaderPixelParameterLocation(pixel, pair, 1) == 3u,
            "aliases of one export with the same interpolation mode must "
            "share that physical location");
  }
  pixel.interpolator_settings[0] = 3u;
  pixel.interpolator_settings[1] = 0x423u;
  pixel.custom_interpolation_mask = 2u;
  Require(name, "smooth/custom alias",
          ShaderPixelParameterLocation(pixel, pair, 0) == 3u &&
              ShaderPixelParameterLocation(pixel, pair, 1) == 3u,
          "custom interpolation must retain its shared vertex export");

  pixel.input_num = 3;
  pixel.custom_interpolation_mask = 0;
  pixel.interpolator_settings[0] = 0x400u;
  pixel.interpolator_settings[1] = 0u;
  pixel.interpolator_settings[2] = 1u;
  const std::array<uint32_t, 3> active = {0, 1, 2};
  Require(name, "reserved physical locations",
          ShaderPixelParameterLocation(pixel, active, 0) == 0u &&
              ShaderPixelParameterLocation(pixel, active, 1) == 2u &&
              ShaderPixelParameterLocation(pixel, active, 2) == 1u,
          "a synthesized opposite-mode alias must not occupy another "
          "vertex export's physical location");
  std::printf("[host]    %-32s ok\n", name);
}

void CheckRectListShaders() {
  constexpr const char *name = "RectListShaders";

  ShaderRecompiler::IR::CompiledShaderInfo program{};
  program.info.inputs.push_back(
      {ShaderRecompiler::IR::StageInputKind::Parameter, 0, 4, "in_param_0"});
  program.info.inputs.push_back(
      {ShaderRecompiler::IR::StageInputKind::Parameter, 1, 4, "in_param_1"});

  ShaderVertexInputInfo vertex{};
  ShaderRecompiler::IR::CompiledShaderInfo vertex_program{.param_export_mask = 1u};
  vertex.stage.program = &vertex_program;
  ShaderPixelInputInfo pixel{};
  pixel.input_num = 2;
  pixel.interpolator_settings[0] = 0x400u;
  pixel.interpolator_settings[1] = 0;
  pixel.stage.program = &program;
  std::vector<uint32_t> perspective_specialization;
  BuildStageStaticKey(pixel, perspective_specialization);
  pixel.ps_no_perspective = true;
  std::vector<uint32_t> no_perspective_specialization;
  BuildStageStaticKey(pixel, no_perspective_specialization);
  pixel.ps_no_perspective = false;
  Require(name, "pipeline identity",
          perspective_specialization != no_perspective_specialization,
          "pixel interpolation mode must participate in the shader and "
          "pipeline key");

  const std::array<uint32_t, 2> active_inputs = {0, 1};
  Require(name, "duplicate mapping",
          ShaderPixelParameterLocation(pixel, active_inputs, 0) == 0 &&
              ShaderPixelParameterLocation(pixel, active_inputs, 1) == 1,
          "duplicate pixel mappings must receive distinct effective output "
          "locations");

  const auto shaders = BuildRectListShaders(vertex, &pixel);
  Require(name, "SPIR-V version",
          shaders.control.size() > 1 && shaders.control[1] == 0x00010500u &&
              shaders.evaluation.size() > 1 &&
              shaders.evaluation[1] == 0x00010500u,
          "vector selection requires SPIR-V 1.5");
  ValidateSpirv(name, shaders.control);
  ValidateSpirv(name, shaders.evaluation);

  spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_2);
  std::string control_text;
  std::string evaluation_text;
  Require(name, "control disassembly",
          tools.Disassemble(shaders.control, &control_text),
          "failed to disassemble rectangle-list tessellation control shader");
  Require(
      name, "evaluation disassembly",
      tools.Disassemble(shaders.evaluation, &evaluation_text),
      "failed to disassemble rectangle-list tessellation evaluation shader");
  Require(name, "control execution mode",
          control_text.find("TessellationControl") != std::string::npos &&
              control_text.find("OutputVertices 4") != std::string::npos,
          "rectangle-list control shader must produce four control points");
  Require(name, "evaluation execution modes",
          evaluation_text.find("TessellationEvaluation") != std::string::npos &&
              evaluation_text.find("Quads") != std::string::npos &&
              evaluation_text.find("SpacingEqual") != std::string::npos &&
              evaluation_text.find("VertexOrderCw") != std::string::npos,
          "rectangle-list evaluation shader has the wrong patch modes");
  Require(name, "no geometry stage",
          control_text.find("Geometry") == std::string::npos &&
              evaluation_text.find("Geometry") == std::string::npos,
          "rectangle-list expansion must not use geometry shaders");
  Require(name, "flat broadcast",
          CountText(control_text, "OpVectorTimesScalar") == 6 &&
              CountText(control_text, "OpSelect %v4float") == 2,
          "flat parameters must use guest vertex zero instead of reconstructed "
          "values");
  Require(name, "remapped interface",
          CountText(control_text, " Location 0") == 2 &&
              CountText(control_text, " Location 1") == 1 &&
              CountText(evaluation_text, " Location 0") == 2 &&
              CountText(evaluation_text, " Location 1") == 2,
          "duplicate pixel mappings must share one vertex input and keep "
          "distinct patch outputs");

  for (const auto flat : {0u, 0x400u}) {
    pixel.interpolator_settings[0] = flat;
    pixel.interpolator_settings[1] = flat;
    const auto shared = BuildRectListShaders(vertex, &pixel);
    ValidateSpirv(name, shared.control);
    ValidateSpirv(name, shared.evaluation);
    Require(name, "same-mode alias disassembly",
            tools.Disassemble(shared.control, &control_text) &&
                tools.Disassemble(shared.evaluation, &evaluation_text),
            "failed to disassemble shared rectangle-list parameters");
    Require(name, "same-mode interface deduplication",
            CountText(control_text, " Location 0") == 2 &&
                CountText(evaluation_text, " Location 0") == 2 &&
                control_text.find(" Location 1") == std::string::npos &&
                evaluation_text.find(" Location 1") == std::string::npos,
            "same-mode aliases must produce one input and one output at "
            "the shared location in each rectangle-list stage");
  }

  const auto position_only = BuildRectListShaders(vertex, nullptr);
  ValidateSpirv(name, position_only.control);
  ValidateSpirv(name, position_only.evaluation);
}

void CheckSpirvText(const TestCase &test, const std::vector<u32> &spirv) {
  if (test.required_spirv.empty() && test.forbidden_spirv.empty()) {
    return;
  }

  spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_2);
  std::string text;
  if (!tools.Disassemble(spirv, &text)) {
    Fail(test.name, "SPIR-V disassembly",
         "failed to disassemble emitted SPIR-V");
  }
  for (const auto &required : test.required_spirv) {
    if (text.find(required) == std::string::npos) {
      Fail(test.name, "SPIR-V disassembly",
           std::string("missing required text: ") + required);
    }
  }
  for (const auto &forbidden : test.forbidden_spirv) {
    if (text.find(forbidden) != std::string::npos) {
      Fail(test.name, "SPIR-V disassembly",
           std::string("found forbidden text: ") + forbidden);
    }
  }
}

CompiledShader CompileCase(const TestCase &test, u32 host_subgroup_size = 64) {
  auto user_data =
      MakeNativeUserData(test.has_user_data ? &test.user_data : nullptr);
  const auto uses_image =
      std::any_of(test.opcodes.begin(), test.opcodes.end(), [](auto op) {
        return op >= ShaderOpcode::IMAGE_GET_RESINFO &&
               op <= ShaderOpcode::IMAGE_GATHER4H;
      });
  if (uses_image && ((user_data[3] >> 28u) & 0xfu) == 0) {
    user_data[3] = static_cast<uint32_t>(Prospero::ImageType::kColor2D) << 28u;
  }
  if (uses_image) {
    user_data[3] = (user_data[3] & ~0xfffu) | test.image_descriptor_swizzle;
  }
  if (!test.has_user_data) {
    user_data[2] = static_cast<u32>(test.initial.size() * sizeof(u32));
  }
  ShaderRecompiler::CompileOptions options;
  options.stage = ShaderType::Compute;
  options.dump_ir = true;
  auto compute_info = test.compute_info;
  compute_info.host_subgroup_size = host_subgroup_size;
  options.input_info.compute = &compute_info;
  options.user_data = user_data;

  if (test.has_compute_info) {
    options.wave_size = test.compute_info.wave_size;
  }

  auto translated = ShaderRecompiler::TranslateProgram(test.code, options);
  auto resource_plan =
      ShaderRecompiler::IR::ExtractResourcePlan(translated.program);
  ShaderRecompiler::IR::ResourceSnapshot resources;
  ShaderRecompiler::IR::ResourceSpecialization specialization;
  const ShaderRecompiler::IR::SrtRuntime runtime{
      .user_data = options.user_data,
      .shader_base = reinterpret_cast<uint64_t>(test.code.data()),
      .read_memory = ReadTestMemory,
      .userdata = const_cast<std::vector<u32> *>(&test.initial),
  };
  Require(test.name, "resource materialization",
          ShaderRecompiler::IR::MaterializeResources(
              resource_plan, runtime, resources, specialization),
          "translated resources could not be materialized");
  auto result = ShaderRecompiler::CompileProgram(
      std::move(translated), options, specialization);
  for (const auto &[text, expected] : test.decoded_counts) {
    const auto actual = CountText(result.decoded_dump, text);
    Require(test.name, "decoded RDNA2", actual == expected,
            text + " count=" + std::to_string(actual) +
                ", expected=" + std::to_string(expected));
  }
  for (const auto &[text, expected] : test.ir_counts) {
    const auto actual = CountText(result.ir_dump, text);
    Require(test.name, "typed IR", actual == expected,
            text + " count=" + std::to_string(actual) +
                ", expected=" + std::to_string(expected));
  }
  if (test.expected_storage_mip_descriptors != 0) {
    const auto image = std::ranges::find_if(
        result.program.info.images, [](const auto &resource) {
          return resource.mip_mode ==
                 ShaderRecompiler::IR::ImageMipMode::DynamicStorage;
        });
    Require(test.name, "dynamic storage mip specialization",
            image != result.program.info.images.end() &&
                image->mip_count == test.expected_storage_mip_descriptors,
            "runtime descriptor range did not specialize the mip count");
    const auto resource =
        static_cast<u32>(image - result.program.info.images.begin());
    const auto binding = std::ranges::find_if(
        result.program.bindings.descriptors, [&](const auto &group) {
          return std::ranges::find(group.resources, resource) !=
                 group.resources.end();
        });
    Require(test.name, "dynamic storage mip binding",
            binding != result.program.bindings.descriptors.end() &&
                std::ranges::count(binding->resources, resource) ==
                    test.expected_storage_mip_descriptors,
            "dynamic storage image did not receive one descriptor per mip");
  }
  if (test.expand_shader_data_storage) {
    auto &block = *result.program.blocks.front();
    for (u32 reg = 0; reg < 33; reg++) {
      auto &user_data = block.AppendNewInst(
          ShaderRecompiler::IR::ValueOpcode::GetUserData,
          {ShaderRecompiler::IR::Value(
              static_cast<ShaderRecompiler::IR::ScalarReg>(reg))});
      block.AppendNewInst(ShaderRecompiler::IR::ValueOpcode::ReferenceU32,
                          {ShaderRecompiler::IR::Value(&user_data)});
    }
    result.program.bindings = {};
    result.program.binding_layout_complete = false;
    ShaderRecompiler::IR::AllocateBindings(result.program);
    const auto *shader_data = ShaderRecompiler::IR::FindBinding(
        result.program.bindings,
        ShaderRecompiler::IR::DescriptorBindingKind::ShaderData);
    Require(test.name, "binding layout",
            result.program.bindings.user_data_registers.size() == 33 &&
                !result.program.bindings.UsesPushData() &&
                shader_data != nullptr,
            "oversized shader data did not use its storage fallback");
    result.spirv = ShaderRecompiler::Spirv::EmitProgram(result.program,
                                                        options.input_info);
  }
  Require(test.name, "SPIR-V emit", !result.spirv.empty(),
          "recompiler returned empty SPIR-V");
  ValidateSpirv(test.name, result.spirv);
  CheckSpirvText(test, result.spirv);
  std::vector<u32> packed_user_data;
  for (const auto reg : result.program.bindings.user_data_registers) {
    packed_user_data.push_back(
        resources.user_data[reg - result.program.user_data_base]);
  }
  packed_user_data.resize(result.program.bindings.ShaderDataDwords());
  const auto buffer_count =
      static_cast<u32>(result.program.info.buffers.size());
  for (u32 i = 0; i < buffer_count; i++) {
    u32 offset = 0;
    if (i < test.storage_buffer_offsets.size()) {
      offset = test.storage_buffer_offsets[i];
    }
    Require(test.name, "shader data", offset % sizeof(u32) == 0 && offset < 256,
            "storage buffer offset is not representable");
    packed_user_data[result.program.bindings.memory_offset_dword + i / 4u] |=
        offset << ((i % 4u) * 8u);
  }
  return {std::move(result.spirv), std::move(result.program),
          std::move(resources), std::move(packed_user_data)};
}

std::array<u32, 64> MakeStructuredStorageBufferData(u32 stride_bytes,
                                                    u32 num_records,
                                                    bool add_tid = false,
                                                    u32 format = 0) {
  std::array<u32, 64> data{};
  data[1] = (stride_bytes & 0x3fffu) << 16u;
  data[2] = num_records;
  data[3] = DstSel(4, 5, 6, 7) | (1u << 24u);
  if (add_tid) {
    data[3] |= 1u << 23u;
  }
  data[3] |= (format & 0x7fu) << 12u;
  return data;
}

std::array<u32, 64> MakeStorageTextureData(Prospero::BufferFormat format) {
  std::array<u32, 64> data{};
  data[0] = 0x1000u;
  data[1] = (static_cast<uint32_t>(format) & 0x1ffu) << 20u;
  data[3] = static_cast<uint32_t>(Prospero::ImageType::kColor2D) << 28u;
  return data;
}

std::string StorageUint2DImageBindingName(bool atomic) {
  ShaderRecompiler::IR::ImageResource image{};
  image.resource_class = ShaderRecompiler::IR::ImageResourceClass::Storage;
  image.numeric_class = Prospero::TextureNumericClass::Uint;
  image.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2D;
  image.atomic = atomic;
  const auto binding = ShaderRecompiler::IR::DescriptorBindingForImage(image);
  Require("StorageUint2DImageBindingName", "descriptor binding", binding.has_value(),
          "storage image has no descriptor binding");
  return "image_" + std::to_string(static_cast<uint32_t>(*binding));
}

CompiledShader CompileFragmentCase(const GraphicsCase &test) {
  const auto user_data =
      MakeNativeUserData(test.has_user_data ? &test.user_data : nullptr);
  ShaderPixelInputInfo pixel_info{};
  pixel_info.input_num =
      test.pixel_interpolator_settings.empty()
          ? 1u
          : static_cast<u32>(test.pixel_interpolator_settings.size());
  pixel_info.ps_no_perspective = test.pixel_no_perspective;
  pixel_info.ps_ancillary = test.pixel_ancillary;
  pixel_info.ps_front_face = test.pixel_front_face;
  pixel_info.ps_pos_w = test.pixel_position_w;
  pixel_info.ps_depth_export_enable = test.pixel_depth_export;
  pixel_info.ps_system_input_base = 2;
  pixel_info.ps_perspective_centroid_vgpr = test.pixel_perspective_centroid_vgpr;
  pixel_info.custom_interpolation_mask = test.pixel_custom_interpolation_mask;
  for (u32 i = 0; i < std::size(pixel_info.interpolator_settings); i++) {
    pixel_info.interpolator_settings[i] = i;
  }
  for (u32 i = 0; i < test.pixel_interpolator_settings.size() &&
                  i < std::size(pixel_info.interpolator_settings);
       i++) {
    pixel_info.interpolator_settings[i] = test.pixel_interpolator_settings[i];
  }

  ShaderRecompiler::CompileOptions options;
  options.stage = ShaderType::Pixel;
  options.dump_ir = false;
  options.input_info.pixel = &pixel_info;
  options.user_data = user_data;

  auto translated =
      ShaderRecompiler::TranslateProgram(test.fragment_code, options);
  auto resource_plan =
      ShaderRecompiler::IR::ExtractResourcePlan(translated.program);
  ShaderRecompiler::IR::ResourceSnapshot resources;
  ShaderRecompiler::IR::ResourceSpecialization specialization;
  const ShaderRecompiler::IR::SrtRuntime runtime{
      .user_data = options.user_data,
      .shader_base = reinterpret_cast<uint64_t>(test.fragment_code.data()),
  };
  Require(test.name, "resource materialization",
          ShaderRecompiler::IR::MaterializeResources(
              resource_plan, runtime, resources, specialization),
          "translated resources could not be materialized");
  auto result = ShaderRecompiler::CompileProgram(
      std::move(translated), options, specialization);
  Require(test.name, "SPIR-V emit", !result.spirv.empty(),
          "recompiler returned empty SPIR-V");
  ValidateSpirv(test.name, result.spirv);
  std::vector<u32> packed_user_data;
  for (const auto reg : result.program.bindings.user_data_registers) {
    packed_user_data.push_back(
        resources.user_data[reg - result.program.user_data_base]);
  }
  packed_user_data.resize(result.program.bindings.ShaderDataDwords());
  return {std::move(result.spirv), std::move(result.program),
          std::move(resources), std::move(packed_user_data)};
}

std::array<u32, 64> MakeSampledTextureData(Prospero::BufferFormat format) {
  return MakeStorageTextureData(format);
}

namespace TestSpv {

std::vector<u32> MakePassthroughVertexSpirv(bool layered, float clip_w = 1.0f) {
  using ShaderRecompiler::Spirv::Builder;

  Builder b;
  const auto void_type = b.Type(spv::OpTypeVoid);
  const auto uint_type = b.Type(spv::OpTypeInt, 32, 0);
  const auto int_type = b.Type(spv::OpTypeInt, 32, 1);
  const auto float_type = b.Type(spv::OpTypeFloat, 32);
  const auto vec2_type = b.Type(spv::OpTypeVector, float_type, 2);
  const auto vec4_type = b.Type(spv::OpTypeVector, float_type, 4);
  const auto per_vertex_type =
      b.DecoratedType(spv::OpTypeStruct, {{spv::OpDecorate, {spv::DecorationBlock}},
                       {spv::OpMemberDecorate,
                        {0, spv::DecorationBuiltIn, spv::BuiltInPosition}}}, vec4_type);
  const auto ptr_input_vec2 =
      b.Type(spv::OpTypePointer, spv::StorageClassInput, vec2_type);
  const auto ptr_input_vec4 =
      b.Type(spv::OpTypePointer, spv::StorageClassInput, vec4_type);
  const auto ptr_output_vec4 =
      b.Type(spv::OpTypePointer, spv::StorageClassOutput, vec4_type);
  const auto ptr_output_per_vertex =
      b.Type(spv::OpTypePointer, spv::StorageClassOutput, per_vertex_type);
  const auto func_type = b.Type(spv::OpTypeFunction, void_type);
  const auto const_u32_0 = b.Constant(spv::OpConstant, uint_type, 0);
  const auto const_f32_0 =
      b.Constant(spv::OpConstant, float_type, 0x00000000u);
  const auto const_f32_w =
      b.Constant(spv::OpConstant, float_type, std::bit_cast<u32>(clip_w));
  const auto in_pos =
      b.DefineGlobalVariable(ptr_input_vec2, spv::StorageClassInput);
  const auto in_color =
      b.DefineGlobalVariable(ptr_input_vec4, spv::StorageClassInput);
  const auto out_color =
      b.DefineGlobalVariable(ptr_output_vec4, spv::StorageClassOutput);
  const auto per_vertex =
      b.DefineGlobalVariable(ptr_output_per_vertex, spv::StorageClassOutput);
  u32 instance = 0;
  u32 layer = 0;
  std::vector<u32> interfaces = {in_pos, in_color, per_vertex, out_color};
  if (layered) {
    instance = b.DefineGlobalVariable(
        b.Type(spv::OpTypePointer, spv::StorageClassInput, int_type),
        spv::StorageClassInput);
    layer = b.DefineGlobalVariable(
        b.Type(spv::OpTypePointer, spv::StorageClassOutput, int_type),
        spv::StorageClassOutput);
    b.AddAnnotation(spv::OpDecorate, instance, spv::DecorationBuiltIn,
                     spv::BuiltInInstanceIndex);
    b.AddAnnotation(spv::OpDecorate, layer, spv::DecorationBuiltIn, spv::BuiltInLayer);
    b.RequireVersion(0x00010500u);
    b.RequireCapability(spv::CapabilityShaderLayer);
    interfaces.insert(interfaces.end(), {instance, layer});
  }
  const auto main = b.AllocateId();
  const auto label = b.AllocateId();
  const auto pos2 = b.AllocateId();
  const auto color4 = b.AllocateId();
  const auto pos_x = b.AllocateId();
  const auto pos_y = b.AllocateId();
  const auto position = b.AllocateId();
  const auto position_ptr = b.AllocateId();

  b.RequireCapability(spv::CapabilityShader);
  b.AddMemoryModel(spv::AddressingModelLogical, spv::MemoryModelGLSL450);
  b.AddEntryPoint(spv::ExecutionModelVertex, main, "main", interfaces);
  b.AddAnnotation(spv::OpDecorate, in_pos, spv::DecorationLocation, 0);
  b.AddAnnotation(spv::OpDecorate, in_color, spv::DecorationLocation, 1);
  b.AddAnnotation(spv::OpDecorate, out_color, spv::DecorationLocation, 0);

  b.AddFunction(spv::OpFunction, void_type, main, spv::FunctionControlMaskNone,
                 func_type);
  b.AddFunction(spv::OpLabel, label);
  b.AddFunction(spv::OpLoad, vec2_type, pos2, in_pos);
  b.AddFunction(spv::OpLoad, vec4_type, color4, in_color);
  b.AddFunction(spv::OpCompositeExtract, float_type, pos_x, pos2, 0);
  b.AddFunction(spv::OpCompositeExtract, float_type, pos_y, pos2, 1);
  b.AddFunction(spv::OpCompositeConstruct, vec4_type, position, pos_x, pos_y,
                 const_f32_0, const_f32_w);
  b.AddFunction(spv::OpAccessChain, ptr_output_vec4, position_ptr, per_vertex,
                 const_u32_0);
  b.AddFunction(spv::OpStore, position_ptr, position);
  b.AddFunction(spv::OpStore, out_color, color4);
  if (layered) {
    const auto index = b.AllocateId();
    b.AddFunction(spv::OpLoad, int_type, index, instance);
    b.AddFunction(spv::OpStore, layer, index);
  }
  b.AddFunction(spv::OpReturn);
  b.AddFunction(spv::OpFunctionEnd);
  return b.Build();
}

} // namespace TestSpv

class VulkanHarness {
public:
  VulkanHarness() { Init(); }
  ~VulkanHarness() { Destroy(); }

  VulkanHarness(const VulkanHarness &) = delete;
  VulkanHarness &operator=(const VulkanHarness &) = delete;

  struct Buffer {
    vk::Buffer buffer = nullptr;
    vk::DeviceMemory memory = nullptr;
    vk::DeviceAddress device_address = 0;
    vk::DeviceSize size = 0;
    bool coherent = false;
  };

  struct Image {
    vk::Image image = nullptr;
    vk::DeviceMemory memory = nullptr;
    vk::ImageView view = nullptr;
    vk::Format format = vk::Format::eUndefined;
    vk::ImageLayout layout = vk::ImageLayout::eUndefined;
    u32 width = 0;
    u32 height = 0;
    u32 layers = 1;
    u32 mip_levels = 1;
    u32 dwords_per_pixel = 0;
  };

  [[nodiscard]] vk::Device Device() const { return m_device; }
  [[nodiscard]] u32 SubgroupSize() const {
    vk::PhysicalDeviceSubgroupProperties subgroup{};
    vk::PhysicalDeviceProperties2 properties{};
    properties.pNext = &subgroup;
    m_physical_device.getProperties2(&properties);
    return subgroup.subgroupSize;
  }
  [[nodiscard]] GraphicContext &RuntimeContext() {
    EnsureRuntimeContext();
    return m_runtime_context;
  }
  [[nodiscard]] RenderContext &RuntimeRenderer() {
    EnsureRuntimeContext();
    return Renderer();
  }

  void CheckHostImageAllocation() {
    constexpr const char *name = "HostImageAllocation";
    auto &graphics = RuntimeContext();
    VulkanImage image;
    vk::ImageCreateInfo create{};
    create.flags = vk::ImageCreateFlagBits::eMutableFormat;
    create.imageType = vk::ImageType::e2D;
    create.format = vk::Format::eR8G8B8A8Unorm;
    create.extent = {16, 8, 1};
    create.mipLevels = 3;
    create.arrayLayers = 4;
    create.samples = vk::SampleCountFlagBits::e1;
    create.tiling = vk::ImageTiling::eOptimal;
    create.usage = vk::ImageUsageFlagBits::eTransferSrc |
                   vk::ImageUsageFlagBits::eTransferDst |
                   vk::ImageUsageFlagBits::eSampled;
    create.initialLayout = vk::ImageLayout::eUndefined;

    for (uint32_t pass = 0; pass < 2; ++pass) {
      Require(name, "create", graphics.CreateImage(create, image),
              "could not allocate native image");
      Require(name, "allocation metadata",
              image.image != nullptr && image.allocation != nullptr &&
                  image.format == create.format &&
                  image.image_type == create.imageType &&
                  image.extent == create.extent &&
                  image.layers == create.arrayLayers &&
                  image.mip_levels == create.mipLevels &&
                  image.samples == static_cast<uint32_t>(create.samples) &&
                  image.usage == create.usage && image.flags == create.flags,
              "native image metadata did not follow its creation descriptor");
      Require(name, "fresh synchronization state",
              image.state.layout == create.initialLayout &&
                  image.state.access_mask == vk::AccessFlags2{} &&
                  image.state.pl_stage == vk::PipelineStageFlagBits2::eAllCommands &&
                  image.subresource_states.empty(),
              "new allocation retained synchronization state from an old image");
      VkMemoryPropertyFlags properties{};
      vmaGetAllocationMemoryProperties(graphics.allocator, image.allocation,
                                       &properties);
      Require(name, "allocation policy",
              (properties & VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT) != 0,
              "native image lost its device-local memory requirement");

      // A reused presentation image may still describe its previous recording.
      // No commands use this fixture; seed that bookkeeping before retirement.
      image.state = {vk::PipelineStageFlagBits2::eTransfer,
                     vk::AccessFlagBits2::eTransferWrite,
                     vk::ImageLayout::eTransferDstOptimal};
      image.subresource_states.assign(image.layers * image.mip_levels, image.state);
      graphics.DeleteImage(image);
      Require(name, "retirement",
              image.image == nullptr && image.allocation == nullptr,
              "retired native image retained an allocation handle");

      create.flags = vk::ImageCreateFlagBits::e2DArrayCompatible;
      create.imageType = vk::ImageType::e3D;
      create.format = vk::Format::eR32Uint;
      create.extent = {8, 4, 2};
      create.mipLevels = 2;
      create.arrayLayers = 1;
      create.usage = vk::ImageUsageFlagBits::eTransferSrc |
                     vk::ImageUsageFlagBits::eTransferDst;
    }
    std::printf("[host]    %-32s ok\n", name);
  }

  void CheckDescriptorHeapLargeSet() {
    EnsureRuntimeContext();
    std::array<vk::DescriptorSetLayoutBinding, 3> bindings{};
    constexpr std::array stages{
        vk::ShaderStageFlagBits::eVertex,
        vk::ShaderStageFlagBits::eFragment,
        vk::ShaderStageFlagBits::eCompute,
    };
    for (uint32_t i = 0; i < bindings.size(); i++) {
      bindings[i].binding = i;
      bindings[i].descriptorType = vk::DescriptorType::eSampler;
      bindings[i].descriptorCount = 16;
      bindings[i].stageFlags = stages[i];
    }
    vk::DescriptorSetLayoutCreateInfo create{};
    create.sType = vk::StructureType::eDescriptorSetLayoutCreateInfo;
    create.bindingCount = static_cast<uint32_t>(bindings.size());
    create.pBindings = bindings.data();
    vk::DescriptorSetLayout layout = nullptr;
    RequireVk("DescriptorHeapLargeSet", "layout",
              m_device.createDescriptorSetLayout(&create, nullptr, &layout),
              "vkCreateDescriptorSetLayout");

    vk::PipelineLayoutCreateInfo pipeline_create{};
    pipeline_create.sType = vk::StructureType::ePipelineLayoutCreateInfo;
    pipeline_create.setLayoutCount = 1;
    pipeline_create.pSetLayouts = &layout;
    vk::PipelineLayout pipeline_layout = nullptr;
    RequireVk("DescriptorHeapLargeSet", "pipeline layout",
              m_device.createPipelineLayout(&pipeline_create, nullptr,
                                            &pipeline_layout),
              "vkCreatePipelineLayout");

    {
      RenderContext context(m_runtime_context);
      auto &scheduler = context.GetCommandScheduler();
      HW::Context registers{};
      HW::UserConfig user_config{};
      HW::Shader shaders{};
      scheduler.Begin(registers, user_config, shaders);

      const auto commit = [&] {
        const auto set = context.GetDescriptorHeap().Commit(layout);
        Require("DescriptorHeapLargeSet", "allocation", set != nullptr,
                "ordinary descriptor heap could not allocate an oversized sampler set");
        scheduler.Current().Handle().bindDescriptorSets(
            vk::PipelineBindPoint::eCompute, pipeline_layout, 0, 1, &set, 0,
            nullptr);
      };

      for (uint32_t i = 0; i < 22; i++) {
        commit();
      }
      scheduler.Finish();
      for (uint32_t i = 0; i < 21; i++) {
        commit();
      }
    }

    m_device.destroyPipelineLayout(pipeline_layout, nullptr);
    m_device.destroyDescriptorSetLayout(layout, nullptr);
    std::printf("[host]    %-32s ok\n", "DescriptorHeapLargeSet");
  }

  void CheckGraphicsPushConstantBank() {
    constexpr const char *name = "GraphicsPushConstantStages";
    EnsureRuntimeContext();
    RenderContext context(m_runtime_context);
    auto &scheduler = context.GetCommandScheduler();
    HW::Context registers{};
    HW::UserConfig user_config{};
    HW::Shader shaders{};
    scheduler.Begin(registers, user_config, shaders);

    ShaderRecompiler::IR::CompiledShaderInfo vertex_program{};
    vertex_program.stage = ShaderType::Vertex;
    vertex_program.bindings.push_data_start_dword = 2;
    vertex_program.bindings.user_data_registers = {0, 1};
    vertex_program.bindings.memory_offset_dword = 2;
    ShaderRecompiler::IR::CompiledShaderInfo pixel_program{};
    pixel_program.stage = ShaderType::Pixel;
    pixel_program.bindings.push_data_start_dword = 0;
    pixel_program.bindings.user_data_registers = {0, 1};
    pixel_program.bindings.memory_offset_dword = 2;
    ShaderStageRuntime vertex_runtime{.program = &vertex_program};
    vertex_runtime.resources.user_data = {0x11111111u, 0x22222222u};
    ShaderStageRuntime pixel_runtime{.program = &pixel_program};
    pixel_runtime.resources.user_data = {0x33333333u, 0x44444444u};
    auto vertex = context.GetRenderExecutor().PrepareBindings(vertex_runtime);
    auto pixel = context.GetRenderExecutor().PrepareBindings(pixel_runtime);

    const auto pipeline = RenderExecutorTestAccess::CommitBindings(
        context.GetRenderExecutor(), scheduler.Current(), vertex, pixel);
    Require(name, "shared push data",
            vertex.shader_data ==
                    std::vector<uint32_t>{0x11111111u, 0x22222222u} &&
                pixel.shader_data ==
                    std::vector<uint32_t>{0x33333333u, 0x44444444u},
            "graphics stages did not commit their shared push data");
    scheduler.Finish();
    RenderExecutorTestAccess::DestroyDescriptorPipelines(
        context.GetRenderExecutor(), std::span {&pipeline, 1u});
    std::printf("[host]    %-32s ok\n", name);
  }

  void CheckSchedulerTimeline() {
    EnsureRuntimeContext();
    CommandScheduler scheduler(Renderer(), m_runtime_context);
    HW::Context registers{};
    HW::UserConfig user_config{};
    HW::Shader shaders{};
    scheduler.Begin(registers, user_config, shaders);

    auto *command = &scheduler.Current();
    const auto original_handle = command->Handle();
    HW::Context next_registers{};
    HW::UserConfig next_user_config{};
    HW::Shader next_shaders{};
    scheduler.Begin(next_registers, next_user_config, next_shaders);
    Require("SchedulerTimeline", "guest context rebind",
            &scheduler.Current() == command &&
                command->Handle() == original_handle &&
                &command->GetRegisters() == &next_registers &&
                &command->GetUserConfig() == &next_user_config &&
                &command->GetShaders() == &next_shaders,
            "rebinding guest state replaced the active command recording");
    scheduler.FlushAndWait();
    Require("SchedulerTimeline", "guest context after recording restart",
            scheduler.Active() && &scheduler.Current() == command &&
                &command->GetRegisters() == &next_registers &&
                &command->GetUserConfig() == &next_user_config &&
                &command->GetShaders() == &next_shaders,
            "restarting command recording lost the current guest context");
    scheduler.Begin(registers, user_config, shaders);

    const auto first_tick = scheduler.CurrentTick();
    uint32_t completed = 0;
    scheduler.DeferOperation([owned = std::make_unique<uint32_t>(1),
                              &completed] { completed = *owned; });
    scheduler.Flush();
    scheduler.Wait(first_tick);
    Require("SchedulerTimeline", "wait boundary",
            scheduler.CurrentTick() == first_tick + 1 &&
                scheduler.IsFree(first_tick) && completed == 0,
            "timeline wait released a resource in the middle of an operation");
    scheduler.PopPendingOperations();
    Require("SchedulerTimeline", "first tick", completed == 1,
            "operation boundary did not release its deferred operation");

    const auto second_tick = scheduler.CurrentTick();
    std::atomic<bool> priority_in_callback{false};
    scheduler.DeferPriorityOperation([owned = std::make_unique<uint32_t>(2),
                                      &completed, &priority_in_callback] {
      priority_in_callback = CommandScheduler::InDeferredOperation();
      completed = *owned;
    });
    scheduler.Finish();
    scheduler.DrainPriorityOperations();
    Require("SchedulerTimeline", "finish",
            scheduler.CurrentTick() == second_tick + 1 &&
                scheduler.IsFree(second_tick) && completed == 2 &&
                priority_in_callback.load() &&
                !CommandScheduler::InDeferredOperation(),
            "scheduler completion drain lost its tick or callback context");

    const auto implicit_flush_tick = scheduler.CurrentTick();
    scheduler.DeferOperation([owned = std::make_unique<uint32_t>(3),
                              &completed] { completed = *owned; });
    scheduler.Wait(implicit_flush_tick);
    Require("SchedulerTimeline", "implicit flush",
            scheduler.CurrentTick() == implicit_flush_tick + 1 &&
                scheduler.IsFree(implicit_flush_tick) && completed == 2,
            "waiting for the current tick released a deferred resource");
    scheduler.PopPendingOperations();
    Require("SchedulerTimeline", "implicit boundary", completed == 3,
            "operation boundary did not release the implicit tick callback");

    vk::SemaphoreTypeCreateInfo timeline_type{};
    timeline_type.sType = vk::StructureType::eSemaphoreTypeCreateInfo;
    timeline_type.semaphoreType = vk::SemaphoreType::eTimeline;
    vk::SemaphoreCreateInfo timeline_create{};
    timeline_create.sType = vk::StructureType::eSemaphoreCreateInfo;
    timeline_create.pNext = &timeline_type;
    vk::Semaphore external_timeline = nullptr;
    Require("SchedulerTimeline", "external timeline create",
            m_runtime_context.device.createSemaphore(&timeline_create, nullptr,
                                                     &external_timeline) ==
                    vk::Result::eSuccess &&
                external_timeline != nullptr,
            "failed to create the external timeline semaphore");

    constexpr uint64_t external_wait_value = 9;
    const auto external_wait_tick = scheduler.CurrentTick();
    SubmitInfo external_wait;
    external_wait.AddWait(external_timeline, external_wait_value);
    constexpr size_t blocked_submission_count = 6;
    std::array<vk::CommandBuffer, blocked_submission_count> blocked_handles{};
    for (size_t i = 0; i < blocked_submission_count; ++i) {
      blocked_handles[i] = scheduler.Current().Handle();
      if (i == 0) {
        scheduler.Flush(external_wait);
      } else {
        scheduler.Flush();
      }
    }
    bool distinct_handles = true;
    for (size_t i = 0; i < blocked_handles.size(); ++i) {
      for (size_t j = i + 1; j < blocked_handles.size(); ++j) {
        distinct_handles &= blocked_handles[i] != blocked_handles[j];
      }
    }
    const auto last_blocked_tick = scheduler.CurrentTick() - 1;
    Require("SchedulerTimeline", "external timeline overflow",
            distinct_handles &&
                last_blocked_tick ==
                    external_wait_tick + blocked_submission_count - 1 &&
                !scheduler.IsFree(last_blocked_tick),
            "blocked submissions did not grow the command-buffer pool");
    vk::SemaphoreSignalInfo signal_info{};
    signal_info.sType = vk::StructureType::eSemaphoreSignalInfo;
    signal_info.semaphore = external_timeline;
    signal_info.value = external_wait_value;
    Require("SchedulerTimeline", "external timeline signal",
            m_runtime_context.device.signalSemaphore(&signal_info) ==
                vk::Result::eSuccess,
            "failed to signal the external timeline semaphore");
    scheduler.Wait(last_blocked_tick);
    m_runtime_context.device.destroySemaphore(external_timeline, nullptr);
    scheduler.Flush();
    scheduler.Flush();
    Require(
        "SchedulerTimeline", "timeline pool reuse",
        std::ranges::find(blocked_handles, scheduler.Current().Handle()) !=
            blocked_handles.end(),
        "completed command buffers were not reused after timeline progress");
    scheduler.Shutdown();

    CommandScheduler draining(Renderer(), m_runtime_context);
    HW::Context drain_registers{};
    HW::UserConfig drain_user_config{};
    HW::Shader drain_shaders{};
    draining.Begin(drain_registers, drain_user_config, drain_shaders);
    uint32_t reentrant = 0;
    draining.DeferOperation([&draining, &reentrant] {
      reentrant++;
      draining.DeferOperation([&reentrant] { reentrant++; });
    });

    std::binary_semaphore priority_entered{0};
    std::binary_semaphore release_priority{0};
    draining.DeferPriorityOperation(
        [&draining, &priority_entered, &release_priority] {
          priority_entered.release();
          draining.Shutdown();
          release_priority.acquire();
        });
    std::jthread shutdown_thread([&draining] { draining.Shutdown(); });
    priority_entered.acquire();
    std::jthread second_shutdown_thread([&draining] { draining.Shutdown(); });

    std::atomic<bool> concurrent_completed{false};
    std::jthread concurrent_defer([&draining, &concurrent_completed] {
      draining.DeferOperation(
          [&concurrent_completed] { concurrent_completed = true; });
    });
    release_priority.release();
    shutdown_thread.join();
    second_shutdown_thread.join();
    concurrent_defer.join();
    Require("SchedulerTimeline", "shutdown drain",
            reentrant == 2 && concurrent_completed.load(),
            "shutdown lost reentrant or concurrent deferred work");
    std::printf("[host]    %-32s ok\n", "SchedulerTimeline");
  }

  void CheckGpuMappedRangeLifecycle() {
    EnsureRuntimeContext();
    RenderContext context(m_runtime_context);
    auto &scheduler = context.GetCommandScheduler();
    HW::Context registers{};
    HW::UserConfig user_config{};
    HW::Shader shaders{};
    scheduler.Begin(registers, user_config, shaders);
    context.InitializeGpu(nullptr);
    auto &resources = context;

    constexpr uint64_t base = 0x0000000200000000ull;
    constexpr uint64_t page = 0x4000;
    resources.MapMemory(base, page * 4);
    resources.MapMemory(base + page * 2, page * 4);
    Require("GpuMappedRangeLifecycle", "union",
            resources.IsMapped(base, page * 6) &&
                !resources.IsMapped(base, page * 7),
            "overlapping maps did not form one interval union");

    resources.UnmapMemory(base + page * 2, page * 2);
    Require("GpuMappedRangeLifecycle", "subtract",
            resources.IsMapped(base, page * 2) &&
                resources.IsMapped(base + page * 4, page * 2) &&
                !resources.IsMapped(base, page * 6),
            "partial unmap did not punch the expected interval hole");

    resources.UnmapMemory(base + page * 2, page * 2);
    Require("GpuMappedRangeLifecycle", "idempotent unmap",
            resources.IsMapped(base, page * 2) &&
                resources.IsMapped(base + page * 4, page * 2),
            "unmapping an absent interval changed neighboring mappings");

    resources.UnmapMemory(base, page * 6);
    Require("GpuMappedRangeLifecycle", "clear",
            !resources.IsMapped(base, page * 6),
            "full unmap did not clear the interval union");

    constexpr uint64_t old_prt = base + page * 8;
    constexpr uint64_t new_prt = base + page * 16;
    resources.MapMemory(old_prt, page * 4);
    resources.UnmapMemory(old_prt, page * 4);
    resources.MapMemory(new_prt, page * 6);
    Require("GpuMappedRangeLifecycle", "PRT replacement",
            !resources.IsMapped(old_prt, page * 4) &&
                resources.IsMapped(new_prt, page * 6),
            "old-unmap/new-map did not replace full PRT coverage");

    scheduler.Finish();
    context.ShutdownGpu();
    std::printf("[host]    %-32s ok\n", "GpuMappedRangeLifecycle");
  }

  void CheckStreamBufferRing() {
    EnsureRuntimeContext();
    RenderContext context(m_runtime_context);
    auto &scheduler = context.GetCommandScheduler();
    HW::Context registers{};
    HW::UserConfig user_config{};
    HW::Shader shaders{};
    scheduler.Begin(registers, user_config, shaders);
    auto &resources = context;
    auto &cache = resources.GetBufferCache();
    constexpr std::array<std::pair<MemoryUsage, uint64_t>, 4> utilities{{
        {MemoryUsage::Upload, 512ull << 20},
        {MemoryUsage::Stream, 64ull << 20},
        {MemoryUsage::Download, 32ull << 20},
        {MemoryUsage::DeviceLocal, 128ull << 20},
    }};
    std::array<vk::Buffer, utilities.size()> handles{};
    for (size_t i = 0; i < utilities.size(); i++) {
      auto &utility = cache.GetUtilityBuffer(utilities[i].first);
      handles[i] = utility.Handle();
      Require("StreamBufferRing", "utility ownership",
              utility.Usage() == utilities[i].first &&
                  utility.Size() == utilities[i].second &&
                  utility.Handle() != nullptr,
              "BufferCache utility buffer does not match the fixed layout");
    }
    for (size_t i = 0; i < handles.size(); i++) {
      for (size_t j = i + 1; j < handles.size(); j++) {
        Require("StreamBufferRing", "utility identity",
                handles[i] != handles[j],
                "utility usages alias the same native buffer");
      }
    }
    auto *fixed_download = &cache.GetUtilityBuffer(MemoryUsage::Download);
    const auto fixed_handle = fixed_download->Handle();
    const auto [oversized_download, oversized_offset] =
        fixed_download->Map(fixed_download->Size() + 4, 64, false);
    const auto [download_probe, download_probe_offset] =
        fixed_download->Map(64, 64, false);
    Require("StreamBufferRing", "fixed download utility",
            oversized_download == nullptr && oversized_offset == 0 &&
                download_probe != nullptr && download_probe_offset == 0 &&
                &cache.GetUtilityBuffer(MemoryUsage::Download) ==
                    fixed_download &&
                fixed_download->Size() == (32ull << 20) &&
                fixed_download->Handle() == fixed_handle,
            "oversized download replaced or corrupted the fixed shared ring");
    fixed_download->Commit();

    const std::array<uint8_t, 16> overflow_data{
        0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5,
        0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5, 0xa5};
    auto &upload_stream = cache.GetUtilityBuffer(MemoryUsage::Stream);
    const auto stream_offset =
        upload_stream.Copy(overflow_data.data(), overflow_data.size(), 16);
    Require("StreamBufferRing", "cache-owned stream upload",
            upload_stream.Handle() != nullptr &&
                stream_offset < upload_stream.Size() &&
                std::memcmp(upload_stream.Mapped().data() + stream_offset,
                            overflow_data.data(), overflow_data.size()) == 0,
            "cache-owned stream upload lost bytes");

    const auto atom =
        m_runtime_context.physical_device_properties.limits.nonCoherentAtomSize;
    uint64_t policy_size = 17;
    uint64_t policy_alignment = 12;
    uint64_t coherent_size = policy_size;
    uint64_t coherent_alignment = policy_alignment;
    Require("StreamBufferRing", "non-coherent reservation policy",
            StreamBufferTestAccess::NormalizeReservation(
                false, 256, policy_size, policy_alignment) &&
                policy_size == 256 && policy_alignment == 768 &&
                StreamBufferTestAccess::NormalizeReservation(
                    true, 256, coherent_size, coherent_alignment) &&
                coherent_size == 17 && coherent_alignment == 12,
            "non-coherent reservations are not isolated at the atom/texel LCM");
    const auto small_ring_size = std::max<uint64_t>(64, atom * 2);
    StreamBuffer stream(m_runtime_context, scheduler, MemoryUsage::Upload,
                        small_ring_size);
    const auto first_size =
        stream.IsCoherent() ? small_ring_size - 16 : small_ring_size - atom + 1;
    constexpr uint64_t blocked_size = 24;
    const auto [first, first_offset] = stream.Map(first_size, 16, false);
    Require("StreamBufferRing", "first allocation",
            first != nullptr && first_offset == 0,
            "initial stream allocation failed");
    std::memset(first, 0x5a, static_cast<size_t>(first_size));
    stream.Commit();

    const auto [oversize, oversize_offset] =
        stream.Map(small_ring_size + 1, 1, false);
    Require("StreamBufferRing", "oversize",
            oversize == nullptr && oversize_offset == 0,
            "oversize allocation was accepted");
    const auto [blocked, blocked_offset] = stream.Map(blocked_size, 1, false);
    const auto [blocked_again, blocked_again_offset] =
        stream.Map(blocked_size, 1, false);
    Require("StreamBufferRing", "transactional failure",
            blocked == nullptr && blocked_offset == 0 &&
                blocked_again == nullptr && blocked_again_offset == 0,
            "failed wrap mutated stream state");

    scheduler.Flush();
    const auto [wrapped, wrapped_offset] = stream.Map(blocked_size, 1);
    Require("StreamBufferRing", "watched wrap",
            wrapped != nullptr && wrapped_offset == 0,
            "completed watch did not release the wrapped allocation");
    stream.Commit();

    const auto download_alignment = atom / std::gcd<uint64_t>(atom, 12) * 12;
    const auto download_ring_size = std::max<uint64_t>(
        64, download_alignment + std::max<uint64_t>(atom, 16));
    StreamBuffer download(m_runtime_context, scheduler, MemoryUsage::Download,
                          download_ring_size);
    const auto [download_data, download_offset] = download.Map(16, 8);
    Require("StreamBufferRing", "download allocation",
            download_data != nullptr && download_offset == 0,
            "download stream is not host visible");
    download.Commit();
    scheduler.Flush();
    const auto [second_download, second_download_offset] = download.Map(16, 12);
    Require("StreamBufferRing", "download atom isolation",
            second_download != nullptr &&
                (download.IsCoherent() ||
                 (download_offset % atom == 0 &&
                  second_download_offset % atom == 0 &&
                  second_download_offset >= download_offset + atom)) &&
                second_download_offset % 12 == 0,
            "download reservations share a non-coherent atom or lost caller "
            "alignment");
    download.Commit();

    scheduler.Finish();
    download.Invalidate(download_offset, 16);
    std::printf("[host]    %-32s ok\n", "StreamBufferRing");
  }

  void CheckGpuCommandLane() {
    EnsureRuntimeContext();
    auto &context = Renderer();
    context.InitializeGpu(nullptr);
    auto &gpu = context.GetGpu();

    const auto caller_thread = std::this_thread::get_id();
    std::thread::id gpu_thread;
    std::thread::id nested_thread;
    uint32_t order = 0;
    gpu.SendCommand([&order] { order = 1; });
    gpu.SendCommandSync([&] {
      gpu_thread = std::this_thread::get_id();
      Require("GpuCommandLane", "FIFO", order == 1,
              "synchronous command overtook an older host command");
      Require("GpuCommandLane", "GPU context", GuestGpu::IsGpuThread(),
              "host command did not run on the GPU thread");
      gpu.SendCommandSync(
          [&nested_thread] { nested_thread = std::this_thread::get_id(); });
      order = 2;
    });
    Require(
        "GpuCommandLane", "dispatch thread",
        order == 2 && gpu_thread != caller_thread &&
            nested_thread == gpu_thread,
        "host command did not run on the GPU thread or nested sync deadlocked");

    {
      const auto make_release_mem =
          [](uint32_t data_sel, uint32_t interrupt_selector, void *destination,
             uint64_t value, uint32_t action = 0x28u,
             uint32_t gcr_cntl = 1u << 9u) {
            std::array<uint32_t, 8> packet{};
            const auto address = reinterpret_cast<uint64_t>(destination);
            const auto event_index = (action >= 0x2fu ? 6u : 5u);
            packet[0] = KYTY_PM4(8, Pm4::IT_NOP, Pm4::R_RELEASE_MEM);
            packet[1] = action | (event_index << 8u) | (gcr_cntl << 12u);
            packet[2] = (interrupt_selector << 24u) | (data_sel << 29u);
            packet[3] = static_cast<uint32_t>(address);
            packet[4] = static_cast<uint32_t>(address >> 32u);
            packet[5] = static_cast<uint32_t>(value);
            packet[6] = static_cast<uint32_t>(value >> 32u);
            packet[7] = 0x123u;
            return packet;
          };

      vk::SemaphoreTypeCreateInfo timeline_type{};
      timeline_type.sType = vk::StructureType::eSemaphoreTypeCreateInfo;
      timeline_type.semaphoreType = vk::SemaphoreType::eTimeline;
      vk::SemaphoreCreateInfo timeline_create{};
      timeline_create.sType = vk::StructureType::eSemaphoreCreateInfo;
      timeline_create.pNext = &timeline_type;
      vk::Semaphore blocked_timeline = nullptr;
      Require("GpuCommandLane", "blocked timeline create",
              m_runtime_context.device.createSemaphore(
                  &timeline_create, nullptr, &blocked_timeline) ==
                      vk::Result::eSuccess &&
                  blocked_timeline != nullptr,
              "failed to create the blocked GPU timeline");

      constexpr uint64_t release_tick = 1;
      auto &gpu_scheduler = context.GetCommandScheduler();
      auto processor = std::make_unique<CommandProcessor>(context, 0);
      gpu.SendCommandSync([&] {
        processor->BufferInit();
        SubmitInfo blocked_submit;
        blocked_submit.AddWait(blocked_timeline, release_tick);
        gpu_scheduler.Flush(blocked_submit);
      });

      std::binary_semaphore parser_complete{0};
      alignas(uint64_t) uint64_t interrupt_only_gds_label = UINT64_MAX;
      alignas(uint64_t) uint64_t cb_db_release_label = UINT64_MAX;
      bool parser_kept_nonblocking_boundaries = false;
      std::jthread no_gpu_wait([&] {
        gpu.SendCommandSync([&] {
          processor->BufferInit();
          const auto tick_before = gpu_scheduler.CurrentTick();
          processor->TriggerEvent(0x16u, 0u);
          auto packet = make_release_mem(0, 0, nullptr, 0);
          Pm4Execution execution;
          const auto result = processor->Process(execution, packet);
          processor->IncrementDe();
          const bool cache_and_counter_did_not_submit =
              result == Pm4ProcessResult::Complete &&
              gpu_scheduler.CurrentTick() == tick_before;

          const auto cb_db_tick = gpu_scheduler.CurrentTick();
          auto cb_db_release =
              make_release_mem(2, 0, &cb_db_release_label, 0, 0x14u, 0);
          Pm4Execution cb_db_execution;
          const auto cb_db_result =
              processor->Process(cb_db_execution, cb_db_release);
          const bool cb_db_release_did_not_submit =
              cb_db_result == Pm4ProcessResult::Complete &&
              cb_db_release_label == 0 &&
              gpu_scheduler.CurrentTick() == cb_db_tick;

          auto gds_interrupt_only =
              make_release_mem(5, 1, &interrupt_only_gds_label, 1ull << 16u);
          Pm4Execution gds_interrupt_execution;
          const auto interrupt_tick = gpu_scheduler.CurrentTick();
          const auto interrupt_result =
              processor->Process(gds_interrupt_execution, gds_interrupt_only);
          parser_kept_nonblocking_boundaries =
              cache_and_counter_did_not_submit &&
              cb_db_release_did_not_submit &&
              interrupt_result == Pm4ProcessResult::Complete &&
              gpu_scheduler.CurrentTick() == interrupt_tick + 1 &&
              interrupt_only_gds_label == UINT64_MAX;
        });
        parser_complete.release();
      });
      const bool parser_did_not_wait_gpu =
          parser_complete.try_acquire_for(std::chrono::seconds(2));

      vk::SemaphoreSignalInfo signal_info{};
      signal_info.sType = vk::StructureType::eSemaphoreSignalInfo;
      signal_info.semaphore = blocked_timeline;
      signal_info.value = release_tick;
      Require("GpuCommandLane", "blocked timeline signal",
              m_runtime_context.device.signalSemaphore(&signal_info) ==
                  vk::Result::eSuccess,
              "failed to release the blocked GPU timeline");
      no_gpu_wait.join();
      gpu.SendCommandSync([&] { gpu_scheduler.Finish(); });
      m_runtime_context.device.destroySemaphore(blocked_timeline, nullptr);
      Require("GpuCommandLane", "nonblocking GPU packets",
              parser_did_not_wait_gpu && parser_kept_nonblocking_boundaries,
              "a cache event, GL2 writeback, DE counter, or interrupt boundary "
              "used the wrong "
              "submission behavior");

      alignas(uint64_t) uint64_t release_label = 0;
      alignas(uint64_t) uint64_t gds_label = UINT64_MAX;
      bool release_mem_submission_counts = false;
      gpu.SendCommandSync([&] {
        processor->BufferInit();

        auto immediate = make_release_mem(1, 0, &release_label, 0x11223344u);
        Pm4Execution immediate_execution;
        const auto immediate_tick = gpu_scheduler.CurrentTick();
        const auto immediate_result =
            processor->Process(immediate_execution, immediate);
        const bool immediate_split_once =
            gpu_scheduler.CurrentTick() == immediate_tick + 1;

        auto gds = make_release_mem(5, 0, &gds_label, 1ull << 16u);
        Pm4Execution gds_execution;
        const auto gds_tick = gpu_scheduler.CurrentTick();
        const auto gds_result = processor->Process(gds_execution, gds);
        const bool gds_waited_once =
            gpu_scheduler.CurrentTick() == gds_tick + 1;

        auto interrupt_only = make_release_mem(0, 4, nullptr, 0);
        Pm4Execution interrupt_execution;
        const auto interrupt_tick = gpu_scheduler.CurrentTick();
        const auto interrupt_result =
            processor->Process(interrupt_execution, interrupt_only);
        const bool interrupt_split_once =
            gpu_scheduler.CurrentTick() == interrupt_tick + 1;

        auto gds_interrupt = make_release_mem(5, 2, &gds_label, 1ull << 16u);
        Pm4Execution gds_interrupt_execution;
        const auto gds_interrupt_tick = gpu_scheduler.CurrentTick();
        const auto gds_interrupt_result =
            processor->Process(gds_interrupt_execution, gds_interrupt);
        const bool gds_interrupt_waited_once =
            gpu_scheduler.CurrentTick() == gds_interrupt_tick + 1;

        release_mem_submission_counts =
            immediate_result == Pm4ProcessResult::Complete &&
            immediate_split_once && gds_result == Pm4ProcessResult::Complete &&
            gds_waited_once && interrupt_result == Pm4ProcessResult::Complete &&
            interrupt_split_once &&
            gds_interrupt_result == Pm4ProcessResult::Complete &&
            gds_interrupt_waited_once;
      });
      gpu.SendCommandSync([&] {
        gpu_scheduler.Finish();
        gpu_scheduler.WaitPriorityOperations(gpu_scheduler.CurrentTick() - 1);
      });
      Require("GpuCommandLane", "RELEASE_MEM submission counts",
              release_mem_submission_counts &&
                  static_cast<uint32_t>(release_label) == 0x11223344u &&
                  static_cast<uint32_t>(gds_label) == 0,
              "RELEASE_MEM lost its required split/readback or retained a "
              "redundant GPU wait");
    }

    alignas(uint32_t) uint32_t packet_marker_a = 0;
    alignas(uint32_t) uint32_t packet_marker_b = 0;
    const auto write_packet = [](uint32_t *packet, uint32_t *destination,
                                 uint32_t value) {
      const auto destination_address = reinterpret_cast<uint64_t>(destination);
      packet[0] = KYTY_PM4(5, Pm4::IT_WRITE_DATA, 0);
      packet[1] = 0;
      packet[2] = static_cast<uint32_t>(destination_address);
      packet[3] = static_cast<uint32_t>(destination_address >> 32u);
      packet[4] = value;
    };

    uint32_t live_graphics_value = 0;
    std::array<uint32_t, 5> live_graphics_commands{};
    write_packet(live_graphics_commands.data(), &live_graphics_value, 11);
    std::binary_semaphore graphics_gate_entered{0};
    std::binary_semaphore graphics_gate_release{0};
    gpu.SendCommand([&] {
      graphics_gate_entered.release();
      graphics_gate_release.acquire();
    });
    gpu.Submit(live_graphics_commands, {});
    graphics_gate_entered.acquire();
    live_graphics_commands[4] = 22;
    graphics_gate_release.release();
    gpu.Done();
    Require("GpuCommandLane", "borrowed graphics commands",
            live_graphics_value == 22,
            "graphics submission executed a copied PM4 stream");

    uint32_t live_compute_value = 0;
    std::array<uint32_t, 5> live_compute_commands{};
    write_packet(live_compute_commands.data(), &live_compute_value, 33);
    std::binary_semaphore compute_gate_entered{0};
    std::binary_semaphore compute_gate_release{0};
    gpu.SendCommand([&] {
      compute_gate_entered.release();
      compute_gate_release.acquire();
    });
    gpu.SubmitCompute(0x20, live_compute_commands);
    compute_gate_entered.acquire();
    live_compute_commands[4] = 44;
    compute_gate_release.release();
    gpu.Done();
    Require("GpuCommandLane", "borrowed compute commands",
            live_compute_value == 44,
            "compute submission executed a copied PM4 stream");

    LibKernel::EventQueue::KernelEqueue interrupt_queue =
        LibKernel::EventQueue::KERNEL_EQUEUE_INVALID;
    uint32_t graphics_interrupt_udata = 0;
    uint32_t compute_interrupt_udata = 0;
    uint32_t other_compute_interrupt_udata = 0;
    const bool interrupt_queue_ready =
        LibKernel::EventQueue::KernelCreateEqueue(&interrupt_queue,
                                                  "pm4-interrupts") == 0 &&
        Sync::AddEqEvent(context, interrupt_queue, 0,
                         &graphics_interrupt_udata) == 0 &&
        Sync::AddEqEvent(context, interrupt_queue, 0x20,
                         &compute_interrupt_udata) == 0 &&
        Sync::AddEqEvent(context, interrupt_queue, 0x21,
                         &other_compute_interrupt_udata) == 0;
    Require("GpuCommandLane", "interrupt queue", interrupt_queue_ready,
            "failed to register the PM4 interrupt events");

    const auto make_interrupt_packet =
        [](uint32_t data_selector, uint32_t interrupt_selector,
           void *destination, uint64_t value, uint32_t context_id) {
          std::array<uint32_t, 8> packet{};
          const auto address = reinterpret_cast<uint64_t>(destination);
          packet[0] = KYTY_PM4(8, Pm4::IT_NOP, Pm4::R_RELEASE_MEM);
          packet[1] = 0x28u | (5u << 8u);
          packet[2] = (interrupt_selector << 24u) | (data_selector << 29u);
          packet[3] = static_cast<uint32_t>(address);
          packet[4] = static_cast<uint32_t>(address >> 32u);
          packet[5] = static_cast<uint32_t>(value);
          packet[6] = static_cast<uint32_t>(value >> 32u);
          packet[7] = context_id & 0x07ffffffu;
          return packet;
        };
    const auto finish_gpu = [&] {
      gpu.SendCommandSync([&] {
        auto &scheduler = context.GetCommandScheduler();
        scheduler.Finish();
        scheduler.WaitPriorityOperations(scheduler.CurrentTick() - 1);
      });
    };
    const auto wait_for_interrupt =
        [&](LibKernel::EventQueue::KernelEvent &event, int &count) {
          LibKernel::KernelUseconds timeout = 0;
          return LibKernel::EventQueue::KernelWaitEqueue(
              interrupt_queue, &event, 1, &count, &timeout);
        };

    uint32_t no_interrupt_graphics_value = 0;
    std::array<uint32_t, 5> no_interrupt_graphics_commands{};
    write_packet(no_interrupt_graphics_commands.data(),
                 &no_interrupt_graphics_value, 55);
    gpu.Submit(no_interrupt_graphics_commands, {});
    gpu.Done();
    finish_gpu();

    LibKernel::EventQueue::KernelEvent interrupt_event{};
    int interrupt_count = 0;
    const auto no_graphics_interrupt_wait =
        wait_for_interrupt(interrupt_event, interrupt_count);
    Require("GpuCommandLane", "no implicit graphics interrupt",
            no_graphics_interrupt_wait == LibKernel::KERNEL_ERROR_ETIMEDOUT &&
                interrupt_count == 0 && no_interrupt_graphics_value == 55,
            "graphics submission completion synthesized an interrupt");

    auto live_interrupt_commands =
        make_interrupt_packet(0, 1, nullptr, 0, 0x234u);
    std::binary_semaphore interrupt_gate_entered{0};
    std::binary_semaphore interrupt_gate_release{0};
    gpu.SendCommand([&] {
      interrupt_gate_entered.release();
      interrupt_gate_release.acquire();
    });
    gpu.SubmitCompute(0x20, live_interrupt_commands);
    interrupt_gate_entered.acquire();
    live_interrupt_commands[2] = 0;
    interrupt_gate_release.release();
    gpu.Done();
    finish_gpu();

    interrupt_count = 0;
    const auto no_interrupt_wait =
        wait_for_interrupt(interrupt_event, interrupt_count);
    Require("GpuCommandLane", "no implicit completion interrupt",
            no_interrupt_wait == LibKernel::KERNEL_ERROR_ETIMEDOUT &&
                interrupt_count == 0,
            "submission completion synthesized an interrupt absent from the "
            "executed PM4 stream");

    uint32_t graphics_interrupt_label = 0xa5a5a5a5u;
    auto graphics_interrupt_commands = make_interrupt_packet(
        1, 1, &graphics_interrupt_label, 0x11223344u, 0);
    gpu.Submit(graphics_interrupt_commands, {});
    gpu.Done();
    finish_gpu();

    interrupt_count = 0;
    const auto graphics_interrupt_wait =
        wait_for_interrupt(interrupt_event, interrupt_count);
    Require("GpuCommandLane", "graphics interrupt routing",
            graphics_interrupt_wait == 0 && interrupt_count == 1 &&
                interrupt_event.ident == 0 && interrupt_event.data == 0 &&
                interrupt_event.udata == &graphics_interrupt_udata &&
                graphics_interrupt_label == 0xa5a5a5a5u,
            "graphics kOnly interrupt was misrouted or wrote its label");

    uint32_t compute_interrupt_label = 0x5a5a5a5au;
    auto compute_interrupt_commands = make_interrupt_packet(
        1, 0, &compute_interrupt_label, 0x55667788u, 0x456u);
    std::binary_semaphore compute_interrupt_gate_entered{0};
    std::binary_semaphore compute_interrupt_gate_release{0};
    gpu.SendCommand([&] {
      compute_interrupt_gate_entered.release();
      compute_interrupt_gate_release.acquire();
    });
    gpu.SubmitCompute(0x20, compute_interrupt_commands);
    compute_interrupt_gate_entered.acquire();
    compute_interrupt_commands[2] |= 1u << 24u;
    compute_interrupt_gate_release.release();
    gpu.Done();
    finish_gpu();

    interrupt_count = 0;
    const auto compute_interrupt_wait =
        wait_for_interrupt(interrupt_event, interrupt_count);
    const bool compute_interrupt_matches =
        compute_interrupt_wait == 0 && interrupt_count == 1 &&
        interrupt_event.ident == 0x20 && interrupt_event.data == 0x456u &&
        interrupt_event.udata == &compute_interrupt_udata &&
        compute_interrupt_label == 0x55667788u;

    uint64_t compute_clock_label = 0;
    auto compute_clock_commands = make_interrupt_packet(
        3, 1, &compute_clock_label, 0, 0x567u);
    gpu.SubmitCompute(0x20, compute_clock_commands);
    gpu.Done();
    finish_gpu();

    interrupt_count = 0;
    const auto compute_clock_wait =
        wait_for_interrupt(interrupt_event, interrupt_count);
    const bool compute_clock_matches =
        compute_clock_wait == 0 && interrupt_count == 1 &&
        interrupt_event.ident == 0x20 && interrupt_event.data == 0x567u &&
        interrupt_event.udata == &compute_interrupt_udata &&
        compute_clock_label != 0;

    constexpr uint64_t compute_done_value = 0x1234567887654321ull;
    uint64_t compute_done_label = 0;
    auto compute_done_commands = make_interrupt_packet(
        2, 2, &compute_done_label, compute_done_value, 0x678u);
    compute_done_commands[1] = 0x62fu; // CS_DONE, shader-done index, no GCR action.
    gpu.SubmitCompute(0x20, compute_done_commands);
    gpu.Done();
    finish_gpu();

    interrupt_count = 0;
    const auto compute_done_wait =
        wait_for_interrupt(interrupt_event, interrupt_count);
    Require("GpuCommandLane", "CS_DONE write-confirm interrupt",
            compute_done_wait == 0 && interrupt_count == 1 &&
                interrupt_event.ident == 0x20 && interrupt_event.data == 0x678u &&
                interrupt_event.udata == &compute_interrupt_udata &&
                compute_done_label == compute_done_value,
            "CS_DONE lost its full 64-bit label write or write-confirm interrupt");

    interrupt_count = 0;
    const auto extra_interrupt_wait =
        wait_for_interrupt(interrupt_event, interrupt_count);
    const auto delete_other_compute_event =
        Sync::DeleteEqEvent(context, interrupt_queue, 0x21);
    LibKernel::EventQueue::KernelDeleteEqueue(interrupt_queue);
    context.TriggerInterrupt(0, 0);
    context.TriggerInterrupt(0x20, 0);
    context.TriggerInterrupt(0x21, 0);
    Require("GpuCommandLane", "compute interrupt routing",
            compute_interrupt_matches && compute_clock_matches &&
                extra_interrupt_wait == LibKernel::KERNEL_ERROR_ETIMEDOUT &&
                interrupt_count == 0 && delete_other_compute_event == 0,
            "compute kOnly interrupt was misrouted, broadcast, or lost a "
            "label write");

    std::array<uint32_t, 1024> polling_loop{};
    for (size_t i = 0; i < polling_loop.size() - 4; i += 2) {
      polling_loop[i] = KYTY_PM4(2, Pm4::IT_NOP, Pm4::R_ZERO);
      polling_loop[i + 1] = 0;
    }
    const auto loop_address = reinterpret_cast<uint64_t>(polling_loop.data());
    polling_loop[1020] = KYTY_PM4(4, Pm4::IT_INDIRECT_BUFFER, 0);
    polling_loop[1021] = static_cast<uint32_t>(loop_address);
    polling_loop[1022] = static_cast<uint32_t>(loop_address >> 32u);
    polling_loop[1023] =
        0x0f200000u | static_cast<uint32_t>(polling_loop.size());

    std::array<uint32_t, 14> polling_commands{};
    write_packet(polling_commands.data(), &packet_marker_a, 11);
    polling_commands[5] = KYTY_PM4(4, Pm4::IT_INDIRECT_BUFFER, 0);
    polling_commands[6] = static_cast<uint32_t>(loop_address);
    polling_commands[7] = static_cast<uint32_t>(loop_address >> 32u);
    polling_commands[8] =
        0x0f200000u | static_cast<uint32_t>(polling_loop.size());
    write_packet(polling_commands.data() + 9, &packet_marker_b, 22);
    std::binary_semaphore stream_gate_entered{0};
    std::binary_semaphore stream_gate_release{0};
    gpu.SendCommand([&] {
      stream_gate_entered.release();
      stream_gate_release.acquire();
    });
    gpu.Submit(polling_commands, {});
    stream_gate_entered.acquire();
    stream_gate_release.release();
    uint32_t packet_marker_a_at_callback = UINT32_MAX;
    uint32_t packet_marker_b_at_callback = UINT32_MAX;
    for (uint32_t attempt = 0; attempt < 8 && packet_marker_a_at_callback != 11;
         attempt++) {
      gpu.SendCommandSync([&] {
        if (packet_marker_a == 11 && packet_marker_b == 0) {
          packet_marker_a_at_callback = packet_marker_a;
          packet_marker_b_at_callback = packet_marker_b;
          polling_commands[13] = 33;
          polling_loop[1020] = KYTY_PM4(2, Pm4::IT_NOP, Pm4::R_ZERO);
          polling_loop[1021] = 0;
          polling_loop[1022] = KYTY_PM4(2, Pm4::IT_NOP, Pm4::R_ZERO);
          polling_loop[1023] = 0;
        }
      });
      std::this_thread::yield();
    }
    gpu.Done();
    Require("GpuCommandLane", "packet-boundary command polling",
            packet_marker_a_at_callback == 11 &&
                packet_marker_b_at_callback == 0 && packet_marker_a == 11 &&
                packet_marker_b == 33,
            "host command waited for an entire PM4 stream or resumed a copied "
            "stream");

    uint32_t label = 0;
    uint32_t prefix = 0;
    uint32_t suffix = 0;
    const auto address = [](const void *value) {
      return reinterpret_cast<uint64_t>(value);
    };
    std::array<uint32_t, 17> commands{};
    commands[0] = KYTY_PM4(5, Pm4::IT_WRITE_DATA, 0);
    commands[1] = 0;
    commands[2] = static_cast<uint32_t>(address(&prefix));
    commands[3] = static_cast<uint32_t>(address(&prefix) >> 32u);
    commands[4] = 11;
    commands[5] = KYTY_PM4(7, Pm4::IT_WAIT_REG_MEM, 0);
    commands[6] = 0x10u | 3u;
    commands[7] = static_cast<uint32_t>(address(&label));
    commands[8] = static_cast<uint32_t>(address(&label) >> 32u);
    commands[9] = 1;
    commands[10] = UINT32_MAX;
    commands[12] = KYTY_PM4(5, Pm4::IT_WRITE_DATA, 0);
    commands[13] = 0;
    commands[14] = static_cast<uint32_t>(address(&suffix));
    commands[15] = static_cast<uint32_t>(address(&suffix) >> 32u);
    commands[16] = 22;
      gpu.Submit(commands, {});

    std::binary_semaphore ordered_started{0};
    std::atomic<bool> ordered_finished{false};
    uint32_t ordered_suffix = 0;
    std::jthread ordered([&] {
      ordered_started.release();
      gpu.Done();
      ordered_suffix = suffix;
      ordered_finished = true;
    });
    ordered_started.acquire();
    gpu.SendCommandSync([&] {
      Require("GpuCommandLane", "submit done barrier", !ordered_finished.load(),
              "submit done returned before a queued submission");
      label = 1;
    });
    ordered.join();
    Require("GpuCommandLane", "ordered completion",
            prefix == 11 && suffix == 22 && ordered_suffix == 22 &&
                ordered_finished.load(),
            "submit done did not drain prior PM4 work");

    auto &resources = context;
    constexpr uint64_t empty_unmap_base = 0x0000000200400000ull;
    constexpr uint64_t empty_unmap_size = 0x4000;
    resources.MapMemory(empty_unmap_base, empty_unmap_size);
    label = 0;
    prefix = 0;
    suffix = 0;
    gpu.Submit(commands, {});

    std::binary_semaphore unmap_complete{0};
    std::jthread unmap_thread([&] {
      resources.UnmapMemory(empty_unmap_base, empty_unmap_size);
      unmap_complete.release();
    });
    const bool unmap_returned =
        unmap_complete.try_acquire_for(std::chrono::seconds(2));
    gpu.SendCommandSync([&] { label = 1; });
    if (!unmap_returned) {
      unmap_complete.acquire();
    }
    unmap_thread.join();
    gpu.Done();
    Require("GpuCommandLane", "unmap queue progress",
            unmap_returned &&
                !resources.IsMapped(empty_unmap_base, empty_unmap_size) &&
                prefix == 11 && suffix == 22,
            "an unrelated unmap waited for a blocked PM4 submission");

    auto &scheduler = context.GetCommandScheduler();
    std::atomic<bool> normal_completed{false};
    gpu.SendCommandSync(
        [&] { scheduler.DeferOperation([&] { normal_completed = true; }); });
    resources.MapMemory(empty_unmap_base, empty_unmap_size);
    resources.UnmapMemory(empty_unmap_base, empty_unmap_size);
    Require("GpuCommandLane", "unmap native completion",
            normal_completed.load() &&
                !resources.IsMapped(empty_unmap_base, empty_unmap_size),
            "unmap returned before an earlier native guest-memory callback");

    std::binary_semaphore priority_entered{0};
    std::binary_semaphore release_priority{0};
    gpu.SendCommandSync([&] {
      scheduler.DeferPriorityOperation([&] {
        priority_entered.release();
        release_priority.acquire();
      });
      scheduler.Flush();
    });
    priority_entered.acquire();
    resources.MapMemory(empty_unmap_base, empty_unmap_size);

    std::binary_semaphore priority_unmap_entered{0};
    std::binary_semaphore priority_unmap_complete{0};
    std::jthread priority_unmap_thread([&] {
      gpu.SendCommandSync([&] {
        priority_unmap_entered.release();
        resources.UnmapMemory(empty_unmap_base, empty_unmap_size);
      });
      priority_unmap_complete.release();
    });
    priority_unmap_entered.acquire();
    const bool unmap_overtook_priority =
        priority_unmap_complete.try_acquire_for(std::chrono::seconds(1));
    release_priority.release();
    if (!unmap_overtook_priority) {
      priority_unmap_complete.acquire();
    }
    priority_unmap_thread.join();
    Require("GpuCommandLane", "unmap priority ordering",
            !unmap_overtook_priority &&
                !resources.IsMapped(empty_unmap_base, empty_unmap_size),
            "unmap returned before an earlier guest-memory callback");

    constexpr uintptr_t fault_base = 0x0000000200500000ull;
    constexpr uint64_t fault_size = 0x10000;
    int64_t fault_direct_offset = -1;
    Require("GpuCommandLane", "processor fault direct allocation",
            Libs::LibKernel::Memory::KernelAllocateDirectMemory(
                0, Libs::LibKernel::Memory::KernelGetDirectMemorySize(),
                fault_size, fault_size, 0, &fault_direct_offset) == 0,
            "processor-fault direct-memory allocation failed");
    void *fault_memory = reinterpret_cast<void *>(fault_base);
    Require("GpuCommandLane", "processor fault direct mapping",
            Libs::LibKernel::Memory::KernelMapDirectMemory(
                &fault_memory, fault_size, 0x3, 0x10, fault_direct_offset,
                fault_size) == 0,
            "processor-fault fixed direct-memory mapping failed");
    Require("GpuCommandLane", "processor fault allocation",
            fault_memory == reinterpret_cast<void *>(fault_base),
            "fixed processor-fault allocation failed");
    resources.MapMemory(fault_base, fault_size);

    constexpr uint64_t immediate_dst = fault_base + 0x1000;
    constexpr uint64_t immediate_memory_dst = fault_base + 0x2000;
    constexpr uint64_t memory_src = fault_base + 0x4000;
    constexpr uint64_t memory_copy_dst = fault_base + 0x6000;
    constexpr uint64_t memory_dst = fault_base + 0x8000;
    constexpr uint64_t l2_copy_dst = fault_base + 0xa000;
    constexpr uint64_t nowhere_dst = fault_base + 0xc000;
    constexpr uint64_t clean_cached_fill = fault_base + 0x3000;
    constexpr uint64_t clean_cached_copy = fault_base + 0x3008;
    constexpr uint64_t clean_cached_source = fault_base + 0x3010;
    constexpr uint64_t clean_cached_readback = fault_base + 0xb000;
    constexpr std::array<uint32_t, 2> source_words{0x11223344u, 0x55667788u};
    constexpr std::array<uint32_t, 2> nowhere_words{0x89abcdefu, 0x01234567u};
    constexpr std::array<uint32_t, 2> clean_copy_words{0x13579bdfu,
                                                       0x2468ace0u};
    std::memcpy(reinterpret_cast<void *>(memory_src), source_words.data(),
                sizeof(source_words));
    std::memcpy(reinterpret_cast<void *>(nowhere_dst), nowhere_words.data(),
                sizeof(nowhere_words));
    std::memcpy(reinterpret_cast<void *>(clean_cached_source),
                clean_copy_words.data(), sizeof(clean_copy_words));

    std::array<uint32_t, 56> dma_commands{};
    size_t dma_cursor = 0;
    const auto append_dma = [&](uint8_t dst_sel, uint64_t dst, uint8_t src_sel,
                                uint64_t src, uint32_t bytes,
                                uint32_t command_flags = 0) {
      auto *packet = dma_commands.data() + dma_cursor;
      dma_cursor += 7;
      packet[0] = KYTY_PM4(7, Pm4::IT_DMA_DATA, 0);
      packet[1] = (static_cast<uint32_t>(dst_sel) << 20u) |
                  (static_cast<uint32_t>(src_sel) << 29u);
      packet[2] = static_cast<uint32_t>(src);
      packet[3] = static_cast<uint32_t>(src >> 32u);
      packet[4] = static_cast<uint32_t>(dst);
      packet[5] = static_cast<uint32_t>(dst >> 32u);
      packet[6] = bytes | command_flags;
    };
    constexpr uint64_t gds_immediate_offset = 0;
    constexpr uint64_t gds_memory_offset = 0x10;
    constexpr uint32_t immediate_value = 0xa1b2c3d4u;
    append_dma(1, gds_immediate_offset, 2, immediate_value,
               sizeof(source_words));
    append_dma(0, immediate_dst, 1, gds_immediate_offset, sizeof(source_words));
    append_dma(1, gds_memory_offset, 0, memory_src, sizeof(source_words));
    append_dma(0, memory_dst, 1, gds_memory_offset, sizeof(source_words));
    append_dma(0, immediate_memory_dst, 2, immediate_value,
               sizeof(source_words));
    append_dma(0, memory_copy_dst, 0, memory_src, sizeof(source_words));
    append_dma(3, l2_copy_dst, 3, memory_src, sizeof(source_words));
    append_dma(2, nowhere_dst, 3, nowhere_dst, sizeof(nowhere_words),
               1u << 31u);
    Require("GpuCommandLane", "DMA_DATA packet assembly",
            dma_cursor == dma_commands.size(),
            "DMA_DATA packet stream has the wrong size");
    gpu.Submit(dma_commands, {});
    gpu.Done();
    constexpr uint32_t clean_fill_value = 0xdecafbad;
    gpu.SendCommandSync([&] {
      auto &buffer_cache = resources.GetBufferCache();
      Require("GpuCommandLane", "clean cached setup",
              buffer_cache.IsRegionRegistered(clean_cached_fill,
                                              sizeof(source_words)) &&
                  !buffer_cache.HasGpuDirtyBytes(nowhere_dst,
                                                 sizeof(nowhere_words)) &&
                  buffer_cache.HasGpuDirtyBytes(immediate_dst,
                                                sizeof(source_words)),
              "DMA prefetch modified ownership or did not establish a dirty "
              "cached page");

      buffer_cache.FillBuffer(clean_cached_fill, sizeof(source_words),
                              clean_fill_value, false);
      buffer_cache.CopyBuffer(clean_cached_copy, clean_cached_source,
                              sizeof(clean_copy_words), false, false);
      Require("GpuCommandLane", "clean cached DMA ownership",
              !buffer_cache.HasGpuDirtyBytes(clean_cached_fill,
                                             sizeof(source_words)) &&
                  !buffer_cache.HasGpuDirtyBytes(clean_cached_copy,
                                                 sizeof(clean_copy_words)) &&
                  buffer_cache.HasGpuDirtyBytes(immediate_dst,
                                                sizeof(source_words)),
              "clean cached DMA acquired ownership or released a byte-disjoint "
              "dirty sibling");

      constexpr uint64_t gds_clean_mirror = 0x20;
      buffer_cache.CopyBuffer(gds_clean_mirror, clean_cached_fill,
                              2 * sizeof(source_words), true, false);
      buffer_cache.CopyBuffer(clean_cached_readback, gds_clean_mirror,
                              2 * sizeof(source_words), false, true);
    });
    Require("GpuCommandLane", "DMA_DATA immediate GDS readback",
            resources.HandleFault(PageFaultAccess::Read, immediate_dst),
            "immediate-to-GDS-to-memory copy did not publish GPU bytes");
    Require("GpuCommandLane", "DMA_DATA memory GDS readback",
            resources.HandleFault(PageFaultAccess::Read, memory_dst),
            "memory-to-GDS-to-memory copy did not publish GPU bytes");
    Require("GpuCommandLane", "DMA_DATA immediate memory readback",
            resources.HandleFault(PageFaultAccess::Read, immediate_memory_dst),
            "immediate-to-memory copy did not publish GPU bytes");
    Require("GpuCommandLane", "DMA_DATA memory copy readback",
            resources.HandleFault(PageFaultAccess::Read, memory_copy_dst),
            "memory-to-memory copy did not publish GPU bytes");
    Require("GpuCommandLane", "DMA_DATA L2 readback",
            resources.HandleFault(PageFaultAccess::Read, l2_copy_dst),
            "MemoryUsingL2 copy did not publish GPU bytes");
    Require("GpuCommandLane", "clean cached mirror readback",
            resources.HandleFault(PageFaultAccess::Read, clean_cached_readback),
            "clean host DMA was not reflected in the cached buffer");
    std::array<uint32_t, 2> immediate_words{};
    std::array<uint32_t, 2> copied_words{};
    std::array<uint32_t, 2> immediate_memory_words{};
    std::array<uint32_t, 2> memory_copy_words{};
    std::array<uint32_t, 2> l2_copy_words{};
    std::array<uint32_t, 4> clean_cached_words{};
    std::memcpy(immediate_words.data(),
                reinterpret_cast<const void *>(immediate_dst),
                sizeof(immediate_words));
    std::memcpy(copied_words.data(), reinterpret_cast<const void *>(memory_dst),
                sizeof(copied_words));
    std::memcpy(immediate_memory_words.data(),
                reinterpret_cast<const void *>(immediate_memory_dst),
                sizeof(immediate_memory_words));
    std::memcpy(memory_copy_words.data(),
                reinterpret_cast<const void *>(memory_copy_dst),
                sizeof(memory_copy_words));
    std::memcpy(l2_copy_words.data(),
                reinterpret_cast<const void *>(l2_copy_dst),
                sizeof(l2_copy_words));
    std::memcpy(clean_cached_words.data(),
                reinterpret_cast<const void *>(clean_cached_readback),
                sizeof(clean_cached_words));
    Require("GpuCommandLane", "DMA_DATA immediate GDS contents",
            immediate_words ==
                std::array<uint32_t, 2>{immediate_value, immediate_value},
            "immediate-to-GDS-to-memory bytes do not match");
    Require("GpuCommandLane", "DMA_DATA memory GDS contents",
            copied_words == source_words,
            "memory-to-GDS-to-memory bytes do not match");
    Require("GpuCommandLane", "DMA_DATA immediate memory contents",
            immediate_memory_words ==
                std::array<uint32_t, 2>{immediate_value, immediate_value},
            "immediate-to-memory bytes do not match");
    Require("GpuCommandLane", "DMA_DATA memory copy contents",
            memory_copy_words == source_words,
            "memory-to-memory bytes do not match");
    Require("GpuCommandLane", "DMA_DATA L2 contents",
            l2_copy_words == source_words, "MemoryUsingL2 bytes do not match");
    Require("GpuCommandLane", "DMA_DATA nowhere contents",
            std::memcmp(reinterpret_cast<const void *>(nowhere_dst),
                        nowhere_words.data(), sizeof(nowhere_words)) == 0,
            "Nowhere destination modified guest memory");
    Require("GpuCommandLane", "clean cached DMA contents",
            clean_cached_words == std::array<uint32_t, 4>{clean_fill_value,
                                                          clean_fill_value,
                                                          clean_copy_words[0],
                                                          clean_copy_words[1]},
            "host-memory fill/copy did not update the clean cached mirror");

    gpu.SendCommandSync([&] {
      Require("GpuCommandLane", "GPU memory invalidation",
              resources.InvalidateMemory(fault_base, sizeof(uint32_t)),
              "GPU memory invalidation did not find its mapped range");
    });

    auto &buffer_cache = resources.GetBufferCache();
    Require("GpuCommandLane", "clean tracked fault setup",
            buffer_cache.IsRegionRegistered(immediate_dst, sizeof(uint32_t)) &&
                !buffer_cache.HasGpuDirtyBytes(immediate_dst, sizeof(uint32_t)),
            "clean write-fault test address is not backed by a clean cached "
            "Buffer");
    constexpr uint64_t dirty_fault_address = fault_base + 0xd000;
    constexpr uint32_t dirty_fault_value = 0x5a17c0deu;
    constexpr uint32_t dirty_fault_stale = 0x0ddba11u;
    std::memcpy(reinterpret_cast<void *>(dirty_fault_address),
                &dirty_fault_stale, sizeof(dirty_fault_stale));
    gpu.SendCommandSync([&] {
      auto dirty = buffer_cache.ObtainBuffer(
          dirty_fault_address, sizeof(dirty_fault_value), true, false);
      Require("GpuCommandLane", "dirty tracked fault setup",
              dirty.first != nullptr,
              "dirty write-fault test could not create a cached Buffer");
      buffer_cache.FillBuffer(dirty_fault_address, sizeof(dirty_fault_value),
                              dirty_fault_value, false);
    });
    Require("GpuCommandLane", "dirty tracked fault ownership",
            buffer_cache.HasGpuDirtyBytes(dirty_fault_address,
                                          sizeof(dirty_fault_value)),
            "dirty write-fault test address did not acquire GPU ownership");

    std::binary_semaphore block_entered{0};
    std::binary_semaphore block_release{0};
    std::binary_semaphore clean_fault_complete{0};
    bool clean_fault_handled = false;
    gpu.SendCommand([&] {
      block_entered.release();
      block_release.acquire();
    });
    block_entered.acquire();
    std::jthread clean_fault_thread([&] {
      clean_fault_handled =
          resources.HandleFault(PageFaultAccess::Write, immediate_dst);
      clean_fault_complete.release();
    });
    const bool clean_fault_was_direct =
        clean_fault_complete.try_acquire_for(std::chrono::seconds(1));
    if (!clean_fault_was_direct) {
      block_release.release();
      clean_fault_complete.acquire();
    }
    clean_fault_thread.join();
    Require("GpuCommandLane", "clean fault direct path",
            clean_fault_was_direct && clean_fault_handled,
            "a clean CPU write fault waited for the blocked GPU command lane");

    std::binary_semaphore dirty_fault_complete{0};
    bool dirty_fault_handled = false;
    std::jthread dirty_fault_thread([&] {
      dirty_fault_handled =
          resources.HandleFault(PageFaultAccess::Write, dirty_fault_address);
      dirty_fault_complete.release();
    });
    const bool dirty_fault_bypassed_lane =
        dirty_fault_complete.try_acquire_for(std::chrono::milliseconds(200));
    block_release.release();
    if (!dirty_fault_bypassed_lane) {
      dirty_fault_complete.acquire();
    }
    dirty_fault_thread.join();
    uint32_t dirty_fault_backing = 0;
    std::memcpy(&dirty_fault_backing,
                reinterpret_cast<const void *>(dirty_fault_address),
                sizeof(dirty_fault_backing));
    Require("GpuCommandLane", "dirty fault synchronization",
            !dirty_fault_bypassed_lane && dirty_fault_handled &&
                dirty_fault_backing == dirty_fault_value &&
                !buffer_cache.HasGpuDirtyBytes(dirty_fault_address,
                                               sizeof(dirty_fault_value)),
            "a GPU-dirty write fault bypassed synchronization or lost the "
            "published bytes");

    constexpr uint64_t empty_copy_fault_address = fault_base + 0xe000;
    constexpr uint32_t empty_copy_fault_value = 0x6b28d1efu;
    gpu.SendCommandSync([&] {
      auto dirty = buffer_cache.ObtainBuffer(empty_copy_fault_address,
                                             sizeof(empty_copy_fault_value),
                                             true, false);
      Require("GpuCommandLane", "empty-copy write setup",
              dirty.first != nullptr,
              "empty-copy write test could not create a cached Buffer");
      buffer_cache.FillBuffer(empty_copy_fault_address,
                              sizeof(empty_copy_fault_value),
                              empty_copy_fault_value, false);
      buffer_cache.ReadMemory(empty_copy_fault_address,
                              sizeof(empty_copy_fault_value));
      const bool gpu_owned = buffer_cache.IsRegionGpuModified(
          empty_copy_fault_address, sizeof(empty_copy_fault_value));
      const bool cpu_owned = buffer_cache.IsRegionCpuModified(
          empty_copy_fault_address, sizeof(empty_copy_fault_value));
      Require("GpuCommandLane", "empty-copy read ownership",
              !gpu_owned && !cpu_owned,
              "readback did not leave clean ownership for the queued write "
              "invalidation");
      buffer_cache.ReadMemory(empty_copy_fault_address,
                              sizeof(empty_copy_fault_value), true);
    });
    uint32_t empty_copy_fault_backing = 0;
    std::memcpy(&empty_copy_fault_backing,
                reinterpret_cast<const void *>(empty_copy_fault_address),
                sizeof(empty_copy_fault_backing));
    const bool empty_copy_cpu_owned = buffer_cache.IsRegionCpuModified(
        empty_copy_fault_address, sizeof(empty_copy_fault_value));
    const bool empty_copy_gpu_owned = buffer_cache.IsRegionGpuModified(
        empty_copy_fault_address, sizeof(empty_copy_fault_value));
    const bool empty_copy_dirty = buffer_cache.HasGpuDirtyBytes(
        empty_copy_fault_address, sizeof(empty_copy_fault_value));
    Require("GpuCommandLane", "empty-copy write ownership",
            empty_copy_fault_backing == empty_copy_fault_value &&
                empty_copy_cpu_owned && !empty_copy_gpu_owned &&
                !empty_copy_dirty,
            "write invalidation without a remaining copy did not establish CPU "
            "ownership");

    resources.UnmapMemory(fault_base, fault_size);
    Require("GpuCommandLane", "processor fault unmap",
            Libs::LibKernel::Memory::KernelMunmap(fault_base, fault_size) == 0,
            "processor-fault direct-memory mapping release failed");
    Require("GpuCommandLane", "processor fault free",
            Libs::LibKernel::Memory::KernelReleaseDirectMemory(
                fault_direct_offset, fault_size) == 0,
            "processor-fault direct-memory allocation release failed");

    std::binary_semaphore command_entered{0};
    std::binary_semaphore release_command{0};
    std::atomic<bool> shutdown_complete{false};
    std::atomic<bool> submission_lane_entered{false};
    bool shutdown_owner_visible = false;
    resources.MapMemory(empty_unmap_base, empty_unmap_size);
    gpu.SendCommand([&] {
      command_entered.release();
      release_command.acquire();
      shutdown_owner_visible = &context.GetGpu() == &gpu;
      gpu.Done();
      submission_lane_entered = true;
    });
    command_entered.acquire();
    std::jthread shutdown_thread([&] {
      context.ShutdownGpu();
      shutdown_complete = true;
    });
    while (!gpu.IsStopping()) {
      std::this_thread::yield();
    }
    Require("GpuCommandLane", "owned shutdown", !shutdown_complete.load(),
            "GPU owner returned before an in-flight command completed");
    release_command.release();
    shutdown_thread.join();
    Require(
        "GpuCommandLane", "owned shutdown completion",
        shutdown_complete.load() && submission_lane_entered.load() &&
            shutdown_owner_visible,
        "GPU owner did not remain available while draining queued work");
    resources.UnmapMemory(empty_unmap_base, empty_unmap_size);
    Require("GpuCommandLane", "unmap after shutdown",
            !resources.IsMapped(empty_unmap_base, empty_unmap_size),
            "renderer retained mapped coverage after the GPU command lane stopped");
    context.ShutdownGpu();
    std::printf("[host]    %-32s ok\n", "GpuCommandLane");
  }

  void CheckUnifiedImageViewCache() {
    EnsureRuntimeContext();
    constexpr const char *name = "UnifiedImageViewCache";
    CommandScheduler scheduler(Renderer(), m_runtime_context);

    ImageInfo color_info{};
    color_info.pixel_format = vk::Format::eR8G8B8A8Unorm;
    color_info.guest_format = Prospero::BufferFormat::k8_8_8_8UNorm;
    color_info.type = Prospero::ImageType::kColor2D;
    color_info.extent = {8, 8, 1};
    color_info.resources = {2, 2};
    color_info.pitch = 8;
    color_info.bytes_per_block = 4;
    color_info.samples = 1;
    color_info.tile_mode = Prospero::TileMode::kLinear;
    color_info.mip_layout[0] = {0, 512, 8, 8};
    color_info.mip_layout[1] = {512, 128, 4, 4};

    Libs::Graphics::Image color(m_runtime_context, scheduler, color_info);
    const vk::ComponentMapping identity{};
    const vk::ComponentMapping bgra{
        vk::ComponentSwizzle::eB, vk::ComponentSwizzle::eG,
        vk::ComponentSwizzle::eR, vk::ComponentSwizzle::eA};

    ImageViewInfo sampled{};
    sampled.format = color_info.pixel_format;
    sampled.type = vk::ImageViewType::e2D;
    sampled.aspect = vk::ImageAspectFlagBits::eColor;
    sampled.base_level = 0;
    sampled.level_count = 1;
    sampled.base_layer = 0;
    sampled.layer_count = 1;
    sampled.mapping = identity;
    sampled.usage = vk::ImageUsageFlagBits::eSampled;

    const auto first = color.FindView(sampled);
    const auto first_again = color.FindView(sampled);
    auto swizzled_info = sampled;
    swizzled_info.mapping = bgra;
    const auto swizzled = color.FindView(swizzled_info);
    auto mip_info = sampled;
    mip_info.base_level = 1;
    const auto mip = color.FindView(mip_info);
    auto layer_info = sampled;
    layer_info.base_layer = 1;
    const auto layer = color.FindView(layer_info);
    auto array_info = sampled;
    array_info.type = vk::ImageViewType::e2DArray;
    array_info.layer_count = 2;
    const auto array = color.FindView(array_info);
    auto reinterpreted_info = sampled;
    reinterpreted_info.format = vk::Format::eR8G8B8A8Uint;
    const auto reinterpreted = color.FindView(reinterpreted_info);
    auto storage_info = sampled;
    storage_info.usage = vk::ImageUsageFlagBits::eStorage;
    const auto storage = color.FindView(storage_info);
    auto attachment_info = sampled;
    attachment_info.usage = vk::ImageUsageFlagBits::eColorAttachment;
    const auto attachment = color.FindView(attachment_info);

    Require(name, "color views",
            first != nullptr && first_again == first && swizzled != nullptr &&
                swizzled != first && mip != nullptr && mip != first &&
                layer != nullptr && layer != first && array != nullptr &&
                array != first && reinterpreted != nullptr &&
                reinterpreted != first && storage != nullptr &&
                storage != first && attachment == first &&
                color.views.size() == 7,
            "dynamic view identity omitted mapping, format, mip, layer, type, "
            "or storage usage");

    auto video_out_info = color_info;
    video_out_info.pixel_format = vk::Format::eA2R10G10B10UnormPack32;
    video_out_info.guest_format = Prospero::BufferFormat::k10_10_10_2UNorm;
    Libs::Graphics::Image video_out(m_runtime_context, scheduler,
                                    video_out_info);
    auto video_out_view_info = sampled;
    video_out_view_info.format = video_out_info.pixel_format;
    video_out_view_info.usage = vk::ImageUsageFlagBits::eTransferSrc;
    const auto video_out_view = video_out.FindView(video_out_view_info);
    auto storage_alias_info = video_out_view_info;
    storage_alias_info.format = vk::Format::eA2B10G10R10UnormPack32;
    storage_alias_info.usage = vk::ImageUsageFlagBits::eStorage;
    const auto storage_alias_view = video_out.FindView(storage_alias_info);
    Require(
        name, "video-out storage alias usage",
        ImageViewOps::FormatsCompatible(video_out_info.pixel_format,
                                        storage_alias_info.format) &&
            static_cast<bool>(video_out.backing.usage &
                              vk::ImageUsageFlagBits::eStorage) &&
            video_out_view != nullptr && storage_alias_view != nullptr,
        "compatible video-out backing was created without storage usage");

    ImageInfo depth_info{};
    depth_info.pixel_format = vk::Format::eD32Sfloat;
    depth_info.guest_format = Prospero::BufferFormat::k32Float;
    depth_info.type = Prospero::ImageType::kColor2D;
    depth_info.extent = {8, 8, 1};
    depth_info.resources = {1, 2};
    depth_info.pitch = 8;
    depth_info.bytes_per_block = 4;
    depth_info.samples = 1;
    depth_info.tile_mode = Prospero::TileMode::kDepth;
    depth_info.mip_layout[0] = {0, 512, 8, 8};

    Libs::Graphics::Image depth(m_runtime_context, scheduler, depth_info);
    ImageViewInfo depth_sampled{};
    depth_sampled.format = depth_info.pixel_format;
    depth_sampled.type = vk::ImageViewType::e2D;
    depth_sampled.aspect = vk::ImageAspectFlagBits::eDepth;
    depth_sampled.base_level = 0;
    depth_sampled.level_count = 1;
    depth_sampled.base_layer = 0;
    depth_sampled.layer_count = 1;
    depth_sampled.mapping = {vk::ComponentSwizzle::eR, vk::ComponentSwizzle::eR,
                             vk::ComponentSwizzle::eR,
                             vk::ComponentSwizzle::eR};
    depth_sampled.usage = vk::ImageUsageFlagBits::eSampled;
    const auto depth_first = depth.FindView(depth_sampled);
    auto depth_alias_info = depth_sampled;
    depth_alias_info.format = vk::Format::eR32Uint;
    const auto depth_alias = depth.FindView(depth_alias_info);
    const auto depth_again = depth.FindView(depth_sampled);
    auto depth_array_info = depth_sampled;
    depth_array_info.type = vk::ImageViewType::e2DArray;
    depth_array_info.layer_count = 2;
    const auto depth_array = depth.FindView(depth_array_info);
    auto depth_attachment_info = depth_array_info;
    depth_attachment_info.mapping = {};
    depth_attachment_info.usage =
        vk::ImageUsageFlagBits::eDepthStencilAttachment;
    const auto depth_attachment = depth.FindView(depth_attachment_info);
    Require(name, "depth views",
            depth_first != nullptr && depth_again == depth_first &&
                depth_alias == depth_first && depth_array != nullptr &&
                depth_array != depth_first && depth_attachment != nullptr &&
                depth_attachment != depth_array &&
                depth.views.size() == 3,
            "unified depth view cache lost sampled/attachment identity");

    auto depth_stencil_info = depth_info;
    depth_stencil_info.pixel_format = vk::Format::eD24UnormS8Uint;
    depth_stencil_info.guest_format = Prospero::BufferFormat::k16UNorm;
    depth_stencil_info.bytes_per_block = 2;
    Libs::Graphics::Image depth_stencil(m_runtime_context, scheduler,
                                        depth_stencil_info);
    auto depth_only_info = depth_sampled;
    depth_only_info.format = depth_stencil_info.pixel_format;
    const auto depth_only = depth_stencil.FindView(depth_only_info);
    auto combined_info = depth_only_info;
    combined_info.aspect =
        vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil;
    combined_info.mapping = {};
    combined_info.usage = vk::ImageUsageFlagBits::eDepthStencilAttachment;
    const auto combined = depth_stencil.FindView(combined_info);
    Require(name, "depth/stencil aspects",
            depth_only != nullptr && combined != nullptr &&
                depth_only != combined &&
                depth_stencil.views.size() == 2 &&
                depth_stencil.views[0].info.aspect ==
                    vk::ImageAspectFlagBits::eDepth &&
                depth_stencil.views[1].info.aspect ==
                    (vk::ImageAspectFlagBits::eDepth |
                     vk::ImageAspectFlagBits::eStencil),
            "explicit depth-only and combined aspects shared one image view");
    Require(name, "role-free backing",
            color.backing.image_type == vk::ImageType::e2D &&
                color.backing.layers == 2 &&
                depth.backing.image_type == vk::ImageType::e2D &&
                ImageViewOps::FormatsCompatible(vk::Format::eR8G8B8A8Unorm,
                                                vk::Format::eR8G8B8A8Uint) &&
                !ImageViewOps::FormatsCompatible(vk::Format::eD32Sfloat,
                                                 vk::Format::eR32Sfloat),
            "role-free image backing or host format compatibility diverged");

    auto line_info = color_info;
    line_info.type = Prospero::ImageType::kColor1D;
    line_info.extent = {8, 1, 1};
    line_info.resources = {2, 2};
    line_info.mip_layout[0] = {0, 64, 8, 1};
    line_info.mip_layout[1] = {64, 16, 4, 1};
    Libs::Graphics::Image line(m_runtime_context, scheduler, line_info);
    auto line_view_info = sampled;
    line_view_info.type = vk::ImageViewType::e1D;
    const auto line_view = line.FindView(line_view_info);
    auto line_array_info = line_view_info;
    line_array_info.type = vk::ImageViewType::e1DArray;
    line_array_info.layer_count = 2;
    const auto line_array = line.FindView(line_array_info);
    Require(name, "1D views",
            line_view != nullptr && line_array != nullptr &&
                line_array != line_view &&
                line.backing.image_type == vk::ImageType::e1D &&
                line.backing.layers == 2,
            "1D and 1D-array views did not use a first-class 1D backing");

    auto volume_info = color_info;
    volume_info.type = Prospero::ImageType::kColor3D;
    volume_info.extent = {8, 8, 4};
    volume_info.resources = {2, 1};
    Libs::Graphics::Image volume(m_runtime_context, scheduler, volume_info);
    auto slice_info = sampled;
    slice_info.type = vk::ImageViewType::e2D;
    slice_info.base_level = 1;
    slice_info.base_layer = 1;
    const auto slice = volume.FindView(slice_info);
    auto slice_array_info = slice_info;
    slice_array_info.type = vk::ImageViewType::e2DArray;
    slice_array_info.base_layer = 0;
    slice_array_info.layer_count = 2;
    const auto slice_array = volume.FindView(slice_array_info);
    Require(name, "3D slice views",
            slice != nullptr && slice_array != nullptr &&
                slice_array != slice &&
                static_cast<bool>(volume.backing.flags &
                                  vk::ImageCreateFlagBits::e2DArrayCompatible),
            "2D slice views of a compatible 3D backing were rejected");
    std::printf("[host]    %-32s ok\n", name);
  }

  void CheckBufferCacheDirtyGarbageCollection() {
    constexpr const char *name = "BufferCacheDirtyGarbageCollection";
    constexpr uintptr_t base = 0x0000000200700000ull;
    constexpr uint64_t allocation_size = 0x2400000;
    constexpr uint64_t allocation_alignment = 0x10000;
    constexpr uint64_t first_offset = 0x100;
    constexpr uint64_t second_offset = 0x200;
    constexpr uint64_t clean_offset = 0x300;
    constexpr uint64_t unmap_offset = 0x4100;
    constexpr uint64_t partial_unmap_offset = 0x8100;
    constexpr uint64_t partial_unmap_survivor_offset = 0xc100;
    constexpr uint64_t ring_fault_first_offset = 0x2100;
    constexpr uint64_t ring_fault_second_offset = 0x2110;
    constexpr uint32_t first_value = 0x10203040u;
    constexpr uint32_t second_value = 0x50607080u;
    constexpr uint32_t first_stale = 0x0badf00du;
    constexpr uint32_t second_stale = 0xdeadbeefu;
    constexpr uint32_t clean_value = 0xaabbccddu;
    constexpr uint32_t unmap_value = 0x91a2b3c4u;
    constexpr uint32_t remap_value = 0xd5e6f708u;
    constexpr uint32_t partial_unmap_value = 0x62738495u;
    constexpr uint32_t partial_unmap_survivor_value = 0xa6b7c8d9u;
    constexpr uint32_t ring_fault_first_value = 0x0a1b2c3du;
    constexpr uint32_t ring_fault_second_value = 0x4e5f6071u;

    EnsureRuntimeContext();
    RenderContext context(m_runtime_context);
    auto &scheduler = context.GetCommandScheduler();
    HW::Context registers{};
    HW::UserConfig user_config{};
    HW::Shader shaders{};
    scheduler.Begin(registers, user_config, shaders);
    context.InitializeGpu(nullptr);

    int64_t direct_offset = -1;
    Require(name, "direct allocation",
            Libs::LibKernel::Memory::KernelAllocateDirectMemory(
                0, Libs::LibKernel::Memory::KernelGetDirectMemorySize(),
                allocation_size, allocation_alignment, 0, &direct_offset) == 0,
            "dirty-GC direct-memory allocation failed");
    void *mapped = reinterpret_cast<void *>(base);
    Require(name, "direct mapping",
            Libs::LibKernel::Memory::KernelMapDirectMemory(
                &mapped, allocation_size, 0x3, 0x10, direct_offset,
                allocation_alignment) == 0 &&
                mapped == reinterpret_cast<void *>(base),
            "dirty-GC fixed direct-memory mapping failed");
    auto *memory = static_cast<uint8_t *>(mapped);
    std::memcpy(memory + first_offset, &first_stale, sizeof(first_stale));
    std::memcpy(memory + second_offset, &second_stale, sizeof(second_stale));
    std::memcpy(memory + clean_offset, &clean_value, sizeof(clean_value));

    {
      auto &resources = context;
      auto &cache = resources.GetBufferCache();
      resources.MapMemory(base, allocation_size);

      const auto MarkGpuWrite = [&](uint64_t address, uint64_t size) {
        auto allocation = cache.ObtainBuffer(address, size, true, false);
        Require(name, "dirty allocation", allocation.first != nullptr,
                "dirty-GC buffer allocation failed");
      };
      const auto ReadNativeValue =
          [&](const Libs::Graphics::Buffer &buffer, uint64_t offset) {
        auto readback =
            CreateHostBuffer(name, sizeof(uint32_t),
                             vk::BufferUsageFlagBits::eTransferDst, {0});
        const vk::BufferCopy copy{offset, 0, sizeof(uint32_t)};
        scheduler.Current().Handle().copyBuffer(buffer.Handle(), readback.buffer,
                                                1, &copy);
        vk::BufferMemoryBarrier barrier{};
        barrier.sType = vk::StructureType::eBufferMemoryBarrier;
        barrier.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
        barrier.dstAccessMask = vk::AccessFlagBits::eHostRead;
        barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.buffer = readback.buffer;
        barrier.size = readback.size;
        scheduler.Current().Handle().pipelineBarrier(
            vk::PipelineStageFlagBits::eTransfer,
            vk::PipelineStageFlagBits::eHost, {}, 0, nullptr, 1, &barrier, 0,
            nullptr);
        scheduler.Finish();
        const auto value = ReadBuffer(name, readback, 1)[0];
        DestroyBuffer(&readback);
        return value;
      };

      constexpr uint64_t large_copy_source_offset = 0x40000;
      constexpr uint64_t large_copy_destination_offset = 0x80000;
      constexpr uint64_t large_copy_size = 96 * 1024;
      std::vector<uint8_t> large_copy_source(large_copy_size);
      for (uint64_t index = 0; index < large_copy_size; ++index) {
        large_copy_source[index] =
            static_cast<uint8_t>((index * 37 + index / 251) & 0xffu);
      }
      std::memcpy(memory + large_copy_source_offset, large_copy_source.data(),
                  large_copy_size);
      std::memset(memory + large_copy_destination_offset, 0, large_copy_size);
      cache.CopyBuffer(base + large_copy_destination_offset,
                       base + large_copy_source_offset, large_copy_size, false,
                       false);
      Require(name, "large host copy",
              std::memcmp(memory + large_copy_destination_offset,
                          large_copy_source.data(), large_copy_size) == 0,
              "chunked host copy lost bytes across its scratch boundary");

      constexpr uint64_t index_offset = 0x180000;
      constexpr uint64_t index_page = BufferCache::CACHING_PAGESIZE;
      constexpr uint64_t index_span = 3 * index_page;
      const uint64_t index_begin = base + index_offset;
      Require(name, "registered-range empty lookup",
              !cache.IsRegionRegistered(index_begin, index_span) &&
                  !BufferCacheTestAccess::PageOwner(cache, index_begin),
              "empty Buffer cache reported a registered range");
      const auto index_left =
          cache.FindBuffer(index_begin + 0x100, sizeof(uint32_t));
      const auto index_right = cache.FindBuffer(
          index_begin + 2 * index_page + 0x100, sizeof(uint32_t));
      Require(name, "registered-range owners",
              index_left && index_right &&
                  cache.FindBuffer(index_begin + 0x200, sizeof(uint32_t)) ==
                      index_left &&
                  BufferCacheTestAccess::PageOwner(cache, index_begin) ==
                      index_left &&
                  !BufferCacheTestAccess::PageOwner(cache,
                                                    index_begin + index_page) &&
                  BufferCacheTestAccess::PageOwner(
                      cache, index_begin + 2 * index_page) == index_right,
              "failed to create disjoint Buffer index owners");
      Require(
          name, "registered-range boundaries",
          cache.IsRegionRegistered(index_begin, 1) &&
              cache.IsRegionRegistered(index_begin + index_page - 1, 1) &&
              !cache.IsRegionRegistered(index_begin - 1, 1) &&
              !cache.IsRegionRegistered(index_begin + index_page, index_page) &&
              cache.IsRegionRegistered(index_begin + index_page,
                                       index_page + 1) &&
              !cache.IsRegionRegistered(index_begin + index_span, 1) &&
              cache.IsRegionRegistered(index_begin - 1, index_span + 2),
          "indexed lookup mishandled a half-open boundary, gap, or broad "
          "overlap");
      const auto index_bridge =
          cache.FindBuffer(index_begin + index_page - 1, index_page + 2);
      Require(name, "registered-range merge",
              index_bridge && cache.IsRegionRegistered(index_begin + index_page,
                                                       index_page) &&
                  BufferCacheTestAccess::PageOwner(cache, index_begin) ==
                      index_bridge &&
                  BufferCacheTestAccess::PageOwner(
                      cache, index_begin + index_page) == index_bridge &&
                  BufferCacheTestAccess::PageOwner(
                      cache, index_begin + 2 * index_page) == index_bridge,
              "bridging acquisition did not publish its merged Buffer range");
      scheduler.Finish();
      constexpr uint64_t recycled_offset = index_offset + 4 * index_page;
      const auto recycled = cache.FindBuffer(base + recycled_offset + 0x100,
                                             sizeof(uint32_t));
      Require(name, "slot generation reuse",
              (recycled.index == index_left.index && recycled != index_left) ||
                  (recycled.index == index_right.index &&
                   recycled != index_right),
              "retired Buffer slot was not reused with a new generation");
      const auto [resolved_left, resolved_left_offset] = cache.ObtainBuffer(
          index_begin + 0x100, sizeof(uint32_t), true, false, index_left);
      const auto [resolved_right, resolved_right_offset] =
          cache.ObtainBuffer(index_begin + 2 * index_page + 0x100,
                             sizeof(uint32_t), true, false, index_right);
      Require(name, "two-pass stale id resolution",
              resolved_left == &cache.GetBuffer(index_bridge) &&
                  resolved_right == resolved_left &&
                  resolved_left_offset != resolved_right_offset,
              "saved descriptor IDs did not resolve through the merged owner");

      constexpr uint64_t stream_page = BufferCache::CACHING_PAGESIZE;
      constexpr uint64_t stream_leap = stream_page * 128;
      for (const bool forward : {true, false}) {
        const char *stream_name =
            forward ? "ForwardBufferStream" : "BackwardBufferStream";
        const uint64_t stream_begin = base + (forward ? 0x1800000 : 0x2000000);
        const uint64_t caught_address = forward
                                            ? stream_begin + stream_leap / 2
                                            : stream_begin - stream_leap / 2;
        const uint64_t untouched_address = forward
                                               ? stream_begin - stream_leap / 2
                                               : stream_begin + stream_leap / 2;
        const auto caught = cache.FindBuffer(caught_address, stream_page);
        const auto untouched = cache.FindBuffer(untouched_address, stream_page);
        auto grown = cache.FindBuffer(stream_begin, stream_page * 2);
        constexpr uint32_t stream_value = 0x6a3b92d1u;
        for (const auto address : {stream_begin, caught_address}) {
          MarkGpuWrite(address, sizeof(stream_value));
          cache.FillBuffer(address, sizeof(stream_value), stream_value, false);
        }

        uint64_t requested_begin = stream_begin;
        uint64_t requested_end = stream_begin + stream_page * 2;
        for (uint32_t step = 1; step <= 18; ++step) {
          const auto address = (forward ? requested_end : requested_begin) - 4;
          grown = cache.FindBuffer(address, 8);
          if (forward) {
            requested_end += stream_page;
          } else {
            requested_begin -= stream_page;
          }
          if (step < 18) {
            const auto &owner = cache.GetBuffer(grown);
            Require(stream_name, "growth before threshold",
                    owner.CpuAddress() == requested_begin &&
                        owner.Size() == requested_end - requested_begin &&
                        owner.StreamScore() == static_cast<int>(step),
                    "sequential requests grew beyond their consumed pages too "
                    "early");
          }
        }
        const auto &grown_buffer = cache.GetBuffer(grown);
        Require(stream_name, "growth reserve",
                grown_buffer.CpuAddress() ==
                        (forward ? requested_begin
                                 : requested_begin - stream_leap) &&
                    grown_buffer.Size() ==
                        requested_end - requested_begin + stream_leap &&
                    grown_buffer.StreamScore() == 0 &&
                    cache.GetBuffer(caught).is_deleted &&
                    !cache.GetBuffer(untouched).is_deleted &&
                    BufferCacheTestAccess::PageOwner(cache, caught_address) ==
                        grown &&
                    BufferCacheTestAccess::PageOwner(
                        cache, untouched_address) == untouched,
                "streaming did not reserve the next pages or retain correct "
                "neighboring owners");
        for (uint32_t step = 0; step < 128; ++step) {
          const auto address = forward
                                   ? requested_end + step * stream_page - 4
                                   : requested_begin - step * stream_page - 4;
          Require(stream_name, "reuse reserved pages",
                  cache.FindBuffer(address, 8) == grown,
                  "continued sequential requests replaced the buffer within "
                  "its growth reserve");
        }
        for (const auto address : {stream_begin, caught_address}) {
          Require(
              stream_name, "preserve GPU contents",
              ReadNativeValue(grown_buffer, grown_buffer.Offset(address)) ==
                  stream_value,
              "stream growth lost GPU-written contents from a merged owner");
        }
      }

      resources.UnmapMemory(index_begin, index_span);
      resources.UnmapMemory(base + recycled_offset, index_page);
      Require(name, "invalidation retains owners",
              !resources.IsMapped(index_begin, index_span) &&
                  !resources.IsMapped(base + recycled_offset, index_page) &&
                  cache.IsRegionRegistered(index_begin, index_span) &&
                  BufferCacheTestAccess::PageOwner(cache, index_begin) ==
                      index_bridge &&
                  BufferCacheTestAccess::PageOwner(
                      cache, index_begin + index_page) == index_bridge &&
                  BufferCacheTestAccess::PageOwner(
                      cache, index_begin + 2 * index_page) == index_bridge &&
                  BufferCacheTestAccess::PageOwner(
                      cache, base + recycled_offset) == recycled &&
                  cache.IsRegionCpuModified(index_begin, index_span) &&
                  cache.IsRegionCpuModified(base + recycled_offset,
                                            index_page),
              "CPU invalidation retired a reusable Buffer owner");
      resources.MapMemory(index_begin, index_span);
      resources.MapMemory(base + recycled_offset, index_page);

      MarkGpuWrite(base + first_offset, sizeof(first_value));
      MarkGpuWrite(base + second_offset, sizeof(second_value));
      cache.FillBuffer(base + first_offset, sizeof(first_value), first_value,
                       false);
      cache.FillBuffer(base + second_offset, sizeof(second_value), second_value,
                       false);
      auto &download = BufferCacheTestAccess::DownloadBuffer(cache);
      auto *fixed_download = &download;
      const auto fixed_download_handle = download.Handle();
      auto [ring_tail, ring_tail_offset] =
          download.Map(download.Size() - sizeof(uint32_t), 4);
      Require(name, "fault-ring tail reservation",
              ring_tail != nullptr && ring_tail_offset == 0,
              "failed to position the reusable download ring near wrap");
      download.Commit();
      MarkGpuWrite(base + ring_fault_first_offset,
                   sizeof(ring_fault_first_value));
      MarkGpuWrite(base + ring_fault_second_offset,
                   sizeof(ring_fault_second_value));
      cache.FillBuffer(base + ring_fault_first_offset,
                       sizeof(ring_fault_first_value), ring_fault_first_value,
                       false);
      cache.FillBuffer(base + ring_fault_second_offset,
                       sizeof(ring_fault_second_value), ring_fault_second_value,
                       false);
      Require(name, "fault-ring wrapped batch",
              resources.HandleFault(PageFaultAccess::Read,
                                    base + ring_fault_first_offset),
              "fault readback could not wrap a live download-ring tick");
      // The widened window collects the two earlier writes and both
      // fault-adjacent writes.
      uint64_t expected_packing_offset = 4 * 64;
      uint64_t expected_packing_alignment = 1;
      if (!download.IsCoherent()) {
        Require(name, "fault-ring atom policy",
                StreamBufferTestAccess::NormalizeReservation(
                    false,
                    m_runtime_context.physical_device_properties.limits
                        .nonCoherentAtomSize,
                    expected_packing_offset, expected_packing_alignment),
                "failed to calculate non-coherent fault-ring stride");
      }
      auto [packing_probe, packing_offset] = download.Map(1, 1, false);
      Require(name, "adjacent download reservation stride",
              packing_probe != nullptr &&
                  packing_offset == expected_packing_offset,
              "adjacent fault downloads did not reserve an atom-safe stride");
      download.Commit();
      uint32_t widened_first_backing = 0;
      uint32_t widened_second_backing = 0;
      uint32_t ring_fault_first_backing = 0;
      uint32_t ring_fault_second_backing = 0;
      std::memcpy(&widened_first_backing, memory + first_offset,
                  sizeof(widened_first_backing));
      std::memcpy(&widened_second_backing, memory + second_offset,
                  sizeof(widened_second_backing));
      std::memcpy(&ring_fault_first_backing, memory + ring_fault_first_offset,
                  sizeof(ring_fault_first_backing));
      std::memcpy(&ring_fault_second_backing, memory + ring_fault_second_offset,
                  sizeof(ring_fault_second_backing));
      Require(name, "fault-ring wrapped contents",
              widened_first_backing == first_value &&
                  widened_second_backing == second_value &&
                  ring_fault_first_backing == ring_fault_first_value &&
                  ring_fault_second_backing == ring_fault_second_value &&
                  &BufferCacheTestAccess::DownloadBuffer(cache) ==
                      fixed_download &&
                  download.Handle() == fixed_download_handle &&
                  download.Size() == (32ull << 20),
              "wrapped fault batch published incorrect disjoint ranges");

      constexpr uint64_t window_size = 512 * 1024;
      constexpr uint64_t window_owner_offset = 0x240000;
      constexpr uint64_t window_owner_size = 0xc0000;
      constexpr uint64_t window_fault_offset = window_owner_offset + 0x100;
      constexpr uint64_t window_inside_offset =
          window_owner_offset + window_size - sizeof(uint32_t);
      constexpr uint64_t window_outside_offset =
          window_owner_offset + window_size;
      constexpr uint32_t window_stale = 0x13579bdfu;
      constexpr uint32_t window_value = 0x2468ace0u;
      constexpr std::array window_offsets{
          window_fault_offset, window_inside_offset, window_outside_offset};
      static_assert((base + window_owner_offset) % window_size ==
                    window_size / 2);
      for (const auto offset : window_offsets) {
        Libs::LibKernel::Memory::WriteBacking(base + offset, &window_stale,
                                              sizeof(window_stale));
      }
      (void)cache.FindBuffer(base + window_owner_offset, window_owner_size);
      for (const auto offset : window_offsets) {
        MarkGpuWrite(base + offset, sizeof(window_value));
        cache.FillBuffer(base + offset, sizeof(window_value), window_value,
                         false);
      }
      cache.ReadMemory(base + window_fault_offset, sizeof(window_value));
      uint32_t window_inside_backing = 0;
      uint32_t window_outside_backing = 0;
      Libs::LibKernel::Memory::TryReadBacking(base + window_inside_offset,
                                              &window_inside_backing,
                                              sizeof(window_inside_backing));
      Libs::LibKernel::Memory::TryReadBacking(base + window_outside_offset,
                                              &window_outside_backing,
                                              sizeof(window_outside_backing));
      Require(name, "widened-window boundary",
              window_inside_backing == window_value &&
                  window_outside_backing == window_stale &&
                  !cache.HasGpuDirtyBytes(base + window_inside_offset,
                                          sizeof(window_value)) &&
                  cache.HasGpuDirtyBytes(base + window_outside_offset,
                                         sizeof(window_value)) &&
                  !cache.IsRegionGpuModified(base + window_inside_offset,
                                             sizeof(window_value)) &&
                  cache.IsRegionGpuModified(base + window_outside_offset,
                                            sizeof(window_value)),
              "readback did not honor the clamped half-open 512 KiB window");
      cache.ReadMemory(base + window_outside_offset, sizeof(window_value));

      Libs::LibKernel::Memory::WriteBacking(base + first_offset, &first_stale,
                                            sizeof(first_stale));
      Libs::LibKernel::Memory::WriteBacking(base + second_offset, &second_stale,
                                            sizeof(second_stale));
      MarkGpuWrite(base + first_offset, sizeof(first_value));
      MarkGpuWrite(base + second_offset, sizeof(second_value));
      cache.FillBuffer(base + first_offset, sizeof(first_value), first_value,
                       false);
      cache.FillBuffer(base + second_offset, sizeof(second_value), second_value,
                       false);

      for (uint32_t tick = 0; tick < 160; tick++) {
        cache.RunGarbageCollector();
      }
      Require(name, "age before pressure",
              cache.IsRegionRegistered(base, allocation_size),
              "buffer was reclaimed without memory pressure");
      BufferCacheTestAccess::SetGarbageCollectionThresholds(
          cache, 0, std::numeric_limits<uint64_t>::max());
      const auto gc_submission_tick = scheduler.CurrentTick();
      cache.RunGarbageCollector();
      uint32_t first_before_completion = 0;
      uint32_t second_before_completion = 0;
      Libs::LibKernel::Memory::TryReadBacking(base + first_offset,
                                              &first_before_completion,
                                              sizeof(first_before_completion));
      Libs::LibKernel::Memory::TryReadBacking(base + second_offset,
                                              &second_before_completion,
                                              sizeof(second_before_completion));
      Require(name, "normal dirty retention",
              first_before_completion == first_stale &&
                  second_before_completion == second_stale &&
                  cache.IsRegionRegistered(base, allocation_size) &&
                  cache.IsRegionGpuModified(base + first_offset,
                                            sizeof(first_value)) &&
                  cache.IsRegionGpuModified(base + second_offset,
                                            sizeof(second_value)) &&
                  cache.HasGpuDirtyBytes(base + first_offset,
                                         sizeof(first_value)) &&
                  cache.HasGpuDirtyBytes(base + second_offset,
                                         sizeof(second_value)) &&
                  scheduler.CurrentTick() == gc_submission_tick,
              "normal GC retired or synchronized a dirty Buffer");
      BufferCacheTestAccess::SetGarbageCollectionThresholds(cache, 0, 0);
      const auto older_publication_tick = scheduler.CurrentTick();
      std::binary_semaphore older_publication_entered{0};
      std::binary_semaphore release_older_publication{0};
      std::atomic<bool> gc_returned{false};
      scheduler.DeferPriorityOperation([&] {
        older_publication_entered.release();
        release_older_publication.acquire();
        Libs::LibKernel::Memory::WriteBacking(
            base + first_offset, &first_stale, sizeof(first_stale));
      });
      std::jthread release_publication([&] {
        older_publication_entered.acquire();
        const auto deadline = std::chrono::steady_clock::now() +
                              std::chrono::milliseconds(100);
        while (!gc_returned.load() &&
               std::chrono::steady_clock::now() < deadline) {
          std::this_thread::yield();
        }
        release_older_publication.release();
      });
      cache.RunGarbageCollector();
      gc_returned = true;
      release_publication.join();
      scheduler.WaitPriorityOperations(older_publication_tick);

      uint32_t first_backing = 0;
      uint32_t second_backing = 0;
      uint32_t clean_backing = 0;
      std::memcpy(&first_backing, memory + first_offset, sizeof(first_backing));
      std::memcpy(&second_backing, memory + second_offset,
                  sizeof(second_backing));
      std::memcpy(&clean_backing, memory + clean_offset, sizeof(clean_backing));
      Require(name, "downloaded contents",
              first_backing == first_value && second_backing == second_value &&
                  clean_backing == clean_value &&
                  !cache.IsRegionRegistered(base, allocation_size) &&
                  !cache.IsRegionGpuModified(base + first_offset,
                                             sizeof(first_value)) &&
                  !cache.IsRegionGpuModified(base + second_offset,
                                             sizeof(second_value)) &&
                  !cache.HasGpuDirtyBytes(base + first_offset,
                                          sizeof(first_value)) &&
                  !cache.HasGpuDirtyBytes(base + second_offset,
                                          sizeof(second_value)) &&
                  scheduler.CurrentTick() > gc_submission_tick,
              "critical GC did not publish exact ranges before clearing "
              "Buffer ownership");

      constexpr uint64_t starvation_offset = 0x100000;
      constexpr uint64_t starvation_stride = 2 * BufferCache::CACHING_PAGESIZE;
      constexpr uint32_t starvation_count = 33;
      constexpr uint32_t starvation_value = 0x31415926u;
      BufferCacheTestAccess::SetGarbageCollectionThresholds(
          cache, std::numeric_limits<uint64_t>::max(),
          std::numeric_limits<uint64_t>::max());
      for (uint32_t index = 0; index < starvation_count; index++) {
        const auto address = base + starvation_offset + index * starvation_stride;
        (void)cache.ObtainBuffer(address, sizeof(starvation_value), true);
        cache.FillBuffer(address, sizeof(starvation_value), starvation_value,
                         false);
      }
      for (uint32_t tick = 0; tick < 160; tick++) {
        cache.RunGarbageCollector();
      }
      constexpr uint64_t starvation_clean_offset =
          starvation_offset + starvation_count * starvation_stride;
      const auto starvation_clean = cache.FindBuffer(
          base + starvation_clean_offset, sizeof(starvation_value));
      Require(name, "normal-GC clean candidate",
              static_cast<bool>(starvation_clean),
              "failed to create the clean starvation candidate");
      for (uint32_t tick = 0; tick <= 160; tick++) {
        cache.RunGarbageCollector();
      }
      BufferCacheTestAccess::SetGarbageCollectionThresholds(
          cache, 0, std::numeric_limits<uint64_t>::max());
      cache.RunGarbageCollector();
      Require(
          name, "normal-GC dirty bypass",
          cache.IsRegionRegistered(base + starvation_offset,
                                   sizeof(starvation_value)) &&
              cache.IsRegionRegistered(
                  base + starvation_offset +
                      (starvation_count - 1) * starvation_stride,
                  sizeof(starvation_value)) &&
              !cache.IsRegionRegistered(base + starvation_clean_offset,
                                        sizeof(starvation_value)),
          "old dirty owners hid an eligible clean Buffer from normal GC");
      BufferCacheTestAccess::SetGarbageCollectionThresholds(cache, 0, 0);
      const auto starvation_retired =
          BufferCacheTestAccess::PageOwner(cache, base + starvation_offset);
      cache.RunGarbageCollector();
      Require(name, "critical-GC starvation cleanup",
              !cache.IsRegionRegistered(base + starvation_offset,
                                        sizeof(starvation_value)) &&
                  !cache.IsRegionRegistered(
                      base + starvation_offset +
                          (starvation_count - 1) * starvation_stride,
                      sizeof(starvation_value)) &&
                  !BufferCacheTestAccess::IsBufferAllocated(
                      cache, starvation_retired),
              "critical GC did not immediately free the skipped dirty owners");

      constexpr uint64_t lookup_only_offset = 0x218000;
      constexpr uint64_t obtained_offset = 0x220000;
      constexpr uint64_t residency_size =
          2 * BufferCache::CACHING_PAGESIZE;
      BufferCacheTestAccess::SetGarbageCollectionThresholds(
          cache, std::numeric_limits<uint64_t>::max(),
          std::numeric_limits<uint64_t>::max());
      const auto lookup_only = cache.FindBuffer(
          base + lookup_only_offset, residency_size);
      const auto obtained =
          cache.FindBuffer(base + obtained_offset, residency_size);
      for (uint32_t tick = 0; tick <= 160; tick++) {
        cache.RunGarbageCollector();
      }
      Require(name, "lookup-only owner identity",
              cache.FindBuffer(base + lookup_only_offset, residency_size) ==
                  lookup_only,
              "lookup-only discovery replaced its valid Buffer owner");
      const auto [obtained_buffer, obtained_buffer_offset] = cache.ObtainBuffer(
          base + obtained_offset, residency_size, false, false, obtained);
      BufferCacheTestAccess::SetGarbageCollectionThresholds(
          cache, 0, std::numeric_limits<uint64_t>::max());
      cache.RunGarbageCollector();
      Require(name, "lookup versus acquisition residency",
              !cache.IsRegionRegistered(base + lookup_only_offset,
                                        residency_size) &&
                  !BufferCacheTestAccess::PageOwner(
                      cache, base + lookup_only_offset) &&
                  obtained_buffer == &cache.GetBuffer(obtained) &&
                  obtained_buffer_offset == 0 &&
                  cache.IsRegionRegistered(base + obtained_offset,
                                           residency_size) &&
                  BufferCacheTestAccess::PageOwner(
                      cache, base + obtained_offset) == obtained,
              "lookup refreshed residency or actual acquisition did not");
      BufferCacheTestAccess::SetGarbageCollectionThresholds(cache, 0, 0);

      auto unmap_allocation = cache.ObtainBuffer(
          base + unmap_offset, sizeof(unmap_value), true, false);
      Require(name, "direct-invalidation allocation",
              unmap_allocation.first != nullptr,
              "direct-invalidation buffer allocation failed");
      cache.FillBuffer(base + unmap_offset, sizeof(unmap_value), unmap_value,
                       false);
      resources.UnmapMemory(base + 0x4000, 0x4000);
      uint32_t unmap_backing = 0;
      std::memcpy(&unmap_backing, memory + unmap_offset, sizeof(unmap_backing));
      Require(name, "direct-invalidation contents",
              unmap_backing == unmap_value &&
                  !resources.IsMapped(base + 0x4000, 0x4000) &&
                  cache.IsRegionRegistered(base + 0x4000, 0x4000) &&
                  cache.IsRegionCpuModified(base + 0x4000, 0x4000) &&
                  !cache.IsRegionGpuModified(base + 0x4000, 0x4000) &&
                  !cache.HasGpuDirtyBytes(base + 0x4000, 0x4000),
              "dirty invalidation did not publish bytes and retain its owner");
      std::memcpy(memory + unmap_offset, &remap_value, sizeof(remap_value));
      resources.MapMemory(base + 0x4000, 0x4000);
      const auto remapped =
          cache.ObtainBuffer(base + unmap_offset, sizeof(remap_value), true);
      Require(name, "same-address remap allocation",
              remapped.first == unmap_allocation.first,
              "same-address remap did not synchronize the retained Buffer");
      Require(name, "same-address remap contents",
              ReadNativeValue(*remapped.first, remapped.second) == remap_value,
              "same-address remap reused stale native Buffer bytes");

      auto partial_unmap_allocation =
          cache.ObtainBuffer(base + 0x8000, 0x8000, true, false);
      Require(name, "partial-invalidation allocation",
              partial_unmap_allocation.first != nullptr,
              "cross-page cached buffer allocation failed");
      cache.FillBuffer(base + partial_unmap_offset, sizeof(partial_unmap_value),
                       partial_unmap_value, false);
      cache.FillBuffer(base + partial_unmap_survivor_offset,
                       sizeof(partial_unmap_survivor_value),
                       partial_unmap_survivor_value, false);
      resources.UnmapMemory(base + 0x8000, 0x4000);
      uint32_t partial_unmap_survivor_backing = 0;
      std::memcpy(&partial_unmap_survivor_backing,
                  memory + partial_unmap_survivor_offset,
                  sizeof(partial_unmap_survivor_backing));
      Require(
          name, "partial-invalidation ownership",
          !resources.IsMapped(base + 0x8000, 0x4000) &&
              cache.IsRegionRegistered(base + 0x8000, 0x8000) &&
              cache.IsRegionCpuModified(base + 0x8000, 0x4000) &&
              !cache.IsRegionCpuModified(
                  base + partial_unmap_survivor_offset,
                  sizeof(partial_unmap_survivor_value)) &&
              !cache.HasGpuDirtyBytes(base + partial_unmap_offset,
                                      sizeof(partial_unmap_value)) &&
              !cache.HasGpuDirtyBytes(base + partial_unmap_survivor_offset,
                                      sizeof(partial_unmap_survivor_value)) &&
              partial_unmap_survivor_backing == partial_unmap_survivor_value,
          "widened partial invalidation mishandled ownership or backing");
      resources.MapMemory(base + 0x8000, 0x4000);
      auto survivor =
          cache.ObtainBuffer(base + partial_unmap_survivor_offset,
                             sizeof(partial_unmap_survivor_value), false);
      Require(name, "partial-invalidation survivor", survivor.first != nullptr,
              "cached-buffer remainder was not retained");
      Require(name, "partial-invalidation survivor contents",
              ReadNativeValue(*survivor.first, survivor.second) ==
                  partial_unmap_survivor_value,
              "partial invalidation lost disjoint native bytes");

      constexpr uint64_t large_offset = 0x10000;
      constexpr uint64_t large_size = 32ull << 20;
      constexpr uint32_t large_value = 0x5aa55aa5u;
      constexpr uint32_t large_stale = 0x12345678u;
      std::memcpy(memory + large_offset, &large_stale, sizeof(large_stale));
      std::memcpy(memory + large_offset + large_size - sizeof(large_stale),
                  &large_stale, sizeof(large_stale));
      auto large_allocation =
          cache.ObtainBuffer(base + large_offset, large_size, true, false);
      Require(name, "near-capacity dirty allocation",
              large_allocation.first != nullptr,
              "failed to allocate the near-capacity dirty native buffer");
      cache.FillBuffer(base + large_offset, large_size, large_value, false);
      const auto large_submission_tick = scheduler.CurrentTick();
      for (uint32_t tick = 0; tick <= 160; tick++) {
        cache.RunGarbageCollector();
      }
      // Earlier dirty owners in this GC pass may require one ring-wrap drain
      // before the full-capacity download can reserve the stream.
      Require(name, "near-capacity synchronized retirement",
              !cache.IsRegionRegistered(base + large_offset, large_size) &&
                  scheduler.CurrentTick() > large_submission_tick &&
                  scheduler.CurrentTick() <= large_submission_tick + 2,
              "capacity-sized dirty Buffer exceeded one ring-wrap drain");
      uint32_t large_before_completion = 0;
      Libs::LibKernel::Memory::TryReadBacking(base + large_offset,
                                              &large_before_completion,
                                              sizeof(large_before_completion));
      Require(name, "near-capacity backing publication",
              large_before_completion == large_value,
              "near-capacity Buffer GC retired ownership before publication");
      const auto large_image_source =
          cache.ObtainBufferForImage(base + large_offset, sizeof(large_value));
      Require(name, "fixed download after Buffer retirement",
              large_image_source.first != nullptr &&
                  &BufferCacheTestAccess::DownloadBuffer(cache) ==
                      fixed_download &&
                  fixed_download->Handle() == fixed_download_handle &&
                  fixed_download->Size() == (32ull << 20),
              "image acquisition replaced the shared Buffer download stream");
      std::vector<uint32_t> large_published(large_size / sizeof(uint32_t));
      Require(name, "near-capacity Buffer publication contents",
              Libs::LibKernel::Memory::TryReadBacking(
                  base + large_offset, large_published.data(), large_size) &&
                  std::ranges::all_of(large_published, [](uint32_t value) {
                    return value == large_value;
                  }),
              "near-capacity Buffer GC did not publish its complete transfer");

      constexpr uint64_t grouped_first_offset = 0x10000;
      constexpr uint64_t grouped_second_offset = 0x1200000;
      constexpr uint64_t grouped_owner_size = 17ull * 1024 * 1024;
      constexpr uint32_t grouped_first_value = 0x1122aabbu;
      constexpr uint32_t grouped_second_value = 0x3344ccddu;
      constexpr uint32_t grouped_stale = 0;
      static_assert(grouped_owner_size < (32ull << 20) &&
                    grouped_owner_size * 2 > (32ull << 20));
      Libs::LibKernel::Memory::WriteBacking(
          base + grouped_first_offset, &grouped_stale, sizeof(grouped_stale));
      Libs::LibKernel::Memory::WriteBacking(
          base + grouped_second_offset, &grouped_stale, sizeof(grouped_stale));
      auto grouped_first = cache.ObtainBuffer(base + grouped_first_offset,
                                              grouped_owner_size, true, false);
      auto grouped_second = cache.ObtainBuffer(base + grouped_second_offset,
                                               grouped_owner_size, true, false);
      Require(name, "per-owner GC allocation",
              grouped_first.first != nullptr &&
                  grouped_second.first != nullptr &&
                  grouped_first.first != grouped_second.first,
              "disjoint GC candidates merged into one Buffer owner");
      cache.FillBuffer(base + grouped_first_offset, grouped_owner_size,
                       grouped_first_value, false);
      cache.FillBuffer(base + grouped_second_offset, grouped_owner_size,
                       grouped_second_value, false);
      for (uint32_t tick = 0; tick <= 160; tick++) {
        cache.RunGarbageCollector();
      }
      Require(name, "per-owner fixed-ring retirement",
              !cache.IsRegionRegistered(base + grouped_first_offset,
                                        grouped_owner_size) &&
                  !cache.IsRegionRegistered(base + grouped_second_offset,
                                            grouped_owner_size) &&
                  &BufferCacheTestAccess::DownloadBuffer(cache) ==
                      fixed_download &&
                  fixed_download->Handle() == fixed_download_handle,
              "GC aggregated disjoint retirees or replaced the download ring");
      uint32_t grouped_first_backing = 0;
      uint32_t grouped_second_backing = 0;
      Libs::LibKernel::Memory::TryReadBacking(base + grouped_first_offset,
                                              &grouped_first_backing,
                                              sizeof(grouped_first_backing));
      Libs::LibKernel::Memory::TryReadBacking(base + grouped_second_offset,
                                              &grouped_second_backing,
                                              sizeof(grouped_second_backing));
      Require(name, "per-owner fixed-ring contents",
              grouped_first_backing == grouped_first_value &&
                  grouped_second_backing == grouped_second_value,
              "per-owner GC transfers lost data while wrapping the fixed ring");

      constexpr uint64_t sparse_offset = 0x2180000;
      constexpr uint64_t sparse_owner_stride = 2 * BufferCache::CACHING_PAGESIZE;
      constexpr std::array<uint64_t, 3> sparse_starts{1, 7, 13};
      constexpr std::array<uint64_t, 3> sparse_sizes{3, 2, 1};
      constexpr std::array<uint32_t, 2> sparse_values{0x41372b19u, 0x957f6953u};
      std::array<uint8_t, 16> sparse_clean{};
      sparse_clean.fill(0xcdu);
      const auto FillSparseOwner = [&](uint32_t owner_index) {
        const auto address = base + sparse_offset +
                             owner_index * sparse_owner_stride;
        Libs::LibKernel::Memory::WriteBacking(address, sparse_clean.data(),
                                              sparse_clean.size());
        Libs::Graphics::Buffer *owner = nullptr;
        for (size_t index = 0; index < sparse_starts.size(); ++index) {
          const auto allocation = cache.ObtainBuffer(
              address + sparse_starts[index], sparse_sizes[index], true, false);
          Require(name, "sparse byte-range owner",
                  allocation.first != nullptr &&
                      (owner == nullptr || owner == allocation.first),
                  "disjoint byte ranges did not resolve to one cached owner");
          owner = allocation.first;
        }
        // Deliberately change native clean neighbors too: only the exact dirty
        // bytes may be published to guest memory.
        owner->Fill(owner->Offset(address), sparse_clean.size(),
                    sparse_values[owner_index]);
      };
      const auto CheckSparseOwner = [&](uint32_t owner_index) {
        const auto address = base + sparse_offset +
                             owner_index * sparse_owner_stride;
        auto expected = sparse_clean;
        std::array<uint8_t, sizeof(uint32_t)> value_bytes{};
        std::memcpy(value_bytes.data(), &sparse_values[owner_index],
                    value_bytes.size());
        for (size_t index = 0; index < sparse_starts.size(); ++index) {
          for (uint64_t byte = sparse_starts[index];
               byte < sparse_starts[index] + sparse_sizes[index]; ++byte) {
            expected[byte] = value_bytes[byte % value_bytes.size()];
          }
        }
        std::array<uint8_t, 16> published{};
        Require(name, "sparse byte-range publication",
                Libs::LibKernel::Memory::TryReadBacking(
                    address, published.data(), published.size()) &&
                    published == expected &&
                    !cache.HasGpuDirtyBytes(address, published.size()) &&
                    !cache.IsRegionGpuModified(address, published.size()),
                "odd-byte readback lost dirty bytes or overwrote clean neighbors");
      };
      FillSparseOwner(0);
      bool sparse_callback_ran = false;
      bool sparse_callback_clean = false;
      scheduler.DeferOperation([&] {
        sparse_callback_clean =
            !cache.HasGpuDirtyBytes(base + sparse_offset, sparse_clean.size()) &&
            !cache.IsRegionGpuModified(base + sparse_offset, sparse_clean.size());
        sparse_callback_ran = true;
      });
      const auto sparse_read_tick = scheduler.CurrentTick();
      cache.ReadMemory(base + sparse_offset + sparse_starts[0], sparse_sizes[0]);
      Require(name, "sparse byte-range submission",
              scheduler.CurrentTick() == sparse_read_tick + 1,
              "sparse source ranges were downloaded in separate submissions");
      scheduler.PopPendingOperations();
      Require(name, "readback callback ownership consistency",
              sparse_callback_ran && sparse_callback_clean,
              "readback drained a deferred callback before clearing page ownership");
      CheckSparseOwner(0);

      FillSparseOwner(0);
      FillSparseOwner(1);
      Require(name, "sparse disjoint GC owners",
              BufferCacheTestAccess::PageOwner(cache, base + sparse_offset) !=
                  BufferCacheTestAccess::PageOwner(
                      cache, base + sparse_offset + sparse_owner_stride),
              "sparse GC fixtures merged into one source owner");
      const auto sparse_gc_tick = scheduler.CurrentTick();
      for (uint32_t tick = 0; tick <= 160; ++tick) {
        cache.RunGarbageCollector();
      }
      Require(name, "sparse multi-owner GC submission",
              scheduler.CurrentTick() == sparse_gc_tick + 1 &&
                  !cache.IsRegionRegistered(base + sparse_offset,
                                             sparse_owner_stride + 16),
              "sparse GC owners did not share one completion drain");
      CheckSparseOwner(0);
      CheckSparseOwner(1);

      constexpr uint64_t disjoint_owner_offset = 0x2140000;
      constexpr uint64_t disjoint_owner_size = 0x8000;
      constexpr uint64_t disjoint_dirty_offset = disjoint_owner_offset + 0x100;
      constexpr uint64_t disjoint_new_owner_offset =
          disjoint_owner_offset + 0x5000;
      constexpr uint32_t disjoint_value = 0x89abcdefu;
      constexpr uint32_t disjoint_stale = 0x76543210u;
      std::memcpy(memory + disjoint_dirty_offset, &disjoint_stale,
                  sizeof(disjoint_stale));
      auto wide_owner = cache.ObtainBuffer(base + disjoint_owner_offset,
                                           disjoint_owner_size, false);
      Require(name, "disjoint retirement owner", wide_owner.first != nullptr,
              "failed to create the clean cross-page retirement owner");
      (void)cache.ObtainBuffer(base + disjoint_dirty_offset,
                               sizeof(disjoint_value), true, false);
      cache.FillBuffer(base + disjoint_dirty_offset, sizeof(disjoint_value),
                       disjoint_value, false);
      for (uint32_t tick = 0; tick <= 160; tick++) {
        cache.RunGarbageCollector();
      }
      Require(name, "disjoint synchronized retirement",
              !cache.IsRegionRegistered(base + disjoint_owner_offset,
                                        disjoint_owner_size),
              "cross-page owner survived pressured collection");
      uint32_t disjoint_before_unmap = 0;
      Libs::LibKernel::Memory::TryReadBacking(base + disjoint_dirty_offset,
                                              &disjoint_before_unmap,
                                              sizeof(disjoint_before_unmap));
      Require(
          name, "disjoint retirement publication",
          disjoint_before_unmap == disjoint_value,
          "whole-owner Buffer retired before publishing its dirty bytes");
      resources.UnmapMemory(base + disjoint_owner_offset + 0x4000, 0x4000);
      uint32_t disjoint_after_unmap = 0;
      Libs::LibKernel::Memory::TryReadBacking(base + disjoint_dirty_offset,
                                              &disjoint_after_unmap,
                                              sizeof(disjoint_after_unmap));
      Require(name, "disjoint synchronized invalidation",
              disjoint_after_unmap == disjoint_value &&
                  !cache.HasGpuDirtyBytes(base + disjoint_dirty_offset,
                                          sizeof(disjoint_value)),
              "disjoint invalidation lost the completed whole-owner publication");
      resources.MapMemory(base + disjoint_owner_offset + 0x4000, 0x4000);
      auto disjoint_new_owner =
          cache.ObtainBuffer(base + disjoint_new_owner_offset,
                             sizeof(disjoint_value), true, false);
      Require(name, "disjoint post-publication reacquire",
              disjoint_new_owner.first != nullptr,
              "disjoint acquisition failed after whole-owner publication");
      uint32_t disjoint_backing = 0;
      Libs::LibKernel::Memory::TryReadBacking(base + disjoint_dirty_offset,
                                              &disjoint_backing,
                                              sizeof(disjoint_backing));
      Require(name, "disjoint retirement contents",
              disjoint_backing == disjoint_value,
              "old retirement callback lost dirty bytes or retained ownership "
              "after a disjoint reacquire");
      cache.ReadMemory(base + disjoint_new_owner_offset,
                       sizeof(disjoint_value));

      constexpr uint64_t reacquire_owner_offset = 0x2200000;
      constexpr uint64_t reacquire_owner_size = 0x8000;
      constexpr uint64_t reacquire_dirty_offset =
          reacquire_owner_offset + 0x100;
      constexpr uint64_t reacquire_disjoint_offset =
          reacquire_owner_offset + 0x5000;
      constexpr uint32_t reacquire_value = 0xc001d00du;
      constexpr uint32_t reacquire_stale = 0x0badf00du;
      std::memcpy(memory + reacquire_dirty_offset, &reacquire_stale,
                  sizeof(reacquire_stale));
      auto reacquire_owner = cache.ObtainBuffer(base + reacquire_owner_offset,
                                                reacquire_owner_size, false);
      Require(name, "reacquire retirement owner",
              reacquire_owner.first != nullptr,
              "failed to create a fresh cross-page retirement owner");
      (void)cache.ObtainBuffer(base + reacquire_dirty_offset,
                               sizeof(reacquire_value), true, false);
      cache.FillBuffer(base + reacquire_dirty_offset, sizeof(reacquire_value),
                       reacquire_value, false);
      for (uint32_t tick = 0; tick <= 160; tick++) {
        cache.RunGarbageCollector();
      }
      Require(name, "reacquire synchronized retirement",
              !cache.IsRegionRegistered(base + reacquire_owner_offset,
                                        reacquire_owner_size),
              "fresh cross-page owner survived pressured collection");
      uint32_t reacquire_before = 0;
      Libs::LibKernel::Memory::TryReadBacking(base + reacquire_dirty_offset,
                                              &reacquire_before,
                                              sizeof(reacquire_before));
      Require(name, "reacquire publication completed",
              reacquire_before == reacquire_value,
              "fresh whole-owner ownership retired before publication");
      auto reacquired =
          cache.ObtainBuffer(base + reacquire_disjoint_offset,
                             sizeof(reacquire_value), true, false);
      Require(name, "independent disjoint post-publication reacquire",
              reacquired.first != nullptr,
              "clean disjoint-half acquisition failed after publication");
      uint32_t reacquire_after = 0;
      Libs::LibKernel::Memory::TryReadBacking(base + reacquire_dirty_offset,
                                              &reacquire_after,
                                              sizeof(reacquire_after));
      Require(name, "independent disjoint reacquire contents",
              reacquire_after == reacquire_value &&
                  !cache.HasGpuDirtyBytes(base + reacquire_dirty_offset,
                                          sizeof(reacquire_value)),
              "disjoint-half acquisition failed to publish the retired "
              "owner's dirty prefix");
      cache.ReadMemory(base + reacquire_disjoint_offset,
                       sizeof(reacquire_value));

      resources.UnmapMemory(base, allocation_size);
      scheduler.Finish();
    }
    context.ShutdownGpu();
    Require(name, "unmap direct backing",
            Libs::LibKernel::Memory::KernelMunmap(base, allocation_size) == 0,
            "dirty-GC direct-memory mapping release failed");
    Require(name, "release direct backing",
            Libs::LibKernel::Memory::KernelReleaseDirectMemory(
                direct_offset, allocation_size) == 0,
            "dirty-GC direct-memory allocation release failed");
    std::printf("[host]    %-32s ok\n", name);
  }

  void CheckComputeMetaClearClassification() {
    constexpr const char *name = "ComputeMetaClearClassification";
    constexpr uint64_t read_only_meta = 0x0000000204201f00ull;
    constexpr uint64_t read_write_meta = 0x0000000204202000ull;
    constexpr uint64_t write_only_meta = 0x0000000204202100ull;
    EnsureRuntimeContext();
    RenderContext context(m_runtime_context);
    auto &scheduler = context.GetCommandScheduler();
    HW::Context registers{};
    HW::UserConfig user_config{};
    HW::Shader shaders{};
    scheduler.Begin(registers, user_config, shaders);
    auto &texture_cache = context.GetTextureCache();
    TextureCacheTestAccess::RegisterHtileMeta(texture_cache, read_only_meta);
    TextureCacheTestAccess::RegisterHtileMeta(texture_cache, read_write_meta);
    TextureCacheTestAccess::RegisterHtileMeta(texture_cache, write_only_meta);

    // An empty dispatch must not inspect even an unreadable shader address.
    shaders.SetCsShader({.data_addr = 1});
    constexpr std::array<std::array<uint32_t, 3>, 3> empty_dispatches{{
        {0, 1, 1}, {1, 0, 1}, {1, 1, 0}}};
    for (const auto mode : {0x41u, 0x61u}) {
      for (const auto &groups : empty_dispatches) {
        context.GetRenderExecutor().DispatchDirect(
            0, scheduler.Current(), groups[0], groups[1], groups[2], mode);
      }
    }
    Require(name, "HTile fixture",
            texture_cache.IsMeta(read_only_meta) &&
                texture_cache.IsMeta(read_write_meta) &&
                texture_cache.IsMeta(write_only_meta) &&
                !texture_cache.IsMetaCleared(read_only_meta, 0) &&
                !texture_cache.IsMetaCleared(read_write_meta, 0) &&
                !texture_cache.IsMetaCleared(write_only_meta, 0),
            "test HTile entries were not registered in their initial state");

    const auto MakeInput = [](uint64_t address, bool read, bool written,
                              ShaderRecompiler::IR::CompiledShaderInfo &program) {
      program.stage = ShaderType::Compute;
      ShaderRecompiler::IR::BufferResource resource{};
      resource.read = read;
      resource.written = written;
      resource.formatted = true;
      program.info.buffers.push_back(resource);

      ShaderBufferResource descriptor{};
      descriptor.UpdateAddress48(address);
      descriptor.fields[1] |= 16u << 16u;
      descriptor.fields[2] = 8;
      descriptor.fields[3] =
          DstSel(4, 5, 6, 7) |
          (static_cast<uint32_t>(Prospero::BufferFormat::k32_32_32_32UInt)
           << 12u);
      ShaderRecompiler::IR::DescriptorValue value{};
      value.dword_count = 4;
      std::copy_n(descriptor.fields, value.dword_count, value.dwords.begin());
      ShaderComputeInputInfo input{};
      input.stage.program = &program;
      input.stage.resources.buffers.push_back(value);
      return input;
    };
    auto &executor = context.GetRenderExecutor();
    auto &command = scheduler.Current();
    ShaderRecompiler::IR::CompiledShaderInfo read_only_program{};
    const auto read_only_input =
        MakeInput(read_only_meta, true, false, read_only_program);
    const bool read_only_consumed =
        RenderExecutorTestAccess::TryConsumeComputeMetaClear(
            executor, read_only_input, command);
    Require(name, "read-only dispatch preserved",
            !read_only_consumed &&
                !texture_cache.IsMetaCleared(read_only_meta, 0),
            "a metadata read-only dispatch changed logical clear state");

    ShaderRecompiler::IR::CompiledShaderInfo read_write_program{};
    const auto read_write_input =
        MakeInput(read_write_meta, true, true, read_write_program);
    const bool read_write_consumed =
        RenderExecutorTestAccess::TryConsumeComputeMetaClear(
            executor, read_write_input, command);
    Require(name, "read/write dispatch preserved",
            !read_write_consumed &&
                !texture_cache.IsMetaCleared(read_write_meta, 0),
            "a metadata read/modify/write dispatch was replaced by a clear");

    ShaderRecompiler::IR::CompiledShaderInfo write_only_program{};
    const auto write_only_input =
        MakeInput(write_only_meta, false, true, write_only_program);
    const bool write_only_consumed =
        RenderExecutorTestAccess::TryConsumeComputeMetaClear(
            executor, write_only_input, command);
    Require(name, "write-only fill consumed",
            write_only_consumed &&
                texture_cache.IsMetaCleared(write_only_meta, 0),
            "a metadata write-only fill was not consumed as a clear");
    scheduler.Finish();
    std::printf("[host]    %-32s ok\n", name);
  }

  void CheckUnifiedTextureCacheFlow() {
    constexpr const char *name = "UnifiedTextureCacheFlow";
    constexpr uintptr_t base = 0x0000000200600000ull;
    constexpr uint64_t allocation_size = 0x2800000;
    constexpr uint64_t allocation_alignment = 0x200000;
    EnsureRuntimeContext();
    RenderContext context(m_runtime_context);
    auto &scheduler = context.GetCommandScheduler();
    HW::Context registers{};
    HW::UserConfig user_config{};
    HW::Shader shaders{};
    scheduler.Begin(registers, user_config, shaders);
    context.InitializeGpu(nullptr);
    auto &gpu = context.GetGpu();
    int64_t direct_offset = -1;
    Require(name, "direct allocation",
            Libs::LibKernel::Memory::KernelAllocateDirectMemory(
                0, Libs::LibKernel::Memory::KernelGetDirectMemorySize(),
                allocation_size, allocation_alignment, 0, &direct_offset) == 0,
            "cache test direct-memory allocation failed");
    void *mapped = reinterpret_cast<void *>(base);
    Require(name, "direct mapping",
            Libs::LibKernel::Memory::KernelMapDirectMemory(
                &mapped, allocation_size, 0x3, 0x10, direct_offset,
                allocation_alignment) == 0 &&
                mapped == reinterpret_cast<void *>(base),
            "fixed cache direct-memory mapping failed");
    auto *memory = static_cast<uint8_t *>(mapped);
    const uint32_t initial = 0x44332211u;
    std::memcpy(memory, &initial, sizeof(initial));

    {
      auto &resources = context;
      LibKernel::Memory::InstallGpuResources(&resources);
      auto &texture_cache = resources.GetTextureCache();
      const auto [narrow_download, narrow_download_offset] =
          TextureCacheTestAccess::MapDownload(texture_cache, 4, 4);
      const auto [wide_download, wide_download_offset] =
          TextureCacheTestAccess::MapDownload(texture_cache, 1, 16);
      Require(name, "image download alignment",
              narrow_download != nullptr && narrow_download_offset % 4 == 0 &&
                  wide_download != nullptr && wide_download_offset % 16 == 0,
              "wide/block image readback was not aligned to its texel block");
      resources.MapMemory(base, allocation_size);

      ImageDesc sampled{};
      sampled.type = BindingType::Texture;
      sampled.info.data = {base, sizeof(initial)};
      sampled.info.pixel_format = vk::Format::eR8G8B8A8Srgb;
      sampled.info.guest_format = Prospero::BufferFormat::k8_8_8_8Srgb;
      sampled.info.type = Prospero::ImageType::kColor2D;
      sampled.info.extent = {1, 1, 1};
      sampled.info.resources = {1, 1};
      sampled.info.pitch = 1;
      sampled.info.bytes_per_block = 4;
      sampled.info.samples = 1;
      sampled.info.tile_mode = Prospero::TileMode::kLinear;
      sampled.info.mip_layout[0] = {0, 4, 1, 1};
      sampled.view_info.format = sampled.info.pixel_format;
      sampled.view_info.type = vk::ImageViewType::e2D;
      sampled.view_info.aspect = vk::ImageAspectFlagBits::eColor;
      sampled.view_info.usage = vk::ImageUsageFlagBits::eSampled;

      auto &command = scheduler.Current();
      auto first_desc = sampled;
      const auto first = texture_cache.FindImage(first_desc);
      auto repeated_desc = sampled;
      const auto repeated = texture_cache.FindImage(repeated_desc);
      auto compatible_desc = sampled;
      compatible_desc.info.pixel_format = vk::Format::eR8G8B8A8Uint;
      compatible_desc.info.guest_format = Prospero::BufferFormat::k8_8_8_8UInt;
      compatible_desc.view_info.format = compatible_desc.info.pixel_format;
      const auto compatible = texture_cache.FindImage(compatible_desc);
      Require(name, "normalized FindImage",
              first && repeated == first && compatible == first &&
                  texture_cache.GetImage(first).info.pixel_format ==
                      vk::Format::eR8G8B8A8Srgb,
              "registered compatible backing did not reuse one ImageId");

      const auto IsOnlyImage = [](const std::vector<ImageId> &ids,
                                  ImageId expected) {
        return ids.size() == 1 && ids.front() == expected;
      };
      const auto exact_byte_miss =
          TextureCacheTestAccess::FindImages(texture_cache, base + 8, 1, false);
      const auto touched_page_hit =
          TextureCacheTestAccess::FindImages(texture_cache, base + 8, 1, true);
      const auto next_page_miss = TextureCacheTestAccess::FindImages(
          texture_cache, base + 0x1000, 1, true);
      Require(name, "exact and 4-KiB page filtering",
              exact_byte_miss.empty() && IsOnlyImage(touched_page_hit, first) &&
                  next_page_miss.empty(),
              "coarse candidates did not preserve exact-byte and touched-page "
              "semantics");

      const auto MakeOwnershipInfo = [](uint64_t address, uint64_t size) {
        ImageInfo info{};
        info.data = {address, size};
        info.extent = {1, 1, 1};
        info.resources = {1, 1};
        info.samples = 1;
        return info;
      };
      const auto spanning_info = MakeOwnershipInfo(base + 0x1ff000, 0x2000);
      const auto spanning =
          TextureCacheTestAccess::InsertImage(texture_cache, spanning_info);
      const auto spanning_results = TextureCacheTestAccess::FindImages(
          texture_cache, spanning_info.data.address, spanning_info.data.size,
          false);
      Require(name, "one-MiB cross-page deduplication",
              spanning && IsOnlyImage(spanning_results, spanning) &&
                  TextureCacheTestAccess::PageOwnerCount(
                      texture_cache, spanning_info.data.address) == 1 &&
                  TextureCacheTestAccess::PageOwnerCount(
                      texture_cache, spanning_info.data.End() - 1) == 1,
              "an image spanning two coarse pages was missing or returned more "
              "than once");
      TextureCacheTestAccess::DeleteImage(texture_cache, spanning);
      Require(name, "cross-page owner cleanup",
              TextureCacheTestAccess::PageOwnerCount(
                  texture_cache, spanning_info.data.address) == 0 &&
                  TextureCacheTestAccess::PageOwnerCount(
                      texture_cache, spanning_info.data.End() - 1) == 0 &&
                  TextureCacheTestAccess::FindImages(
                      texture_cache, spanning_info.data.address,
                      spanning_info.data.size, false)
                      .empty(),
              "cross-page unregister left a stale coarse-page membership");

      const auto shared_info = MakeOwnershipInfo(base + 0x500100, 0x100);
      const auto shared_first =
          TextureCacheTestAccess::InsertImage(texture_cache, shared_info);
      const auto shared_second =
          TextureCacheTestAccess::InsertImage(texture_cache, shared_info);
      const auto shared_results = TextureCacheTestAccess::FindImages(
          texture_cache, shared_info.data.address, shared_info.data.size,
          false);
      Require(name, "shared coarse-page registration",
              shared_results.size() == 2 &&
                  std::find(shared_results.begin(), shared_results.end(),
                            shared_first) != shared_results.end() &&
                  std::find(shared_results.begin(), shared_results.end(),
                            shared_second) != shared_results.end(),
              "two registered owners were not retained in one coarse page");
      TextureCacheTestAccess::DeleteImage(texture_cache, shared_first);
      const auto shared_survivor = TextureCacheTestAccess::FindImages(
          texture_cache, shared_info.data.address, shared_info.data.size,
          false);
      Require(name, "shared coarse-page unregister",
              IsOnlyImage(shared_survivor, shared_second) &&
                  TextureCacheTestAccess::PageOwnerCount(
                      texture_cache, shared_info.data.address) == 1,
              "unregistering one owner removed its coarse-page neighbor");
      TextureCacheTestAccess::DeleteImage(texture_cache, shared_second);
      Require(name, "final shared coarse-page unregister",
              TextureCacheTestAccess::PageOwnerCount(
                  texture_cache, shared_info.data.address) == 0,
              "the final shared owner remained registered");

      constexpr uint64_t large_owner_size = 64ull * 1024 * 1024;
      const auto large_info =
          MakeOwnershipInfo(base + 0x800000, large_owner_size);
      const auto large_owner =
          TextureCacheTestAccess::InsertImage(texture_cache, large_info);
      Require(name, "production one-MiB registration granularity",
              TextureCacheTestAccess::OwnedPageCount(
                  texture_cache, large_info.data.address, large_info.data.size,
                  large_owner) == 64,
              "64 MiB image registration did not create exactly 64 coarse "
              "memberships");
      TextureCacheTestAccess::DeleteImage(texture_cache, large_owner);
      Require(name, "production one-MiB unregister granularity",
              TextureCacheTestAccess::OwnedPageCount(
                  texture_cache, large_info.data.address, large_info.data.size,
                  large_owner) == 0,
              "large image unregister left coarse memberships behind");

      const ImageId stale{first.index, first.generation + 1};
      TextureCacheTestAccess::AddPageOwner(texture_cache, base, stale);
      const auto stale_filtered = TextureCacheTestAccess::FindImages(
          texture_cache, base, sizeof(initial), false);
      Require(name, "stale page owner filtering",
              IsOnlyImage(stale_filtered, first) &&
                  TextureCacheTestAccess::RemovePageOwner(texture_cache, base,
                                                          stale),
              "a stale generation escaped the direct page-owner lookup");

      TextureCacheTestAccess::SetQueryEpoch(texture_cache, UINT32_MAX);
      const auto wrap_results = TextureCacheTestAccess::FindImages(
          texture_cache, base, sizeof(initial), false);
      Require(name, "page-owner query epoch wrap",
              IsOnlyImage(wrap_results, first) &&
                  TextureCacheTestAccess::QueryEpoch(texture_cache) == 1,
              "query deduplication failed while wrapping its epoch");

      auto &image = texture_cache.GetImage(first);
      constexpr uint32_t final_sampled_value = 0x88776655u;
      Require(name, "sampled write between discovery and acquisition",
              resources.HandleFault(PageFaultAccess::Write,
                                    sampled.info.data.address),
              "sampled image did not accept a CPU update after discovery");
      std::memcpy(memory, &final_sampled_value, sizeof(final_sampled_value));
      Require(name, "sampled final-acquisition precondition",
              image.IsCpuDirty(),
              "the between-phase CPU write did not dirty the discovered image");
      const auto first_view = texture_cache.FindTexture(first, first_desc);
      const auto repeated_view =
          texture_cache.FindTexture(repeated, repeated_desc);
      auto mapped_view_info = sampled.view_info;
      mapped_view_info.mapping.r = vk::ComponentSwizzle::eB;
      mapped_view_info.mapping.b = vk::ComponentSwizzle::eR;
      const auto mapped_view = image.FindView(mapped_view_info);
      Require(
          name, "dynamic views",
          first_view != nullptr && repeated_view == first_view &&
              mapped_view != nullptr && mapped_view != first_view &&
              image.views.size() == 2 && !image.usage.texture &&
              !image.IsGpuModified() && !image.IsCpuDirty() &&
              !TextureCacheTestAccess::PendingDownload(texture_cache, first),
          "TextureCache::FindTexture did not preserve sampled view "
          "identity, final refresh, and cache-only ownership");

      constexpr uint64_t resource_replacement_offset = 0x700000;
      const std::array<uint32_t, 3> resource_replacement_data{
          0x01020304u, 0x11121314u, 0x21222324u};
      std::memcpy(memory + resource_replacement_offset,
                  resource_replacement_data.data(),
                  sizeof(resource_replacement_data));
      auto underspecified = sampled;
      underspecified.info.data = {base + resource_replacement_offset,
                                  sizeof(resource_replacement_data)};
      underspecified.info.pixel_format = vk::Format::eR32Uint;
      underspecified.info.guest_format = Prospero::BufferFormat::k32UInt;
      underspecified.info.extent = {2, 1, 1};
      underspecified.info.resources = {1, 1};
      underspecified.info.pitch = 2;
      underspecified.info.mip_layout[0] = {0, 8, 2, 1};
      underspecified.info.mip_layout[1] = {8, 4, 1, 1};
      underspecified.view_info.format = underspecified.info.pixel_format;
      underspecified.view_info.level_count = 1;
      const auto underspecified_id = texture_cache.FindImage(underspecified);
      (void)texture_cache.FindTexture(underspecified_id, underspecified);
      texture_cache.MarkGpuWritten(underspecified_id);

      auto complete = underspecified;
      complete.info.resources = {2, 1};
      complete.view_info.level_count = 2;
      const auto complete_id = texture_cache.FindImage(complete);
      const auto complete_owner =
          TextureCacheTestAccess::Owner(texture_cache, complete_id);
      Require(name, "insufficient-resource replacement",
              complete_id && complete_id != underspecified_id &&
                  !TextureCacheTestAccess::Contains(texture_cache,
                                                    underspecified_id) &&
                  complete_owner != nullptr && complete_owner->registered &&
                  complete_owner->info.resources == complete.info.resources &&
                  !complete_owner->IsGpuModified() &&
                  complete_owner->IsDefinitelyCpuDirty(),
              "an exact backing with insufficient resources was expanded "
              "instead of being discarded and recreated");

      ImageInfo chain = sampled.info;
      chain.data = {0x2394c1000, 0x384000};
      chain.extent = {64, 64, 1};
      chain.resources = {7, 150};
      chain.pitch = 64;
      chain.tile_mode = Prospero::TileMode::kStandard4KB;
      chain.mip_layout[0] = {0x2000, 0x258000, 64, 64};
      chain.mip_layout[1] = {0x1000, 0x96000, 32, 32};
      for (uint32_t level = 2; level < chain.resources.levels; ++level) {
        chain.mip_layout[level] = {0, 0x96000, 32, 32};
      }
      ImageInfo subresource = chain;
      subresource.data = {0x2394c3000, 0x4000};
      subresource.resources = {1, 1};
      subresource.mip_layout = {};
      subresource.mip_layout[0] = {0, 0x4000, 64, 64};
      const auto mip = subresource.MipOf(chain);
      Require(name, "overlap resolution",
              mip == 0 && subresource.SliceOf(chain, mip) == 0 &&
                  ImageRangeOverlaps(chain.data, subresource.data) &&
                  ImagePageRangesOverlap(chain.data, subresource.data),
              "captured PS5 atlas mip/slice overlap did not resolve");

      auto exact_desc = compatible_desc;
      const auto exact = texture_cache.FindImage(exact_desc, true);
      Require(name, "exact-format coexistence",
              exact && exact != first &&
                  TextureCacheTestAccess::Contains(texture_cache, first) &&
                  texture_cache.GetImage(first).info.pixel_format ==
                      sampled.info.pixel_format &&
                  texture_cache.GetImage(exact).info.pixel_format ==
                      compatible_desc.info.pixel_format,
              "exact-format lookup replaced or synchronized its compatible "
              "cache record");
      auto compatible_after_exact_desc = compatible_desc;
      const auto compatible_after_exact =
          texture_cache.FindImage(compatible_after_exact_desc);
      Require(name, "last compatible format winner",
              compatible_after_exact == exact,
              "non-exact lookup did not retain the last compatible "
              "registration");

      auto null_desc = sampled;
      null_desc.info.data = {};
      auto null_repeat_desc = null_desc;
      const auto null_image = texture_cache.FindImage(null_desc);
      const auto null_repeat = texture_cache.FindImage(null_repeat_desc);
      Require(name, "null image",
              null_image && null_repeat == null_image && null_image != exact,
              "typed null-image lookup was not stable");

      constexpr uint64_t extent_alias_offset = 0x2400000;
      auto narrow_target = sampled;
      narrow_target.type = BindingType::RenderTarget;
      narrow_target.info.data = {base + extent_alias_offset, 0x10000};
      narrow_target.info.pixel_format = vk::Format::eR16G16B16A16Sfloat;
      narrow_target.info.guest_format =
          Prospero::BufferFormat::k16_16_16_16Float;
      narrow_target.info.extent = {1, 1, 1};
      narrow_target.info.pitch = 128;
      narrow_target.info.bytes_per_block = 8;
      narrow_target.info.tile_mode = Prospero::TileMode::kRenderTarget;
      narrow_target.info.mip_layout[0] = {0, 0x10000, 128, 1};
      narrow_target.view_info.format = narrow_target.info.pixel_format;
      narrow_target.view_info.usage = vk::ImageUsageFlagBits::eColorAttachment;
      const auto narrow_target_id = texture_cache.FindImage(narrow_target);
      const auto narrow_target_view =
          texture_cache.FindRenderTarget(narrow_target_id, narrow_target);

      auto wide_target = narrow_target;
      wide_target.info.extent.width = 9;
      const auto wide_target_id = texture_cache.FindImage(wide_target);
      const auto wide_target_view =
          texture_cache.FindRenderTarget(wide_target_id, wide_target);
      const auto wide_owner =
          TextureCacheTestAccess::Owner(texture_cache, wide_target_id);
      Require(name, "equal-allocation render-target growth",
              narrow_target_view != nullptr && wide_target_view != nullptr &&
                  wide_target_id != narrow_target_id &&
                  !TextureCacheTestAccess::Contains(texture_cache,
                                                    narrow_target_id) &&
                  wide_owner != nullptr &&
                  wide_owner->info.extent == vk::Extent3D{9, 1, 1} &&
                  wide_owner->backing.extent == vk::Extent3D{9, 1, 1},
              "a 9x1 render target reused its equal-size 1x1 native backing");

      auto narrow_again = narrow_target;
      const auto narrow_again_id = texture_cache.FindImage(narrow_again);
      Require(name, "larger render-target backing reuse",
              narrow_again_id == wide_target_id &&
                  texture_cache.GetImage(narrow_again_id).backing.extent ==
                      vk::Extent3D{9, 1, 1},
              "a smaller render area replaced its compatible larger backing");

      auto MakeLinearDesc =
          [&](uint64_t address, uint64_t size, vk::Format format,
              Prospero::BufferFormat guest_format, Prospero::ImageType type,
              vk::Extent3D extent, uint32_t layers, uint32_t bytes_per_block,
              uint32_t samples) {
            ImageDesc desc{};
            desc.type = BindingType::Texture;
            desc.info.data = {address, size};
            desc.info.pixel_format = format;
            desc.info.guest_format = guest_format;
            desc.info.type = type;
            desc.info.extent = extent;
            desc.info.resources = {1, layers};
            desc.info.pitch = extent.width;
            desc.info.bytes_per_block = bytes_per_block;
            desc.info.samples = samples;
            desc.info.tile_mode = Prospero::TileMode::kLinear;
            desc.info.mip_layout[0] = {0, size, extent.width, extent.height};
            desc.view_info.format = format;
            if (type == Prospero::ImageType::kColor3D) {
              desc.view_info.type = vk::ImageViewType::e3D;
            } else if (layers > 1) {
              desc.view_info.type = vk::ImageViewType::e2DArray;
            } else {
              desc.view_info.type = vk::ImageViewType::e2D;
            }
            desc.view_info.aspect = vk::ImageAspectFlagBits::eColor;
            desc.view_info.layer_count = layers;
            desc.view_info.usage = vk::ImageUsageFlagBits::eSampled;
            return desc;
          };
      const auto HostReadBarrier = [&](vk::Buffer buffer, uint64_t size,
                                       vk::PipelineStageFlags source_stage,
                                       vk::AccessFlags source_access) {
        vk::BufferMemoryBarrier barrier{};
        barrier.sType = vk::StructureType::eBufferMemoryBarrier;
        barrier.srcAccessMask = source_access;
        barrier.dstAccessMask = vk::AccessFlagBits::eHostRead;
        barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.buffer = buffer;
        barrier.offset = 0;
        barrier.size = size;
        scheduler.Current().Handle().pipelineBarrier(
            source_stage, vk::PipelineStageFlagBits::eHost, {}, 0, nullptr, 1,
            &barrier, 0, nullptr);
      };
      const auto TransferReadBarrier = [&](vk::Buffer buffer, uint64_t size) {
        vk::BufferMemoryBarrier barrier{};
        barrier.sType = vk::StructureType::eBufferMemoryBarrier;
        barrier.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
        barrier.dstAccessMask = vk::AccessFlagBits::eTransferRead;
        barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        barrier.buffer = buffer;
        barrier.offset = 0;
        barrier.size = size;
        scheduler.Current().Handle().pipelineBarrier(
            vk::PipelineStageFlagBits::eTransfer,
            vk::PipelineStageFlagBits::eTransfer, {}, 0, nullptr, 1, &barrier,
            0, nullptr);
      };

      constexpr uint64_t mip_layout_offset = 0x27f0000;
      std::vector<u32> mip_guest(0x2000 / sizeof(u32));
      std::iota(mip_guest.begin(), mip_guest.end(), 0x51000000u);
      ImageId previous{};
      for (const uint32_t width : {32u, 64u, 32u}) {
        if (previous) {
          Require(name, "mip-layout CPU overwrite",
                  resources.HandleFault(PageFaultAccess::Write,
                                        base + mip_layout_offset),
                  "mip-layout guest overwrite did not invalidate the old texture");
        }
        std::memcpy(memory + mip_layout_offset, mip_guest.data(),
                    mip_guest.size() * sizeof(u32));
        TileSurfaceLayout surface{};
        Require(name, "mip-tail layout",
                TileGetTiledTextureLayout(
                    {.format = Prospero::BufferFormat::kBc3Srgb,
                     .tile_mode = Prospero::TileMode::kStandard4KB,
                     .width = width, .height = 64, .levels = 7}, surface) &&
                    surface.first_tail_level == (width == 32 ? 0u : 1u) &&
                    surface.total_size == (width == 32 ? 0x1000u : 0x2000u),
                "BC3 width change did not move mip zero into or out of the tail");
        ImageDesc desc{};
        desc.type = BindingType::Texture;
        desc.info.data = {base + mip_layout_offset, surface.total_size};
        desc.info.pixel_format = vk::Format::eBc3SrgbBlock;
        desc.info.guest_format = Prospero::BufferFormat::kBc3Srgb;
        desc.info.extent = {width, 64, 1};
        desc.info.resources = {7, 1};
        desc.info.pitch = 64;
        desc.info.bytes_per_block = 16;
        desc.info.tile_mode = Prospero::TileMode::kStandard4KB;
        desc.view_info.format = desc.info.pixel_format;
        desc.view_info.type = vk::ImageViewType::e2D;
        desc.view_info.level_count = 7;
        desc.view_info.aspect = vk::ImageAspectFlagBits::eColor;
        desc.view_info.usage = vk::ImageUsageFlagBits::eSampled;
        std::vector<vk::BufferImageCopy> copies;
        std::vector<u32> expected;
        for (uint32_t level = 0; level < 7; level++) {
          const auto &layout = surface.mips[level];
          desc.info.mip_layout[level] = {
              layout.offset, layout.size, layout.padded_width,
              layout.padded_height};
          vk::BufferImageCopy copy{};
          copy.bufferOffset = expected.size() * sizeof(u32);
          copy.imageSubresource = {vk::ImageAspectFlagBits::eColor, level, 0, 1};
          copy.imageExtent = {std::max(width >> level, 1u),
                              std::max(64u >> level, 1u), 1};
          copies.push_back(copy);
          for (uint32_t y = 0; y < layout.height; y++) {
            for (uint32_t x = 0; x < layout.width; x++) {
              uint32_t offset = 0;
              Require(name, "mip-tail CPU address",
                      TileGetBlockOffset(
                          surface.texture.block, x + layout.tail_x,
                          y + layout.tail_y, 0, offset),
                      "BC3 mip-tail block address could not be computed");
              const auto word = (layout.offset + offset) / sizeof(u32);
              expected.insert(expected.end(), mip_guest.begin() + word,
                              mip_guest.begin() + word + 4);
            }
          }
        }
        const auto id = texture_cache.FindImage(desc);
        Require(name, "distinct mip-layout backing", id && id != previous,
                "different guest mip layouts reused the same native image");
        (void)texture_cache.FindTexture(id, desc);
        auto readback = CreateHostBuffer(
            name, expected.size() * sizeof(u32),
            vk::BufferUsageFlagBits::eTransferDst,
            std::vector<u32>(expected.size()));
        texture_cache.GetImage(id).Download(copies, readback.buffer, 0,
                                            readback.size);
        HostReadBarrier(readback.buffer, readback.size,
                        vk::PipelineStageFlagBits::eTransfer,
                        vk::AccessFlagBits::eTransferWrite);
        scheduler.Finish();
        Require(name, "mip-layout GPU contents",
                ReadBuffer(name, readback, expected.size()) == expected,
                "cached native copying contaminated the requested guest mip layout");
        DestroyBuffer(&readback);
        if (width == 64) {
          // Leave only the larger backing so shrinking must reject its layout.
          TextureCacheTestAccess::DeleteImage(texture_cache, previous);
        }
        previous = id;
      }

      // A formatted Buffer read must use the private
      // Exercise the cache-native image-copy path. Use a request larger
      // than the stream shortcut and poison guest backing
      // after upload so stale CPU staging cannot accidentally
      // satisfy the content check.
      constexpr uint64_t mip_prefix_offset = 0x2740000;
      constexpr auto mip_format = Prospero::BufferFormat::k32UInt;
      constexpr auto mip_tile = Prospero::TileMode::kLinear;
      constexpr uint32_t mip_width = 4097;
      constexpr uint32_t mip_height = 1;
      constexpr uint32_t mip_levels = 1;
      const uint32_t mip_pitch =
          TileGetTexturePitch(mip_format, mip_width, mip_tile);
      TileSizeAlign mip_total{};
      std::array<TileSizeOffset, 16> mip_sizes{};
      std::array<TilePaddedSize, 16> mip_padded{};
      TileGetTextureSize(mip_format, mip_width, mip_height, mip_levels,
                         mip_tile, &mip_total, mip_sizes.data(),
                         mip_padded.data());
      const uint64_t mip_prefix_size = mip_sizes[0].offset + mip_sizes[0].size;
      const uint64_t mip_guest_size = mip_total.size + 256;
      Require(name, "formatted mip fixture",
              mip_sizes[0].offset == 0 &&
                  mip_prefix_size > BufferCache::CACHING_PAGESIZE &&
                  mip_prefix_size < mip_guest_size &&
                  mip_guest_size % sizeof(uint32_t) == 0,
              "single-mip fixture did not expose a cache-sized fitting backing "
              "prefix");
      std::vector<uint32_t> mip_native(mip_guest_size / sizeof(uint32_t));
      std::iota(mip_native.begin(), mip_native.end(), 0x61000000u);
      std::memcpy(memory + mip_prefix_offset, mip_native.data(),
                  mip_guest_size);
      auto mip_desc = MakeLinearDesc(
          base + mip_prefix_offset, mip_guest_size, vk::Format::eR32Uint,
          mip_format, Prospero::ImageType::kColor2D, {mip_width, mip_height, 1},
          1, sizeof(uint32_t), 1);
      mip_desc.info.resources.levels = mip_levels;
      mip_desc.info.pitch = mip_pitch;
      mip_desc.view_info.level_count = mip_levels;
      for (uint32_t level = 0; level < mip_levels; level++) {
        mip_desc.info.mip_layout[level] = {
            mip_sizes[level].offset, mip_sizes[level].size,
            mip_padded[level].width, mip_padded[level].height};
      }
      const auto mip_image = texture_cache.FindImage(mip_desc);
      (void)texture_cache.FindTexture(mip_image, mip_desc);
      texture_cache.MarkGpuWritten(mip_image);
      std::vector<uint32_t> mip_stale(mip_native.size(), 0xdeadbeefu);
      Libs::LibKernel::Memory::WriteBacking(base + mip_prefix_offset,
                                            mip_stale.data(), mip_guest_size);

      Libs::Graphics::Buffer mip_insufficient(
          m_runtime_context, scheduler, MemoryUsage::DeviceLocal,
          mip_desc.info.data.address, AllFlags, mip_prefix_size - 1);
      Libs::Graphics::Buffer mip_prefix(
          m_runtime_context, scheduler, MemoryUsage::DeviceLocal,
          mip_desc.info.data.address, AllFlags, mip_prefix_size);
      Require(name, "formatted mip containment",
              !BufferCacheTestAccess::SynchronizeBufferFromImage(
                  resources.GetBufferCache(), mip_insufficient,
                  mip_desc.info.data.address, mip_prefix_size - 1) &&
                  BufferCacheTestAccess::SynchronizeBufferFromImage(
                      resources.GetBufferCache(), mip_prefix,
                      mip_desc.info.data.address, mip_prefix_size) &&
                  texture_cache.GetImage(mip_image).IsGpuModified(),
              "image synchronization accepted a partial first "
              "mip, rejected a fitting mip "
              "prefix, or transferred ownership");

      auto &buffer_cache = resources.GetBufferCache();
      std::pair<Libs::Graphics::Buffer *, uint64_t> mip_formatted;
      bool formatted_owner_was_absent = false;
      gpu.SendCommandSync([&] {
        formatted_owner_was_absent = !buffer_cache.IsRegionRegistered(
            mip_desc.info.data.address, mip_desc.info.data.size);
        mip_formatted = buffer_cache.ObtainBuffer(
            mip_desc.info.data.address, mip_desc.info.data.size, false, true);
      });
      Require(name, "formatted cache fixture", formatted_owner_was_absent,
              "formatted image already had a cached Buffer owner");
      Require(name, "formatted Buffer path",
              mip_formatted.first != nullptr &&
                  texture_cache.GetImage(mip_image).IsGpuModified(),
              "formatted read bypassed the cached image-copy "
              "path or transferred ownership");
      auto mip_prefix_readback = CreateHostBuffer(
          name, mip_prefix_size, vk::BufferUsageFlagBits::eTransferDst,
          std::vector<u32>(mip_prefix_size / sizeof(uint32_t), 0));
      auto mip_formatted_readback = CreateHostBuffer(
          name, mip_guest_size, vk::BufferUsageFlagBits::eTransferDst,
          std::vector<u32>(mip_guest_size / sizeof(uint32_t), 0));
      TransferReadBarrier(mip_prefix.Handle(), mip_prefix_size);
      const vk::BufferCopy mip_prefix_copy{0, 0, mip_prefix_size};
      command.Handle().copyBuffer(
          mip_prefix.Handle(), mip_prefix_readback.buffer, 1, &mip_prefix_copy);
      TransferReadBarrier(mip_formatted.first->Handle(), mip_guest_size);
      const vk::BufferCopy mip_formatted_copy{mip_formatted.second, 0,
                                              mip_guest_size};
      command.Handle().copyBuffer(mip_formatted.first->Handle(),
                                  mip_formatted_readback.buffer, 1,
                                  &mip_formatted_copy);
      HostReadBarrier(mip_prefix_readback.buffer, mip_prefix_readback.size,
                      vk::PipelineStageFlagBits::eTransfer,
                      vk::AccessFlagBits::eTransferWrite);
      HostReadBarrier(mip_formatted_readback.buffer,
                      mip_formatted_readback.size,
                      vk::PipelineStageFlagBits::eTransfer,
                      vk::AccessFlagBits::eTransferWrite);
      const std::array<uint32_t, 2> volume_values{0x10203040u, 0x50607080u};
      TileSizeAlign volume_size{};
      TileGetTextureTotalSize(Prospero::BufferFormat::k32UInt, 1, 1, 2, 1,
                              Prospero::TileMode::kLinear, true, volume_size);
      const auto volume_pitch = TileGetTexturePitch(
          Prospero::BufferFormat::k32UInt, 1, Prospero::TileMode::kLinear);
      const auto volume_slice_words = volume_size.size / 2 / sizeof(uint32_t);
      std::vector<uint32_t> volume_guest(volume_size.size / sizeof(uint32_t));
      volume_guest[0] = volume_values[0];
      volume_guest[volume_slice_words] = volume_values[1];
      std::memcpy(memory + 0x1000, volume_guest.data(), volume_size.size);
      auto array_desc =
          MakeLinearDesc(base + 0x1000, volume_size.size,
                         vk::Format::eR32Uint, Prospero::BufferFormat::k32UInt,
                         Prospero::ImageType::kColor2D, {1, 1, 1}, 2, 4, 1);
      array_desc.info.pitch = volume_pitch;
      array_desc.info.mip_layout[0].pitch = volume_pitch;
      const auto array_image = texture_cache.FindImage(array_desc);
      (void)texture_cache.FindTexture(array_image, array_desc);
      texture_cache.MarkGpuWritten(array_image);
      auto volume_desc = array_desc;
      volume_desc.info.type = Prospero::ImageType::kColor3D;
      volume_desc.info.extent = {1, 1, 2};
      volume_desc.info.resources.layers = 1;
      volume_desc.view_info.type = vk::ImageViewType::e3D;
      volume_desc.view_info.layer_count = 1;
      const auto volume_image = texture_cache.FindImage(volume_desc);
      Require(name, "2D-array/3D overlap copy",
              volume_image && volume_image != array_image &&
                  texture_cache.GetImage(volume_image).backing.image_type ==
                      vk::ImageType::e3D &&
                  texture_cache.GetImage(volume_image).IsGpuModified(),
              "array-to-volume expansion lost slices or GPU "
              "ownership");

      constexpr uint64_t unique_volume_offset = 0x27b0000;
      std::memcpy(memory + unique_volume_offset, volume_guest.data(),
                  volume_size.size);
      auto unique_volume_desc = volume_desc;
      unique_volume_desc.info.data.address = base + unique_volume_offset;
      const auto unique_volume_image =
          texture_cache.FindImage(unique_volume_desc);
      (void)texture_cache.FindTexture(unique_volume_image, unique_volume_desc);
      texture_cache.MarkGpuWritten(unique_volume_image);
      Libs::Graphics::Buffer partial_volume(
          m_runtime_context, scheduler, MemoryUsage::DeviceLocal,
          unique_volume_desc.info.data.address, AllFlags,
          unique_volume_desc.info.data.size - sizeof(uint32_t));
      Libs::Graphics::Buffer full_volume(
          m_runtime_context, scheduler, MemoryUsage::DeviceLocal,
          unique_volume_desc.info.data.address, AllFlags,
          unique_volume_desc.info.data.size);
      Require(name, "formatted volume containment",
              !BufferCacheTestAccess::SynchronizeBufferFromImage(
                  resources.GetBufferCache(), partial_volume,
                  unique_volume_desc.info.data.address,
                  unique_volume_desc.info.data.size - sizeof(uint32_t)) &&
                  BufferCacheTestAccess::SynchronizeBufferFromImage(
                      resources.GetBufferCache(), full_volume,
                      unique_volume_desc.info.data.address,
                      unique_volume_desc.info.data.size) &&
                  texture_cache.GetImage(unique_volume_image).IsGpuModified(),
              "partial 3D synchronization was accepted, "
              "full-volume synchronization was "
              "rejected, or ownership changed");
      auto volume_readback = CreateHostBuffer(
          name, volume_size.size, vk::BufferUsageFlagBits::eTransferDst,
          std::vector<u32>(volume_guest.size(), 0));
      TransferReadBarrier(full_volume.Handle(), volume_size.size);
      const vk::BufferCopy volume_copy{0, 0, volume_size.size};
      command.Handle().copyBuffer(full_volume.Handle(), volume_readback.buffer,
                                  1, &volume_copy);
      HostReadBarrier(volume_readback.buffer, volume_readback.size,
                      vk::PipelineStageFlagBits::eTransfer,
                      vk::AccessFlagBits::eTransferWrite);

      constexpr uint64_t depth_containment_offset = 0x27c0000;
      constexpr std::array<float, 3> depth_containment_values{0.25f, 0.75f,
                                                              0.5f};
      std::memcpy(memory + depth_containment_offset,
                  depth_containment_values.data(),
                  sizeof(depth_containment_values));
      auto depth_containment = MakeLinearDesc(
          base + depth_containment_offset, sizeof(depth_containment_values),
          vk::Format::eD32Sfloat, Prospero::BufferFormat::k32Float,
          Prospero::ImageType::kColor2D, {2, 1, 1}, 1, sizeof(float), 1);
      depth_containment.type = BindingType::DepthTarget;
      depth_containment.info.resources.levels = 2;
      depth_containment.info.mip_layout[0] = {0, 2 * sizeof(float), 2, 1};
      depth_containment.info.mip_layout[1] = {2 * sizeof(float), sizeof(float),
                                              1, 1};
      depth_containment.view_info.format = vk::Format::eD32Sfloat;
      depth_containment.view_info.aspect = vk::ImageAspectFlagBits::eDepth;
      depth_containment.view_info.usage =
          vk::ImageUsageFlagBits::eDepthStencilAttachment;
      depth_containment.view_info.level_count = 2;
      const auto depth_containment_image =
          texture_cache.FindImage(depth_containment);
      (void)texture_cache.FindDepthTarget(depth_containment_image,
                                          depth_containment);
      texture_cache.MarkGpuWritten(depth_containment_image);
      Libs::Graphics::Buffer partial_depth(
          m_runtime_context, scheduler, MemoryUsage::DeviceLocal,
          depth_containment.info.data.address, AllFlags,
          depth_containment.info.mip_layout[0].size);
      Require(
          name, "formatted depth containment",
          !BufferCacheTestAccess::SynchronizeBufferFromImage(
              resources.GetBufferCache(), partial_depth,
              depth_containment.info.data.address,
              depth_containment.info.mip_layout[0].size) &&
              texture_cache.GetImage(depth_containment_image).IsGpuModified(),
          "partial depth synchronization was accepted or "
          "transferred ownership");

      constexpr uint64_t raw_d16_offset = 0x27d0000;
      constexpr std::array<uint16_t, 2> raw_d16_values{0x2000u, 0xc000u};
      std::memcpy(memory + raw_d16_offset, raw_d16_values.data(),
                  sizeof(raw_d16_values));
      auto raw_d16 = MakeLinearDesc(
          base + raw_d16_offset, sizeof(raw_d16_values), vk::Format::eD16Unorm,
          Prospero::BufferFormat::k16UNorm, Prospero::ImageType::kColor2D,
          {2, 1, 1}, 1, sizeof(uint16_t), 1);
      raw_d16.type = BindingType::DepthTarget;
      raw_d16.view_info.format = vk::Format::eD16Unorm;
      raw_d16.view_info.aspect = vk::ImageAspectFlagBits::eDepth;
      raw_d16.view_info.usage = vk::ImageUsageFlagBits::eDepthStencilAttachment;
      const auto raw_d16_image = texture_cache.FindImage(raw_d16);
      (void)texture_cache.FindDepthTarget(raw_d16_image, raw_d16);

      auto raw_d16_uint = raw_d16;
      raw_d16_uint.type = BindingType::Texture;
      raw_d16_uint.info.pixel_format = vk::Format::eR16Uint;
      raw_d16_uint.info.guest_format = Prospero::BufferFormat::k16UInt;
      raw_d16_uint.view_info.format = vk::Format::eR16Uint;
      raw_d16_uint.view_info.aspect = vk::ImageAspectFlagBits::eColor;
      raw_d16_uint.view_info.usage = vk::ImageUsageFlagBits::eSampled;
      const auto raw_d16_uint_image = texture_cache.FindImage(raw_d16_uint);
      Require(
          name, "raw D16 uint texture backing",
          raw_d16_uint_image && raw_d16_uint_image != raw_d16_image &&
              !TextureCacheTestAccess::Contains(texture_cache, raw_d16_image) &&
              texture_cache.GetImage(raw_d16_uint_image).backing.format ==
                  vk::Format::eR16Uint,
          "D16 uint sampling did not recreate a true integer color backing");
      Require(name, "raw D16 uint texture view",
              texture_cache.FindTexture(raw_d16_uint_image, raw_d16_uint) !=
                  nullptr,
              "D16 uint sampling did not create an integer sampled view");

      constexpr uint64_t layered_raw_d16_offset = raw_d16_offset + 0x1000;
      constexpr std::array<uint16_t, 12> layered_raw_d16_values{
          0x0102u, 0x0304u, 0x1112u, 0x1314u, 0x2122u, 0x2324u,
          0x3132u, 0x3334u, 0x4142u, 0x4344u, 0x5152u, 0x5354u};
      std::memcpy(memory + layered_raw_d16_offset,
                  layered_raw_d16_values.data(),
                  sizeof(layered_raw_d16_values));
      auto layered_d16_color = MakeLinearDesc(
          base + layered_raw_d16_offset, sizeof(layered_raw_d16_values),
          vk::Format::eR16Unorm, Prospero::BufferFormat::k16UNorm,
          Prospero::ImageType::kColor2D, {2, 1, 1}, 6, sizeof(uint16_t), 1);
      const auto layered_d16_color_image =
          texture_cache.FindImage(layered_d16_color);
      (void)texture_cache.FindTexture(layered_d16_color_image,
                                      layered_d16_color);
      auto &layered_d16_color_native =
          texture_cache.GetImage(layered_d16_color_image);
      layered_d16_color_native.Transit(vk::ImageLayout::eTransferDstOptimal,
                                       vk::AccessFlagBits2::eTransferWrite, {},
                                       scheduler.Current().Handle());
      vk::ClearColorValue layered_raw_d16_clear_value{};
      layered_raw_d16_clear_value.float32[0] = 1.0f;
      const vk::ImageSubresourceRange layered_raw_d16_clear_range{
          vk::ImageAspectFlagBits::eColor, 0, 1, 0, 6};
      scheduler.Current().Handle().clearColorImage(
          layered_d16_color_native.backing.image,
          vk::ImageLayout::eTransferDstOptimal, &layered_raw_d16_clear_value, 1,
          &layered_raw_d16_clear_range);
      texture_cache.MarkGpuWritten(layered_d16_color_image);

      auto layered_raw_d16_depth = layered_d16_color;
      layered_raw_d16_depth.type = BindingType::DepthTarget;
      layered_raw_d16_depth.info.data.size = sizeof(uint16_t) * 2 * 5;
      layered_raw_d16_depth.info.pixel_format = vk::Format::eD16Unorm;
      layered_raw_d16_depth.info.guest_format =
          Prospero::BufferFormat::k16UNorm;
      layered_raw_d16_depth.info.resources.layers = 5;
      layered_raw_d16_depth.info.mip_layout[0].size =
          layered_raw_d16_depth.info.data.size;
      layered_raw_d16_depth.view_info.format = vk::Format::eD16Unorm;
      layered_raw_d16_depth.view_info.aspect = vk::ImageAspectFlagBits::eDepth;
      layered_raw_d16_depth.view_info.layer_count = 5;
      layered_raw_d16_depth.view_info.usage =
          vk::ImageUsageFlagBits::eDepthStencilAttachment;
      const auto layered_raw_d16_depth_image =
          texture_cache.FindImage(layered_raw_d16_depth);
      const auto &layered_depth_owner =
          texture_cache.GetImage(layered_raw_d16_depth_image);
      Require(name, "layered raw D16 owner layout",
              layered_raw_d16_depth_image != layered_d16_color_image &&
                  !TextureCacheTestAccess::Contains(texture_cache,
                                                    layered_d16_color_image) &&
                  layered_depth_owner.info.resources.layers == 6 &&
                  layered_depth_owner.info.data.size ==
                      sizeof(layered_raw_d16_values) &&
                  layered_depth_owner.info.mip_layout[0].size ==
                      sizeof(layered_raw_d16_values),
              "a partial depth view detached the retained six-layer owner from "
              "its full guest range");
      (void)texture_cache.FindDepthTarget(layered_raw_d16_depth_image,
                                          layered_raw_d16_depth);

      auto reacquired_layered_raw_d16_uint = layered_d16_color;
      reacquired_layered_raw_d16_uint.info.pixel_format = vk::Format::eR16Uint;
      reacquired_layered_raw_d16_uint.info.guest_format =
          Prospero::BufferFormat::k16UInt;
      reacquired_layered_raw_d16_uint.view_info.format = vk::Format::eR16Uint;
      const auto reacquired_layered_raw_d16_uint_image =
          texture_cache.FindImage(reacquired_layered_raw_d16_uint);
      const auto reacquired_layered_raw_d16_uint_view =
          texture_cache.FindTexture(reacquired_layered_raw_d16_uint_image,
                                    reacquired_layered_raw_d16_uint);
      auto layered_raw_d16_readback = CreateHostBuffer(
          name, sizeof(layered_raw_d16_values),
          vk::BufferUsageFlagBits::eTransferDst, std::vector<u32>(6, 0));
      auto &reacquired_layered_raw_d16_native =
          texture_cache.GetImage(reacquired_layered_raw_d16_uint_image);
      reacquired_layered_raw_d16_native.Transit(
          vk::ImageLayout::eTransferSrcOptimal,
          vk::AccessFlagBits2::eTransferRead, {}, scheduler.Current().Handle());
      vk::BufferImageCopy layered_raw_d16_copy{};
      layered_raw_d16_copy.bufferRowLength = 2;
      layered_raw_d16_copy.imageSubresource = {vk::ImageAspectFlagBits::eColor,
                                               0, 0, 6};
      layered_raw_d16_copy.imageExtent = {2, 1, 1};
      scheduler.Current().Handle().copyImageToBuffer(
          reacquired_layered_raw_d16_native.backing.image,
          vk::ImageLayout::eTransferSrcOptimal, layered_raw_d16_readback.buffer,
          1, &layered_raw_d16_copy);
      HostReadBarrier(layered_raw_d16_readback.buffer,
                      layered_raw_d16_readback.size,
                      vk::PipelineStageFlagBits::eTransfer,
                      vk::AccessFlagBits::eTransferWrite);
      scheduler.Finish();
      const auto layered_raw_d16_words =
          ReadBuffer(name, layered_raw_d16_readback, 6);
      std::array<uint16_t, 12> layered_raw_d16_after{};
      std::memcpy(layered_raw_d16_after.data(), layered_raw_d16_words.data(),
                  sizeof(layered_raw_d16_after));
      std::array<uint16_t, 12> layered_raw_d16_expected{};
      layered_raw_d16_expected.fill(UINT16_MAX);
      Require(
          name, "layered raw D16 round trip",
          reacquired_layered_raw_d16_uint_image &&
              reacquired_layered_raw_d16_uint_image !=
                  layered_raw_d16_depth_image &&
              !TextureCacheTestAccess::Contains(texture_cache,
                                                layered_raw_d16_depth_image) &&
              reacquired_layered_raw_d16_native.backing.format ==
                  vk::Format::eR16Uint &&
              reacquired_layered_raw_d16_uint_view != nullptr &&
              layered_raw_d16_after == layered_raw_d16_expected,
          "the partial depth view lost a layer or failed to restore raw UINT "
          "sampling");
      DestroyBuffer(&layered_raw_d16_readback);

      auto native_array_info = array_desc.info;
      native_array_info.data = {};
      auto native_volume_info = volume_desc.info;
      native_volume_info.data = {};
      Libs::Graphics::Image native_array(m_runtime_context, scheduler,
                                         native_array_info);
      Libs::Graphics::Image native_volume(m_runtime_context, scheduler,
                                          native_volume_info);
      native_volume.CopyImage(native_array);
      native_array.CopyImage(native_volume);
      Require(name, "Image-owned 2D-array/3D copy state",
              native_volume.backing.state.layout ==
                      vk::ImageLayout::eTransferSrcOptimal &&
                  native_volume.backing.state.access_mask ==
                      vk::AccessFlagBits2::eTransferRead &&
                  native_array.backing.state.layout ==
                      vk::ImageLayout::eGeneral &&
                  native_array.backing.state.access_mask ==
                      (vk::AccessFlagBits2::eShaderRead |
                       vk::AccessFlagBits2::eTransferRead),
              "Image::CopyImage did not retain pinned "
              "source/destination states");

      ImageInfo resolve_source_info{};
      resolve_source_info.pixel_format = vk::Format::eR8G8B8A8Unorm;
      resolve_source_info.guest_format = Prospero::BufferFormat::k8_8_8_8UNorm;
      resolve_source_info.type = Prospero::ImageType::kColor2D;
      resolve_source_info.extent = {4, 4, 1};
      resolve_source_info.resources = {1, 1};
      resolve_source_info.pitch = 4;
      resolve_source_info.bytes_per_block = 4;
      resolve_source_info.samples = 2;
      resolve_source_info.tile_mode = Prospero::TileMode::kRenderTarget;
      ImageInfo resolve_destination_info = resolve_source_info;
      resolve_destination_info.type = Prospero::ImageType::kColor2D;
      resolve_destination_info.samples = 1;
      Libs::Graphics::Image resolve_source(m_runtime_context, scheduler,
                                           resolve_source_info);
      Libs::Graphics::Image resolve_destination(m_runtime_context, scheduler,
                                                resolve_destination_info);
      resolve_destination.Resolve(resolve_source, {}, {});
      Require(
          name, "Image-owned MSAA resolve",
          resolve_source.backing.state.layout ==
                  vk::ImageLayout::eTransferSrcOptimal &&
              resolve_destination.backing.state.layout ==
                  vk::ImageLayout::eTransferDstOptimal,
          "Image::Resolve did not issue the MSAA-to-single-sample transfer");
      Libs::Graphics::Image copy_destination(m_runtime_context, scheduler,
                                             resolve_destination_info);
      copy_destination.Resolve(resolve_destination, {}, {});
      Require(name, "Image-owned single-sample resolve copy",
              resolve_destination.backing.state.layout ==
                      vk::ImageLayout::eTransferSrcOptimal &&
                  copy_destination.backing.state.layout ==
                      vk::ImageLayout::eTransferDstOptimal,
              "Image::Resolve did not retain the single-sample copy path");

      const std::array<uint16_t, 2> multisample_source{0x4000u, 0xc000u};
      std::memcpy(memory + 0x2000, &multisample_source,
                  sizeof(multisample_source));
      auto color_desc = MakeLinearDesc(
          base + 0x2000, sizeof(multisample_source), vk::Format::eR16G16Unorm,
          Prospero::BufferFormat::k16_16UNorm, Prospero::ImageType::kColor2D,
          {1, 1, 1}, 1, 4, 1);
      const auto color_image = texture_cache.FindImage(color_desc);
      (void)texture_cache.FindTexture(color_image, color_desc);
      texture_cache.MarkGpuWritten(color_image);
      const std::array<uint16_t, 2> refreshed_multisample_source{0x2000u,
                                                                 0xe000u};
      Require(name, "unequal-sample source CPU write",
              resources.HandleFault(PageFaultAccess::Write,
                                    color_desc.info.data.address),
              "color-to-MS-depth source did not accept a CPU update");
      std::memcpy(memory + 0x2000, refreshed_multisample_source.data(),
                  sizeof(refreshed_multisample_source));
      constexpr uint64_t ms_stencil_offset = 0x80000;
      constexpr uint64_t ms_stencil_size = 0x10000;
      auto ms_stencil_owner = resources.GetBufferCache().ObtainBuffer(
          base + ms_stencil_offset, ms_stencil_size, false);
      Require(name, "MS stencil buffer allocation",
              ms_stencil_owner.first != nullptr,
              "failed to create an unequal-sample stencil source");
      resources.GetBufferCache().FillBuffer(
          base + ms_stencil_offset, ms_stencil_size, 0x41414141u, false);
      auto ms_depth_desc = color_desc;
      ms_depth_desc.type = BindingType::DepthTarget;
      ms_depth_desc.info.stencil = {base + ms_stencil_offset, ms_stencil_size};
      ms_depth_desc.info.pixel_format = vk::Format::eD24UnormS8Uint;
      ms_depth_desc.info.guest_format = Prospero::BufferFormat::k16UNorm;
      ms_depth_desc.info.bytes_per_block = 2;
      ms_depth_desc.info.samples = 2;
      ms_depth_desc.info.type = Prospero::ImageType::kColor2D;
      ms_depth_desc.view_info.format = vk::Format::eD24UnormS8Uint;
      ms_depth_desc.view_info.aspect =
          vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil;
      ms_depth_desc.view_info.usage =
          vk::ImageUsageFlagBits::eDepthStencilAttachment;
      const auto ms_depth_image = texture_cache.FindImage(ms_depth_desc);
      constexpr uint64_t ms_htile_address = base + 0x2600000;
      constexpr uint64_t ms_htile_size = 0x10000;
      ms_depth_desc.info.metadata.range = {ms_htile_address, ms_htile_size};
      ms_depth_desc.info.metadata.kind = ImageMetadataKind::Htile;
      const auto ms_depth_with_htile = texture_cache.FindImage(ms_depth_desc);
      const auto ms_depth_view =
          texture_cache.FindDepthTarget(ms_depth_with_htile, ms_depth_desc);
      auto sampled_ms_depth = ms_depth_desc;
      sampled_ms_depth.type = BindingType::Texture;
      sampled_ms_depth.info.metadata = {};
      sampled_ms_depth.view_info.usage = vk::ImageUsageFlagBits::eSampled;
      const auto sampled_ms_depth_image =
          texture_cache.FindImage(sampled_ms_depth);
      Require(
          name, "unequal-sample depth overlap",
          ms_depth_image && ms_depth_with_htile == ms_depth_image &&
              sampled_ms_depth_image == ms_depth_image &&
              ms_depth_image != color_image && ms_depth_view != nullptr &&
              texture_cache.GetImage(ms_depth_image).backing.samples == 2 &&
              texture_cache.GetImage(ms_depth_image).backing.state.layout ==
                  vk::ImageLayout::eDepthStencilAttachmentOptimal &&
              texture_cache.GetImage(ms_depth_image).IsGpuModified() &&
              texture_cache.GetImage(ms_depth_image).info.htile_clear_mask ==
                  0 &&
              texture_cache.GetImage(ms_depth_image).info.metadata.range ==
                  ms_depth_desc.info.metadata.range &&
              texture_cache.IsMeta(ms_htile_address) &&
              !texture_cache.IsMetaCleared(ms_htile_address, 0) &&
              !resources.GetBufferCache().HasGpuDirtyBytes(
                  base + ms_stencil_offset, ms_stencil_size) &&
              !texture_cache.IsRegionGpuModified(base + ms_stencil_offset,
                                                 ms_stencil_size),
          "unequal-sample overlap did not run the color-to-MS-depth pass "
          "without manufacturing stencil ownership");
      auto &oversized_ms = texture_cache.GetImage(ms_depth_image);
      const auto ms_data_size = oversized_ms.info.data.size;
      oversized_ms.info.data.size = (32ull << 20) + 4;
      const bool oversized_ms_readback =
          !TextureCacheTestAccess::TryDownload(texture_cache, ms_depth_image);
      oversized_ms.info.data.size = ms_data_size;
      Require(name, "oversized multisample download rejection",
              oversized_ms_readback && oversized_ms.IsGpuModified() &&
                  !oversized_ms.IsBufferModified() &&
                  !resources.GetBufferCache().HasGpuDirtyBytes(
                      ms_depth_desc.info.data.address, ms_data_size),
              "an unsupported multisample source reserved download storage or "
              "published Buffer ownership");

      const std::array<uint16_t, 4> multisample_source_4x{0x0000u, 0x4000u,
                                                          0x8000u, 0xffffu};
      std::memcpy(memory + 0x7000, multisample_source_4x.data(),
                  sizeof(multisample_source_4x));
      auto color_desc_4x =
          MakeLinearDesc(base + 0x7000, sizeof(multisample_source_4x),
                         vk::Format::eR16G16B16A16Unorm,
                         Prospero::BufferFormat::k16_16_16_16UNorm,
                         Prospero::ImageType::kColor2D, {1, 1, 1}, 1, 8, 1);
      const auto color_image_4x = texture_cache.FindImage(color_desc_4x);
      auto ms_depth_desc_4x = color_desc_4x;
      ms_depth_desc_4x.type = BindingType::DepthTarget;
      ms_depth_desc_4x.info.pixel_format = vk::Format::eD16Unorm;
      ms_depth_desc_4x.info.guest_format = Prospero::BufferFormat::k16UNorm;
      ms_depth_desc_4x.info.bytes_per_block = 2;
      ms_depth_desc_4x.info.samples = 4;
      ms_depth_desc_4x.info.type = Prospero::ImageType::kColor2D;
      ms_depth_desc_4x.view_info.format = vk::Format::eD16Unorm;
      ms_depth_desc_4x.view_info.aspect = vk::ImageAspectFlagBits::eDepth;
      ms_depth_desc_4x.view_info.usage =
          vk::ImageUsageFlagBits::eDepthStencilAttachment;
      const auto ms_depth_image_4x = texture_cache.FindImage(ms_depth_desc_4x);
      Require(name, "four-sample depth overlap",
              ms_depth_image_4x && ms_depth_image_4x != color_image_4x &&
                  texture_cache.GetImage(ms_depth_image_4x).backing.samples ==
                      4,
              "four-sample color packing did not produce a depth image");

      const auto ms_depth_backing =
          texture_cache.GetImage(ms_depth_image).backing.image;
      const auto first_stencil_association = texture_cache.FindImageFromRange(
          base + ms_stencil_offset, ms_stencil_size, false);
      Require(
          name, "stencil association shape",
          first_stencil_association &&
              first_stencil_association != ms_depth_image &&
              texture_cache.GetImage(first_stencil_association)
                      .info.pixel_format == vk::Format::eUndefined &&
              texture_cache.GetImage(first_stencil_association).backing.image ==
                  nullptr &&
              texture_cache.GetImage(first_stencil_association).depth_id ==
                  ms_depth_image,
          "stencil address did not create a lightweight depth association");
      Require(
          name, "stencil association download rejection",
          !TextureCacheTestAccess::TryDownload(texture_cache,
                                               first_stencil_association),
          "a lightweight stencil association entered image download planning");

      auto exact_ms_depth_alias = ms_depth_desc;
      exact_ms_depth_alias.type = BindingType::Texture;
      exact_ms_depth_alias.info.stencil = {};
      exact_ms_depth_alias.info.pixel_format = vk::Format::eR8G8B8A8Unorm;
      exact_ms_depth_alias.info.guest_format =
          Prospero::BufferFormat::k8_8_8_8UNorm;
      exact_ms_depth_alias.info.bytes_per_block = 4;
      exact_ms_depth_alias.view_info.format = vk::Format::eR8G8B8A8Unorm;
      exact_ms_depth_alias.view_info.aspect = vk::ImageAspectFlagBits::eColor;
      exact_ms_depth_alias.view_info.usage = vk::ImageUsageFlagBits::eSampled;
      const auto exact_ms_depth_image =
          texture_cache.FindImage(exact_ms_depth_alias, true);
      Require(
          name, "exact multisample depth/stencil coexistence",
          exact_ms_depth_image && exact_ms_depth_image != ms_depth_image &&
              TextureCacheTestAccess::Contains(texture_cache, ms_depth_image) &&
              texture_cache.GetImage(ms_depth_image).backing.image ==
                  ms_depth_backing &&
              texture_cache.GetImage(first_stencil_association).depth_id ==
                  ms_depth_image,
          "exact multisample depth/stencil lookup replaced the old image "
          "or stole its stencil association");

      constexpr uint64_t second_stencil_offset = 0x90000;
      auto stencil_storage_desc = MakeLinearDesc(
          base + second_stencil_offset, ms_stencil_size, vk::Format::eR8Uint,
          Prospero::BufferFormat::k8UInt, Prospero::ImageType::kColor2D,
          ms_depth_desc.info.extent, 1, 1, 1);
      stencil_storage_desc.type = BindingType::Storage;
      stencil_storage_desc.view_info.usage = vk::ImageUsageFlagBits::eStorage;
      const auto stencil_storage_image =
          texture_cache.FindImage(stencil_storage_desc);
      (void)texture_cache.FindTexture(stencil_storage_image,
                                      stencil_storage_desc);
      auto switched_ms_depth = ms_depth_desc;
      switched_ms_depth.info.stencil = {base + second_stencil_offset,
                                        ms_stencil_size};
      const auto switched_ms_depth_id =
          texture_cache.FindImage(switched_ms_depth);
      TextureCacheTestAccess::AssociateStencil(
          texture_cache, switched_ms_depth_id, switched_ms_depth.info.stencil);
      const auto second_stencil_association = texture_cache.FindImageFromRange(
          base + second_stencil_offset, ms_stencil_size, false);
      Require(name, "stencil association switch",
              switched_ms_depth_id == ms_depth_image &&
                  texture_cache.GetImage(switched_ms_depth_id).backing.image ==
                      ms_depth_backing &&
                  texture_cache.FindImageFromRange(base + ms_stencil_offset,
                                                   ms_stencil_size, false) ==
                      first_stencil_association &&
                  texture_cache.GetImage(first_stencil_association).depth_id ==
                      ms_depth_image &&
                  second_stencil_association &&
                  second_stencil_association == stencil_storage_image &&
                  texture_cache.GetImage(second_stencil_association).IsTracked() &&
                  texture_cache.GetImage(second_stencil_association).depth_id ==
                      ms_depth_image,
              "changing stencil address recreated depth or discarded an "
              "existing lightweight association");
      Require(name, "CPU write to tracked stencil association",
              resources.HandleFault(PageFaultAccess::Write,
                                    base + second_stencil_offset) &&
                  !texture_cache.GetImage(second_stencil_association).IsTracked() &&
                  texture_cache.GetImage(second_stencil_association).IsCpuDirty() &&
                  texture_cache.GetImage(second_stencil_association).depth_id ==
                      ms_depth_image,
              "CPU invalidation left a reused stencil image write-protected");
      memory[second_stencil_offset] = 0x5a;

      constexpr uint64_t added_stencil_depth_offset = 0x60000;
      constexpr uint64_t added_stencil_offset = 0x70000;
      constexpr uint64_t added_stencil_size = 0x10000;
      constexpr float added_stencil_depth_value = 0.75f;
      std::memcpy(memory + added_stencil_depth_offset,
                  &added_stencil_depth_value,
                  sizeof(added_stencil_depth_value));
      auto depth_only_source = MakeLinearDesc(
          base + added_stencil_depth_offset, 0x10000, vk::Format::eD32Sfloat,
          Prospero::BufferFormat::k32Float, Prospero::ImageType::kColor2D,
          {1, 1, 1}, 1, 4, 1);
      depth_only_source.type = BindingType::DepthTarget;
      depth_only_source.view_info.format = vk::Format::eD32Sfloat;
      depth_only_source.view_info.aspect = vk::ImageAspectFlagBits::eDepth;
      depth_only_source.view_info.usage =
          vk::ImageUsageFlagBits::eDepthStencilAttachment;
      const auto depth_only_source_image =
          texture_cache.FindImage(depth_only_source);

      auto combined_destination = depth_only_source;
      combined_destination.info.stencil = {base + added_stencil_offset,
                                           added_stencil_size};
      combined_destination.info.pixel_format = vk::Format::eD32SfloatS8Uint;
      combined_destination.view_info.format = vk::Format::eD32SfloatS8Uint;
      combined_destination.view_info.aspect =
          vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil;
      const auto combined_destination_image =
          texture_cache.FindImage(combined_destination);
      TextureCacheTestAccess::AssociateStencil(
          texture_cache, combined_destination_image,
          combined_destination.info.stencil);
      const auto combined_stencil_association =
          texture_cache.FindImageFromRange(base + added_stencil_offset,
                                           added_stencil_size, false);
      Require(
          name, "depth-only to combined association",
          combined_destination_image != depth_only_source_image &&
              combined_stencil_association &&
              texture_cache.GetImage(combined_stencil_association).depth_id ==
                  combined_destination_image &&
              texture_cache.GetImage(combined_stencil_association)
                      .backing.image == nullptr,
          "stencil addition did not recreate depth and register its "
          "lightweight association");

      const uint32_t mirror_value = 0xa1b2c3d4u;
      std::memcpy(memory + 0x5000, &mirror_value, sizeof(mirror_value));
      auto mirror_desc =
          MakeLinearDesc(base + 0x5000, sizeof(mirror_value),
                         vk::Format::eR32Uint, Prospero::BufferFormat::k32UInt,
                         Prospero::ImageType::kColor2D, {1, 1, 1}, 1, 4, 1);
      const auto mirror_image = texture_cache.FindImage(mirror_desc);
      (void)texture_cache.FindTexture(mirror_image, mirror_desc);
      texture_cache.MarkGpuWritten(mirror_image);
      constexpr uint32_t mirror_cpu_value = 0x0f1e2d3cu;
      Require(name, "CPU-dirty formatted mirror fault",
              resources.HandleFault(PageFaultAccess::Write,
                                    mirror_desc.info.data.address),
              "GPU image did not accept a CPU write before Buffer mirroring");
      std::memcpy(memory + 0x5000, &mirror_cpu_value, sizeof(mirror_cpu_value));
      auto mirror_binding = resources.GetBufferCache().ObtainBuffer(
          base + 0x5000, sizeof(mirror_value), false, true);
      Require(name, "CPU-dirty formatted mirror source",
              mirror_binding.first != nullptr &&
                  !texture_cache.GetImage(mirror_image).IsBufferModified(),
              "formatted mirror did not expose a readable Buffer source");
      auto mirror_cpu_readback = CreateHostBuffer(
          name, sizeof(mirror_cpu_value), vk::BufferUsageFlagBits::eTransferDst,
          std::vector<u32>{0});
      const vk::BufferCopy mirror_cpu_copy{mirror_binding.second, 0,
                                           sizeof(mirror_cpu_value)};
      command.Handle().copyBuffer(mirror_binding.first->Handle(),
                                  mirror_cpu_readback.buffer, 1,
                                  &mirror_cpu_copy);
      HostReadBarrier(mirror_cpu_readback.buffer, mirror_cpu_readback.size,
                      vk::PipelineStageFlagBits::eTransfer,
                      vk::AccessFlagBits::eTransferWrite);
      auto mirror_refresh_desc = mirror_desc;
      const auto mirror_refresh = texture_cache.FindImage(mirror_refresh_desc);
      (void)texture_cache.FindTexture(mirror_refresh, mirror_refresh_desc);
      Require(name, "buffer-to-image ownership",
              mirror_refresh == mirror_image &&
                  !texture_cache.GetImage(mirror_refresh).IsBufferModified(),
              "buffer-backed refresh incorrectly transferred dirty ownership "
              "to the image");
      texture_cache.MarkGpuWritten(mirror_refresh);

      constexpr uint64_t exact_buffer_offset = 0x90000;
      constexpr uint32_t exact_buffer_value = 0x3f234567u;
      std::memcpy(memory + exact_buffer_offset, &exact_buffer_value,
                  sizeof(exact_buffer_value));
      auto exact_buffer_desc =
          MakeLinearDesc(base + exact_buffer_offset, sizeof(exact_buffer_value),
                         vk::Format::eR32Uint, Prospero::BufferFormat::k32UInt,
                         Prospero::ImageType::kColor2D, {1, 1, 1}, 1, 4, 1);
      const auto exact_buffer_image =
          texture_cache.FindImage(exact_buffer_desc);
      (void)texture_cache.FindTexture(exact_buffer_image, exact_buffer_desc);
      texture_cache.MarkGpuWritten(exact_buffer_image);
      auto exact_buffer_binding = resources.GetBufferCache().ObtainBuffer(
          exact_buffer_desc.info.data.address, exact_buffer_desc.info.data.size,
          false, true);
      Require(
          name, "exact replacement Buffer synchronization",
          exact_buffer_binding.first != nullptr &&
              !texture_cache.GetImage(exact_buffer_image).IsBufferModified() &&
              texture_cache.GetImage(exact_buffer_image).IsGpuModified(),
          "exact replacement copy transferred cache ownership");
      auto exact_float_desc = exact_buffer_desc;
      exact_float_desc.info.pixel_format = vk::Format::eR32Sfloat;
      exact_float_desc.info.guest_format = Prospero::BufferFormat::k32Float;
      exact_float_desc.view_info.format = vk::Format::eR32Sfloat;
      const auto exact_float_image =
          texture_cache.FindImage(exact_float_desc, true);
      (void)texture_cache.FindTexture(exact_float_image, exact_float_desc);
      Require(
          name, "Buffer-superseded exact coexistence",
          exact_float_image != exact_buffer_image &&
              TextureCacheTestAccess::Contains(texture_cache,
                                               exact_buffer_image) &&
              texture_cache.GetImage(exact_buffer_image).IsGpuModified() &&
              !texture_cache.GetImage(exact_float_image).IsBufferModified() &&
              !texture_cache.GetImage(exact_float_image).IsGpuModified(),
          "exact-format lookup retired its old record or transferred Buffer "
          "ownership");
      auto exact_buffer_readback = CreateHostBuffer(
          name, sizeof(exact_buffer_value),
          vk::BufferUsageFlagBits::eTransferDst, std::vector<u32>{0});
      auto &exact_float_native = texture_cache.GetImage(exact_float_image);
      exact_float_native.Transit(vk::ImageLayout::eTransferSrcOptimal,
                                 vk::AccessFlagBits2::eTransferRead, {},
                                 command.Handle());
      vk::BufferImageCopy exact_float_copy{};
      exact_float_copy.imageSubresource.aspectMask =
          vk::ImageAspectFlagBits::eColor;
      exact_float_copy.imageSubresource.layerCount = 1;
      exact_float_copy.imageExtent = {1, 1, 1};
      command.Handle().copyImageToBuffer(exact_float_native.backing.image,
                                         vk::ImageLayout::eTransferSrcOptimal,
                                         exact_buffer_readback.buffer, 1,
                                         &exact_float_copy);
      HostReadBarrier(exact_buffer_readback.buffer, exact_buffer_readback.size,
                      vk::PipelineStageFlagBits::eTransfer,
                      vk::AccessFlagBits::eTransferWrite);

      const uint32_t clear_source = 0x01010101u;
      std::memcpy(memory + 0x6000, &clear_source, sizeof(clear_source));
      auto clear_desc = MakeLinearDesc(
          base + 0x6000, sizeof(clear_source), vk::Format::eR8G8B8A8Unorm,
          Prospero::BufferFormat::k8_8_8_8UNorm, Prospero::ImageType::kColor2D,
          {1, 1, 1}, 1, 4, 1);
      const auto clear_image = texture_cache.FindImage(clear_desc);
      auto buffer_write = resources.GetBufferCache().ObtainBuffer(
          base + 0x6000, sizeof(clear_source), true, true);
      texture_cache.InvalidateMemoryFromGPU(base + 0x6000,
                                            sizeof(clear_source));
      Require(name, "buffer-write ownership",
              buffer_write.first != nullptr &&
                  texture_cache.GetImage(clear_image).IsBufferModified(),
              "formatted buffer write did not supersede the image");
      Require(name, "buffer-owned full image clear",
              texture_cache.ClearImageFromBuffer(
                  command, base + 0x6000, sizeof(clear_source), 0xaabbccddu) &&
                  !texture_cache.GetImage(clear_image).IsBufferModified() &&
                  texture_cache.GetImage(clear_image).IsGpuModified(),
              "full image clear retained dual buffer/image GPU ownership");
      texture_cache.MarkGpuWritten(clear_image);
      auto clear_read_desc = clear_desc;
      Require(name, "post-clear image reuse",
              texture_cache.FindImage(clear_read_desc) == clear_image,
              "cleared image could not be read or written after ownership "
              "transfer");

      auto stencil_clear_desc = MakeLinearDesc(
          base + 0x27e0000, 0x1000, vk::Format::eD32SfloatS8Uint,
          Prospero::BufferFormat::k32Float, Prospero::ImageType::kColor2D,
          {13, 11, 1}, 2, 4, 1);
      stencil_clear_desc.info.stencil = {base + 0x27e2000, 0x1000};
      stencil_clear_desc.info.resources.levels = 2;
      stencil_clear_desc.info.mip_layout[0] = {0, 0x800, 13, 11};
      stencil_clear_desc.info.mip_layout[1] = {0x800, 0x800, 6, 5};
      stencil_clear_desc.view_info.aspect =
          vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil;
      const auto stencil_clear_id = texture_cache.FindImage(stencil_clear_desc);
      auto &stencil_clear_image = texture_cache.GetImage(stencil_clear_id);
      stencil_clear_image.Transit(vk::ImageLayout::eTransferDstOptimal,
          vk::AccessFlagBits2::eTransferWrite, {}, command.Handle());
      const vk::ClearDepthStencilValue initial_depth_stencil{0.75f, 0x91};
      const vk::ImageSubresourceRange all_depth_stencil{
          stencil_clear_desc.view_info.aspect, 0, 2, 0, 2};
      command.Handle().clearDepthStencilImage(stencil_clear_image.backing.image,
          vk::ImageLayout::eTransferDstOptimal, &initial_depth_stencil, 1,
          &all_depth_stencil);
      texture_cache.MarkGpuWritten(stencil_clear_id);
      vk::ClearValue stencil_value{};
      stencil_value.depthStencil = vk::ClearDepthStencilValue{0.f, 0x35};
      TextureCacheTestAccess::ClearImage(texture_cache, command, stencil_clear_id,
          {vk::ImageAspectFlagBits::eStencil, 1, 1, 1, 1}, stencil_value);

      // Read every mip/layer of both aspects to prove that the stencil clear is local.
      auto stencil_readback = CreateHostBuffer(name, 0x4000,
          vk::BufferUsageFlagBits::eTransferDst, {});
      std::vector<vk::BufferImageCopy> stencil_copies;
      for (uint32_t mip = 0; mip < 2; mip++) {
        for (uint32_t layer = 0; layer < 2; layer++) {
          for (const auto aspect : {vk::ImageAspectFlagBits::eDepth,
                                    vk::ImageAspectFlagBits::eStencil}) {
            vk::BufferImageCopy copy{};
            copy.bufferOffset = stencil_copies.size() * 0x800;
            copy.imageSubresource = {aspect, mip, layer, 1};
            copy.imageExtent = {13u >> mip, 11u >> mip, 1};
            stencil_copies.push_back(copy);
          }
        }
      }
      stencil_clear_image.Download(stencil_copies, stencil_readback.buffer, 0,
                                   stencil_readback.size);
      HostReadBarrier(stencil_readback.buffer, stencil_readback.size,
                      vk::PipelineStageFlagBits::eTransfer,
                      vk::AccessFlagBits::eTransferWrite);
      scheduler.Finish();
      const auto stencil_words = ReadBuffer(name, stencil_readback, 0x1000);
      const auto *stencil_bytes = reinterpret_cast<const uint8_t *>(stencil_words.data());
      for (const auto &copy : stencil_copies) {
        const auto &sub = copy.imageSubresource;
        const auto count = copy.imageExtent.width * copy.imageExtent.height;
        const auto *bytes = stencil_bytes + copy.bufferOffset;
        const bool depth = sub.aspectMask == vk::ImageAspectFlagBits::eDepth;
        uint32_t expected = 0x91u;
        if (depth) {
          expected = std::bit_cast<uint32_t>(0.75f);
        } else if (sub.mipLevel == 1 && sub.baseArrayLayer == 1) {
          expected = 0x35u;
        }
        for (uint32_t pixel = 0; pixel < count; pixel++) {
          uint32_t actual = bytes[pixel];
          if (depth) std::memcpy(&actual, bytes + pixel * 4, 4);
          Require(name, "stencil clear preserves depth and neighbors", actual == expected,
                  "selected stencil clear changed depth, another mip, or another layer");
        }
      }
      DestroyBuffer(&stencil_readback);

      constexpr uint64_t partial_image_offset = 0xa000;
      constexpr uint64_t partial_buffer_offset = 0xa010;
      constexpr uint64_t partial_clean_offset = 0xa020;
      constexpr uint32_t partial_image_value = 0x31415926u;
      constexpr uint32_t partial_buffer_value = 0x27182818u;
      constexpr uint32_t partial_clean_value = 0xabcdef01u;
      std::memcpy(memory + partial_clean_offset, &partial_clean_value,
                  sizeof(partial_clean_value));
      auto partial_write = resources.GetBufferCache().ObtainBuffer(
          base + partial_image_offset, sizeof(partial_image_value), true);
      Require(name, "partial-page buffer allocation",
              partial_write.first != nullptr,
              "partial-page GPU write did not create a native buffer");
      resources.GetBufferCache().FillBuffer(base + partial_image_offset,
                                            sizeof(partial_image_value),
                                            partial_image_value, false);
      resources.GetBufferCache().FillBuffer(base + partial_buffer_offset,
                                            sizeof(partial_buffer_value),
                                            partial_buffer_value, false);
      auto partial_desc = MakeLinearDesc(
          base + partial_image_offset, sizeof(partial_image_value),
          vk::Format::eR32Uint, Prospero::BufferFormat::k32UInt,
          Prospero::ImageType::kColor2D, {1, 1, 1}, 1, 4, 1);
      const auto partial_image = texture_cache.FindImage(partial_desc);
      Require(name, "partial-page image upload",
              !texture_cache.GetImage(partial_image).IsGpuModified(),
              "image upload incorrectly consumed buffer dirty ownership");
      auto partial_image_mirror = resources.GetBufferCache().ObtainBuffer(
          base + partial_image_offset, sizeof(partial_image_value), false,
          true);
      Require(name, "partial-page image mirror",
              partial_image_mirror.first != nullptr &&
                  !texture_cache.GetImage(partial_image).IsGpuModified(),
              "same-page image upload lost its buffer source");
      const auto partial_clean_source =
          resources.GetBufferCache().ObtainBufferForImage(
              base + partial_clean_offset, sizeof(partial_clean_value));
      Require(name, "partial-page clean source",
              partial_clean_source.first != nullptr,
              "clean same-page bytes inherited unrelated buffer ownership");
      Require(name, "partial-page remaining fault",
              resources.HandleFault(PageFaultAccess::Read,
                                    base + partial_buffer_offset),
              "same-page buffer ownership was lost after image transfer");
      uint32_t partial_buffer_backing = 0;
      std::memcpy(&partial_buffer_backing, memory + partial_buffer_offset,
                  sizeof(partial_buffer_backing));
      uint32_t partial_image_backing = 0;
      std::memcpy(&partial_image_backing, memory + partial_image_offset,
                  sizeof(partial_image_backing));
      Require(name, "partial-page readback values",
              partial_image_backing == partial_image_value &&
                  partial_buffer_backing == partial_buffer_value,
              "same-page image/buffer readback published incorrect bytes");
      constexpr uint32_t partial_cpu_refresh_value = 0x13579bdfu;
      Require(name, "partial-page CPU write fault",
              resources.HandleFault(PageFaultAccess::Write,
                                    base + partial_clean_offset),
              "same-page CPU write did not invalidate cached ownership");
      std::memcpy(memory + partial_clean_offset, &partial_cpu_refresh_value,
                  sizeof(partial_cpu_refresh_value));
      constexpr std::array<uint32_t, 2> partial_neighbors{0x2468ace0u,
                                                        0xfedcba98u};
      std::memcpy(memory + partial_clean_offset - sizeof(uint32_t),
                  &partial_neighbors[0], sizeof(uint32_t));
      std::memcpy(memory + partial_clean_offset + sizeof(uint32_t),
                  &partial_neighbors[1], sizeof(uint32_t));
      std::vector<u32> partial_cpu_refresh_expected(TRACKER_PAGE_SIZE / sizeof(u32));
      std::memcpy(partial_cpu_refresh_expected.data(), memory + partial_image_offset,
                  TRACKER_PAGE_SIZE);
      const auto partial_cpu_refresh_source =
          resources.GetBufferCache().ObtainBufferForImage(
              base + partial_clean_offset, sizeof(partial_cpu_refresh_value));
      Require(name, "partial-page CPU refresh source",
              partial_cpu_refresh_source.first != nullptr,
              "CPU-dirty same-page bytes did not resolve through the cached "
              "buffer");
      auto partial_cpu_refresh_readback =
          CreateHostBuffer(name, TRACKER_PAGE_SIZE,
                           vk::BufferUsageFlagBits::eTransferDst, {0});
      const vk::BufferCopy partial_cpu_refresh_copy{
          partial_cpu_refresh_source.first->Offset(base + partial_image_offset), 0,
          TRACKER_PAGE_SIZE};
      command.Handle().copyBuffer(partial_cpu_refresh_source.first->Handle(),
                                  partial_cpu_refresh_readback.buffer, 1,
                                  &partial_cpu_refresh_copy);
      vk::BufferMemoryBarrier partial_cpu_refresh_barrier{};
      partial_cpu_refresh_barrier.sType =
          vk::StructureType::eBufferMemoryBarrier;
      partial_cpu_refresh_barrier.srcAccessMask =
          vk::AccessFlagBits::eTransferWrite;
      partial_cpu_refresh_barrier.dstAccessMask = vk::AccessFlagBits::eHostRead;
      partial_cpu_refresh_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
      partial_cpu_refresh_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
      partial_cpu_refresh_barrier.buffer = partial_cpu_refresh_readback.buffer;
      partial_cpu_refresh_barrier.size = partial_cpu_refresh_readback.size;
      command.Handle().pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
                                       vk::PipelineStageFlagBits::eHost, {}, 0,
                                       nullptr, 1, &partial_cpu_refresh_barrier,
                                       0, nullptr);

      const uint32_t fault_a = 0x01020304u;
      const uint32_t fault_b = 0x11121314u;
      std::memcpy(memory + 0x8000, &fault_a, sizeof(fault_a));
      std::memcpy(memory + 0x8010, &fault_b, sizeof(fault_b));
      auto fault_a_desc =
          MakeLinearDesc(base + 0x8000, sizeof(fault_a), vk::Format::eR32Uint,
                         Prospero::BufferFormat::k32UInt,
                         Prospero::ImageType::kColor2D, {1, 1, 1}, 1, 4, 1);
      auto fault_b_desc = fault_a_desc;
      fault_b_desc.info.data.address = base + 0x8010;
      const auto fault_a_image = texture_cache.FindImage(fault_a_desc);
      const auto fault_b_image = texture_cache.FindImage(fault_b_desc);
      (void)texture_cache.FindTexture(fault_a_image, fault_a_desc);
      (void)texture_cache.FindTexture(fault_b_image, fault_b_desc);
      texture_cache.MarkGpuWritten(fault_a_image);
      texture_cache.MarkGpuWritten(fault_b_image);
      Require(name, "per-image watcher installation",
              texture_cache.GetImage(fault_a_image).IsTracked() &&
                  texture_cache.GetImage(fault_b_image).IsTracked(),
              "same-page images did not install independent write watchers");
      constexpr uint64_t padding_fault_offset = 0x8080;
      uint32_t write_only_read_a = 0;
      uint32_t write_only_read_b = 0;
      std::memcpy(&write_only_read_a, memory + 0x8000,
                  sizeof(write_only_read_a));
      std::memcpy(&write_only_read_b, memory + 0x8010,
                  sizeof(write_only_read_b));
      Require(name, "write-only image read policy",
              write_only_read_a == fault_a && write_only_read_b == fault_b &&
                  texture_cache.GetImage(fault_a_image).IsGpuModified() &&
                  texture_cache.GetImage(fault_b_image).IsGpuModified(),
              "TextureCache claimed a CPU read fault instead of preserving "
              "GPU image ownership");
      Require(name, "same-page image write invalidation",
              resources.HandleFault(PageFaultAccess::Write,
                                    base + padding_fault_offset) &&
                  texture_cache.GetImage(fault_a_image).IsGpuModified() &&
                  texture_cache.GetImage(fault_b_image).IsGpuModified() &&
                  !texture_cache.GetImage(fault_a_image).IsTracked() &&
                  !texture_cache.GetImage(fault_b_image).IsTracked() &&
                  texture_cache.GetImage(fault_a_image).IsMaybeCpuDirty() &&
                  texture_cache.GetImage(fault_b_image).IsMaybeCpuDirty(),
              "a byte-disjoint CPU write discarded authoritative images");
      const auto retracked_a = texture_cache.FindImage(fault_a_desc);
      const auto retracked_b = texture_cache.FindImage(fault_b_desc);
      (void)texture_cache.FindTexture(retracked_a, fault_a_desc);
      (void)texture_cache.FindTexture(retracked_b, fault_b_desc);
      auto fault_a_mirror = resources.GetBufferCache().ObtainBuffer(
          base + 0x8000, sizeof(fault_a), false, true);
      Require(name, "same-page image re-track",
              retracked_a == fault_a_image && retracked_b == fault_b_image &&
                  texture_cache.GetImage(fault_a_image).IsTracked() &&
                  texture_cache.GetImage(fault_b_image).IsTracked() &&
                  !texture_cache.GetImage(fault_a_image).IsCpuDirty() &&
                  !texture_cache.GetImage(fault_b_image).IsCpuDirty() &&
                  fault_a_mirror.first != nullptr &&
                  texture_cache.GetImage(fault_a_image).IsTracked() &&
                  texture_cache.GetImage(fault_b_image).IsTracked() &&
                  texture_cache.GetImage(fault_a_image).IsGpuModified() &&
                  texture_cache.GetImage(fault_b_image).IsGpuModified(),
              "copying one same-page image lost an authoritative owner");
      Require(name, "same-page survivor write fault",
              resources.HandleFault(PageFaultAccess::Write, base + 0x8010) &&
                  texture_cache.GetImage(fault_b_image).IsGpuModified() &&
                  texture_cache.GetImage(fault_b_image).IsDefinitelyCpuDirty(),
              "the surviving image was not protected after its alias retired");
      constexpr uint32_t fault_b_cpu = 0xa5a6a7a8u;
      std::memcpy(memory + 0x8010, &fault_b_cpu, sizeof(fault_b_cpu));
      const auto refreshed_b = texture_cache.FindImage(fault_b_desc);
      (void)texture_cache.FindTexture(refreshed_b, fault_b_desc);
      Require(
          name, "same-page survivor refresh",
          refreshed_b == fault_b_image &&
              !texture_cache.GetImage(fault_b_image).IsDefinitelyCpuDirty() &&
              texture_cache.GetImage(fault_b_image).IsGpuModified(),
          "the surviving image could not reconcile its CPU write");

      constexpr uint64_t publish_image_offset = 0x26000;
      constexpr uint64_t publish_buffer_offset = 0x26010;
      constexpr uint32_t publish_image_value = 0x31415926u;
      constexpr uint32_t publish_buffer_value = 0x27182818u;
      std::memcpy(memory + publish_image_offset, &publish_image_value,
                  sizeof(publish_image_value));
      auto publish_image_desc = MakeLinearDesc(
          base + publish_image_offset, sizeof(publish_image_value),
          vk::Format::eR32Uint, Prospero::BufferFormat::k32UInt,
          Prospero::ImageType::kColor2D, {1, 1, 1}, 1, 4, 1);
      const auto publish_image = texture_cache.FindImage(publish_image_desc);
      (void)texture_cache.FindTexture(publish_image, publish_image_desc);
      texture_cache.MarkGpuWritten(publish_image);
      resources.GetBufferCache().FillBuffer(base + publish_buffer_offset,
                                            sizeof(publish_buffer_value),
                                            publish_buffer_value, false);
      auto publish_replacement_desc = publish_image_desc;
      publish_replacement_desc.info.pixel_format = vk::Format::eR32Sfloat;
      publish_replacement_desc.info.guest_format =
          Prospero::BufferFormat::k32Float;
      publish_replacement_desc.view_info.format = vk::Format::eR32Sfloat;
      const auto publish_replacement =
          texture_cache.FindImage(publish_replacement_desc, true);
      Require(name, "exact-disjoint image replacement",
              publish_replacement && publish_replacement != publish_image,
              "exact-format lookup did not replace the image");
      Require(name, "exact-disjoint image publication",
              !resources.GetBufferCache().HasGpuDirtyBytes(
                  base + publish_buffer_offset, sizeof(publish_buffer_value)),
              "clean neighboring buffer unexpectedly became GPU-owned");
      uint32_t published_image_backing = 0;
      uint32_t published_buffer_backing = 0;
      std::memcpy(&published_image_backing, memory + publish_image_offset,
                  sizeof(published_image_backing));
      std::memcpy(&published_buffer_backing, memory + publish_buffer_offset,
                  sizeof(published_buffer_backing));
      Require(name, "exact-disjoint publication contents",
              published_image_backing == publish_image_value &&
                  published_buffer_backing == publish_buffer_value,
              "image publication or neighboring buffer readback changed bytes");

      for (const auto [offset, samples] :
           std::array<std::pair<uint64_t, uint32_t>, 2>{
               {{0x10000, 2}, {0x11000, 4}}}) {
        std::memset(memory + offset, 0, samples * sizeof(uint16_t));
        auto standalone_ms = MakeLinearDesc(
            base + offset, samples * sizeof(uint16_t), vk::Format::eD16Unorm,
            Prospero::BufferFormat::k16UNorm, Prospero::ImageType::kColor2D,
            {1, 1, 1}, 1, 2, samples);
        standalone_ms.type = BindingType::DepthTarget;
        standalone_ms.view_info.aspect = vk::ImageAspectFlagBits::eDepth;
        standalone_ms.view_info.usage =
            vk::ImageUsageFlagBits::eDepthStencilAttachment;
        const auto image = texture_cache.FindImage(standalone_ms);
        (void)texture_cache.FindDepthTarget(image, standalone_ms);
        texture_cache.MarkGpuWritten(image);
        uint16_t standalone_cpu_read = 1;
        std::memcpy(&standalone_cpu_read, memory + offset,
                    sizeof(standalone_cpu_read));
        Require(
            name, "standalone MSAA ownership",
            texture_cache.GetImage(image).IsGpuModified() &&
                standalone_cpu_read == 0 &&
                texture_cache.GetImage(image).IsGpuModified() &&
                resources.HandleFault(PageFaultAccess::Write, base + offset) &&
                texture_cache.GetImage(image).IsGpuModified() &&
                texture_cache.GetImage(image).IsDefinitelyCpuDirty(),
            "fresh multisample target violated write-only ownership");
      }

      // A one-layer guest descriptor can alias layer 1 of a cached native array.
      constexpr uint64_t alias_dcc_address = base + 0x2120000;
      auto dcc_array = MakeLinearDesc(
          base + 0x2100000, 0x20000, vk::Format::eR16G16B16A16Sfloat,
          Prospero::BufferFormat::k16_16_16_16Float, Prospero::ImageType::kColor2D,
          {128, 64, 1}, 2, 8, 1);
      dcc_array.type = BindingType::RenderTarget;
      dcc_array.info.tile_mode = Prospero::TileMode::kRenderTarget;
      dcc_array.info.pitch = TileGetRenderTargetPitch(128, 8);
      dcc_array.info.mip_layout[0].pitch = dcc_array.info.pitch;
      dcc_array.info.metadata.kind = ImageMetadataKind::Dcc;
      dcc_array.info.metadata.range = {alias_dcc_address, 0x2000};
      dcc_array.view_info.usage = vk::ImageUsageFlagBits::eColorAttachment;
      WriteMetadata(context, alias_dcc_address, 0x2000, UINT32_MAX);
      WriteMetadata(context, alias_dcc_address + 0x2000, 0x1000, 0x5a5a5a5au);
      const auto dcc_array_id = texture_cache.FindImage(dcc_array);
      vk::ClearValue array_paint{};
      array_paint.color.float32 = std::array{1.0f, 0.0f, 1.0f, 1.0f};
      TextureCacheTestAccess::ClearImage(texture_cache, scheduler.Current(), dcc_array_id,
          {vk::ImageAspectFlagBits::eColor, 0, 1, 0, 2}, array_paint);
      auto dcc_alias = dcc_array;
      dcc_alias.info.data = {dcc_array.info.data.address + 0x10000, 0x10000};
      dcc_alias.info.resources.layers = 1;
      dcc_alias.info.mip_layout[0].size = 0x10000;
      dcc_alias.info.metadata.range = {alias_dcc_address + 0x1000, 0x1000};
      dcc_alias.view_info.type = vk::ImageViewType::e2D;
      dcc_alias.view_info.layer_count = 1;
      WriteMetadata(context, dcc_alias.info.metadata.range.address, 0x1000, 0x40404040u);
      Require(name, "DCC alias host layer",
              texture_cache.FindImage(dcc_alias) == dcc_array_id &&
                  dcc_alias.view_info.base_layer == 1 &&
                  ReadCachedTexel(name, context, dcc_array_id) ==
                      std::vector<u32>{0x00003c00u, 0x3c003c00u} &&
                  ReadCachedTexel(name, context, dcc_array_id, {}, {1, 1, 1}, 1) ==
                      std::vector<u32>{0, 0x3c000000u},
              "guest metadata layer 0 did not clear only remapped native layer 1");
      resources.GetBufferCache().ReadMemory(alias_dcc_address, 0x3000, false);
      std::array<uint8_t, 0x3000> alias_metadata{};
      Require(name, "DCC alias metadata bounds",
              LibKernel::Memory::TryReadBacking(alias_dcc_address, alias_metadata.data(),
                                               alias_metadata.size()) &&
                  std::all_of(alias_metadata.begin(), alias_metadata.begin() + 0x2000,
                              [](uint8_t value) { return value == 0xff; }) &&
                  std::all_of(alias_metadata.begin() + 0x2000, alias_metadata.end(),
                              [](uint8_t value) { return value == 0x5a; }),
              "remapped host layer changed metadata outside the guest alias allocation");

      RenderColorInfo retired_alias{};
      retired_alias.desc = dcc_alias;
      retired_alias.image_id = dcc_array_id;
      retired_alias.guest_mip_level = 0;
      retired_alias.guest_array_layer = 0;
      texture_cache.UnmapMemory(dcc_array.info.data.address, dcc_array.info.data.size);
      WriteMetadata(context, dcc_alias.info.metadata.range.address, 0x1000, 0x40404040u);
      RenderExecutorTestAccess::PrepareGraphicsBindings(
          context.GetRenderExecutor(), std::span<PreparedBindings *const>{},
          std::span{&retired_alias, 1u});
      RenderDepthInfo alias_depth{};
      const auto alias_rendering = RenderExecutorTestAccess::AcquireRenderTargets(
          context.GetRenderExecutor(), scheduler.Current(), &retired_alias, 1, alias_depth);
      Require(name, "retired DCC alias native coordinates",
              retired_alias.image_id != dcc_array_id &&
                  retired_alias.desc.view_info.base_level == 0 &&
                  retired_alias.desc.view_info.base_layer == 0 &&
                  retired_alias.desc.info.resources.layers == 1 &&
                  alias_rendering.color_attachments[0].image_view != nullptr &&
                  ReadCachedTexel(name, context, retired_alias.image_id) ==
                      std::vector<u32>{0, 0x3c000000u},
              "rediscovery treated a retired host layer as the native DCC slice");
      resources.GetBufferCache().ReadMemory(alias_dcc_address, 0x3000);
      Require(name, "retired DCC alias metadata bounds",
              LibKernel::Memory::TryReadBacking(alias_dcc_address, alias_metadata.data(),
                                               alias_metadata.size()) &&
                  std::all_of(alias_metadata.begin(), alias_metadata.begin() + 0x2000,
                              [](uint8_t byte) { return byte == 0xff; }) &&
                  std::all_of(alias_metadata.begin() + 0x2000, alias_metadata.end(),
                              [](uint8_t byte) { return byte == 0x5a; }),
              "retired alias rediscovery overwrote metadata outside its native slice");
      RenderExecutorTestAccess::ResetBindings(context.GetRenderExecutor());

      constexpr uint64_t metadata_data_a = 0x12000;
      constexpr uint64_t metadata_data_b = 0x12100;
      constexpr uint64_t metadata_a = 0x13000;
      constexpr uint64_t metadata_b = 0x13100;
      auto MakeMetadataDepth = [&](uint64_t data, uint64_t metadata) {
        auto desc = MakeLinearDesc(
            base + data, sizeof(uint32_t), vk::Format::eD32Sfloat,
            Prospero::BufferFormat::k32Float, Prospero::ImageType::kColor2D,
            {1, 1, 1}, 1, 4, 1);
        desc.type = BindingType::DepthTarget;
        desc.info.metadata.kind = ImageMetadataKind::Htile;
        desc.info.metadata.range = {base + metadata, 0x80};
        desc.view_info.aspect = vk::ImageAspectFlagBits::eDepth;
        desc.view_info.usage = vk::ImageUsageFlagBits::eDepthStencilAttachment;
        return desc;
      };
      auto metadata_depth_a = MakeMetadataDepth(metadata_data_a, metadata_a);
      auto metadata_depth_b = MakeMetadataDepth(metadata_data_b, metadata_b);
      metadata_depth_a.info.htile_clear_mask = 0;
      const auto metadata_depth_a_id =
          texture_cache.FindImage(metadata_depth_a);
      const auto metadata_depth_b_id =
          texture_cache.FindImage(metadata_depth_b);
      WriteMetadata(context, base + metadata_a, 0x80, 0);
      Require(
          name, "unbound metadata separation",
          !texture_cache.IsMeta(base + metadata_a),
          "unbound metadata bytes were exposed as registered HTile");
      const auto metadata_depth_a_view =
          texture_cache.FindDepthTarget(metadata_depth_a_id, metadata_depth_a);
      const auto metadata_depth_b_view =
          texture_cache.FindDepthTarget(metadata_depth_b_id, metadata_depth_b);
      Require(name, "shared-page metadata state",
              metadata_depth_a_view != nullptr &&
                  metadata_depth_b_view != nullptr &&
                  !texture_cache.IsMetaCleared(base + metadata_a, 0) &&
                  texture_cache.ClearMeta(base + metadata_a) &&
                  texture_cache.ClearMeta(base + metadata_b),
              "shared-page metadata did not retain logical clear state");
      auto metadata_alias = MakeLinearDesc(
          base + metadata_a, sizeof(uint32_t), vk::Format::eR32Sfloat,
          Prospero::BufferFormat::k32Float, Prospero::ImageType::kColor2D,
          {1, 1, 1}, 1, 4, 1);
      metadata_alias.type = BindingType::RenderTarget;
      metadata_alias.view_info.usage = vk::ImageUsageFlagBits::eColorAttachment;
      const auto metadata_alias_id =
          texture_cache.FindImage(metadata_alias, true);
      const auto metadata_alias_view =
          texture_cache.FindRenderTarget(metadata_alias_id, metadata_alias);
      Require(
          name, "exact alias metadata coexistence",
          metadata_alias_view != nullptr &&
              texture_cache.GetImage(metadata_depth_a_id).IsGpuModified() &&
              texture_cache.GetImage(metadata_depth_b_id).IsGpuModified() &&
              texture_cache.IsMeta(base + metadata_a) &&
              texture_cache.IsMetaCleared(base + metadata_a, 0) &&
              texture_cache.IsMeta(base + metadata_b) &&
              texture_cache.IsMetaCleared(base + metadata_b, 0),
          "image discovery retired aliased metadata or its live depth image");
      const bool touched_metadata = texture_cache.TouchMeta(base + metadata_a, 0, false);
      WriteMetadata(context, base + metadata_a, 0x80, 0);
      Require(
          name, "registered DCC/HTile separation",
          touched_metadata && !texture_cache.IsMetaCleared(base + metadata_a, 0),
          "a PS5 DCC fill changed registered HTile state");
      Require(
          name, "metadata first-touch state",
          texture_cache.TouchMeta(base + metadata_b, 0, true) &&
              texture_cache.IsMetaCleared(base + metadata_b, 0) &&
              texture_cache.TouchMeta(base + metadata_b, 0, false) &&
              !texture_cache.IsMetaCleared(base + metadata_b, 0),
          "per-slice metadata update incorrectly required prior GPU ownership");
      resources.GetBufferCache().FillBuffer(base + metadata_b, sizeof(uint32_t),
                                            0, false);
      Require(
          name, "metadata buffer fill state",
          texture_cache.IsMetaCleared(base + metadata_b, 0),
          "BufferCache fill did not publish an exact-address metadata clear");

      // R-Type Final 3 reuses an old color allocation inside a new stencil plane,
      // with the same metadata address changing from DCC to HTile.
      auto reused_depth = MakeMetadataDepth(0x12300, 0x28000);
      reused_depth.info.pixel_format = vk::Format::eD32SfloatS8Uint;
      reused_depth.info.stencil = {base + 0x12200, 0x80};
      reused_depth.info.htile_clear_mask = 0;
      reused_depth.view_info.format = vk::Format::eD32SfloatS8Uint;
      reused_depth.view_info.aspect = vk::ImageAspectFlagBits::eDepth |
                                      vk::ImageAspectFlagBits::eStencil;
      auto reused_color = MakeLinearDesc(
          base + 0x12240, sizeof(uint32_t), vk::Format::eR8G8B8A8Unorm,
          Prospero::BufferFormat::k8_8_8_8UNorm, Prospero::ImageType::kColor2D,
          {1, 1, 1}, 1, 4, 1);
      reused_color.type = BindingType::RenderTarget;
      reused_color.info.metadata.kind = ImageMetadataKind::Dcc;
      reused_color.info.metadata.range = {base + 0x28000, 0x1000};
      reused_color.view_info.usage = vk::ImageUsageFlagBits::eColorAttachment;
      const auto reused_color_id = texture_cache.FindImage(reused_color);
      (void)texture_cache.FindRenderTarget(reused_color_id, reused_color);
      // Repeated CPU stores must remain visible through ordinary buffer ownership.
      for (uint32_t repeat = 0; repeat < 2; repeat++) {
        vk::ClearValue painted{};
        painted.color.float32 = std::array{1.0f, 0.0f, 1.0f, 1.0f};
        TextureCacheTestAccess::ClearImage(
            texture_cache, scheduler.Current(), reused_color_id,
            {vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1}, painted);
        std::memset(memory + 0x28000, 0, 0x1000);
        Require(name, "CPU metadata rediscovery",
                texture_cache.FindImage(reused_color) == reused_color_id,
                "metadata writes replaced the live expanded image");
        (void)texture_cache.FindRenderTarget(reused_color_id, reused_color);
        Require(name, "repeated CPU metadata clear",
                ReadCachedTexel(name, context, reused_color_id) == std::vector<u32>{0},
                "a same-value CPU metadata write lost its clear after rendering");
      }
      WriteMetadata(context, base + 0x28000, 0x1000, 0);
      texture_cache.InvalidateMemoryFromGPU(reused_depth.info.stencil.address,
                                           reused_depth.info.stencil.size);
      const auto reused_depth_id = texture_cache.FindImage(reused_depth);
      (void)texture_cache.FindDepthTarget(reused_depth_id, reused_depth);
      Require(
          name, "DCC allocation reused as HTile",
          TextureCacheTestAccess::Contains(texture_cache, reused_color_id) &&
              texture_cache.GetImage(reused_color_id).IsBufferModified() &&
              !texture_cache.GetImage(reused_color_id).IsGpuModified() &&
              !texture_cache.IsMetaCleared(base + 0x28000, 0) &&
              texture_cache.ClearMeta(base + 0x28000) &&
              texture_cache.TouchMeta(base + 0x28000, 0, false),
          "depth binding retained incompatible DCC clear state");
      TextureCacheTestAccess::DeleteImage(texture_cache, reused_color_id);
      (void)texture_cache.FindDepthTarget(reused_depth_id, reused_depth);
      Require(
          name, "reused metadata owner retirement",
          !TextureCacheTestAccess::Contains(texture_cache, reused_color_id) &&
              texture_cache.IsMeta(base + 0x28000) &&
              !texture_cache.IsMetaCleared(base + 0x28000, 0) &&
              texture_cache.IsMetaCleared(base + 0x28000, 1),
          "retiring the old DCC image erased the live HTile slice state");
      texture_cache.UnmapMemory(reused_depth.info.data.address,
                                reused_depth.info.data.size);
      Require(name, "reused metadata final retirement",
              !texture_cache.IsMeta(base + 0x28000),
              "retiring the HTile image left its metadata registered");

      constexpr uint64_t partial_unmap_image_offset = 0x2700000;
      auto partial_unmap_image =
          MakeLinearDesc(base + partial_unmap_image_offset, 0x2000,
                         vk::Format::eR32Uint, Prospero::BufferFormat::k32UInt,
                         Prospero::ImageType::kColor2D, {2048, 1, 1}, 1, 4, 1);
      const auto partial_unmap_image_id =
          texture_cache.FindImage(partial_unmap_image);
      texture_cache.UnmapMemory(partial_unmap_image.info.data.address, 0x1000);
      Require(name, "partial image unmap tracking",
              partial_unmap_image_id &&
                  !texture_cache.FindImageFromRange(
                      partial_unmap_image.info.data.address, 0x2000, false),
              "partial unmap left the deleted image's mapped tail tracked");

      constexpr uint64_t unformatted_alias_offset = 0x2500000;
      auto unformatted_alias =
          MakeLinearDesc(base + unformatted_alias_offset, sizeof(uint32_t),
                         vk::Format::eR32Uint, Prospero::BufferFormat::k32UInt,
                         Prospero::ImageType::kColor2D, {1, 1, 1}, 1, 4, 1);
      const auto unformatted_alias_image =
          texture_cache.FindImage(unformatted_alias);
      (void)texture_cache.FindTexture(unformatted_alias_image,
                                      unformatted_alias);
      texture_cache.MarkGpuWritten(unformatted_alias_image);
      auto unformatted_alias_buffer = resources.GetBufferCache().ObtainBuffer(
          unformatted_alias.info.data.address, unformatted_alias.info.data.size,
          false);
      Require(
          name, "unformatted buffer/image alias",
          unformatted_alias_buffer.first != nullptr &&
              texture_cache.GetImage(unformatted_alias_image).IsGpuModified() &&
              !texture_cache.GetImage(unformatted_alias_image)
                   .IsBufferModified(),
          "read-only unformatted buffer alias did not follow ordinary "
          "BufferCache acquisition");

      constexpr uint64_t layered_offset = 0x14000;
      constexpr uint64_t layered_guest_size = 0x800;
      const std::array<float, 10> layered_values{0.0f, 0.125f, 0.25f, 0.375f,
                                                 0.5f, 0.625f, 0.75f, 0.875f,
                                                 1.0f, 0.0625f};
      std::memset(memory + layered_offset, 0, layered_guest_size);
      const auto layered_layout = TextureCalcUploadLayout(
          Prospero::BufferFormat::k32Float, 2, 2, 2, 2,
          Prospero::TileMode::kLinear, layered_guest_size, true, false,
          "UnifiedTextureCacheFlow");
      const auto layered_upload_regions =
          TextureBuildImageCopies(layered_layout);
      Require(name, "layered guest layout", layered_upload_regions.size() == 4,
              "unexpected layered/mipped upload-region count");
      for (const auto &region : layered_upload_regions) {
        for (uint32_t y = 0; y < region.imageExtent.height; y++) {
          for (uint32_t x = 0; x < region.imageExtent.width; x++) {
            const uint32_t logical =
                region.imageSubresource.mipLevel == 0
                    ? region.imageSubresource.baseArrayLayer * 4 + y * 2 + x
                    : 8 + region.imageSubresource.baseArrayLayer;
            const uint64_t byte_offset =
                region.bufferOffset +
                (static_cast<uint64_t>(y) * region.bufferRowLength + x) *
                    sizeof(float);
            Require(name, "layered guest layout bounds",
                    byte_offset + sizeof(float) <= layered_guest_size,
                    "layered guest texel lies outside its backing range");
            std::memcpy(memory + layered_offset + byte_offset,
                        &layered_values[logical], sizeof(float));
          }
        }
      }
      auto layered_color = MakeLinearDesc(
          base + layered_offset, layered_guest_size, vk::Format::eR32Sfloat,
          Prospero::BufferFormat::k32Float, Prospero::ImageType::kColor2D,
          {2, 2, 1}, 2, 4, 1);
      layered_color.info.resources.levels = 2;
      layered_color.info.mip_layout[0] = {0, 32, 2, 2};
      layered_color.info.mip_layout[1] = {32, 8, 1, 1};
      layered_color.view_info.level_count = 2;
      const auto layered_color_image = texture_cache.FindImage(layered_color);
      (void)texture_cache.FindTexture(layered_color_image, layered_color);
      texture_cache.MarkGpuWritten(layered_color_image);
      auto layered_depth = layered_color;
      layered_depth.type = BindingType::DepthTarget;
      layered_depth.info.resources = {1, 4};
      layered_depth.view_info.level_count = 1;
      layered_depth.info.pixel_format = vk::Format::eD32Sfloat;
      layered_depth.view_info.format = vk::Format::eD32Sfloat;
      layered_depth.view_info.aspect = vk::ImageAspectFlagBits::eDepth;
      layered_depth.view_info.usage =
          vk::ImageUsageFlagBits::eDepthStencilAttachment;
      const auto layered_depth_image = texture_cache.FindImage(layered_depth);
      const auto &layered_native = texture_cache.GetImage(layered_depth_image);
      Require(name, "layered mipped depth alias",
              layered_depth_image != layered_color_image &&
                  layered_native.backing.layers == 2 &&
                  layered_native.backing.mip_levels == 2 &&
                  layered_native.info.resources ==
                      layered_color.info.resources &&
                  layered_native.IsGpuModified(),
              "depth/color conversion did not use the lexicographic "
              "resource maximum");
      const volatile auto layered_guest_byte =
          *reinterpret_cast<const volatile uint8_t *>(memory + layered_offset);
      (void)layered_guest_byte;
      Require(name, "layered depth write-only read policy",
              texture_cache.GetImage(layered_depth_image).IsGpuModified(),
              "a CPU read invalidated layered depth GPU ownership");

      constexpr uint64_t replacement_offset = 0x18000;
      constexpr uint64_t replacement_size = 0x2000;
      constexpr uint32_t replacement_pixel = 0xcafebabeu;
      constexpr uint32_t replacement_tail = 0x0badf00du;
      std::memset(memory + replacement_offset, 0, replacement_size);
      std::memcpy(memory + replacement_offset, &replacement_pixel,
                  sizeof(replacement_pixel));
      std::memcpy(memory + replacement_offset + replacement_size -
                      sizeof(replacement_tail),
                  &replacement_tail, sizeof(replacement_tail));
      auto replacement_source =
          MakeLinearDesc(base + replacement_offset, sizeof(uint32_t),
                         vk::Format::eR32Uint, Prospero::BufferFormat::k32UInt,
                         Prospero::ImageType::kColor2D, {1, 1, 1}, 1, 4, 1);
      const auto replacement_source_image =
          texture_cache.FindImage(replacement_source);
      (void)texture_cache.FindTexture(replacement_source_image,
                                      replacement_source);
      texture_cache.MarkGpuWritten(replacement_source_image);
      auto replacement_desc =
          MakeLinearDesc(base + replacement_offset, replacement_size,
                         vk::Format::eR32Uint, Prospero::BufferFormat::k32UInt,
                         Prospero::ImageType::kColor2D, {1, 1, 1}, 2, 4, 1);
      const auto replacement = texture_cache.FindImage(replacement_desc);
      const bool replacement_changed = replacement != replacement_source_image;
      const bool replacement_gpu_before =
          texture_cache.GetImage(replacement).IsGpuModified();
      const bool replacement_fault = resources.HandleFault(
          PageFaultAccess::Write, base + replacement_offset + 0x1000);
      const bool replacement_gpu_after =
          texture_cache.GetImage(replacement).IsGpuModified();
      uint32_t replacement_pixel_after = 0;
      uint32_t replacement_tail_after = 0;
      std::memcpy(&replacement_pixel_after, memory + replacement_offset,
                  sizeof(replacement_pixel_after));
      std::memcpy(&replacement_tail_after,
                  memory + replacement_offset + replacement_size -
                      sizeof(replacement_tail_after),
                  sizeof(replacement_tail_after));
      Require(name, "replacement tracking",
              replacement_changed && replacement_gpu_before &&
                  replacement_fault && replacement_gpu_after &&
                  texture_cache.GetImage(replacement).IsDefinitelyCpuDirty() &&
                  replacement_pixel_after == replacement_pixel &&
                  replacement_tail_after == replacement_tail,
              "replacement write invalidation lost native authority or guest "
              "backing");

      const uint32_t compressed_value = 0x55667788u;
      std::memcpy(memory + 0xc000, &compressed_value, sizeof(compressed_value));
      auto compressed_desc = MakeLinearDesc(
          base + 0xc000, sizeof(compressed_value), vk::Format::eR8G8B8A8Srgb,
          Prospero::BufferFormat::k8_8_8_8Srgb, Prospero::ImageType::kColor2D,
          {1, 1, 1}, 1, 4, 1);
      compressed_desc.type = BindingType::RenderTarget;
      compressed_desc.info.metadata.kind = ImageMetadataKind::Dcc;
      compressed_desc.info.metadata.range = {base + 0xd000, 0};
      compressed_desc.info.metadata.compression =
          VideoOutCompression::Dcc256_256_0;
      compressed_desc.view_info.usage =
          vk::ImageUsageFlagBits::eColorAttachment;
      const auto compressed_image = texture_cache.FindImage(compressed_desc);
      (void)texture_cache.FindRenderTarget(compressed_image, compressed_desc);
      uint32_t compressed_cpu_read = 0;
      std::memcpy(&compressed_cpu_read, memory + 0xc000,
                  sizeof(compressed_cpu_read));
      Require(name, "compressed write-only read policy",
              compressed_cpu_read == compressed_value &&
                  texture_cache.GetImage(compressed_image).IsGpuModified(),
              "compressed image incorrectly claimed a CPU read fault");
      Require(name, "compressed download rejection",
              !TextureCacheTestAccess::TryDownload(texture_cache,
                                                   compressed_image) &&
                  texture_cache.GetImage(compressed_image).IsGpuModified() &&
                  !texture_cache.GetImage(compressed_image).IsBufferModified(),
              "a compressed image escaped the unified download guard");
      auto compressed_video_desc = compressed_desc;
      compressed_video_desc.type = BindingType::VideoOut;
      compressed_video_desc.view_info.usage = vk::ImageUsageFlagBits::eSampled;
      const auto compressed_video =
          texture_cache.FindImage(compressed_video_desc);
      const auto &compressed_video_image =
          texture_cache.GetImage(compressed_video);
      Require(
          name, "cache-only video-out discovery",
          compressed_video == compressed_image &&
              !compressed_video_image.binding.is_bound &&
              !compressed_video_image.binding.is_target &&
              !compressed_video_image.binding.needs_rebind &&
              !compressed_video_image.usage.video_out,
          "FindImage claimed caller-owned video-out usage or binding state");

      constexpr uint64_t mixed_source_offset = 0x20000;
      constexpr uint64_t mixed_source_size = 0x1004;
      constexpr uint32_t mixed_source_width = 1025;
      constexpr uint32_t mixed_cpu_value = 0x1234abcdu;
      constexpr uint32_t mixed_gpu_value = 0x9876fedcu;
      auto mixed_owner = resources.GetBufferCache().ObtainBuffer(
          base + mixed_source_offset, mixed_source_size, true);
      Require(name, "mixed-page source allocation",
              mixed_owner.first != nullptr,
              "mixed CPU/GPU image source did not create a containing buffer");
      Require(name, "mixed-page CPU write fault",
              resources.HandleFault(PageFaultAccess::Write,
                                    base + mixed_source_offset),
              "mixed image source could not dirty its first page");
      std::memcpy(memory + mixed_source_offset, &mixed_cpu_value,
                  sizeof(mixed_cpu_value));
      resources.GetBufferCache().FillBuffer(base + mixed_source_offset + 0x1000,
                                            sizeof(mixed_gpu_value),
                                            mixed_gpu_value, false);
      auto mixed_source_desc = MakeLinearDesc(
          base + mixed_source_offset, mixed_source_size, vk::Format::eR32Uint,
          Prospero::BufferFormat::k32UInt, Prospero::ImageType::kColor2D,
          {mixed_source_width, 1, 1}, 1, 4, 1);
      const auto mixed_source_image =
          texture_cache.FindImage(mixed_source_desc);
      (void)texture_cache.FindTexture(mixed_source_image, mixed_source_desc);
      Require(name, "mixed-page image upload",
              !texture_cache.GetImage(mixed_source_image).IsGpuModified(),
              "clean Buffer source manufactured GPU image ownership");
      auto mixed_source_readback = CreateHostBuffer(
          name, mixed_source_size, vk::BufferUsageFlagBits::eTransferDst,
          std::vector<u32>(mixed_source_size / sizeof(u32), 0));
      auto &mixed_source_native = texture_cache.GetImage(mixed_source_image);
      mixed_source_native.Transit(vk::ImageLayout::eTransferSrcOptimal,
                                  vk::AccessFlagBits2::eTransferRead, {},
                                  command.Handle());
      vk::BufferImageCopy mixed_source_copy{};
      mixed_source_copy.bufferRowLength = mixed_source_width;
      mixed_source_copy.imageSubresource.aspectMask =
          vk::ImageAspectFlagBits::eColor;
      mixed_source_copy.imageSubresource.layerCount = 1;
      mixed_source_copy.imageExtent = {mixed_source_width, 1, 1};
      command.Handle().copyImageToBuffer(mixed_source_native.backing.image,
                                         vk::ImageLayout::eTransferSrcOptimal,
                                         mixed_source_readback.buffer, 1,
                                         &mixed_source_copy);
      HostReadBarrier(mixed_source_readback.buffer, mixed_source_readback.size,
                      vk::PipelineStageFlagBits::eTransfer,
                      vk::AccessFlagBits::eTransferWrite);

      constexpr uint64_t bridged_gpu_offset = 0x101000;
      constexpr uint64_t bridged_cpu_offset = 0x105000;
      constexpr uint64_t bridged_texel_size = 16;
      constexpr uint64_t bridged_source_size =
          bridged_cpu_offset - bridged_gpu_offset + bridged_texel_size;
      constexpr uint32_t bridged_source_width =
          bridged_source_size / bridged_texel_size;
      constexpr uint32_t bridged_gpu_value = 0x10293847u;
      constexpr uint32_t bridged_cpu_value = 0x56473829u;
      constexpr uint32_t bridged_gpu_guest_value = 0xa5a5a5a5u;
      std::array<uint32_t, bridged_texel_size / sizeof(uint32_t)>
          bridged_cpu_values{};
      bridged_cpu_values.fill(bridged_cpu_value);
      std::memcpy(memory + bridged_cpu_offset, bridged_cpu_values.data(),
                  sizeof(bridged_cpu_values));
      auto bridged_cpu_owner = resources.GetBufferCache().ObtainBuffer(
          base + bridged_cpu_offset, bridged_texel_size, true);
      Require(name, "bridged CPU owner allocation",
              bridged_cpu_owner.first != nullptr,
              "bridged image source did not create its CPU-side cache owner");
      resources.GetBufferCache().FillBuffer(base + bridged_cpu_offset,
                                            bridged_texel_size, 0, false);
      Require(
          name, "bridged CPU write fault",
          resources.HandleFault(PageFaultAccess::Write,
                                base + bridged_cpu_offset),
          "bridged image source could not transfer its second owner to CPU");
      std::memcpy(memory + bridged_cpu_offset, bridged_cpu_values.data(),
                  sizeof(bridged_cpu_values));

      std::array<uint32_t, bridged_texel_size / sizeof(uint32_t)>
          bridged_gpu_guest_values{};
      bridged_gpu_guest_values.fill(bridged_gpu_guest_value);
      std::memcpy(memory + bridged_gpu_offset, bridged_gpu_guest_values.data(),
                  sizeof(bridged_gpu_guest_values));

      auto bridged_gpu_owner = resources.GetBufferCache().ObtainBuffer(
          base + bridged_gpu_offset, bridged_texel_size, true);
      Require(name, "bridged GPU owner allocation",
              bridged_gpu_owner.first != nullptr &&
                  bridged_gpu_owner.first != bridged_cpu_owner.first,
              "bridged image source did not retain two disjoint cache owners");
      resources.GetBufferCache().FillBuffer(base + bridged_gpu_offset,
                                            bridged_texel_size,
                                            bridged_gpu_value, false);
      Require(name, "bridged ownership split",
              resources.GetBufferCache().HasGpuDirtyBytes(
                  base + bridged_gpu_offset, bridged_texel_size) &&
                  !resources.GetBufferCache().HasGpuDirtyBytes(
                      base + bridged_cpu_offset, bridged_texel_size) &&
                  resources.GetBufferCache().IsRegionCpuModified(
                      base + bridged_cpu_offset, bridged_texel_size),
              "bridged image source did not retain distinct GPU and CPU "
              "ownership domains");

      auto bridged_source_desc = MakeLinearDesc(
          base + bridged_gpu_offset, bridged_source_size,
          vk::Format::eR32G32B32A32Uint,
          Prospero::BufferFormat::k32_32_32_32UInt,
          Prospero::ImageType::kColor2D, {bridged_source_width, 1, 1}, 1,
          bridged_texel_size, 1);
      const auto bridged_source_image =
          texture_cache.FindImage(bridged_source_desc);
      (void)texture_cache.FindTexture(bridged_source_image,
                                      bridged_source_desc);
      auto bridged_source_readback = CreateHostBuffer(
          name, bridged_source_size, vk::BufferUsageFlagBits::eTransferDst,
          std::vector<u32>(bridged_source_size / sizeof(u32), 0));
      auto &bridged_source_native =
          texture_cache.GetImage(bridged_source_image);
      bridged_source_native.Transit(vk::ImageLayout::eTransferSrcOptimal,
                                    vk::AccessFlagBits2::eTransferRead, {},
                                    scheduler.Current().Handle());
      vk::BufferImageCopy bridged_source_copy{};
      bridged_source_copy.bufferRowLength = bridged_source_width;
      bridged_source_copy.imageSubresource.aspectMask =
          vk::ImageAspectFlagBits::eColor;
      bridged_source_copy.imageSubresource.layerCount = 1;
      bridged_source_copy.imageExtent = {bridged_source_width, 1, 1};
      scheduler.Current().Handle().copyImageToBuffer(
          bridged_source_native.backing.image,
          vk::ImageLayout::eTransferSrcOptimal, bridged_source_readback.buffer,
          1, &bridged_source_copy);
      HostReadBarrier(bridged_source_readback.buffer,
                      bridged_source_readback.size,
                      vk::PipelineStageFlagBits::eTransfer,
                      vk::AccessFlagBits::eTransferWrite);

      constexpr uint64_t byte_mirror_page_offset = 0x24000;
      constexpr uint64_t byte_mirror_offset = byte_mirror_page_offset + 1;
      const std::array<uint8_t, 4> byte_mirror_guest{0xacu, 0x5au, 0xbdu,
                                                     0xceu};
      std::memcpy(memory + byte_mirror_page_offset, byte_mirror_guest.data(),
                  byte_mirror_guest.size());
      auto byte_mirror_desc =
          MakeLinearDesc(base + byte_mirror_offset, 1, vk::Format::eR8Unorm,
                         Prospero::BufferFormat::k8UNorm,
                         Prospero::ImageType::kColor2D, {1, 1, 1}, 1, 1, 1);
      const auto byte_mirror_image = texture_cache.FindImage(byte_mirror_desc);
      (void)texture_cache.FindTexture(byte_mirror_image, byte_mirror_desc);
      texture_cache.MarkGpuWritten(byte_mirror_image);
      auto byte_mirror = resources.GetBufferCache().ObtainBuffer(
          base + byte_mirror_offset, 1, false, true);
      Require(
          name, "byte image mirror",
          byte_mirror.first != nullptr &&
              !texture_cache.GetImage(byte_mirror_image).IsBufferModified() &&
              texture_cache.GetImage(byte_mirror_image).IsGpuModified(),
          "one-byte image copy transferred cache ownership");

      const std::array<uint16_t, 4> bgra16_guest{0x3c00u, 0x4000u, 0x4200u,
                                                 0x4400u};
      std::memcpy(memory + 0xb000, bgra16_guest.data(), sizeof(bgra16_guest));
      auto bgra16_desc = MakeLinearDesc(
          base + 0xb000, sizeof(bgra16_guest), vk::Format::eR16G16B16A16Sfloat,
          Prospero::BufferFormat::k16_16_16_16Float,
          Prospero::ImageType::kColor2D, {1, 1, 1}, 1, 8, 1);
      bgra16_desc.type = BindingType::RenderTarget;
      bgra16_desc.info.bgra16 = true;
      bgra16_desc.view_info.usage = vk::ImageUsageFlagBits::eColorAttachment;
      const auto bgra16_image = texture_cache.FindImage(bgra16_desc);
      (void)texture_cache.FindRenderTarget(bgra16_image, bgra16_desc);
      auto bgra16_readback =
          CreateHostBuffer(name, sizeof(bgra16_guest),
                           vk::BufferUsageFlagBits::eTransferDst, {0, 0});
      auto &bgra16_native = texture_cache.GetImage(bgra16_image);
      bgra16_native.Transit(vk::ImageLayout::eTransferSrcOptimal,
                            vk::AccessFlagBits2::eTransferRead, {},
                            command.Handle());
      vk::BufferImageCopy bgra16_copy{};
      bgra16_copy.imageSubresource.aspectMask = vk::ImageAspectFlagBits::eColor;
      bgra16_copy.imageSubresource.layerCount = 1;
      bgra16_copy.imageExtent = {1, 1, 1};
      command.Handle().copyImageToBuffer(
          bgra16_native.backing.image, vk::ImageLayout::eTransferSrcOptimal,
          bgra16_readback.buffer, 1, &bgra16_copy);
      HostReadBarrier(bgra16_readback.buffer, bgra16_readback.size,
                      vk::PipelineStageFlagBits::eTransfer,
                      vk::AccessFlagBits::eTransferWrite);

      auto layered_readback = CreateHostBuffer(
          name, sizeof(layered_values), vk::BufferUsageFlagBits::eTransferDst,
          std::vector<u32>(sizeof(layered_values) / sizeof(u32), 0));
      auto &layered_depth_native = texture_cache.GetImage(layered_depth_image);
      layered_depth_native.Transit(vk::ImageLayout::eTransferSrcOptimal,
                                   vk::AccessFlagBits2::eTransferRead, {},
                                   command.Handle());
      std::array<vk::BufferImageCopy, 2> layered_copies{};
      layered_copies[0].bufferOffset = 0;
      layered_copies[0].imageSubresource.aspectMask =
          vk::ImageAspectFlagBits::eDepth;
      layered_copies[0].imageSubresource.mipLevel = 0;
      layered_copies[0].imageSubresource.layerCount = 2;
      layered_copies[0].imageExtent = {2, 2, 1};
      layered_copies[1].bufferOffset = 32;
      layered_copies[1].imageSubresource.aspectMask =
          vk::ImageAspectFlagBits::eDepth;
      layered_copies[1].imageSubresource.mipLevel = 1;
      layered_copies[1].imageSubresource.layerCount = 2;
      layered_copies[1].imageExtent = {1, 1, 1};
      command.Handle().copyImageToBuffer(
          layered_depth_native.backing.image,
          vk::ImageLayout::eTransferSrcOptimal, layered_readback.buffer,
          static_cast<uint32_t>(layered_copies.size()), layered_copies.data());
      HostReadBarrier(layered_readback.buffer, layered_readback.size,
                      vk::PipelineStageFlagBits::eTransfer,
                      vk::AccessFlagBits::eTransferWrite);

      vk::ShaderModuleCreateInfo module_info{};
      module_info.sType = vk::StructureType::eShaderModuleCreateInfo;
      module_info.codeSize = sizeof(GPU_TEST_MS_DEPTH_SPV);
      module_info.pCode = GPU_TEST_MS_DEPTH_SPV;
      vk::ShaderModule ms_depth_module = nullptr;
      RequireVk(
          name, "MS depth content",
          m_device.createShaderModule(&module_info, nullptr, &ms_depth_module),
          "vkCreateShaderModule");
      std::array<vk::DescriptorSetLayoutBinding, 2> observer_bindings{};
      observer_bindings[0].binding = 0;
      observer_bindings[0].descriptorType = vk::DescriptorType::eSampledImage;
      observer_bindings[0].descriptorCount = 1;
      observer_bindings[0].stageFlags = vk::ShaderStageFlagBits::eCompute;
      observer_bindings[1].binding = 1;
      observer_bindings[1].descriptorType = vk::DescriptorType::eStorageBuffer;
      observer_bindings[1].descriptorCount = 1;
      observer_bindings[1].stageFlags = vk::ShaderStageFlagBits::eCompute;
      vk::DescriptorSetLayoutCreateInfo observer_layout_info{};
      observer_layout_info.sType =
          vk::StructureType::eDescriptorSetLayoutCreateInfo;
      observer_layout_info.bindingCount =
          static_cast<uint32_t>(observer_bindings.size());
      observer_layout_info.pBindings = observer_bindings.data();
      vk::DescriptorSetLayout observer_set_layout = nullptr;
      RequireVk(name, "MS depth content",
                m_device.createDescriptorSetLayout(
                    &observer_layout_info, nullptr, &observer_set_layout),
                "vkCreateDescriptorSetLayout");
      const vk::PushConstantRange observer_push{
          vk::ShaderStageFlagBits::eCompute, 0, sizeof(uint32_t)};
      vk::PipelineLayoutCreateInfo observer_pipeline_layout_info{};
      observer_pipeline_layout_info.sType =
          vk::StructureType::ePipelineLayoutCreateInfo;
      observer_pipeline_layout_info.setLayoutCount = 1;
      observer_pipeline_layout_info.pSetLayouts = &observer_set_layout;
      observer_pipeline_layout_info.pushConstantRangeCount = 1;
      observer_pipeline_layout_info.pPushConstantRanges = &observer_push;
      vk::PipelineLayout observer_pipeline_layout = nullptr;
      RequireVk(name, "MS depth content",
                m_device.createPipelineLayout(&observer_pipeline_layout_info,
                                              nullptr,
                                              &observer_pipeline_layout),
                "vkCreatePipelineLayout");
      vk::PipelineShaderStageCreateInfo observer_stage{};
      observer_stage.sType = vk::StructureType::ePipelineShaderStageCreateInfo;
      observer_stage.stage = vk::ShaderStageFlagBits::eCompute;
      observer_stage.module = ms_depth_module;
      observer_stage.pName = "main";
      vk::ComputePipelineCreateInfo observer_pipeline_info{};
      observer_pipeline_info.sType =
          vk::StructureType::eComputePipelineCreateInfo;
      observer_pipeline_info.stage = observer_stage;
      observer_pipeline_info.layout = observer_pipeline_layout;
      vk::Pipeline observer_depth_pipeline = nullptr;
      RequireVk(
          name, "MS depth content",
          m_device.createComputePipelines(nullptr, 1, &observer_pipeline_info,
                                          nullptr, &observer_depth_pipeline),
          "vkCreateComputePipelines");
      const std::array<vk::DescriptorPoolSize, 2> observer_pool_sizes{{
          {vk::DescriptorType::eSampledImage, 2},
          {vk::DescriptorType::eStorageBuffer, 2},
      }};
      vk::DescriptorPoolCreateInfo observer_pool_info{};
      observer_pool_info.sType = vk::StructureType::eDescriptorPoolCreateInfo;
      observer_pool_info.maxSets = 2;
      observer_pool_info.poolSizeCount =
          static_cast<uint32_t>(observer_pool_sizes.size());
      observer_pool_info.pPoolSizes = observer_pool_sizes.data();
      vk::DescriptorPool observer_pool = nullptr;
      RequireVk(name, "MS depth content",
                m_device.createDescriptorPool(&observer_pool_info, nullptr,
                                              &observer_pool),
                "vkCreateDescriptorPool");
      const std::array<vk::DescriptorSetLayout, 2> observer_layouts{
          observer_set_layout, observer_set_layout};
      std::array<vk::DescriptorSet, 2> observer_sets{};
      vk::DescriptorSetAllocateInfo observer_allocate{};
      observer_allocate.sType = vk::StructureType::eDescriptorSetAllocateInfo;
      observer_allocate.descriptorPool = observer_pool;
      observer_allocate.descriptorSetCount =
          static_cast<uint32_t>(observer_sets.size());
      observer_allocate.pSetLayouts = observer_layouts.data();
      RequireVk(name, "MS depth content",
                m_device.allocateDescriptorSets(&observer_allocate,
                                                observer_sets.data()),
                "vkAllocateDescriptorSets");
      std::array<Buffer, 2> ms_observer_outputs{
          CreateHostBuffer(name, 4 * sizeof(u32),
                           vk::BufferUsageFlagBits::eStorageBuffer,
                           std::vector<u32>(4, 0)),
          CreateHostBuffer(name, 4 * sizeof(u32),
                           vk::BufferUsageFlagBits::eStorageBuffer,
                           std::vector<u32>(4, 0))};
      const std::array<ImageId, 2> observed_images{ms_depth_image,
                                                   ms_depth_image_4x};
      const std::array<uint32_t, 2> observed_samples{2, 4};
      for (uint32_t index = 0; index < observed_images.size(); index++) {
        auto &observed = texture_cache.GetImage(observed_images[index]);
        observed.Transit(vk::ImageLayout::eShaderReadOnlyOptimal,
                         vk::AccessFlagBits2::eShaderRead, {},
                         command.Handle());
        ImageViewInfo view_info{};
        view_info.format = observed.backing.format;
        view_info.type = vk::ImageViewType::e2D;
        view_info.aspect = vk::ImageAspectFlagBits::eDepth;
        view_info.mapping = {vk::ComponentSwizzle::eR, vk::ComponentSwizzle::eR,
                             vk::ComponentSwizzle::eR,
                             vk::ComponentSwizzle::eR};
        view_info.usage = vk::ImageUsageFlagBits::eSampled;
        const auto view = observed.FindView(view_info);
        const vk::DescriptorImageInfo image_info{
            nullptr, view, vk::ImageLayout::eShaderReadOnlyOptimal};
        const vk::DescriptorBufferInfo buffer_info{
            ms_observer_outputs[index].buffer, 0,
            ms_observer_outputs[index].size};
        std::array<vk::WriteDescriptorSet, 2> writes{};
        writes[0].sType = vk::StructureType::eWriteDescriptorSet;
        writes[0].dstSet = observer_sets[index];
        writes[0].dstBinding = 0;
        writes[0].descriptorCount = 1;
        writes[0].descriptorType = vk::DescriptorType::eSampledImage;
        writes[0].pImageInfo = &image_info;
        writes[1].sType = vk::StructureType::eWriteDescriptorSet;
        writes[1].dstSet = observer_sets[index];
        writes[1].dstBinding = 1;
        writes[1].descriptorCount = 1;
        writes[1].descriptorType = vk::DescriptorType::eStorageBuffer;
        writes[1].pBufferInfo = &buffer_info;
        m_device.updateDescriptorSets(static_cast<uint32_t>(writes.size()),
                                      writes.data(), 0, nullptr);
        command.Handle().bindPipeline(vk::PipelineBindPoint::eCompute,
                                      observer_depth_pipeline);
        command.Handle().bindDescriptorSets(vk::PipelineBindPoint::eCompute,
                                            observer_pipeline_layout, 0, 1,
                                            &observer_sets[index], 0, nullptr);
        command.Handle().pushConstants(
            observer_pipeline_layout, vk::ShaderStageFlagBits::eCompute, 0,
            sizeof(observed_samples[index]), &observed_samples[index]);
        command.Handle().dispatch(1, 1, 1);
        HostReadBarrier(ms_observer_outputs[index].buffer,
                        ms_observer_outputs[index].size,
                        vk::PipelineStageFlagBits::eComputeShader,
                        vk::AccessFlagBits::eShaderWrite);
      }

      scheduler.Finish();

      const auto mip_prefix_words = ReadBuffer(
          name, mip_prefix_readback, mip_prefix_size / sizeof(uint32_t));
      const auto volume_words =
          ReadBuffer(name, volume_readback, volume_guest.size());
      Require(name, "formatted volume content",
              volume_words[0] == volume_values[0] &&
                  volume_words[volume_slice_words] == volume_values[1],
              "volume synchronization lost a padded depth slice");
      DestroyBuffer(&volume_readback);
      const auto mip_formatted_words = ReadBuffer(
          name, mip_formatted_readback, mip_guest_size / sizeof(uint32_t));
      const auto mip0_word = mip_sizes[0].offset / sizeof(uint32_t);
      Require(name, "formatted mip prefix content",
              mip0_word < mip_prefix_words.size() &&
                  mip0_word < mip_native.size() &&
                  mip_prefix_words[mip0_word] == mip_native[mip0_word],
              "fitting mip-prefix synchronization copied "
              "stale guest backing");
      Require(name, "formatted Buffer content",
              mip0_word < mip_formatted_words.size() &&
                  mip0_word < mip_native.size() &&
                  mip_formatted_words[mip0_word] == mip_native[mip0_word],
              "formatted Buffer read bypassed authoritative "
              "native image mip data");
      Require(name, "CPU-dirty formatted mirror content",
              ReadBuffer(name, mirror_cpu_readback, 1) ==
                  std::vector<u32>{mirror_cpu_value},
              "formatted Buffer mirror published stale "
              "native image bytes");
      Require(name, "Buffer-superseded exact content",
              ReadBuffer(name, exact_buffer_readback, 1) ==
                  std::vector<u32>{exact_buffer_value},
              "exact-format recreation initialized from "
              "stale guest bytes");
      Require(name, "partial-page CPU refresh content",
              ReadBuffer(name, partial_cpu_refresh_readback,
                         partial_cpu_refresh_expected.size()) ==
                  partial_cpu_refresh_expected,
              "cached buffer uploaded bytes outside the exact "
              "staged guest range");
      const auto mixed_source_words = ReadBuffer(
          name, mixed_source_readback, mixed_source_size / sizeof(u32));
      Require(name, "mixed-page image content",
              mixed_source_words.front() == mixed_cpu_value &&
                  mixed_source_words[0x1000 / sizeof(u32)] == mixed_gpu_value,
              "mixed CPU/GPU source upload lost one "
              "ownership domain");
      const auto bridged_source_words = ReadBuffer(
          name, bridged_source_readback, bridged_source_size / sizeof(u32));
      Require(name, "bridged-owner image content",
              bridged_source_words.front() == bridged_gpu_value &&
                  bridged_source_words.back() == bridged_cpu_value,
              "image upload bridging separate cache owners lost a GPU or CPU "
              "ownership domain");
      Require(name, "BGRA16 content",
              ReadBuffer(name, bgra16_readback, 2) ==
                  std::vector<u32>{0x40004200u, 0x44003c00u},
              "GPU BGRA16 swap did not publish RGBA half-word order");
      scheduler.Finish();
      const auto layered_words =
          ReadBuffer(name, layered_readback, layered_values.size());
      const std::array<float, 10> layered_expected{
          layered_values[0], layered_values[1], layered_values[2],
          layered_values[3], layered_values[4], layered_values[5],
          layered_values[6], layered_values[7], layered_values[8],
          layered_values[9]};
      bool layered_content = layered_words.size() == layered_expected.size();
      for (uint32_t index = 0;
           layered_content && index < layered_expected.size(); index++) {
        layered_content &=
            layered_words[index] == std::bit_cast<u32>(layered_expected[index]);
      }
      Require(name, "layered mipped depth content", layered_content,
              "depth/color conversion changed a mip or array-layer value");
      const std::array<std::array<float, 4>, 2> expected_ms_depth{{
          {0x2000 / 65535.0f, 0xe000 / 65535.0f, 0.0f, 0.0f},
          {0.0f, 0x4000 / 65535.0f, 0x8000 / 65535.0f, 1.0f},
      }};
      for (uint32_t image = 0; image < expected_ms_depth.size(); image++) {
        const auto words = ReadBuffer(name, ms_observer_outputs[image], 4);
        bool content = words.size() == 4;
        for (uint32_t sample = 0; content && sample < observed_samples[image];
             sample++) {
          const float actual = std::bit_cast<float>(words[sample]);
          content &= std::abs(actual - expected_ms_depth[image][sample]) <=
                     1.5f / 65535.0f;
        }
        Require(name,
                image == 0 ? "two-sample depth content"
                           : "four-sample depth content",
                content,
                "color-to-multisample-depth changed a packed sample value");
      }

      auto unrelated_stencil_alias = MakeLinearDesc(
          base + second_stencil_offset, ms_stencil_size, vk::Format::eR32Uint,
          Prospero::BufferFormat::k32UInt, Prospero::ImageType::kColor2D,
          {static_cast<uint32_t>(ms_stencil_size / sizeof(uint32_t)), 1, 1}, 1,
          4, 1);
      const auto unrelated_stencil_image =
          texture_cache.FindImage(unrelated_stencil_alias);
      Require(name, "stencil association filtering",
              unrelated_stencil_image &&
                  unrelated_stencil_image != ms_depth_image &&
                  !texture_cache.GetImage(unrelated_stencil_image).depth_id,
              "an unrelated color alias was hijacked by the stencil "
              "association record");

      texture_cache.UnmapMemory(base + second_stencil_offset, ms_stencil_size);
      Require(name, "stencil proxy unmap",
              !texture_cache.FindImageFromRange(base + second_stencil_offset,
                                                ms_stencil_size, false) &&
                  texture_cache.GetImage(ms_depth_image).backing.image ==
                      ms_depth_backing,
              "stencil unmap removed the depth backing or retained its proxy");
      const auto reassociated_depth =
          texture_cache.FindImage(switched_ms_depth);
      TextureCacheTestAccess::AssociateStencil(
          texture_cache, reassociated_depth, switched_ms_depth.info.stencil);
      const auto reassociated_proxy = texture_cache.FindImageFromRange(
          base + second_stencil_offset, ms_stencil_size, false);
      Require(name, "stencil proxy reassociation",
              reassociated_depth == ms_depth_image && reassociated_proxy &&
                  texture_cache.GetImage(reassociated_proxy).depth_id ==
                      ms_depth_image,
              "stencil proxy did not re-associate with the surviving depth");
      texture_cache.UnmapMemory(ms_depth_desc.info.data.address,
                                ms_depth_desc.info.data.size);
      Require(name, "depth unmap proxy retirement",
              !texture_cache.FindImageFromRange(base + second_stencil_offset,
                                                ms_stencil_size, false),
              "unmapping depth retained its re-associated stencil proxy");

      auto reused_stencil_color = MakeLinearDesc(
          base + 0x2200000, 0x40000, vk::Format::eR8Unorm,
          Prospero::BufferFormat::k8UNorm, Prospero::ImageType::kColor2D,
          {480, 408, 1}, 1, 1, 1);
      const auto reused_stencil_color_id =
          texture_cache.FindImage(reused_stencil_color);
      auto reused_stencil_depth = MakeLinearDesc(
          base + 0x2240000, 0x10000, vk::Format::eD32SfloatS8Uint,
          Prospero::BufferFormat::k32Float, Prospero::ImageType::kColor2D,
          {128, 128, 1}, 1, 4, 1);
      reused_stencil_depth.type = BindingType::DepthTarget;
      reused_stencil_depth.info.stencil = {reused_stencil_color.info.data.address,
                                          0x10000};
      reused_stencil_depth.view_info.aspect =
          vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil;
      reused_stencil_depth.view_info.usage =
          vk::ImageUsageFlagBits::eDepthStencilAttachment;
      const auto reused_stencil_depth_id =
          texture_cache.FindImage(reused_stencil_depth);
      TextureCacheTestAccess::AssociateStencil(
          texture_cache, reused_stencil_depth_id,
          reused_stencil_depth.info.stencil);
      const auto reused_stencil_proxy = texture_cache.FindImageFromRange(
          reused_stencil_depth.info.stencil.address,
          reused_stencil_depth.info.stencil.size, false);
      Require(name, "stencil address reuse preserves color",
              reused_stencil_proxy &&
                  reused_stencil_proxy != reused_stencil_color_id &&
                  !texture_cache.GetImage(reused_stencil_color_id).depth_id &&
                  texture_cache.GetImage(reused_stencil_proxy).depth_id ==
                      reused_stencil_depth_id &&
                  texture_cache.GetImage(reused_stencil_proxy).info.data ==
                      reused_stencil_depth.info.stencil &&
                  texture_cache.GetImage(reused_stencil_proxy).info.extent ==
                      reused_stencil_depth.info.extent,
              "a smaller stencil plane took ownership of an existing R8 image");
      vk::ClearValue reused_stencil_color_clear{};
      reused_stencil_color_clear.color.float32 =
          std::array{1.0f, 0.0f, 0.0f, 0.0f};
      TextureCacheTestAccess::ClearImage(
          texture_cache, scheduler.Current(), reused_stencil_color_id,
          {vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1},
          reused_stencil_color_clear);
      Require(name, "reused stencil plane clear",
              texture_cache.ClearImageFromBuffer(
                  scheduler.Current(), reused_stencil_depth.info.stencil.address,
                  reused_stencil_depth.info.stencil.size, 0x5a5a5a5au) &&
                  texture_cache.GetImage(reused_stencil_depth_id).IsGpuModified(),
              "the separate stencil association did not resolve to depth");
      Require(name, "color clear after stencil address reuse",
              ReadCachedTexel(name, context, reused_stencil_color_id, {},
                              {4, 1, 1}) == std::vector<u32>{0xffffffffu},
              "stencil address reuse changed the native R8 clear contents");
      texture_cache.UnmapMemory(reused_stencil_depth.info.data.address,
                                reused_stencil_depth.info.data.size);
      texture_cache.UnmapMemory(reused_stencil_color.info.data.address,
                                reused_stencil_color.info.data.size);

      constexpr uint64_t exact_image_offset = 0x334100;
      constexpr uint64_t dirty_sibling_offset = 0x334200;
      constexpr uint32_t dirty_sibling_value = 0xc001d00du;
      auto dirty_sibling = resources.GetBufferCache().ObtainBuffer(
          base + dirty_sibling_offset, sizeof(dirty_sibling_value), true);
      Require(name, "same-page dirty sibling allocation",
              dirty_sibling.first != nullptr,
              "failed to create the disjoint same-page Buffer owner");
      resources.GetBufferCache().FillBuffer(base + dirty_sibling_offset,
                                            sizeof(dirty_sibling_value),
                                            dirty_sibling_value, false);
      auto exact_image_desc =
          MakeLinearDesc(base + exact_image_offset, sizeof(uint32_t),
                         vk::Format::eR32Uint, Prospero::BufferFormat::k32UInt,
                         Prospero::ImageType::kColor2D, {1, 1, 1}, 1, 4, 1);
      const auto exact_image = texture_cache.FindImage(exact_image_desc);
      (void)texture_cache.FindTexture(exact_image, exact_image_desc);
      texture_cache.MarkGpuWritten(exact_image);
      Require(name, "same-page exact alias ownership",
              resources.GetBufferCache().HasGpuDirtyBytes(
                  base + dirty_sibling_offset, sizeof(dirty_sibling_value)) &&
                  !resources.GetBufferCache().HasGpuDirtyBytes(
                      base + exact_image_offset, sizeof(uint32_t)) &&
                  texture_cache.GetImage(exact_image).IsGpuModified(),
              "image ownership discarded or conflicted with disjoint dirty "
              "Buffer bytes on the same tracker page");
      auto exact_buffer = resources.GetBufferCache().ObtainBuffer(
          base + exact_image_offset, sizeof(uint32_t), true);
      Require(name, "overlapping buffer ownership allocation",
              exact_buffer.first != nullptr,
              "failed to create the overlapping dirty Buffer owner");
      exact_buffer.first->Fill(exact_buffer.second, sizeof(uint32_t),
                               dirty_sibling_value);
      Libs::Graphics::Buffer exact_download(
          m_runtime_context, scheduler, MemoryUsage::DeviceLocal,
          base + exact_image_offset, AllFlags, sizeof(uint32_t));
      Require(name, "overlapping buffer ownership rejection",
              !texture_cache.FindImageFromRange(base + exact_image_offset,
                                                sizeof(uint32_t)) &&
                  !BufferCacheTestAccess::SynchronizeBufferFromImage(
                      resources.GetBufferCache(), exact_download,
                      base + exact_image_offset, sizeof(uint32_t)),
              "dirty Buffer bytes did not block the stale image source");
      resources.GetBufferCache().ReadMemory(base + exact_image_offset,
                                            sizeof(uint32_t));
      resources.GetBufferCache().ReadMemory(base + dirty_sibling_offset,
                                            sizeof(dirty_sibling_value));

      constexpr std::array<uint64_t, 2> gc_image_offsets{0x330000, 0x332000};
      constexpr std::array<uint32_t, 2> gc_image_values{0x76543210u,
                                                        0x89abcdefu};
      constexpr std::array<uint32_t, 2> gc_stale_values{0x10293847u,
                                                        0x56473829u};
      for (size_t index = 0; index < gc_image_offsets.size(); index++) {
        std::memcpy(memory + gc_image_offsets[index], &gc_image_values[index],
                    sizeof(uint32_t));
      }
      auto gc_image_desc_a =
          MakeLinearDesc(base + gc_image_offsets[0], sizeof(uint32_t),
                         vk::Format::eR32Uint, Prospero::BufferFormat::k32UInt,
                         Prospero::ImageType::kColor2D, {1, 1, 1}, 1, 4, 1);
      auto gc_image_desc_b = gc_image_desc_a;
      gc_image_desc_b.info.data.address = base + gc_image_offsets[1];
      auto clean_buffer_alias = resources.GetBufferCache().ObtainBuffer(
          gc_image_desc_a.info.data.address, gc_image_desc_a.info.data.size,
          true);
      Require(name, "clean pre-image buffer alias",
              clean_buffer_alias.first != nullptr,
              "failed to create the clean cached Buffer alias");
      resources.GetBufferCache().ReadMemory(gc_image_desc_a.info.data.address,
                                            gc_image_desc_a.info.data.size);
      const std::array gc_images{texture_cache.FindImage(gc_image_desc_a),
                                 texture_cache.FindImage(gc_image_desc_b)};
      Require(
          name, "non-GPU image range validity",
          !texture_cache.FindImageFromRange(gc_image_desc_a.info.data.address,
                                            gc_image_desc_a.info.data.size),
          "FindImageFromRange accepted an image without current GPU "
          "contents");
      (void)texture_cache.FindTexture(gc_images[0], gc_image_desc_a);
      (void)texture_cache.FindTexture(gc_images[1], gc_image_desc_b);
      for (const auto image : gc_images) {
        texture_cache.MarkGpuWritten(image);
      }
      Require(name, "GPU image range validity",
              texture_cache.FindImageFromRange(
                  gc_image_desc_a.info.data.address,
                  gc_image_desc_a.info.data.size) == gc_images[0],
              "FindImageFromRange rejected a clean GPU-current image");
      texture_cache.GetImage(gc_images[0])
          .InvalidateCpuWrite(gc_image_desc_a.info.data.address,
                              gc_image_desc_a.info.data.size);
      Require(
          name, "CPU-dirty image range validity",
          !texture_cache.FindImageFromRange(gc_image_desc_a.info.data.address,
                                            gc_image_desc_a.info.data.size),
          "FindImageFromRange accepted CPU-dirty native contents");
      texture_cache.MarkGpuWritten(gc_images[0]);
      for (size_t index = 0; index < gc_image_offsets.size(); index++) {
        Libs::LibKernel::Memory::WriteBacking(base + gc_image_offsets[index],
                                              &gc_stale_values[index],
                                              sizeof(uint32_t));
      }
      TextureCacheTestAccess::ConfigureGarbageCollection(
          texture_cache, gc_images, 17, UINT64_MAX);
      texture_cache.RunGarbageCollector();
      Require(name, "downloadable image pre-pressure retention",
              std::ranges::all_of(gc_images,
                                  [&](ImageId image) {
                                    return TextureCacheTestAccess::Contains(
                                        texture_cache, image);
                                  }),
              "GC retired safely downloadable GPU images before pressure");
      const auto gc_batch_tick = scheduler.CurrentTick();
      TextureCacheTestAccess::ConfigureGarbageCollection(texture_cache,
                                                         gc_images, 81, 0);
      texture_cache.RunGarbageCollector();
      std::array<uint32_t, 2> gc_before_completion{};
      for (size_t index = 0; index < gc_image_offsets.size(); index++) {
        Libs::LibKernel::Memory::TryReadBacking(base + gc_image_offsets[index],
                                                &gc_before_completion[index],
                                                sizeof(uint32_t));
      }
      Require(name, "batched image pressure retirement",
              std::ranges::none_of(gc_images,
                                   [&](ImageId image) {
                                     return TextureCacheTestAccess::Contains(
                                         texture_cache, image);
                                   }) &&
                  scheduler.CurrentTick() == gc_batch_tick &&
                  gc_before_completion == gc_stale_values,
              "GC submitted per image or published a readback before GPU "
              "completion");
      scheduler.Finish();
      scheduler.DrainPriorityOperations();
      auto refreshed_buffer_alias = resources.GetBufferCache().ObtainBuffer(
          gc_image_desc_a.info.data.address, gc_image_desc_a.info.data.size,
          false);
      Require(name, "post-publication Buffer reacquire",
              refreshed_buffer_alias.first != nullptr,
              "Buffer lookup failed after the retired image publication");
      std::array<uint32_t, 2> gc_after_completion{};
      for (size_t index = 0; index < gc_image_offsets.size(); index++) {
        Libs::LibKernel::Memory::TryReadBacking(base + gc_image_offsets[index],
                                                &gc_after_completion[index],
                                                sizeof(uint32_t));
      }
      Require(name, "batched image readback publication",
              scheduler.CurrentTick() == gc_batch_tick + 1 &&
                  gc_after_completion == gc_image_values,
              "one submission did not publish both deferred image readbacks");
      Require(name, "refreshed post-image buffer alias",
              refreshed_buffer_alias.first != nullptr,
              "failed to reacquire the cached Buffer alias after image "
              "publication");
      auto alias_readback = CreateHostBuffer(
          name, sizeof(uint32_t), vk::BufferUsageFlagBits::eTransferDst, {0});
      const vk::BufferCopy alias_copy{refreshed_buffer_alias.second, 0,
                                      sizeof(uint32_t)};
      scheduler.Current().Handle().copyBuffer(
          refreshed_buffer_alias.first->Handle(), alias_readback.buffer, 1,
          &alias_copy);
      HostReadBarrier(alias_readback.buffer, alias_readback.size,
                      vk::PipelineStageFlagBits::eTransfer,
                      vk::AccessFlagBits::eTransferWrite);
      scheduler.Finish();
      Require(name, "post-image Buffer alias content",
              ReadBuffer(name, alias_readback, 1) ==
                  std::vector<u32>{gc_image_values[0]},
              "a clean cached Buffer alias survived image ownership with "
              "stale native bytes");
      DestroyBuffer(&alias_readback);

      constexpr uint64_t submit_readback_offset = 0x336000;
      constexpr uint32_t submit_readback_value = 0x13579bdfu;
      constexpr uint32_t submit_readback_stale = 0x2468ace0u;
      auto submit_readback_desc =
          MakeLinearDesc(base + submit_readback_offset, sizeof(uint32_t),
                         vk::Format::eR32Uint, Prospero::BufferFormat::k32UInt,
                         Prospero::ImageType::kColor2D, {1, 1, 1}, 1, 4, 1);
      submit_readback_desc.type = BindingType::Storage;
      submit_readback_desc.view_info.usage = vk::ImageUsageFlagBits::eStorage;
      TextureCacheTestAccess::SetLinearReadback(texture_cache, true);
      const auto submit_readback_image =
          texture_cache.FindImage(submit_readback_desc);
      Require(name, "linear submit image clear",
              texture_cache.ClearImageFromBuffer(
                  command, submit_readback_desc.info.data.address,
                  submit_readback_desc.info.data.size, submit_readback_value),
              "failed to create GPU-current linear storage contents");
      TextureCacheTestAccess::TrackDownload(texture_cache,
                                            submit_readback_image);
      Libs::LibKernel::Memory::WriteBacking(
          submit_readback_desc.info.data.address, &submit_readback_stale,
          sizeof(submit_readback_stale));
      const auto submit_readback_tick = scheduler.CurrentTick();
      texture_cache.ProcessDownloadImages();
      TextureCacheTestAccess::SetLinearReadback(texture_cache, false);
      uint32_t submit_before_completion = 0;
      Libs::LibKernel::Memory::TryReadBacking(
          submit_readback_desc.info.data.address, &submit_before_completion,
          sizeof(submit_before_completion));
      Require(name, "linear submit deferred publication",
              submit_before_completion == submit_readback_stale &&
                  scheduler.CurrentTick() == submit_readback_tick,
              "submit-time linear readback published synchronously");
      scheduler.Finish();
      scheduler.DrainPriorityOperations();
      uint32_t submit_after_completion = 0;
      Libs::LibKernel::Memory::TryReadBacking(
          submit_readback_desc.info.data.address, &submit_after_completion,
          sizeof(submit_after_completion));
      Require(name, "linear submit readback reuse",
              submit_after_completion == submit_readback_value &&
                  TextureCacheTestAccess::Contains(texture_cache,
                                                   submit_readback_image) &&
                  texture_cache.GetImage(submit_readback_image).IsGpuModified(),
              "submit-time readback did not publish or retained no reusable "
              "GPU-current image");

      constexpr uint64_t linear_depth_offset = 0x33a000;
      constexpr uint64_t linear_stencil_offset = 0x33b000;
      constexpr uint32_t linear_depth_width = 3;
      constexpr uint32_t linear_depth_height = 2;
      constexpr uint32_t linear_depth_pitch = 4;
      constexpr uint32_t linear_depth_layers = 2;
      constexpr uint32_t linear_depth_words =
          linear_depth_pitch * linear_depth_height * linear_depth_layers;
      constexpr uint32_t linear_depth_clear = 0x3f400000u;
      std::array<uint32_t, linear_depth_words> linear_depth_guest{};
      for (uint32_t index = 0; index < linear_depth_words; index++) {
        linear_depth_guest[index] = 0x51000000u + index;
      }
      constexpr std::array<uint8_t, 8> linear_stencil_guest{
          0x91, 0x82, 0x73, 0x64, 0x55, 0x46, 0x37, 0x28};
      std::memcpy(memory + linear_depth_offset, linear_depth_guest.data(),
                  sizeof(linear_depth_guest));
      std::memcpy(memory + linear_stencil_offset, linear_stencil_guest.data(),
                  sizeof(linear_stencil_guest));
      auto linear_depth_desc = MakeLinearDesc(
          base + linear_depth_offset, sizeof(linear_depth_guest),
          vk::Format::eD32SfloatS8Uint, Prospero::BufferFormat::k32Float,
          Prospero::ImageType::kColor2D,
          {linear_depth_width, linear_depth_height, 1}, linear_depth_layers, 4,
          1);
      linear_depth_desc.type = BindingType::DepthTarget;
      linear_depth_desc.info.pitch = linear_depth_pitch;
      linear_depth_desc.info.stencil = {base + linear_stencil_offset,
                                        sizeof(linear_stencil_guest)};
      linear_depth_desc.info.mip_layout[0] = {0, sizeof(linear_depth_guest),
                                              linear_depth_pitch,
                                              linear_depth_height};
      linear_depth_desc.view_info.aspect =
          vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil;
      linear_depth_desc.view_info.usage =
          vk::ImageUsageFlagBits::eDepthStencilAttachment;
      const auto linear_depth_image =
          texture_cache.FindImage(linear_depth_desc);
      Require(name, "linear depth native clear",
              texture_cache.ClearImageFromBuffer(
                  command, linear_depth_desc.info.data.address,
                  linear_depth_desc.info.data.size, linear_depth_clear),
              "failed to create GPU-current padded linear depth contents");
      TextureCacheTestAccess::SetLinearReadback(texture_cache, true);
      TextureCacheTestAccess::TrackDownload(texture_cache, linear_depth_image);
      const auto linear_depth_tick = scheduler.CurrentTick();
      texture_cache.ProcessDownloadImages();
      TextureCacheTestAccess::SetLinearReadback(texture_cache, false);
      std::array<uint32_t, linear_depth_words> linear_depth_before{};
      std::memcpy(linear_depth_before.data(), memory + linear_depth_offset,
                  sizeof(linear_depth_before));
      Require(name, "linear depth deferred publication",
              linear_depth_before == linear_depth_guest &&
                  scheduler.CurrentTick() == linear_depth_tick,
              "linear depth readback published before GPU completion");
      scheduler.Finish();
      scheduler.DrainPriorityOperations();
      std::array<uint32_t, linear_depth_words> linear_depth_after{};
      std::array<uint8_t, linear_stencil_guest.size()> linear_stencil_after{};
      std::memcpy(linear_depth_after.data(), memory + linear_depth_offset,
                  sizeof(linear_depth_after));
      std::memcpy(linear_stencil_after.data(), memory + linear_stencil_offset,
                  sizeof(linear_stencil_after));
      bool linear_depth_matches = true;
      uint32_t linear_depth_mismatch = UINT32_MAX;
      for (uint32_t layer = 0; layer < linear_depth_layers; layer++) {
        for (uint32_t y = 0; y < linear_depth_height; y++) {
          for (uint32_t x = 0; x < linear_depth_pitch; x++) {
            const auto index =
                layer * linear_depth_pitch * linear_depth_height +
                y * linear_depth_pitch + x;
            const auto expected = x < linear_depth_width
                                      ? linear_depth_clear
                                      : linear_depth_guest[index];
            if (linear_depth_after[index] != expected &&
                linear_depth_mismatch == UINT32_MAX) {
              linear_depth_mismatch = index;
            }
            linear_depth_matches &= linear_depth_after[index] == expected;
          }
        }
      }
      Require(name, "linear depth native contents",
              linear_depth_matches &&
                  linear_stencil_after == linear_stencil_guest &&
                  TextureCacheTestAccess::Contains(texture_cache,
                                                   linear_depth_image) &&
                  texture_cache.GetImage(linear_depth_image).IsGpuModified(),
              fmt::format(
                  "linear depth mismatch={} actual=0x{:08x} expected=0x{:08x} "
                  "stencil={} contains={} gpu={}",
                  linear_depth_mismatch,
                  linear_depth_mismatch == UINT32_MAX
                      ? 0
                      : linear_depth_after[linear_depth_mismatch],
                  linear_depth_mismatch == UINT32_MAX
                      ? 0
                      : (linear_depth_mismatch % linear_depth_pitch <
                                 linear_depth_width
                             ? linear_depth_clear
                             : linear_depth_guest[linear_depth_mismatch]),
                  linear_stencil_after == linear_stencil_guest,
                  TextureCacheTestAccess::Contains(texture_cache,
                                                   linear_depth_image),
                  texture_cache.GetImage(linear_depth_image).IsGpuModified())
                  .c_str());

      constexpr uint64_t tiled_depth_offset = 0x380000;
      constexpr uint32_t tiled_depth_width = 3;
      constexpr uint32_t tiled_depth_height = 2;
      constexpr uint32_t tiled_depth_pitch = 4;
      constexpr uint32_t tiled_depth_layers = 2;
      constexpr uint64_t tiled_depth_slice = 0x10000;
      constexpr uint64_t tiled_depth_size =
          tiled_depth_slice * tiled_depth_layers;
      constexpr uint32_t tiled_depth_clear = 0x3f200000u;
      constexpr uint32_t tiled_depth_stale = 0xdeadbeefu;
      std::vector<uint32_t> tiled_depth_guest(
          tiled_depth_size / sizeof(uint32_t), tiled_depth_stale);
      std::memcpy(memory + tiled_depth_offset, tiled_depth_guest.data(),
                  tiled_depth_size);
      auto tiled_depth_desc = MakeLinearDesc(
          base + tiled_depth_offset, tiled_depth_size, vk::Format::eD32Sfloat,
          Prospero::BufferFormat::k32Float, Prospero::ImageType::kColor2D,
          {tiled_depth_width, tiled_depth_height, 1}, tiled_depth_layers, 4, 1);
      tiled_depth_desc.type = BindingType::DepthTarget;
      tiled_depth_desc.info.pitch = tiled_depth_pitch;
      tiled_depth_desc.info.tile_mode = Prospero::TileMode::kDepth;
      tiled_depth_desc.info.mip_layout[0] = {
          0, tiled_depth_size, tiled_depth_pitch, tiled_depth_height};
      tiled_depth_desc.view_info.aspect = vk::ImageAspectFlagBits::eDepth;
      tiled_depth_desc.view_info.usage =
          vk::ImageUsageFlagBits::eDepthStencilAttachment;
      const auto tiled_depth_image = texture_cache.FindImage(tiled_depth_desc);
      Require(name, "tiled depth native clear",
              texture_cache.ClearImageFromBuffer(
                  command, tiled_depth_desc.info.data.address,
                  tiled_depth_desc.info.data.size, tiled_depth_clear),
              "failed to create GPU-current layered tiled depth contents");
      const auto [tiled_prefix, tiled_prefix_offset] =
          TextureCacheTestAccess::MapDownload(texture_cache, 64, 64);
      Require(name, "tiled depth download prefix",
              tiled_prefix != nullptr && tiled_prefix_offset != 0,
              "failed to force a nonzero reusable-download offset");
      const auto tiled_depth_tick = scheduler.CurrentTick();
      Require(
          name, "tiled depth download queue",
          TextureCacheTestAccess::TryDownload(texture_cache, tiled_depth_image),
          "layered tiled depth readback was rejected");
      std::vector<uint32_t> tiled_depth_before(tiled_depth_guest.size());
      std::memcpy(tiled_depth_before.data(), memory + tiled_depth_offset,
                  tiled_depth_size);
      Require(name, "tiled depth deferred publication",
              tiled_depth_before == tiled_depth_guest &&
                  scheduler.CurrentTick() == tiled_depth_tick,
              "tiled depth readback published before GPU completion");
      scheduler.Finish();
      scheduler.DrainPriorityOperations();
      std::vector<uint32_t> tiled_depth_after(tiled_depth_guest.size());
      std::memcpy(tiled_depth_after.data(), memory + tiled_depth_offset,
                  tiled_depth_size);
      const auto active_tiled_words =
          tiled_depth_width * tiled_depth_height * tiled_depth_layers;
      const auto clear_tiled_words =
          std::ranges::count(tiled_depth_after, tiled_depth_clear);
      const auto stale_tiled_words =
          std::ranges::count(tiled_depth_after, tiled_depth_stale);
      Require(
          name, "tiled depth backing preservation",
          clear_tiled_words == active_tiled_words &&
              stale_tiled_words ==
                  tiled_depth_after.size() - active_tiled_words,
          fmt::format("tiled depth readback changed clear={}/{} stale={}/{}",
                      clear_tiled_words, active_tiled_words, stale_tiled_words,
                      tiled_depth_after.size() - active_tiled_words)
              .c_str());

      TileBlockLayout depth_block{};
      Require(name, "tiled depth block layout",
              TileGetBlockLayout(TileBlockFamily::Depth64KB, sizeof(uint32_t),
                                 depth_block),
              "failed to describe the tiled depth test surface");
      std::array<GpuTileInfo, tiled_depth_layers> tiled_depth_tiles{};
      for (uint32_t layer = 0; layer < tiled_depth_layers; layer++) {
        const uint64_t offset = tiled_depth_slice * layer;
        tiled_depth_tiles[layer] = {depth_block.family,
                                    depth_block.bytes_per_element,
                                    offset,
                                    tiled_depth_slice,
                                    offset,
                                    tiled_depth_slice,
                                    0,
                                    tiled_depth_width,
                                    tiled_depth_height,
                                    1,
                                    tiled_depth_pitch};
        tiled_depth_tiles[layer].surface_z = layer;
      }
      auto tiled_depth_input =
          CreateHostBuffer(name, tiled_depth_size, AllFlags, tiled_depth_after);
      auto tiled_depth_linear =
          TextureCacheTestAccess::Tiler(texture_cache)
              .Detile(tiled_depth_input.buffer, 0, tiled_depth_size,
                      tiled_depth_size, tiled_depth_tiles);
      auto tiled_depth_output =
          CreateHostBuffer(name, tiled_depth_size, AllFlags,
                           std::vector<uint32_t>(tiled_depth_guest.size(), 0));
      const vk::BufferCopy tiled_depth_copy{tiled_depth_linear.offset, 0,
                                            tiled_depth_size};
      scheduler.Current().Handle().copyBuffer(tiled_depth_linear.buffer,
                                              tiled_depth_output.buffer, 1,
                                              &tiled_depth_copy);
      HostReadBarrier(tiled_depth_output.buffer, tiled_depth_size,
                      vk::PipelineStageFlagBits::eTransfer,
                      vk::AccessFlagBits::eTransferWrite);
      scheduler.Finish();
      const auto tiled_depth_words =
          ReadBuffer(name, tiled_depth_output, tiled_depth_guest.size());
      bool tiled_depth_matches = true;
      for (uint32_t layer = 0; layer < tiled_depth_layers; layer++) {
        for (uint32_t y = 0; y < tiled_depth_height; y++) {
          for (uint32_t x = 0; x < tiled_depth_width; x++) {
            const auto index = layer * (tiled_depth_slice / sizeof(uint32_t)) +
                               y * tiled_depth_pitch + x;
            tiled_depth_matches &=
                tiled_depth_words[index] == tiled_depth_clear;
          }
        }
      }
      Require(name, "tiled depth layered contents",
              tiled_depth_matches &&
                  TextureCacheTestAccess::Contains(texture_cache,
                                                   tiled_depth_image) &&
                  texture_cache.GetImage(tiled_depth_image).IsGpuModified(),
              "tiled depth readback lost a padded slice or retired its image");
      DestroyBuffer(&tiled_depth_output);
      DestroyBuffer(&tiled_depth_input);

      constexpr uint64_t tiled_d16_offset = 0x3a0000;
      constexpr uint64_t tiled_d16_stencil_offset = 0x3c0000;
      constexpr uint16_t tiled_d16_clear = 0x8000u;
      constexpr uint16_t tiled_d16_stale = 0xbeefu;
      std::vector<uint16_t> tiled_d16_guest(tiled_depth_size / sizeof(uint16_t),
                                            tiled_d16_stale);
      constexpr std::array<uint8_t, 16> tiled_d16_stencil{
          0x10, 0x21, 0x32, 0x43, 0x54, 0x65, 0x76, 0x87,
          0x98, 0xa9, 0xba, 0xcb, 0xdc, 0xed, 0xfe, 0x0f};
      std::memcpy(memory + tiled_d16_offset, tiled_d16_guest.data(),
                  tiled_depth_size);
      std::memcpy(memory + tiled_d16_stencil_offset, tiled_d16_stencil.data(),
                  tiled_d16_stencil.size());
      auto tiled_d16_desc = MakeLinearDesc(
          base + tiled_d16_offset, tiled_depth_size,
          vk::Format::eD32SfloatS8Uint, Prospero::BufferFormat::k16UNorm,
          Prospero::ImageType::kColor2D,
          {tiled_depth_width, tiled_depth_height, 1}, tiled_depth_layers, 2, 1);
      tiled_d16_desc.type = BindingType::DepthTarget;
      tiled_d16_desc.info.pitch = tiled_depth_pitch;
      tiled_d16_desc.info.tile_mode = Prospero::TileMode::kDepth;
      tiled_d16_desc.info.stencil = {base + tiled_d16_stencil_offset,
                                     tiled_d16_stencil.size()};
      tiled_d16_desc.info.mip_layout[0] = {
          0, tiled_depth_size, tiled_depth_pitch, tiled_depth_height};
      tiled_d16_desc.view_info.aspect =
          vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil;
      tiled_d16_desc.view_info.usage =
          vk::ImageUsageFlagBits::eDepthStencilAttachment;
      const auto tiled_d16_image = texture_cache.FindImage(tiled_d16_desc);
      Require(name, "tiled D16 native clear",
              texture_cache.ClearImageFromBuffer(
                  command, tiled_d16_desc.info.data.address,
                  tiled_d16_desc.info.data.size,
                  EncodeD16AsD32(tiled_d16_clear)),
              "failed to clear a layered tiled D16 fallback image");
      Require(
          name, "tiled D16 download queue",
          TextureCacheTestAccess::TryDownload(texture_cache, tiled_d16_image),
          "layered tiled D16 fallback readback was rejected");
      scheduler.Finish();
      scheduler.DrainPriorityOperations();
      std::vector<uint16_t> tiled_d16_after(tiled_d16_guest.size());
      std::array<uint8_t, tiled_d16_stencil.size()> tiled_d16_stencil_after{};
      std::memcpy(tiled_d16_after.data(), memory + tiled_d16_offset,
                  tiled_depth_size);
      std::memcpy(tiled_d16_stencil_after.data(),
                  memory + tiled_d16_stencil_offset,
                  tiled_d16_stencil_after.size());
      Require(name, "tiled D16 backing preservation",
              std::ranges::count(tiled_d16_after, tiled_d16_clear) ==
                      active_tiled_words &&
                  std::ranges::count(tiled_d16_after, tiled_d16_stale) ==
                      tiled_d16_after.size() - active_tiled_words &&
                  tiled_d16_stencil_after == tiled_d16_stencil,
              "tiled D16 fallback overwrote inactive depth or stencil backing");

      std::vector<uint32_t> tiled_d16_words(tiled_depth_size /
                                            sizeof(uint32_t));
      std::memcpy(tiled_d16_words.data(), tiled_d16_after.data(),
                  tiled_depth_size);
      std::array<GpuTileInfo, tiled_depth_layers> tiled_d16_tiles{};
      Require(name, "tiled D16 block layout",
              TileGetBlockLayout(TileBlockFamily::Depth64KB, sizeof(uint16_t),
                                 depth_block),
              "failed to describe the tiled D16 test surface");
      for (uint32_t layer = 0; layer < tiled_depth_layers; layer++) {
        const uint64_t offset = tiled_depth_slice * layer;
        tiled_d16_tiles[layer] = {depth_block.family,
                                  depth_block.bytes_per_element,
                                  offset,
                                  tiled_depth_slice,
                                  offset,
                                  tiled_depth_slice,
                                  0,
                                  tiled_depth_width,
                                  tiled_depth_height,
                                  1,
                                  tiled_depth_pitch};
        tiled_d16_tiles[layer].surface_z = layer;
      }
      auto tiled_d16_input =
          CreateHostBuffer(name, tiled_depth_size, AllFlags, tiled_d16_words);
      auto tiled_d16_linear =
          TextureCacheTestAccess::Tiler(texture_cache)
              .Detile(tiled_d16_input.buffer, 0, tiled_depth_size,
                      tiled_depth_size, tiled_d16_tiles);
      auto tiled_d16_output =
          CreateHostBuffer(name, tiled_depth_size, AllFlags,
                           std::vector<uint32_t>(tiled_d16_words.size(), 0));
      const vk::BufferCopy tiled_d16_copy{tiled_d16_linear.offset, 0,
                                          tiled_depth_size};
      scheduler.Current().Handle().copyBuffer(
          tiled_d16_linear.buffer, tiled_d16_output.buffer, 1, &tiled_d16_copy);
      HostReadBarrier(tiled_d16_output.buffer, tiled_depth_size,
                      vk::PipelineStageFlagBits::eTransfer,
                      vk::AccessFlagBits::eTransferWrite);
      scheduler.Finish();
      const auto tiled_d16_linear_words =
          ReadBuffer(name, tiled_d16_output, tiled_d16_words.size());
      std::vector<uint16_t> tiled_d16_linear_values(tiled_d16_guest.size());
      std::memcpy(tiled_d16_linear_values.data(), tiled_d16_linear_words.data(),
                  tiled_depth_size);
      bool tiled_d16_matches = true;
      for (uint32_t layer = 0; layer < tiled_depth_layers; layer++) {
        for (uint32_t y = 0; y < tiled_depth_height; y++) {
          for (uint32_t x = 0; x < tiled_depth_width; x++) {
            const auto index = layer * (tiled_depth_slice / sizeof(uint16_t)) +
                               y * tiled_depth_pitch + x;
            tiled_d16_matches &=
                tiled_d16_linear_values[index] == tiled_d16_clear;
          }
        }
      }
      Require(name, "tiled D16 layered contents",
              tiled_d16_matches &&
                  TextureCacheTestAccess::Contains(texture_cache,
                                                   tiled_d16_image) &&
                  texture_cache.GetImage(tiled_d16_image).IsGpuModified(),
              "tiled D16 fallback lost a converted layer or retired its image");
      DestroyBuffer(&tiled_d16_output);
      DestroyBuffer(&tiled_d16_input);

      constexpr uint64_t d16_fallback_offset = 0x33c000;
      constexpr uint64_t d16_fallback_stencil_offset = 0x33d000;
      constexpr std::array<uint16_t, 4> d16_fallback_values{0x0000u, 0x2468u,
                                                            0xabcdu, 0xffffu};
      std::memcpy(memory + d16_fallback_offset, d16_fallback_values.data(),
                  sizeof(d16_fallback_values));
      std::memset(memory + d16_fallback_stencil_offset, 0x6d, 4);
      auto d16_depth_desc = MakeLinearDesc(
          base + d16_fallback_offset, sizeof(d16_fallback_values),
          vk::Format::eD24UnormS8Uint, Prospero::BufferFormat::k16UNorm,
          Prospero::ImageType::kColor2D, {4, 1, 1}, 1, 2, 1);
      d16_depth_desc.type = BindingType::DepthTarget;
      d16_depth_desc.info.stencil = {base + d16_fallback_stencil_offset, 4};
      d16_depth_desc.view_info.aspect =
          vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil;
      d16_depth_desc.view_info.usage =
          vk::ImageUsageFlagBits::eDepthStencilAttachment;
      const auto d16_depth_image = texture_cache.FindImage(d16_depth_desc);
      (void)texture_cache.FindDepthTarget(d16_depth_image, d16_depth_desc);
      texture_cache.MarkGpuWritten(d16_depth_image);
      auto d16_storage_desc = d16_depth_desc;
      d16_storage_desc.type = BindingType::Storage;
      d16_storage_desc.info.stencil = {};
      d16_storage_desc.info.pixel_format = vk::Format::eR16Unorm;
      d16_storage_desc.view_info.format = vk::Format::eR16Unorm;
      d16_storage_desc.view_info.aspect = vk::ImageAspectFlagBits::eColor;
      d16_storage_desc.view_info.usage = vk::ImageUsageFlagBits::eStorage;
      const auto d16_storage_image =
          texture_cache.FindImage(d16_storage_desc, true);
      auto d16_storage_readback = CreateHostBuffer(
          name, sizeof(d16_fallback_values),
          vk::BufferUsageFlagBits::eTransferDst, std::vector<u32>(2, 0));
      auto &d16_storage_native = texture_cache.GetImage(d16_storage_image);
      d16_storage_native.Transit(vk::ImageLayout::eTransferSrcOptimal,
                                 vk::AccessFlagBits2::eTransferRead, {},
                                 scheduler.Current().Handle());
      vk::BufferImageCopy d16_storage_copy{};
      d16_storage_copy.bufferRowLength = 4;
      d16_storage_copy.imageSubresource = {vk::ImageAspectFlagBits::eColor, 0,
                                           0, 1};
      d16_storage_copy.imageExtent = {4, 1, 1};
      scheduler.Current().Handle().copyImageToBuffer(
          d16_storage_native.backing.image,
          vk::ImageLayout::eTransferSrcOptimal, d16_storage_readback.buffer, 1,
          &d16_storage_copy);
      HostReadBarrier(d16_storage_readback.buffer, d16_storage_readback.size,
                      vk::PipelineStageFlagBits::eTransfer,
                      vk::AccessFlagBits::eTransferWrite);
      scheduler.Finish();
      const auto d16_storage_words = ReadBuffer(name, d16_storage_readback, 2);
      std::array<uint16_t, 4> d16_storage_values{};
      std::memcpy(d16_storage_values.data(), d16_storage_words.data(),
                  sizeof(d16_storage_values));
      Require(
          name, "D16 fallback depth/storage copy",
          d16_storage_values == d16_fallback_values &&
              d16_storage_image != d16_depth_image &&
              texture_cache.GetImage(d16_storage_image).IsGpuModified(),
          "D16 fallback reinterpreted four-byte host depth as two-byte color");
      DestroyBuffer(&d16_storage_readback);

      if (!texture_cache.GetImage(combined_destination_image).IsGpuModified()) {
        texture_cache.MarkGpuWritten(combined_destination_image);
      }
      constexpr float stale_added_stencil_depth = 0.125f;
      Libs::LibKernel::Memory::WriteBacking(
          combined_destination.info.data.address, &stale_added_stencil_depth,
          sizeof(stale_added_stencil_depth));
      const auto depth_gc_tick = scheduler.CurrentTick();
      TextureCacheTestAccess::ConfigureGarbageCollection(
          texture_cache, std::array{combined_destination_image}, 81, 0);
      texture_cache.RunGarbageCollector();
      float depth_before_completion = 0.0f;
      Libs::LibKernel::Memory::TryReadBacking(
          combined_destination.info.data.address, &depth_before_completion,
          sizeof(depth_before_completion));
      const bool depth_image_retired = !TextureCacheTestAccess::Contains(
          texture_cache, combined_destination_image);
      const bool depth_proxy_retired = !texture_cache.FindImageFromRange(
          base + added_stencil_offset, added_stencil_size, false);
      Require(
          name, "depth/stencil deferred pressure retirement",
          depth_image_retired && depth_proxy_retired &&
              scheduler.CurrentTick() == depth_gc_tick &&
              depth_before_completion == stale_added_stencil_depth,
          fmt::format(
              "GC failed to retire/defer depth: image={} proxy={} tick={}/{} "
              "depth={}/{}",
              depth_image_retired, depth_proxy_retired, scheduler.CurrentTick(),
              depth_gc_tick, depth_before_completion, stale_added_stencil_depth)
              .c_str());
      scheduler.Finish();
      scheduler.DrainPriorityOperations();
      float depth_after_completion = 0.0f;
      Libs::LibKernel::Memory::TryReadBacking(
          combined_destination.info.data.address, &depth_after_completion,
          sizeof(depth_after_completion));
      Require(name, "depth/stencil depth-plane preservation",
              depth_after_completion == added_stencil_depth_value,
              "GC discarded the current depth plane of a depth/stencil "
              "image");

      constexpr size_t gc_depth_pair_count = 6;
      constexpr uint64_t gc_depth_pair_offset = 0x350000;
      constexpr uint64_t gc_depth_pair_stride = 0x1000;
      std::array<ImageId, gc_depth_pair_count> gc_depth_images{};
      std::array<ImageId, gc_depth_pair_count> gc_stencil_images{};
      std::array<ImageId, gc_depth_pair_count * 2> gc_depth_lru{};
      for (size_t index = 0; index < gc_depth_pair_count; index++) {
        auto depth = MakeLinearDesc(
            base + gc_depth_pair_offset + index * gc_depth_pair_stride,
            sizeof(float), vk::Format::eD32SfloatS8Uint,
            Prospero::BufferFormat::k32Float, Prospero::ImageType::kColor2D,
            {1, 1, 1}, 1, 4, 1);
        depth.type = BindingType::DepthTarget;
        depth.info.stencil = {depth.info.data.address +
                                  gc_depth_pair_stride / 2,
                              sizeof(uint32_t)};
        depth.view_info.format = vk::Format::eD32SfloatS8Uint;
        depth.view_info.aspect =
            vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil;
        depth.view_info.usage = vk::ImageUsageFlagBits::eDepthStencilAttachment;
        gc_depth_images[index] = texture_cache.FindImage(depth);
        TextureCacheTestAccess::AssociateStencil(
            texture_cache, gc_depth_images[index], depth.info.stencil);
        gc_stencil_images[index] = texture_cache.FindImageFromRange(
            depth.info.stencil.address, depth.info.stencil.size, false);
        gc_depth_lru[index * 2] = gc_depth_images[index];
        gc_depth_lru[index * 2 + 1] = gc_stencil_images[index];
      }
      Require(
          name, "depth/stencil GC fixtures",
          std::ranges::all_of(gc_depth_images,
                              [](ImageId image) { return bool{image}; }) &&
              std::ranges::all_of(gc_stencil_images,
                                  [](ImageId image) { return bool{image}; }),
          "failed to create six depth/stencil association pairs");
      TextureCacheTestAccess::ConfigureGarbageCollection(
          texture_cache, gc_depth_lru, 81, UINT64_MAX);
      texture_cache.RunGarbageCollector();
      bool gc_depth_budget = true;
      for (size_t index = 0; index < gc_depth_pair_count; index++) {
        const bool expected_live = index == gc_depth_pair_count - 1;
        gc_depth_budget &=
            TextureCacheTestAccess::Contains(
                texture_cache, gc_depth_images[index]) == expected_live &&
            TextureCacheTestAccess::Contains(
                texture_cache, gc_stencil_images[index]) == expected_live;
      }
      Require(name, "depth/stencil GC traversal budget", gc_depth_budget,
              "recursive association deletion stopped LRU traversal or "
              "exceeded the ten-entry deletion budget");

      constexpr uint64_t large_offset = 0x400000;
      constexpr uint32_t large_width = 4096;
      constexpr uint32_t large_height = 2047;
      constexpr uint64_t large_size =
          uint64_t{large_width} * large_height * sizeof(uint32_t);
      static_assert(large_size < (32ull << 20));
      std::memset(memory + large_offset, 0, static_cast<size_t>(large_size));
      auto large_desc = MakeLinearDesc(
          base + large_offset, large_size, vk::Format::eR8G8B8A8Unorm,
          Prospero::BufferFormat::k8_8_8_8UNorm, Prospero::ImageType::kColor2D,
          {large_width, large_height, 1}, 1, 4, 1);
      const auto RunLargeReadback = [&](uint32_t clear_value) {
        const auto image = texture_cache.FindImage(large_desc);
        Require(name, "near-capacity image clear",
                texture_cache.ClearImageFromBuffer(
                    command, large_desc.info.data.address,
                    large_desc.info.data.size, clear_value),
                "failed to write the near-capacity readback source image");
        const std::array<uint64_t, 3> sample_offsets{
            0, large_size / 2, large_size - sizeof(uint32_t)};
        constexpr uint32_t stale = 0;
        for (const auto offset : sample_offsets) {
          Libs::LibKernel::Memory::WriteBacking(base + large_offset + offset,
                                                &stale, sizeof(stale));
        }
        TextureCacheTestAccess::ConfigureGarbageCollection(
            texture_cache, std::array{image}, 81, 0);
        const auto tick = scheduler.CurrentTick();
        texture_cache.RunGarbageCollector();
        const auto handle =
            BufferCacheTestAccess::DownloadBuffer(resources.GetBufferCache())
                .Handle();
        Require(
            name, "near-capacity deferred retirement",
            !TextureCacheTestAccess::Contains(texture_cache, image) &&
                scheduler.CurrentTick() == tick,
            "near-capacity readback was rejected or synchronously submitted");
        scheduler.Finish();
        scheduler.DrainPriorityOperations();
        bool content = true;
        for (const auto offset : sample_offsets) {
          uint32_t value = 0;
          Libs::LibKernel::Memory::TryReadBacking(base + large_offset + offset,
                                                  &value, sizeof(value));
          content &= value == clear_value;
        }
        Require(
            name, "near-capacity readback content", content,
            "near-capacity image readback did not publish its GPU contents");
        return handle;
      };
      const auto large_download = RunLargeReadback(0xa5a5a5a5u);
      const auto reused_large_download = RunLargeReadback(0x5a5a5a5au);
      Require(name, "near-capacity shared download reuse",
              large_download == reused_large_download,
              "successive near-capacity image transfers replaced the shared "
              "download buffer");

      constexpr uint64_t tile_alias_offset = 0x2000000;
      constexpr uint64_t tile_alias_size = 0x400000;
      constexpr uint32_t tile_alias_extent = 1024;
      std::memset(memory + tile_alias_offset, 0,
                  static_cast<size_t>(tile_alias_size));
      auto render_target_alias = MakeLinearDesc(
          base + tile_alias_offset, tile_alias_size, vk::Format::eR8G8B8A8Unorm,
          Prospero::BufferFormat::k8_8_8_8UNorm, Prospero::ImageType::kColor2D,
          {tile_alias_extent, tile_alias_extent, 1}, 1, 4, 1);
      render_target_alias.type = BindingType::Storage;
      render_target_alias.info.tile_mode = Prospero::TileMode::kRenderTarget;
      render_target_alias.view_info.usage = vk::ImageUsageFlagBits::eStorage;
      const auto render_target_alias_image =
          texture_cache.FindImage(render_target_alias);

      auto standard_4kb_alias = render_target_alias;
      standard_4kb_alias.type = BindingType::Texture;
      standard_4kb_alias.info.tile_mode = Prospero::TileMode::kStandard4KB;
      standard_4kb_alias.view_info.usage = vk::ImageUsageFlagBits::eSampled;
      const auto standard_4kb_alias_image =
          texture_cache.FindImage(standard_4kb_alias);
      auto repeated_standard_4kb_alias = standard_4kb_alias;
      const auto repeated_standard_4kb_alias_image =
          texture_cache.FindImage(repeated_standard_4kb_alias);
      Require(
          name, "equal-size tile-mode alias",
          render_target_alias_image && standard_4kb_alias_image &&
              standard_4kb_alias_image != render_target_alias_image &&
              repeated_standard_4kb_alias_image == standard_4kb_alias_image &&
              texture_cache.GetImage(render_target_alias_image)
                      .info.tile_mode == Prospero::TileMode::kRenderTarget &&
              texture_cache.GetImage(standard_4kb_alias_image).info.tile_mode ==
                  Prospero::TileMode::kStandard4KB,
          "equal address/size lookup reused an incompatible "
          "tiled backing");

      for (auto &output : ms_observer_outputs) {
        DestroyBuffer(&output);
      }
      DestroyBuffer(&layered_readback);
      DestroyBuffer(&bgra16_readback);
      DestroyBuffer(&mixed_source_readback);
      DestroyBuffer(&bridged_source_readback);
      DestroyBuffer(&mip_formatted_readback);
      DestroyBuffer(&mip_prefix_readback);
      DestroyBuffer(&partial_cpu_refresh_readback);
      DestroyBuffer(&mirror_cpu_readback);
      DestroyBuffer(&exact_buffer_readback);
      m_device.destroyDescriptorPool(observer_pool, nullptr);
      m_device.destroyPipeline(observer_depth_pipeline, nullptr);
      m_device.destroyPipelineLayout(observer_pipeline_layout, nullptr);
      m_device.destroyDescriptorSetLayout(observer_set_layout, nullptr);
      m_device.destroyShaderModule(ms_depth_module, nullptr);

      constexpr uint64_t mapped_end = base + allocation_size;
      constexpr uint64_t final_word_address = mapped_end - sizeof(uint32_t);
      auto *final_word = reinterpret_cast<volatile uint32_t *>(final_word_address);
      auto *final_byte = reinterpret_cast<volatile uint8_t *>(mapped_end - 1);
      Require(name, "fault boundary containment",
              resources.IsMapped(final_word_address, sizeof(uint32_t)) &&
                  !resources.IsMapped(final_word_address, sizeof(uint64_t)) &&
                  !resources.HandleFault(PageFaultAccess::Write, mapped_end) &&
                  !resources.HandleFault(PageFaultAccess::Read, mapped_end),
              "fault handling changed the mapped range's exclusive end");
      Require(name, "fault boundary setup",
              resources.InvalidateMemory(final_word_address, sizeof(uint32_t)),
              "the final mapped word could not be initialized");
      *final_word = 0;
      auto final_word_desc = MakeLinearDesc(
          final_word_address, sizeof(uint32_t), vk::Format::eR32Uint,
          Prospero::BufferFormat::k32UInt, Prospero::ImageType::kColor2D,
          {1, 1, 1}, 1, 4, 1);
      const auto final_word_image = texture_cache.FindImage(final_word_desc);
      (void)texture_cache.FindTexture(final_word_image, final_word_desc);
      Require(name, "fault boundary image tracking",
              texture_cache.GetImage(final_word_image).IsTracked() &&
                  !texture_cache.GetImage(final_word_image).IsCpuDirty(),
              "the final mapped word's image was not clean before its CPU store");
      *final_word = 45;
      Require(name, "fault boundary CPU store",
              *final_word == 45 &&
                  texture_cache.GetImage(final_word_image).IsDefinitelyCpuDirty(),
              "a valid four-byte store at the mapping end did not invalidate its image");

      constexpr uint32_t final_gpu_value = 0xa1b2c3d4u;
      auto &boundary_buffer_cache = resources.GetBufferCache();
      (void)boundary_buffer_cache.ObtainBuffer(final_word_address, sizeof(uint32_t), true);
      boundary_buffer_cache.FillBuffer(final_word_address, sizeof(uint32_t),
                                       final_gpu_value, false);
      Require(name, "fault boundary GPU ownership",
              boundary_buffer_cache.HasGpuDirtyBytes(final_word_address, sizeof(uint32_t)) &&
                  !HostMemoryIsReadable(mapped_end - 1),
              "the final mapped byte was not protected by GPU ownership");
      const uint8_t final_gpu_byte = *final_byte;
      Require(name, "fault boundary GPU readback",
              final_gpu_byte == static_cast<uint8_t>(final_gpu_value >> 24u) &&
                  *final_word == final_gpu_value &&
                  !boundary_buffer_cache.HasGpuDirtyBytes(final_word_address, sizeof(uint32_t)),
              "a final-byte CPU read did not publish the GPU-owned final word");

      resources.UnmapMemory(base, allocation_size);
      scheduler.Finish();
      LibKernel::Memory::InstallGpuResources(nullptr);
    }
    context.ShutdownGpu();
    Require(name, "unmap direct backing",
            Libs::LibKernel::Memory::KernelMunmap(base, allocation_size) == 0,
            "cache direct-memory mapping release failed");
    Require(name, "release direct backing",
            Libs::LibKernel::Memory::KernelReleaseDirectMemory(
                direct_offset, allocation_size) == 0,
            "cache direct-memory allocation release failed");
    std::printf("[host]    %-32s ok\n", name);
  }

  void CheckBgra16Readback() {
    constexpr const char *name = "Bgra16Readback";
    constexpr uintptr_t base = 0x0000000204000000ull;
    constexpr uint64_t allocation_size = 0x200000;
    constexpr auto format = Prospero::BufferFormat::k16_16_16_16Float;
    constexpr auto tile = Prospero::TileMode::kRenderTarget;
    EnsureRuntimeContext();

    int64_t direct_offset = -1;
    Require(name, "direct allocation",
            Libs::LibKernel::Memory::KernelAllocateDirectMemory(
                0, Libs::LibKernel::Memory::KernelGetDirectMemorySize(),
                allocation_size, allocation_size, 0, &direct_offset) == 0,
            "BGRA16 direct-memory allocation failed");
    void *mapped = reinterpret_cast<void *>(base);
    Require(name, "direct mapping",
            Libs::LibKernel::Memory::KernelMapDirectMemory(
                &mapped, allocation_size, 0x3, 0x10, direct_offset,
                allocation_size) == 0 &&
                mapped == reinterpret_cast<void *>(base),
            "BGRA16 fixed mapping failed");

    RenderContext context(m_runtime_context);
    auto &scheduler = context.GetCommandScheduler();
    HW::Context registers{};
    HW::UserConfig user_config{};
    HW::Shader shaders{};
    scheduler.Begin(registers, user_config, shaders);
    {
      auto &resources = context;
      resources.MapMemory(base, allocation_size);
      const uint32_t pitch = TileGetTexturePitch(format, 1, tile);
      TileSizeAlign total{};
      TileSizeOffset mip{};
      TilePaddedSize padded{};
      TileGetTextureSize(format, 1, 1, 1, tile, &total, &mip, &padded);
      Require(name, "tiled layout",
              total.size >= 8 && total.size <= allocation_size,
              "BGRA16 tiled layout exceeds its guest allocation");
      std::memset(mapped, 0x5a, total.size);

      ImageDesc desc{};
      desc.type = BindingType::RenderTarget;
      desc.info.data = {base, total.size};
      desc.info.pixel_format = vk::Format::eR16G16B16A16Sfloat;
      desc.info.guest_format = format;
      desc.info.type = Prospero::ImageType::kColor2D;
      desc.info.extent = {1, 1, 1};
      desc.info.resources = {1, 1};
      desc.info.pitch = pitch;
      desc.info.bytes_per_block = 8;
      desc.info.samples = 1;
      desc.info.tile_mode = tile;
      desc.info.bgra16 = true;
      desc.info.mip_layout[0] = {mip.offset, mip.size, pitch, 1};
      desc.view_info.format = desc.info.pixel_format;
      desc.view_info.type = vk::ImageViewType::e2D;
      desc.view_info.aspect = vk::ImageAspectFlagBits::eColor;
      desc.view_info.usage = vk::ImageUsageFlagBits::eColorAttachment;

      auto &cache = resources.GetTextureCache();
      const auto id = cache.FindImage(desc);
      auto &image = cache.GetImage(id);
      image.Transit(vk::ImageLayout::eTransferDstOptimal,
                    vk::AccessFlagBits2::eTransferWrite, {},
                    scheduler.Current().Handle());
      vk::ClearColorValue clear{};
      clear.float32[0] = 1.0f;
      clear.float32[1] = 2.0f;
      clear.float32[2] = 3.0f;
      clear.float32[3] = 4.0f;
      const vk::ImageSubresourceRange range{vk::ImageAspectFlagBits::eColor, 0,
                                            1, 0, 1};
      scheduler.Current().Handle().clearColorImage(
          image.backing.image, vk::ImageLayout::eTransferDstOptimal, clear,
          range);
      cache.MarkGpuWritten(id);
      Require(name, "guest readback queue",
              TextureCacheTestAccess::TryDownload(cache, id),
              "tiled BGRA16 guest readback was rejected");
      auto mirror = resources.GetBufferCache().ObtainBuffer(base, total.size,
                                                            false, true);
      Require(name, "mirror owner", mirror.first != nullptr,
              "tiled BGRA16 mirror has no BufferCache owner");
      auto mirror_readback = CreateHostBuffer(
          name, 8, vk::BufferUsageFlagBits::eTransferDst, {0, 0});
      const vk::BufferCopy copy{mirror.second, 0, 8};
      scheduler.Current().Handle().copyBuffer(mirror.first->Handle(),
                                              mirror_readback.buffer, 1, &copy);
      vk::BufferMemoryBarrier barrier{};
      barrier.sType = vk::StructureType::eBufferMemoryBarrier;
      barrier.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
      barrier.dstAccessMask = vk::AccessFlagBits::eHostRead;
      barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
      barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
      barrier.buffer = mirror_readback.buffer;
      barrier.size = mirror_readback.size;
      scheduler.Current().Handle().pipelineBarrier(
          vk::PipelineStageFlagBits::eTransfer,
          vk::PipelineStageFlagBits::eHost, {}, 0, nullptr, 1, &barrier, 0,
          nullptr);
      scheduler.Finish();
      scheduler.DrainPriorityOperations();

      std::vector<uint8_t> backing(total.size);
      Require(name, "guest backing",
              Libs::LibKernel::Memory::TryReadBacking(base, backing.data(),
                                                      backing.size()),
              "tiled BGRA16 guest backing is unreadable");
      const std::array<uint16_t, 4> expected{0x4200u, 0x4000u, 0x3c00u,
                                             0x4400u};
      std::array<uint16_t, 4> observed{};
      std::memcpy(observed.data(), backing.data(), sizeof(observed));
      Require(name, "guest component order",
              observed == expected &&
                  std::all_of(backing.begin() + sizeof(observed), backing.end(),
                              [](uint8_t value) { return value == 0x5a; }),
              "tiled BGRA16 guest readback changed component order or padding");
      Require(name, "mirror component order",
              ReadBuffer(name, mirror_readback, 2) ==
                  std::vector<u32>{0x40004200u, 0x44003c00u},
              "tiled BGRA16 Buffer mirror changed guest component order");
      DestroyBuffer(&mirror_readback);
      resources.UnmapMemory(base, allocation_size);
      scheduler.Finish();
    }
    Require(name, "unmap",
            Libs::LibKernel::Memory::KernelMunmap(base, allocation_size) == 0,
            "BGRA16 fixed mapping release failed");
    Require(name, "release",
            Libs::LibKernel::Memory::KernelReleaseDirectMemory(
                direct_offset, allocation_size) == 0,
            "BGRA16 direct-memory release failed");
    std::printf("[gpu]     %-32s ok\n", name);
  }

  void CheckRenderExecutorColorDiscovery() {
    constexpr const char *name = "RenderExecutorColorDiscovery";
    constexpr uintptr_t base = 0x0000000203c00000ull;
    constexpr uint32_t width = 512;
    constexpr uint32_t height = 1;
    constexpr uint32_t bytes_per_element = 4;
    constexpr uint64_t allocation_alignment = 0x10000;
    EnsureRuntimeContext();

    const auto pitch =
        TileGetRenderTargetPitch(width, bytes_per_element, 0);
    TileSizeAlign layout{};
    Require(name, "tile layout",
            pitch != 0 && TileGetRenderTargetSize(
                              width, height, pitch, bytes_per_element, layout, 0),
            "1D render-target layout is unavailable");
    struct TargetCase {
      uint32_t width, height, dimension, pitch;
      uint64_t size;
      Prospero::TileMode tile;
    };
    const std::array cases{
        TargetCase{width, height, 0, pitch, layout.size,
                   Prospero::TileMode::kRenderTarget},
        // PPSA28068: the 1440x720 agreement target must alias its sampled texture.
        TargetCase{1440, 720, 1, 1472, 0x40b000, Prospero::TileMode::kLinear},
    };
    constexpr uint64_t allocation_size = 0x410000;

    int64_t direct_offset = -1;
    Require(name, "direct allocation",
            Libs::LibKernel::Memory::KernelAllocateDirectMemory(
                0, Libs::LibKernel::Memory::KernelGetDirectMemorySize(),
                allocation_size, allocation_alignment, 0, &direct_offset) == 0,
            "color direct-memory allocation failed");
    void *mapped = reinterpret_cast<void *>(base);
    Require(name, "direct mapping",
            Libs::LibKernel::Memory::KernelMapDirectMemory(
                &mapped, allocation_size, 0x3, 0x10, direct_offset,
                allocation_alignment) == 0 &&
                mapped == reinterpret_cast<void *>(base),
            "color fixed mapping failed");
    std::memset(mapped, 0, allocation_size);

    for (const auto &target : cases) {
      const auto width = target.width;
      const auto height = target.height;
      const bool is_1d = target.dimension == 0;
      RenderContext context(m_runtime_context);
      auto &scheduler = context.GetCommandScheduler();
      HW::Context registers{};
      HW::UserConfig user_config{};
      HW::Shader shaders{};
      registers.SetColorBase(0, {.addr = base});
      registers.SetColorInfo(
          0, {.format = Prospero::ChannelLayout::k8_8_8_8,
              .channel_type = Prospero::ChannelType::kSrgb,
              .channel_order = Prospero::ChannelOrder::kStandard});
      registers.SetColorAttrib2(0, {.height = height - 1, .width = width - 1});
      registers.SetColorAttrib3(0,
                                {.tile_mode = target.tile,
                                 .dimension = target.dimension,
                                 .metadata_pipe_aligned = true});
      registers.SetRenderTargetMask(0x0f);
      scheduler.Begin(registers, user_config, shaders);

      auto &resources = context;
      auto &texture_cache = resources.GetTextureCache();
      auto &executor = context.GetRenderExecutor();
      resources.MapMemory(base, allocation_size);

      RenderColorInfo color{};
      RenderExecutorTestAccess::ResolveRenderColorTarget(
          executor, scheduler.Current(), color, 0);
      const auto attachment =
          texture_cache.FindRenderTarget(color.image_id, color.desc);
      const auto &image = texture_cache.GetImage(color.image_id);
      RenderDepthInfo no_depth{};
      const auto rendering = RenderExecutorTestAccess::AcquireRenderTargets(
          executor, scheduler.Current(), &color, 1, no_depth);
      scheduler.Current().BeginRendering(rendering);
      scheduler.Current().EndRendering();
      Require(name, "captured color target",
              color.image_id && attachment != nullptr &&
                  rendering.color_attachments[0].image_view != nullptr &&
                  color.desc.info.type == (is_1d ? Prospero::ImageType::kColor1D
                                                  : Prospero::ImageType::kColor2D) &&
                  color.desc.info.extent == vk::Extent3D{width, height, 1} &&
                  color.desc.info.resources == ImageSubresources{1, 1} &&
                  color.desc.info.pitch == target.pitch &&
                  color.desc.info.data.size == target.size &&
                  color.desc.info.mip_layout[0].offset == 0 &&
                  color.desc.info.mip_layout[0].size == target.size &&
                  color.desc.view_info.type == (is_1d ? vk::ImageViewType::e1D
                                                       : vk::ImageViewType::e2D) &&
                  image.backing.image_type == (is_1d ? vk::ImageType::e1D
                                                      : vk::ImageType::e2D) &&
                  rendering.width == width && rendering.height == height &&
                  rendering.num_layers == 1 &&
                  rendering.num_color_attachments == 1,
              "color attachment lost its dimensions or padded guest layout");

      if (target.tile == Prospero::TileMode::kLinear) {
        vk::ClearValue clear{};
        clear.color.float32 = std::array{1.0f, 0.0f, 1.0f, 1.0f};
        TextureCacheTestAccess::ClearImage(
            texture_cache, scheduler.Current(), color.image_id,
            {vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1}, clear);
        RenderExecutorTestAccess::ResetBindings(executor);
        ShaderTextureResource descriptor{{
            static_cast<uint32_t>(base >> 8u),
            (static_cast<uint32_t>(Prospero::BufferFormat::k8_8_8_8Srgb) << 20u) |
                (((width - 1u) & 3u) << 30u),
            ((width - 1u) >> 2u) | ((height - 1u) << 14u),
            DstSel(4, 5, 6, 7) |
                (static_cast<uint32_t>(Prospero::ImageType::kColor2D) << 28u),
            0, 0x00700000u, 0, 0}};
        ShaderRecompiler::IR::DescriptorValue value{};
        value.dword_count = 8;
        std::copy_n(descriptor.fields, 8, value.dwords.begin());
        ShaderRecompiler::IR::ImageResource resource{};
        resource.resource_class = ShaderRecompiler::IR::ImageResourceClass::Sampled;
        resource.numeric_class = Prospero::TextureNumericClass::Float;
        resource.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2D;
        resource.read = true;
        const auto sampled =
            RenderExecutorTestAccess::ResolveTexture(executor, resource, value);
        Require(name, "linear target sampled alias",
                sampled.image_id == color.image_id &&
                    sampled.desc.info.pitch == target.pitch &&
                    sampled.desc.info.data.size == target.size &&
                    sampled.desc.info.mip_layout == color.desc.info.mip_layout &&
                    texture_cache.FindTexture(sampled.image_id, sampled.desc) != nullptr,
                "sampling the linear agreement target created a second image");
        Require(name, "linear target sampled contents",
                ReadCachedTexel(name, context, sampled.image_id,
                                {1439, 719, 0}) == std::vector<u32>{0xffff00ffu},
                "the sampled linear target lost its GPU-written final texel");
      }

      RenderExecutorTestAccess::ResetBindings(executor);
      resources.UnmapMemory(base, allocation_size);
      scheduler.Finish();
    }

    Require(name, "unmap direct backing",
            Libs::LibKernel::Memory::KernelMunmap(base, allocation_size) == 0,
            "color direct mapping release failed");
    Require(name, "release direct backing",
            Libs::LibKernel::Memory::KernelReleaseDirectMemory(
                direct_offset, allocation_size) == 0,
            "color direct-memory allocation release failed");
    std::printf("[gpu]     %-32s ok\n", name);
  }

  void CheckRenderExecutorColorVolumeDiscovery() {
    constexpr const char *name = "RenderExecutorColorVolumeDiscovery";
    constexpr uintptr_t base = 0x0000000203e00000ull;
    constexpr uint64_t color_size = 0x200000;
    constexpr uint64_t metadata_size = 0x20000;
    constexpr uint64_t allocation_size = color_size + metadata_size;
    constexpr uint64_t allocation_alignment = 0x10000;
    EnsureRuntimeContext();

    int64_t direct_offset = -1;
    Require(name, "direct allocation",
            Libs::LibKernel::Memory::KernelAllocateDirectMemory(
                0, Libs::LibKernel::Memory::KernelGetDirectMemorySize(),
                allocation_size, allocation_alignment, 0, &direct_offset) == 0,
            "color-volume direct-memory allocation failed");
    void *mapped = reinterpret_cast<void *>(base);
    Require(name, "direct mapping",
            Libs::LibKernel::Memory::KernelMapDirectMemory(
                &mapped, allocation_size, 0x3, 0x10, direct_offset,
                allocation_alignment) == 0 &&
                mapped == reinterpret_cast<void *>(base),
            "color-volume fixed mapping failed");
    std::memset(mapped, 0x5a, allocation_size);
    constexpr uint64_t slice_size = 0x10000;

    {
      RenderContext context(m_runtime_context);
      context.InitializeGpu(nullptr);
      LibKernel::Memory::InstallGpuResources(&context);
      auto &scheduler = context.GetCommandScheduler();
      HW::Context registers{};
      HW::UserConfig user_config{};
      HW::Shader shaders{};
      registers.SetColorBase(0, {.addr = base});
      registers.SetColorInfo(
          0, {.dcc_compression_enable = true,
              .format = Prospero::ChannelLayout::k10_10_10_2,
              .channel_type = Prospero::ChannelType::kUNorm,
              .channel_order = Prospero::ChannelOrder::kStandard});
      registers.SetColorAttrib2(0, {.height = 31, .width = 31});
      registers.SetColorAttrib3(0,
                                {.depth = 31,
                                 .tile_mode = Prospero::TileMode::kRenderTarget,
                                 .dimension = 2,
                                 .metadata_pipe_aligned = true});
      constexpr uint64_t dcc_address = base + color_size;
      registers.SetColorDccAddr(0, {.addr = dcc_address});
      registers.SetColorClearWord0(0, {.word0 = 0});
      registers.SetColorClearWord1(0, {.word1 = 0});
      registers.SetRenderTargetMask(0x0f);
      scheduler.Begin(registers, user_config, shaders);

      auto &resources = context;
      auto &texture_cache = resources.GetTextureCache();
      auto &executor = context.GetRenderExecutor();
      resources.MapMemory(base, allocation_size);
      WriteMetadata(context, dcc_address, metadata_size, 0);
      Require(name, "deferred DCC clear",
              !texture_cache.IsMeta(dcc_address),
              "a pre-registration DCC clear was not deferred");

      RenderColorInfo color{};
      RenderExecutorTestAccess::ResolveRenderColorTarget(
          executor, scheduler.Current(), color, 0);
      const auto attachment =
          texture_cache.FindRenderTarget(color.image_id, color.desc);
      const auto &image = texture_cache.GetImage(color.image_id);
      Require(
          name, "captured 3D target",
          color.image_id && attachment != nullptr &&
              color.desc.info.type == Prospero::ImageType::kColor3D &&
              color.desc.info.extent == vk::Extent3D{32, 32, 32} &&
              color.desc.info.resources == ImageSubresources{1, 1} &&
              color.desc.info.pitch == 128 &&
              color.desc.info.data.size == color_size &&
              color.desc.info.mip_layout[0].size == 0x10000 &&
              color.desc.info.metadata.kind == ImageMetadataKind::Dcc &&
              color.desc.info.metadata.range.address == dcc_address &&
              !texture_cache.IsMeta(dcc_address) && !texture_cache.ClearMeta(dcc_address) &&
              color.desc.view_info.type == vk::ImageViewType::e2D &&
              color.desc.view_info.layer_count == 1 &&
              image.backing.image_type == vk::ImageType::e3D &&
              static_cast<bool>(image.backing.flags &
                                vk::ImageCreateFlagBits::e2DArrayCompatible) &&
              image.usage.render_target && image.IsGpuModified(),
          "dimension=2/depth=31 did not create the expected 32x32x32 "
          "backing and 2D "
          "attachment slice");
      constexpr uint64_t metadata_slice_size = metadata_size / 32;
      std::vector<uint8_t> metadata_bytes(metadata_size);
      resources.GetBufferCache().ReadMemory(dcc_address, metadata_size);
      Require(name, "first volume slice expanded metadata",
              LibKernel::Memory::TryReadBacking(dcc_address, metadata_bytes.data(),
                                               metadata_bytes.size()) &&
                  std::all_of(metadata_bytes.begin(),
                              metadata_bytes.begin() + metadata_slice_size,
                              [](uint8_t byte) { return byte == 0xff; }) &&
                  std::all_of(metadata_bytes.begin() + metadata_slice_size,
                              metadata_bytes.end(), [](uint8_t byte) { return byte == 0; }),
              "consuming volume slice 0 changed unrequested native metadata slices");

      RenderExecutorTestAccess::ResetBindings(executor);
      registers.SetColorView(
          0, {.base_array_slice_index = 7, .last_array_slice_index = 7});
      RenderColorInfo sliced_color{};
      RenderExecutorTestAccess::ResolveRenderColorTarget(
          executor, scheduler.Current(), sliced_color, 0);
      RenderDepthInfo no_depth{};
      const auto sliced_rendering =
          RenderExecutorTestAccess::AcquireRenderTargets(
              executor, scheduler.Current(), &sliced_color, 1, no_depth);
      Require(
          name, "3D slice transition",
          sliced_color.image_id == color.image_id &&
              sliced_rendering.color_attachments[0].image_view != nullptr &&
              sliced_color.desc.view_info.base_layer == 7 &&
              sliced_rendering.num_color_attachments == 1 &&
              sliced_rendering.num_layers == 1,
          "a nonzero 3D attachment slice was treated as a Vulkan array layer");
      resources.GetBufferCache().ReadMemory(dcc_address, metadata_size);
      Require(name, "mixed volume metadata readback",
              LibKernel::Memory::TryReadBacking(dcc_address, metadata_bytes.data(),
                                               metadata_bytes.size()),
              "mixed volume metadata is unavailable");
      for (uint32_t slice = 0; slice < 32; slice++) {
        const uint8_t expected = slice == 0 || slice == 7 ? 0xff : 0;
        const auto first = metadata_bytes.begin() + slice * metadata_slice_size;
        Require(name, "independent volume metadata consumption",
                std::all_of(first, first + metadata_slice_size,
                            [expected](uint8_t byte) { return byte == expected; }),
                "mixed DCC metadata lost a pending slice or consumed an unrequested slice");
      }
      Require(name, "3D slice clear and preservation",
              ReadCachedTexel(name, context, color.image_id, {0, 0, 7}) ==
                  std::vector<u32>{0} &&
                  ReadCachedTexel(name, context, color.image_id, {0, 0, 31}) ==
                      std::vector<u32>{0x5a5a5a5a},
              "clearing one volume slice changed untouched slice contents");
      auto storage_desc = color.desc;
      storage_desc.type = BindingType::Storage;
      storage_desc.info.metadata = {};
      storage_desc.info.guest_format = Prospero::BufferFormat::k10_10_10_2UNorm;
      storage_desc.view_info.type = vk::ImageViewType::e3D;
      storage_desc.view_info.usage = vk::ImageUsageFlagBits::eStorage;
      const auto storage_id = texture_cache.FindImage(storage_desc);
      const auto storage_view =
          texture_cache.FindTexture(storage_id, storage_desc);
      const auto &shared_image = texture_cache.GetImage(storage_id);
      Require(name, "storage alias reuse",
              storage_id == color.image_id && storage_view != nullptr &&
                  shared_image.IsGpuModified() &&
                  shared_image.usage.render_target,
              "the matching 3D storage binding did not reuse the live "
              "render-target image");

      Require(
          name, "volume readback queue",
          TextureCacheTestAccess::TryDownload(texture_cache, storage_id),
          "the 3D render target could not be queued for guest-layout readback");
      auto mirror = resources.GetBufferCache().ObtainBuffer(
          base, color_size, false, true);
      Require(name, "volume mirror", mirror.first != nullptr,
              "the 3D render-target readback has no BufferCache owner");
      auto slice_probe =
          CreateHostBuffer(name, 4, vk::BufferUsageFlagBits::eTransferDst, {0});
      const vk::BufferCopy copy{mirror.second + 31 * slice_size, 0, 4};
      scheduler.Current().Handle().copyBuffer(mirror.first->Handle(),
                                              slice_probe.buffer, 1, &copy);
      vk::BufferMemoryBarrier barrier{};
      barrier.sType = vk::StructureType::eBufferMemoryBarrier;
      barrier.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
      barrier.dstAccessMask = vk::AccessFlagBits::eHostRead;
      barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
      barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
      barrier.buffer = slice_probe.buffer;
      barrier.size = slice_probe.size;
      scheduler.Current().Handle().pipelineBarrier(
          vk::PipelineStageFlagBits::eTransfer,
          vk::PipelineStageFlagBits::eHost, {}, 0, nullptr, 1, &barrier, 0,
          nullptr);
      scheduler.Finish();
      scheduler.DrainPriorityOperations();
      Require(name, "volume Z transfer",
              ReadBuffer(name, slice_probe, 1) == std::vector<u32>{0x5a5a5a5a},
              "render-target upload/readback lost the final Z slice");
      DestroyBuffer(&slice_probe);

      vk::ClearValue painted{};
      painted.color.float32 = std::array{1.0f, 1.0f, 1.0f, 0.0f};
      TextureCacheTestAccess::ClearImage(
          texture_cache, scheduler.Current(), color.image_id,
          {vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1}, painted);
      WriteMetadata(context, dcc_address, metadata_size, 0xffffffffu);
      color.image_id = texture_cache.FindImage(color.desc);
      (void)texture_cache.FindRenderTarget(color.image_id, color.desc);
      resources.GetBufferCache().ReadMemory(dcc_address, metadata_size);
      Require(name, "expanded volume metadata preserves rendering",
              ReadCachedTexel(name, context, color.image_id) ==
                  std::vector<u32>{0x3fffffffu} &&
                  LibKernel::Memory::TryReadBacking(dcc_address, metadata_bytes.data(),
                                                   metadata_bytes.size()) &&
                  std::all_of(metadata_bytes.begin(), metadata_bytes.end(),
                              [](uint8_t byte) { return byte == 0xff; }),
              "uncompressed native keys reapplied an old volume clear");
      WriteMetadata(context, dcc_address, metadata_size, 0);
      color.image_id = texture_cache.FindImage(color.desc);
      (void)texture_cache.FindRenderTarget(color.image_id, color.desc);
      resources.GetBufferCache().ReadMemory(dcc_address, metadata_size);
      Require(name, "native volume re-clear",
              ReadCachedTexel(name, context, color.image_id) == std::vector<u32>{0} &&
                  LibKernel::Memory::TryReadBacking(dcc_address, metadata_bytes.data(),
                                                   metadata_bytes.size()) &&
                  std::all_of(metadata_bytes.begin(),
                              metadata_bytes.begin() + metadata_slice_size,
                              [](uint8_t byte) { return byte == 0xff; }) &&
                  std::all_of(metadata_bytes.begin() + metadata_slice_size,
                              metadata_bytes.end(), [](uint8_t byte) { return byte == 0; }),
              "a native metadata overwrite did not clear only its requested volume slice");

      for (const uint32_t base_slice : {0u, 7u}) {
        RenderExecutorTestAccess::ResetBindings(executor);
        registers.SetColorView(0, {.base_array_slice_index = base_slice,
                                   .last_array_slice_index = 32});
        RenderColorInfo volume_color{};
        RenderExecutorTestAccess::ResolveRenderColorTarget(
            executor, scheduler.Current(), volume_color, 0);
        const auto volume_rendering =
            RenderExecutorTestAccess::AcquireRenderTargets(
                executor, scheduler.Current(), &volume_color, 1, no_depth);
        Require(name, "3D export bound exceeds depth",
                volume_color.image_id == color.image_id &&
                    volume_color.desc.info.extent == vk::Extent3D{32, 32, 32} &&
                    volume_color.desc.info.data.size == color_size &&
                    volume_color.desc.view_info.type == vk::ImageViewType::e2DArray &&
                    volume_color.desc.view_info.base_layer == base_slice &&
                    volume_color.desc.view_info.layer_count == 32 - base_slice &&
                    volume_rendering.num_layers == 32 - base_slice &&
                    registers.GetRenderTarget(0).view.last_array_slice_index == 32,
                "3D export bounds changed the backing or exceeded its attachment depth");
        scheduler.Current().BeginRendering(volume_rendering);
        scheduler.Current().EndRendering();
      }
      resources.GetBufferCache().ReadMemory(dcc_address, metadata_size);
      Require(name, "complete volume expansion",
              LibKernel::Memory::TryReadBacking(dcc_address, metadata_bytes.data(),
                                               metadata_bytes.size()) &&
                  std::all_of(metadata_bytes.begin(), metadata_bytes.end(),
                              [](uint8_t byte) { return byte == 0xff; }),
              "full volume acquisition left an unconsumed native clear slice");

      RenderExecutorTestAccess::ResetBindings(executor);
      resources.UnmapMemory(base, allocation_size);
      scheduler.Finish();
      context.ShutdownGpu();
      LibKernel::Memory::InstallGpuResources(nullptr);
    }

    Require(name, "unmap direct backing",
            Libs::LibKernel::Memory::KernelMunmap(base, allocation_size) == 0,
            "color-volume direct mapping release failed");
    Require(name, "release direct backing",
            Libs::LibKernel::Memory::KernelReleaseDirectMemory(
                direct_offset, allocation_size) == 0,
            "color-volume direct-memory allocation release failed");
    std::printf("[gpu]     %-32s ok\n", name);
  }

  static void WriteMetadata(RenderContext &context, uint64_t address,
                            uint64_t size, uint32_t value) {
    Require("DccMetadata", "guest write range", size % sizeof(value) == 0 &&
                context.InvalidateMemory(address, size),
            "metadata write is outside the mapped allocation");
    const std::vector<uint32_t> words(size / sizeof(value), value);
    LibKernel::Memory::WriteBacking(address, words.data(), size);
  }

  std::vector<u32> ReadCachedTexel(const char *name, RenderContext &context,
                                 ImageId id, vk::Offset3D offset = {},
                                 vk::Extent3D extent = {1, 1, 1}, uint32_t layer = 0,
                                 uint32_t mip = 0) {
    auto &scheduler = context.GetCommandScheduler();
    auto &image = context.GetTextureCache().GetImage(id);
    const auto bytes = image.info.bytes_per_block * extent.width *
                       extent.height * extent.depth;
    auto probe = CreateHostBuffer(name, bytes,
                                 vk::BufferUsageFlagBits::eTransferDst, {});
    scheduler.Current().EndRendering();
    image.Transit(vk::ImageLayout::eTransferSrcOptimal,
                  vk::AccessFlagBits2::eTransferRead, {},
                  scheduler.Current().Handle());
    vk::BufferImageCopy copy{};
    copy.imageSubresource = {image.info.IsDepth() ? vk::ImageAspectFlagBits::eDepth
                                                : vk::ImageAspectFlagBits::eColor, mip, layer, 1};
    copy.imageOffset = offset;
    copy.imageExtent = extent;
    scheduler.Current().Handle().copyImageToBuffer(
        image.backing.image, vk::ImageLayout::eTransferSrcOptimal,
        probe.buffer, 1, &copy);
    vk::BufferMemoryBarrier barrier{};
    barrier.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
    barrier.dstAccessMask = vk::AccessFlagBits::eHostRead;
    barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrier.buffer = probe.buffer;
    barrier.size = probe.size;
    scheduler.Current().Handle().pipelineBarrier(
        vk::PipelineStageFlagBits::eTransfer,
        vk::PipelineStageFlagBits::eHost, {}, 0, nullptr, 1, &barrier, 0,
        nullptr);
    scheduler.Finish();
    auto result = ReadBuffer(name, probe, bytes / 4);
    DestroyBuffer(&probe);
    return result;
  }

  void CheckRenderExecutorDccFixedClearFloat() {
    constexpr const char *name = "RenderExecutorDccFixedClearFloat";
    constexpr uintptr_t base = 0x0000000204100000ull;
    constexpr uint64_t allocation_size = 0x200000;
    constexpr uint64_t allocation_alignment = 0x10000;
    constexpr uint64_t dcc_address = base + 0x100000;
    struct FillCase {
      uint32_t fill;
      std::array<uint32_t, 2> texel;
      bool reuse_unorm = false;
    };
    constexpr std::array cases{
        FillCase{0x40404040u, {0, 0x3c000000u}},
        FillCase{0x80808080u, {0x3c003c00u, 0x00003c00u}},
        FillCase{0x40404040u, {0, 0x3c000000u}, true},
    };
    EnsureRuntimeContext();
    // Astro's generic metadata fill, through S_ENDPGM; trailing debug data is omitted.
    static constexpr std::array<uint32_t, 69> native_fill{
        0xbfa00003u, 0xd7460002u, 0x04010c0au, 0x7da80408u,
        0xbf88003fu, 0x7e000c09u, 0xbf070980u, 0x858a807eu,
        0x7e005700u, 0x100000ffu, 0x4f800000u, 0x7e060f00u,
        0xd5766a00u, 0x02020609u, 0x7d8a0280u, 0x4c020080u,
        0x02000101u, 0xd56a0001u, 0x00020700u, 0x4c000303u,
        0x4a020303u, 0x02000101u, 0xd56a0000u, 0x00020500u,
        0xd5690001u, 0x00020009u, 0x4c060302u, 0x7d860609u,
        0x7d8c02f9u, 0x06068c02u, 0x87ea6a0cu, 0x50000080u,
        0xd5286a00u, 0x003200c1u, 0xd5010000u, 0x002a00c1u,
        0xd5690000u, 0x00020009u, 0x4c000102u, 0x7d0a0080u,
        0xbe88246au, 0xbf880015u, 0x7d0a0081u, 0xbe8a246au,
        0xbf88000cu, 0x7d0a0082u, 0xbeea246au, 0xbf880003u,
        0x7e000207u, 0xe0102000u, 0x80000002u, 0x8afe7e6au,
        0xbf880003u, 0x7e000206u, 0xe0102000u, 0x80000002u,
        0xbefe046au, 0x8afe7e0au, 0xbf880003u, 0x7e000205u,
        0xe0102000u, 0x80000002u, 0xbefe040au, 0x8afe7e08u,
        0xbf880003u, 0x7e000204u, 0xe0102000u, 0x80000002u,
        0xbf810000u,
    };
    static constexpr auto raw_fill = [] {
      auto words = native_fill;
      for (auto &word : words) {
        if (word == 0xe0102000u) {
          word = 0xe0702000u; // BUFFER_STORE_DWORD in place of BUFFER_STORE_FORMAT_X.
        }
      }
      return words;
    }();
    for (const auto *shader : {&native_fill, &raw_fill}) {
      ShaderMapUserData(reinterpret_cast<uint64_t>(shader->data()),
          {.type = Prospero::ShaderBinaryType::kCs,
           .code_size_bytes = sizeof(native_fill)});
    }
    TileSizeAlign metadata_size{};
    (void)TileGetDccSize(512, 256, 1, 8, 1,
                        Prospero::TileMode::kRenderTarget, metadata_size, 0);

    int64_t direct_offset = -1;
    Require(name, "direct allocation",
            Libs::LibKernel::Memory::KernelAllocateDirectMemory(
                0, Libs::LibKernel::Memory::KernelGetDirectMemorySize(),
                allocation_size, allocation_alignment, 0, &direct_offset) == 0,
            "fixed-clear direct-memory allocation failed");
    void *mapped = reinterpret_cast<void *>(base);
    Require(name, "direct mapping",
            Libs::LibKernel::Memory::KernelMapDirectMemory(
                &mapped, allocation_size, 0x3, 0x10, direct_offset,
                allocation_alignment) == 0 &&
                mapped == reinterpret_cast<void *>(base),
            "fixed-clear direct mapping failed");
    std::memset(mapped, 0, allocation_size);

    for (const auto &fill_case : cases) {
      RenderContext context(m_runtime_context);
      HW::Context registers{};
      HW::UserConfig user_config{};
      HW::Shader shaders{};
      context.InitializeGpu(nullptr);
      LibKernel::Memory::InstallGpuResources(&context);
      context.GetGpu().SendCommandSync([&] {
        auto &scheduler = context.GetCommandScheduler();
        registers.SetColorBase(0, {.addr = base});
        registers.SetColorInfo(
            0, {.dcc_compression_enable = true,
                .format = Prospero::ChannelLayout::k16_16_16_16,
                .channel_type = Prospero::ChannelType::kFloat,
                .channel_order = Prospero::ChannelOrder::kStandard});
        registers.SetColorAttrib2(0, {.height = 255, .width = 511});
        registers.SetColorAttrib3(0,
                                  {.tile_mode = Prospero::TileMode::kRenderTarget,
                                   .dimension = 1,
                                   .metadata_pipe_aligned = true});
        registers.SetColorDccAddr(0, {.addr = dcc_address});
        registers.SetColorClearWord0(0, {.word0 = 0});
        registers.SetColorClearWord1(0, {.word1 = 0});
        registers.SetRenderTargetMask(0x0f);
        scheduler.Begin(registers, user_config, shaders);

        auto &resources = context;
        auto &texture_cache = resources.GetTextureCache();
        auto &executor = context.GetRenderExecutor();
        resources.MapMemory(base, allocation_size);
        ImageId unorm_id{};
        if (fill_case.reuse_unorm) {
          const auto float_info = registers.GetRenderTarget(0).info;
          auto unorm_info = float_info;
          unorm_info.dcc_compression_enable = false;
          unorm_info.channel_type = Prospero::ChannelType::kUNorm;
          registers.SetColorInfo(0, unorm_info);
          RenderColorInfo unorm{};
          RenderExecutorTestAccess::ResolveRenderColorTarget(
              executor, scheduler.Current(), unorm, 0);
          unorm_id = unorm.image_id;
          (void)texture_cache.FindRenderTarget(unorm_id, unorm.desc);
          RenderExecutorTestAccess::ResetBindings(executor);
          registers.SetColorInfo(0, float_info);
        }
        const auto fill_metadata = [&](uint32_t count, bool raw = false) {
          const auto *shader = &native_fill;
          if (raw) {
            shader = &raw_fill;
          }
          shaders.SetCsShader({.data_addr = reinterpret_cast<uint64_t>(shader->data()),
                               .num_thread_x = 64, .num_thread_y = 1, .num_thread_z = 1,
                               .wave_size = 64, .user_sgpr = 10, .tgid_x_en = true});
          const std::array<uint32_t, 10> user_data{
              static_cast<uint32_t>(dcc_address),
              static_cast<uint32_t>(dcc_address >> 32u) | (4u << 16u),
              count, 0x00014004u, fill_case.fill, 0, 0x200, 0, count, 1};
          for (uint32_t i = 0; i < user_data.size(); i++) {
            shaders.SetCsUserSgpr(i, user_data[i], HW::UserSgprType::Unknown);
          }
          executor.DispatchDirect(0, scheduler.Current(), (count + 63) / 64, 1, 1, 0x41u);
        };
        const auto metadata_words = static_cast<uint32_t>(metadata_size.size / 4);
        fill_metadata(metadata_words);
        Require(name, "metadata before descriptor",
                !texture_cache.IsMeta(dcc_address),
                "the native fill guessed an unbound metadata allocation's type");

        RenderColorInfo color{};
        RenderExecutorTestAccess::ResolveRenderColorTarget(
            executor, scheduler.Current(), color, 0);
        RenderDepthInfo no_depth{};
        const auto rendering = RenderExecutorTestAccess::AcquireRenderTargets(
            executor, scheduler.Current(), &color, 1, no_depth);
        if (fill_case.reuse_unorm) {
          Require(name, "FLOAT clear reuses UNORM image",
                  color.image_id == unorm_id &&
                      texture_cache.GetImage(unorm_id).backing.format ==
                          vk::Format::eR16G16B16A16Unorm,
                  "the aliased clear did not reuse its existing UNORM allocation");
        }
        Require(name, "fixed clear on a float target",
                color.image_id &&
                    color.desc.info.metadata.kind == ImageMetadataKind::Dcc &&
                    color.desc.info.metadata.range.address == dcc_address &&
                    rendering.num_color_attachments == 1 &&
                    !texture_cache.IsMeta(dcc_address),
                "a DCC fixed clear code was not materialised on an RGBA16F "
                "target");
        const auto cleared = ReadCachedTexel(name, context, color.image_id);
        Require(name, "GPU float clear value",
                cleared ==
                    std::vector<u32>(fill_case.texel.begin(), fill_case.texel.end()),
                "expected " + Hex(fill_case.texel[0]) + ", " + Hex(fill_case.texel[1]) +
                    "; got " + Hex(cleared[0]) + ", " + Hex(cleared[1]));
        context.GetBufferCache().ReadMemory(dcc_address, metadata_size.size, false);
        std::vector<uint8_t> expanded_metadata(metadata_size.size);
        Require(name, "expanded native metadata",
                LibKernel::Memory::TryReadBacking(dcc_address, expanded_metadata.data(),
                                                 expanded_metadata.size()) &&
                    std::all_of(expanded_metadata.begin(), expanded_metadata.end(),
                                [](uint8_t value) { return value == 0xff; }),
                "materialized color retained stale native DCC clear codes");

        const auto bind = [&] {
          RenderExecutorTestAccess::ResetBindings(executor);
          color.image_id = texture_cache.FindImage(color.desc);
          (void)texture_cache.FindRenderTarget(color.image_id, color.desc);
        };
        const auto paint = [&] {
          vk::ClearValue clear{};
          clear.color.float32 = std::array{1.0f, 0.0f, 1.0f, 1.0f};
          TextureCacheTestAccess::ClearImage(
              texture_cache, scheduler.Current(), color.image_id,
              {vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1}, clear);
        };
        std::vector<u32> painted{0x00003c00u, 0x3c003c00u};
        if (fill_case.reuse_unorm) {
          painted = {0x0000ffffu, 0xffffffffu};
        }
        const auto retains_painted_texel = [&] {
          const auto texels = ReadCachedTexel(name, context, color.image_id, {}, {512, 256, 1});
          for (size_t i = 0; i < texels.size(); i += 2) {
            if (texels[i] == painted[0] && texels[i + 1] == painted[1]) {
              return true;
            }
          }
          return false;
        };
        paint();
        bind();
        Require(name, "unchanged metadata preserves rendering",
                ReadCachedTexel(name, context, color.image_id) == painted,
                "rebinding an unchanged DCC allocation reapplied an old clear");
        fill_metadata(metadata_words - 1);
        bind();
        Require(name, "partial same-value metadata fill",
                retains_painted_texel(),
                "a partial same-value write reused stale clear bytes after rendering");
        fill_metadata(metadata_words, true);
        bind();
        Require(name, "same-value raw native re-clear",
                ReadCachedTexel(name, context, color.image_id) ==
                    std::vector<u32>(fill_case.texel.begin(), fill_case.texel.end()),
                "a repeated metadata fill did not clear an already drawn target");
        paint();
        WriteMetadata(context, dcc_address, metadata_size.size, UINT32_MAX);
        fill_metadata(metadata_words - 1);
        bind();
        Require(name, "partial native metadata fill",
                retains_painted_texel(),
                "a nonuniform metadata allocation cleared the whole target");
        fill_metadata(metadata_words);
        bind();
        Require(name, "complete fill after partial fill",
                ReadCachedTexel(name, context, color.image_id) ==
                    std::vector<u32>(fill_case.texel.begin(), fill_case.texel.end()),
                "completing the metadata overwrite did not restore its clear");

        ImageDesc previous_depth{};
        previous_depth.type = BindingType::DepthTarget;
        previous_depth.info.data = {base + 0x180000, 0x10000};
        previous_depth.info.pixel_format = vk::Format::eD32Sfloat;
        previous_depth.info.guest_format = Prospero::BufferFormat::k32Float;
        previous_depth.info.type = Prospero::ImageType::kColor2D;
        previous_depth.info.extent = {128, 128, 1};
        previous_depth.info.resources = {1, 1};
        previous_depth.info.pitch = 128;
        previous_depth.info.bytes_per_block = 4;
        previous_depth.info.samples = 1;
        previous_depth.info.tile_mode = Prospero::TileMode::kLinear;
        previous_depth.info.mip_layout[0] = {0, 0x10000, 128, 128};
        previous_depth.info.metadata.kind = ImageMetadataKind::Htile;
        previous_depth.info.metadata.range = {dcc_address, metadata_size.size};
        previous_depth.info.htile_clear_mask = 0;
        previous_depth.view_info.format = vk::Format::eD32Sfloat;
        previous_depth.view_info.type = vk::ImageViewType::e2D;
        previous_depth.view_info.aspect = vk::ImageAspectFlagBits::eDepth;
        previous_depth.view_info.usage = vk::ImageUsageFlagBits::eDepthStencilAttachment;
        const auto previous_depth_id = texture_cache.FindImage(previous_depth);
        Require(name, "old HTile interpretation",
                texture_cache.FindDepthTarget(previous_depth_id, previous_depth) != nullptr &&
                    texture_cache.IsMeta(dcc_address),
                "the old depth target did not register its metadata allocation");
        paint();
        bind();
        Require(name, "HTile allocation reused as expanded DCC",
                !texture_cache.IsMeta(dcc_address) && !texture_cache.ClearMeta(dcc_address) &&
                    ReadCachedTexel(name, context, color.image_id) == painted,
                "DCC discovery retained the old HTile classification or erased rendered color");
        fill_metadata(metadata_words);
        bind();
        context.GetBufferCache().ReadMemory(dcc_address, metadata_size.size);
        Require(name, "native DCC dispatch after HTile reuse",
                ReadCachedTexel(name, context, color.image_id) ==
                    std::vector<u32>(fill_case.texel.begin(), fill_case.texel.end()) &&
                    LibKernel::Memory::TryReadBacking(dcc_address, expanded_metadata.data(),
                                                     expanded_metadata.size()) &&
                    std::all_of(expanded_metadata.begin(), expanded_metadata.end(),
                                [](uint8_t byte) { return byte == 0xff; }),
                "the former HTile entry swallowed the native DCC fill dispatch");
        RenderExecutorTestAccess::ResetBindings(executor);
        resources.UnmapMemory(base, allocation_size);
        scheduler.Finish();
      });
      context.ShutdownGpu();
      LibKernel::Memory::InstallGpuResources(nullptr);
    }

    Require(name, "unmap direct backing",
            Libs::LibKernel::Memory::KernelMunmap(base, allocation_size) == 0,
            "fixed-clear direct mapping release failed");
    Require(name, "release direct backing",
            Libs::LibKernel::Memory::KernelReleaseDirectMemory(
                direct_offset, allocation_size) == 0,
            "fixed-clear direct-memory allocation release failed");
    std::printf("[gpu]     %-32s ok\n", name);
  }

  void CheckSampledDccClear() {
    constexpr const char *name = "SampledDccClear";
    constexpr uintptr_t base = 0x0000000205000000ull;
    constexpr uint64_t color_size = 0x3fc0000;
    constexpr uint64_t metadata_size = 0x48000;
    constexpr uint64_t dcc_address = base + color_size;
    constexpr uint64_t allocation_size = 0x4020000;
    constexpr uint64_t alignment = 0x10000;
    EnsureRuntimeContext();
    int64_t direct_offset = -1;
    Require(name, "direct allocation",
            Libs::LibKernel::Memory::KernelAllocateDirectMemory(
                0, Libs::LibKernel::Memory::KernelGetDirectMemorySize(),
                allocation_size, alignment, 0, &direct_offset) == 0,
            "captured scene allocation failed");
    void *mapped = reinterpret_cast<void *>(base);
    Require(name, "direct mapping",
            Libs::LibKernel::Memory::KernelMapDirectMemory(
                &mapped, allocation_size, 0x3, 0x10, direct_offset, alignment) == 0 &&
                mapped == reinterpret_cast<void *>(base),
            "captured scene mapping failed");
    for (const auto initial_size : {metadata_size - 0x1000, metadata_size}) {
      std::memset(mapped, 0x5a, color_size);
      std::memset(reinterpret_cast<void *>(dcc_address), 0xff, metadata_size);
      RenderContext context(m_runtime_context);
      context.InitializeGpu(nullptr);
      LibKernel::Memory::InstallGpuResources(&context);
      auto &scheduler = context.GetCommandScheduler();
      HW::Context registers{};
      HW::UserConfig user_config{};
      HW::Shader shaders{};
      scheduler.Begin(registers, user_config, shaders);
      auto &resources = context;
      auto &cache = resources.GetTextureCache();
      auto &executor = context.GetRenderExecutor();
      resources.MapMemory(base, allocation_size);
      WriteMetadata(context, dcc_address, initial_size, 0x40404040u);
      Require(name, "deferred metadata fill",
              !cache.IsMeta(dcc_address),
              "unknown metadata was consumed before descriptor discovery");

      // PPSA19244's first sampled scene descriptor, with relocated allocations.
      ShaderTextureResource descriptor{{static_cast<uint32_t>(base >> 8u),
          0xc4700000u, 0x021bc3bfu, 0x91b00facu, 0, 0x00700000u,
          0x006b0000u | (static_cast<uint32_t>(dcc_address >> 8u) << 24u),
          static_cast<uint32_t>(dcc_address >> 16u)}};
      ShaderRecompiler::IR::DescriptorValue value{};
      value.dword_count = 8;
      std::copy_n(descriptor.fields, 8, value.dwords.begin());
      ShaderRecompiler::IR::ImageResource resource{};
      resource.resource_class = ShaderRecompiler::IR::ImageResourceClass::Sampled;
      resource.numeric_class = Prospero::TextureNumericClass::Float;
      resource.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2D;
      resource.read = true;
      auto binding = RenderExecutorTestAccess::ResolveTexture(executor, resource, value);
      Require(name, "sampled metadata discovery",
              binding.desc.info.extent == vk::Extent3D{3840, 2160, 1} &&
                  binding.desc.info.data.size == color_size &&
                  binding.desc.info.metadata.kind == ImageMetadataKind::Dcc &&
                  binding.desc.info.metadata.range.address == dcc_address &&
                  binding.desc.info.metadata.range.size == metadata_size,
              "captured sampled descriptor lost its DCC allocation");
      Require(name, "sampled view", cache.FindTexture(binding.image_id, binding.desc) != nullptr,
              "captured scene did not produce a sampled view");
      if (initial_size != metadata_size) {
        Require(name, "partial metadata coverage",
                ReadCachedTexel(name, context, binding.image_id) ==
                    std::vector<u32>{0x5a5a5a5au, 0x5a5a5a5au},
                "an incomplete metadata fill cleared the whole scene");
        WriteMetadata(context, dcc_address, metadata_size, 0x40404040u);
        binding.image_id = cache.FindImage(binding.desc);
        (void)cache.FindTexture(binding.image_id, binding.desc);
      }
      Require(name, "opaque black before first sample",
              ReadCachedTexel(name, context, binding.image_id, {3839, 2159, 0}) ==
                  std::vector<u32>{0, 0x3c000000u},
              "sampling read stale color bytes instead of the DCC opaque black clear");
      context.GetBufferCache().ReadMemory(dcc_address, metadata_size);
      std::vector<uint8_t> expanded_metadata(metadata_size);
      Require(name, "sampled clear expands native metadata",
              LibKernel::Memory::TryReadBacking(dcc_address, expanded_metadata.data(),
                                               expanded_metadata.size()) &&
                  std::all_of(expanded_metadata.begin(), expanded_metadata.end(),
                              [](uint8_t byte) { return byte == 0xff; }),
              "the sampled clear retained native clear keys after materialization");
      WriteMetadata(context, dcc_address, metadata_size, 0x80808080u);
      binding.image_id = cache.FindImage(binding.desc);
      (void)cache.FindTexture(binding.image_id, binding.desc);
      Require(name, "later sampled clear",
              ReadCachedTexel(name, context, binding.image_id) ==
                  std::vector<u32>{0x3c003c00u, 0x00003c00u},
              "an existing sampled image retained the previous DCC clear");
      resources.UnmapMemory(base, allocation_size);
      scheduler.Finish();
      context.ShutdownGpu();
      LibKernel::Memory::InstallGpuResources(nullptr);
    }
    Require(name, "unmap",
            Libs::LibKernel::Memory::KernelMunmap(base, allocation_size) == 0,
            "captured scene mapping release failed");
    Require(name, "release",
            Libs::LibKernel::Memory::KernelReleaseDirectMemory(
                direct_offset, allocation_size) == 0,
            "captured scene allocation release failed");
    std::printf("[gpu]     %-32s ok\n", name);
  }

  void CheckPackedTextureComponents() {
    constexpr const char *name = "PackedTextureComponents";
    constexpr uintptr_t base = 0x0000000204200000ull;
    constexpr uint64_t allocation_size = 0x10000;
    struct FormatCase {
      Prospero::BufferFormat format;
      std::array<uint16_t, 4> words;
      std::array<std::array<uint32_t, 4>, 4> channels;
      std::array<uint32_t, 4> maxima;
    };
    // Packed format channels start at the least significant bit.
    // PPSA24515's blue, white, and masked black exposed the 5551 reversal.
    constexpr std::array cases{
        FormatCase{Prospero::BufferFormat::k5_5_5_1UNorm,
                   {0x7c00, 0x7fff, 0x8000, 0x8c41},
                   {{{0, 0, 31, 0}, {31, 31, 31, 0}, {0, 0, 0, 1}, {1, 2, 3, 1}}},
                   {31, 31, 31, 1}},
        FormatCase{Prospero::BufferFormat::k4_4_4_4UNorm,
                   {0x000f, 0x00f0, 0x0f00, 0x4321},
                   {{{15, 0, 0, 0}, {0, 15, 0, 0}, {0, 0, 15, 0}, {1, 2, 3, 4}}},
                   {15, 15, 15, 15}},
    };
    const auto argb = TextureGetComponentMapping(DstSel(5, 1, 7, 0),
                                                 Prospero::ColorMappingArgb);
    Require(name, "inverse mapping",
            argb == vk::ComponentMapping{vk::ComponentSwizzle::eB,
                vk::ComponentSwizzle::eOne, vk::ComponentSwizzle::eR,
                vk::ComponentSwizzle::eZero},
            "cyclic host mapping reordered output slots or descriptor constants");
    const auto target = TextureGetRenderTargetFormat(
        Prospero::ChannelLayout::k1_5_5_5, Prospero::ChannelType::kUNorm,
        Prospero::ChannelOrder::kStandard);
    Require(name, "1555 render target",
            target.format == vk::Format::eR5G5B5A1UnormPack16 &&
                target.export_mapping == Prospero::ColorMappingAbgr,
            "shared format resolution changed the existing 1555 render target");
    EnsureRuntimeContext();
    int64_t direct_offset = -1;
    Require(name, "allocation",
            Libs::LibKernel::Memory::KernelAllocateDirectMemory(
                0, Libs::LibKernel::Memory::KernelGetDirectMemorySize(),
                allocation_size, allocation_size, 0, &direct_offset) == 0,
            "packed texture allocation failed");
    void *mapped = reinterpret_cast<void *>(base);
    Require(name, "mapping",
            Libs::LibKernel::Memory::KernelMapDirectMemory(
                &mapped, allocation_size, 0x3, 0x10, direct_offset,
                allocation_size) == 0 && mapped == reinterpret_cast<void *>(base),
            "packed texture mapping failed");
    for (const auto &format : cases) {
      std::memset(mapped, 0, allocation_size);
      std::memcpy(mapped, format.words.data(), sizeof(format.words));
      RenderContext context(m_runtime_context);
      auto &scheduler = context.GetCommandScheduler();
      HW::Context registers{};
      HW::UserConfig user_config{};
      HW::Shader shaders{};
      scheduler.Begin(registers, user_config, shaders);
      auto &resources = context;
      auto &cache = resources.GetTextureCache();
      auto &executor = context.GetRenderExecutor();
      resources.MapMemory(base, allocation_size);
      for (const auto swizzle : {DstSel(4, 5, 6, 7), DstSel(7, 1, 4, 0)}) {
        ShaderTextureResource descriptor{{static_cast<uint32_t>(base >> 8u),
            (static_cast<uint32_t>(format.format) << 20u) | (3u << 30u), 0,
            swizzle | (static_cast<uint32_t>(Prospero::ImageType::kColor2D) << 28u),
            0, 0x00700000u, 0, 0}};
        TestCase test;
        test.name = name;
        test.has_user_data = true;
        test.image_descriptor_swizzle = swizzle;
        std::copy_n(descriptor.fields, 8, test.user_data.begin());
        test.user_data[50] = 16 * sizeof(uint32_t);
        test.opcodes = {ShaderOpcode::V_MOV_B32, ShaderOpcode::IMAGE_LOAD,
                        ShaderOpcode::BUFFER_STORE_DWORD, ShaderOpcode::S_ENDPGM};
        for (uint32_t pixel = 0; pixel < format.words.size(); ++pixel) {
          AppendVMovU32(&test.code, 20, pixel);
          AppendVMovU32(&test.code, 21, 0);
          test.code.push_back(EncodeMimg0(0x00, 0xf));
          test.code.push_back(EncodeMimg1(0, 20));
          for (uint32_t channel = 0; channel < 4; ++channel) {
            AppendStoreVgpr(&test.code, channel, pixel * 4 + channel);
          }
        }
        AppendEnd(&test.code);
        const auto compiled = CompileCase(test, SubgroupSize());
        ShaderRecompiler::IR::DescriptorValue value{};
        value.dword_count = 8;
        std::copy_n(descriptor.fields, 8, value.dwords.begin());
        const auto binding = RenderExecutorTestAccess::ResolveTexture(
            executor, compiled.program.info.images.at(0), value);
        Image sampled;
        sampled.view = cache.FindTexture(binding.image_id, binding.desc);
        sampled.layout = cache.GetImage(binding.image_id).backing.state.layout;
        scheduler.Finish();
        auto output = CreateStorageBuffer(name, {}, 16);
        Dispatch(test, compiled, output, nullptr, &sampled);
        const auto actual = ReadBuffer(name, output, 16);
        for (uint32_t pixel = 0; pixel < format.words.size(); ++pixel) {
          for (uint32_t channel = 0; channel < 4; ++channel) {
            const auto selector = GetDstSel(swizzle, channel);
            const auto maximum = selector < 4 ? 1u : format.maxima[selector - 4];
            const auto expected = selector < 4 ? selector : format.channels[pixel][selector - 4];
            const float observed = std::bit_cast<float>(actual[pixel * 4 + channel]);
            // Recover the source bits without testing the host's UNORM rounding precision.
            const bool matches = maximum == 1 ? observed == expected
                : observed >= 0.0f && observed <= 1.0f &&
                      std::round(observed * maximum) == expected;
            if (!matches) {
              std::ostringstream message;
              message << "format=" << static_cast<uint32_t>(format.format)
                      << " swizzle=" << swizzle << " word=" << format.words[pixel]
                      << " channel=" << channel << " expected=" << expected
                      << " actual=" << observed;
              Fail(name, "GPU components", message.str());
            }
          }
        }
        DestroyBuffer(&output);
      }
      RenderExecutorTestAccess::ResetBindings(executor);
      resources.UnmapMemory(base, allocation_size);
      scheduler.Finish();
    }
    Require(name, "release",
            Libs::LibKernel::Memory::KernelMunmap(base, allocation_size) == 0 &&
                Libs::LibKernel::Memory::KernelReleaseDirectMemory(
                    direct_offset, allocation_size) == 0,
            "packed texture backing release failed");
    std::printf("[gpu]     %-32s ok\n", name);
  }

  void CheckComparisonDepthTexture() {
    constexpr const char *name = "ComparisonDepthTexture";
    constexpr uintptr_t base = 0x0000000204200000ull;
    constexpr uint64_t allocation_size = 0x20000;
    constexpr uint64_t ordinary_address = base + 0x10000;
    constexpr std::array<uint16_t, 6> depths{0, 13107, 26214, 39321, 52428, 65535};
    constexpr std::array<float, 5> references{0.1f, 0.3f, 0.5f, 0.7f, 0.9f};
    EnsureRuntimeContext();
    int64_t direct_offset = -1;
    Require(name, "direct allocation",
            Libs::LibKernel::Memory::KernelAllocateDirectMemory(
                0, Libs::LibKernel::Memory::KernelGetDirectMemorySize(),
                allocation_size, allocation_size, 0, &direct_offset) == 0,
            "comparison texture allocation failed");
    void *mapped = reinterpret_cast<void *>(base);
    Require(name, "direct mapping",
            Libs::LibKernel::Memory::KernelMapDirectMemory(
                &mapped, allocation_size, 0x3, 0x10, direct_offset,
                allocation_size) == 0 && mapped == reinterpret_cast<void *>(base),
            "comparison texture mapping failed");
    // Sea of Stars' 1D comparison texture and the existing six-face cube.
    const auto check_layout = [&](bool cube) {
      const uint32_t layers = cube ? depths.size() : 1;
      const auto depth_at = [&](uint32_t layer, bool reversed) {
        const auto index = cube ? layer : 2u;
        return depths[reversed ? depths.size() - 1u - index : index];
      };
      std::memset(mapped, 0, allocation_size);
      for (uint32_t face = 0; face < layers; face++) {
        const auto depth = depth_at(face, false);
        for (const auto address : {base, ordinary_address}) {
          std::memcpy(reinterpret_cast<void *>(address + face * 0x100),
                      &depth, sizeof(depth));
        }
      }

      RenderContext context(m_runtime_context);
      auto &scheduler = context.GetCommandScheduler();
      HW::Context registers{};
      HW::UserConfig user_config{};
      HW::Shader shaders{};
      scheduler.Begin(registers, user_config, shaders);
      auto &resources = context;
      auto &cache = resources.GetTextureCache();
      auto &executor = context.GetRenderExecutor();
      resources.MapMemory(base, allocation_size);
      ShaderTextureResource descriptor{{static_cast<uint32_t>(base >> 8u),
          0x00700000u, 0, cube ? 0xb0100204u : 0x81800924u,
          layers - 1u, 0x00700000u, 0, 0}};
      ShaderSamplerResource sampler_descriptor{{1u << 12u, 0, 1u << 24u, 0}};
      TestCase test;
      test.name = name;
      test.has_user_data = true;
      test.image_descriptor_swizzle = descriptor.DstSelXYZW();
      std::copy_n(descriptor.fields, 8, test.user_data.begin());
      std::copy_n(sampler_descriptor.fields, 4, test.user_data.begin() + 8);
      test.user_data[50] = layers * references.size() * sizeof(uint32_t);
      test.opcodes = {ShaderOpcode::V_MOV_B32, ShaderOpcode::IMAGE_SAMPLE,
                      ShaderOpcode::BUFFER_STORE_DWORD, ShaderOpcode::S_ENDPGM};
      test.required_spirv = {"OpImageSampleDrefExplicitLod"};
      std::vector<uint32_t> promoted_expected;
      for (uint32_t face = 0; face < layers; face++) {
        for (const auto reference : references) {
          AppendVMovLiteral(&test.code, 20, std::bit_cast<uint32_t>(reference));
          AppendVMovLiteral(&test.code, 21,
                            std::bit_cast<uint32_t>(cube ? 1.5f : 0.5f));
          if (cube) {
            AppendVMovLiteral(&test.code, 22, std::bit_cast<uint32_t>(1.5f));
            AppendVMovLiteral(&test.code, 23,
                              std::bit_cast<uint32_t>(static_cast<float>(face)));
          }
          test.code.push_back(EncodeMimg0(0x2f, 1, 0, false, cube ? 3 : 0));
          test.code.push_back(EncodeMimg1(0, 20, 0, 2));
          AppendStoreVgpr(&test.code, 0, static_cast<uint32_t>(test.expected.size()));
          test.expected.push_back(
              reference < static_cast<float>(depth_at(face, false)) / 65535.f
                  ? 0x3f800000u : 0u);
          promoted_expected.push_back(
              reference < static_cast<float>(depth_at(face, true)) / 65535.f
                  ? 0x3f800000u : 0u);
        }
      }
      AppendEnd(&test.code);
      const auto compiled = CompileCase(test, SubgroupSize());
      Require(name, "comparison resource", compiled.program.info.images.size() == 1 &&
                  compiled.program.info.images[0].depth_compare &&
                  compiled.program.info.images[0].cube == cube &&
                  compiled.program.info.images[0].dimension ==
                      (cube ? ShaderRecompiler::Decoder::ImageDimension::Dim2DArray
                            : ShaderRecompiler::Decoder::ImageDimension::Dim1D),
              "native comparison did not retain its resource semantics");
      ShaderRecompiler::IR::DescriptorValue value{};
      value.dword_count = 8;
      std::copy_n(descriptor.fields, 8, value.dwords.begin());
      auto binding = RenderExecutorTestAccess::ResolveTexture(
          executor, compiled.program.info.images[0], value);
      const auto view = cache.FindTexture(binding.image_id, binding.desc);
      auto &image = cache.GetImage(binding.image_id);
      Require(name, "fresh depth backing", view != nullptr &&
                  image.info.pixel_format == vk::Format::eD16Unorm &&
                  image.info.guest_format == Prospero::BufferFormat::k16UNorm &&
                  image.info.tile_mode == descriptor.TileMode() &&
                  image.info.type == (cube ? Prospero::ImageType::kColor2D
                                          : Prospero::ImageType::kColor1D) &&
                  image.info.data.size == (cube ? 0x600u : 0x10000u) &&
                  image.info.resources.layers == layers,
              "comparison texture lost its guest layout or depth representation");
      auto ordinary_resource = compiled.program.info.images[0];
      ordinary_resource.depth_compare = false;
      value.dwords[0] = static_cast<uint32_t>(ordinary_address >> 8u);
      auto ordinary = RenderExecutorTestAccess::ResolveTexture(executor, ordinary_resource, value);
      (void)cache.FindTexture(ordinary.image_id, ordinary.desc);
      auto &color = cache.GetImage(ordinary.image_id);
      Require(name, "ordinary R16", color.info.pixel_format == vk::Format::eR16Unorm,
              "ordinary R16 sampling unexpectedly acquired a depth format");
      scheduler.Finish();

      auto output = CreateStorageBuffer(name, {}, test.expected.size());
      const auto sampler = context.GetSamplerCache().GetSampler(sampler_descriptor);
      Image sampled;
      sampled.view = view;
      sampled.layout = image.backing.state.layout;
      Dispatch(test, compiled, output, nullptr, &sampled, nullptr, nullptr, sampler);
      Require(name, "native comparisons",
              ReadBuffer(name, output, test.expected.size()) == test.expected,
              "comparison samples lost a depth value or guest layer stride");

      image.Transit(vk::ImageLayout::eTransferDstOptimal, vk::AccessFlagBits2::eTransferWrite,
                    {}, scheduler.Current().Handle());
      color.Transit(vk::ImageLayout::eTransferDstOptimal, vk::AccessFlagBits2::eTransferWrite,
                    {}, scheduler.Current().Handle());
      for (uint32_t face = 0; face < layers; face++) {
        const vk::ImageSubresourceRange depth_range{vk::ImageAspectFlagBits::eDepth, 0, 1, face, 1};
        const vk::ClearDepthStencilValue clear_depth{
            static_cast<float>(depth_at(face, true)) / 65535.f, 0};
        scheduler.Current().Handle().clearDepthStencilImage(image.backing.image,
            vk::ImageLayout::eTransferDstOptimal, &clear_depth, 1, &depth_range);
        const vk::ImageSubresourceRange color_range{vk::ImageAspectFlagBits::eColor, 0, 1, face, 1};
        const vk::ClearColorValue clear_color{std::array<float, 4>{
            static_cast<float>(depth_at(face, true)) / 65535.f, 0.f, 0.f, 0.f}};
        scheduler.Current().Handle().clearColorImage(color.backing.image,
            vk::ImageLayout::eTransferDstOptimal, &clear_color, 1, &color_range);
      }
      cache.MarkGpuWritten(binding.image_id);
      cache.MarkGpuWritten(ordinary.image_id);
      Require(name, "depth readback", TextureCacheTestAccess::TryDownload(cache, binding.image_id),
              "ordinary tiled depth readback did not use the shared transfer path");
      scheduler.Finish();
      scheduler.DrainPriorityOperations();
      for (uint32_t face = 0; face < layers; face++) {
        uint16_t actual = 0;
        std::memcpy(&actual, reinterpret_cast<const void *>(base + face * 0x100), sizeof(actual));
        Require(name, "depth guest roundtrip", actual == depth_at(face, true),
                "GPU depth clear was not written to the correct guest face");
      }

      auto promoted = RenderExecutorTestAccess::ResolveTexture(
          executor, compiled.program.info.images[0], value);
      sampled.view = cache.FindTexture(promoted.image_id, promoted.desc);
      auto &promoted_image = cache.GetImage(promoted.image_id);
      Require(name, "GPU color owner promotion", promoted.image_id != ordinary.image_id &&
                  promoted_image.info.pixel_format == vk::Format::eD16Unorm &&
                  promoted_image.IsGpuModified(),
              "comparison binding did not preserve the GPU-current color owner");
      sampled.layout = promoted_image.backing.state.layout;
      scheduler.Finish();
      Dispatch(test, compiled, output, nullptr, &sampled, nullptr, nullptr, sampler);
      Require(name, "promoted comparisons",
              ReadBuffer(name, output, promoted_expected.size()) == promoted_expected,
              "color-to-depth ownership conversion changed comparison results");
      DestroyBuffer(&output);
      RenderExecutorTestAccess::ResetBindings(executor);
      resources.UnmapMemory(base, allocation_size);
      scheduler.Finish();
    };
    check_layout(false);
    check_layout(true);
    Require(name, "unmap", Libs::LibKernel::Memory::KernelMunmap(base, allocation_size) == 0,
            "comparison texture unmap failed");
    Require(name, "release", Libs::LibKernel::Memory::KernelReleaseDirectMemory(
                direct_offset, allocation_size) == 0,
            "comparison texture release failed");
    std::printf("[gpu]     %-32s ok\n", name);
  }


  void CheckRenderExecutorColorStandardTileDiscovery() {
    constexpr const char *name = "RenderExecutorColorStandardTile";
    constexpr uintptr_t base = 0x0000000203b00000ull;
    constexpr uint64_t allocation_size = 0x190000;
    constexpr uint64_t allocation_alignment = 0x10000;
    constexpr auto format = Prospero::BufferFormat::k32Float;
    struct TileCase {
      Prospero::TileMode tile;
      uint64_t target_offset;
      uint64_t alignment;
    };
    constexpr std::array cases{
        TileCase{Prospero::TileMode::kStandard4KB, 0x4000, 0x1000},
        TileCase{Prospero::TileMode::kStandard64KB, 0x10000, 0x10000},
    };
    EnsureRuntimeContext();

    const auto odd_pitch =
        TileGetTexturePitch(format, 257, Prospero::TileMode::kStandard4KB);
    TileSizeAlign odd_slice{};
    TileGetTextureSize(format, 257, 131, 1, Prospero::TileMode::kStandard4KB,
                       &odd_slice, nullptr, nullptr);
    Require(name, "tile layout",
            odd_pitch == 288 && odd_slice.size == 0x2d000 &&
                odd_slice.align == 0x1000,
            "Standard4KB pitch, footprint, or block alignment is incorrect");

    int64_t direct_offset = -1;
    Require(name, "direct allocation",
            Libs::LibKernel::Memory::KernelAllocateDirectMemory(
                0, Libs::LibKernel::Memory::KernelGetDirectMemorySize(),
                allocation_size, allocation_alignment, 0, &direct_offset) == 0,
            "standard-tiled color allocation failed");
    void *mapped = reinterpret_cast<void *>(base);
    Require(name, "direct mapping",
            Libs::LibKernel::Memory::KernelMapDirectMemory(
                &mapped, allocation_size, 0x3, 0x10, direct_offset,
                allocation_alignment) == 0 &&
                mapped == reinterpret_cast<void *>(base),
            "standard-tiled color mapping failed");
    std::memset(mapped, 0, allocation_size);

    for (const auto &tile_case : cases) {
      const auto pitch = TileGetTexturePitch(format, 256, tile_case.tile);
      TileSizeAlign slice{};
      TileGetTextureSize(format, 256, 256, 1, tile_case.tile, &slice, nullptr,
                         nullptr);
      Require(
          name, "tile layout",
          pitch == 256 && slice.size == 0x40000 &&
              slice.align == tile_case.alignment,
          "standard tile pitch, footprint, or block alignment is incorrect");

      const auto target_address = base + tile_case.target_offset;
      const auto target_size = slice.size * 6ull;
      RenderContext context(m_runtime_context);
      auto &scheduler = context.GetCommandScheduler();
      HW::Context registers{};
      HW::UserConfig user_config{};
      HW::Shader shaders{};
      registers.SetColorBase(0, {.addr = target_address});
      registers.SetColorInfo(
          0, {.format = Prospero::ChannelLayout::k32,
              .channel_type = Prospero::ChannelType::kFloat,
              .channel_order = Prospero::ChannelOrder::kStandard});
      registers.SetColorView(
          0, {.base_array_slice_index = 5, .last_array_slice_index = 5});
      registers.SetColorAttrib2(0, {.height = 255, .width = 255});
      registers.SetColorAttrib3(0, {.tile_mode = tile_case.tile,
                                    .dimension = 1,
                                    .metadata_pipe_aligned = true});
      registers.SetRenderTargetMask(0x0f);
      scheduler.Begin(registers, user_config, shaders);

      auto &resources = context;
      auto &texture_cache = resources.GetTextureCache();
      auto &executor = context.GetRenderExecutor();
      resources.MapMemory(base, allocation_size);

      RenderColorInfo color{};
      RenderExecutorTestAccess::ResolveRenderColorTarget(
          executor, scheduler.Current(), color, 0);
      const auto attachment =
          texture_cache.FindRenderTarget(color.image_id, color.desc);
      const auto &image = texture_cache.GetImage(color.image_id);
      Require(name, "captured target",
              color.image_id && attachment != nullptr &&
                  color.guest_array_layer == 5 &&
                  color.desc.view_info.base_layer == 5 &&
                  color.desc.info.data.address == target_address &&
                  color.desc.info.data.size == target_size &&
                  color.desc.info.tile_mode == tile_case.tile &&
                  color.desc.info.extent == vk::Extent3D{256, 256, 1} &&
                  color.desc.info.resources == ImageSubresources{1, 6} &&
                  color.desc.info.pitch == pitch &&
                  color.desc.info.mip_layout[0].offset == 0 &&
                  color.desc.info.mip_layout[0].size == target_size &&
                  color.desc.view_info.type == vk::ImageViewType::e2D &&
                  color.desc.view_info.base_layer == 5 &&
                  color.desc.view_info.layer_count == 1 &&
                  (target_address & (tile_case.alignment - 1)) == 0 &&
                  image.usage.render_target && image.IsGpuModified(),
              "slice 5 standard-tiled render target was not resolved");

      RenderExecutorTestAccess::ResetBindings(executor);
      resources.UnmapMemory(base, allocation_size);
      scheduler.Finish();
    }

    Require(name, "unmap direct backing",
            Libs::LibKernel::Memory::KernelMunmap(base, allocation_size) == 0,
            "standard-tiled color mapping release failed");
    Require(name, "release direct backing",
            Libs::LibKernel::Memory::KernelReleaseDirectMemory(
                direct_offset, allocation_size) == 0,
            "standard-tiled color allocation release failed");
    std::printf("[gpu]     %-32s ok\n", name);
  }

  void CheckRenderExecutorColorDepthTileDiscovery() {
    constexpr const char *name = "RenderExecutorColorDepthTile";
    constexpr uintptr_t base = 0x0000000203d00000ull;
    constexpr uint64_t allocation_size = 0x10000;
    constexpr uint64_t allocation_alignment = 0x10000;
    EnsureRuntimeContext();

    int64_t direct_offset = -1;
    Require(name, "direct allocation",
            Libs::LibKernel::Memory::KernelAllocateDirectMemory(
                0, Libs::LibKernel::Memory::KernelGetDirectMemorySize(),
                allocation_size, allocation_alignment, 0, &direct_offset) == 0,
            "depth-tiled color allocation failed");
    void *mapped = reinterpret_cast<void *>(base);
    Require(name, "direct mapping",
            Libs::LibKernel::Memory::KernelMapDirectMemory(
                &mapped, allocation_size, 0x3, 0x10, direct_offset,
                allocation_alignment) == 0 &&
                mapped == reinterpret_cast<void *>(base),
            "depth-tiled color mapping failed");
    constexpr uint32_t width = 64;
    constexpr uint32_t height = 64;
    TileTextureBlockLayout tile_layout{};
    Require(name, "tile layout",
            TileGetTextureBlockLayout(Prospero::BufferFormat::k32Float,
                                      Prospero::TileMode::kDepth, false,
                                      tile_layout),
            "depth-tiled color block layout is unavailable");
    uint32_t block_xor = 0;
    Require(name, "block xor",
            TileGetBlockXor(tile_layout.block, 0, 0, 0, block_xor),
            "depth-tiled color block XOR is unavailable");
    std::vector<uint32_t> expected(allocation_size / sizeof(uint32_t));
    for (uint32_t y = 0; y < height; ++y) {
      for (uint32_t x = 0; x < width; ++x) {
        uint32_t offset = 0;
        Require(name, "texel offset",
                TileGetBlockOffset(tile_layout.block, x, y, 0, offset),
                "depth-tiled color texel offset is unavailable");
        const auto index = (offset ^ block_xor) / sizeof(uint32_t);
        Require(name, "texel address", index < expected.size(),
                "depth-tiled color texel address exceeds its backing");
        expected[index] = 0x3f000000u + y * width + x;
      }
    }
    std::memcpy(mapped, expected.data(), allocation_size);

    {
      RenderContext context(m_runtime_context);
      auto &scheduler = context.GetCommandScheduler();
      HW::Context registers{};
      HW::UserConfig user_config{};
      HW::Shader shaders{};
      registers.SetColorBase(0, {.addr = base});
      registers.SetColorInfo(
          0, {.format = Prospero::ChannelLayout::k32,
              .channel_type = Prospero::ChannelType::kFloat,
              .channel_order = Prospero::ChannelOrder::kStandard});
      registers.SetColorAttrib2(0, {.height = 63, .width = 63});
      registers.SetColorAttrib3(0, {.tile_mode = Prospero::TileMode::kDepth,
                                    .dimension = 1,
                                    .metadata_pipe_aligned = true});
      registers.SetRenderTargetMask(0x0f);
      scheduler.Begin(registers, user_config, shaders);

      auto &resources = context;
      auto &texture_cache = resources.GetTextureCache();
      auto &executor = context.GetRenderExecutor();
      resources.MapMemory(base, allocation_size);

      RenderColorInfo color{};
      RenderExecutorTestAccess::ResolveRenderColorTarget(
          executor, scheduler.Current(), color, 0);
      const auto attachment =
          texture_cache.FindRenderTarget(color.image_id, color.desc);
      const auto &image = texture_cache.GetImage(color.image_id);
      Require(name, "captured target",
              color.image_id && attachment != nullptr &&
                  color.desc.info.tile_mode == Prospero::TileMode::kDepth &&
                  color.desc.info.pitch == 128 &&
                  color.desc.info.data.size == allocation_size &&
                  color.desc.info.mip_layout[0].size == allocation_size &&
                  image.usage.render_target && image.IsGpuModified(),
              "supported depth-tiled color target was not resolved");
      scheduler.Finish();
      scheduler.DrainPriorityOperations();
      std::vector<uint8_t> cleared(allocation_size);
      Require(name, "clear guest backing",
              Libs::LibKernel::Memory::TryWriteBacking(base, cleared.data(),
                                                       allocation_size),
              "depth-tiled color backing could not be cleared");
      Require(
          name, "readback queue",
          TextureCacheTestAccess::TryDownload(texture_cache, color.image_id),
          "depth-tiled color target could not be queued for readback");

      RenderExecutorTestAccess::ResetBindings(executor);
      scheduler.Finish();
      scheduler.DrainPriorityOperations();
      std::vector<uint32_t> observed(expected.size());
      Require(name, "readback backing",
              Libs::LibKernel::Memory::TryReadBacking(base, observed.data(),
                                                      allocation_size),
              "depth-tiled color readback is unavailable");
      bool recovered = true;
      for (uint32_t y = 0; y < height; ++y) {
        for (uint32_t x = 0; x < width; ++x) {
          uint32_t offset = 0;
          const auto valid =
              TileGetBlockOffset(tile_layout.block, x, y, 0, offset);
          const auto index = (offset ^ block_xor) / sizeof(uint32_t);
          recovered &= valid && index < observed.size() &&
                       observed[index] == expected[index];
        }
      }
      Require(name, "round trip", recovered,
              "depth-tiled color upload/readback changed active texels");
      resources.UnmapMemory(base, allocation_size);
      scheduler.Finish();
    }

    Require(name, "unmap direct backing",
            Libs::LibKernel::Memory::KernelMunmap(base, allocation_size) == 0,
            "depth-tiled color mapping release failed");
    Require(name, "release direct backing",
            Libs::LibKernel::Memory::KernelReleaseDirectMemory(
                direct_offset, allocation_size) == 0,
            "depth-tiled color allocation release failed");
    std::printf("[gpu]     %-32s ok\n", name);
  }

  void CheckRenderExecutorStencilBindingDiscovery() {
    constexpr const char *name = "RenderExecutorStencilBindingDiscovery";
    constexpr uintptr_t base = 0x0000000203600000ull;
    constexpr uint64_t allocation_size = 0x200000;
    constexpr uint64_t allocation_alignment = 0x10000;
    constexpr uint64_t depth_address = base + 0x40000;
    constexpr uint64_t stencil_address = base + 0x70000;
    constexpr uint64_t mipped_storage_address = base + 0x100000;
    constexpr uint32_t tail_backing_value = 0x2468ace0u;
    constexpr uint32_t tail_gpu_value = 0x13579bdfu;
    EnsureRuntimeContext();

    int64_t direct_offset = -1;
    Require(name, "direct allocation",
            Libs::LibKernel::Memory::KernelAllocateDirectMemory(
                0, Libs::LibKernel::Memory::KernelGetDirectMemorySize(),
                allocation_size, allocation_alignment, 0, &direct_offset) == 0,
            "descriptor discovery direct-memory allocation failed");
    void *mapped = reinterpret_cast<void *>(base);
    Require(name, "direct mapping",
            Libs::LibKernel::Memory::KernelMapDirectMemory(
                &mapped, allocation_size, 0x3, 0x10, direct_offset,
                allocation_alignment) == 0 &&
                mapped == reinterpret_cast<void *>(base),
            "descriptor discovery fixed mapping failed");
    std::memset(mapped, 0, allocation_size);
    std::fill_n(reinterpret_cast<uint32_t *>(mipped_storage_address),
                0x10000 / 4, tail_backing_value);

    {
      RenderContext context(m_runtime_context);
      auto &scheduler = context.GetCommandScheduler();
      HW::Context registers{};
      HW::UserConfig user_config{};
      HW::Shader shaders{};
      context.InitializeGpu(nullptr);
      scheduler.Begin(registers, user_config, shaders);
      auto &resources = context;
      auto &texture_cache = resources.GetTextureCache();
      auto &executor = context.GetRenderExecutor();
      resources.MapMemory(base, allocation_size);
      std::vector<PipelineCache::Pipeline> descriptor_pipelines;

      // The virtual-texture atlas is written as raw BC3 blocks, then sampled as BC3.
      constexpr uint64_t block_alias_address = base + 0xf0000;
      constexpr std::array<uint32_t, 4> block_alias_data{
          0x01234567u, 0x89abcdefu, 0xfedcba98u, 0x76543210u};
      const auto resolve_block_alias = [&](bool compressed) {
        const uint32_t side = compressed ? 256 : 64;
        const auto format = compressed ? Prospero::BufferFormat::kBc3UNorm
                                       : Prospero::BufferFormat::k32_32_32_32UInt;
        ShaderRecompiler::IR::DescriptorValue value{};
        value.dword_count = 8;
        value.dwords = {static_cast<uint32_t>(block_alias_address >> 8u),
                        (static_cast<uint32_t>(format) << 20u) | (3u << 30u),
                        ((side - 1u) >> 2u) | ((side - 1u) << 14u),
                        0x90900facu, 0, 0x00700000u, 0, 0};
        ShaderRecompiler::IR::ImageResource resource{};
        resource.resource_class = compressed
            ? ShaderRecompiler::IR::ImageResourceClass::Sampled
            : ShaderRecompiler::IR::ImageResourceClass::Storage;
        resource.numeric_class = compressed ? Prospero::TextureNumericClass::Float
                                            : Prospero::TextureNumericClass::Uint;
        resource.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2D;
        resource.read = compressed;
        resource.written = !compressed;
        return RenderExecutorTestAccess::ResolveTexture(executor, resource, value);
      };
      auto raw_blocks = resolve_block_alias(false);
      (void)texture_cache.FindTexture(raw_blocks.image_id, raw_blocks.desc);
      auto &raw_blocks_native = texture_cache.GetImage(raw_blocks.image_id);
      raw_blocks_native.Transit(vk::ImageLayout::eTransferDstOptimal,
                                vk::AccessFlagBits2::eTransferWrite, {},
                                scheduler.Current().Handle());
      vk::ClearColorValue block_clear{};
      std::copy(block_alias_data.begin(), block_alias_data.end(),
                block_clear.uint32.begin());
      const vk::ImageSubresourceRange block_range{
          vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1};
      scheduler.Current().Handle().clearColorImage(
          raw_blocks_native.backing.image, vk::ImageLayout::eTransferDstOptimal,
          &block_clear, 1, &block_range);
      texture_cache.MarkGpuWritten(raw_blocks.image_id);
      auto compressed_blocks = resolve_block_alias(true);
      (void)texture_cache.FindTexture(compressed_blocks.image_id,
                                      compressed_blocks.desc);
      auto raw_blocks_again = resolve_block_alias(false);
      Require(name, "compressed atlas storage reuse",
              compressed_blocks.image_id != raw_blocks.image_id &&
                  raw_blocks_again.image_id == compressed_blocks.image_id &&
                  texture_cache.FindTexture(raw_blocks_again.image_id,
                                            raw_blocks_again.desc) != nullptr,
              "BC3 sampling replaced the GPU atlas on its next raw-block write");
      Require(name, "compressed atlas download",
              TextureCacheTestAccess::TryDownload(texture_cache,
                                                  raw_blocks_again.image_id),
              "the retained BC3 atlas could not publish its native contents");
      scheduler.Finish();
      scheduler.DrainPriorityOperations();
      const auto *block_words = reinterpret_cast<const uint32_t *>(block_alias_address);
      Require(name, "compressed atlas GPU contents",
              std::equal(block_alias_data.begin(), block_alias_data.end(), block_words) &&
                  std::equal(block_alias_data.begin(), block_alias_data.end(),
                             block_words + 0x10000 / sizeof(uint32_t) - 4),
              "compressed atlas aliases reloaded stale CPU bytes over GPU-written blocks");

      const auto allocate_bindings =
          [&](ShaderRecompiler::IR::Program &program) {
            program.shader_info_complete = true;
            ShaderRecompiler::IR::AllocateBindings(program);
          };

      {
        ShaderRecompiler::IR::Program buffer_ir{};
        buffer_ir.stage = ShaderType::Compute;
        buffer_ir.resource_tracking_complete = true;
        buffer_ir.info.buffers.resize(1);
        buffer_ir.info.buffers[0].read = true;
        allocate_bindings(buffer_ir);
        ShaderRecompiler::IR::CompiledShaderInfo buffer_program{};
        buffer_program.stage = buffer_ir.stage;
        buffer_program.info = std::move(buffer_ir.info);
        buffer_program.bindings = std::move(buffer_ir.bindings);

        constexpr uint64_t buffer_address = base + allocation_size - 0x5000;
        ShaderBufferResource buffer_descriptor{};
        buffer_descriptor.UpdateAddress48(buffer_address);
        buffer_descriptor.fields[2] = 0x8000;
        ShaderStageRuntime buffer_runtime{.program = &buffer_program};
        auto &value = buffer_runtime.resources.buffers.emplace_back();
        std::memcpy(value.dwords.data(), buffer_descriptor.fields,
                    sizeof(buffer_descriptor.fields));
        value.dword_count = 4;
        auto buffer_bindings = executor.PrepareBindings(buffer_runtime);
        executor.FindBuffers(buffer_bindings);
        const auto original_id = buffer_bindings.buffer_sources[0].id;

        auto &buffer_cache = resources.GetBufferCache();
        const auto merged_id =
            buffer_cache.FindBuffer(base + allocation_size - 0x10000, 0x10000);
        Require(name, "buffer discovery invalidation", merged_id != original_id,
                "overlapping buffer discovery did not replace its smaller owner");
        executor.RebindBuffers(buffer_bindings);
        const auto &binding = buffer_bindings.buffers[0];
        const auto &owner = buffer_cache.GetBuffer(merged_id);
        Require(name, "clamped buffer rebind",
                binding.buffer == owner.Handle() &&
                    binding.offset == owner.Offset(buffer_address) &&
                    binding.range == 0x5000,
                "descriptor rebind lost its clamped guest range or retained a stale host owner");
      }

      constexpr auto stencil_format = Prospero::BufferFormat::k8UInt;
      constexpr auto linear = Prospero::TileMode::kLinear;
      TileSizeAlign stencil_layout{};
      TileGetTextureTotalSize(stencil_format, 1, 1, 1, 1, linear, false,
                              stencil_layout);
      Require(name, "stencil footprint",
              stencil_layout.size != 0 && stencil_layout.align != 0 &&
                  (stencil_address & (stencil_layout.align - 1u)) == 0,
              "linear stencil descriptor produced an invalid footprint");

      ShaderRecompiler::IR::Program null_program{};
      null_program.stage = ShaderType::Compute;
      null_program.resource_tracking_complete = true;
      ShaderRecompiler::IR::ImageResource null_resource{};
      null_resource.resource_class =
          ShaderRecompiler::IR::ImageResourceClass::Sampled;
      null_resource.numeric_class = Prospero::TextureNumericClass::Uint;
      null_resource.dimension =
          ShaderRecompiler::Decoder::ImageDimension::Dim2D;
      null_resource.read = true;
      null_program.info.images.push_back(null_resource);
      auto null_volume = null_resource;
      null_volume.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim3D;
      null_program.info.images.push_back(null_volume);
      auto null_storage = null_resource;
      null_storage.resource_class =
          ShaderRecompiler::IR::ImageResourceClass::Storage;
      null_storage.read = false;
      null_storage.written = true;
      null_program.info.images.push_back(null_storage);
      ShaderRecompiler::IR::ResourceSnapshot null_snapshot{};
      ShaderRecompiler::IR::DescriptorValue null_descriptor{};
      null_descriptor.dword_count = 8;
      null_snapshot.images.assign(3, null_descriptor);
      ShaderRecompiler::IR::ResourceSpecialization null_specialization{};
      null_specialization.images.resize(3);
      for (auto &image : null_specialization.images) {
        image.numeric_class = Prospero::TextureNumericClass::Float;
        image.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2D;
      }
      ShaderRecompiler::IR::ApplyResourceSpecialization(
          null_program, null_specialization);
      allocate_bindings(null_program);
      ShaderRecompiler::IR::CompiledShaderInfo null_info{};
      null_info.stage = null_program.stage;
      null_info.info = std::move(null_program.info);
      null_info.bindings = std::move(null_program.bindings);
      ShaderStageRuntime null_runtime{&null_info, std::move(null_snapshot)};
      auto null_bindings = executor.PrepareBindings(null_runtime);
      executor.RebindImages(null_bindings);
      Require(name, "null descriptor count",
              null_bindings.images.size() == 3,
              "null descriptor preparation lost an image binding");
      const auto null_image_id = null_bindings.images[0].image_id;
      const auto &null_image = texture_cache.GetImage(null_image_id);
      Require(name, "one null image per format",
              null_bindings.images[1].image_id == null_image_id &&
                  null_bindings.images[2].image_id == null_image_id &&
                  TextureCacheTestAccess::NullImageCount(texture_cache) == 1,
              "null view dimension or usage created another image allocation");
      Require(name, "null descriptors share final cache acquisition",
              null_image.info.data.Empty() && !null_image.binding.is_bound &&
                  !null_image.binding.is_target &&
                  !null_image.binding.needs_rebind &&
                  null_image.usage.texture && null_image.usage.storage &&
                  null_image.IsGpuModified() &&
                  !TextureCacheTestAccess::PendingDownload(texture_cache,
                                                           null_image_id),
              "the shared null image did not preserve texture/storage "
              "acquisition without guest readback or RenderExecutor ownership");
      descriptor_pipelines.push_back(RenderExecutorTestAccess::CommitBindings(
          executor, scheduler.Current(), null_bindings));
      Require(name, "null descriptor general layouts",
              std::ranges::all_of(null_bindings.images,
                                  [](const auto &binding) {
                                    const auto info = MakeImageInfo(binding);
                                    return binding.layout ==
                                               vk::ImageLayout::eGeneral &&
                                           info.imageView ==
                                               binding.image_view &&
                                           info.imageLayout == binding.layout;
                                  }) &&
                  null_image.backing.state.layout == vk::ImageLayout::eGeneral,
              "shared sampled/storage null descriptors did not retain "
              "the general layout through descriptor generation");

      constexpr uint64_t target_mip_size = 0x10000;
      const auto make_target_desc = [&](uint64_t address, uint64_t size,
                                        vk::Extent3D extent) {
        ImageDesc desc{};
        desc.type = BindingType::RenderTarget;
        desc.info.data = {address, size};
        desc.info.pixel_format = vk::Format::eR32Uint;
        desc.info.guest_format = Prospero::BufferFormat::k32UInt;
        desc.info.type = Prospero::ImageType::kColor2D;
        desc.info.extent = extent;
        desc.info.resources = {1, 1};
        desc.info.pitch = extent.width;
        desc.info.bytes_per_block = 4;
        desc.info.samples = 1;
        desc.info.tile_mode = linear;
        desc.info.mip_layout[0] = {0, size, extent.width, extent.height};
        desc.view_info.format = desc.info.pixel_format;
        desc.view_info.type = vk::ImageViewType::e2D;
        desc.view_info.aspect = vk::ImageAspectFlagBits::eColor;
        desc.view_info.usage = vk::ImageUsageFlagBits::eColorAttachment;
        return desc;
      };

      TextureCacheTestAccess::SetLinearReadback(texture_cache, true);
      ShaderTextureResource storage{};
      const uint64_t storage_address = base + 0x60000;
      constexpr uint32_t storage_native_value = 0x13579bdfu;
      constexpr uint32_t storage_stale_value = 0x2468ace0u;
      std::memcpy(reinterpret_cast<uint8_t *>(mapped) + 0x60000,
                  &storage_native_value, sizeof(storage_native_value));
      const uint64_t encoded_storage_address = storage_address >> 8u;
      storage.fields[0] = static_cast<uint32_t>(encoded_storage_address);
      storage.fields[1] =
          static_cast<uint32_t>(encoded_storage_address >> 32u) |
          (static_cast<uint32_t>(stencil_format) << 20u);
      storage.fields[3] =
          DstSel(4, 5, 6, 7) | (static_cast<uint32_t>(linear) << 20u) |
          (static_cast<uint32_t>(Prospero::ImageType::kColor2D) << 28u);
      storage.fields[5] = 0x00700000u;
      ShaderRecompiler::IR::Program storage_program{};
      storage_program.stage = ShaderType::Vertex;
      storage_program.resource_tracking_complete = true;
      ShaderRecompiler::IR::ImageResource storage_resource{};
      storage_resource.resource_class =
          ShaderRecompiler::IR::ImageResourceClass::Storage;
      storage_resource.numeric_class = Prospero::TextureNumericClass::Uint;
      storage_resource.dimension =
          ShaderRecompiler::Decoder::ImageDimension::Dim2D;
      storage_resource.written = true;
      storage_program.info.images.push_back(storage_resource);
      allocate_bindings(storage_program);
      ShaderRecompiler::IR::DescriptorValue storage_descriptor{};
      std::copy(std::begin(storage.fields), std::end(storage.fields),
                storage_descriptor.dwords.begin());
      storage_descriptor.dword_count = 8;
      auto mipped_storage = storage;
      const auto encoded_mipped_storage_address = mipped_storage_address >> 8u;
      mipped_storage.fields[0] =
          static_cast<uint32_t>(encoded_mipped_storage_address);
      mipped_storage.fields[1] =
          static_cast<uint32_t>(encoded_mipped_storage_address >> 32u) |
          (static_cast<uint32_t>(Prospero::BufferFormat::k32UInt) << 20u) |
          (3u << 30u);
      mipped_storage.fields[2] = 15u | (63u << 14u);
      mipped_storage.fields[3] =
          DstSel(4, 5, 6, 7) | (1u << 12u) | (3u << 16u) |
          (static_cast<uint32_t>(Prospero::TileMode::kStandard64KB) << 20u) |
          (static_cast<uint32_t>(Prospero::ImageType::kColor2D) << 28u);
      mipped_storage.fields[5] = 0x00700000u | (3u << 4u);
      ShaderRecompiler::IR::DescriptorValue mipped_storage_descriptor{};
      std::copy(std::begin(mipped_storage.fields),
                std::end(mipped_storage.fields),
                mipped_storage_descriptor.dwords.begin());
      mipped_storage_descriptor.dword_count = 8;
      auto overwide_mipped_storage = mipped_storage;
      overwide_mipped_storage.fields[3] =
          (overwide_mipped_storage.fields[3] & ~(0xfu << 16u)) | (4u << 16u);
      ShaderRecompiler::IR::DescriptorValue
          overwide_mipped_storage_descriptor{};
      std::copy(std::begin(overwide_mipped_storage.fields),
                std::end(overwide_mipped_storage.fields),
                overwide_mipped_storage_descriptor.dwords.begin());
      overwide_mipped_storage_descriptor.dword_count = 8;
#if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS
      ExpectFatal("MipViewPhysicalLayoutChange", [&] {
        auto linear_view = overwide_mipped_storage_descriptor;
        linear_view.dwords[3] &= ~(0x1fu << 20u);
        (void)RenderExecutorTestAccess::ResolveTexture(executor, storage_resource,
                                                       linear_view);
      });
#endif
      auto mipped_storage_resource = storage_resource;
      mipped_storage_resource.mip_mode =
          ShaderRecompiler::IR::ImageMipMode::DynamicStorage;
      mipped_storage_resource.mip_count = 3;
      auto sampled_overwide_resource = storage_resource;
      sampled_overwide_resource.resource_class =
          ShaderRecompiler::IR::ImageResourceClass::Sampled;
      sampled_overwide_resource.numeric_class =
          Prospero::TextureNumericClass::Uint;
      sampled_overwide_resource.read = true;
      sampled_overwide_resource.written = false;
      auto plain_mipped_storage_binding =
          RenderExecutorTestAccess::ResolveTexture(executor, storage_resource,
                                                   mipped_storage_descriptor);
      vk::ClearValue tail_clear{};
      tail_clear.color.uint32[0] = tail_gpu_value;
      TextureCacheTestAccess::ClearImage(
          texture_cache, scheduler.Current(), plain_mipped_storage_binding.image_id,
          {vk::ImageAspectFlagBits::eColor, 0, 4, 0, 1}, tail_clear);
      auto mipped_storage_binding = RenderExecutorTestAccess::ResolveTexture(
          executor, mipped_storage_resource, mipped_storage_descriptor);
      auto overwide_mipped_storage_binding =
          RenderExecutorTestAccess::ResolveTexture(
              executor, storage_resource, overwide_mipped_storage_descriptor);
      auto sampled_overwide_resolved = RenderExecutorTestAccess::ResolveTexture(
          executor, sampled_overwide_resource,
          overwide_mipped_storage_descriptor);
      const auto tail0 = ReadCachedTexel(name, context, overwide_mipped_storage_binding.image_id);
      const auto tail3 = ReadCachedTexel(name, context, overwide_mipped_storage_binding.image_id,
                                        {}, {1, 1, 1}, 0, 3);
      const auto tail4 = ReadCachedTexel(name, context, overwide_mipped_storage_binding.image_id,
                                        {}, {1, 1, 1}, 0, 4);
      Require(name, "expanded tail preserves GPU and backing data",
              tail0 == std::vector<u32>{tail_gpu_value} &&
                  tail3 == std::vector<u32>{tail_gpu_value} &&
                  tail4 == std::vector<u32>{tail_backing_value},
              "expanding a shared mip tail lost GPU writes or the added mip's backing bytes");
      PreparedBindings mipped_prepared{};
      ShaderRecompiler::IR::CompiledShaderInfo mipped_program{};
      mipped_program.info.images.push_back(storage_resource);
      mipped_program.info.images.push_back(mipped_storage_resource);
      mipped_program.info.images.push_back(storage_resource);
      mipped_program.info.images.push_back(sampled_overwide_resource);
      ShaderRecompiler::IR::ResourceSnapshot mipped_snapshot{};
      mipped_snapshot.images = {mipped_storage_descriptor,
                                mipped_storage_descriptor,
                                overwide_mipped_storage_descriptor,
                                overwide_mipped_storage_descriptor};
      ShaderStageRuntime mipped_runtime{&mipped_program, std::move(mipped_snapshot)};
      mipped_prepared.runtime = &mipped_runtime;
      mipped_prepared.images.push_back(
          std::move(plain_mipped_storage_binding));
      mipped_prepared.images.push_back(
          std::move(mipped_storage_binding));
      mipped_prepared.images.push_back(
          std::move(overwide_mipped_storage_binding));
      mipped_prepared.images.push_back(
          std::move(sampled_overwide_resolved));
      executor.RebindImages(mipped_prepared);
      auto &plain_mipped_binding = mipped_prepared.images[0];
      auto &mipped_binding = mipped_prepared.images[1];
      auto &overwide_mipped_binding = mipped_prepared.images[2];
      auto &sampled_overwide_binding = mipped_prepared.images[3];
      plain_mipped_binding.layout = vk::ImageLayout::eGeneral;
      mipped_binding.layout = vk::ImageLayout::eGeneral;
      overwide_mipped_binding.layout = vk::ImageLayout::eGeneral;
      sampled_overwide_binding.layout = vk::ImageLayout::eGeneral;
      auto plain_view_desc = plain_mipped_binding.desc;
      plain_view_desc.view_info.level_count = 1;
      Require(name, "dynamic storage mip views",
              plain_mipped_binding.desc.view_info.base_level == 1 &&
                  plain_mipped_binding.desc.view_info.level_count == 3 &&
                  plain_mipped_binding.mip_views.empty() &&
                  plain_mipped_binding.image_view ==
                      texture_cache.FindTexture(plain_mipped_binding.image_id,
                                                plain_view_desc) &&
                  mipped_binding.desc.info.resources.levels == 4 &&
                  mipped_binding.desc.view_info.base_level == 1 &&
                  mipped_binding.desc.view_info.level_count == 3 &&
                  mipped_binding.mip_views.size() == 3 &&
                  mipped_binding.mip_views[0] != nullptr &&
                  mipped_binding.mip_views[1] != nullptr &&
                  mipped_binding.mip_views[2] != nullptr &&
                  mipped_binding.mip_views[0] != mipped_binding.mip_views[1] &&
                  mipped_binding.mip_views[1] != mipped_binding.mip_views[2] &&
                  MakeImageInfo(mipped_binding, 0).imageView ==
                      mipped_binding.mip_views[0] &&
                  MakeImageInfo(mipped_binding, 1).imageView ==
                      mipped_binding.mip_views[1] &&
                  MakeImageInfo(mipped_binding, 2).imageView ==
                      mipped_binding.mip_views[2],
              "base-1 through last-3 storage view did not create three "
              "ordered one-level descriptors");
      Require(name, "over-wide fixed storage mip view",
              overwide_mipped_storage.LastLevel() == 4 &&
                  overwide_mipped_storage.MaxMip() == 3 &&
                  overwide_mipped_binding.image_id ==
                      plain_mipped_binding.image_id &&
                  overwide_mipped_binding.desc.info.resources.levels == 5 &&
                  overwide_mipped_binding.desc.view_info.base_level == 1 &&
                  overwide_mipped_binding.desc.view_info.level_count == 4 &&
                  overwide_mipped_binding.mip_views.empty() &&
                  overwide_mipped_binding.image_view ==
                      plain_mipped_binding.image_view,
              "fixed storage view lost addressable mips in the allocated tail");
      Require(name, "over-wide sampled mip view",
              sampled_overwide_binding.image_id ==
                      plain_mipped_binding.image_id &&
                  sampled_overwide_binding.desc.info.resources.levels == 5 &&
                  sampled_overwide_binding.desc.view_info.base_level == 1 &&
                  sampled_overwide_binding.desc.view_info.level_count == 4 &&
                  sampled_overwide_binding.mip_views.empty() &&
                  sampled_overwide_binding.image_view != nullptr,
              "sampled view lost addressable mips in the allocated tail");
      // Streaming T# clamps apply after S# max LOD, without changing the view
      // base.
      {
        constexpr uint64_t lod_address = base + 0x170000;
        auto lod_descriptor = mipped_storage_descriptor;
        lod_descriptor.dwords[0] = static_cast<uint32_t>(lod_address >> 8u);
        lod_descriptor.dwords[1] =
            static_cast<uint32_t>(lod_address >> 40u) |
            (static_cast<uint32_t>(Prospero::BufferFormat::k32Float) << 20u) |
            (3u << 30u);
        lod_descriptor.dwords[3] &= ~(0xfu << 12u);
        ShaderSamplerResource lod_sampler{
            {0, 0,
             static_cast<uint32_t>(Prospero::SamplerMipFilter::kLinear) << 26u,
             0}};
        TestCase lod_test;
        lod_test.name = "TextureMinLodAfterSamplerClamp";
        lod_test.has_user_data = true;
        lod_test.image_descriptor_swizzle = mipped_storage.DstSelXYZW();
        std::copy_n(lod_descriptor.dwords.begin(), 8,
                    lod_test.user_data.begin());
        std::copy_n(lod_sampler.fields, 4, lod_test.user_data.begin() + 8);
        lod_test.user_data[50] = sizeof(uint32_t);
        lod_test.opcodes = {ShaderOpcode::V_MOV_B32, ShaderOpcode::IMAGE_SAMPLE,
                            ShaderOpcode::BUFFER_STORE_DWORD,
                            ShaderOpcode::S_ENDPGM};
        lod_test.required_spirv = {"OpImageSampleExplicitLod"};
        AppendVMovLiteral(&lod_test.code, 20, std::bit_cast<uint32_t>(0.5f));
        AppendVMovLiteral(&lod_test.code, 21, std::bit_cast<uint32_t>(0.5f));
        lod_test.code.push_back(EncodeMimg0(0x27, 1));
        lod_test.code.push_back(EncodeMimg1(0, 20, 0, 2));
        AppendStoreVgpr(&lod_test.code, 0, 0);
        AppendEnd(&lod_test.code);
        const auto lod_program = CompileCase(lod_test, SubgroupSize());
#if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS
        ExpectFatal("TextureMinLodBeyondView", [&] {
          auto invalid_lod = lod_descriptor;
          invalid_lod.dwords[1] |= 1024u << 8u;
          (void)RenderExecutorTestAccess::ResolveTexture(
              executor, lod_program.program.info.images[0], invalid_lod);
        });
#endif
        const auto lod_binding = RenderExecutorTestAccess::ResolveTexture(
            executor, lod_program.program.info.images[0], lod_descriptor);
        for (uint32_t mip = 0; mip < 4; ++mip) {
          vk::ClearValue clear{};
          clear.color.float32[0] = static_cast<float>(1u << mip);
          TextureCacheTestAccess::ClearImage(
              texture_cache, scheduler.Current(), lod_binding.image_id,
              {vk::ImageAspectFlagBits::eColor, mip, 1, 0, 1}, clear);
        }
        const auto sampler = context.GetSamplerCache().GetSampler(lod_sampler);
        auto output = CreateStorageBuffer(lod_test.name, {}, 1);
        struct LodCase {
          uint32_t base_level;
          uint32_t min_lod;
          float expected;
          float integer_min_lod_expected;
        };
        constexpr std::array lod_cases{
            LodCase{0, 0, 1.0f, 1.0f},   LodCase{0, 256, 2.0f, 2.0f},
            LodCase{0, 384, 3.0f, 2.0f}, LodCase{1, 384, 3.0f, 2.0f},
            LodCase{1, 512, 4.0f, 4.0f}, LodCase{1, 0, 2.0f, 2.0f},
            LodCase{0, 256, 2.0f, 2.0f}};
        std::array<vk::ImageView, lod_cases.size()> views{};
        for (size_t index = 0; index < lod_cases.size(); ++index) {
          const auto &test = lod_cases[index];
          lod_descriptor.dwords[1] =
              (lod_descriptor.dwords[1] & ~0xfff00u) | (test.min_lod << 8u);
          lod_descriptor.dwords[3] =
              (lod_descriptor.dwords[3] & ~(0xfu << 12u)) |
              (test.base_level << 12u);
          std::copy_n(lod_descriptor.dwords.begin(), 8,
                      lod_test.user_data.begin());
          const auto binding = RenderExecutorTestAccess::ResolveTexture(
              executor, lod_program.program.info.images[0], lod_descriptor);
          views[index] =
              texture_cache.FindTexture(binding.image_id, binding.desc);
          auto &image = texture_cache.GetImage(binding.image_id);
          image.Transit(vk::ImageLayout::eShaderReadOnlyOptimal,
                        vk::AccessFlagBits2::eShaderRead, {},
                        scheduler.Current().Handle());
          Image sampled;
          sampled.view = views[index];
          sampled.layout = image.backing.state.layout;
          scheduler.Finish();
          Dispatch(lod_test, lod_program, output, nullptr, &sampled, nullptr,
                   nullptr, sampler);
          const auto result = ReadBuffer(lod_test.name, output, 1)[0];
          // Vulkan permits flooring imageViewMinLod instead of retaining its
          // fraction.
          Require(lod_test.name, "sampled mip",
                  result == std::bit_cast<uint32_t>(test.expected) ||
                      result == std::bit_cast<uint32_t>(
                                    test.integer_min_lod_expected),
                  "texture clamp was lost, applied before sampler max LOD, or "
                  "rebased incorrectly");
        }
        Require(lod_test.name, "view identity",
                views[0] != views[1] && views[1] != views[2] &&
                    views[2] != views[3] && views[1] == views.back(),
                "different texture clamps aliased or identical clamped views "
                "were not reused");
        DestroyBuffer(&output);
        RenderExecutorTestAccess::ResetBindings(executor);
      }

      auto srgb_storage = storage;
      constexpr auto srgb_format =
          static_cast<uint32_t>(Prospero::BufferFormat::k8_8_8_8Srgb);
      constexpr uint64_t srgb_storage_address = base + 0xc0000;
      const auto encoded_srgb_storage_address = srgb_storage_address >> 8u;
      srgb_storage.fields[0] =
          static_cast<uint32_t>(encoded_srgb_storage_address);
      srgb_storage.fields[1] =
          static_cast<uint32_t>(encoded_srgb_storage_address >> 32u) |
          (srgb_format << 20u);
      ShaderRecompiler::IR::DescriptorValue srgb_storage_descriptor{};
      std::copy(std::begin(srgb_storage.fields), std::end(srgb_storage.fields),
                srgb_storage_descriptor.dwords.begin());
      srgb_storage_descriptor.dword_count = 8;
      auto srgb_storage_resource = storage_resource;
      srgb_storage_resource.resource_class =
          ShaderRecompiler::IR::ImageResourceClass::Storage;
      srgb_storage_resource.numeric_class =
          Prospero::TextureNumericClass::Float;
      const auto srgb_storage_binding =
          RenderExecutorTestAccess::ResolveTexture(
              executor, srgb_storage_resource, srgb_storage_descriptor);
      const auto srgb_storage_view = texture_cache.FindTexture(
          srgb_storage_binding.image_id, srgb_storage_binding.desc);
      Require(name, "sRGB storage view",
              srgb_storage_view != nullptr &&
                  srgb_storage_binding.desc.info.pixel_format ==
                      vk::Format::eR8G8B8A8Srgb &&
                  srgb_storage_binding.desc.view_info.format ==
                      vk::Format::eR8G8B8A8Unorm &&
                  texture_cache.GetImage(srgb_storage_binding.image_id)
                          .backing.format == vk::Format::eR8G8B8A8Srgb,
              "storage descriptor did not preserve its sRGB backing and "
              "select an UNORM Vulkan view");

      ShaderTextureResource sint_storage{{0x01514b00u, 0xc1500000u, 0x000bc00bu,
                                          0x91b00204u, 0x00000000u, 0x00700000u,
                                          0x102b0000u, 0x0001514au}};
      Require(name, "PPSA06888 R32 SINT descriptor",
              sint_storage.Base40() == 0x1514b0000ull &&
                  sint_storage.Width5() + 1u == 48 &&
                  sint_storage.Height5() + 1u == 48 &&
                  sint_storage.Depth() + 1u == 1 &&
                  sint_storage.Format() == Prospero::BufferFormat::k32SInt &&
                  sint_storage.Type() == Prospero::ImageType::kColor2D &&
                  sint_storage.TileMode() ==
                      Prospero::TileMode::kRenderTarget &&
                  sint_storage.DstSelXYZW() == DstSel(4, 0, 0, 1),
              "captured write-only signed storage descriptor was decoded "
              "incorrectly");
      const uint64_t mapped_sint_address = base + 0xe0000;
      const auto encoded_sint_address = mapped_sint_address >> 8u;
      sint_storage.fields[0] = static_cast<uint32_t>(encoded_sint_address);
      sint_storage.fields[1] =
          (sint_storage.fields[1] & ~0xffu) |
          static_cast<uint32_t>(encoded_sint_address >> 32u);
      constexpr uint64_t sint_metadata_address = base + 0x160000;
      const auto encoded_sint_metadata = sint_metadata_address >> 8u;
      sint_storage.fields[6] = (sint_storage.fields[6] & 0x00ffffffu) |
          (static_cast<uint32_t>(encoded_sint_metadata & 0xffu) << 24u);
      sint_storage.fields[7] = static_cast<uint32_t>(encoded_sint_metadata >> 8u);
      WriteMetadata(context, sint_metadata_address, 0x1000, UINT32_MAX);
      ShaderRecompiler::IR::DescriptorValue sint_storage_descriptor{};
      std::copy(std::begin(sint_storage.fields), std::end(sint_storage.fields),
                sint_storage_descriptor.dwords.begin());
      sint_storage_descriptor.dword_count = 8;
      auto sint_storage_resource = srgb_storage_resource;
      sint_storage_resource.resource_class =
          ShaderRecompiler::IR::ImageResourceClass::Storage;
      sint_storage_resource.numeric_class = Prospero::TextureNumericClass::Uint;
      const auto sint_storage_binding =
          RenderExecutorTestAccess::ResolveTexture(
              executor, sint_storage_resource, sint_storage_descriptor);
      const auto sint_storage_view = texture_cache.FindTexture(
          sint_storage_binding.image_id, sint_storage_binding.desc);
      Require(name, "PPSA06888 raw R32 SINT storage view",
              sint_storage_view != nullptr &&
                  sint_storage_binding.desc.info.metadata.range ==
                      GuestRange{sint_metadata_address, 0x1000} &&
                  sint_storage_binding.desc.info.data.size == 0x10000 &&
                  sint_storage_binding.desc.info.pixel_format ==
                      vk::Format::eR32Sint &&
                  sint_storage_binding.desc.view_info.format ==
                      vk::Format::eR32Uint &&
                  texture_cache.GetImage(sint_storage_binding.image_id)
                          .backing.format == vk::Format::eR32Sint,
              "write-only R32 SINT storage did not select a bit-compatible "
              "uint view");

      auto narrowed_storage = storage;
      constexpr uint64_t narrowed_storage_address = base + 0xd0000;
      const auto encoded_narrowed_address = narrowed_storage_address >> 8u;
      narrowed_storage.fields[0] =
          static_cast<uint32_t>(encoded_narrowed_address);
      narrowed_storage.fields[1] =
          static_cast<uint32_t>(encoded_narrowed_address >> 32u) |
          (static_cast<uint32_t>(stencil_format) << 20u);
      narrowed_storage.fields[3] =
          DstSel(4, 5, 6, 7) | (static_cast<uint32_t>(linear) << 20u) |
          (static_cast<uint32_t>(Prospero::ImageType::kColor1DArray) << 28u);
      narrowed_storage.fields[4] = 1u | (1u << 16u);
      ShaderRecompiler::IR::DescriptorValue narrowed_storage_descriptor{};
      std::copy(std::begin(narrowed_storage.fields),
                std::end(narrowed_storage.fields),
                narrowed_storage_descriptor.dwords.begin());
      narrowed_storage_descriptor.dword_count = 8;
      auto narrowed_storage_resource = storage_resource;
      narrowed_storage_resource.dimension =
          ShaderRecompiler::Decoder::ImageDimension::Dim1D;
      const auto narrowed_storage_binding =
          RenderExecutorTestAccess::ResolveTexture(
              executor, narrowed_storage_resource, narrowed_storage_descriptor);
      const auto narrowed_storage_view = texture_cache.FindTexture(
          narrowed_storage_binding.image_id, narrowed_storage_binding.desc);
      const auto &narrowed_storage_image =
          texture_cache.GetImage(narrowed_storage_binding.image_id);
      Require(name, "narrowed 1D array storage view",
              narrowed_storage_view != nullptr &&
                  narrowed_storage_binding.desc.info.type ==
                      Prospero::ImageType::kColor1D &&
                  narrowed_storage_binding.desc.info.resources.layers == 2 &&
                  narrowed_storage_binding.desc.view_info.type ==
                      vk::ImageViewType::e1D &&
                  narrowed_storage_binding.desc.view_info.base_layer == 1 &&
                  narrowed_storage_binding.desc.view_info.layer_count == 1 &&
                  narrowed_storage_image.backing.image_type ==
                      vk::ImageType::e1D,
              "non-array 1D specialization did not select the descriptor "
              "base layer from its 1D-array backing");

      ShaderRecompiler::IR::ResourceSnapshot storage_snapshot{};
      storage_snapshot.images.push_back(storage_descriptor);
      ShaderRecompiler::IR::CompiledShaderInfo storage_info{};
      storage_info.stage = storage_program.stage;
      storage_info.info = std::move(storage_program.info);
      storage_info.bindings = std::move(storage_program.bindings);
      ShaderStageRuntime storage_runtime{&storage_info,
                                         std::move(storage_snapshot)};
      auto storage_discovery = executor.PrepareBindings(storage_runtime);
      const auto storage_id = storage_discovery.images[0].image_id;
      Require(name, "storage prefetch purity",
              storage_discovery.images[0].image_view == nullptr &&
                  texture_cache.GetImage(storage_id).binding.is_bound &&
                  !texture_cache.GetImage(storage_id).usage.storage &&
                  !TextureCacheTestAccess::PendingDownload(texture_cache,
                                                           storage_id),
              "the first descriptor pass performed final storage acquisition");
      RenderExecutorTestAccess::ResetBindings(executor);

      ShaderRecompiler::IR::Program sampled_program{};
      sampled_program.stage = ShaderType::Pixel;
      sampled_program.resource_tracking_complete = true;
      ShaderRecompiler::IR::ImageResource sampled_resource{};
      sampled_resource.resource_class =
          ShaderRecompiler::IR::ImageResourceClass::Sampled;
      sampled_resource.numeric_class = Prospero::TextureNumericClass::Uint;
      sampled_resource.dimension =
          ShaderRecompiler::Decoder::ImageDimension::Dim2D;
      sampled_resource.read = true;
      sampled_program.info.images.push_back(sampled_resource);
      allocate_bindings(sampled_program);
      ShaderRecompiler::IR::ResourceSnapshot sampled_snapshot{};
      sampled_snapshot.images.push_back(storage_descriptor);
      ShaderRecompiler::IR::CompiledShaderInfo sampled_info{};
      sampled_info.stage = sampled_program.stage;
      sampled_info.info = std::move(sampled_program.info);
      sampled_info.bindings = std::move(sampled_program.bindings);
      ShaderStageRuntime sampled_runtime{&sampled_info,
                                         std::move(sampled_snapshot)};

      constexpr uint64_t ordered_sampled_address = base + 0x10000;
      const uint32_t ordered_sampled_value = 0x89abcdefu;
      std::memcpy(reinterpret_cast<uint8_t *>(mapped) + 0x10000,
                  &ordered_sampled_value, sizeof(ordered_sampled_value));
      auto ordered_sampled = storage;
      const auto encoded_ordered_address = ordered_sampled_address >> 8u;
      ordered_sampled.fields[0] =
          static_cast<uint32_t>(encoded_ordered_address);
      ordered_sampled.fields[1] =
          static_cast<uint32_t>(encoded_ordered_address >> 32u) |
          (static_cast<uint32_t>(stencil_format) << 20u);
      ShaderRecompiler::IR::DescriptorValue ordered_descriptor{};
      std::copy(std::begin(ordered_sampled.fields),
                std::end(ordered_sampled.fields),
                ordered_descriptor.dwords.begin());
      ordered_descriptor.dword_count = 8;
      ShaderRecompiler::IR::ResourceSnapshot ordered_snapshot{};
      ordered_snapshot.images.push_back(ordered_descriptor);
      ShaderStageRuntime ordered_sampled_runtime{sampled_runtime.program,
                                                 std::move(ordered_snapshot)};
      auto ordered_bindings = RenderExecutorTestAccess::PrepareGraphicsBindings(
          executor, storage_runtime, ordered_sampled_runtime, true);
      const auto ordered_sampled_id =
          ordered_bindings.pixel->images[0].image_id;
      Require(
          name, "VS-before-PS retained-owner order",
          ordered_bindings.vertex[0].images[0].image_id == storage_id &&
              ordered_sampled_id != storage_id &&
              RenderExecutorTestAccess::BoundImagesInOrder(executor, storage_id,
                                                           ordered_sampled_id),
          "production graphics binding did not retain vertex resources "
          "before pixel resources");
      RenderExecutorTestAccess::ResetBindings(executor);

      auto graphics_bindings =
          RenderExecutorTestAccess::PrepareGraphicsBindings(
              executor, storage_runtime, sampled_runtime, true);
      const auto &storage_binding =
          graphics_bindings.vertex[0].images[0];
      const auto &sampled_binding =
          graphics_bindings.pixel->images[0];
      Require(name, "storage final acquisition",
              storage_binding.image_view != nullptr &&
                  texture_cache.GetImage(storage_id).usage.storage &&
                  texture_cache.GetImage(storage_id).IsGpuModified() &&
                  TextureCacheTestAccess::PendingDownload(texture_cache,
                                                          storage_id),
              "the production graphics binding path did not establish GPU "
              "ownership before storage readback");
      Require(name, "VS-to-PS image acquisition order",
              storage_binding.image_id == storage_id &&
                  sampled_binding.image_id == storage_id &&
                  texture_cache.GetImage(storage_id).binding.force_general &&
                  texture_cache.GetImage(storage_id).binding.shader_write &&
                  texture_cache.GetImage(storage_id).IsGpuModified() &&
                  texture_cache.GetImage(storage_id).usage.storage &&
                  texture_cache.GetImage(storage_id).usage.texture,
              "the production graphics binding path did not complete vertex "
              "storage acquisition before pixel sampling");
      descriptor_pipelines.push_back(RenderExecutorTestAccess::CommitBindings(
          executor, scheduler.Current(), graphics_bindings.vertex[0],
          *graphics_bindings.pixel));
      Require(name, "early writable alias retention",
              texture_cache.GetImage(storage_id).backing.state.access_mask ==
                  (vk::AccessFlagBits2::eShaderRead |
                   vk::AccessFlagBits2::eShaderWrite),
              "a later sampled alias dropped an earlier storage write access");
      RenderExecutorTestAccess::ResetBindings(executor);

      ShaderRecompiler::IR::Program vertex_sampled_program{};
      vertex_sampled_program.stage = ShaderType::Vertex;
      vertex_sampled_program.resource_tracking_complete = true;
      vertex_sampled_program.info.images.push_back(sampled_resource);
      allocate_bindings(vertex_sampled_program);
      ShaderRecompiler::IR::CompiledShaderInfo vertex_sampled_info{};
      vertex_sampled_info.stage = vertex_sampled_program.stage;
      vertex_sampled_info.info = std::move(vertex_sampled_program.info);
      vertex_sampled_info.bindings =
          std::move(vertex_sampled_program.bindings);
      ShaderStageRuntime vertex_sampled_runtime{
          &vertex_sampled_info, sampled_runtime.resources};
      ShaderRecompiler::IR::Program pixel_storage_program{};
      pixel_storage_program.stage = ShaderType::Pixel;
      pixel_storage_program.resource_tracking_complete = true;
      pixel_storage_program.info.images.push_back(storage_resource);
      allocate_bindings(pixel_storage_program);
      ShaderRecompiler::IR::CompiledShaderInfo pixel_storage_info{};
      pixel_storage_info.stage = pixel_storage_program.stage;
      pixel_storage_info.info = std::move(pixel_storage_program.info);
      pixel_storage_info.bindings = std::move(pixel_storage_program.bindings);
      ShaderStageRuntime pixel_storage_runtime{&pixel_storage_info,
                                               storage_runtime.resources};
      auto writable_alias_bindings =
          RenderExecutorTestAccess::PrepareGraphicsBindings(
              executor, vertex_sampled_runtime, pixel_storage_runtime, true);
      Require(name, "late writable alias promotion",
              texture_cache.GetImage(storage_id).binding.force_general,
              "an already sampled image was not promoted when a later "
              "storage alias bound the same backing");
      descriptor_pipelines.push_back(RenderExecutorTestAccess::CommitBindings(
          executor, scheduler.Current(), writable_alias_bindings.vertex[0],
          *writable_alias_bindings.pixel));
      Require(
          name, "forced-general descriptor capture",
          writable_alias_bindings.vertex[0].images[0].layout ==
                  vk::ImageLayout::eGeneral &&
              writable_alias_bindings.pixel->images[0].layout ==
                  vk::ImageLayout::eGeneral &&
              MakeImageInfo(writable_alias_bindings.vertex[0].images[0])
                      .imageLayout == vk::ImageLayout::eGeneral &&
              MakeImageInfo(writable_alias_bindings.pixel->images[0])
                      .imageLayout == vk::ImageLayout::eGeneral &&
              texture_cache.GetImage(storage_id).backing.state.layout ==
                  vk::ImageLayout::eGeneral &&
              texture_cache.GetImage(storage_id).backing.state.access_mask ==
                  (vk::AccessFlagBits2::eShaderRead |
                   vk::AccessFlagBits2::eShaderWrite),
          "sampled/storage aliases did not retain the promoted general "
          "layout and writable access in both generated descriptors");
      RenderExecutorTestAccess::ResetBindings(executor);

      const std::array<uint32_t, 3> split_mip_data{0x01020304u, 0x05060708u,
                                                   0x090a0b0cu};
      std::memcpy(reinterpret_cast<uint8_t *>(mapped) + 0x50000,
                  split_mip_data.data(), sizeof(split_mip_data));
      ImageDesc split_desc{};
      split_desc.type = BindingType::Texture;
      split_desc.info.data = {base + 0x50000, sizeof(split_mip_data)};
      split_desc.info.pixel_format = vk::Format::eR32Uint;
      split_desc.info.guest_format = Prospero::BufferFormat::k32UInt;
      split_desc.info.type = Prospero::ImageType::kColor2D;
      split_desc.info.extent = {2, 1, 1};
      split_desc.info.resources = {2, 1};
      split_desc.info.pitch = 2;
      split_desc.info.bytes_per_block = 4;
      split_desc.info.samples = 1;
      split_desc.info.tile_mode = linear;
      split_desc.info.mip_layout[0] = {0, 8, 2, 1};
      split_desc.info.mip_layout[1] = {8, 4, 1, 1};
      split_desc.view_info.format = split_desc.info.pixel_format;
      split_desc.view_info.type = vk::ImageViewType::e2D;
      split_desc.view_info.aspect = vk::ImageAspectFlagBits::eColor;
      split_desc.view_info.level_count = 2;
      split_desc.view_info.layer_count = 1;
      split_desc.view_info.usage = vk::ImageUsageFlagBits::eSampled;
      const auto split_id = texture_cache.FindImage(split_desc);

      auto split_storage_desc = split_desc;
      split_storage_desc.type = BindingType::Storage;
      split_storage_desc.view_info.base_level = 0;
      split_storage_desc.view_info.level_count = 1;
      split_storage_desc.view_info.usage = vk::ImageUsageFlagBits::eStorage;
      auto split_sampled_desc = split_desc;
      split_sampled_desc.view_info.base_level = 1;
      split_sampled_desc.view_info.level_count = 1;
      split_sampled_desc.view_info.usage = vk::ImageUsageFlagBits::eSampled;

      ShaderRecompiler::IR::Program split_ir{};
      split_ir.stage = ShaderType::Vertex;
      split_ir.resource_tracking_complete = true;
      split_ir.info.images = {storage_resource, sampled_resource};
      allocate_bindings(split_ir);
      ShaderRecompiler::IR::CompiledShaderInfo split_program{};
      split_program.stage = split_ir.stage;
      split_program.info = std::move(split_ir.info);
      split_program.bindings = std::move(split_ir.bindings);
      PreparedBindings split_bindings{};
      ShaderStageRuntime split_runtime{.program = &split_program};
      split_bindings.runtime = &split_runtime;
      split_bindings.images.push_back(
          {split_id, texture_cache.FindTexture(split_id, split_storage_desc),
           split_storage_desc});
      split_bindings.images.push_back(
          {split_id, texture_cache.FindTexture(split_id, split_sampled_desc),
           split_sampled_desc});
      descriptor_pipelines.push_back(RenderExecutorTestAccess::CommitBindings(
          executor, scheduler.Current(), split_bindings));
      const auto &split_image = texture_cache.GetImage(split_id);
      Require(
          name, "per-binding subresource layouts",
          split_bindings.images[0].layout ==
                  vk::ImageLayout::eGeneral &&
              split_bindings.images[1].layout ==
                  vk::ImageLayout::eShaderReadOnlyOptimal &&
              MakeImageInfo(split_bindings.images[0]).imageLayout ==
                  vk::ImageLayout::eGeneral &&
              MakeImageInfo(split_bindings.images[1]).imageLayout ==
                  vk::ImageLayout::eShaderReadOnlyOptimal &&
              split_image.backing.subresource_states.size() == 2 &&
              split_image.backing.subresource_states[0].layout ==
                  vk::ImageLayout::eGeneral &&
              split_image.backing.subresource_states[1].layout ==
                  vk::ImageLayout::eShaderReadOnlyOptimal,
          "descriptor layouts were queried after a later mip transition "
          "instead of being captured at each binding");

      Libs::LibKernel::Memory::WriteBacking(
          storage_address, &storage_stale_value, sizeof(storage_stale_value));
      texture_cache.ProcessDownloadImages();
      Require(
          name, "storage acquisition download consumption",
          !TextureCacheTestAccess::PendingDownload(texture_cache, storage_id),
          "submit-time processing retained an acquired storage request");
      RenderExecutorTestAccess::ResetBindings(executor);
      scheduler.Finish();
      scheduler.DrainPriorityOperations();
      uint32_t storage_downloaded_value = 0;
      Libs::LibKernel::Memory::TryReadBacking(storage_address,
                                              &storage_downloaded_value,
                                              sizeof(storage_downloaded_value));
      const uint32_t storage_expected_value =
          (storage_stale_value & 0xffffff00u) | (storage_native_value & 0xffu);
      Require(name, "storage acquisition readback window",
              storage_downloaded_value == storage_expected_value &&
                  texture_cache.GetImage(storage_id).IsGpuModified(),
              "readback enrollment was consumed before final storage "
              "ownership became visible");

      constexpr uint64_t phased_depth_address = base + 0x90000;
      constexpr uint64_t phased_stencil_address = base + 0xa0000;
      constexpr uint64_t phased_htile_address = base + 0xb0000;
      HW::DepthRenderTarget phased_depth_target{};
      phased_depth_target.z_info.format = Prospero::DepthFormat::kZ32F;
      phased_depth_target.z_info.texture_compatibility =
          Prospero::TextureCompatiblePlaneCompression::kEnable;
      phased_depth_target.z_info.htile_acceleration = true;
      phased_depth_target.z_info.z_compare_base = Prospero::ZCompareBase::kZMax;
      phased_depth_target.stencil_info.format = Prospero::StencilFormat::k8UInt;
      phased_depth_target.stencil_info.texture_compatibility =
          Prospero::TextureCompatibleStencil::kEnable;
      phased_depth_target.stencil_info.htile_stencil_disabled = false;
      phased_depth_target.z_read_base_addr = phased_depth_address;
      phased_depth_target.z_write_base_addr = phased_depth_address;
      phased_depth_target.stencil_read_base_addr = phased_stencil_address;
      phased_depth_target.stencil_write_base_addr = phased_stencil_address;
      phased_depth_target.htile_data_base_addr = phased_htile_address;
      phased_depth_target.size.valid = true;
      registers.SetDepthRenderTarget(phased_depth_target);
      HW::DepthControl phased_depth_control{};
      phased_depth_control.z_write_enable = true;
      registers.SetDepthControl(phased_depth_control);
      registers.SetRenderControl({});
      RenderDepthInfo disabled_depth{};
      RenderExecutorTestAccess::ResolveRenderDepthTarget(
          executor, scheduler.Current(), disabled_depth);
      Require(name, "disabled tests with stale depth write enable",
              !disabled_depth.image_id,
              "a dormant depth write bit bound a depth attachment");
      phased_depth_control.z_enable = true;
      registers.SetDepthControl(phased_depth_control);
      HW::RenderControl phased_render_control{};
      phased_render_control.resummarize_enable = true;
      registers.SetRenderControl(phased_render_control);

      RenderDepthInfo phased_depth{};
      RenderExecutorTestAccess::ResolveRenderDepthTarget(
          executor, scheduler.Current(), phased_depth);
      auto non_texture_compatible_target = phased_depth_target;
      non_texture_compatible_target.z_info.texture_compatibility =
          Prospero::TextureCompatiblePlaneCompression::kDisable;
      non_texture_compatible_target.stencil_info.texture_compatibility =
          Prospero::TextureCompatibleStencil::kDisable;
      registers.SetDepthRenderTarget(non_texture_compatible_target);
      RenderDepthInfo non_texture_compatible_depth{};
      RenderExecutorTestAccess::ResolveRenderDepthTarget(
          executor, scheduler.Current(), non_texture_compatible_depth);
      Require(
          name, "depth texture compatibility identity",
          phased_depth.image_id && (phased_depth.desc.info.metadata.kind == ImageMetadataKind::Htile) &&
              non_texture_compatible_depth.image_id == phased_depth.image_id &&
              non_texture_compatible_depth.desc.info.data ==
                  phased_depth.desc.info.data &&
              non_texture_compatible_depth.desc.info.stencil ==
                  phased_depth.desc.info.stencil &&
              non_texture_compatible_depth.desc.info.metadata.range ==
                  phased_depth.desc.info.metadata.range &&
              phased_depth.desc.info.metadata.stencil_compressed &&
              !phased_depth.depth_clear_enable &&
              !texture_cache.IsMeta(phased_depth.desc.info.metadata.range.address) &&
              !texture_cache.GetImage(phased_depth.image_id).IsGpuModified() &&
              !texture_cache.GetImage(phased_depth.image_id).usage.depth_target,
          "valid PS5 texture-compatibility policy changed logical depth image "
          "identity or discovery side effects");

      auto read_only_depth_target = phased_depth_target;
      read_only_depth_target.z_write_base_addr = 0;
      read_only_depth_target.stencil_write_base_addr = 0;
      read_only_depth_target.depth_view.depth_write_disable = true;
      read_only_depth_target.depth_view.stencil_write_disable = true;
      registers.SetDepthRenderTarget(read_only_depth_target);
      auto read_only_depth_control = phased_depth_control;
      read_only_depth_control.z_write_enable = false;
      read_only_depth_control.zfunc =
          static_cast<uint8_t>(vk::CompareOp::eAlways);
      read_only_depth_control.stencil_enable = true;
      read_only_depth_control.stencilfunc =
          static_cast<uint8_t>(vk::CompareOp::eAlways);
      registers.SetDepthControl(read_only_depth_control);
      HW::StencilControl read_only_stencil_control{};
      read_only_stencil_control.stencil_zpass =
          static_cast<uint8_t>(Prospero::StencilOp::kReplaceOp);
      registers.SetStencilControl(read_only_stencil_control);
      HW::StencilMask read_only_stencil_mask{};
      read_only_stencil_mask.stencil_testval = 0x12;
      read_only_stencil_mask.stencil_mask = 0xff;
      read_only_stencil_mask.stencil_writemask = 0xff;
      read_only_stencil_mask.stencil_opval = 0x34;
      registers.SetStencilMask(read_only_stencil_mask);
      RenderDepthInfo read_only_depth{};
      RenderExecutorTestAccess::ResolveRenderDepthTarget(
          executor, scheduler.Current(), read_only_depth);
      Require(
          name, "read-only depth/stencil target without write addresses",
          read_only_depth.image_id == phased_depth.image_id &&
              read_only_depth.desc.info.data.address == phased_depth_address &&
              read_only_depth.desc.info.stencil.address == phased_stencil_address &&
              !read_only_depth.depth_write_enable &&
              !read_only_depth.stencil_clear_enable &&
              read_only_depth.stencil_test_enable &&
              read_only_depth.stencil_front.writeMask == 0 &&
              read_only_depth.stencil_back.writeMask == 0 &&
              read_only_depth.stencil_front.passOp ==
                  vk::StencilOp::eKeep &&
              !read_only_depth.AttachmentWriteAspects() &&
              depth_attachment_layout(read_only_depth) ==
                  vk::ImageLayout::eDepthStencilReadOnlyOptimal,
          "a PS5 read-only depth/stencil target required write addresses or "
          "retained host writes");

      auto read_only_render_control = phased_render_control;
      read_only_render_control.stencil_clear_enable = true;
      registers.SetRenderControl(read_only_render_control);
      RenderDepthInfo read_only_clear_depth{};
      RenderExecutorTestAccess::ResolveRenderDepthTarget(
          executor, scheduler.Current(), read_only_clear_depth);
      Require(name, "read-only stencil clear suppression",
              read_only_clear_depth.image_id == phased_depth.image_id &&
                  !read_only_clear_depth.stencil_clear_enable &&
                  !read_only_clear_depth.AttachmentWriteAspects() &&
                  depth_attachment_layout(read_only_clear_depth) ==
                      vk::ImageLayout::eDepthStencilReadOnlyOptimal,
              "a PS5 target-level stencil write disable retained a host clear");

      registers.SetDepthRenderTarget(phased_depth_target);
      registers.SetDepthControl(phased_depth_control);
      registers.SetStencilControl({});
      registers.SetStencilMask({});
      registers.SetRenderControl(phased_render_control);
      RenderColorInfo no_color{};
      auto phased_rendering = RenderExecutorTestAccess::AcquireRenderTargets(
          executor, scheduler.Current(), &no_color, 0, phased_depth);
      Require(
          name, "HTile final acquisition",
          phased_rendering.depth_stencil_attachment.image_view != nullptr &&
              phased_rendering.num_color_attachments == 0 &&
              phased_rendering.depth_stencil_attachment.has_depth &&
              phased_rendering.depth_stencil_attachment.depth_clear &&
              phased_depth.depth_load_clear_enable &&
              texture_cache.IsMeta(phased_depth.desc.info.metadata.range.address) &&
              !texture_cache.IsMetaCleared(
                  phased_depth.desc.info.metadata.range.address,
                  phased_depth.desc.view_info.base_layer) &&
              texture_cache.GetImage(phased_depth.image_id).IsGpuModified() &&
              texture_cache.GetImage(phased_depth.image_id).usage.depth_target,
          "final depth acquisition did not publish and consume HTile "
          "state at the final acquisition boundary");
      RenderExecutorTestAccess::ResetBindings(executor);

      constexpr uint64_t depth_only_address = base + 0x140000;
      constexpr uint64_t depth_only_htile_address = base + 0x150000;
      constexpr uint32_t captured_depth_only_z_info = 0x22900983u;
      constexpr uint32_t captured_depth_only_stencil_info = 0x00100980u;
      HW::DepthRenderTarget depth_only_target{};
      depth_only_target.z_info =
          HW::DepthZInfo::Decode(captured_depth_only_z_info);
      depth_only_target.stencil_info =
          HW::DepthStencilInfo::Decode(captured_depth_only_stencil_info);
      depth_only_target.z_read_base_addr = depth_only_address;
      depth_only_target.z_write_base_addr = depth_only_address;
      depth_only_target.htile_data_base_addr = depth_only_htile_address;
      depth_only_target.size = {63, 63, true};
      registers.SetDepthRenderTarget(depth_only_target);
      HW::DepthControl depth_only_control{};
      depth_only_control.stencil_enable = true;
      depth_only_control.z_enable = true;
      depth_only_control.z_write_enable = true;
      depth_only_control.zfunc = static_cast<uint8_t>(vk::CompareOp::eAlways);
      registers.SetDepthControl(depth_only_control);
      HW::RenderControl depth_only_render_control{};
      depth_only_render_control.depth_clear_enable = true;
      depth_only_render_control.stencil_clear_enable = true;
      registers.SetRenderControl(depth_only_render_control);
      RenderDepthInfo depth_only{};
      RenderExecutorTestAccess::ResolveRenderDepthTarget(
          executor, scheduler.Current(), depth_only);
      Require(
          name, "depth-only target with stale stencil state",
          depth_only.image_id && depth_only.desc.view_info.format == vk::Format::eD32Sfloat &&
              (depth_only.desc.info.metadata.kind == ImageMetadataKind::Htile) &&
              depth_only.depth_test_enable && !depth_only.depth_write_enable &&
              depth_only.depth_clear_enable &&
              !depth_only.stencil_test_enable &&
              !depth_only.stencil_clear_enable &&
              depth_only.desc.info.stencil.Empty() &&
              depth_only.desc.info.metadata.range.address ==
                  depth_only_htile_address &&
              depth_only.desc.info.data.size != 0 &&
              depth_only_address + depth_only.desc.info.data.size <=
                  base + allocation_size &&
              depth_only.AttachmentWriteAspects() ==
                  vk::ImageAspectFlagBits::eDepth,
          "inactive stencil state changed a depth-only HTile attachment");
      RenderExecutorTestAccess::ResetBindings(executor);

      const auto sampled_width = depth_only.desc.info.extent.width - 1u;
      const auto sampled_height = depth_only.desc.info.extent.height - 1u;
      const auto sampled_address = depth_only_address >> 8u;
      ShaderTextureResource sampled_depth_descriptor{};
      sampled_depth_descriptor.fields[0] =
          static_cast<uint32_t>(sampled_address);
      sampled_depth_descriptor.fields[1] =
          static_cast<uint32_t>(sampled_address >> 32u) |
          (static_cast<uint32_t>(Prospero::BufferFormat::k32UInt) << 20u) |
          ((sampled_width & 3u) << 30u);
      sampled_depth_descriptor.fields[2] =
          (sampled_width >> 2u) | (sampled_height << 14u);
      sampled_depth_descriptor.fields[3] =
          DstSel(4, 4, 4, 4) |
          (static_cast<uint32_t>(Prospero::TileMode::kDepth) << 20u) |
          (static_cast<uint32_t>(Prospero::ImageType::kColor2D) << 28u);
      sampled_depth_descriptor.fields[5] = 0x00700000u;
      ShaderRecompiler::IR::DescriptorValue sampled_depth_value{};
      std::copy(std::begin(sampled_depth_descriptor.fields),
                std::end(sampled_depth_descriptor.fields),
                sampled_depth_value.dwords.begin());
      sampled_depth_value.dword_count = 8;
      ShaderRecompiler::IR::ImageResource sampled_depth_resource{};
      sampled_depth_resource.resource_class =
          ShaderRecompiler::IR::ImageResourceClass::Sampled;
      sampled_depth_resource.numeric_class =
          Prospero::TextureNumericClass::Uint;
      sampled_depth_resource.dimension =
          ShaderRecompiler::Decoder::ImageDimension::Dim2D;
      sampled_depth_resource.read = true;
      const auto sampled_depth_backing =
          texture_cache.GetImage(depth_only.image_id).backing.image;
      auto sampled_depth_binding = RenderExecutorTestAccess::ResolveTexture(
          executor, sampled_depth_resource, sampled_depth_value);
      const auto sampled_depth_view = texture_cache.FindTexture(
          sampled_depth_binding.image_id, sampled_depth_binding.desc);
      const auto &sampled_depth_image =
          texture_cache.GetImage(sampled_depth_binding.image_id);
      const bool normalized_depth_view = std::ranges::any_of(
          sampled_depth_image.views, [&](const auto &cached) {
            return cached.view == sampled_depth_view &&
                   cached.info.format == vk::Format::eD32Sfloat &&
                   cached.info.aspect == vk::ImageAspectFlagBits::eDepth &&
                   cached.info.usage == vk::ImageUsageFlags{};
          });
      Require(
          name, "R32 uint depth-backed view",
          sampled_depth_binding.image_id == depth_only.image_id &&
              sampled_depth_binding.desc.info.guest_format ==
                  Prospero::BufferFormat::k32UInt &&
              sampled_depth_binding.desc.info.pixel_format ==
                  vk::Format::eR32Uint &&
              sampled_depth_binding.desc.view_info.format ==
                  vk::Format::eR32Uint &&
              sampled_depth_binding.desc.view_info.aspect ==
                  vk::ImageAspectFlagBits::eColor &&
              sampled_depth_binding.desc.view_info.usage ==
                  vk::ImageUsageFlagBits::eSampled &&
              sampled_depth_image.info.pixel_format == vk::Format::eD32Sfloat &&
              sampled_depth_image.backing.format == vk::Format::eD32Sfloat &&
              sampled_depth_image.backing.image == sampled_depth_backing &&
              sampled_depth_view != nullptr && normalized_depth_view,
          "uint T# did not retain its requested format while the concrete "
          "view followed the D32 backing");
      RenderExecutorTestAccess::ResetBindings(executor);

      // Attachment acquisition consumes pending HTile clears using DB_DEPTH_CLEAR.
      (void)texture_cache.FindDepthTarget(depth_only.image_id, depth_only.desc);
      auto bounds_target = depth_only_target;
      bounds_target.z_write_base_addr = 0;
      bounds_target.depth_view.depth_write_disable = true;
      registers.SetDepthRenderTarget(bounds_target);
      HW::DepthControl bounds_control{};
      bounds_control.depth_bounds_enable = true;
      registers.SetDepthControl(bounds_control);
      registers.SetRenderControl({});
      registers.SetDepthClearValue(0.375f);
      ShaderStageRuntime bounds_vertex{&vertex_sampled_info, {}};
      ShaderStageRuntime bounds_pixel{&sampled_info, {}};
      bounds_vertex.resources.images.push_back(sampled_depth_value);
      bounds_pixel.resources.images.push_back(sampled_depth_value);
      const auto depth_texels = depth_only.desc.info.extent.width *
                                depth_only.desc.info.extent.height;
      const auto depth_bytes = depth_texels * sizeof(uint32_t);
      auto bounds_readback = CreateHostBuffer(name, depth_bytes * 2,
          vk::BufferUsageFlagBits::eTransferDst, {});
      for (uint32_t pass = 0; pass < 2; ++pass) {
        Require(name, "bounds prior depth contents",
                texture_cache.ClearImageFromBuffer(scheduler.Current(),
                    depth_only.desc.info.data.address, depth_only.desc.info.data.size,
                    std::bit_cast<uint32_t>(0.625f)),
                "failed to seed depth before the deferred HTile clear");
        if (pass == 0) {
          Require(name, "bounds deferred HTile clear",
                  texture_cache.ClearMeta(depth_only_htile_address),
                  "depth-only HTile was not registered");
        } else {
          bounds_target.z_write_base_addr = depth_only_address;
          bounds_target.depth_view.depth_write_disable = false;
          bounds_control.z_write_enable = true;
          registers.SetDepthRenderTarget(bounds_target);
          registers.SetDepthControl(bounds_control);
        }
        RenderDepthInfo bounds_depth{};
        RenderExecutorTestAccess::ResolveRenderDepthTarget(
            executor, scheduler.Current(), bounds_depth);
        auto bounds_bindings = RenderExecutorTestAccess::PrepareGraphicsBindings(
            executor, bounds_vertex, bounds_pixel, true);
        const auto bounds_rendering = RenderExecutorTestAccess::AcquireRenderTargets(
            executor, scheduler.Current(), &no_color, 0, bounds_depth, bounds_bindings.pixel);
        descriptor_pipelines.push_back(RenderExecutorTestAccess::CommitBindings(
            executor, scheduler.Current(), bounds_bindings.vertex[0], *bounds_bindings.pixel));
        const auto &vertex_depth = bounds_bindings.vertex[0].images[0];
        const auto &pixel_depth = bounds_bindings.pixel->images[0];
        constexpr auto readonly_layout = vk::ImageLayout::eDepthReadOnlyOptimal;
        Require(name, "deferred clear with sampled read-only depth bounds",
                bounds_depth.image_id == depth_only.image_id &&
                    bounds_depth.depth_bounds_test_enable &&
                    !bounds_depth.depth_write_enable &&
                    bounds_depth.depth_load_clear_enable == (pass == 0) &&
                    !texture_cache.IsMetaCleared(depth_only_htile_address, 0) &&
                    bounds_rendering.depth_stencil_attachment.image_layout == readonly_layout &&
                    bounds_rendering.depth_stencil_attachment.depth_clear == (pass == 0) &&
                    vertex_depth.image_id == depth_only.image_id &&
                    pixel_depth.image_id == depth_only.image_id &&
                    MakeImageInfo(vertex_depth).imageLayout == readonly_layout &&
                    MakeImageInfo(pixel_depth).imageLayout == readonly_layout,
                "deferred clear changed guest depth writes, sampled layouts, or repeated");
        scheduler.BeginRendering(bounds_rendering);
        scheduler.EndRendering();
        RenderExecutorTestAccess::ResetBindings(executor);
        const vk::BufferImageCopy copy{pass * depth_bytes, 0, 0,
            {vk::ImageAspectFlagBits::eDepth, 0, 0, 1}, {}, depth_only.desc.info.extent};
        texture_cache.GetImage(depth_only.image_id).Download(
            std::span{&copy, 1}, bounds_readback.buffer, 0, bounds_readback.size);
      }
      vk::MemoryBarrier2 bounds_host_barrier{};
      bounds_host_barrier.sType = vk::StructureType::eMemoryBarrier2;
      bounds_host_barrier.srcStageMask = vk::PipelineStageFlagBits2::eTransfer;
      bounds_host_barrier.srcAccessMask = vk::AccessFlagBits2::eTransferWrite;
      bounds_host_barrier.dstStageMask = vk::PipelineStageFlagBits2::eHost;
      bounds_host_barrier.dstAccessMask = vk::AccessFlagBits2::eHostRead;
      vk::DependencyInfo bounds_dependency{};
      bounds_dependency.sType = vk::StructureType::eDependencyInfo;
      bounds_dependency.memoryBarrierCount = 1;
      bounds_dependency.pMemoryBarriers = &bounds_host_barrier;
      scheduler.Current().Handle().pipelineBarrier2(bounds_dependency);
      scheduler.Finish();
      const auto bounds_result = ReadBuffer(name, bounds_readback, depth_texels * 2);
      Require(name, "deferred HTile clear occurs once",
              std::ranges::all_of(std::span{bounds_result}.first(depth_texels),
                  [](uint32_t value) { return value == std::bit_cast<uint32_t>(0.375f); }) &&
              std::ranges::all_of(std::span{bounds_result}.subspan(depth_texels),
                  [](uint32_t value) { return value == std::bit_cast<uint32_t>(0.625f); }),
              "pending clear did not use DB_DEPTH_CLEAR or cleared the next acquisition again");
      DestroyBuffer(&bounds_readback);
      registers.SetDepthClearValue(0.0f);

      // DB override copies run with depth and stencil tests disabled.
      constexpr uint64_t copy_source_depth = base + 0x180000;
      constexpr uint64_t copy_source_stencil = base + 0x1a0000;
      constexpr uint64_t copy_destination_depth = base + 0x1c0000;
      constexpr uint64_t copy_destination_stencil = base + 0x1e0000;
      constexpr uint32_t copy_side = 8;
      constexpr uint32_t copy_layer_texels = copy_side * copy_side;
      constexpr uint32_t copy_depth_bytes =
          copy_layer_texels * 2 * sizeof(uint32_t);
      constexpr uint32_t copy_readback_stride =
          copy_depth_bytes + copy_layer_texels * 2;
      HW::DepthRenderTarget copy_target{};
      copy_target.z_info.format = Prospero::DepthFormat::kZ32F;
      copy_target.z_info.texture_compatibility =
          Prospero::TextureCompatiblePlaneCompression::kEnable;
      copy_target.stencil_info.format = Prospero::StencilFormat::k8UInt;
      copy_target.stencil_info.texture_compatibility =
          Prospero::TextureCompatibleStencil::kEnable;
      copy_target.stencil_info.htile_stencil_disabled = true;
      copy_target.depth_view.slice_max = 1;
      copy_target.size = {copy_side - 1, copy_side - 1, true};
      HW::DepthControl copy_seed_control{};
      copy_seed_control.z_enable = true;
      copy_seed_control.z_write_enable = true;
      copy_seed_control.stencil_enable = true;
      registers.SetDepthControl(copy_seed_control);
      registers.SetRenderControl({});
      const auto make_copy_target = [&](uint64_t depth, uint64_t stencil) {
        auto target = copy_target;
        target.z_read_base_addr = depth;
        target.z_write_base_addr = depth;
        target.stencil_read_base_addr = stencil;
        target.stencil_write_base_addr = stencil;
        registers.SetDepthRenderTarget(target);
        RenderDepthInfo resolved{};
        RenderExecutorTestAccess::ResolveRenderDepthTarget(
            executor, scheduler.Current(), resolved);
        (void)texture_cache.FindDepthTarget(resolved.image_id, resolved.desc);
        RenderExecutorTestAccess::ResetBindings(executor);
        return resolved;
      };
      const auto copy_source =
          make_copy_target(copy_source_depth, copy_source_stencil);
      const auto copy_destination =
          make_copy_target(copy_destination_depth, copy_destination_stencil);
      const auto clear_copy_target = [&](ImageId id, bool source) {
        auto &image = texture_cache.GetImage(id);
        image.Transit(vk::ImageLayout::eTransferDstOptimal,
                      vk::AccessFlagBits2::eTransferWrite, {},
                      scheduler.Current().Handle());
        for (uint32_t layer = 0; layer < 2; ++layer) {
          const vk::ClearDepthStencilValue clear{
              source ? (layer == 0 ? 0.75f : 0.25f)
                     : (layer == 0 ? 0.875f : 0.625f),
              source ? (layer == 0 ? 0xa3u : 0x5au)
                     : (layer == 0 ? 0x31u : 0xc4u)};
          const vk::ImageSubresourceRange range{
              vk::ImageAspectFlagBits::eDepth |
                  vk::ImageAspectFlagBits::eStencil,
              0, 1, layer, 1};
          scheduler.Current().Handle().clearDepthStencilImage(
              image.backing.image, vk::ImageLayout::eTransferDstOptimal, &clear,
              1, &range);
        }
        texture_cache.MarkGpuWritten(id);
      };
      struct CopyCase {
        const char *label;
        HW::DepthRenderOverride override;
        uint32_t color_mode;
        bool depth;
        bool stencil;
      };
      constexpr std::array copy_cases{
          CopyCase{"no override", {}, 0, false, false},
          CopyCase{
              "depth valid only", {true, false, false, false}, 0, false, false},
          CopyCase{
              "depth dirty only", {false, true, false, false}, 0, false, false},
          CopyCase{"stencil valid only",
                   {false, false, true, false},
                   0,
                   false,
                   false},
          CopyCase{"stencil dirty only",
                   {false, false, false, true},
                   0,
                   false,
                   false},
          CopyCase{
              "unpaired aspects", {true, false, false, true}, 0, false, false},
          CopyCase{"color enabled", {true, true, true, true}, 1, false, false},
          CopyCase{"depth only", {true, true, false, false}, 0, true, false},
          CopyCase{"stencil only", {false, false, true, true}, 0, false, true},
          CopyCase{
              "depth and stencil", {true, true, true, true}, 0, true, true}};
      auto copy_readback =
          CreateHostBuffer(name, copy_cases.size() * copy_readback_stride,
                           vk::BufferUsageFlagBits::eTransferDst, {});
      copy_target.z_read_base_addr = copy_source_depth;
      copy_target.z_write_base_addr = copy_destination_depth;
      copy_target.stencil_read_base_addr = copy_source_stencil;
      copy_target.stencil_write_base_addr = copy_destination_stencil;
      copy_target.depth_view.slice_start = 1;
      registers.SetDepthRenderTarget(copy_target);
      registers.SetDepthControl({});
      RenderDepthInfo copy_disabled_depth{};
      RenderExecutorTestAccess::ResolveRenderDepthTarget(
          executor, scheduler.Current(), copy_disabled_depth);
      Require(name, "copy without attachment tests",
              !copy_disabled_depth.image_id,
              "disabled depth/stencil tests acquired a regular attachment");
      for (size_t index = 0; index < copy_cases.size(); ++index) {
        const auto &test = copy_cases[index];
        clear_copy_target(copy_source.image_id, true);
        clear_copy_target(copy_destination.image_id, false);
        registers.SetDepthRenderOverride(test.override);
        auto color_control = registers.GetColorControl();
        color_control.mode = test.color_mode;
        registers.SetColorControl(color_control);
        Require(name, test.label,
                RenderExecutorTestAccess::DepthStencilCopy(
                    executor, scheduler.Current()) ==
                    (test.depth || test.stencil),
                "DB override copy did not honor paired flags and disabled "
                "color output");
        RenderExecutorTestAccess::ResetBindings(executor);
        const auto offset = index * copy_readback_stride;
        const std::array<vk::BufferImageCopy, 2> copies{
            {{offset,
              0,
              0,
              {vk::ImageAspectFlagBits::eDepth, 0, 0, 2},
              {},
              copy_destination.desc.info.extent},
             {offset + copy_depth_bytes,
              0,
              0,
              {vk::ImageAspectFlagBits::eStencil, 0, 0, 2},
              {},
              copy_destination.desc.info.extent}}};
        texture_cache.GetImage(copy_destination.image_id)
            .Download(copies, copy_readback.buffer, 0, copy_readback.size);
      }
      scheduler.Current().Handle().pipelineBarrier2(bounds_dependency);
      scheduler.Finish();
      const auto copy_result = ReadBuffer(
          name, copy_readback,
          copy_cases.size() * copy_readback_stride / sizeof(uint32_t));
      for (size_t index = 0; index < copy_cases.size(); ++index) {
        const auto &test = copy_cases[index];
        const auto *depth = copy_result.data() +
                            index * copy_readback_stride / sizeof(uint32_t);
        const auto *stencil =
            reinterpret_cast<const uint8_t *>(depth) + copy_depth_bytes;
        for (uint32_t layer = 0; layer < 2; ++layer) {
          const auto expected_depth =
              std::bit_cast<uint32_t>(layer == 0   ? 0.875f
                                      : test.depth ? 0.25f
                                                   : 0.625f);
          const auto expected_stencil = layer == 0     ? 0x31u
                                        : test.stencil ? 0x5au
                                                       : 0xc4u;
          for (uint32_t texel = 0; texel < copy_layer_texels; ++texel) {
            const auto position = layer * copy_layer_texels + texel;
            Require(name, test.label,
                    depth[position] == expected_depth &&
                        stencil[position] == expected_stencil,
                    "DB override copy changed an unselected layer/aspect or "
                    "missed copied texels");
          }
        }
      }
      DestroyBuffer(&copy_readback);

      ShaderTextureResource copy_sample_descriptor{};
      copy_sample_descriptor.fields[0] =
          static_cast<uint32_t>(copy_destination_depth >> 8u);
      copy_sample_descriptor.fields[1] =
          static_cast<uint32_t>(copy_destination_depth >> 40u) |
          (static_cast<uint32_t>(Prospero::BufferFormat::k32Float) << 20u) |
          (((copy_side - 1u) & 3u) << 30u);
      copy_sample_descriptor.fields[2] =
          ((copy_side - 1u) >> 2u) | ((copy_side - 1u) << 14u);
      copy_sample_descriptor.fields[3] =
          DstSel(4, 4, 4, 4) |
          (static_cast<uint32_t>(Prospero::TileMode::kDepth) << 20u) |
          (static_cast<uint32_t>(Prospero::ImageType::kColor2DArray) << 28u);
      copy_sample_descriptor.fields[4] = 1;
      copy_sample_descriptor.fields[5] = 0x00700000u;
      TestCase copy_sample_test;
      copy_sample_test.name = "DepthOverrideR32Sampling";
      copy_sample_test.has_user_data = true;
      copy_sample_test.image_descriptor_swizzle =
          copy_sample_descriptor.DstSelXYZW();
      std::copy_n(copy_sample_descriptor.fields, 8,
                  copy_sample_test.user_data.begin());
      copy_sample_test.user_data[50] = 2 * sizeof(uint32_t);
      copy_sample_test.opcodes = {
          ShaderOpcode::V_MOV_B32, ShaderOpcode::IMAGE_SAMPLE,
          ShaderOpcode::BUFFER_STORE_DWORD, ShaderOpcode::S_ENDPGM};
      copy_sample_test.required_spirv = {"OpImageSampleExplicitLod"};
      for (uint32_t layer = 0; layer < 2; ++layer) {
        AppendVMovLiteral(&copy_sample_test.code, 20,
                          std::bit_cast<uint32_t>(0.5f));
        AppendVMovLiteral(&copy_sample_test.code, 21,
                          std::bit_cast<uint32_t>(0.5f));
        AppendVMovLiteral(&copy_sample_test.code, 22,
                          std::bit_cast<uint32_t>(static_cast<float>(layer)));
        copy_sample_test.code.push_back(EncodeMimg0(0x20, 1, 0, false, 5));
        copy_sample_test.code.push_back(EncodeMimg1(0, 20, 0, 2));
        AppendStoreVgpr(&copy_sample_test.code, 0, layer);
        copy_sample_test.expected.push_back(
            std::bit_cast<uint32_t>(layer == 0 ? 0.875f : 0.25f));
      }
      AppendEnd(&copy_sample_test.code);
      const auto copy_sample_program =
          CompileCase(copy_sample_test, SubgroupSize());
      ShaderRecompiler::IR::DescriptorValue copy_sample_value{};
      copy_sample_value.dword_count = 8;
      std::copy_n(copy_sample_descriptor.fields, 8,
                  copy_sample_value.dwords.begin());
      const auto copy_sample_binding = RenderExecutorTestAccess::ResolveTexture(
          executor, copy_sample_program.program.info.images[0],
          copy_sample_value);
      const auto copy_sample_view = texture_cache.FindTexture(
          copy_sample_binding.image_id, copy_sample_binding.desc);
      Require(
          name, "copied depth sampled owner",
          copy_sample_binding.image_id == copy_destination.image_id &&
              copy_sample_binding.desc.info.pixel_format ==
                  vk::Format::eR32Sfloat,
          "R32 sampling did not reuse the GPU-written depth-copy destination");
      auto &copy_sample_image = texture_cache.GetImage(copy_destination.image_id);
      copy_sample_image.Transit(vk::ImageLayout::eShaderReadOnlyOptimal,
                                vk::AccessFlagBits2::eShaderRead, {},
                                scheduler.Current().Handle());
      Image copied_depth_sample;
      copied_depth_sample.view = copy_sample_view;
      copied_depth_sample.layout = copy_sample_image.backing.state.layout;
      scheduler.Finish();
      auto copy_sample_output = CreateStorageBuffer(name, {}, 2);
      const auto copy_sampler = CreateNearestSampler(name);
      Dispatch(copy_sample_test, copy_sample_program, copy_sample_output,
               nullptr, &copied_depth_sample, nullptr, nullptr, copy_sampler);
      Require(
          name, "copied depth R32 samples",
          ReadBuffer(name, copy_sample_output, 2) == copy_sample_test.expected,
          "R32 post-effect sampling saw stale depth after the override copy");
      m_device.destroySampler(copy_sampler);
      DestroyBuffer(&copy_sample_output);
      RenderExecutorTestAccess::ResetBindings(executor);
      registers.SetDepthRenderOverride({});
      registers.SetColorControl({});

      auto shared_depth_descriptor = sampled_depth_descriptor;
      shared_depth_descriptor.fields[0] =
          static_cast<uint32_t>(phased_depth_address >> 8u);
      shared_depth_descriptor.fields[1] =
          static_cast<uint32_t>(phased_depth_address >> 40u) |
          (static_cast<uint32_t>(Prospero::BufferFormat::k32UInt) << 20u);
      shared_depth_descriptor.fields[2] = 0;
      ShaderRecompiler::IR::DescriptorValue shared_depth_value{};
      std::copy(std::begin(shared_depth_descriptor.fields),
                std::end(shared_depth_descriptor.fields),
                shared_depth_value.dwords.begin());
      shared_depth_value.dword_count = 8;
      ShaderStageRuntime shared_depth_vertex{&vertex_sampled_info, {}};
      ShaderStageRuntime shared_depth_pixel{&sampled_info, {}};
      shared_depth_vertex.resources.images.push_back(shared_depth_value);
      shared_depth_pixel.resources.images.push_back(shared_depth_value);
      for (const bool stencil_write : {true, false}) {
        registers.SetDepthRenderTarget(phased_depth_target);
        registers.SetRenderControl({});
        registers.SetDepthControl(read_only_depth_control);
        HW::StencilControl shared_stencil_control{};
        shared_stencil_control.stencil_zpass =
            static_cast<uint8_t>(Prospero::StencilOp::kReplaceTest);
        registers.SetStencilControl(shared_stencil_control);
        HW::StencilMask shared_stencil_mask{};
        shared_stencil_mask.stencil_testval = 0x20;
        shared_stencil_mask.stencil_mask = 0xff;
        shared_stencil_mask.stencil_writemask = stencil_write ? 0xf4 : 0;
        registers.SetStencilMask(shared_stencil_mask);
        RenderDepthInfo shared_depth{};
        RenderExecutorTestAccess::ResolveRenderDepthTarget(
            executor, scheduler.Current(), shared_depth);
        auto shared_bindings =
            RenderExecutorTestAccess::PrepareGraphicsBindings(
                executor, shared_depth_vertex, shared_depth_pixel, true);
        const auto shared_rendering =
            RenderExecutorTestAccess::AcquireRenderTargets(
                executor, scheduler.Current(), &no_color, 0, shared_depth, shared_bindings.pixel);
        descriptor_pipelines.push_back(RenderExecutorTestAccess::CommitBindings(
            executor, scheduler.Current(), shared_bindings.vertex[0],
            *shared_bindings.pixel));
        const auto expected_layout =
            stencil_write
                ? vk::ImageLayout::eDepthReadOnlyStencilAttachmentOptimal
                : vk::ImageLayout::eDepthStencilReadOnlyOptimal;
        const auto expected_access =
            vk::AccessFlagBits2::eShaderRead |
            vk::AccessFlagBits2::eDepthStencilAttachmentRead |
            vk::AccessFlagBits2::eDepthStencilAttachmentWrite;
        const auto &shared_image = texture_cache.GetImage(shared_depth.image_id);
        const auto &vertex_image = shared_bindings.vertex[0].images[0];
        const auto &pixel_image = shared_bindings.pixel->images[0];
        Require(name, "sampled depth and stencil attachment layout",
                shared_depth.image_id == phased_depth.image_id &&
                    vertex_image.image_id == shared_depth.image_id &&
                    pixel_image.image_id == shared_depth.image_id &&
                    MakeImageInfo(vertex_image).imageLayout == expected_layout &&
                    MakeImageInfo(pixel_image).imageLayout == expected_layout &&
                    shared_rendering.depth_stencil_attachment.image_layout ==
                        expected_layout &&
                    shared_image.backing.state.layout == expected_layout &&
                    shared_image.backing.state.access_mask == expected_access,
                "a shader alias replaced the depth/stencil attachment layout "
                "or dropped an attachment access");
        scheduler.BeginRendering(shared_rendering);
        scheduler.EndRendering();
        RenderExecutorTestAccess::ResetBindings(executor);
        Require(name, "attachment binding reset",
                !shared_image.binding.is_target &&
                    shared_image.binding.attachment_layout ==
                        vk::ImageLayout::eUndefined &&
                    !shared_image.binding.attachment_access,
                "attachment usage leaked into the next draw");
      }

      auto video_subresource =
          make_target_desc(base + 0x20000, target_mip_size, {1, 1, 1});
      video_subresource.type = BindingType::VideoOut;
      video_subresource.info.pixel_format = vk::Format::eR8G8B8A8Srgb;
      video_subresource.info.guest_format =
          Prospero::BufferFormat::k8_8_8_8Srgb;
      video_subresource.view_info.format = video_subresource.info.pixel_format;
      video_subresource.view_info.usage = vk::ImageUsageFlagBits::eSampled;
      const auto video_subresource_id =
          texture_cache.FindImage(video_subresource);
      const auto video_subresource_owner =
          TextureCacheTestAccess::Owner(texture_cache, video_subresource_id);
      auto video_parent =
          make_target_desc(base + 0x20000, target_mip_size * 2, {2, 2, 1});
      video_parent.type = BindingType::VideoOut;
      video_parent.info.pixel_format = vk::Format::eR8G8B8A8Srgb;
      video_parent.info.guest_format = Prospero::BufferFormat::k8_8_8_8Srgb;
      video_parent.info.resources.levels = 2;
      video_parent.info.mip_layout[0] = {0, target_mip_size, 2, 2};
      video_parent.info.mip_layout[1] = {target_mip_size, target_mip_size, 1,
                                         1};
      video_parent.view_info.format = video_parent.info.pixel_format;
      video_parent.view_info.usage = vk::ImageUsageFlagBits::eSampled;
      const auto video_parent_id = texture_cache.FindImage(video_parent);
      const auto video_parent_owner =
          TextureCacheTestAccess::Owner(texture_cache, video_parent_id);
      Require(name, "video-out replacement remains cache-only",
              video_subresource_owner != nullptr &&
                  video_parent_owner != nullptr &&
                  video_parent_id != video_subresource_id &&
                  !video_subresource_owner->binding.is_bound &&
                  !video_subresource_owner->binding.is_target &&
                  !video_subresource_owner->binding.needs_rebind &&
                  !video_subresource_owner->usage.video_out &&
                  !video_parent_owner->binding.is_bound &&
                  !video_parent_owner->binding.is_target &&
                  !video_parent_owner->binding.needs_rebind &&
                  !video_parent_owner->usage.video_out,
              "FindImage leaked caller-owned state across a video-out "
              "replacement");

      constexpr uint64_t array_target_address = base + 0xd0000;
      auto array_target = make_target_desc(array_target_address,
                                           target_mip_size, {128, 128, 1});
      const auto array_target_id = texture_cache.FindImage(array_target);
      const auto array_target_owner =
          TextureCacheTestAccess::Owner(texture_cache, array_target_id);
      RenderExecutorTestAccess::BindRenderTarget(executor, array_target_id);
      const auto array_target_view =
          texture_cache.FindRenderTarget(array_target_id, array_target);

      ShaderTextureResource array_texture{};
      const auto encoded_array_address = array_target_address >> 8u;
      constexpr auto array_format =
          static_cast<uint32_t>(Prospero::BufferFormat::k32UInt);
      array_texture.fields[0] = static_cast<uint32_t>(encoded_array_address);
      array_texture.fields[1] =
          static_cast<uint32_t>(encoded_array_address >> 32u) |
          (array_format << 20u) | (3u << 30u);
      array_texture.fields[2] = (127u >> 2u) | (127u << 14u);
      array_texture.fields[3] =
          DstSel(4, 5, 6, 7) | (static_cast<uint32_t>(linear) << 20u) |
          (static_cast<uint32_t>(Prospero::ImageType::kColor2DArray) << 28u);
      array_texture.fields[4] = 1;

      ShaderRecompiler::IR::CompiledShaderInfo array_program{};
      array_program.stage = ShaderType::Compute;
      ShaderRecompiler::IR::ImageResource array_resource{};
      array_resource.resource_class =
          ShaderRecompiler::IR::ImageResourceClass::Sampled;
      array_resource.numeric_class = Prospero::TextureNumericClass::Uint;
      array_resource.dimension =
          ShaderRecompiler::Decoder::ImageDimension::Dim2DArray;
      array_resource.read = true;
      array_program.info.images.push_back(array_resource);
      ShaderRecompiler::IR::DescriptorValue array_descriptor{};
      std::copy(std::begin(array_texture.fields),
                std::end(array_texture.fields),
                array_descriptor.dwords.begin());
      array_descriptor.dword_count = 8;
      ShaderRecompiler::IR::ResourceSnapshot array_snapshot{};
      array_snapshot.images.push_back(array_descriptor);
      ShaderStageRuntime array_runtime{&array_program,
                                       std::move(array_snapshot)};

      auto array_binding = executor.PrepareBindings(array_runtime);
      executor.RebindImages(array_binding);
      const auto expanded_array_id = array_binding.images[0].image_id;
      const auto &expanded_array = texture_cache.GetImage(expanded_array_id);
      Require(
          name, "2D target to array backing expansion",
          array_target_view != nullptr && array_target_owner != nullptr &&
              array_target_owner->binding.needs_rebind &&
              expanded_array_id != array_target_id &&
              !TextureCacheTestAccess::Contains(texture_cache,
                                                array_target_id) &&
              array_binding.images[0].image_view != nullptr &&
              array_binding.images[0].desc.info.type ==
                  Prospero::ImageType::kColor2D &&
              array_binding.images[0].desc.info.resources ==
                  ImageSubresources{1, 2} &&
              array_binding.images[0].desc.view_info.type ==
                  vk::ImageViewType::e2DArray &&
              array_binding.images[0].desc.view_info.layer_count ==
                  2 &&
              expanded_array.backing.layers == 2 &&
              expanded_array.IsGpuModified() && expanded_array.usage.texture,
          "raw array view did not expand and reuse the Color2D backing");

      RenderColorInfo rebound_array_target{};
      rebound_array_target.desc = array_target;
      rebound_array_target.image_id = array_target_id;
      RenderDepthInfo no_array_depth{};
      const auto acquired_array_view = array_binding.images[0].image_view;
      RenderExecutorTestAccess::PrepareGraphicsBindings(
          executor, std::span<PreparedBindings *const>{},
          std::span{&rebound_array_target, 1u});
      auto array_rendering = RenderExecutorTestAccess::AcquireRenderTargets(
          executor, scheduler.Current(), &rebound_array_target, 1,
          no_array_depth);
      Require(name, "expanded array target rebind",
              rebound_array_target.image_id == expanded_array_id &&
                  array_binding.images[0].image_id == expanded_array_id &&
                  array_binding.images[0].image_view == acquired_array_view &&
                  array_rendering.color_attachments[0].image_view != nullptr &&
                  array_rendering.num_color_attachments == 1 &&
                  array_rendering.width == 128 &&
                  array_rendering.height == 128 &&
                  array_rendering.num_layers == 1 &&
                  texture_cache.GetImage(expanded_array_id).binding.is_bound &&
                  texture_cache.GetImage(expanded_array_id).binding.is_target,
              "the retained single-layer target did not rebind to the expanded "
              "backing");
      RenderExecutorTestAccess::ResetBindings(executor);

      {
        constexpr uint32_t before = 0x13579bdfu;
        constexpr uint32_t guard = 0x2468ace0u;
        constexpr uint32_t after = 0xa1b2c3d4u;
        vk::ClearValue clear{};
        clear.color.uint32[0] = before;
        TextureCacheTestAccess::ClearImage(
            texture_cache, scheduler.Current(), expanded_array_id,
            {vk::ImageAspectFlagBits::eColor, 0, 1, 0, 2}, clear);
        clear.color.uint32[0] = guard;
        TextureCacheTestAccess::ClearImage(
            texture_cache, scheduler.Current(), expanded_array_id,
            {vk::ImageAspectFlagBits::eColor, 0, 1, 1, 1}, clear);

        ShaderRecompiler::IR::Program buffer_ir{};
        buffer_ir.stage = ShaderType::Vertex;
        buffer_ir.resource_tracking_complete = true;
        buffer_ir.info.buffers.resize(1);
        buffer_ir.info.buffers[0].read = true;
        buffer_ir.info.buffers[0].formatted = true;
        allocate_bindings(buffer_ir);
        ShaderRecompiler::IR::CompiledShaderInfo buffer_program{};
        buffer_program.stage = buffer_ir.stage;
        buffer_program.info = std::move(buffer_ir.info);
        buffer_program.bindings = std::move(buffer_ir.bindings);

        constexpr uint64_t buffer_size = 2 * target_mip_size;
        static_assert(buffer_size > BufferCache::CACHING_PAGESIZE);
        ShaderBufferResource descriptor{};
        descriptor.UpdateAddress48(array_target_address);
        descriptor.fields[1] |= 4u << 16u;
        descriptor.fields[2] = buffer_size / sizeof(uint32_t);
        descriptor.fields[3] = 0x00014004u;
        ShaderStageRuntime buffer_runtime{.program = &buffer_program};
        auto &value = buffer_runtime.resources.buffers.emplace_back();
        std::memcpy(value.dwords.data(), descriptor.fields, sizeof(descriptor.fields));
        value.dword_count = 4;
        auto buffer_bindings = executor.PrepareBindings(buffer_runtime);
        std::array stages{&buffer_bindings};
        RenderColorInfo target{};
        target.desc = array_target;
        target.image_id = array_target_id;
        RenderExecutorTestAccess::PrepareGraphicsBindings(
            executor, stages, std::span{&target, 1u});
        const auto &buffer = buffer_bindings.buffers[0];
        Require(name, "rediscovered target formatted-buffer read",
                target.image_id == expanded_array_id &&
                    buffer.range == buffer_size &&
                    buffer_bindings.images.empty() &&
                    texture_cache.GetImage(target.image_id).backing.state.layout ==
                        vk::ImageLayout::eTransferSrcOptimal,
                "target discovery did not precede the formatted image-to-buffer copy");
        auto readback = CreateHostBuffer(name, 2 * sizeof(uint32_t),
                                        vk::BufferUsageFlagBits::eTransferDst, {0, 0});
        const std::array copies{
            vk::BufferCopy{buffer.offset, 0, sizeof(uint32_t)},
            vk::BufferCopy{buffer.offset + target_mip_size, sizeof(uint32_t),
                           sizeof(uint32_t)}};
        scheduler.Current().Handle().copyBuffer(buffer.buffer, readback.buffer,
                                                copies.size(), copies.data());
        vk::BufferMemoryBarrier readback_barrier{};
        readback_barrier.srcAccessMask = vk::AccessFlagBits::eTransferWrite;
        readback_barrier.dstAccessMask = vk::AccessFlagBits::eHostRead;
        readback_barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        readback_barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
        readback_barrier.buffer = readback.buffer;
        readback_barrier.size = readback.size;
        scheduler.Current().Handle().pipelineBarrier(
            vk::PipelineStageFlagBits::eTransfer, vk::PipelineStageFlagBits::eHost,
            {}, 0, nullptr, 1, &readback_barrier, 0, nullptr);

        const auto rendering = RenderExecutorTestAccess::AcquireRenderTargets(
            executor, scheduler.Current(), &target, 1, no_array_depth);
        Require(name, "attachment layout after formatted-buffer read",
                rendering.color_attachments[0].image_layout ==
                    vk::ImageLayout::eColorAttachmentOptimal &&
                    texture_cache.GetImage(target.image_id).backing.state.layout ==
                        vk::ImageLayout::eColorAttachmentOptimal,
                "the formatted buffer copy left the render attachment in its transfer layout");
        vk::ClearAttachment clear_attachment{};
        clear_attachment.aspectMask = vk::ImageAspectFlagBits::eColor;
        clear_attachment.colorAttachment = 0;
        clear_attachment.clearValue.color.uint32[0] = after;
        const vk::ClearRect clear_rect{{{0, 0}, {128, 128}}, 0, 1};
        scheduler.BeginRendering(rendering);
        scheduler.Current().Handle().clearAttachments(1, &clear_attachment, 1, &clear_rect);
        scheduler.EndRendering();
        scheduler.Finish();
        Require(name, "formatted alias observes prior GPU contents",
                ReadBuffer(name, readback, 2) == std::vector<u32>{before, guard},
                "formatted buffer acquisition copied stale guest bytes instead of the image");
        DestroyBuffer(&readback);
        Require(name, "rendering after formatted-buffer acquisition",
                ReadCachedTexel(name, context, target.image_id) == std::vector<u32>{after} &&
                    ReadCachedTexel(name, context, target.image_id, {}, {1, 1, 1}, 1) ==
                        std::vector<u32>{guard},
                "attachment rendering lost its new color or changed the untouched array layer");
        RenderExecutorTestAccess::ResetBindings(executor);
      }

      auto colliding_msaa_texture = array_texture;
      colliding_msaa_texture.fields[3] =
          DstSel(4, 5, 6, 7) | (1u << 16u) |
          (static_cast<uint32_t>(Prospero::TileMode::kRenderTarget) << 20u) |
          (static_cast<uint32_t>(Prospero::ImageType::kColor2DMsaa) << 28u);
      colliding_msaa_texture.fields[4] = 0;
      colliding_msaa_texture.fields[5] = (7u << 20u) | (1u << 4u);
      ShaderRecompiler::IR::DescriptorValue colliding_msaa_descriptor{};
      std::copy(std::begin(colliding_msaa_texture.fields),
                std::end(colliding_msaa_texture.fields),
                colliding_msaa_descriptor.dwords.begin());
      colliding_msaa_descriptor.dword_count = 8;
      ShaderRecompiler::IR::CompiledShaderInfo colliding_msaa_program{};
      colliding_msaa_program.stage = ShaderType::Compute;
      auto colliding_msaa_resource = array_resource;
      colliding_msaa_resource.dimension =
          ShaderRecompiler::Decoder::ImageDimension::Dim2DMsaa;
      colliding_msaa_program.info.images.push_back(colliding_msaa_resource);
      ShaderRecompiler::IR::ResourceSnapshot colliding_msaa_snapshot{};
      colliding_msaa_snapshot.images.push_back(colliding_msaa_descriptor);
      ShaderStageRuntime colliding_msaa_runtime{
          &colliding_msaa_program, std::move(colliding_msaa_snapshot)};
      auto colliding_msaa_binding =
          executor.PrepareBindings(colliding_msaa_runtime);
      executor.RebindImages(colliding_msaa_binding);
      const auto &resolved_colliding_msaa =
          colliding_msaa_binding.images[0];
      Require(
          name, "equal-footprint sample-count identity",
          resolved_colliding_msaa.image_id != expanded_array_id &&
              resolved_colliding_msaa.image_view != nullptr &&
              resolved_colliding_msaa.desc.info.type ==
                  Prospero::ImageType::kColor2D &&
              resolved_colliding_msaa.desc.info.resources ==
                  ImageSubresources{1, 1} &&
              resolved_colliding_msaa.desc.info.samples == 2 &&
              resolved_colliding_msaa.desc.info.data.size == 0x20000 &&
              texture_cache.GetImage(resolved_colliding_msaa.image_id)
                      .backing.samples == 2 &&
              texture_cache.GetImage(expanded_array_id).backing.samples == 1 &&
              texture_cache.GetImage(expanded_array_id).backing.layers == 2,
          "equal-size 1x array and 2x image shared an incompatible backing");
      RenderExecutorTestAccess::ResetBindings(executor);

      constexpr uint64_t msaa_target_address = base + 0x100000;
      constexpr uint32_t msaa_samples = 4;
      auto msaa_target =
          make_target_desc(msaa_target_address, 0x40000, {128, 128, 1});
      msaa_target.info.samples = msaa_samples;
      msaa_target.info.tile_mode = Prospero::TileMode::kRenderTarget;
      msaa_target.info.mip_layout[0].size = msaa_target.info.data.size;
      const auto msaa_target_id = texture_cache.FindImage(msaa_target);
      RenderExecutorTestAccess::BindRenderTarget(executor, msaa_target_id);
      const auto msaa_target_view =
          texture_cache.FindRenderTarget(msaa_target_id, msaa_target);

      auto msaa_texture = array_texture;
      const auto encoded_msaa_address = msaa_target_address >> 8u;
      msaa_texture.fields[0] = static_cast<uint32_t>(encoded_msaa_address);
      msaa_texture.fields[1] =
          static_cast<uint32_t>(encoded_msaa_address >> 32u) |
          (array_format << 20u) | (3u << 30u);
      msaa_texture.fields[3] =
          DstSel(4, 5, 6, 7) | (2u << 16u) |
          (static_cast<uint32_t>(Prospero::TileMode::kRenderTarget) << 20u) |
          (static_cast<uint32_t>(Prospero::ImageType::kColor2DMsaa) << 28u);
      msaa_texture.fields[4] = 0;
      msaa_texture.fields[5] = (7u << 20u) | (2u << 4u);
      ShaderRecompiler::IR::DescriptorValue msaa_descriptor{};
      std::copy(std::begin(msaa_texture.fields), std::end(msaa_texture.fields),
                msaa_descriptor.dwords.begin());
      msaa_descriptor.dword_count = 8;
      ShaderRecompiler::IR::CompiledShaderInfo msaa_program{};
      msaa_program.stage = ShaderType::Compute;
      auto msaa_resource = array_resource;
      msaa_resource.dimension =
          ShaderRecompiler::Decoder::ImageDimension::Dim2DMsaa;
      msaa_program.info.images.push_back(msaa_resource);
      ShaderRecompiler::IR::ResourceSnapshot msaa_snapshot{};
      msaa_snapshot.images.push_back(msaa_descriptor);
      ShaderStageRuntime msaa_runtime{&msaa_program, std::move(msaa_snapshot)};
      auto msaa_binding = executor.PrepareBindings(msaa_runtime);
      executor.RebindImages(msaa_binding);
      const auto &resolved_msaa = msaa_binding.images[0];
      Require(
          name, "MSAA descriptor backing reuse",
          msaa_target_view != nullptr &&
              resolved_msaa.image_id == msaa_target_id &&
              resolved_msaa.image_view != nullptr &&
              resolved_msaa.desc.info.type == Prospero::ImageType::kColor2D &&
              resolved_msaa.desc.info.resources == ImageSubresources{1, 1} &&
              resolved_msaa.desc.info.samples == msaa_samples &&
              resolved_msaa.desc.info.data.size == 0x40000 &&
              resolved_msaa.desc.view_info.level_count == 1 &&
              texture_cache.GetImage(msaa_target_id).backing.samples ==
                  msaa_samples,
          "MSAA view fields did not resolve to the matching multisample "
          "backing");
      RenderExecutorTestAccess::ResetBindings(executor);

      auto msaa_array_texture = msaa_texture;
      msaa_array_texture.fields[3] =
          (msaa_array_texture.fields[3] & ~(0xfu << 28u)) |
          (static_cast<uint32_t>(Prospero::ImageType::kColor2DMsaaArray)
           << 28u);
      msaa_array_texture.fields[4] = 1;
      ShaderRecompiler::IR::DescriptorValue msaa_array_descriptor{};
      std::copy(std::begin(msaa_array_texture.fields),
                std::end(msaa_array_texture.fields),
                msaa_array_descriptor.dwords.begin());
      msaa_array_descriptor.dword_count = 8;
      ShaderRecompiler::IR::CompiledShaderInfo msaa_array_program{};
      msaa_array_program.stage = ShaderType::Compute;
      auto msaa_array_resource = array_resource;
      msaa_array_resource.dimension =
          ShaderRecompiler::Decoder::ImageDimension::Dim2DMsaaArray;
      msaa_array_program.info.images.push_back(msaa_array_resource);
      ShaderRecompiler::IR::ResourceSnapshot msaa_array_snapshot{};
      msaa_array_snapshot.images.push_back(msaa_array_descriptor);
      ShaderStageRuntime msaa_array_runtime{&msaa_array_program,
                                            std::move(msaa_array_snapshot)};
      auto msaa_array_binding = executor.PrepareBindings(msaa_array_runtime);
      executor.RebindImages(msaa_array_binding);
      const auto &resolved_msaa_array = msaa_array_binding.images[0];
      Require(name, "MSAA array backing expansion",
              resolved_msaa_array.image_id != msaa_target_id &&
                  resolved_msaa_array.image_view != nullptr &&
                  resolved_msaa_array.desc.info.type ==
                      Prospero::ImageType::kColor2D &&
                  resolved_msaa_array.desc.info.resources ==
                      ImageSubresources{1, 2} &&
                  resolved_msaa_array.desc.info.samples == msaa_samples &&
                  resolved_msaa_array.desc.info.data.size == 0x80000 &&
                  resolved_msaa_array.desc.view_info.type ==
                      vk::ImageViewType::e2DArray &&
                  resolved_msaa_array.desc.view_info.layer_count == 2 &&
                  texture_cache.GetImage(resolved_msaa_array.image_id)
                          .backing.layers == 2 &&
                  texture_cache.GetImage(resolved_msaa_array.image_id)
                          .backing.samples == msaa_samples,
              "MSAA array view did not expand the matching Color2D backing");
      RenderExecutorTestAccess::ResetBindings(executor);

      ImageDesc depth{};
      depth.type = BindingType::DepthTarget;
      depth.info.data = {depth_address, 0x10000};
      depth.info.stencil = {stencil_address, stencil_layout.size};
      depth.info.pixel_format = vk::Format::eD32SfloatS8Uint;
      depth.info.guest_format = Prospero::BufferFormat::k32Float;
      depth.info.type = Prospero::ImageType::kColor2D;
      depth.info.extent = {1, 1, 1};
      depth.info.resources = {1, 1};
      depth.info.pitch = 1;
      depth.info.bytes_per_block = 4;
      depth.info.samples = 1;
      depth.info.tile_mode = linear;
      depth.info.mip_layout[0] = {0, depth.info.data.size, 1, 1};
      depth.view_info.format = depth.info.pixel_format;
      depth.view_info.type = vk::ImageViewType::e2D;
      depth.view_info.aspect = vk::ImageAspectFlagBits::eDepth;
      depth.view_info.usage = vk::ImageUsageFlagBits::eDepthStencilAttachment;
      const auto depth_id = texture_cache.FindImage(depth);
      Require(name, "cache-only depth discovery",
              !texture_cache.FindImageFromRange(stencil_address,
                                                stencil_layout.size, false) &&
                  !texture_cache.GetImage(depth_id).binding.is_bound &&
                  !texture_cache.GetImage(depth_id).binding.is_target &&
                  !texture_cache.GetImage(depth_id).usage.depth_target,
              "FindImage created depth acquisition state or a stencil proxy");
      RenderExecutorTestAccess::BindRenderTarget(executor, depth_id);
      Require(name, "depth prefetch purity",
              texture_cache.GetImage(depth_id).binding.is_target &&
                  !texture_cache.GetImage(depth_id).usage.depth_target &&
                  !texture_cache.FindImageFromRange(stencil_address,
                                                    stencil_layout.size, false),
              "depth prefetch performed final target acquisition");

      auto target_parent = make_target_desc(base, 1536, {4, 4, 1});
      target_parent.type = BindingType::RenderTarget;
      target_parent.info.resources.levels = 2;
      // PS5 linear rows align to 256 bytes; smaller mips precede larger ones.
      target_parent.info.pitch = 64;
      target_parent.info.mip_layout[0] = {512, 1024, 64, 4};
      target_parent.info.mip_layout[1] = {0, 512, 64, 2};
      target_parent.view_info.usage = vk::ImageUsageFlagBits::eColorAttachment;
      auto target_base_subresource =
          make_target_desc(base + 512, 1024, {4, 4, 1});
      target_base_subresource.info.pitch = 64;
      target_base_subresource.info.mip_layout[0] = {0, 1024, 64, 4};
      const auto target_base_subresource_id =
          texture_cache.FindImage(target_base_subresource);
      auto target_subresource = make_target_desc(base, 512, {2, 2, 1});
      target_subresource.info.pitch = 64;
      target_subresource.info.mip_layout[0] = {0, 512, 64, 2};
      const auto target_subresource_id =
          texture_cache.FindImage(target_subresource);
      const auto *target_subresource_owner =
          TextureCacheTestAccess::Owner(texture_cache, target_subresource_id);
      const auto &discovered_target =
          texture_cache.GetImage(target_subresource_id);
      Require(name, "cache-only target discovery",
              !discovered_target.binding.is_bound &&
                  !discovered_target.binding.is_target &&
                  !discovered_target.binding.needs_rebind &&
                  !discovered_target.usage.render_target &&
                  !TextureCacheTestAccess::PendingDownload(
                      texture_cache, target_subresource_id),
              "FindImage claimed RenderExecutor-owned render-target state");
      vk::ClearValue target_clear{};
      target_clear.color.uint32[0] = 0x12345678;
      TextureCacheTestAccess::ClearImage(
          texture_cache, scheduler.Current(), target_base_subresource_id,
          {vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1}, target_clear);
      target_clear.color.uint32[0] = 0x89abcdef;
      TextureCacheTestAccess::ClearImage(
          texture_cache, scheduler.Current(), target_subresource_id,
          {vk::ImageAspectFlagBits::eColor, 0, 1, 0, 1}, target_clear);
      RenderExecutorTestAccess::BindRenderTarget(executor,
                                                 target_subresource_id);
      Require(name, "target prefetch purity",
              texture_cache.GetImage(target_subresource_id).binding.is_target &&
                  !texture_cache.GetImage(target_subresource_id)
                       .usage.render_target &&
                  !TextureCacheTestAccess::PendingDownload(
                      texture_cache, target_subresource_id),
              "target prefetch performed final target acquisition");
      const auto target_parent_id = texture_cache.FindImage(target_parent);
      Require(name, "active target overlap",
              target_parent_id &&
                  target_parent_id != target_base_subresource_id &&
                  target_parent_id != target_subresource_id &&
                  target_subresource_owner != nullptr &&
                  target_subresource_owner->binding.needs_rebind &&
                  texture_cache.GetImage(target_parent_id).binding.is_target &&
                  !TextureCacheTestAccess::PendingDownload(texture_cache,
                                                           target_parent_id),
              "target overlap did not transfer target state to the merged "
              "owner");
      auto target_readback = CreateHostBuffer(
          name, 2 * sizeof(u32), vk::BufferUsageFlagBits::eTransferDst,
          {0xaaaaaaaa, 0xaaaaaaaa});
      const std::array target_probes{
          vk::BufferImageCopy{0,
                              0,
                              0,
                              {vk::ImageAspectFlagBits::eColor, 0, 0, 1},
                              {},
                              {1, 1, 1}},
          vk::BufferImageCopy{sizeof(u32),
                              0,
                              0,
                              {vk::ImageAspectFlagBits::eColor, 1, 0, 1},
                              {},
                              {1, 1, 1}}};
      texture_cache.GetImage(target_parent_id)
          .Download(target_probes, target_readback.buffer, 0,
                    target_readback.size);
      const vk::MemoryBarrier2 target_host_barrier{
          .srcStageMask = vk::PipelineStageFlagBits2::eCopy,
          .srcAccessMask = vk::AccessFlagBits2::eTransferWrite,
          .dstStageMask = vk::PipelineStageFlagBits2::eHost,
          .dstAccessMask = vk::AccessFlagBits2::eHostRead};
      vk::DependencyInfo target_dependency{};
      target_dependency.memoryBarrierCount = 1;
      target_dependency.pMemoryBarriers = &target_host_barrier;
      scheduler.Current().Handle().pipelineBarrier2(target_dependency);
      RenderColorInfo rebound_color{};
      rebound_color.desc = target_subresource;
      rebound_color.image_id = target_subresource_id;
      RenderDepthInfo rebound_depth{};
      rebound_depth.desc = depth;
      rebound_depth.image_id = depth_id;
      scheduler.Finish();
      Require(name, "promoted target mip contents",
              ReadBuffer(name, target_readback, 2) ==
                  std::vector<u32>{0x12345678, 0x89abcdef},
              "promotion discarded GPU contents from a child mip");
      DestroyBuffer(&target_readback);
      Require(name, "deferred target slot erasure",
              TextureCacheTestAccess::Owner(texture_cache,
                                            target_subresource_id) == nullptr,
              "the displaced target slot was not erased after GPU completion");
      RenderExecutorTestAccess::PrepareGraphicsBindings(
          executor, std::span<PreparedBindings *const>{}, std::span{&rebound_color, 1u});
      auto rebound_rendering = RenderExecutorTestAccess::AcquireRenderTargets(
          executor, scheduler.Current(), &rebound_color, 1, rebound_depth);
      Require(name, "guest target extent after host mip remap",
              rebound_color.desc.view_info.base_level == 1 &&
                  rebound_color.guest_mip_level == 0 &&
                  rebound_color.Extent() == vk::Extent2D{2, 2},
              "remapping a guest target into its parent mip shrank the guest "
              "render area twice");
      const auto stencil_proxy_id = texture_cache.FindImageFromRange(
          stencil_address, stencil_layout.size, false);
      Require(
          name, "production target rebind",
          rebound_color.image_id == target_parent_id &&
              rebound_rendering.color_attachments[0].image_view != nullptr &&
              rebound_rendering.depth_stencil_attachment.image_view != nullptr &&
              rebound_rendering.num_color_attachments == 1 &&
              rebound_rendering.width == 1 && rebound_rendering.height == 1 &&
              texture_cache.GetImage(target_parent_id).binding.is_target &&
              texture_cache.GetImage(target_parent_id).usage.render_target &&
              texture_cache.GetImage(target_parent_id).IsGpuModified() &&
              texture_cache.GetImage(depth_id).usage.depth_target &&
              texture_cache.GetImage(depth_id).IsGpuModified() &&
              TextureCacheTestAccess::PendingDownload(texture_cache,
                                                      target_parent_id) &&
              stencil_proxy_id &&
              texture_cache.GetImage(stencil_proxy_id).depth_id == depth_id,
          "the final target pass did not acquire color before depth and "
          "build the dynamic render state");
      scheduler.BeginRendering(rebound_rendering);
      scheduler.EndRendering();
      RenderExecutorTestAccess::ResetBindings(executor);
      Require(name, "draw-scoped target reset",
              TextureCacheTestAccess::Owner(texture_cache,
                                            target_subresource_id) == nullptr &&
                  !texture_cache.GetImage(target_parent_id).binding.is_target &&
                  !texture_cache.GetImage(depth_id).binding.is_target,
              "RenderExecutor retained target binding state after reset");

      constexpr uint64_t ordered_color_address = base + 0x80000;
      auto ordered_color_desc =
          make_target_desc(ordered_color_address, target_mip_size, {1, 1, 1});
      const auto stale_ordered_color =
          texture_cache.FindImage(ordered_color_desc);
      RenderExecutorTestAccess::BindRenderTarget(executor, stale_ordered_color);
      resources.UnmapMemory(ordered_color_address, target_mip_size);
      resources.MapMemory(ordered_color_address, target_mip_size);

      auto ordered_depth_desc = depth;
      ordered_depth_desc.info.stencil = {ordered_color_address,
                                         target_mip_size};
      const auto ordered_depth_id = texture_cache.FindImage(ordered_depth_desc);
      RenderExecutorTestAccess::BindRenderTarget(executor, ordered_depth_id);
      RenderColorInfo ordered_color{};
      ordered_color.desc = ordered_color_desc;
      ordered_color.image_id = stale_ordered_color;
      RenderDepthInfo ordered_depth{};
      ordered_depth.desc = ordered_depth_desc;
      ordered_depth.image_id = ordered_depth_id;
      RenderExecutorTestAccess::PrepareGraphicsBindings(
          executor, std::span<PreparedBindings *const>{}, std::span{&ordered_color, 1u});
      auto ordered_rendering = RenderExecutorTestAccess::AcquireRenderTargets(
          executor, scheduler.Current(), &ordered_color, 1, ordered_depth);
      Require(name, "color-before-depth acquisition order",
              ordered_color.image_id != stale_ordered_color &&
                  ordered_rendering.color_attachments[0].image_view != nullptr &&
                  ordered_rendering.depth_stencil_attachment.image_view != nullptr &&
                  texture_cache.GetImage(ordered_color.image_id).depth_id ==
                      ordered_depth.image_id,
              "depth acquisition ran before the stale color target was "
              "recreated and associated");
      RenderExecutorTestAccess::ResetBindings(executor);
      TextureCacheTestAccess::SetLinearReadback(texture_cache, false);

      ShaderTextureResource stencil{};
      const uint64_t encoded_address = stencil_address >> 8u;
      stencil.fields[0] = static_cast<uint32_t>(encoded_address);
      stencil.fields[1] = static_cast<uint32_t>(encoded_address >> 32u) |
                          (static_cast<uint32_t>(stencil_format) << 20u);
      stencil.fields[3] =
          DstSel(4, 5, 6, 7) | (static_cast<uint32_t>(linear) << 20u) |
          (static_cast<uint32_t>(Prospero::ImageType::kColor2D) << 28u);

      ShaderRecompiler::IR::CompiledShaderInfo program{};
      program.stage = ShaderType::Compute;
      ShaderRecompiler::IR::ImageResource stencil_resource{};
      stencil_resource.resource_class =
          ShaderRecompiler::IR::ImageResourceClass::Sampled;
      stencil_resource.numeric_class = Prospero::TextureNumericClass::Uint;
      stencil_resource.dimension =
          ShaderRecompiler::Decoder::ImageDimension::Dim2D;
      stencil_resource.read = true;
      program.info.images.push_back(stencil_resource);

      ShaderRecompiler::IR::ResourceSnapshot snapshot{};
      ShaderRecompiler::IR::DescriptorValue descriptor{};
      std::copy(std::begin(stencil.fields), std::end(stencil.fields),
                descriptor.dwords.begin());
      descriptor.dword_count = 8;
      snapshot.images.push_back(descriptor);
      ShaderStageRuntime runtime{&program, std::move(snapshot)};

      auto prepared = context.GetRenderExecutor().PrepareBindings(runtime);
      const auto sampled_stencil_id = prepared.images[0].image_id;
      Require(name, "first stencil discovery",
              prepared.images.size() == 1 &&
                  sampled_stencil_id != depth_id &&
                  prepared.images[0].image_view == nullptr &&
                  texture_cache.GetImage(sampled_stencil_id).binding.is_bound &&
                  !texture_cache.GetImage(stencil_proxy_id).binding.is_bound &&
                  !texture_cache.GetImage(stencil_proxy_id).binding.is_target,
              "the first sampled-stencil lookup did not remain an ordinary "
              "discovery before final depth acquisition");

      context.GetRenderExecutor().RebindImages(prepared);
      Require(name, "first stencil acquisition",
              prepared.images[0].image_id == sampled_stencil_id &&
                  prepared.images[0].image_view != nullptr &&
                  texture_cache.GetImage(sampled_stencil_id).usage.texture,
              "the first sampled-stencil image was not finally acquired");

      RenderExecutorTestAccess::ResetBindings(executor);
      RenderDepthInfo reassociated_depth = rebound_depth;
      RenderColorInfo no_reassociated_color{};
      (void)RenderExecutorTestAccess::AcquireRenderTargets(
          executor, scheduler.Current(), &no_reassociated_color, 0,
          reassociated_depth);
      Require(name, "existing stencil association selection",
              texture_cache.GetImage(sampled_stencil_id).depth_id ==
                  reassociated_depth.image_id,
              "final depth acquisition did not associate the existing image "
              "at the stencil guest address");
      RenderExecutorTestAccess::ResetBindings(executor);

      auto redirected = context.GetRenderExecutor().PrepareBindings(runtime);
      Require(name, "redirected owner discovery",
              redirected.images.size() == 1 &&
                  redirected.images[0].image_id == depth_id &&
                  redirected.images[0].image_view == nullptr &&
                  texture_cache.GetImage(depth_id).binding.is_bound &&
                  !texture_cache.GetImage(sampled_stencil_id).binding.is_bound,
              "the established stencil association did not redirect the next "
              "discovery to the depth owner");
      context.GetRenderExecutor().RebindImages(redirected);
      Require(name, "second-pass stencil acquisition",
              redirected.images[0].image_id == depth_id &&
                  redirected.images[0].image_view != nullptr &&
                  texture_cache.GetImage(depth_id).usage.texture,
              "RebindImages did not acquire the associated depth owner");
      RenderExecutorTestAccess::ResetBindings(executor);

      // Execute the captured IMAGE_STORE clear through production fill recognition.
      const std::array<uint32_t, 12> stencil_shader{
          0xd7460000u, 0x0401060cu, 0xf4201a84u, 0xfa000000u,
          0xbf8cc07fu, 0x7e06026au, 0xd7460001u, 0x0405060du,
          0x7e04020eu, 0xf0200128u, 0x00000300u, 0xbf810000u};
      uint32_t stencil_byte = 0x35;
      const auto value_address = reinterpret_cast<uint64_t>(&stencil_byte);
      auto storage_stencil = stencil;
      storage_stencil.fields[3] = (storage_stencil.fields[3] & 0x0fffffffu) |
          (static_cast<uint32_t>(Prospero::ImageType::kColor2DArray) << 28u);
      storage_stencil.fields[5] = 0x00700000u;
      std::array<uint32_t, 12> stencil_userdata{};
      std::copy_n(storage_stencil.fields, 8, stencil_userdata.begin());
      stencil_userdata[8] = static_cast<uint32_t>(value_address);
      stencil_userdata[9] = static_cast<uint32_t>(value_address >> 32) | (4u << 16);
      stencil_userdata[10] = 1;
      stencil_userdata[11] = 0x14204u;
      ShaderComputeInputInfo stencil_compute{};
      stencil_compute.threads_num[0] = stencil_compute.threads_num[1] = 8;
      stencil_compute.threads_num[2] = 1;
      stencil_compute.workgroup_register = 12;
      stencil_compute.thread_ids_num = 2;
      std::fill_n(stencil_compute.group_id, 3, true);
      ShaderRecompiler::CompileOptions stencil_options;
      stencil_options.stage = ShaderType::Compute;
      stencil_options.user_data = stencil_userdata;
      stencil_options.input_info.compute = &stencil_compute;
      auto stencil_translated = ShaderRecompiler::TranslateProgram(stencil_shader, stencil_options);
      auto stencil_plan = ShaderRecompiler::IR::ExtractResourcePlan(stencil_translated.program);
      ShaderRecompiler::IR::ResourceSpecialization stencil_specialization;
      Require(name, "stencil fill materialization",
          ShaderRecompiler::IR::MaterializeResources(stencil_plan,
              {.user_data = stencil_userdata, .userdata = &stencil_byte,
               .read_specialization_memory = +[](void *data, uint64_t address, uint32_t *word) {
                 if (address != reinterpret_cast<uint64_t>(data)) return false;
                 *word = *static_cast<uint32_t *>(data);
                 return true;
               }}, stencil_compute.stage.resources, stencil_specialization),
          "captured stencil shader could not resolve its clear byte");
      ShaderRecompiler::IR::ApplyResourceSpecialization(stencil_translated.program,
                                                       stencil_specialization);
      ShaderRecompiler::IR::CompiledShaderInfo stencil_program{};
      stencil_program.stage = ShaderType::Compute;
      stencil_program.info = std::move(stencil_translated.program.info);
      stencil_compute.stage.program = &stencil_program;
      vk::ClearValue stencil_initial{};
      stencil_initial.depthStencil = vk::ClearDepthStencilValue{0.625f, 0x91};
      TextureCacheTestAccess::ClearImage(texture_cache, scheduler.Current(), depth_id,
          {vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil, 0, 1, 0, 1},
          stencil_initial);
      Require(name, "stencil fill coverage",
          !RenderExecutorTestAccess::TryConsumeComputeImageClear(executor, stencil_compute,
              scheduler.Current(), 0, 1, 1, 0x41u) &&
          !RenderExecutorTestAccess::TryConsumeComputeImageClear(executor, stencil_compute,
              scheduler.Current(), 2, 1, 1, 0x41u),
          "incomplete or excessive stencil dispatch was consumed");
      auto &stencil_source = stencil_compute.stage.resources.buffers[0];
      const auto clean_source = stencil_source;
      stencil_source.dwords[0] = static_cast<uint32_t>(stencil_address);
      stencil_source.dwords[1] = static_cast<uint32_t>(stencil_address >> 32) | (4u << 16);
      Require(name, "stencil fill source alias",
          !RenderExecutorTestAccess::TryConsumeComputeImageClear(executor, stencil_compute,
              scheduler.Current(), 1, 1, 1, 0x41u),
          "an aliased scalar load was consumed as a uniform image clear");
      stencil_source = clean_source;
      Require(name, "stencil IMAGE_STORE clear",
          RenderExecutorTestAccess::TryConsumeComputeImageClear(executor, stencil_compute,
              scheduler.Current(), 1, 1, 1, 0x41u),
          "captured clear attempted an unsupported depth/stencil storage binding");
      auto stencil_readback = CreateHostBuffer(name, 8,
          vk::BufferUsageFlagBits::eTransferDst, {});
      const std::array<vk::BufferImageCopy, 2> stencil_copies{{
          {0, 0, 0, {vk::ImageAspectFlagBits::eDepth, 0, 0, 1}, {}, {1, 1, 1}},
          {4, 0, 0, {vk::ImageAspectFlagBits::eStencil, 0, 0, 1}, {}, {1, 1, 1}}}};
      texture_cache.GetImage(depth_id).Download(stencil_copies, stencil_readback.buffer, 0, 8);
      vk::MemoryBarrier2 stencil_host_barrier{};
      stencil_host_barrier.sType = vk::StructureType::eMemoryBarrier2;
      stencil_host_barrier.srcStageMask = vk::PipelineStageFlagBits2::eTransfer;
      stencil_host_barrier.srcAccessMask = vk::AccessFlagBits2::eTransferWrite;
      stencil_host_barrier.dstStageMask = vk::PipelineStageFlagBits2::eHost;
      stencil_host_barrier.dstAccessMask = vk::AccessFlagBits2::eHostRead;
      vk::DependencyInfo stencil_dependency{};
      stencil_dependency.sType = vk::StructureType::eDependencyInfo;
      stencil_dependency.memoryBarrierCount = 1;
      stencil_dependency.pMemoryBarriers = &stencil_host_barrier;
      scheduler.Current().Handle().pipelineBarrier2(stencil_dependency);
      scheduler.Finish();
      const auto stencil_result = ReadBuffer(name, stencil_readback, 2);
      Require(name, "stencil clear retains depth",
          stencil_result[0] == std::bit_cast<uint32_t>(0.625f) &&
              (stencil_result[1] & 0xffu) == 0x35 &&
              !texture_cache.GetImage(depth_id).usage.storage,
          "stencil clear altered depth, lost its scalar value, or used a storage view");
      DestroyBuffer(&stencil_readback);
      resources.UnmapMemory(base, allocation_size);
      scheduler.Finish();
      RenderExecutorTestAccess::DestroyDescriptorPipelines(
          executor, descriptor_pipelines);
      context.ShutdownGpu();
    }

    Require(name, "unmap direct backing",
            Libs::LibKernel::Memory::KernelMunmap(base, allocation_size) == 0,
            "descriptor discovery direct mapping release failed");
    Require(name, "release direct backing",
            Libs::LibKernel::Memory::KernelReleaseDirectMemory(
                direct_offset, allocation_size) == 0,
            "descriptor discovery direct-memory allocation release failed");
    std::printf("[host]    %-32s ok\n", name);
  }

  Buffer CreateStorageBuffer(const char *shader_name,
                             const std::vector<u32> &initial,
                             size_t dword_count, bool device_address = false) {
    Buffer ret;
    ret.size = static_cast<vk::DeviceSize>(std::max<size_t>(dword_count, 1u) *
                                           sizeof(u32));

    vk::BufferCreateInfo buffer_info{};
    buffer_info.sType = vk::StructureType::eBufferCreateInfo;
    buffer_info.size = ret.size;
    buffer_info.usage = vk::BufferUsageFlagBits::eStorageBuffer;
    if (device_address) {
      buffer_info.usage |= vk::BufferUsageFlagBits::eShaderDeviceAddress;
    }
    buffer_info.sharingMode = vk::SharingMode::eExclusive;
    RequireVk(shader_name, "dispatch",
              m_device.createBuffer(&buffer_info, nullptr, &ret.buffer),
              "vkCreateBuffer");

    vk::MemoryRequirements req{};
    m_device.getBufferMemoryRequirements(ret.buffer, &req);
    u32 memory_type = 0;
    ret.coherent = FindMemoryType(req.memoryTypeBits,
                                  vk::MemoryPropertyFlagBits::eHostVisible |
                                      vk::MemoryPropertyFlagBits::eHostCoherent,
                                  &memory_type);
    if (!ret.coherent) {
      Require(shader_name, "dispatch",
              FindMemoryType(req.memoryTypeBits,
                             vk::MemoryPropertyFlagBits::eHostVisible,
                             &memory_type),
              "no host-visible memory type for storage buffer");
    }

    vk::MemoryAllocateInfo alloc{};
    alloc.sType = vk::StructureType::eMemoryAllocateInfo;
    alloc.allocationSize = req.size;
    alloc.memoryTypeIndex = memory_type;
    vk::MemoryAllocateFlagsInfo flags{};
    if (device_address) {
      flags.sType = vk::StructureType::eMemoryAllocateFlagsInfo;
      flags.flags = vk::MemoryAllocateFlagBits::eDeviceAddress;
      alloc.pNext = &flags;
    }
    RequireVk(shader_name, "dispatch",
              m_device.allocateMemory(&alloc, nullptr, &ret.memory),
              "vkAllocateMemory");
    RequireVk(shader_name, "dispatch",
              m_device.bindBufferMemory(ret.buffer, ret.memory, 0),
              "vkBindBufferMemory");
    if (device_address) {
      vk::BufferDeviceAddressInfo address_info{};
      address_info.sType = vk::StructureType::eBufferDeviceAddressInfo;
      address_info.buffer = ret.buffer;
      ret.device_address = m_device.getBufferAddress(address_info);
      Require(shader_name, "dispatch", ret.device_address != 0,
              "storage buffer has no device address");
    }

    std::vector<u32> contents(dword_count, 0);
    for (size_t i = 0; i < initial.size() && i < contents.size(); i++) {
      contents[i] = initial[i];
    }
    WriteBuffer(shader_name, ret, contents);
    return ret;
  }

  void DestroyBuffer(Buffer *buffer) {
    if (buffer == nullptr) {
      return;
    }
    if (buffer->buffer != nullptr) {
      m_device.destroyBuffer(buffer->buffer, nullptr);
      buffer->buffer = nullptr;
    }
    if (buffer->memory != nullptr) {
      m_device.freeMemory(buffer->memory, nullptr);
      buffer->memory = nullptr;
    }
  }

  Image CreateImage2D(const char *shader_name, u32 width, u32 height,
                      vk::Format format, vk::ImageUsageFlags usage,
                      const std::vector<u32> &initial, u32 dwords_per_pixel,
                      vk::ImageLayout final_layout) {
    std::vector<std::vector<u32>> mips;
    if (!initial.empty()) {
      mips.push_back(initial);
    }
    return CreateImageMips(shader_name, width, height, format, usage, mips,
                           dwords_per_pixel, final_layout, vk::ImageType::e2D,
                           vk::ImageViewType::e2D, 1);
  }

  static u32 MipExtent(u32 value, u32 level) {
    for (u32 i = 0; i < level && value > 1u; i++) {
      value >>= 1u;
    }
    return std::max(value, 1u);
  }

  static size_t ImageMipDwordCount(u32 width, u32 height, u32 dwords_per_pixel,
                                   u32 level, u32 layers = 1) {
    return static_cast<size_t>(MipExtent(width, level)) *
           static_cast<size_t>(MipExtent(height, level)) * layers *
           dwords_per_pixel;
  }

  Image CreateImageMips(const char *shader_name, u32 width, u32 height,
                        vk::Format format, vk::ImageUsageFlags usage,
                        const std::vector<std::vector<u32>> &initial_mips,
                        u32 dwords_per_pixel, vk::ImageLayout final_layout,
                        vk::ImageType image_type, vk::ImageViewType view_type,
                        u32 layers, u32 view_base_layer = 0,
                        u32 view_layers = 0,
                        vk::SampleCountFlagBits samples = vk::SampleCountFlagBits::e1) {
    Image ret;
    ret.format = format;
    ret.width = width;
    ret.height = height;
    ret.layers = layers;
    ret.mip_levels = std::max<u32>(static_cast<u32>(initial_mips.size()), 1u);
    ret.dwords_per_pixel = dwords_per_pixel;

    vk::ImageCreateInfo image_info{};
    image_info.sType = vk::StructureType::eImageCreateInfo;
    image_info.imageType = image_type;
    image_info.format = format;
    image_info.extent.width = width;
    image_info.extent.height = height;
    image_info.extent.depth = 1;
    image_info.mipLevels = ret.mip_levels;
    image_info.arrayLayers = layers;
    image_info.samples = samples;
    image_info.tiling = vk::ImageTiling::eOptimal;
    image_info.usage = usage | vk::ImageUsageFlagBits::eTransferDst |
                       vk::ImageUsageFlagBits::eTransferSrc;
    image_info.sharingMode = vk::SharingMode::eExclusive;
    image_info.initialLayout = vk::ImageLayout::eUndefined;
    RequireVk(shader_name, "dispatch",
              m_device.createImage(&image_info, nullptr, &ret.image),
              "vkCreateImage");

    vk::MemoryRequirements req{};
    m_device.getImageMemoryRequirements(ret.image, &req);
    u32 memory_type = 0;
    if (!FindMemoryType(req.memoryTypeBits,
                        vk::MemoryPropertyFlagBits::eDeviceLocal,
                        &memory_type)) {
      Require(shader_name, "dispatch",
              FindMemoryType(req.memoryTypeBits, {}, &memory_type),
              "no memory type for image");
    }

    vk::MemoryAllocateInfo alloc{};
    alloc.sType = vk::StructureType::eMemoryAllocateInfo;
    alloc.allocationSize = req.size;
    alloc.memoryTypeIndex = memory_type;
    RequireVk(shader_name, "dispatch",
              m_device.allocateMemory(&alloc, nullptr, &ret.memory),
              "vk::Device::allocateMemory(image)");
    RequireVk(shader_name, "dispatch",
              m_device.bindImageMemory(ret.image, ret.memory, 0),
              "vkBindImageMemory");

    vk::ImageViewCreateInfo view_info{};
    view_info.sType = vk::StructureType::eImageViewCreateInfo;
    view_info.image = ret.image;
    view_info.viewType = view_type;
    view_info.format = format;
    view_info.subresourceRange.aspectMask = vk::ImageAspectFlagBits::eColor;
    view_info.subresourceRange.baseMipLevel = 0;
    view_info.subresourceRange.levelCount = ret.mip_levels;
    Require(shader_name, "dispatch", view_base_layer < layers,
            "image view base layer is out of bounds");
    if (view_layers == 0) {
      view_layers = layers - view_base_layer;
    }
    Require(shader_name, "dispatch", view_layers <= layers - view_base_layer,
            "image view layer count is out of bounds");
    view_info.subresourceRange.baseArrayLayer = view_base_layer;
    view_info.subresourceRange.layerCount = view_layers;
    RequireVk(shader_name, "dispatch",
              m_device.createImageView(&view_info, nullptr, &ret.view),
              "vkCreateImageView");

    if (!initial_mips.empty()) {
      size_t total_dwords = 0;
      for (u32 level = 0; level < ret.mip_levels; level++) {
        total_dwords +=
            ImageMipDwordCount(width, height, dwords_per_pixel, level, layers);
      }
      std::vector<u32> contents(total_dwords, 0);
      size_t offset = 0;
      for (u32 level = 0; level < ret.mip_levels; level++) {
        const auto level_dwords =
            ImageMipDwordCount(width, height, dwords_per_pixel, level, layers);
        const auto &src = initial_mips[level];
        for (size_t i = 0; i < src.size() && i < level_dwords; i++) {
          contents[offset + i] = src[i];
        }
        offset += level_dwords;
      }
      auto staging =
          CreateHostBuffer(shader_name, contents.size() * sizeof(u32),
                           vk::BufferUsageFlagBits::eTransferSrc, contents);
      UploadImageMips(shader_name, &ret, staging.buffer, final_layout);
      DestroyBuffer(&staging);
    } else {
      TransitionImage(shader_name, &ret, final_layout,
                      vk::PipelineStageFlagBits::eTopOfPipe,
                      vk::PipelineStageFlagBits::eComputeShader, {},
                      AccessForLayout(final_layout));
    }
    return ret;
  }

  void DestroyImage(Image *image) {
    if (image == nullptr) {
      return;
    }
    if (image->view != nullptr) {
      m_device.destroyImageView(image->view, nullptr);
      image->view = nullptr;
    }
    if (image->image != nullptr) {
      m_device.destroyImage(image->image, nullptr);
      image->image = nullptr;
    }
    if (image->memory != nullptr) {
      m_device.freeMemory(image->memory, nullptr);
      image->memory = nullptr;
    }
  }

  std::vector<u32> ReadImage(const char *shader_name, Image *image) {
    const auto dword_count = static_cast<size_t>(image->width) *
                             static_cast<size_t>(image->height) *
                             image->layers * image->dwords_per_pixel;
    auto staging = CreateHostBuffer(shader_name, dword_count * sizeof(u32),
                                   vk::BufferUsageFlagBits::eTransferDst, {});

    vk::CommandBuffer cmd = BeginCommands(shader_name, "readback");
    AddImageBarrier(
        cmd, image->image, image->layout, vk::ImageLayout::eTransferSrcOptimal,
        vk::PipelineStageFlagBits::eAllCommands,
        vk::PipelineStageFlagBits::eTransfer,
        vk::AccessFlagBits::eMemoryRead | vk::AccessFlagBits::eMemoryWrite,
        vk::AccessFlagBits::eTransferRead, image->mip_levels, image->layers);
    vk::BufferImageCopy copy{};
    copy.bufferOffset = 0;
    copy.imageSubresource.aspectMask = vk::ImageAspectFlagBits::eColor;
    copy.imageSubresource.mipLevel = 0;
    copy.imageSubresource.baseArrayLayer = 0;
    copy.imageSubresource.layerCount = image->layers;
    copy.imageExtent.width = image->width;
    copy.imageExtent.height = image->height;
    copy.imageExtent.depth = 1;
    cmd.copyImageToBuffer(image->image, vk::ImageLayout::eTransferSrcOptimal,
                          staging.buffer, 1, &copy);
    EndSubmitAndFree(shader_name, "readback", cmd);
    image->layout = vk::ImageLayout::eTransferSrcOptimal;

    auto ret = ReadBuffer(shader_name, staging, dword_count);
    DestroyBuffer(&staging);
    return ret;
  }

  vk::Sampler CreateNearestSampler(const char *shader_name, u32 mip_levels = 1) {
    vk::SamplerCreateInfo sampler_info{};
    sampler_info.sType = vk::StructureType::eSamplerCreateInfo;
    sampler_info.magFilter = vk::Filter::eNearest;
    sampler_info.minFilter = vk::Filter::eNearest;
    sampler_info.mipmapMode = vk::SamplerMipmapMode::eNearest;
    sampler_info.addressModeU = vk::SamplerAddressMode::eClampToEdge;
    sampler_info.addressModeV = vk::SamplerAddressMode::eClampToEdge;
    sampler_info.addressModeW = vk::SamplerAddressMode::eClampToEdge;
    sampler_info.minLod = 0.0f;
    sampler_info.maxLod = static_cast<float>(mip_levels - 1u);
    vk::Sampler sampler = nullptr;
    RequireVk(shader_name, "dispatch",
              m_device.createSampler(&sampler_info, nullptr, &sampler),
              "vkCreateSampler");
    return sampler;
  }

  std::vector<u32> ReadBuffer(const char *shader_name, const Buffer &buffer,
                              size_t dword_count) {
    if (!buffer.coherent) {
      vk::MappedMemoryRange range{};
      range.sType = vk::StructureType::eMappedMemoryRange;
      range.memory = buffer.memory;
      range.offset = 0;
      range.size = VK_WHOLE_SIZE;
      RequireVk(shader_name, "readback",
                m_device.invalidateMappedMemoryRanges(1, &range),
                "vkInvalidateMappedMemoryRanges");
    }

    void *data = nullptr;
    RequireVk(shader_name, "readback",
              m_device.mapMemory(buffer.memory, 0, buffer.size, {}, &data),
              "vkMapMemory");
    std::vector<u32> ret(dword_count, 0);
    std::memcpy(ret.data(), data, dword_count * sizeof(u32));
    m_device.unmapMemory(buffer.memory);
    return ret;
  }

  void Dispatch(const TestCase &test, const CompiledShader &compiled,
                const Buffer &buffer, const Buffer *gds_buffer = nullptr,
                const Image *sampled_image = nullptr,
                const Image *storage_image = nullptr,
                const Image *storage_image_uint = nullptr,
                vk::Sampler sampler = nullptr) {
    using Kind = ShaderRecompiler::IR::DescriptorBindingKind;
    const auto &layout = compiled.program.bindings;
    auto Binding = [&](Kind kind) {
      return ShaderRecompiler::IR::FindBinding(layout, kind);
    };
    auto Native = [](Kind kind) {
      return ShaderRecompiler::IR::NativeBinding(ShaderType::Compute, kind);
    };
    for (const auto &binding : layout.descriptors) {
      const auto resource_class =
          ShaderRecompiler::IR::ImageBindingResourceClass(binding.kind);
      if (resource_class == ShaderRecompiler::IR::ImageResourceClass::None) {
        continue;
      }
      const auto &image =
          compiled.program.info.images.at(binding.resources.front());
      bool supported =
          image.dimension == ShaderRecompiler::Decoder::ImageDimension::Dim2D;
      if (resource_class == ShaderRecompiler::IR::ImageResourceClass::Sampled) {
        supported = supported ||
                    image.dimension ==
                        ShaderRecompiler::Decoder::ImageDimension::Dim1D ||
                    image.dimension ==
                        ShaderRecompiler::Decoder::ImageDimension::Dim1DArray ||
                    image.dimension ==
                        ShaderRecompiler::Decoder::ImageDimension::Dim2DArray;
      }
      Require(test.name, "dispatch", supported,
              "unsupported image dimension needs a matching Vulkan test view");
    }

    vk::ShaderModuleCreateInfo module_info{};
    module_info.sType = vk::StructureType::eShaderModuleCreateInfo;
    module_info.codeSize = compiled.spirv.size() * sizeof(u32);
    module_info.pCode = compiled.spirv.data();
    vk::ShaderModule module = nullptr;
    RequireVk(test.name, "SPIR-V module",
              m_device.createShaderModule(&module_info, nullptr, &module),
              "vkCreateShaderModule");

    std::vector<vk::DescriptorSetLayoutBinding> layout_bindings;
    auto add_layout_binding =
        [&layout_bindings](u32 binding, vk::DescriptorType type, u32 count) {
          if (count == 0) {
            return;
          }
          vk::DescriptorSetLayoutBinding item{};
          item.binding = binding;
          item.descriptorType = type;
          item.descriptorCount = count;
          item.stageFlags = vk::ShaderStageFlagBits::eCompute;
          layout_bindings.push_back(item);
        };
    for (const auto &binding : layout.descriptors) {
      add_layout_binding(ShaderRecompiler::IR::NativeBinding(
                             ShaderType::Compute, binding.kind),
                         NativeDescriptorType(binding.kind),
                         NativeDescriptorCount(binding));
    }

    vk::DescriptorSetLayoutCreateInfo layout_info{};
    layout_info.sType = vk::StructureType::eDescriptorSetLayoutCreateInfo;
    layout_info.bindingCount = static_cast<u32>(layout_bindings.size());
    layout_info.pBindings =
        layout_bindings.empty() ? nullptr : layout_bindings.data();
    vk::DescriptorSetLayout descriptor_layout = nullptr;
    RequireVk(test.name, "dispatch",
              m_device.createDescriptorSetLayout(&layout_info, nullptr,
                                                 &descriptor_layout),
              "vkCreateDescriptorSetLayout");

    vk::PipelineLayoutCreateInfo pipeline_layout_info{};
    pipeline_layout_info.sType = vk::StructureType::ePipelineLayoutCreateInfo;
    pipeline_layout_info.setLayoutCount = 1;
    pipeline_layout_info.pSetLayouts = &descriptor_layout;
    vk::PushConstantRange push_range{};
    if (layout.UsesPushData()) {
      push_range.stageFlags = vk::ShaderStageFlagBits::eCompute;
      push_range.offset = 0;
      push_range.size = ShaderRecompiler::IR::NativePushConstantSize;
      pipeline_layout_info.pushConstantRangeCount = 1;
      pipeline_layout_info.pPushConstantRanges = &push_range;
    }
    vk::PipelineLayout pipeline_layout = nullptr;
    RequireVk(test.name, "dispatch",
              m_device.createPipelineLayout(&pipeline_layout_info, nullptr,
                                            &pipeline_layout),
              "vkCreatePipelineLayout");

    vk::PipelineShaderStageCreateInfo stage{};
    stage.sType = vk::StructureType::ePipelineShaderStageCreateInfo;
    stage.stage = vk::ShaderStageFlagBits::eCompute;
    stage.module = module;
    stage.pName = "main";

    vk::ComputePipelineCreateInfo pipeline_info{};
    pipeline_info.sType = vk::StructureType::eComputePipelineCreateInfo;
    pipeline_info.stage = stage;
    pipeline_info.layout = pipeline_layout;
    vk::Pipeline pipeline = nullptr;
    RequireVk(test.name, "dispatch",
              m_device.createComputePipelines(nullptr, 1, &pipeline_info,
                                              nullptr, &pipeline),
              "vkCreateComputePipelines");

    std::vector<vk::DescriptorPoolSize> pool_sizes;
    auto add_pool_size = [&pool_sizes](vk::DescriptorType type, u32 count) {
      if (count == 0) {
        return;
      }
      for (auto &size : pool_sizes) {
        if (size.type == type) {
          size.descriptorCount += count;
          return;
        }
      }
      pool_sizes.push_back({type, count});
    };
    for (const auto &binding : layout.descriptors) {
      add_pool_size(NativeDescriptorType(binding.kind),
                    NativeDescriptorCount(binding));
    }
    vk::DescriptorPoolCreateInfo pool_info{};
    pool_info.sType = vk::StructureType::eDescriptorPoolCreateInfo;
    pool_info.maxSets = 1;
    pool_info.poolSizeCount = static_cast<u32>(pool_sizes.size());
    pool_info.pPoolSizes = pool_sizes.empty() ? nullptr : pool_sizes.data();
    vk::DescriptorPool descriptor_pool = nullptr;
    RequireVk(
        test.name, "dispatch",
        m_device.createDescriptorPool(&pool_info, nullptr, &descriptor_pool),
        "vkCreateDescriptorPool");

    vk::DescriptorSetAllocateInfo set_info{};
    set_info.sType = vk::StructureType::eDescriptorSetAllocateInfo;
    set_info.descriptorPool = descriptor_pool;
    set_info.descriptorSetCount = 1;
    set_info.pSetLayouts = &descriptor_layout;
    vk::DescriptorSet descriptor_set = nullptr;
    RequireVk(test.name, "dispatch",
              m_device.allocateDescriptorSets(&set_info, &descriptor_set),
              "vkAllocateDescriptorSets");

    std::vector<vk::WriteDescriptorSet> writes;
    std::vector<vk::DescriptorBufferInfo> buffer_infos;
    std::vector<vk::DescriptorImageInfo> sampled_infos;
    std::vector<vk::DescriptorImageInfo> storage_infos;
    std::vector<vk::DescriptorImageInfo> storage_uint_infos;
    std::vector<vk::DescriptorImageInfo> storage_atomic_infos;
    std::vector<vk::DescriptorImageInfo> sampler_infos;
    Buffer flattened_buffer;
    Buffer user_data_buffer;
    vk::DescriptorBufferInfo flattened_info{};
    vk::DescriptorBufferInfo user_data_info{};
    vk::DescriptorBufferInfo gds_info{};
    vk::DescriptorBufferInfo bda_pagetable_info{};
    vk::DescriptorBufferInfo fault_buffer_info{};

    const bool uses_bda = Binding(Kind::BdaPagetable) != nullptr;
    Require(test.name, "dispatch",
            uses_bda == (Binding(Kind::FaultBuffer) != nullptr),
            "BDA page table and fault buffer must be bound together");
    if (uses_bda) {
      EnsureBdaBuffers(test.name);
      bda_pagetable_info = {m_bda_pagetable_buffer.buffer, 0,
                            m_bda_pagetable_buffer.size};
      fault_buffer_info = {m_fault_buffer.buffer, 0, m_fault_buffer.size};
      const std::array special_buffers{
          std::pair{Kind::BdaPagetable, &bda_pagetable_info},
          std::pair{Kind::FaultBuffer, &fault_buffer_info},
      };
      for (const auto &[kind, info] : special_buffers) {
        vk::WriteDescriptorSet write{};
        write.sType = vk::StructureType::eWriteDescriptorSet;
        write.dstSet = descriptor_set;
        write.dstBinding = Native(kind);
        write.descriptorCount = 1;
        write.descriptorType = vk::DescriptorType::eStorageBuffer;
        write.pBufferInfo = info;
        writes.push_back(write);
      }
    }

    const auto *buffers = Binding(Kind::Buffers);
    if (buffers != nullptr) {
      buffer_infos.resize(buffers->resources.size());
      for (u32 i = 0; i < buffer_infos.size(); i++) {
        auto &info = buffer_infos[i];
        info.buffer = buffer.buffer;
        info.offset = 0;
        info.range = buffer.size;
        if (test.storage_buffer_range_dwords != 0) {
          const auto offset = i < test.storage_buffer_offsets.size()
                                  ? test.storage_buffer_offsets[i]
                                  : 0u;
          info.range = static_cast<vk::DeviceSize>(
              test.storage_buffer_range_dwords * sizeof(u32) + offset);
          Require(test.name, "dispatch", info.range <= buffer.size,
                  "storage buffer descriptor range exceeds backing buffer");
        }
      }
      vk::WriteDescriptorSet write{};
      write.sType = vk::StructureType::eWriteDescriptorSet;
      write.dstSet = descriptor_set;
      write.dstBinding = Native(Kind::Buffers);
      write.descriptorCount = static_cast<u32>(buffer_infos.size());
      write.descriptorType = vk::DescriptorType::eStorageBuffer;
      write.pBufferInfo = buffer_infos.data();
      writes.push_back(write);
    }
    if (const auto *flattened = Binding(Kind::FlattenedSrt);
        flattened != nullptr) {
      flattened_buffer =
          CreateStorageBuffer(test.name, compiled.resources.flattened_srt,
                              compiled.resources.flattened_srt.size());
      flattened_info = {flattened_buffer.buffer, 0, flattened_buffer.size};
      vk::WriteDescriptorSet write{};
      write.sType = vk::StructureType::eWriteDescriptorSet;
      write.dstSet = descriptor_set;
      write.dstBinding = Native(Kind::FlattenedSrt);
      write.descriptorCount = 1;
      write.descriptorType = vk::DescriptorType::eStorageBuffer;
      write.pBufferInfo = &flattened_info;
      writes.push_back(write);
    }
    if (const auto *user = Binding(Kind::ShaderData); user != nullptr) {
      user_data_buffer =
          CreateStorageBuffer(test.name, compiled.packed_user_data,
                              compiled.packed_user_data.size());
      user_data_info = {user_data_buffer.buffer, 0, user_data_buffer.size};
      vk::WriteDescriptorSet write{};
      write.sType = vk::StructureType::eWriteDescriptorSet;
      write.dstSet = descriptor_set;
      write.dstBinding = Native(Kind::ShaderData);
      write.descriptorCount = 1;
      write.descriptorType = vk::DescriptorType::eStorageBuffer;
      write.pBufferInfo = &user_data_info;
      writes.push_back(write);
    }
    if (const auto *gds = Binding(Kind::Gds); gds != nullptr) {
      Require(test.name, "dispatch", gds_buffer != nullptr,
              "GDS descriptor requested but no GDS buffer was provided");
      gds_info = {gds_buffer->buffer, 0, gds_buffer->size};
      vk::WriteDescriptorSet write{};
      write.sType = vk::StructureType::eWriteDescriptorSet;
      write.dstSet = descriptor_set;
      write.dstBinding = Native(Kind::Gds);
      write.descriptorCount = 1;
      write.descriptorType = vk::DescriptorType::eStorageBuffer;
      write.pBufferInfo = &gds_info;
      writes.push_back(write);
    }
    const ShaderRecompiler::IR::DescriptorBinding *sampled = nullptr;
    const ShaderRecompiler::IR::DescriptorBinding *storage = nullptr;
    const ShaderRecompiler::IR::DescriptorBinding *storage_uint = nullptr;
    const ShaderRecompiler::IR::DescriptorBinding *storage_atomic = nullptr;
    for (const auto &binding : layout.descriptors) {
      const auto resource_class =
          ShaderRecompiler::IR::ImageBindingResourceClass(binding.kind);
      if (resource_class == ShaderRecompiler::IR::ImageResourceClass::None) {
        continue;
      }
      const auto &image =
          compiled.program.info.images.at(binding.resources.front());
      if (resource_class == ShaderRecompiler::IR::ImageResourceClass::Sampled) {
        Require(test.name, "dispatch", sampled == nullptr,
                "Vulkan test harness needs separate sampled images for mixed "
                "descriptor classes");
        sampled = &binding;
      } else if (image.atomic) {
        storage_atomic = &binding;
      } else if (image.numeric_class == Prospero::TextureNumericClass::Float) {
        storage = &binding;
      } else {
        storage_uint = &binding;
      }
    }
    if (sampled != nullptr) {
      Require(test.name, "dispatch", sampled_image != nullptr,
              "sampled image descriptor requested but no sampled image was "
              "provided");
      sampled_infos.resize(sampled->resources.size());
      for (auto &info : sampled_infos) {
        info.imageView = sampled_image->view;
        info.imageLayout = sampled_image->layout;
      }
      vk::WriteDescriptorSet write{};
      write.sType = vk::StructureType::eWriteDescriptorSet;
      write.dstSet = descriptor_set;
      write.dstBinding = Native(sampled->kind);
      write.descriptorCount = static_cast<u32>(sampled_infos.size());
      write.descriptorType = vk::DescriptorType::eSampledImage;
      write.pImageInfo = sampled_infos.data();
      writes.push_back(write);
    }
    const auto BindStorage =
        [&](const ShaderRecompiler::IR::DescriptorBinding *binding,
            const Image *image, std::vector<vk::DescriptorImageInfo> *infos) {
          if (binding == nullptr) {
            return;
          }
          Require(
              test.name, "dispatch", image != nullptr,
              "storage image descriptor requested but no matching image was "
              "provided");
          infos->resize(binding->resources.size());
          for (auto &info : *infos) {
            info.imageView = image->view;
            info.imageLayout = image->layout;
          }
          vk::WriteDescriptorSet write{};
          write.sType = vk::StructureType::eWriteDescriptorSet;
          write.dstSet = descriptor_set;
          write.dstBinding = Native(binding->kind);
          write.descriptorCount = static_cast<u32>(infos->size());
          write.descriptorType = vk::DescriptorType::eStorageImage;
          write.pImageInfo = infos->data();
          writes.push_back(write);
        };
    BindStorage(storage, storage_image, &storage_infos);
    BindStorage(storage_uint, storage_image_uint, &storage_uint_infos);
    BindStorage(storage_atomic, storage_image_uint, &storage_atomic_infos);
    const auto *samplers = Binding(Kind::Samplers);
    if (samplers != nullptr) {
      Require(test.name, "dispatch", sampler != nullptr,
              "sampler descriptor requested but no sampler was provided");
      sampler_infos.resize(samplers->resources.size());
      for (auto &info : sampler_infos) {
        info.sampler = sampler;
      }
      vk::WriteDescriptorSet write{};
      write.sType = vk::StructureType::eWriteDescriptorSet;
      write.dstSet = descriptor_set;
      write.dstBinding = Native(Kind::Samplers);
      write.descriptorCount = static_cast<u32>(sampler_infos.size());
      write.descriptorType = vk::DescriptorType::eSampler;
      write.pImageInfo = sampler_infos.data();
      writes.push_back(write);
    }
    if (!writes.empty()) {
      m_device.updateDescriptorSets(static_cast<u32>(writes.size()),
                                    writes.data(), 0, nullptr);
    }

    vk::CommandBuffer cmd = BeginCommands(test.name, "dispatch");
    if (uses_bda) {
      Require(test.name, "dispatch", buffer.device_address != 0,
              "BDA test backing has no device address");
      Require(test.name, "dispatch", !test.bda_mappings.empty(),
              "BDA test has no explicit guest mapping");
      cmd.fillBuffer(m_bda_pagetable_buffer.buffer, 0,
                     m_bda_pagetable_buffer.size, 0);
      cmd.fillBuffer(m_fault_buffer.buffer, 0, m_fault_buffer.size, 0);
      std::array<vk::BufferMemoryBarrier, 2> barriers{};
      barriers[0].sType = vk::StructureType::eBufferMemoryBarrier;
      barriers[0].srcAccessMask = vk::AccessFlagBits::eTransferWrite;
      barriers[0].dstAccessMask = vk::AccessFlagBits::eTransferWrite;
      barriers[0].srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
      barriers[0].dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
      barriers[0].buffer = m_bda_pagetable_buffer.buffer;
      barriers[0].offset = 0;
      barriers[0].size = m_bda_pagetable_buffer.size;
      barriers[1] = barriers[0];
      barriers[1].dstAccessMask = vk::AccessFlagBits::eShaderRead |
                                  vk::AccessFlagBits::eShaderWrite;
      barriers[1].buffer = m_fault_buffer.buffer;
      barriers[1].size = m_fault_buffer.size;
      cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
                          vk::PipelineStageFlagBits::eTransfer, {}, 0, nullptr,
                          1, barriers.data(), 0, nullptr);
      for (const auto &[guest_base, backing] : test.bda_mappings) {
        const auto page_offset = guest_base &
                                 (BufferCache::CACHING_PAGESIZE - 1);
        Require(test.name, "dispatch",
                backing >= page_offset && backing < buffer.size,
                "BDA test mapping begins outside its backing buffer");
        const auto bytes = page_offset + buffer.size - backing;
        const auto pages =
            (bytes + BufferCache::CACHING_PAGESIZE - 1) /
            BufferCache::CACHING_PAGESIZE;
        auto address = buffer.device_address + backing - page_offset;
        auto page = guest_base >> BufferCache::CACHING_PAGEBITS;
        for (uint64_t mapped = 0; mapped < pages; mapped++) {
          cmd.updateBuffer(m_bda_pagetable_buffer.buffer,
                           (page + mapped) * sizeof(vk::DeviceAddress),
                           sizeof(address), &address);
          address += BufferCache::CACHING_PAGESIZE;
        }
      }
      barriers[0].dstAccessMask = vk::AccessFlagBits::eShaderRead;
      cmd.pipelineBarrier(vk::PipelineStageFlagBits::eTransfer,
                          vk::PipelineStageFlagBits::eComputeShader, {}, 0,
                          nullptr, static_cast<u32>(barriers.size()),
                          barriers.data(), 0, nullptr);
    }
    cmd.bindPipeline(vk::PipelineBindPoint::eCompute, pipeline);
    cmd.bindDescriptorSets(vk::PipelineBindPoint::eCompute, pipeline_layout, 0,
                           1, &descriptor_set, 0, nullptr);
    if (layout.UsesPushData()) {
      ShaderRecompiler::IR::PushData push_data;
      std::copy(compiled.packed_user_data.begin(),
                compiled.packed_user_data.end(),
                push_data.dwords.begin() + layout.push_data_start_dword);
      cmd.pushConstants(pipeline_layout, vk::ShaderStageFlagBits::eCompute, 0,
                        sizeof(push_data), push_data.dwords.data());
    }
    cmd.dispatch(test.dispatch_x, test.dispatch_y, test.dispatch_z);

    if (buffers != nullptr) {
      vk::BufferMemoryBarrier barrier{};
      barrier.sType = vk::StructureType::eBufferMemoryBarrier;
      barrier.srcAccessMask =
          vk::AccessFlagBits::eShaderRead | vk::AccessFlagBits::eShaderWrite;
      barrier.dstAccessMask = vk::AccessFlagBits::eHostRead;
      barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
      barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
      barrier.buffer = buffer.buffer;
      barrier.offset = 0;
      barrier.size = buffer.size;
      cmd.pipelineBarrier(vk::PipelineStageFlagBits::eComputeShader,
                          vk::PipelineStageFlagBits::eHost, {}, 0, nullptr, 1,
                          &barrier, 0, nullptr);
    }
    if (gds_buffer != nullptr) {
      vk::BufferMemoryBarrier barrier{};
      barrier.sType = vk::StructureType::eBufferMemoryBarrier;
      barrier.srcAccessMask =
          vk::AccessFlagBits::eShaderRead | vk::AccessFlagBits::eShaderWrite;
      barrier.dstAccessMask = vk::AccessFlagBits::eHostRead;
      barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
      barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
      barrier.buffer = gds_buffer->buffer;
      barrier.offset = 0;
      barrier.size = gds_buffer->size;
      cmd.pipelineBarrier(vk::PipelineStageFlagBits::eComputeShader,
                          vk::PipelineStageFlagBits::eHost, {}, 0, nullptr, 1,
                          &barrier, 0, nullptr);
    }
    EndSubmitAndFree(test.name, "dispatch", cmd);
    if (flattened_buffer.buffer != nullptr) {
      DestroyBuffer(&flattened_buffer);
    }
    if (user_data_buffer.buffer != nullptr) {
      DestroyBuffer(&user_data_buffer);
    }
    m_device.destroyDescriptorPool(descriptor_pool, nullptr);
    m_device.destroyPipeline(pipeline, nullptr);
    m_device.destroyPipelineLayout(pipeline_layout, nullptr);
    m_device.destroyDescriptorSetLayout(descriptor_layout, nullptr);
    m_device.destroyShaderModule(module, nullptr);
  }

  void CheckRasterization(bool depth_feedback, bool packed_vertex_color = false) {
    const char *name = packed_vertex_color ? "PackedFloatVertexColor"
                      : depth_feedback ? "DepthAttachmentFeedback"
                                       : "PolygonModeRasterization";
    const uint32_t extent = depth_feedback ? 8 : 32;
    constexpr uintptr_t depth_address = 0x0000000204400000ull;
    constexpr uint64_t allocation_size = 0x40000;
    EnsureRuntimeContext();
    RenderContext context(m_runtime_context);
    auto &scheduler = context.GetCommandScheduler();
    HW::Context registers{};
    HW::UserConfig user_config{};
    HW::Shader shaders{};
    registers.SetRenderTargetMask(0xf);
    scheduler.Begin(registers, user_config, shaders);
    auto &resources = context;
    auto &cache = context.GetTextureCache();
    auto &executor = context.GetRenderExecutor();
    int64_t direct_offset = -1;
    RenderDepthInfo depth{};
    Require(name, "direct allocation",
            Libs::LibKernel::Memory::KernelAllocateDirectMemory(
                0, Libs::LibKernel::Memory::KernelGetDirectMemorySize(),
                allocation_size, allocation_size, 0, &direct_offset) == 0,
            "depth allocation failed");
    void *mapped = reinterpret_cast<void *>(depth_address);
    Require(name, "direct mapping",
            Libs::LibKernel::Memory::KernelMapDirectMemory(
                &mapped, allocation_size, 0x3, 0x10, direct_offset,
                allocation_size) == 0 &&
                mapped == reinterpret_cast<void *>(depth_address),
            "depth mapping failed");
    std::memset(mapped, 0, allocation_size);
    const auto initial_depth = [](uint32_t x, uint32_t y) {
      return 0.125f + static_cast<float>(x + 2 * y) / 128.0f;
    };
    for (uint32_t y = 0; y < extent; y++) {
      for (uint32_t x = 0; x < extent; x++) {
        static_cast<float *>(mapped)[y * 64 + x] = initial_depth(x, y);
      }
    }
    resources.MapMemory(depth_address, allocation_size);
    if (depth_feedback) {
      depth.desc.type = BindingType::DepthTarget;
      depth.desc.info.data = {depth_address, 256 * extent};
      depth.desc.info.pixel_format = vk::Format::eD32Sfloat;
      depth.desc.info.guest_format = Prospero::BufferFormat::k32Float;
      depth.desc.info.extent = {extent, extent, 1};
      depth.desc.info.pitch = 64;
      depth.desc.info.bytes_per_block = 4;
      depth.desc.info.tile_mode = Prospero::TileMode::kLinear;
      depth.desc.info.mip_layout[0] = {0, 256 * extent, 64, extent};
      depth.desc.view_info.format = depth.desc.info.pixel_format;
      depth.desc.view_info.aspect = vk::ImageAspectFlagBits::eDepth;
      depth.desc.view_info.usage = vk::ImageUsageFlagBits::eDepthStencilAttachment;
      depth.depth_test_enable = depth.depth_write_enable = true;
      depth.depth_compare_op = vk::CompareOp::eAlways;
      depth.image_id = cache.FindImage(depth.desc);
    }

    GraphicsCase test;
    test.name = name;
    test.pixel_depth_export = depth_feedback;
    if (depth_feedback) {
      const ShaderTextureResource descriptor{{
          static_cast<uint32_t>(depth_address >> 8u),
          (static_cast<uint32_t>(Prospero::BufferFormat::k32Float) << 20u) |
              (((extent - 1u) & 3u) << 30u),
          ((extent - 1u) >> 2u) | ((extent - 1u) << 14u),
          DstSel(4, 4, 4, 4) |
              (static_cast<uint32_t>(Prospero::ImageType::kColor2D) << 28u),
          0, 0, 0, 0}};
      test.has_user_data = true;
      std::copy_n(descriptor.fields, 8, test.user_data.begin());
      // Each fragment samples its own texel through interpolated screen UVs.
      for (uint32_t component = 0; component < 2; component++) {
        test.fragment_code.push_back(EncodeVintrp(0, 20 + component, 0, component, 0));
        test.fragment_code.push_back(EncodeVintrp(1, 20 + component, 0, component, 1));
      }
      test.fragment_code.push_back(EncodeMimg0(0x27, 1));
      test.fragment_code.push_back(EncodeMimg1(0, 20, 0, 2));
      AppendVMovLiteral(&test.fragment_code, 1, 0x3e000000u);
      test.fragment_code.push_back(EncodeVop2(0x03, 1, Vgpr(0), 1));
      test.fragment_code.push_back(EncodeExp0(0x08, 0x1, false));
      test.fragment_code.push_back(EncodeExp1(1, 1, 1, 1));
    } else {
      test.pixel_interpolator_settings = {0x400u};
      for (uint32_t component = 0; component < (packed_vertex_color ? 4u : 1u); component++) {
        test.fragment_code.push_back(EncodeVintrp(0x02, component, 0, component, 2));
      }
    }
    test.fragment_code.push_back(EncodeExp0(0x00, 0xf));
    test.fragment_code.push_back(packed_vertex_color ? EncodeExp1(0, 1, 2, 3)
                                                    : EncodeExp1(0, 0, 0, 0));
    AppendEnd(&test.fragment_code);
    auto fragment = CompileFragmentCase(test);
    const auto vertex_spirv = TestSpv::MakePassthroughVertexSpirv(false);
    ShaderProgram vertex_shader{1, CreateShaderModule(name, vertex_spirv)};
    ShaderProgram pixel_shader{2, CreateShaderModule(name, fragment.spirv)};
    ShaderRecompiler::IR::CompiledShaderInfo vertex_program{};
    vertex_program.stage = ShaderType::Vertex;
    vertex_program.info.vertex_fetch_components[0] = 2;
    vertex_program.info.vertex_fetch_components[1] = packed_vertex_color ? 3 : 4;
    ShaderRecompiler::IR::CompiledShaderInfo pixel_program{};
    pixel_program.stage = ShaderType::Pixel;
    pixel_program.info = fragment.program.info;
    pixel_program.bindings = fragment.program.bindings;
    ShaderVertexInputInfo vertex{};
    vertex.stage.program = &vertex_program;
    vertex.resources_num = 2;
    vertex.buffers_num = 1;
    vertex.buffers[0].stride = 6 * sizeof(float);
    vertex.buffers[0].attr_num = 2;
    vertex.buffers[0].attr_indices[1] = 1;
    vertex.buffers[0].attr_offsets[1] = 2 * sizeof(float);
    for (uint32_t i = 0; i < 2; i++) {
      const auto format = i == 0 ? Prospero::BufferFormat::k32_32Float
                          : packed_vertex_color ? Prospero::BufferFormat::k11_11_10Float
                                                : Prospero::BufferFormat::k32_32_32_32Float;
      vertex.resources[i].fields[3] = DstSel(4, 5, 6, 7) |
                                      (static_cast<uint32_t>(format) << 12u);
      vertex.resources_dst[i].registers_num =
          i == 0 ? 2 : vertex_program.info.vertex_fetch_components[1];
    }
    ShaderPixelInputInfo pixel{};
    pixel.stage.program = &pixel_program;
    pixel.stage.resources = std::move(fragment.resources);

    RenderColorInfo color{};
    color.desc.type = BindingType::RenderTarget;
    color.desc.info.data = {depth_address + 0x10000, extent * extent * 16};
    color.desc.info.mip_layout[0] = {0, color.desc.info.data.size, extent, extent};
    color.desc.info.pixel_format = vk::Format::eR32G32B32A32Sfloat;
    color.desc.info.guest_format = Prospero::BufferFormat::k32_32_32_32Float;
    color.desc.info.extent = {extent, extent, 1};
    color.desc.info.pitch = extent;
    color.desc.info.bytes_per_block = 16;
    color.desc.view_info.format = color.desc.info.pixel_format;
    color.desc.view_info.usage = vk::ImageUsageFlagBits::eColorAttachment;
    color.image_id = cache.FindImage(color.desc);
    std::array<float, 18> vertices{
        -0.75f, -0.75f, 1, 1, 1, 1, 0.75f, -0.75f, 0.5f, 1, 1, 1,
        0.0f, 0.75f, 0.25f, 1, 1, 1};
    if (depth_feedback) {
      vertices = {-1, -1, 0, 0, 0, 1, 3, -1, 2, 0, 0, 1, -1, 3, 0, 2, 0, 1};
    }
    std::vector<u32> vertex_words(vertices.size());
    std::memcpy(vertex_words.data(), vertices.data(), sizeof(vertices));
    if (packed_vertex_color) {
      // R11/G11/B10 unsigned floats: 0.5, 1.0, 2.0; Vulkan supplies the missing alpha as 1.
      for (uint32_t i = 0; i < 3; i++) {
        vertex_words[i * 6 + 2] = 0x801e0380u;
      }
    }
    auto buffer = CreateHostBuffer(name, sizeof(vertices), vk::BufferUsageFlagBits::eVertexBuffer,
                                   vertex_words);
    const auto pipeline = [&](bool enabled, uint8_t front, uint8_t back,
                              bool provoking_last = false,
                              bool clockwise = false,
                              vk::PrimitiveTopology topology = vk::PrimitiveTopology::eTriangleList)
        -> PipelineCache::Pipeline & {
      HW::ModeControl mode{};
      mode.face = clockwise;
      mode.poly_mode = enabled;
      mode.polymode_front_ptype = front;
      mode.polymode_back_ptype = back;
      mode.provoking_vtx_last = provoking_last;
      registers.SetModeControl(mode);
      return context.GetPipelineCache().GetGraphicsPipeline(
          std::span{&color, 1u}, depth, std::span{&vertex, 1u}, scheduler.Current(), &pixel,
          topology, false,
          PipelineCache::GraphicsPrograms{{vertex_shader}, pixel_shader});
    };
    auto &filled = pipeline(true, 2, 2);
    const auto draw = [&](const PipelineCache::Pipeline &selected, uint32_t vertex_count = 3) {
      RenderExecutorTestAccess::BindRenderTarget(executor, color.image_id);
      if (depth.image_id) {
        RenderExecutorTestAccess::BindRenderTarget(executor, depth.image_id);
      }
      auto bindings = RenderExecutorTestAccess::PrepareGraphicsBindings(
          executor, vertex.stage, pixel.stage, true);
      Require(name, "sampled attachment identity",
              !depth_feedback || bindings.pixel->images[0].image_id == depth.image_id,
              "the fragment must sample the depth attachment's native image");
      auto &command = scheduler.Current();
      auto rendering = RenderExecutorTestAccess::AcquireRenderTargets(
          executor, command, &color, 1, depth, bindings.pixel);
      const bool feedback_enabled = rendering.depth_stencil_attachment.image_layout ==
                                    vk::ImageLayout::eAttachmentFeedbackLoopOptimalEXT;
      Require(name, "per-draw depth feedback",
              feedback_enabled == (depth_feedback && depth.depth_write_enable),
              "feedback was not selected only for an overlapping fragment depth read/write");
      RenderExecutorTestAccess::CommitBindings(
          executor, command, selected, bindings.vertex[0], *bindings.pixel);
      rendering.color_attachments[0].is_clear = true;
      command.BeginRendering(rendering);
      auto cmd = command.Handle();
      cmd.bindPipeline(vk::PipelineBindPoint::eGraphics, selected.pipeline);
      const vk::Viewport viewport{0, 0, static_cast<float>(extent),
                                  static_cast<float>(extent), 0, 1};
      const vk::Rect2D scissor{{0, 0}, {extent, extent}};
      cmd.setViewportWithCount(1, &viewport);
      cmd.setScissorWithCount(1, &scissor);
      cmd.setLineWidth(1);
      cmd.setDepthTestEnable(depth.depth_test_enable);
      cmd.setDepthWriteEnable(depth.depth_write_enable);
      cmd.setDepthCompareOp(depth.depth_compare_op);
      cmd.setDepthBiasEnable(false);
      cmd.setStencilTestEnable(depth.stencil_test_enable);
      if (depth.stencil_test_enable) {
        const auto set_stencil = [&](vk::StencilFaceFlagBits face,
                                     const vk::StencilOpState &state) {
          cmd.setStencilOp(face, state.failOp, state.passOp, state.depthFailOp,
                           state.compareOp);
          cmd.setStencilCompareMask(face, state.compareMask);
          cmd.setStencilWriteMask(face, state.writeMask);
          cmd.setStencilReference(face, state.reference);
        };
        set_stencil(vk::StencilFaceFlagBits::eFront, depth.stencil_front);
        set_stencil(vk::StencilFaceFlagBits::eBack, depth.stencil_back);
      }
      const vk::Bool32 write = true;
      cmd.setColorWriteEnableEXT(1, &write);
      cmd.setAttachmentFeedbackLoopEnableEXT(
          feedback_enabled ? vk::ImageAspectFlags{vk::ImageAspectFlagBits::eDepth}
                           : vk::ImageAspectFlags{});
      const vk::DeviceSize offset = 0;
      cmd.bindVertexBuffers(0, 1, &buffer.buffer, &offset);
      cmd.draw(vertex_count, 1, 0, 0);
      command.EndRendering();
      RenderExecutorTestAccess::ResetBindings(executor);
    };
    const auto read_color = [&] {
      return ReadCachedTexel(name, context, color.image_id, {}, {extent, extent, 1});
    };
    draw(filled);
    const auto solid_pixels = read_color();
    if (packed_vertex_color) {
      const std::array<float, 4> expected{0.5f, 1.0f, 2.0f, 1.0f};
      const auto center = 4 * ((extent / 2) * extent + extent / 2);
      for (uint32_t component = 0; component < expected.size(); component++) {
        Require(name, "packed vertex fetch and coverage",
                std::abs(std::bit_cast<float>(solid_pixels[center + component]) -
                         expected[component]) < 0.0001f && solid_pixels[component] == 0,
                "packed vertex color changed channels, clamped HDR, or filled outside the triangle");
      }
    } else if (depth_feedback) {
      // Consecutive draws in the same submission must see each earlier depth write.
      draw(filled);
      draw(filled);
      depth.depth_write_enable = false;
      draw(filled); // Reset feedback in the same command buffer and preserve the depth writes.
      const auto repeated_pixels = read_color();
      const auto stored_depth = ReadCachedTexel(
          name, context, depth.image_id, {}, {extent, extent, 1});
      for (uint32_t y = 0; y < extent; y++) {
        for (uint32_t x = 0; x < extent; x++) {
          const auto index = y * extent + x;
          Require(name, "sampled and stored depth",
                  solid_pixels[index * 4] == std::bit_cast<uint32_t>(initial_depth(x, y)) &&
                      repeated_pixels[index * 4] ==
                          std::bit_cast<uint32_t>(initial_depth(x, y) + 0.375f) &&
                      stored_depth[index] == repeated_pixels[index * 4],
                  "depth feedback lost a prior write or the read-only draw changed depth");
        }
      }
    } else {
      auto &wireframe = pipeline(true, 1, 1);
      Require(name, "pipeline cache", filled.pipeline != wireframe.pipeline &&
                  pipeline(true, 2, 2).pipeline == filled.pipeline &&
                  pipeline(false, 1, 0).pipeline == filled.pipeline,
              "polygon mode was lost from the cache key or dormant face modes were applied");
      draw(wireframe);
      const auto line_pixels = read_color();
      const auto interior = 4 * (16 * extent + 16);
      Require(name, "GPU coverage", solid_pixels[interior] == 0x3f800000u &&
                  line_pixels[interior] == 0 &&
                  std::ranges::any_of(line_pixels, [](u32 value) { return value == 0x3f800000u; }),
              "wireframe did not preserve triangle edges while leaving its interior empty");
      auto &last_vertex = pipeline(true, 2, 2, true);
      Require(name, "provoking vertex pipeline cache",
              last_vertex.pipeline != filled.pipeline &&
                  pipeline(true, 2, 2, true).pipeline == last_vertex.pipeline &&
                  pipeline(true, 2, 2).pipeline == filled.pipeline,
              "first and last provoking vertices did not keep distinct cached pipelines");
      draw(last_vertex);
      const auto last_pixels = read_color();
      for (size_t i = 0; i < solid_pixels.size(); i++) {
        Require(name, "flat provoking vertex output",
                last_pixels[i] == (solid_pixels[i] == 0 ? 0 : 0x3e800000u),
                "last-vertex flat shading changed coverage or did not use vertex two");
      }

      const auto blend_pipeline = [&](bool enabled, bool bypass) -> PipelineCache::Pipeline & {
        auto blend = registers.GetBlendControl(0);
        blend.enable = enabled;
        blend.color_srcblend = static_cast<uint8_t>(Prospero::BlendFactor::kZero);
        blend.alpha_srcblend = static_cast<uint8_t>(Prospero::BlendFactor::kZero);
        registers.SetBlendControl(0, blend);
        auto target = registers.GetRenderTarget(0).info;
        target.blend_bypass = bypass;
        registers.SetColorInfo(0, target);
        return pipeline(true, 2, 2);
      };
      auto &disabled_blend = blend_pipeline(false, false);
      Require(name, "effective blend pipeline cache",
              blend_pipeline(false, true).pipeline == disabled_blend.pipeline &&
                  blend_pipeline(true, true).pipeline == disabled_blend.pipeline,
              "disabled and bypassed blending did not share the same host pipeline");
      auto &enabled_blend = blend_pipeline(true, false);
      Require(name, "enabled blend pipeline cache",
              enabled_blend.pipeline != disabled_blend.pipeline &&
                  blend_pipeline(true, false).pipeline == enabled_blend.pipeline,
              "active blending was lost from the pipeline key or missed its cached pipeline");
      draw(enabled_blend);
      const auto blended_pixels = read_color();
      Require(name, "active blend output",
              std::ranges::all_of(blended_pixels, [](u32 value) { return value == 0; }),
              "zero-factor blending did not clear the fragment color");
      draw(blend_pipeline(true, true));
      Require(name, "bypassed blend output", read_color() == solid_pixels,
              "blend bypass did not restore the unblended fragment color and coverage");

      HW::DepthRenderTarget stencil_target{};
      stencil_target.z_info.format = Prospero::DepthFormat::kZ32F;
      stencil_target.stencil_info.format = Prospero::StencilFormat::k8UInt;
      stencil_target.stencil_info.htile_stencil_disabled = true;
      stencil_target.z_read_base_addr = stencil_target.z_write_base_addr = depth_address;
      stencil_target.stencil_read_base_addr = stencil_target.stencil_write_base_addr =
          depth_address + 0x20000;
      stencil_target.size = {static_cast<uint16_t>(extent - 1),
                             static_cast<uint16_t>(extent - 1), true};
      registers.SetDepthRenderTarget(stencil_target);
      HW::DepthControl stencil_control{};
      // Keep the same depth/stencil attachment active when stencil testing is disabled.
      stencil_control.z_enable = true;
      stencil_control.zfunc = static_cast<uint8_t>(vk::CompareOp::eAlways);
      stencil_control.stencil_enable = stencil_control.backface_enable = true;
      stencil_control.stencilfunc = stencil_control.stencilfunc_bf =
          static_cast<uint8_t>(vk::CompareOp::eAlways);
      registers.SetDepthControl(stencil_control);
      // PPSA01325 sets bit 7 on front faces and clears it on back faces.
      registers.SetStencilControl({3, 3, 3, 4, 4, 4});
      registers.SetStencilMask({0x80, 0, 0x80, 1, 0x80, 0, 0x80, 1});
      RenderExecutorTestAccess::ResolveRenderDepthTarget(executor, scheduler.Current(), depth);
      auto stencil_readback = CreateHostBuffer(name, extent * extent,
          vk::BufferUsageFlagBits::eTransferDst, {});
      const auto read_stencil = [&] {
        const vk::BufferImageCopy copy{0, 0, 0,
            {vk::ImageAspectFlagBits::eStencil, 0, 0, 1}, {}, {extent, extent, 1}};
        cache.GetImage(depth.image_id).Download(std::span{&copy, 1},
            stencil_readback.buffer, 0, stencil_readback.size);
        const vk::MemoryBarrier2 barrier{
            .srcStageMask = vk::PipelineStageFlagBits2::eCopy,
            .srcAccessMask = vk::AccessFlagBits2::eTransferWrite,
            .dstStageMask = vk::PipelineStageFlagBits2::eHost,
            .dstAccessMask = vk::AccessFlagBits2::eHostRead};
        vk::DependencyInfo dependency{};
        dependency.memoryBarrierCount = 1;
        dependency.pMemoryBarriers = &barrier;
        scheduler.Current().Handle().pipelineBarrier2(dependency);
        scheduler.Finish();
        return ReadBuffer(name, stencil_readback, extent * extent / 4);
      };
      const std::array stencil_pipelines{
          pipeline(true, 2, 2, false, true).pipeline,
          pipeline(true, 2, 2, false, false).pipeline};
      const auto check_stencil = [&](const char *label, bool back_face,
                                     uint8_t initial, uint8_t written) {
        vk::ClearValue clear{};
        clear.depthStencil = vk::ClearDepthStencilValue{0.625f, initial};
        TextureCacheTestAccess::ClearImage(cache, scheduler.Current(), depth.image_id,
            {vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil,
             0, 1, 0, 1}, clear);
        const auto &selected = pipeline(true, 2, 2, false, !back_face);
        Require(name, "dynamic stencil pipeline reuse",
                selected.pipeline == stencil_pipelines[back_face],
                "stencil enable, operations or references changed the graphics pipeline");
        draw(selected);
        const auto result = read_stencil();
        const auto *stencil_bytes = reinterpret_cast<const uint8_t *>(result.data());
        for (uint32_t texel = 0; texel < extent * extent; ++texel) {
          const uint8_t expected = solid_pixels[texel * 4] != 0 ? written : initial;
          Require(name, label,
                  stencil_bytes[texel] == expected,
                  "captured stencil operations changed masked bits or triangle coverage");
        }
      };
      check_stencil("front-face ReplaceTest", false, 0x35, 0xb5);
      check_stencil("back-face masked ReplaceOp", true, 0xb5, 0x35);

      stencil_control.stencil_enable = false;
      registers.SetDepthControl(stencil_control);
      RenderExecutorTestAccess::ResolveRenderDepthTarget(executor, scheduler.Current(), depth);
      check_stencil("disabled front stencil", false, 0x35, 0x35);
      check_stencil("disabled back stencil", true, 0xb5, 0xb5);
      stencil_control.stencil_enable = true;
      registers.SetDepthControl(stencil_control);
      RenderExecutorTestAccess::ResolveRenderDepthTarget(executor, scheduler.Current(), depth);
      check_stencil("re-enabled front stencil", false, 0x35, 0xb5);
      check_stencil("re-enabled back stencil", true, 0xb5, 0x35);

      // Frame 6115 uses separate test/op replacement values with Always comparisons.
      stencil_control.z_enable = stencil_control.z_write_enable = true;
      stencil_control.zfunc = static_cast<uint8_t>(vk::CompareOp::eLessOrEqual);
      registers.SetDepthControl(stencil_control);
      registers.SetStencilControl({0, 3, 9, 0, 4, 8});
      registers.SetStencilMask({8, 0xff, 0xff, 1, 8, 0xff, 0xff, 1});
      RenderExecutorTestAccess::ResolveRenderDepthTarget(executor, scheduler.Current(), depth);
      Require(name, "independent stencil references",
              depth.stencil_front.reference == 8 &&
                  depth.stencil_back.reference == 1,
              "always-pass faces must preserve their distinct replacement values");
      check_stencil("front test-value replacement", false, 0x35, 8);
      check_stencil("back operation-value replacement", true, 0x35, 1);
      stencil_control.zfunc = static_cast<uint8_t>(vk::CompareOp::eNever);
      registers.SetDepthControl(stencil_control);
      RenderExecutorTestAccess::ResolveRenderDepthTarget(executor, scheduler.Current(), depth);
      check_stencil("front depth-fail subtract wrap", false, 0, 0xff);
      check_stencil("back depth-fail add wrap", true, 0xff, 0);

      // A compare on bit 3 and replacement on bit 0 share one Vulkan reference
      // without changing either native operation or the untouched stencil bits.
      stencil_control.z_enable = stencil_control.z_write_enable = false;
      stencil_control.stencilfunc = stencil_control.stencilfunc_bf =
          static_cast<uint8_t>(vk::CompareOp::eEqual);
      registers.SetDepthControl(stencil_control);
      registers.SetStencilControl({0, 4, 0, 0, 4, 0});
      registers.SetStencilMask({8, 8, 1, 1, 8, 8, 1, 1});
      RenderExecutorTestAccess::ResolveRenderDepthTarget(executor, scheduler.Current(), depth);
      Require(name, "masked compare and replace reference",
              depth.stencil_front.reference == 9 &&
                  depth.stencil_back.reference == 9,
              "disjoint comparison and replacement bits must combine into one reference");
      check_stencil("masked compare passes", false, 0xb8, 0xb9);
      check_stencil("masked compare fails", false, 0xb0, 0xb0);

      // SPI_PS_IN_CONTROL must select the native wave width through the actual
      // program cache. In wave32 a low-word compare preserves scalar VCC_HI.
      static const auto native_vertex = [] {
        std::vector<u32> code;
        AppendVMovLiteral(&code, 1, 0xbf800000u);
        AppendVMovLiteral(&code, 2, 0x40400000u);
        code.push_back(EncodeVopc(0xc2, InlineU32(1), 5));
        code.push_back(EncodeVop2(0x01, 3, Vgpr(1), 2));
        code.push_back(EncodeVopc(0xc2, InlineU32(2), 5));
        code.push_back(EncodeVop2(0x01, 4, Vgpr(1), 2));
        AppendVMovU32(&code, 0, 0);
        AppendVMovLiteral(&code, 6, 0x3f800000u);
        code.push_back(EncodeExp0(0x0c, 0xf));
        code.push_back(EncodeExp1(3, 4, 0, 6));
        for (u32 parameter = 0; parameter < 8; parameter++) {
          code.push_back(EncodeExp0(0x20 + parameter, 0xf));
          code.push_back(EncodeExp1(0, 0, 0, 0));
        }
        AppendEnd(&code);
        return code;
      }();
      static const auto native_pixel = [] {
        std::vector<u32> code;
        AppendVMovU32(&code, 0, 0);
        AppendSMovLiteral(&code, 107, 0x3e800000u);
        code.push_back(EncodeVopc(0xc2, InlineU32(1), 0));
        code.push_back(EncodeVop1(0x01, 1, 107));
        AppendVMovLiteral(&code, 2, 0x3f800000u);
        code.push_back(EncodeExp0(0x00, 0xf));
        code.push_back(EncodeExp1(1, 1, 1, 2));
        AppendEnd(&code);
        return code;
      }();
      static ShaderUserData native_user_data{};
      const auto vertex_address = reinterpret_cast<uint64_t>(native_vertex.data());
      const auto pixel_address = reinterpret_cast<uint64_t>(native_pixel.data());
      ShaderMapUserData(vertex_address,
          {.type = Prospero::ShaderBinaryType::kGs,
           .user_data = &native_user_data,
           .code_size_bytes = static_cast<uint32_t>(native_vertex.size() * sizeof(u32))});
      ShaderMapUserData(pixel_address,
          {.type = Prospero::ShaderBinaryType::kPs,
           .code_size_bytes = static_cast<uint32_t>(native_pixel.size() * sizeof(u32))});
      HW::VertexShaderInfo native_vertex_regs{};
      native_vertex_regs.es_regs.data_addr = vertex_address;
      HW::PixelShaderInfo native_pixel_regs{};
      native_pixel_regs.ps_regs.data_addr = pixel_address;
      const auto owned_vertex_shader = vertex_shader;
      const auto owned_pixel_shader = pixel_shader;
      depth.stencil_test_enable = false;
      registers.SetViewportTransformControl(0x300);
      user_config.SetPrimitiveType(Prospero::PrimitiveType::kTriList);
      std::array<Prospero::ColorComponentMapping, 8> export_mapping{};
      std::array<ShaderVertexInputInfo, 3> native_vertex_info{};
      std::array<uint64_t, 2> wave_ids{};
      std::array<std::vector<u32>, 2> wave_keys;
      struct PixelWaveCase { uint32_t control, width, color; };
      for (const auto wave : {PixelWaveCase{0x0008, 64, 0},
                              PixelWaveCase{0x8008, 32, 0x3e800000},
                              PixelWaveCase{0x0008, 64, 0}}) {
        registers.SetPsInControl(wave.control);
        const auto programs = context.GetPipelineCache().GetGraphicsPrograms(
            native_vertex_regs, native_pixel_regs, registers.GetShaderRegisters(),
            registers, user_config, export_mapping, true, native_vertex_info, pixel);
        Require(name, "pixel wave metadata propagation",
                pixel.input_num == 8 && pixel.stage.program->wave_size == wave.width,
                "SPI_PS_IN_CONTROL width did not reach the compiled pixel program");
        const auto index = static_cast<uint32_t>(wave.width == 32);
        std::vector<u32> key;
        BuildStageStaticKey(pixel, key);
        if (wave_ids[index] != 0) {
          Require(name, "pixel wave cache reuse",
                  programs.pixel.id == wave_ids[index] && key == wave_keys[index],
                  "restoring wave64 did not reuse its original program");
        }
        wave_ids[index] = programs.pixel.id;
        wave_keys[index] = std::move(key);
        vertex_shader = programs.vertex[0];
        pixel_shader = programs.pixel;
        vertex = native_vertex_info[0];
        draw(pipeline(true, 2, 2));
        const auto wave_pixels = read_color();
        for (size_t component = 0; component < wave_pixels.size(); component++) {
          const auto expected = component % 4 == 3 ? 0x3f800000u : wave.color;
          Require(name, "pixel wave VCC_HI readback", wave_pixels[component] == expected,
                  "pixel comparison clobbered VCC_HI in wave32 or retained it in wave64");
        }
      }
      Require(name, "pixel wave cache distinction",
              wave_ids[0] != wave_ids[1] && wave_keys[0] != wave_keys[1],
              "wave32 and wave64 pixel programs shared a cache key");

      // Captured Playroom strips contain the fullscreen triangle followed by an
      // out-of-bounds fetch exporting (0,0,0,0). Additive color reveals any extra triangle.
      static constexpr std::array<std::array<u32, 4>, 4> fourth_positions{{
          {0, 0, 0, 0}, {0x80000000u, 0, 0x80000000u, 0x80000000u},
          {0, 0, 0, 0x3f800000u}, {0xbf800000u, 0xbf800000u, 0, 0}}};
      static const auto position_shaders = [&] {
        std::array<std::vector<u32>, fourth_positions.size()> result;
        for (size_t i = 0; i < result.size(); i++) {
          auto &code = result[i];
          const auto position_export = std::ranges::find(native_vertex, EncodeExp0(0x0c, 0xf));
          code.assign(native_vertex.begin(), position_export);
          code.push_back(EncodeVopc(0xc2, InlineU32(3), 5));
          constexpr std::array<u32, 4> position_registers{3, 4, 0, 6};
          for (size_t component = 0; component < position_registers.size(); component++) {
            AppendVMovLiteral(&code, 7, fourth_positions[i][component]);
            const auto reg = position_registers[component];
            code.push_back(EncodeVop2(0x01, reg, Vgpr(reg), 7));
          }
          code.insert(code.end(), position_export, native_vertex.end());
        }
        return result;
      }();
      auto additive_blend = registers.GetBlendControl(0);
      additive_blend.enable = true;
      additive_blend.color_srcblend = additive_blend.color_destblend =
          additive_blend.alpha_srcblend = additive_blend.alpha_destblend =
              static_cast<uint8_t>(Prospero::BlendFactor::kOne);
      registers.SetBlendControl(0, additive_blend);
      auto target_info = registers.GetRenderTarget(0).info;
      target_info.blend_bypass = false;
      registers.SetColorInfo(0, target_info);
      registers.SetPsInControl(0x8008);
      user_config.SetPrimitiveType(Prospero::PrimitiveType::kTriStrip);
      for (size_t i = 0; i < position_shaders.size(); i++) {
        const auto &code = position_shaders[i];
        native_vertex_regs.es_regs.data_addr = reinterpret_cast<uint64_t>(code.data());
        ShaderMapUserData(native_vertex_regs.es_regs.data_addr,
            {.type = Prospero::ShaderBinaryType::kGs,
             .user_data = &native_user_data,
             .code_size_bytes = static_cast<uint32_t>(code.size() * sizeof(u32))});
        const auto programs = context.GetPipelineCache().GetGraphicsPrograms(
            native_vertex_regs, native_pixel_regs, registers.GetShaderRegisters(),
            registers, user_config, export_mapping, true, native_vertex_info, pixel);
        vertex_shader = programs.vertex[0];
        pixel_shader = programs.pixel;
        vertex = native_vertex_info[0];
        draw(pipeline(true, 2, 2, false, false, vk::PrimitiveTopology::eTriangleStrip), 4);
        const auto pixels = read_color();
        bool second_triangle = false;
        for (size_t component = 0; component < pixels.size(); component += 4) {
          Require(name, "fullscreen triangle preserved",
                  pixels[component] == 0x3e800000u || pixels[component] == 0x3f000000u,
                  "clipping-error culling removed valid fullscreen coverage");
          second_triangle |= pixels[component] == 0x3f000000u;
        }
        Require(name, "zero homogeneous position culling", second_triangle == (i >= 2),
                "zero positions drew an extra triangle, or a valid position was culled");
      }

      // A NULL-export stencil pass must ignore smaller stale color targets,
      // materialize the whole pending HTile clear, and still execute pixel discard.
      static const auto null_pixels = [] {
        std::array<std::vector<u32>, 2> result;
        for (uint32_t discard = 0; discard < result.size(); discard++) {
          auto &code = result[discard];
          if (discard != 0) {
            code.push_back(EncodeSop1(0x04, 126, InlineU32(0)));
          }
          code.push_back(EncodeExp0(0x09, 0, true, false, true));
          code.push_back(EncodeExp1(0, 0, 0, 0));
          AppendEnd(&code);
        }
        return result;
      }();
      registers.Reset();
      registers.SetViewportTransformControl(0x300);
      registers.SetViewportScaleOffset(0, extent / 2, extent / 2,
                                       extent / 2, extent / 2, 1, 0);
      registers.SetViewportZMax(0, 1);
      registers.SetScreenScissor(0, 0, extent, extent);
      registers.SetWindowScissor(0, 0, extent, extent, false);
      registers.SetGenericScissor(0, 0, extent, extent, false);
      registers.SetViewportScissor(0, 0, 0, extent, extent, false);
      registers.SetRenderTargetMask(0xf00f);
      registers.SetShaderMask(0xf00f);
      registers.SetPsInControl(0x8000);
      registers.SetDepthShaderControl({.shader_kill_enable = true});
      for (const auto slot : {0u, 3u}) {
        registers.SetColorBase(slot,
            {.addr = depth_address + (slot == 0 ? 0x38000 : 0x10000)});
        registers.SetColorInfo(slot,
            {.format = Prospero::ChannelLayout::k32_32_32_32,
             .channel_type = Prospero::ChannelType::kFloat,
             .channel_order = Prospero::ChannelOrder::kStandard});
        const auto side = slot == 0 ? extent / 4 : extent;
        registers.SetColorAttrib2(slot, {.height = side - 1, .width = side - 1});
        registers.SetColorAttrib3(slot,
            {.tile_mode = Prospero::TileMode::kLinear, .dimension = 1});
        registers.SetTargetOutputMode(slot, 4);
      }
      stencil_target.z_info.htile_acceleration = true;
      stencil_target.htile_data_base_addr = depth_address + 0x30000;
      registers.SetDepthRenderTarget(stencil_target);
      registers.SetDepthClearValue(1);
      stencil_control = {};
      stencil_control.stencil_enable = true;
      stencil_control.stencilfunc = static_cast<uint8_t>(vk::CompareOp::eAlways);
      registers.SetDepthControl(stencil_control);
      registers.SetStencilControl({3, 3, 3, 3, 3, 3});
      registers.SetStencilMask({0x80, 0, 0x80, 1, 0x80, 0, 0x80, 1});
      user_config.SetPrimitiveType(Prospero::PrimitiveType::kTriList);
      shaders.SetEsShaderBase(vertex_address);
      for (uint32_t discard = 0; discard < null_pixels.size(); discard++) {
        const auto &code = null_pixels[discard];
        const auto address = reinterpret_cast<uint64_t>(code.data());
        ShaderMapUserData(address,
            {.type = Prospero::ShaderBinaryType::kPs,
             .code_size_bytes = static_cast<uint32_t>(code.size() * sizeof(u32))});
        shaders.SetPsShaderBase(address);
        RenderExecutorTestAccess::ResolveRenderDepthTarget(executor, scheduler.Current(), depth);
        (void)cache.FindDepthTarget(depth.image_id, depth.desc);
        vk::ClearValue zero{};
        TextureCacheTestAccess::ClearImage(cache, scheduler.Current(), depth.image_id,
            {vk::ImageAspectFlagBits::eDepth | vk::ImageAspectFlagBits::eStencil,
             0, 1, 0, 1}, zero);
        Require(name, "pending stencil-pass HTile clear",
                cache.ClearMeta(stencil_target.htile_data_base_addr),
                "the stencil pass did not retain its HTile metadata");
        RenderExecutorTestAccess::DrawAuto(
            executor, scheduler.Current(), {.vertex_count = 3, .instance_count = 1});
        const auto depth_pixels = ReadCachedTexel(name, context, depth.image_id,
                                                  {}, {extent, extent, 1});
        Require(name, "NULL-export full depth clear",
                std::ranges::all_of(depth_pixels, [](u32 v) { return v == 0x3f800000u; }),
                "an unexported color target clipped the pending depth clear");
        const auto stencil = read_stencil();
        const auto expected = discard == 0 ? 0x80808080u : 0u;
        Require(name, "NULL-export stencil coverage and discard",
                std::ranges::all_of(stencil, [=](u32 v) { return v == expected; }),
                "a stale color target clipped stencil coverage or the NULL-export shader was skipped");
      }

      // With MRT0 still bound, an MRT3-only export must retain location3 in
      // rendering attachments, pipeline formats, blend masks and dynamic write enables.
      static const auto sparse_pixel = [] {
        auto code = native_pixel;
        *std::ranges::find(code, EncodeExp0(0x00, 0xf)) = EncodeExp0(0x03, 0xf);
        return code;
      }();
      const auto sparse_address = reinterpret_cast<uint64_t>(sparse_pixel.data());
      ShaderMapUserData(sparse_address,
          {.type = Prospero::ShaderBinaryType::kPs,
           .code_size_bytes = static_cast<uint32_t>(sparse_pixel.size() * sizeof(u32))});
      shaders.SetPsShaderBase(sparse_address);
      registers.SetDepthControl({});
      registers.SetDepthShaderControl({});
      RenderExecutorTestAccess::DrawAuto(
            executor, scheduler.Current(), {.vertex_count = 3, .instance_count = 1});
      RenderColorInfo sparse_color{};
      RenderExecutorTestAccess::ResolveRenderColorTarget(
          executor, scheduler.Current(), sparse_color, 3);
      const auto sparse_pixels = ReadCachedTexel(name, context, sparse_color.image_id,
                                                {}, {extent, extent, 1});
      for (size_t component = 0; component < sparse_pixels.size(); component++) {
        const auto expected = component % 4 == 3 ? 0x3f800000u : 0x3e800000u;
        Require(name, "sparse MRT3 output", sparse_pixels[component] == expected,
                "MRT3 was compacted to a different slot or clipped by unused MRT0");
      }
      DestroyBuffer(&stencil_readback);

      vertex_shader = owned_vertex_shader;
      pixel_shader = owned_pixel_shader;
    }
    resources.UnmapMemory(depth_address, allocation_size);
    scheduler.Finish();
    DestroyBuffer(&buffer);
    m_device.destroyShaderModule(pixel_shader.module);
    m_device.destroyShaderModule(vertex_shader.module);
    Require(name, "release depth memory",
              Libs::LibKernel::Memory::KernelMunmap(depth_address, allocation_size) == 0 &&
                  Libs::LibKernel::Memory::KernelReleaseDirectMemory(
                      direct_offset, allocation_size) == 0,
              "depth mapping or allocation release failed");
    std::printf("[gpu]     %-32s ok\n", name);
  }

  std::vector<u32> RenderFragment(const GraphicsCase &test,
                                  const CompiledShader &fragment) {
    const auto vertex_spirv =
        TestSpv::MakePassthroughVertexSpirv(test.layers > 1, test.vertex_clip_w);
    ValidateSpirv(test.name, vertex_spirv);

    Image target =
        CreateImageMips(test.name, 1, 1, vk::Format::eR32G32B32A32Sfloat,
                      vk::ImageUsageFlagBits::eColorAttachment, {}, 4,
                      vk::ImageLayout::eGeneral, vk::ImageType::e2D,
                      test.layers > 1 ? vk::ImageViewType::e2DArray : vk::ImageViewType::e2D,
                      test.layers, 0, 0, test.samples);
    Image resolved;
    if (test.samples != vk::SampleCountFlagBits::e1) {
      resolved = CreateImageMips(
          test.name, 1, 1, target.format, vk::ImageUsageFlagBits::eColorAttachment,
          {}, 4, vk::ImageLayout::eGeneral, vk::ImageType::e2D,
          test.layers > 1 ? vk::ImageViewType::e2DArray : vk::ImageViewType::e2D,
          test.layers);
    }
    const std::vector<u32> default_vertices = {
        0xbf800000u, 0xbf800000u, 0x3e800000u, 0x3f000000u, 0x3f400000u,
        0x3f800000u, 0x40400000u, 0xbf800000u, 0x3e800000u, 0x3f000000u,
        0x3f400000u, 0x3f800000u, 0xbf800000u, 0x40400000u, 0x3e800000u,
        0x3f000000u, 0x3f400000u, 0x3f800000u,
    };
    const auto &vertices =
        test.vertices.empty() ? default_vertices : test.vertices;
    Require(test.name, "graphics", vertices.size() == 18u,
            "graphics vertex buffer must contain three pos2/color4 vertices");
    auto vertex_buffer =
        CreateHostBuffer(test.name, vertices.size() * sizeof(u32),
                         vk::BufferUsageFlagBits::eVertexBuffer, vertices);

    vk::ShaderModule vertex_module = CreateShaderModule(test.name, vertex_spirv);
    vk::ShaderModule fragment_module = CreateShaderModule(test.name, fragment.spirv);

    const auto &fragment_bind = fragment.program.bindings;
    vk::PushConstantRange push_constant_range{};
    if (fragment_bind.UsesPushData()) {
      Require(test.name, "graphics",
              test.push_constants.size() * sizeof(u32) ==
                  fragment_bind.ShaderDataDwords() * sizeof(u32),
              "fragment push constant data size does not match reflection");
      push_constant_range.stageFlags = vk::ShaderStageFlagBits::eFragment;
      push_constant_range.offset = 0;
      push_constant_range.size = ShaderRecompiler::IR::NativePushConstantSize;
    }

    vk::PipelineLayoutCreateInfo pipeline_layout_info{};
    pipeline_layout_info.sType = vk::StructureType::ePipelineLayoutCreateInfo;
    pipeline_layout_info.pushConstantRangeCount =
        push_constant_range.size != 0 ? 1u : 0u;
    pipeline_layout_info.pPushConstantRanges =
        push_constant_range.size != 0 ? &push_constant_range : nullptr;
    vk::PipelineLayout pipeline_layout = nullptr;
    RequireVk(test.name, "graphics",
              m_device.createPipelineLayout(&pipeline_layout_info, nullptr,
                                            &pipeline_layout),
              "vkCreatePipelineLayout");

    vk::PipelineShaderStageCreateInfo stages[2] = {};
    stages[0].sType = vk::StructureType::ePipelineShaderStageCreateInfo;
    stages[0].stage = vk::ShaderStageFlagBits::eVertex;
    stages[0].module = vertex_module;
    stages[0].pName = "main";
    stages[1].sType = vk::StructureType::ePipelineShaderStageCreateInfo;
    stages[1].stage = vk::ShaderStageFlagBits::eFragment;
    stages[1].module = fragment_module;
    stages[1].pName = "main";

    vk::VertexInputBindingDescription vertex_binding{};
    vertex_binding.binding = 0;
    vertex_binding.stride = 6u * sizeof(float);
    vertex_binding.inputRate = vk::VertexInputRate::eVertex;
    vk::VertexInputAttributeDescription attributes[2] = {};
    attributes[0].location = 0;
    attributes[0].binding = 0;
    attributes[0].format = vk::Format::eR32G32Sfloat;
    attributes[0].offset = 0;
    attributes[1].location = 1;
    attributes[1].binding = 0;
    attributes[1].format = vk::Format::eR32G32B32A32Sfloat;
    attributes[1].offset = 2u * sizeof(float);
    vk::PipelineVertexInputStateCreateInfo vertex_input{};
    vertex_input.sType = vk::StructureType::ePipelineVertexInputStateCreateInfo;
    vertex_input.vertexBindingDescriptionCount = 1;
    vertex_input.pVertexBindingDescriptions = &vertex_binding;
    vertex_input.vertexAttributeDescriptionCount = 2;
    vertex_input.pVertexAttributeDescriptions = attributes;

    vk::PipelineInputAssemblyStateCreateInfo input_assembly{};
    input_assembly.sType =
        vk::StructureType::ePipelineInputAssemblyStateCreateInfo;
    input_assembly.topology = vk::PrimitiveTopology::eTriangleList;

    vk::Viewport viewport{};
    viewport.x = 0.0f;
    viewport.y = 0.0f;
    viewport.width = 1.0f;
    viewport.height = 1.0f;
    viewport.minDepth = 0.0f;
    viewport.maxDepth = 1.0f;
    vk::Rect2D scissor{};
    scissor.extent.width = 1;
    scissor.extent.height = 1;
    vk::PipelineViewportStateCreateInfo viewport_state{};
    viewport_state.sType = vk::StructureType::ePipelineViewportStateCreateInfo;
    viewport_state.viewportCount = 1;
    viewport_state.pViewports = &viewport;
    viewport_state.scissorCount = 1;
    viewport_state.pScissors = &scissor;

    vk::PipelineRasterizationStateCreateInfo raster{};
    raster.sType = vk::StructureType::ePipelineRasterizationStateCreateInfo;
    raster.polygonMode = vk::PolygonMode::eFill;
    raster.cullMode = vk::CullModeFlagBits::eNone;
    raster.frontFace = vk::FrontFace::eCounterClockwise;
    raster.lineWidth = 1.0f;

    vk::PipelineMultisampleStateCreateInfo multisample{};
    multisample.sType = vk::StructureType::ePipelineMultisampleStateCreateInfo;
    multisample.rasterizationSamples = test.samples;

    vk::PipelineColorBlendAttachmentState color_attachment{};
    color_attachment.colorWriteMask =
        vk::ColorComponentFlagBits::eR | vk::ColorComponentFlagBits::eG |
        vk::ColorComponentFlagBits::eB | vk::ColorComponentFlagBits::eA;
    vk::PipelineColorBlendStateCreateInfo color_blend{};
    color_blend.sType = vk::StructureType::ePipelineColorBlendStateCreateInfo;
    color_blend.attachmentCount = 1;
    color_blend.pAttachments = &color_attachment;

    vk::GraphicsPipelineCreateInfo pipeline_info{};
    const vk::Format color_format = vk::Format::eR32G32B32A32Sfloat;
    vk::PipelineRenderingCreateInfo rendering_pipeline{};
    rendering_pipeline.sType = vk::StructureType::ePipelineRenderingCreateInfo;
    rendering_pipeline.colorAttachmentCount = 1;
    rendering_pipeline.pColorAttachmentFormats = &color_format;
    pipeline_info.sType = vk::StructureType::eGraphicsPipelineCreateInfo;
    pipeline_info.pNext = &rendering_pipeline;
    pipeline_info.stageCount = 2;
    pipeline_info.pStages = stages;
    pipeline_info.pVertexInputState = &vertex_input;
    pipeline_info.pInputAssemblyState = &input_assembly;
    pipeline_info.pViewportState = &viewport_state;
    pipeline_info.pRasterizationState = &raster;
    pipeline_info.pMultisampleState = &multisample;
    pipeline_info.pColorBlendState = &color_blend;
    pipeline_info.layout = pipeline_layout;
    vk::Pipeline pipeline = nullptr;
    RequireVk(test.name, "graphics",
              m_device.createGraphicsPipelines(nullptr, 1, &pipeline_info,
                                               nullptr, &pipeline),
              "vkCreateGraphicsPipelines");

    vk::CommandBuffer cmd = BeginCommands(test.name, "graphics");
    vk::RenderingAttachmentInfo color{};
    color.sType = vk::StructureType::eRenderingAttachmentInfo;
    color.imageView = target.view;
    color.imageLayout = vk::ImageLayout::eGeneral;
    color.loadOp = vk::AttachmentLoadOp::eClear;
    color.storeOp = vk::AttachmentStoreOp::eStore;
    if (resolved.image != nullptr) {
      color.resolveMode = vk::ResolveModeFlagBits::eAverage;
      color.resolveImageView = resolved.view;
      color.resolveImageLayout = vk::ImageLayout::eGeneral;
    }
    vk::RenderingInfo rendering{};
    rendering.sType = vk::StructureType::eRenderingInfo;
    rendering.renderArea.extent = {1, 1};
    rendering.layerCount = test.layers;
    rendering.colorAttachmentCount = 1;
    rendering.pColorAttachments = &color;
    cmd.beginRendering(rendering);
    cmd.bindPipeline(vk::PipelineBindPoint::eGraphics, pipeline);
    if (push_constant_range.size != 0) {
      ShaderRecompiler::IR::PushData push_data;
      std::copy(test.push_constants.begin(), test.push_constants.end(),
                push_data.dwords.begin() + fragment_bind.push_data_start_dword);
      cmd.pushConstants(pipeline_layout, vk::ShaderStageFlagBits::eFragment, 0,
                        sizeof(push_data), push_data.dwords.data());
    }
    vk::DeviceSize offset = 0;
    cmd.bindVertexBuffers(0, 1, &vertex_buffer.buffer, &offset);
    cmd.draw(3, test.layers, 0, 0);
    cmd.endRendering();
    EndSubmitAndFree(test.name, "graphics", cmd);
    target.layout = vk::ImageLayout::eGeneral;

    auto pixel = ReadImage(test.name, resolved.image != nullptr ? &resolved : &target);
    pixel.resize(4 * test.layers);

    m_device.destroyPipeline(pipeline, nullptr);
    m_device.destroyPipelineLayout(pipeline_layout, nullptr);
    m_device.destroyShaderModule(fragment_module, nullptr);
    m_device.destroyShaderModule(vertex_module, nullptr);
    DestroyBuffer(&vertex_buffer);
    DestroyImage(&resolved);
    DestroyImage(&target);
    return pixel;
  }

  void CheckGpuTilerCpuParity() {
    constexpr const char *name = "GpuTilerCpuParity";
    EnsureRuntimeContext();

    CommandScheduler scheduler(Renderer(), m_runtime_context);
    HW::Context registers{};
    HW::UserConfig user_config{};
    HW::Shader shaders{};
    scheduler.Begin(registers, user_config, shaders);
    StreamBuffer parameters(m_runtime_context, scheduler, MemoryUsage::Stream,
                            1u << 20);
    TileManager tile_manager(m_runtime_context, scheduler, parameters);
    constexpr uint64_t conversion_limit = 128ull << 20;
    Require(name, "D16 conversion chunk boundaries",
            TileManagerTestAccess::ConversionRows(0, 32ull << 10, 32ull << 10,
                                                  4096, 256, conversion_limit,
                                                  65535) == 4096 &&
                TileManagerTestAccess::ConversionRows(
                    0, 32ull << 10, 32ull << 10, 4097, 256, conversion_limit,
                    65535) == 4096 &&
                TileManagerTestAccess::ConversionRows(
                    257, 32ull << 10, 32ull << 10, 4097, 256, conversion_limit,
                    65535) == 4095,
            "D16 conversion planner exceeds descriptor or dispatch limits");

    const auto align_dword = [](uint64_t size) {
      return (size + sizeof(u32) - 1u) & ~(uint64_t{sizeof(u32) - 1u});
    };
    const auto to_dwords = [&](const std::vector<uint8_t> &bytes,
                               uint64_t padded_size) {
      std::vector<u32> words(static_cast<size_t>(padded_size / sizeof(u32)), 0);
      std::memcpy(words.data(), bytes.data(), bytes.size());
      return words;
    };
    const auto read_bytes = [&](const Buffer &buffer, uint64_t size) {
      const auto words = ReadBuffer(
          name, buffer, static_cast<size_t>(align_dword(size) / sizeof(u32)));
      std::vector<uint8_t> bytes(static_cast<size_t>(size));
      std::memcpy(bytes.data(), words.data(), bytes.size());
      return bytes;
    };
    const auto host_barrier = [&](vk::Buffer buffer, uint64_t size,
                                  vk::PipelineStageFlags source_stage,
                                  vk::AccessFlags source_access) {
      vk::BufferMemoryBarrier barrier{};
      barrier.sType = vk::StructureType::eBufferMemoryBarrier;
      barrier.srcAccessMask = source_access;
      barrier.dstAccessMask = vk::AccessFlagBits::eHostRead;
      barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
      barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
      barrier.buffer = buffer;
      barrier.offset = 0;
      barrier.size = size;
      scheduler.Current().Handle().pipelineBarrier(
          source_stage, vk::PipelineStageFlagBits::eHost, {}, 0, nullptr, 1,
          &barrier, 0, nullptr);
    };
    const auto gpu_detile =
        [&](const std::vector<uint8_t> &tiled, std::vector<uint8_t> *linear,
            uint64_t tiled_capacity, uint64_t linear_capacity,
            std::span<const GpuTileInfo> infos) {
          const uint64_t padded_tiled = align_dword(tiled_capacity);
          const uint64_t padded_linear = align_dword(linear_capacity);
          auto input = CreateHostBuffer(name, padded_tiled, AllFlags,
                                        to_dwords(tiled, padded_tiled));
          auto output = CreateHostBuffer(
              name, padded_linear, AllFlags,
              std::vector<u32>(static_cast<size_t>(padded_linear / sizeof(u32)),
                               0xabababab));
          const auto result = tile_manager.Detile(input.buffer, 0, padded_tiled,
                                                  padded_linear, infos);
          const vk::BufferCopy copy{result.offset, 0, padded_linear};
          scheduler.Current().Handle().copyBuffer(result.buffer, output.buffer,
                                                  1, &copy);
          host_barrier(output.buffer, padded_linear,
                       vk::PipelineStageFlagBits::eTransfer,
                       vk::AccessFlagBits::eTransferWrite);
          scheduler.Finish();
          *linear = read_bytes(output, linear_capacity);
          DestroyBuffer(&output);
          DestroyBuffer(&input);
        };
    const auto gpu_tile = [&](const std::vector<uint8_t> &linear,
                              std::vector<uint8_t> *tiled,
                              uint64_t tiled_capacity, uint64_t linear_capacity,
                              std::span<const GpuTileInfo> infos) {
      const uint64_t padded_tiled = align_dword(tiled_capacity);
      const uint64_t padded_linear = align_dword(linear_capacity);
      auto input = CreateHostBuffer(name, padded_linear, AllFlags,
                                    to_dwords(linear, padded_linear));
      auto output = CreateHostBuffer(
          name, padded_tiled, AllFlags,
          std::vector<u32>(static_cast<size_t>(padded_tiled / sizeof(u32)),
                           0xabababab));
      tile_manager.Tile(input.buffer, 0, padded_linear, output.buffer, 0,
                        padded_tiled, infos);
      host_barrier(output.buffer, padded_tiled,
                   vk::PipelineStageFlagBits::eComputeShader,
                   vk::AccessFlagBits::eShaderWrite);
      scheduler.Finish();
      *tiled = read_bytes(output, tiled_capacity);
      DestroyBuffer(&output);
      DestroyBuffer(&input);
    };

    for (const bool d32 : std::array{true, false}) {
      constexpr uint32_t width = 5;
      constexpr uint32_t height = 3;
      constexpr uint32_t pitch = 8;
      constexpr uint32_t layers = 2;
      constexpr uint64_t d16_row = pitch * sizeof(uint16_t);
      constexpr uint64_t d32_row = pitch * sizeof(uint32_t);
      constexpr uint64_t d16_slice = d16_row * height;
      constexpr uint64_t d32_slice = d32_row * height;
      constexpr uint64_t d16_size = d16_slice * layers;
      constexpr uint64_t d32_size = d32_slice * layers;
      StreamBuffer conversion_upload(m_runtime_context, scheduler,
                                     MemoryUsage::Upload, 1u << 20);
      auto [prefix, prefix_offset] = conversion_upload.Map(4096, 256);
      Require(name, "D16 conversion prefix",
              prefix != nullptr && prefix_offset == 0,
              "failed to advance the D16 conversion upload ring");
      std::memset(prefix, 0x7b, 4096);
      conversion_upload.Commit();
      auto [source_bytes, source_offset] = conversion_upload.Map(d16_size, 4);
      Require(name, "D16 conversion source",
              source_bytes != nullptr && source_offset != 0,
              "failed to reserve a nonzero D16 conversion source");
      std::memset(source_bytes, 0x3c, d16_size);
      for (uint32_t layer = 0; layer < layers; layer++) {
        for (uint32_t y = 0; y < height; y++) {
          auto *row = reinterpret_cast<uint16_t *>(
              source_bytes + layer * d16_slice + y * d16_row);
          for (uint32_t x = 0; x < width; x++) {
            row[x] = static_cast<uint16_t>(
                0x1111u * (1u + x + y * width + layer * width * height));
          }
        }
      }
      conversion_upload.Commit();
      auto promoted = CreateHostBuffer(
          name, d32_size, AllFlags,
          std::vector<u32>(static_cast<size_t>(d32_size / sizeof(u32)), 0));
      auto round_trip = CreateHostBuffer(
          name, d16_size, AllFlags,
          std::vector<u32>(static_cast<size_t>(d16_size / sizeof(u32)),
                           0xa5a5a5a5u));
      const TileManager::D16Layout promote_layout{
          .width = width,
          .height = height,
          .layers = layers,
          .source_row_stride = d16_row,
          .target_row_stride = d32_row,
          .source_slice_stride = d16_slice,
          .target_slice_stride = d32_slice,
      };
      tile_manager.ConvertD16({conversion_upload.Handle(), source_offset,
                               conversion_upload.Size() - source_offset},
                              {promoted.buffer, 0, d32_size},
                              TileManager::D16Direction::Promote, d32,
                              promote_layout);
      tile_manager.ConvertD16({promoted.buffer, 0, d32_size},
                              {round_trip.buffer, 0, d16_size},
                              TileManager::D16Direction::Demote, d32,
                              {.width = width,
                               .height = height,
                               .layers = layers,
                               .source_row_stride = d32_row,
                               .target_row_stride = d16_row,
                               .source_slice_stride = d32_slice,
                               .target_slice_stride = d16_slice});
      host_barrier(round_trip.buffer, d16_size,
                   vk::PipelineStageFlagBits::eComputeShader,
                   vk::AccessFlagBits::eShaderWrite);
      scheduler.Finish();
      const auto result = read_bytes(round_trip, d16_size);
      bool conversion_matches = true;
      for (uint32_t layer = 0; layer < layers; layer++) {
        for (uint32_t y = 0; y < height; y++) {
          for (uint32_t x = 0; x < pitch; x++) {
            const auto offset =
                layer * d16_slice + y * d16_row + x * sizeof(uint16_t);
            conversion_matches &=
                x < width
                    ? std::memcmp(result.data() + offset, source_bytes + offset,
                                  sizeof(uint16_t)) == 0
                    : result[offset] == 0xa5 && result[offset + 1] == 0xa5;
          }
        }
      }
      Require(name,
              d32 ? "D32 conversion round trip" : "D24 conversion round trip",
              conversion_matches,
              "D16 conversion lost rows, layers, active values, or padding");
      DestroyBuffer(&round_trip);
      DestroyBuffer(&promoted);
    }

    auto fill = [](std::vector<uint8_t> *bytes, u32 salt) {
      for (size_t i = 0; i < bytes->size(); i++) {
        uint64_t value =
            i + static_cast<uint64_t>(salt) * 0x9e3779b97f4a7c15ull;
        value = (value ^ (value >> 30u)) * 0xbf58476d1ce4e5b9ull;
        value = (value ^ (value >> 27u)) * 0x94d049bb133111ebull;
        (*bytes)[i] = static_cast<uint8_t>((value ^ (value >> 31u)) >> 56u);
      }
    };
    auto compare = [&](const char *stage, const std::vector<uint8_t> &expected,
                       const std::vector<uint8_t> &actual) {
      if (expected != actual) {
        const auto mismatch = static_cast<size_t>(
            std::mismatch(expected.begin(), expected.end(), actual.begin())
                .first -
            expected.begin());
        std::ostringstream out;
        out << "first mismatch at " << mismatch << " of " << expected.size();
        Fail(name, stage, out.str());
      }
    };
    auto convert_reference = [&](bool to_tiled, std::vector<uint8_t> *dst,
                                 const std::vector<uint8_t> &src,
                                 const GpuTileInfo &info) {
      TileBlockLayout block{};
      Require(name, "reference layout",
              TileGetBlockLayout(info.family, info.bytes_per_element, block),
              "CPU reference rejected GPU tile info");
      const u32 tiled_width =
          info.tiled_width != 0 ? info.tiled_width : info.pitch;
      const u32 tiled_height =
          info.tiled_height != 0 ? info.tiled_height : info.height;
      const uint64_t columns =
          (tiled_width + block.block_width - 1u) / block.block_width;
      const uint64_t rows =
          (tiled_height + block.block_height - 1u) / block.block_height;
      const uint64_t slice = info.linear_slice_stride != 0
                                 ? info.linear_slice_stride
                                 : static_cast<uint64_t>(info.pitch) *
                                       info.height * info.bytes_per_element;
      for (u32 z = 0; z < info.depth; ++z) {
        for (u32 y = 0; y < info.height; ++y) {
          for (u32 x = 0; x < info.width; ++x) {
            const u32 bx = info.tail ? 0 : x / block.block_width;
            const u32 by = info.tail ? 0 : y / block.block_height;
            const u32 bz = info.tail ? 0 : z / block.block_depth;
            const u32 lx = info.tail ? x + info.tail_x : x % block.block_width;
            const u32 ly = info.tail ? y + info.tail_y : y % block.block_height;
            const u32 lz = z % block.block_depth;
            u32 local = 0, block_xor = 0;
            Require(name, "reference offset",
                    TileGetBlockOffset(block, lx, ly, lz, local) &&
                        TileGetBlockXor(block, bx, by, info.surface_z + bz,
                                        block_xor),
                    "CPU reference address lookup failed");
            const uint64_t block_index =
                static_cast<uint64_t>(bz) * columns * rows + by * columns + bx;
            const uint64_t tiled = info.tiled_offset +
                                   block_index * block.block_size +
                                   (local ^ block_xor);
            const uint64_t linear =
                info.linear_offset + static_cast<uint64_t>(z) * slice +
                static_cast<uint64_t>(y) * info.pitch * info.bytes_per_element +
                static_cast<uint64_t>(x) * info.bytes_per_element;
            const uint64_t dst_offset = to_tiled ? tiled : linear;
            const uint64_t src_offset = to_tiled ? linear : tiled;
            Require(name, "reference range",
                    dst_offset + info.bytes_per_element <= dst->size() &&
                        src_offset + info.bytes_per_element <= src.size(),
                    "CPU reference address escaped storage");
            std::memcpy(dst->data() + dst_offset, src.data() + src_offset,
                        info.bytes_per_element);
          }
        }
      }
    };
    struct FamilyCase {
      TileBlockFamily family;
      u32 max_bpe;
    };
    constexpr FamilyCase families[] = {
        {TileBlockFamily::Standard256B, 16},
        {TileBlockFamily::Standard4KB, 16},
        {TileBlockFamily::Standard4KB3D, 16},
        {TileBlockFamily::Standard64KB, 16},
        {TileBlockFamily::Standard64KB3D, 16},
        {TileBlockFamily::Prt64KB, 16},
        {TileBlockFamily::Prt64KB3D, 16},
        {TileBlockFamily::RenderTarget64KB, 16},
        {TileBlockFamily::Depth64KB, 8},
    };

    {
      TileBlockLayout standard{}, prt{}, standard_3d{}, prt_3d{}, color{},
          depth{};
      u32 standard_offset = 0, prt_offset = 0, standard_3d_offset = 0,
          prt_3d_offset = 0, color_z = 0, depth_z = 0;
      bool fixed_addresses =
          TileGetBlockLayout(TileBlockFamily::Standard64KB, 4, standard) &&
          TileGetBlockLayout(TileBlockFamily::Prt64KB, 4, prt) &&
          TileGetBlockLayout(TileBlockFamily::Standard64KB3D, 4, standard_3d) &&
          TileGetBlockLayout(TileBlockFamily::Prt64KB3D, 4, prt_3d) &&
          TileGetBlockLayout(TileBlockFamily::RenderTarget64KB, 4, color) &&
          TileGetBlockLayout(TileBlockFamily::Depth64KB, 4, depth) &&
          TileGetBlockOffset(standard, 64, 0, 0, standard_offset) &&
          TileGetBlockOffset(prt, 64, 0, 0, prt_offset) &&
          TileGetBlockOffset(standard_3d, 16, 0, 0, standard_3d_offset) &&
          TileGetBlockOffset(prt_3d, 16, 0, 0, prt_3d_offset) &&
          TileGetBlockXor(color, 0, 0, 1, color_z) &&
          TileGetBlockXor(depth, 0, 0, 15, depth_z);
      Require(name, "fixed address vectors",
              fixed_addresses && standard_offset == 0x8000 &&
                  prt_offset == 0x8100 && standard_3d_offset == 0x8000 &&
                  prt_3d_offset == 0x8400 && standard_3d.block_width == 32 &&
                  standard_3d.block_height == 32 &&
                  standard_3d.block_depth == 16 && color_z == 0x800 &&
                  depth_z == 0xf00,
              "a fixed block address changed");

      constexpr auto format = Prospero::BufferFormat::k32Float;
      constexpr u32 levels = 7;
      TileSizeAlign total{};
      TileSizeOffset mip[levels]{};
      TilePaddedSize padded[levels]{};
      TileGetTextureSize(format, 65, 33, levels,
                         Prospero::TileMode::kStandard256B, &total, mip,
                         padded);
      constexpr u32 offsets[levels] = {0x1a00, 0xb00, 0x500, 0x300,
                                       0x200,  0x100, 0};
      constexpr u32 sizes[levels] = {0x2d00, 0xf00, 0x600, 0x200,
                                     0x100,  0x100, 0x100};
      bool layout_matches = total.size == 0x4700 && total.align == 0x100 &&
                            padded[0].width == 72 && padded[0].height == 40;
      for (u32 level = 0; level < levels; ++level) {
        layout_matches &= mip[level].offset == offsets[level] &&
                          mip[level].size == sizes[level];
      }
      Require(name, "fixed mip vector", layout_matches,
              "the reverse-packed small-block mip layout changed");
    }

    u32 case_index = 0;
    auto check_round_trip = [&](const char *stage, uint64_t tiled_size,
                                std::span<const GpuTileInfo> infos) {
      uint64_t linear_size = 0;
      for (const auto &info : infos) {
        linear_size =
            std::max(linear_size, info.linear_offset + info.linear_size);
      }
      std::vector<uint8_t> tiled(tiled_size);
      std::vector<uint8_t> cpu(linear_size, 0);
      std::vector<uint8_t> gpu(linear_size, 0xab);
      fill(&tiled, ++case_index);
      for (const auto &info : infos) {
        convert_reference(false, &cpu, tiled, info);
      }
      gpu_detile(tiled, &gpu, tiled_size, linear_size, infos);
      compare((std::string(stage) + " detile bytes").c_str(), cpu, gpu);

      std::vector<uint8_t> linear(linear_size);
      std::vector<uint8_t> cpu_tiled(tiled_size, 0xab);
      std::vector<uint8_t> gpu_tiled(tiled_size, 0xab);
      fill(&linear, 0x280u + case_index);
      for (const auto &info : infos) {
        convert_reference(true, &cpu_tiled, linear, info);
      }
      gpu_tile(linear, &gpu_tiled, tiled_size, linear_size, infos);
      compare((std::string(stage) + " tile bytes").c_str(), cpu_tiled,
              gpu_tiled);
    };
    for (const auto family : families) {
      for (u32 bpe = 1; bpe <= family.max_bpe; bpe <<= 1u) {
        TileBlockLayout block{};
        Require(name, "block layout",
                TileGetBlockLayout(family.family, bpe, block),
                "admitted family/BPE has no block layout");
        const bool volume = block.block_depth > 1;
        const u32 width =
            block.block_width * 3u + std::min(block.block_width, 3u);
        const u32 height =
            block.block_height * 3u + std::min(block.block_height, 3u);
        const u32 depth = volume ? block.block_depth + 1u : 1u;
        const u32 pitch = block.block_width * 4u;
        const uint64_t block_columns =
            (pitch + block.block_width - 1u) / block.block_width;
        const uint64_t block_rows =
            (height + block.block_height - 1u) / block.block_height;
        const uint64_t block_slices =
            (depth + block.block_depth - 1u) / block.block_depth;
        const uint64_t storage_size =
            block_columns * block_rows * block_slices * block.block_size;
        const uint64_t slice_stride =
            static_cast<uint64_t>(pitch) * height * bpe;

        std::vector<uint8_t> tiled(storage_size);
        std::vector<uint8_t> cpu(storage_size, 0);
        std::vector<uint8_t> gpu(storage_size, 0xab);
        fill(&tiled, ++case_index);

        GpuTileInfo info{};
        info.family = block.family;
        info.bytes_per_element = block.bytes_per_element;
        info.linear_size = storage_size;
        info.tiled_size = storage_size;
        info.linear_slice_stride = volume ? slice_stride : 0;
        info.width = width;
        info.height = height;
        info.depth = depth;
        info.pitch = pitch;
        info.surface_z = family.family == TileBlockFamily::RenderTarget64KB ||
                                 family.family == TileBlockFamily::Depth64KB
                             ? 3
                             : 0;
        convert_reference(false, &cpu, tiled, info);
        gpu_detile(tiled, &gpu, storage_size, storage_size,
                   std::span<const GpuTileInfo>(&info, 1));
        const auto family_label = [&](const char *operation) {
          std::ostringstream out;
          out << operation << " family=" << static_cast<u32>(family.family)
              << " bpe=" << bpe;
          return out.str();
        };
        compare(family_label("detile bytes").c_str(), cpu, gpu);

        {
          std::vector<uint8_t> linear(storage_size);
          std::vector<uint8_t> cpu_tiled(storage_size, 0xab);
          std::vector<uint8_t> gpu_tiled(storage_size, 0xab);
          fill(&linear, 0x80u + case_index);
          convert_reference(true, &cpu_tiled, linear, info);
          gpu_tile(linear, &gpu_tiled, storage_size, storage_size,
                   std::span<const GpuTileInfo>(&info, 1));
          compare(family_label("tile bytes").c_str(), cpu_tiled, gpu_tiled);
        }
      }
    }

    // Exercise the real texture-layout/info-building seam for every format
    // admitted by each standard tile mode.  Formats sharing a byte/block width
    // intentionally share a shader, but this loop still validates their
    // texel-to-element conversion (notably every BCn format).
    struct StandardMode {
      Prospero::TileMode tile;
      TileBlockFamily family;
    };
    constexpr StandardMode standard_modes[] = {
        {Prospero::TileMode::kStandard256B, TileBlockFamily::Standard256B},
        {Prospero::TileMode::kStandard4KB, TileBlockFamily::Standard4KB},
        {Prospero::TileMode::kStandard64KB, TileBlockFamily::Standard64KB},
        {Prospero::TileMode::kPrt, TileBlockFamily::Prt64KB},
    };
    for (const auto format :
         {Prospero::BufferFormat::k8Srgb, Prospero::BufferFormat::k8_8Srgb,
          Prospero::BufferFormat::k9_9_9_5Float}) {
      for (const auto tile :
           {Prospero::TileMode::kDepth, Prospero::TileMode::kRenderTarget}) {
        TileTextureBlockLayout texture{};
        Require(name, "RT format policy",
                !TileGetTextureBlockLayout(format, tile, false, texture),
                "non-render-target format admitted by an RT/depth tile family");
      }
    }
    {
      TileSurfaceLayout invalid{};
      const TileSurfaceDescription description{
          Prospero::BufferFormat::k32Float,
          Prospero::TileMode::kStandard256B,
          TileSurfaceDimension::Dim3D,
          16,
          16,
          16,
          1,
          1,
      };
      Require(name, "3D tile policy",
              !TileGetTiledTextureLayout(description, invalid),
              "Standard256B volume silently fell back to a 2D array layout");
    }
    {
      constexpr auto format = Prospero::BufferFormat::kFmask8_S4_F4;
      constexpr auto tile = Prospero::TileMode::kStandard64KB;
      TileSizeAlign total{};
      TileGetTextureSize(format, 128, 128, 1, tile, &total, nullptr, nullptr);
      const auto layout = TextureCalcUploadLayout(
          format, 128, 128, 1, 1, tile, total.size, false, false, name);
      const auto regions = TextureBuildImageCopies(layout);
      std::vector<GpuTileInfo> infos;
      Require(name, "FMASK policy",
              !TextureBuildGpuTileInfos(total.size, regions, layout, 1, infos),
              "FMASK entered the texel tiler through a non-depth family");
    }
    u32 format_cases = 0;
    for (u32 raw_format = 1;
         raw_format <= static_cast<uint32_t>(Prospero::BufferFormat::kBc7Srgb);
         ++raw_format) {
      const auto format = static_cast<Prospero::BufferFormat>(raw_format);
      // FMASK contains sample-to-fragment metadata, not texels for the GPU tiler.
      if (Prospero::IsFmaskTextureFormat(format)) {
        continue;
      }
      for (const auto &mode : standard_modes) {
        TileTextureBlockLayout texture{};
        if (!TileGetTextureBlockLayout(format, mode.tile, false, texture)) {
          continue;
        }
        const u32 bpe = texture.block.bytes_per_element;
        Require(name, "format block", texture.block.family == mode.family,
                "CPU-supported format selected the wrong block family");

        constexpr u32 width = 67;
        constexpr u32 height = 51;
        const u32 pitch = TileGetTexturePitch(format, width, mode.tile);
        TileSizeAlign total{};
        TileGetTextureSize(format, width, height, 1, mode.tile, &total, nullptr,
                           nullptr);
        Require(name, "format size", total.size != 0,
                "supported format has an empty layout");

        const auto layout =
            TextureCalcUploadLayout(format, width, height, 1, 1, mode.tile,
                                    total.size, false, false, name);
        const auto regions = TextureBuildImageCopies(layout);
        std::vector<GpuTileInfo> infos;
        if (!TextureBuildGpuTileInfos(total.size, regions, layout, 1, infos)) {
          std::ostringstream out;
          out << "format=" << raw_format
              << " tile=" << static_cast<uint32_t>(mode.tile)
              << " size=" << total.size << " pitch=" << pitch;
          Fail(name, "format infos", out.str());
        }
        Require(name, "format family",
                infos.size() == 1 && infos[0].family == mode.family &&
                    infos[0].bytes_per_element == bpe,
                "texture info selected the wrong shader family");

        std::vector<uint8_t> tiled(total.size);
        std::vector<uint8_t> cpu(total.size, 0);
        std::vector<uint8_t> gpu(total.size, 0xab);
        fill(&tiled, ++case_index);
        convert_reference(false, &cpu, tiled, infos[0]);
        gpu_detile(tiled, &gpu, total.size, total.size, infos);
        compare("format bytes", cpu, gpu);
        ++format_cases;
      }
    }
    Require(name, "format coverage", format_cases != 0,
            "no CPU-supported standard formats were tested");

    {
      constexpr auto format = Prospero::BufferFormat::k11_11_10UInt;
      constexpr auto tile = Prospero::TileMode::kStandard64KB;
      constexpr u32 width = 128, height = 128, levels = 8;
      TileSurfaceLayout surface{};
      const TileSurfaceDescription description{
          format, tile, TileSurfaceDimension::Dim2D, width, height, 1,
          levels, 1};
      TileSizeAlign total{};
      TileGetTextureTotalSize(format, width, height, 1, levels, tile, false,
                              total);
      const bool built = TileGetTiledTextureLayout(description, surface);
      const auto surface_format = TextureGetSurfaceFormatInfo(format);
      constexpr u32 tail_xy[7][2] = {{64, 0}, {0, 64}, {32, 0}, {0, 32},
                                     {16, 0}, {8, 16}, {0, 24}};
      bool valid = built && Prospero::NumBytesPerElement(format) == 4 &&
                   Prospero::BlockCompressedBytesPerBlock(format) == 0 &&
                   Prospero::SampledTextureNumericClass(format) ==
                       Prospero::TextureNumericClass::Uint &&
                   Prospero::RemapTextureFormat(format) ==
                       Prospero::BufferFormat::k32UInt &&
                   surface_format.vk_format == vk::Format::eR32Uint &&
                   surface_format.conversion_format == format &&
                   VulkanFormat(format) == vk::Format::eUndefined &&
                   surface.texture.block.block_width == 128 &&
                   surface.texture.block.block_height == 128 &&
                   surface.texture.block.block_depth == 1 &&
                   surface.first_tail_level == 1 &&
                   surface.mips[0].offset == 0x10000 && total.size == 0x20000 &&
                   total.align == 0x10000;
      for (u32 level = 1; level < levels && valid; level++) {
        valid &= surface.mips[level].offset == 0 &&
                 surface.mips[level].tail_x == tail_xy[level - 1][0] &&
                 surface.mips[level].tail_y == tail_xy[level - 1][1];
      }
      Require(name, "11_11_10 uint layout", valid,
              "PS5 packed integer texture metadata or Standard64KB mip tail "
              "changed");

      const auto signed_format = Prospero::BufferFormat::k32SInt;
      const auto signed_surface = TextureGetSurfaceFormatInfo(signed_format);
      Require(name, "signed sampled surface mapping",
              Prospero::SampledTextureNumericClass(signed_format) ==
                      Prospero::TextureNumericClass::Sint &&
                  Prospero::RemapTextureFormat(signed_format) ==
                      signed_format &&
                  signed_surface.vk_format == vk::Format::eR32Sint &&
                  signed_surface.conversion_format ==
                      Prospero::BufferFormat::kInvalid,
              "signed sampled texture class or native backing changed");
    }

    {
      constexpr auto format = Prospero::BufferFormat::k32_32_32Float;
      TileTextureElementLayout element{};
      Require(name, "RGB32 texture policy",
              !TileGetTextureElementLayout(format, element),
              "12-byte texel layouts must be rejected");
    }

    {
      constexpr auto format = Prospero::BufferFormat::kBc1UNorm;
      constexpr auto tile = Prospero::TileMode::kStandard64KB;
      constexpr u32 width = 256, height = 256, levels = 9;
      TileSizeAlign total{};
      TileGetTextureSize(format, width, height, levels, tile, &total, nullptr,
                         nullptr);
      const auto layout =
          TextureCalcUploadLayout(format, width, height, levels, 1, tile,
                                  total.size, false, false, name);
      const auto regions = TextureBuildImageCopies(layout);
      std::vector<GpuTileInfo> infos;
      const bool built =
          TextureBuildGpuTileInfos(total.size, regions, layout, levels, infos);
      uint64_t linear_size = 0;
      for (const auto &info : infos) {
        linear_size =
            std::max(linear_size, info.linear_offset + info.linear_size);
      }
      Require(name, "BC1 mip-tail capacities",
              built && total.size == 0x10000 &&
                  layout.surface.first_tail_level == 0 &&
                  linear_size == 0x15560 && linear_size > total.size,
              "BC1 mip tail conflated tiled and linear capacities");
      check_round_trip("BC1 mip tail", total.size, infos);
    }

    {
      constexpr auto format = Prospero::BufferFormat::k32Float;
      constexpr auto tile = Prospero::TileMode::kRenderTarget;
      constexpr u32 width = 129, height = 65, layers = 3;
      TileSizeAlign total{};
      TileGetTextureTotalSize(format, width, height, layers, 1, tile, false,
                              total);
      const auto layout =
          TextureCalcUploadLayout(format, width, height, 1, layers, tile,
                                  total.size, true, false, name);
      const auto regions = TextureBuildImageCopies(layout);
      std::vector<GpuTileInfo> infos;
      const bool built =
          TextureBuildGpuTileInfos(total.size, regions, layout, 1, infos);
      Require(name, "array infos",
              built && infos.size() == layers && infos[0].surface_z == 0 &&
                  infos[1].surface_z == 1 && infos[2].surface_z == 2,
              "array slices lost their absolute surface Z");
      check_round_trip("array", total.size, infos);
    }

    for (const auto &mode : standard_modes) {
      constexpr auto format = Prospero::BufferFormat::k32Float;
      constexpr u32 levels = 2;
      TileBlockLayout block{};
      Require(name, "odd mip block", TileGetBlockLayout(mode.family, 4, block),
              "odd multi-mip format has no block layout");
      const u32 width = block.block_width * 2u + 1u;
      const u32 height = block.block_height * 2u + 1u;
      TileSizeAlign total{};
      TileGetTextureSize(format, width, height, levels, mode.tile, &total,
                         nullptr, nullptr);
      const auto layout =
          TextureCalcUploadLayout(format, width, height, levels, 1, mode.tile,
                                  total.size, false, false, name);
      const auto regions = TextureBuildImageCopies(layout);
      std::vector<GpuTileInfo> infos;
      Require(name, "odd mip infos",
              TextureBuildGpuTileInfos(total.size, regions, layout, levels,
                                       infos) &&
                  infos.size() == 2 && infos[1].tiled_width >= infos[1].pitch &&
                  infos[1].tiled_height >= infos[1].height &&
                  (mode.family == TileBlockFamily::Standard256B ||
                   infos[1].tiled_height > infos[1].height),
              "odd multi-mip physical stride collapsed to the active linear "
              "extent");
      check_round_trip("odd multi-mip", total.size, infos);
    }

    struct TailMode {
      Prospero::TileMode tile;
      TileBlockFamily family;
    };
    constexpr TailMode tail_modes[] = {
        {Prospero::TileMode::kStandard4KB, TileBlockFamily::Standard4KB},
        {Prospero::TileMode::kStandard64KB, TileBlockFamily::Standard64KB},
        {Prospero::TileMode::kPrt, TileBlockFamily::Prt64KB},
        {Prospero::TileMode::kRenderTarget, TileBlockFamily::RenderTarget64KB},
        {Prospero::TileMode::kDepth, TileBlockFamily::Depth64KB},
    };
    for (const auto &mode : tail_modes) {
      constexpr auto format = Prospero::BufferFormat::k32Float;
      constexpr u32 levels = 7;
      TileBlockLayout block{};
      Require(name, "2D tail block", TileGetBlockLayout(mode.family, 4, block),
              "2D tail mode has no block layout");
      const u32 width = block.block_width * 2u;
      const u32 height = block.block_height * 2u;
      TileSizeAlign total{};
      TileGetTextureSize(format, width, height, levels, mode.tile, &total,
                         nullptr, nullptr);
      const auto layout =
          TextureCalcUploadLayout(format, width, height, levels, 1, mode.tile,
                                  total.size, true, false, name);
      const auto regions = TextureBuildImageCopies(layout);
      std::vector<GpuTileInfo> infos;
      Require(name, "2D mip tail seam",
              layout.surface.first_tail_level == 2 &&
                  TextureBuildGpuTileInfos(total.size, regions, layout, levels,
                                           infos) &&
                  infos.size() == levels && !infos[0].tail && !infos[1].tail &&
                  std::all_of(infos.begin() + 2, infos.end(),
                              [](const auto &info) { return info.tail; }),
              "2D mip chain lost its linear/tiled tail boundary");
      check_round_trip("2D mip tail seam", total.size, infos);
    }

    {
      constexpr auto format = Prospero::BufferFormat::k32Float;
      constexpr auto tile = Prospero::TileMode::kStandard4KB;
      constexpr u32 width = 65;
      constexpr u32 height = 129;
      constexpr u32 depth = 17;
      constexpr u32 levels = 2;
      TileSizeAlign total{};
      TileGetTextureTotalSize(format, width, height, depth, levels, tile, true,
                              total);
      const auto layout =
          TextureCalcUploadLayout(format, width, height, levels, depth, tile,
                                  total.size, false, true, name);
      const auto regions = TextureBuildImageCopies(layout);
      std::vector<GpuTileInfo> infos;
      const bool built =
          TextureBuildGpuTileInfos(total.size, regions, layout, levels, infos);
      Require(name, "3D mip infos",
              regions.size() == depth + (depth >> 1u) && built &&
                  infos.size() == 4 && infos[0].depth == 8 &&
                  infos[1].depth == 8 && infos[2].depth == 1 &&
                  infos[3].depth == 8 && infos[0].tiled_offset == 0x19000 &&
                  infos[1].tiled_offset == 0x83000 &&
                  infos[2].tiled_offset == 0xed000 &&
                  infos[3].tiled_offset == 0 && infos[3].pitch == 32 &&
                  infos[3].height == 64 && infos[3].tiled_width == 40 &&
                  infos[3].tiled_height == 80,
              "Standard4KB3D mip depth, packing, or physical stride changed");
      check_round_trip("3D mip", total.size, infos);
    }

    {
      constexpr auto format = Prospero::BufferFormat::kBc1UNorm;
      constexpr auto tile = Prospero::TileMode::kStandard4KB;
      constexpr u32 width = 65;
      constexpr u32 height = 129;
      constexpr u32 depth = 17;
      constexpr u32 levels = 2;
      TileSizeAlign total{};
      TileGetTextureTotalSize(format, width, height, depth, levels, tile, true,
                              total);
      const auto layout =
          TextureCalcUploadLayout(format, width, height, levels, depth, tile,
                                  total.size, false, true, name);
      const auto regions = TextureBuildImageCopies(layout);
      std::vector<GpuTileInfo> infos;
      Require(name, "3D BC mip infos",
              TextureBuildGpuTileInfos(total.size, regions, layout, levels,
                                       infos) &&
                  infos.size() == 4 && infos[3].pitch == 8 &&
                  infos[3].height == 16 && infos[3].tiled_width == 16 &&
                  infos[3].tiled_height == 24,
              "block-compressed 3D mip lost its physical row or slice stride");
      check_round_trip("3D BC mip", total.size, infos);
    }

    {
      constexpr auto format = Prospero::BufferFormat::kBc3UNorm;
      constexpr auto tile = Prospero::TileMode::kLinear;
      constexpr u32 width = 8, height = 8, levels = 4;
      TileSizeAlign total{};
      TileGetTextureSize(format, width, height, levels, tile, &total, nullptr,
                         nullptr);
      const auto layout =
          TextureCalcUploadLayout(format, width, height, levels, 1, tile,
                                  total.size, false, false, name);
      const auto regions = TextureBuildImageCopies(layout);
      Require(name, "linear BC native regions",
              regions.size() == levels &&
                  std::all_of(regions.begin(), regions.end(),
                              [](const auto &region) {
                                return region.bufferRowLength >=
                                           region.imageExtent.width &&
                                       region.bufferImageHeight >=
                                           region.imageExtent.height &&
                                       region.bufferRowLength % 4 == 0 &&
                                       region.bufferImageHeight % 4 == 0;
                              }),
              "linear BC mip tails emitted invalid Vulkan copy strides");
    }

    struct VolumeModeCase {
      Prospero::TileMode tile;
      TileBlockFamily family;
      Prospero::BufferFormat format;
    };
    constexpr VolumeModeCase volume_modes[] = {
        {Prospero::TileMode::kStandard64KB, TileBlockFamily::Standard64KB3D,
         Prospero::BufferFormat::k32Float},
        {Prospero::TileMode::kPrt, TileBlockFamily::Prt64KB3D,
         Prospero::BufferFormat::k32Float},
        {Prospero::TileMode::kRenderTarget, TileBlockFamily::RenderTarget64KB,
         Prospero::BufferFormat::k32Float},
        {Prospero::TileMode::kDepth, TileBlockFamily::Depth64KB,
         Prospero::BufferFormat::k32Float},
        {Prospero::TileMode::kStandard64KB, TileBlockFamily::Standard64KB3D,
         Prospero::BufferFormat::kBc1UNorm},
        {Prospero::TileMode::kPrt, TileBlockFamily::Prt64KB3D,
         Prospero::BufferFormat::kBc3UNorm},
    };
    for (const auto test : volume_modes) {
      constexpr u32 width = 65, height = 33, depth = 37, levels = 6;
      TileSizeAlign total{};
      TileGetTextureTotalSize(test.format, width, height, depth, levels,
                              test.tile, true, total);
      const auto layout =
          TextureCalcUploadLayout(test.format, width, height, levels, depth,
                                  test.tile, total.size, true, true, name);
      const auto regions = TextureBuildImageCopies(layout);
      std::vector<GpuTileInfo> infos;
      const bool built =
          TextureBuildGpuTileInfos(total.size, regions, layout, levels, infos);
      const bool uses_z = test.family == TileBlockFamily::RenderTarget64KB ||
                          test.family == TileBlockFamily::Depth64KB;
      Require(name, "volume family infos",
              built && !infos.empty() &&
                  std::all_of(infos.begin(), infos.end(),
                              [&](const auto &info) {
                                return info.family == test.family;
                              }) &&
                  (!uses_z || std::any_of(infos.begin(), infos.end(),
                                          [](const auto &info) {
                                            return info.surface_z != 0;
                                          })),
              "volume mode selected the wrong family or lost its surface Z");
      check_round_trip("volume family", total.size, infos);
    }

    struct VolumeTailCase {
      Prospero::BufferFormat format;
      u32 bytes;
    };
    constexpr VolumeTailCase volume_tails[] = {
        {Prospero::BufferFormat::k8UNorm, 1},
        {Prospero::BufferFormat::k16UNorm, 2},
        {Prospero::BufferFormat::k32Float, 4},
        {Prospero::BufferFormat::k16_16_16_16Float, 8},
        {Prospero::BufferFormat::k32_32_32_32Float, 16},
        {Prospero::BufferFormat::kBc1UNorm, 8},
        {Prospero::BufferFormat::kBc3UNorm, 16},
    };
    constexpr u32 volume_tail_xy[5][5][2] = {
        {{0, 8}, {8, 4}, {8, 0}, {0, 4}, {0, 0}},
        {{0, 8}, {4, 4}, {4, 0}, {0, 4}, {0, 0}},
        {{0, 8}, {4, 4}, {4, 0}, {0, 4}, {0, 0}},
        {{0, 4}, {4, 2}, {4, 0}, {0, 2}, {0, 0}},
        {{0, 4}, {2, 2}, {2, 0}, {0, 2}, {0, 0}},
    };
    for (const auto &tail : volume_tails) {
      constexpr auto tile = Prospero::TileMode::kStandard4KB;
      constexpr u32 levels = 5;
      TileBlockLayout block{};
      Require(
          name, "3D tail block",
          TileGetBlockLayout(TileBlockFamily::Standard4KB3D, tail.bytes, block),
          "Standard4KB3D tail format has no block layout");
      const bool compressed =
          Prospero::BlockCompressedBytesPerBlock(tail.format) != 0;
      const u32 width = block.block_width * (compressed ? 4u : 1u);
      const u32 height = block.block_height / 2u * (compressed ? 4u : 1u);
      const u32 depth = block.block_depth + 1u;
      TileSizeAlign total{};
      TileGetTextureTotalSize(tail.format, width, height, depth, levels, tile,
                              true, total);
      const auto layout =
          TextureCalcUploadLayout(tail.format, width, height, levels, depth,
                                  tile, total.size, false, true, name);
      const auto regions = TextureBuildImageCopies(layout);
      std::vector<GpuTileInfo> infos;
      bool valid = total.size == 8192 &&
                   regions.size() == depth + std::max(depth >> 1u, 1u) +
                                         std::max(depth >> 2u, 1u) +
                                         std::max(depth >> 3u, 1u) +
                                         std::max(depth >> 4u, 1u) &&
                   TextureBuildGpuTileInfos(total.size, regions, layout, levels,
                                            infos) &&
                   infos.size() == 6;
      const u32 table = std::countr_zero(tail.bytes);
      for (u32 level = 0; level < levels && valid; level++) {
        const auto &info = infos[level == 0 ? 0 : level + 1];
        valid &= info.tail && info.tail_x == volume_tail_xy[table][level][0] &&
                 info.tail_y == volume_tail_xy[table][level][1] &&
                 info.tiled_offset == 0;
      }
      if (valid) {
        valid = infos[1].tail &&
                infos[1].tail_x == volume_tail_xy[table][0][0] &&
                infos[1].tail_y == volume_tail_xy[table][0][1] &&
                infos[1].tiled_offset == 4096;
      }
      Require(
          name, "3D mip tail infos", valid,
          "Standard4KB3D mip tail coordinates or block-slice packing changed");
      check_round_trip("3D mip tail", total.size, infos);
    }

    for (const auto family :
         {TileBlockFamily::Standard4KB, TileBlockFamily::Standard64KB,
          TileBlockFamily::Prt64KB, TileBlockFamily::RenderTarget64KB,
          TileBlockFamily::Depth64KB}) {
      for (u32 bpe = 1; bpe <= 16; bpe <<= 1u) {
        if (family == TileBlockFamily::Depth64KB && bpe == 16)
          continue;
        TileBlockLayout block{};
        Require(name, "tail layout", TileGetBlockLayout(family, bpe, block),
                "tail family/BPE has no block layout");
        const u32 width = std::max(block.block_width / 4u, 1u);
        const u32 height = std::max(block.block_height / 4u, 1u);
        const u32 x = block.block_width / 2u;
        const u32 y = block.block_height / 2u;
        const u32 pitch = width;
        const uint64_t linear_size =
            static_cast<uint64_t>(pitch) * height * bpe;
        std::vector<uint8_t> tiled(block.block_size);
        std::vector<uint8_t> cpu(linear_size, 0xcd);
        std::vector<uint8_t> gpu(linear_size, 0xab);
        fill(&tiled, ++case_index);
        GpuTileInfo info{};
        info.family = block.family;
        info.bytes_per_element = block.bytes_per_element;
        info.linear_size = linear_size;
        info.tiled_size = block.block_size;
        info.width = width;
        info.height = height;
        info.pitch = pitch;
        info.tail = true;
        info.tail_x = x;
        info.tail_y = y;
        info.surface_z = family == TileBlockFamily::RenderTarget64KB ||
                                 family == TileBlockFamily::Depth64KB
                             ? 2
                             : 0;
        convert_reference(false, &cpu, tiled, info);
        gpu_detile(tiled, &gpu, block.block_size, linear_size,
                   std::span<const GpuTileInfo>(&info, 1));
        compare("tail bytes", cpu, gpu);

        std::vector<uint8_t> linear(linear_size);
        std::vector<uint8_t> cpu_tiled(block.block_size, 0xab);
        std::vector<uint8_t> gpu_tiled(block.block_size, 0xab);
        fill(&linear, 0x400u + case_index);
        convert_reference(true, &cpu_tiled, linear, info);
        gpu_tile(linear, &gpu_tiled, block.block_size, linear_size,
                 std::span<const GpuTileInfo>(&info, 1));
        compare("tail tile bytes", cpu_tiled, gpu_tiled);
      }
    }

    TileBlockLayout small_block{};
    Require(name, "small layout",
            TileGetBlockLayout(TileBlockFamily::Standard256B, 4, small_block),
            "small fixture layout is unavailable");
    std::vector<uint8_t> small_input(small_block.block_size);
    std::vector<uint8_t> small_expected(small_block.block_size, 0);
    std::vector<uint8_t> small_output(small_block.block_size, 0xab);
    fill(&small_input, 0xee);
    GpuTileInfo small_info{};
    small_info.family = small_block.family;
    small_info.bytes_per_element = small_block.bytes_per_element;
    small_info.linear_size = small_output.size();
    small_info.tiled_size = small_input.size();
    small_info.width = 1;
    small_info.height = 1;
    small_info.pitch = small_block.block_width;
    convert_reference(false, &small_expected, small_input, small_info);
    gpu_detile(small_input, &small_output, small_input.size(),
               small_output.size(),
               std::span<const GpuTileInfo>(&small_info, 1));
    compare("small detile", small_expected, small_output);

    std::fill(small_output.begin(), small_output.end(), 0xab);
    gpu_detile(small_input, &small_output, small_input.size(),
               small_output.size(),
               std::span<const GpuTileInfo>(&small_info, 1));
    compare("scheduler-owned reuse", small_expected, small_output);

    constexpr auto volume_format = Prospero::BufferFormat::k32UInt;
    constexpr auto volume_tile = Prospero::TileMode::kLinear;
    constexpr u32 volume_width = 8, volume_height = 4, volume_depth = 5;
    constexpr u32 volume_levels = 3;
    const u32 volume_pitch =
        TileGetTexturePitch(volume_format, volume_width, volume_tile);
    TileSizeAlign volume_size{};
    TileGetTextureTotalSize(volume_format, volume_width, volume_height,
                            volume_depth, volume_levels, volume_tile, true,
                            volume_size);
    const auto volume_layout = TextureCalcUploadLayout(
        volume_format, volume_width, volume_height, volume_levels, volume_depth,
        volume_tile, volume_size.size, true, true, name);
    const auto volume_copies = TextureBuildImageCopies(volume_layout);
    std::vector<u32> volume_source(volume_size.size / sizeof(u32), 0);
    std::vector<std::pair<size_t, u32>> volume_probes;
    for (const auto &copy : volume_copies) {
      for (u32 y = 0; y < copy.imageExtent.height; y++) {
        for (u32 x = 0; x < copy.imageExtent.width; x++) {
          const auto index =
              (copy.bufferOffset +
               (static_cast<uint64_t>(y) * copy.bufferRowLength + x) *
                   sizeof(u32)) /
              sizeof(u32);
          const u32 value =
              0xa0000000u | (copy.imageSubresource.mipLevel << 24u) |
              (static_cast<u32>(copy.imageOffset.z) << 16u) | (y << 8u) | x;
          Require(name, "linear volume native bounds",
                  index < volume_source.size(),
                  "linear volume copy escaped its padded guest layout");
          volume_source[index] = value;
          volume_probes.emplace_back(static_cast<size_t>(index), value);
        }
      }
    }
    auto volume_upload =
        CreateHostBuffer(name, volume_size.size,
                         vk::BufferUsageFlagBits::eTransferSrc, volume_source);
    auto volume_download = CreateHostBuffer(
        name, volume_size.size, vk::BufferUsageFlagBits::eTransferDst,
        std::vector<u32>(volume_source.size(), 0));
    ImageInfo volume_info{};
    volume_info.data = {0x10000, volume_size.size};
    volume_info.pixel_format = vk::Format::eR32Uint;
    volume_info.guest_format = volume_format;
    volume_info.type = Prospero::ImageType::kColor3D;
    volume_info.extent = {volume_width, volume_height, volume_depth};
    volume_info.resources = {volume_levels, 1};
    volume_info.pitch = volume_pitch;
    volume_info.bytes_per_block = sizeof(u32);
    volume_info.tile_mode = volume_tile;
    for (u32 level = 0; level < volume_levels; level++) {
      volume_info.mip_layout[level] = {volume_layout.mips[level].offset,
                                       volume_layout.mips[level].size,
                                       volume_layout.mips[level].row_length,
                                       volume_layout.mips[level].image_height};
    }
    Libs::Graphics::Image volume_image(m_runtime_context, scheduler,
                                       volume_info);
    volume_image.Upload(volume_copies, volume_upload.buffer, 0,
                        volume_size.size);
    volume_image.Download(volume_copies, volume_download.buffer, 0,
                          volume_size.size);
    scheduler.Finish();
    const auto volume_observed =
        ReadBuffer(name, volume_download, volume_source.size());
    Require(name, "linear volume native content",
            std::ranges::all_of(volume_probes,
                                [&](const auto &probe) {
                                  return volume_observed[probe.first] ==
                                         probe.second;
                                }),
            "native upload/download did not preserve padded 3D mip rows");
    DestroyBuffer(&volume_download);
    DestroyBuffer(&volume_upload);
    std::printf("[gpu]     %-32s ok (%u cases, %u format/mode pairs)\n", name,
                case_index, format_cases);
  }

private:
  RenderContext &Renderer() {
    EXIT_IF(m_renderer == nullptr);
    return *m_renderer;
  }

  void EnsureRuntimeContext() {
    if (m_runtime_context.allocator != nullptr) {
      return;
    }
    namespace Exception = Common::HostException;
    Require("VulkanHarness", "guest fault handler",
            Exception::InstallHandler([](const Exception::ExceptionInfo &info) {
              if (info.type != Exception::ExceptionType::AccessViolation ||
                  (info.access_violation_type != Exception::AccessViolationType::Read &&
                   info.access_violation_type != Exception::AccessViolationType::Write)) {
                return false;
              }
              const auto access =
                  info.access_violation_type == Exception::AccessViolationType::Write
                      ? PageFaultAccess::Write : PageFaultAccess::Read;
              return LibKernel::Memory::HandleGpuFault(access, info.access_violation_vaddr);
            }),
            "failed to install the production guest-memory fault route");
    m_runtime_context.instance = m_instance;
    m_runtime_context.physical_device = m_physical_device;
    m_runtime_context.device = m_device;
    m_physical_device.getProperties(
        &m_runtime_context.physical_device_properties);
    m_runtime_context.physical_device_memory_properties = m_memory_properties;
    m_runtime_context.queue_family = m_queue_family;
    m_runtime_context.queue = m_queue;
    m_runtime_context.attachment_feedback_loop_enabled = true;
    m_runtime_context.provoking_vertex_last_enabled = true;
    const vk::PhysicalDeviceImageFormatInfo2 block_texel_view_info{
        .format = vk::Format::eBc1RgbaUnormBlock,
        .type = vk::ImageType::e2D,
        .tiling = vk::ImageTiling::eOptimal,
        .usage = vk::ImageUsageFlagBits::eSampled,
        .flags = vk::ImageCreateFlagBits::eBlockTexelViewCompatible,
    };
    const auto block_texel_view_props =
        m_physical_device.getImageFormatProperties2(block_texel_view_info);
    m_runtime_context.supports_block_texel_view =
        block_texel_view_props.result == vk::Result::eSuccess;

    VmaVulkanFunctions functions{};
    functions.vkGetInstanceProcAddr =
        VULKAN_HPP_DEFAULT_DISPATCHER.vkGetInstanceProcAddr;
    functions.vkGetDeviceProcAddr =
        VULKAN_HPP_DEFAULT_DISPATCHER.vkGetDeviceProcAddr;

    VmaAllocatorCreateInfo allocator_info{};
    allocator_info.instance = m_instance;
    allocator_info.physicalDevice = m_physical_device;
    allocator_info.device = m_device;
    allocator_info.pVulkanFunctions = &functions;
    allocator_info.vulkanApiVersion = VK_API_VERSION_1_3;
    allocator_info.flags = VMA_ALLOCATOR_CREATE_BUFFER_DEVICE_ADDRESS_BIT;
    RequireVk("VulkanHarness", "runtime context",
              static_cast<vk::Result>(vmaCreateAllocator(
                  &allocator_info, &m_runtime_context.allocator)),
              "vmaCreateAllocator");
    m_renderer = std::make_unique<RenderContext>(m_runtime_context);
  }

  void Init() {
    static vk::detail::DynamicLoader loader;
    const auto get_instance_proc_addr =
        loader.getProcAddress<PFN_vkGetInstanceProcAddr>(
            "vkGetInstanceProcAddr");
    Require("VulkanHarness", "dispatch", get_instance_proc_addr != nullptr,
            "could not load the Vulkan loader");
    VULKAN_HPP_DEFAULT_DISPATCHER.init(get_instance_proc_addr);

    vk::ApplicationInfo app{};
    app.sType = vk::StructureType::eApplicationInfo;
    app.pApplicationName = "ShaderRecompilerComputeTests";
    app.apiVersion = VK_API_VERSION_1_3;

    vk::InstanceCreateInfo instance_info{};
    instance_info.sType = vk::StructureType::eInstanceCreateInfo;
    instance_info.pApplicationInfo = &app;
    RequireVk("VulkanHarness", "dispatch",
              vk::createInstance(&instance_info, nullptr, &m_instance),
              "vkCreateInstance");
    VULKAN_HPP_DEFAULT_DISPATCHER.init(m_instance);

    u32 physical_count = 0;
    RequireVk("VulkanHarness", "dispatch",
              m_instance.enumeratePhysicalDevices(&physical_count, nullptr),
              "vkEnumeratePhysicalDevices");
    Require("VulkanHarness", "dispatch", physical_count != 0,
            "no Vulkan physical devices");
    std::vector<vk::PhysicalDevice> physical_devices(physical_count);
    RequireVk("VulkanHarness", "dispatch",
              m_instance.enumeratePhysicalDevices(&physical_count,
                                                  physical_devices.data()),
              "vkEnumeratePhysicalDevices");

    for (auto physical : physical_devices) {
      u32 queue_count = 0;
      physical.getQueueFamilyProperties(&queue_count, nullptr);
      std::vector<vk::QueueFamilyProperties> queues(queue_count);
      physical.getQueueFamilyProperties(&queue_count, queues.data());
      for (u32 i = 0; i < queue_count; i++) {
        if ((queues[i].queueFlags &
             (vk::QueueFlagBits::eCompute | vk::QueueFlagBits::eGraphics)) ==
            (vk::QueueFlagBits::eCompute | vk::QueueFlagBits::eGraphics)) {
          vk::PhysicalDeviceVulkan12Features features12{};
          features12.sType = vk::StructureType::ePhysicalDeviceVulkan12Features;
          vk::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR barycentric{};
          barycentric.sType = vk::StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
          barycentric.pNext = &features12;
          vk::PhysicalDeviceFeatures2 features{};
          features.sType = vk::StructureType::ePhysicalDeviceFeatures2;
          features.pNext = &barycentric;
          physical.getFeatures2(&features);
          if (barycentric.fragmentShaderBarycentric != true ||
              features.features.shaderInt64 != true ||
              features12.bufferDeviceAddress != true) {
            continue;
          }
          m_physical_device = physical;
          m_queue_family = i;
          break;
        }
      }
      if (m_physical_device != nullptr) {
        break;
      }
    }
    Require("VulkanHarness", "dispatch", m_physical_device != nullptr,
            "no Vulkan graphics+compute device with fragment barycentrics");
    m_physical_device.getMemoryProperties(&m_memory_properties);

    vk::PhysicalDeviceFeatures available_features{};
    m_physical_device.getFeatures(&available_features);
    vk::PhysicalDeviceVulkan12Features available_features12{};
    available_features12.sType =
        vk::StructureType::ePhysicalDeviceVulkan12Features;
    vk::PhysicalDeviceVulkan13Features available_features13{};
    available_features13.sType =
        vk::StructureType::ePhysicalDeviceVulkan13Features;
    available_features13.pNext = &available_features12;
    vk::PhysicalDeviceComputeShaderDerivativesFeaturesKHR available_derivatives{};
    available_derivatives.pNext = &available_features13;
    vk::PhysicalDeviceDepthClipEnableFeaturesEXT available_depth_clip{};
    available_depth_clip.pNext = &available_derivatives;
    vk::PhysicalDeviceDepthClipControlFeaturesEXT available_clip_control{};
    available_clip_control.pNext = &available_depth_clip;
    vk::PhysicalDeviceColorWriteEnableFeaturesEXT available_color_write{};
    available_color_write.pNext = &available_clip_control;
    vk::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT available_feedback_layout{};
    available_feedback_layout.pNext = &available_color_write;
    vk::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT available_feedback_dynamic{};
    available_feedback_dynamic.pNext = &available_feedback_layout;
    vk::PhysicalDeviceProvokingVertexFeaturesEXT available_provoking_vertex{};
    available_provoking_vertex.pNext = &available_feedback_dynamic;
    vk::PhysicalDeviceImageViewMinLodFeaturesEXT available_min_lod{};
    available_min_lod.pNext = &available_provoking_vertex;
    vk::PhysicalDeviceFeatures2 available_features2{};
    available_features2.sType = vk::StructureType::ePhysicalDeviceFeatures2;
    available_features2.pNext = &available_min_lod;
    m_physical_device.getFeatures2(&available_features2);
    Require("VulkanHarness", "dispatch",
            available_features.shaderStorageImageWriteWithoutFormat == true,
            "shaderStorageImageWriteWithoutFormat is not supported");
    Require("VulkanHarness", "dispatch",
            available_features.shaderImageGatherExtended == true &&
                available_derivatives.computeDerivativeGroupQuads == true,
            "image gather or compute derivative quads are not supported");
    Require("VulkanHarness", "dispatch",
            available_features12.timelineSemaphore == true,
            "timeline semaphores are not supported");
    Require("VulkanHarness", "dispatch",
            available_features13.dynamicRendering == true,
            "dynamic rendering is not supported");
    Require("VulkanHarness", "dispatch",
            available_features13.synchronization2 == true,
            "synchronization2 is not supported");
    Require("VulkanHarness", "dispatch",
            available_features.sampleRateShading == true,
            "sample-rate shading is not supported");
    Require("VulkanHarness", "dispatch", available_features.shaderInt64 == true,
            "shaderInt64 is not supported");
    Require("VulkanHarness", "dispatch",
            available_features12.bufferDeviceAddress == true,
            "bufferDeviceAddress is not supported");
    Require("VulkanHarness", "dispatch", available_min_lod.minLod == true,
            "image view minimum LOD is not supported");
    Require("VulkanHarness", "graphics", available_features12.shaderOutputLayer == true,
            "vertex layer output is not supported");
    Require("VulkanHarness", "graphics", available_features.fillModeNonSolid &&
                available_depth_clip.depthClipEnable && available_clip_control.depthClipControl &&
                available_color_write.colorWriteEnable &&
                available_feedback_layout.attachmentFeedbackLoopLayout &&
                available_feedback_dynamic.attachmentFeedbackLoopDynamicState &&
                available_provoking_vertex.provokingVertexLast,
            "production rasterization features are not supported");

    float priority = 1.0f;
    vk::DeviceQueueCreateInfo queue_info{};
    queue_info.sType = vk::StructureType::eDeviceQueueCreateInfo;
    queue_info.queueFamilyIndex = m_queue_family;
    queue_info.queueCount = 1;
    queue_info.pQueuePriorities = &priority;

    vk::DeviceCreateInfo device_info{};
    device_info.sType = vk::StructureType::eDeviceCreateInfo;
    device_info.queueCreateInfoCount = 1;
    device_info.pQueueCreateInfos = &queue_info;
    vk::PhysicalDeviceVulkan12Features device_features12{};
    device_features12.sType =
        vk::StructureType::ePhysicalDeviceVulkan12Features;
    device_features12.timelineSemaphore = true;
    device_features12.bufferDeviceAddress = true;
    device_features12.shaderOutputLayer = true;
    vk::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR barycentric{};
    barycentric.sType = vk::StructureType::ePhysicalDeviceFragmentShaderBarycentricFeaturesKHR;
    barycentric.pNext = &device_features12;
    barycentric.fragmentShaderBarycentric = true;
    vk::PhysicalDeviceVulkan13Features device_features13{};
    device_features13.sType =
        vk::StructureType::ePhysicalDeviceVulkan13Features;
    device_features13.pNext = &barycentric;
    device_features13.dynamicRendering = true;
    device_features13.synchronization2 = true;
    vk::PhysicalDeviceComputeShaderDerivativesFeaturesKHR derivatives{};
    derivatives.pNext = &device_features13;
    derivatives.computeDerivativeGroupQuads = true;
    vk::PhysicalDeviceDepthClipEnableFeaturesEXT depth_clip{};
    depth_clip.pNext = &derivatives;
    depth_clip.depthClipEnable = true;
    vk::PhysicalDeviceDepthClipControlFeaturesEXT clip_control{};
    clip_control.pNext = &depth_clip;
    clip_control.depthClipControl = true;
    vk::PhysicalDeviceColorWriteEnableFeaturesEXT color_write{};
    color_write.pNext = &clip_control;
    color_write.colorWriteEnable = true;
    vk::PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT feedback_layout{};
    feedback_layout.pNext = &color_write;
    feedback_layout.attachmentFeedbackLoopLayout = true;
    vk::PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT feedback_dynamic{};
    feedback_dynamic.pNext = &feedback_layout;
    feedback_dynamic.attachmentFeedbackLoopDynamicState = true;
    vk::PhysicalDeviceProvokingVertexFeaturesEXT provoking_vertex{};
    provoking_vertex.pNext = &feedback_dynamic;
    provoking_vertex.provokingVertexLast = available_provoking_vertex.provokingVertexLast;
    vk::PhysicalDeviceImageViewMinLodFeaturesEXT min_lod{};
    min_lod.pNext = &provoking_vertex;
    min_lod.minLod = true;
    device_info.pNext = &min_lod;
    vk::PhysicalDeviceFeatures device_features{};
    device_features.shaderStorageImageWriteWithoutFormat = true;
    device_features.shaderImageGatherExtended = true;
    device_features.sampleRateShading = true;
    device_features.shaderInt64 = true;
    device_features.fillModeNonSolid = true;
    device_info.pEnabledFeatures = &device_features;
    constexpr const char *device_extensions[] = {
        VK_KHR_PUSH_DESCRIPTOR_EXTENSION_NAME,
        VK_KHR_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME,
        VK_KHR_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME,
        VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME,
        VK_EXT_DEPTH_CLIP_CONTROL_EXTENSION_NAME,
        VK_EXT_COLOR_WRITE_ENABLE_EXTENSION_NAME,
        VK_EXT_ATTACHMENT_FEEDBACK_LOOP_LAYOUT_EXTENSION_NAME,
        VK_EXT_ATTACHMENT_FEEDBACK_LOOP_DYNAMIC_STATE_EXTENSION_NAME,
        VK_EXT_PROVOKING_VERTEX_EXTENSION_NAME,
        VK_EXT_IMAGE_VIEW_MIN_LOD_EXTENSION_NAME};
    device_info.enabledExtensionCount = std::size(device_extensions);
    device_info.ppEnabledExtensionNames = device_extensions;
    RequireVk("VulkanHarness", "dispatch",
              m_physical_device.createDevice(&device_info, nullptr, &m_device),
              "vkCreateDevice");
    VULKAN_HPP_DEFAULT_DISPATCHER.init(m_device);
    m_device.getQueue(m_queue_family, 0, &m_queue);

    vk::CommandPoolCreateInfo pool_info{};
    pool_info.sType = vk::StructureType::eCommandPoolCreateInfo;
    pool_info.queueFamilyIndex = m_queue_family;
    pool_info.flags = vk::CommandPoolCreateFlagBits::eResetCommandBuffer;
    RequireVk("VulkanHarness", "dispatch",
              m_device.createCommandPool(&pool_info, nullptr, &m_command_pool),
              "vkCreateCommandPool");
  }

  void Destroy() {
    if (m_device != nullptr) {
      RequireVulkanSuccess(m_device.waitIdle(), "vkDeviceWaitIdle");
      DestroyBuffer(&m_fault_buffer);
      DestroyBuffer(&m_bda_pagetable_buffer);
      if (m_runtime_context.allocator != nullptr) {
        m_renderer.reset();
        vmaDestroyAllocator(m_runtime_context.allocator);
        m_runtime_context.allocator = nullptr;
      }
      if (m_command_pool != nullptr) {
        m_device.destroyCommandPool(m_command_pool, nullptr);
      }
      m_device.destroy(nullptr);
    }
    if (m_instance != nullptr) {
      m_instance.destroy(nullptr);
    }
  }

  bool FindMemoryType(u32 type_bits, vk::MemoryPropertyFlags required,
                      u32 *index) const {
    for (u32 i = 0; i < m_memory_properties.memoryTypeCount; i++) {
      if ((type_bits & (1u << i)) == 0) {
        continue;
      }
      if ((m_memory_properties.memoryTypes[i].propertyFlags & required) ==
          required) {
        *index = i;
        return true;
      }
    }
    return false;
  }

  static vk::AccessFlags AccessForLayout(vk::ImageLayout layout) {
    switch (layout) {
    case vk::ImageLayout::eTransferDstOptimal:
      return vk::AccessFlagBits::eTransferWrite;
    case vk::ImageLayout::eTransferSrcOptimal:
      return vk::AccessFlagBits::eTransferRead;
    case vk::ImageLayout::eShaderReadOnlyOptimal:
      return vk::AccessFlagBits::eShaderRead;
    case vk::ImageLayout::eGeneral:
      return vk::AccessFlagBits::eShaderRead | vk::AccessFlagBits::eShaderWrite;
    default:
      return {};
    }
  }

  vk::ShaderModule CreateShaderModule(const char *shader_name, const std::vector<u32> &spirv) {
    vk::ShaderModuleCreateInfo info{};
    info.codeSize = spirv.size() * sizeof(u32);
    info.pCode = spirv.data();
    vk::ShaderModule module{};
    RequireVk(shader_name, "graphics", m_device.createShaderModule(&info, nullptr, &module),
              "vkCreateShaderModule");
    return module;
  }

  vk::CommandBuffer BeginCommands(const char *shader_name, const char *stage) {
    vk::CommandBufferAllocateInfo cmd_alloc{};
    cmd_alloc.sType = vk::StructureType::eCommandBufferAllocateInfo;
    cmd_alloc.commandPool = m_command_pool;
    cmd_alloc.level = vk::CommandBufferLevel::ePrimary;
    cmd_alloc.commandBufferCount = 1;
    vk::CommandBuffer cmd = nullptr;
    RequireVk(shader_name, stage,
              m_device.allocateCommandBuffers(&cmd_alloc, &cmd),
              "vkAllocateCommandBuffers");

    vk::CommandBufferBeginInfo begin{};
    begin.sType = vk::StructureType::eCommandBufferBeginInfo;
    begin.flags = vk::CommandBufferUsageFlagBits::eOneTimeSubmit;
    RequireVk(shader_name, stage, cmd.begin(&begin), "vkBeginCommandBuffer");
    return cmd;
  }

  void EndSubmitAndFree(const char *shader_name, const char *stage,
                        vk::CommandBuffer cmd) {
    RequireVk(shader_name, stage, cmd.end(), "vkEndCommandBuffer");

    vk::FenceCreateInfo fence_info{};
    fence_info.sType = vk::StructureType::eFenceCreateInfo;
    vk::Fence fence = nullptr;
    RequireVk(shader_name, stage,
              m_device.createFence(&fence_info, nullptr, &fence),
              "vkCreateFence");

    vk::SubmitInfo submit{};
    submit.sType = vk::StructureType::eSubmitInfo;
    submit.commandBufferCount = 1;
    submit.pCommandBuffers = &cmd;
    RequireVk(shader_name, stage, m_queue.submit(1, &submit, fence),
              "vkQueueSubmit");
    RequireVk(shader_name, stage,
              m_device.waitForFences(1, &fence, true, UINT64_MAX),
              "vkWaitForFences");

    m_device.destroyFence(fence, nullptr);
    m_device.freeCommandBuffers(m_command_pool, 1, &cmd);
  }

  void AddImageBarrier(vk::CommandBuffer cmd, vk::Image image,
                       vk::ImageLayout old_layout, vk::ImageLayout new_layout,
                       vk::PipelineStageFlags src_stage,
                       vk::PipelineStageFlags dst_stage,
                       vk::AccessFlags src_access, vk::AccessFlags dst_access,
                       u32 mip_levels = 1, u32 layers = 1) {
    vk::ImageMemoryBarrier barrier{};
    barrier.sType = vk::StructureType::eImageMemoryBarrier;
    barrier.srcAccessMask = src_access;
    barrier.dstAccessMask = dst_access;
    barrier.oldLayout = old_layout;
    barrier.newLayout = new_layout;
    barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
    barrier.image = image;
    barrier.subresourceRange.aspectMask = vk::ImageAspectFlagBits::eColor;
    barrier.subresourceRange.baseMipLevel = 0;
    barrier.subresourceRange.levelCount = mip_levels;
    barrier.subresourceRange.baseArrayLayer = 0;
    barrier.subresourceRange.layerCount = layers;
    cmd.pipelineBarrier(src_stage, dst_stage, {}, 0, nullptr, 0, nullptr, 1,
                        &barrier);
  }

  void TransitionImage(const char *shader_name, Image *image,
                       vk::ImageLayout new_layout,
                       vk::PipelineStageFlags src_stage,
                       vk::PipelineStageFlags dst_stage,
                       vk::AccessFlags src_access, vk::AccessFlags dst_access) {
    vk::CommandBuffer cmd = BeginCommands(shader_name, "dispatch");
    AddImageBarrier(cmd, image->image, image->layout, new_layout, src_stage,
                    dst_stage, src_access, dst_access, image->mip_levels,
                    image->layers);
    EndSubmitAndFree(shader_name, "dispatch", cmd);
    image->layout = new_layout;
  }

  void UploadImage(const char *shader_name, Image *image, vk::Buffer staging,
                   vk::ImageLayout final_layout) {
    UploadImageMips(shader_name, image, staging, final_layout);
  }

  void UploadImageMips(const char *shader_name, Image *image,
                       vk::Buffer staging, vk::ImageLayout final_layout) {
    vk::CommandBuffer cmd = BeginCommands(shader_name, "dispatch");
    AddImageBarrier(cmd, image->image, vk::ImageLayout::eUndefined,
                    vk::ImageLayout::eTransferDstOptimal,
                    vk::PipelineStageFlagBits::eTopOfPipe,
                    vk::PipelineStageFlagBits::eTransfer, {},
                    vk::AccessFlagBits::eTransferWrite, image->mip_levels,
                    image->layers);
    std::vector<vk::BufferImageCopy> copies;
    copies.reserve(image->mip_levels);
    vk::DeviceSize offset = 0;
    for (u32 level = 0; level < image->mip_levels; level++) {
      vk::BufferImageCopy copy{};
      copy.bufferOffset = offset;
      copy.imageSubresource.aspectMask = vk::ImageAspectFlagBits::eColor;
      copy.imageSubresource.mipLevel = level;
      copy.imageSubresource.baseArrayLayer = 0;
      copy.imageSubresource.layerCount = image->layers;
      copy.imageExtent.width = MipExtent(image->width, level);
      copy.imageExtent.height = MipExtent(image->height, level);
      copy.imageExtent.depth = 1;
      copies.push_back(copy);
      offset += static_cast<vk::DeviceSize>(
          ImageMipDwordCount(image->width, image->height,
                             image->dwords_per_pixel, level, image->layers) *
          sizeof(u32));
    }
    cmd.copyBufferToImage(staging, image->image,
                          vk::ImageLayout::eTransferDstOptimal,
                          static_cast<u32>(copies.size()), copies.data());
    AddImageBarrier(cmd, image->image, vk::ImageLayout::eTransferDstOptimal,
                    final_layout, vk::PipelineStageFlagBits::eTransfer,
                    vk::PipelineStageFlagBits::eComputeShader,
                    vk::AccessFlagBits::eTransferWrite,
                    AccessForLayout(final_layout), image->mip_levels,
                    image->layers);
    EndSubmitAndFree(shader_name, "dispatch", cmd);
    image->layout = final_layout;
  }

  Buffer CreateDeviceBuffer(const char *shader_name, vk::DeviceSize size,
                            vk::BufferUsageFlags usage) {
    Buffer ret;
    ret.size = size;
    vk::BufferCreateInfo buffer_info{};
    buffer_info.sType = vk::StructureType::eBufferCreateInfo;
    buffer_info.size = size;
    buffer_info.usage = usage;
    buffer_info.sharingMode = vk::SharingMode::eExclusive;
    RequireVk(shader_name, "dispatch",
              m_device.createBuffer(&buffer_info, nullptr, &ret.buffer),
              "vkCreateBuffer");

    vk::MemoryRequirements requirements{};
    m_device.getBufferMemoryRequirements(ret.buffer, &requirements);
    u32 memory_type = 0;
    Require(shader_name, "dispatch",
            FindMemoryType(requirements.memoryTypeBits,
                           vk::MemoryPropertyFlagBits::eDeviceLocal,
                           &memory_type) ||
                FindMemoryType(requirements.memoryTypeBits, {}, &memory_type),
            "no memory type for BDA support buffer");
    vk::MemoryAllocateInfo allocation{};
    allocation.sType = vk::StructureType::eMemoryAllocateInfo;
    allocation.allocationSize = requirements.size;
    allocation.memoryTypeIndex = memory_type;
    RequireVk(shader_name, "dispatch",
              m_device.allocateMemory(&allocation, nullptr, &ret.memory),
              "vkAllocateMemory");
    RequireVk(shader_name, "dispatch",
              m_device.bindBufferMemory(ret.buffer, ret.memory, 0),
              "vkBindBufferMemory");
    return ret;
  }

  void EnsureBdaBuffers(const char *shader_name) {
    if (m_bda_pagetable_buffer.buffer != nullptr) {
      return;
    }
    const auto usage = vk::BufferUsageFlagBits::eStorageBuffer |
                       vk::BufferUsageFlagBits::eTransferDst;
    m_bda_pagetable_buffer =
        CreateDeviceBuffer(shader_name, BufferCache::BDA_PAGETABLE_SIZE, usage);
    m_fault_buffer = CreateDeviceBuffer(
        shader_name, BufferCache::CACHING_NUMPAGES / 8, usage);
  }

  Buffer CreateHostBuffer(const char *shader_name, vk::DeviceSize size,
                          vk::BufferUsageFlags usage,
                          const std::vector<u32> &contents) {
    Buffer ret;
    ret.size = std::max<vk::DeviceSize>(size, sizeof(u32));

    vk::BufferCreateInfo buffer_info{};
    buffer_info.sType = vk::StructureType::eBufferCreateInfo;
    buffer_info.size = ret.size;
    buffer_info.usage = usage;
    buffer_info.sharingMode = vk::SharingMode::eExclusive;
    RequireVk(shader_name, "dispatch",
              m_device.createBuffer(&buffer_info, nullptr, &ret.buffer),
              "vkCreateBuffer");

    vk::MemoryRequirements req{};
    m_device.getBufferMemoryRequirements(ret.buffer, &req);
    u32 memory_type = 0;
    ret.coherent = FindMemoryType(req.memoryTypeBits,
                                  vk::MemoryPropertyFlagBits::eHostVisible |
                                      vk::MemoryPropertyFlagBits::eHostCoherent,
                                  &memory_type);
    if (!ret.coherent) {
      Require(shader_name, "dispatch",
              FindMemoryType(req.memoryTypeBits,
                             vk::MemoryPropertyFlagBits::eHostVisible,
                             &memory_type),
              "no host-visible memory type for staging buffer");
    }

    vk::MemoryAllocateInfo alloc{};
    alloc.sType = vk::StructureType::eMemoryAllocateInfo;
    alloc.allocationSize = req.size;
    alloc.memoryTypeIndex = memory_type;
    RequireVk(shader_name, "dispatch",
              m_device.allocateMemory(&alloc, nullptr, &ret.memory),
              "vkAllocateMemory");
    RequireVk(shader_name, "dispatch",
              m_device.bindBufferMemory(ret.buffer, ret.memory, 0),
              "vkBindBufferMemory");
    if (!contents.empty()) {
      WriteBuffer(shader_name, ret, contents);
    }
    return ret;
  }

  void WriteBuffer(const char *shader_name, const Buffer &buffer,
                   const std::vector<u32> &contents) {
    void *data = nullptr;
    RequireVk(shader_name, "dispatch",
              m_device.mapMemory(buffer.memory, 0, buffer.size, {}, &data),
              "vkMapMemory");
    std::memcpy(data, contents.data(), contents.size() * sizeof(u32));
    if (!buffer.coherent) {
      vk::MappedMemoryRange range{};
      range.sType = vk::StructureType::eMappedMemoryRange;
      range.memory = buffer.memory;
      range.offset = 0;
      range.size = VK_WHOLE_SIZE;
      RequireVk(shader_name, "dispatch",
                m_device.flushMappedMemoryRanges(1, &range),
                "vkFlushMappedMemoryRanges");
    }
    m_device.unmapMemory(buffer.memory);
  }

  vk::Instance m_instance = nullptr;
  vk::PhysicalDevice m_physical_device = nullptr;
  vk::Device m_device = nullptr;
  vk::Queue m_queue = nullptr;
  vk::CommandPool m_command_pool = nullptr;
  u32 m_queue_family = 0;
  vk::PhysicalDeviceMemoryProperties m_memory_properties{};
  Buffer m_bda_pagetable_buffer;
  Buffer m_fault_buffer;
  GraphicContext m_runtime_context{};
  std::unique_ptr<RenderContext> m_renderer;
};

void CompareWords(const TestCase &test, const char *stage,
                  const std::vector<u32> &expected,
                  const std::vector<u32> &actual) {
  if (actual == expected) {
    return;
  }
  std::ostringstream out;
  out << "expected [";
  for (size_t i = 0; i < expected.size(); i++) {
    out << (i == 0 ? "" : ", ") << Hex(expected[i]);
  }
  out << "] actual [";
  for (size_t i = 0; i < actual.size(); i++) {
    out << (i == 0 ? "" : ", ") << Hex(actual[i]);
  }
  out << "]";
  Fail(test.name, stage, out.str());
}

void CompareGraphicsWords(const GraphicsCase &test,
                          const std::vector<u32> &actual) {
  if (actual == test.expected_pixel) {
    return;
  }
  std::ostringstream out;
  out << "expected [";
  for (size_t i = 0; i < test.expected_pixel.size(); i++) {
    out << (i == 0 ? "" : ", ") << Hex(test.expected_pixel[i]);
  }
  out << "] actual [";
  for (size_t i = 0; i < actual.size(); i++) {
    out << (i == 0 ? "" : ", ") << Hex(actual[i]);
  }
  out << "]";
  Fail(test.name, "graphics readback", out.str());
}

void RunCase(VulkanHarness *vulkan, const TestCase &test) {
  auto compiled = CompileCase(test, vulkan != nullptr ? vulkan->SubgroupSize() : 64u);
  if (test.image_descriptor_swizzle != DstSel(4, 5, 6, 7) &&
      !compiled.program.info.images.empty()) {
    Require(test.name, "resource specialization",
            compiled.program.info.images[0].shader_swizzle ==
                    test.image_descriptor_swizzle,
            "storage image descriptor swizzle did not reach the specialized "
            "program");
  }
  if (test.expected_force_point_sampler) {
    Require(test.name, "sampler specialization",
            compiled.program.info.samplers.size() == 1u &&
                compiled.program.info.samplers[0].force_point_filtering,
            "bit-packed sampled image did not force point filtering");
  }
  if (test.compile_only) {
    std::printf("[compute] %-32s ok\n", test.name);
    return;
  }
  using Kind = ShaderRecompiler::IR::DescriptorBindingKind;
  auto Has = [&](Kind kind) {
    return ShaderRecompiler::IR::FindBinding(compiled.program.bindings, kind) !=
           nullptr;
  };
  const auto dwords = std::max<size_t>(
      {test.initial.size(), test.expected.size(), static_cast<size_t>(1)});
  auto buffer = vulkan->CreateStorageBuffer(
      test.name, test.initial, dwords, Has(Kind::BdaPagetable));
  VulkanHarness::Image sampled_image;
  VulkanHarness::Image storage_image;
  VulkanHarness::Image storage_image_uint;
  VulkanHarness::Buffer gds_buffer;
  vk::Sampler sampler = nullptr;
  bool needs_sampled_image = false;
  bool needs_storage_image = false;
  for (const auto &binding : compiled.program.bindings.descriptors) {
    const auto resource_class =
        ShaderRecompiler::IR::ImageBindingResourceClass(binding.kind);
    if (resource_class == ShaderRecompiler::IR::ImageResourceClass::Sampled) {
      needs_sampled_image = true;
    } else if (resource_class ==
               ShaderRecompiler::IR::ImageResourceClass::Storage) {
      needs_storage_image = true;
    }
  }
  const bool needs_sampler = Has(Kind::Samplers);
  const bool needs_gds = Has(Kind::Gds);
  if (needs_gds) {
    const auto gds_dwords = std::max<size_t>(
        {test.gds_initial.size(), test.expected_gds.size(), 1u});
    gds_buffer =
        vulkan->CreateStorageBuffer(test.name, test.gds_initial, gds_dwords);
  }
  if (needs_sampled_image) {
    auto sampled_mips = test.sampled_image_rgba_mips;
    auto sampled_format = test.sampled_image_format;
    auto sampled_dwords_per_pixel = test.sampled_image_dwords_per_pixel;
    if (!test.sampled_image_rgba_mips.empty()) {
      sampled_format = vk::Format::eR32G32B32A32Sfloat;
      sampled_dwords_per_pixel = 4;
    } else if (!test.sampled_image_rgba.empty()) {
      sampled_mips.push_back(test.sampled_image_rgba);
    }
    sampled_image = vulkan->CreateImageMips(
        test.name, test.image_width, test.image_height, sampled_format,
        vk::ImageUsageFlagBits::eSampled, sampled_mips,
        sampled_dwords_per_pixel, vk::ImageLayout::eShaderReadOnlyOptimal,
        test.sampled_image_type, test.sampled_image_view_type,
        test.sampled_image_layers, test.sampled_image_view_base_layer,
        test.sampled_image_view_layers);
  }
  if (needs_storage_image) {
    storage_image = vulkan->CreateImage2D(
        test.name, test.image_width, test.image_height,
        test.storage_image_format, vk::ImageUsageFlagBits::eStorage,
        test.storage_image_rgba, test.storage_image_dwords_per_pixel,
        vk::ImageLayout::eGeneral);
    storage_image_uint = vulkan->CreateImage2D(
        test.name, test.image_width, test.image_height, vk::Format::eR32Uint,
        vk::ImageUsageFlagBits::eStorage, test.storage_image_r32ui, 1,
        vk::ImageLayout::eGeneral);
  }
  if (needs_sampler) {
    sampler = vulkan->CreateNearestSampler(test.name, sampled_image.mip_levels);
  }

  vulkan->Dispatch(test, compiled, buffer, needs_gds ? &gds_buffer : nullptr,
                   needs_sampled_image ? &sampled_image : nullptr,
                   needs_storage_image ? &storage_image : nullptr,
                   needs_storage_image ? &storage_image_uint : nullptr,
                   sampler);
  auto actual = vulkan->ReadBuffer(test.name, buffer, test.expected.size());
  if (!test.expected_gds.empty()) {
    const auto gds_actual =
        vulkan->ReadBuffer(test.name, gds_buffer, test.expected_gds.size());
    CompareWords(test, "GDS readback", test.expected_gds, gds_actual);
  }
  if (!test.expected_storage_image_rgba.empty()) {
    auto image_actual = vulkan->ReadImage(test.name, &storage_image);
    image_actual.resize(test.expected_storage_image_rgba.size());
    CompareWords(test, "storage image readback",
                 test.expected_storage_image_rgba, image_actual);
  }
  if (!test.expected_storage_image_r32ui.empty()) {
    auto image_actual = vulkan->ReadImage(test.name, &storage_image_uint);
    image_actual.resize(test.expected_storage_image_r32ui.size());
    CompareWords(test, "uint storage image readback",
                 test.expected_storage_image_r32ui, image_actual);
  }
  if (sampler != nullptr) {
    vulkan->Device().destroySampler(sampler, nullptr);
  }
  vulkan->DestroyImage(&sampled_image);
  vulkan->DestroyImage(&storage_image);
  vulkan->DestroyImage(&storage_image_uint);
  vulkan->DestroyBuffer(&gds_buffer);
  vulkan->DestroyBuffer(&buffer);
  CompareWords(test, "readback", test.expected, actual);
  std::printf("[compute] %-32s ok\n", test.name);
}

void RunGraphicsCase(VulkanHarness *vulkan, const GraphicsCase &test) {
  auto compiled = CompileFragmentCase(test);
  auto actual = vulkan->RenderFragment(test, compiled);
  CompareGraphicsWords(test, actual);
  std::printf("[graphics] %-31s ok\n", test.name);
}

enum class CoverageClass {
  Covered,
  ControlOrMarker,
  NeedsAluCase,
  NeedsFloatCase,
  NeedsMemoryCase,
  NeedsImageCase,
  NeedsGraphicsStageCase,
};

CoverageClass ClassifyOpcode(ShaderOpcode opcode,
                             const std::set<ShaderOpcode> &covered) {
  using ShaderRecompiler::Decoder::Opcode;

  if (covered.contains(opcode)) {
    return CoverageClass::Covered;
  }

  switch (opcode) {
  case Opcode::S_GETPC_B64:
  case Opcode::S_SETPC_B64:
  case Opcode::S_NOP:
  case Opcode::S_WAITCNT:
  case Opcode::S_BARRIER:
  case Opcode::S_BRANCH:
  case Opcode::S_CBRANCH_SCC0:
  case Opcode::S_CBRANCH_SCC1:
  case Opcode::S_CBRANCH_VCCZ:
  case Opcode::S_CBRANCH_VCCNZ:
  case Opcode::S_CBRANCH_EXECZ:
  case Opcode::S_CBRANCH_EXECNZ:
  case Opcode::S_SENDMSG:
  case Opcode::S_SETREG_B32:
  case Opcode::S_SLEEP:
  case Opcode::S_TTRACEDATA:
  case Opcode::S_INST_PREFETCH:
  case Opcode::S_ENDPGM:
    return CoverageClass::ControlOrMarker;

  case Opcode::V_ADD_F32:
  case Opcode::V_SUB_F32:
  case Opcode::V_SUBREV_F32:
  case Opcode::V_MUL_F32:
  case Opcode::V_MAC_F32:
  case Opcode::V_MADMK_F32:
  case Opcode::V_MADAK_F32:
  case Opcode::V_MIN_F32:
  case Opcode::V_MAX_F32:
  case Opcode::V_MAD_F32:
  case Opcode::V_FMA_F32:
  case Opcode::V_MIN3_F32:
  case Opcode::V_MAX3_F32:
  case Opcode::V_MED3_F32:
  case Opcode::V_DOT2C_F32_F16:
  case Opcode::V_CVT_F32_I32:
  case Opcode::V_CVT_F32_U32:
  case Opcode::V_CVT_U32_F32:
  case Opcode::V_CVT_I32_F32:
  case Opcode::V_CVT_F16_F32:
  case Opcode::V_CVT_F32_F16:
  case Opcode::V_CVT_U16_F16:
  case Opcode::V_CVT_RPI_I32_F32:
  case Opcode::V_CVT_FLR_I32_F32:
  case Opcode::V_CVT_OFF_F32_I4:
  case Opcode::V_CVT_F32_UBYTE0:
  case Opcode::V_CVT_F32_UBYTE1:
  case Opcode::V_CVT_F32_UBYTE2:
  case Opcode::V_CVT_F32_UBYTE3:
  case Opcode::V_RCP_F32:
  case Opcode::V_FRACT_F32:
  case Opcode::V_TRUNC_F32:
  case Opcode::V_CEIL_F32:
  case Opcode::V_RNDNE_F32:
  case Opcode::V_FLOOR_F32:
  case Opcode::V_EXP_F32:
  case Opcode::V_LOG_F32:
  case Opcode::V_RSQ_F32:
  case Opcode::V_SQRT_F32:
  case Opcode::V_SIN_F32:
  case Opcode::V_COS_F32:
  case Opcode::V_CUBEID_F32:
  case Opcode::V_CUBESC_F32:
  case Opcode::V_CUBETC_F32:
  case Opcode::V_CUBEMA_F32:
  case Opcode::V_LDEXP_F32:
  case Opcode::V_CVT_PK_U8_F32:
  case Opcode::V_CVT_PKNORM_I16_F32:
  case Opcode::V_CVT_PKNORM_U16_F32:
  case Opcode::V_CVT_PKRTZ_F16_F32:
  case Opcode::V_PK_ADD_F16:
  case Opcode::V_PK_MUL_F16:
  case Opcode::V_PK_MIN_F16:
  case Opcode::V_PK_MAX_F16:
  case Opcode::V_PK_FMA_F16:
  case Opcode::V_ADD_F16:
  case Opcode::V_SUB_F16:
  case Opcode::V_SUBREV_F16:
  case Opcode::V_MUL_F16:
  case Opcode::V_MAX_F16:
  case Opcode::V_MIN_F16:
  case Opcode::V_MIN3_F16:
  case Opcode::V_MAX3_F16:
  case Opcode::V_MED3_F16:
  case Opcode::V_RCP_F16:
  case Opcode::V_RSQ_F16:
  case Opcode::V_LOG_F16:
  case Opcode::V_EXP_F16:
  case Opcode::V_SIN_F16:
  case Opcode::V_COS_F16:
  case Opcode::V_MAD_MIXLO_F16:
  case Opcode::V_MAD_MIXHI_F16:
  case Opcode::DS_MIN_F32:
  case Opcode::DS_MAX_F32:
  case Opcode::V_CMP_F_F32:
  case Opcode::V_CMP_LT_F32:
  case Opcode::V_CMP_EQ_F32:
  case Opcode::V_CMP_LE_F32:
  case Opcode::V_CMP_GT_F32:
  case Opcode::V_CMP_LG_F32:
  case Opcode::V_CMP_GE_F32:
  case Opcode::V_CMP_O_F32:
  case Opcode::V_CMP_U_F32:
  case Opcode::V_CMP_NGE_F32:
  case Opcode::V_CMP_NLG_F32:
  case Opcode::V_CMP_NGT_F32:
  case Opcode::V_CMP_NLE_F32:
  case Opcode::V_CMP_NEQ_F32:
  case Opcode::V_CMP_NLT_F32:
  case Opcode::V_CMP_TRU_F32:
  case Opcode::V_CMPX_LT_F32:
  case Opcode::V_CMPX_EQ_F32:
  case Opcode::V_CMPX_LE_F32:
  case Opcode::V_CMPX_GT_F32:
  case Opcode::V_CMPX_LG_F32:
  case Opcode::V_CMPX_GE_F32:
  case Opcode::V_CMPX_NGE_F32:
  case Opcode::V_CMPX_NLG_F32:
  case Opcode::V_CMPX_NGT_F32:
  case Opcode::V_CMPX_NLE_F32:
  case Opcode::V_CMPX_NEQ_F32:
  case Opcode::V_CMPX_NLT_F32:
  case Opcode::V_CMP_CLASS_F32:
  case Opcode::V_CMPX_CLASS_F32:
  case Opcode::V_CMP_LT_F16:
  case Opcode::V_CMP_EQ_F16:
  case Opcode::V_CMP_LE_F16:
  case Opcode::V_CMP_GT_F16:
  case Opcode::V_CMP_LG_F16:
  case Opcode::V_CMP_GE_F16:
  case Opcode::V_CMP_NGT_F16:
  case Opcode::V_CMP_NEQ_F16:
  case Opcode::V_CMP_NLT_F16:
  case Opcode::V_CMPX_LT_F16:
  case Opcode::V_CMPX_EQ_F16:
  case Opcode::V_CMPX_LE_F16:
  case Opcode::V_CMPX_GT_F16:
  case Opcode::V_CMPX_GE_F16:
  case Opcode::V_CMPX_NEQ_F16:
  case Opcode::V_CMPX_NLT_F16:
    return CoverageClass::NeedsFloatCase;

  case Opcode::S_LOAD_DWORD:
  case Opcode::S_LOAD_DWORDX2:
  case Opcode::S_LOAD_DWORDX4:
  case Opcode::S_LOAD_DWORDX8:
  case Opcode::S_LOAD_DWORDX16:
  case Opcode::S_BUFFER_LOAD_DWORD:
  case Opcode::S_BUFFER_LOAD_DWORDX2:
  case Opcode::S_BUFFER_LOAD_DWORDX4:
  case Opcode::S_BUFFER_LOAD_DWORDX8:
  case Opcode::S_BUFFER_LOAD_DWORDX16:
  case Opcode::BUFFER_LOAD_FORMAT_X:
  case Opcode::BUFFER_LOAD_FORMAT_XY:
  case Opcode::BUFFER_LOAD_FORMAT_XYZ:
  case Opcode::BUFFER_LOAD_FORMAT_XYZW:
  case Opcode::BUFFER_STORE_FORMAT_X:
  case Opcode::BUFFER_STORE_FORMAT_XY:
  case Opcode::BUFFER_STORE_FORMAT_XYZ:
  case Opcode::BUFFER_STORE_FORMAT_XYZW:
  case Opcode::BUFFER_LOAD_UBYTE:
  case Opcode::BUFFER_LOAD_SBYTE:
  case Opcode::BUFFER_LOAD_USHORT:
  case Opcode::BUFFER_LOAD_SSHORT:
  case Opcode::BUFFER_LOAD_DWORDX2:
  case Opcode::BUFFER_LOAD_DWORDX3:
  case Opcode::BUFFER_LOAD_DWORDX4:
  case Opcode::BUFFER_STORE_BYTE:
  case Opcode::BUFFER_STORE_SHORT:
  case Opcode::BUFFER_STORE_DWORDX2:
  case Opcode::BUFFER_STORE_DWORDX3:
  case Opcode::BUFFER_STORE_DWORDX4:
  case Opcode::TBUFFER_LOAD_FORMAT_X:
  case Opcode::TBUFFER_LOAD_FORMAT_XY:
  case Opcode::TBUFFER_LOAD_FORMAT_XYZ:
  case Opcode::TBUFFER_LOAD_FORMAT_XYZW:
  case Opcode::TBUFFER_STORE_FORMAT_X:
  case Opcode::TBUFFER_STORE_FORMAT_XY:
  case Opcode::TBUFFER_STORE_FORMAT_XYZ:
  case Opcode::TBUFFER_STORE_FORMAT_XYZW:
  case Opcode::BUFFER_ATOMIC_SWAP:
  case Opcode::BUFFER_ATOMIC_CMPSWAP:
  case Opcode::BUFFER_ATOMIC_ADD:
  case Opcode::BUFFER_ATOMIC_SUB:
  case Opcode::BUFFER_ATOMIC_SMIN:
  case Opcode::BUFFER_ATOMIC_UMIN:
  case Opcode::BUFFER_ATOMIC_SMAX:
  case Opcode::BUFFER_ATOMIC_UMAX:
  case Opcode::BUFFER_ATOMIC_AND:
  case Opcode::BUFFER_ATOMIC_OR:
  case Opcode::BUFFER_ATOMIC_XOR:
  case Opcode::BUFFER_ATOMIC_FMIN:
  case Opcode::BUFFER_ATOMIC_FMAX:
  case Opcode::FLAT_LOAD_UBYTE:
  case Opcode::FLAT_LOAD_SBYTE:
  case Opcode::FLAT_LOAD_USHORT:
  case Opcode::FLAT_LOAD_SSHORT:
  case Opcode::FLAT_LOAD_DWORD:
  case Opcode::FLAT_LOAD_DWORDX2:
  case Opcode::FLAT_LOAD_DWORDX3:
  case Opcode::FLAT_LOAD_DWORDX4:
  case Opcode::FLAT_STORE_BYTE:
  case Opcode::FLAT_STORE_SHORT:
  case Opcode::FLAT_STORE_DWORD:
  case Opcode::FLAT_STORE_DWORDX2:
  case Opcode::FLAT_STORE_DWORDX3:
  case Opcode::FLAT_STORE_DWORDX4:
  case Opcode::DS_ADD_U32:
  case Opcode::DS_ADD_RTN_U32:
  case Opcode::DS_SUB_U32:
  case Opcode::DS_SUB_RTN_U32:
  case Opcode::DS_INC_RTN_U32:
  case Opcode::DS_DEC_RTN_U32:
  case Opcode::DS_MIN_I32:
  case Opcode::DS_MIN_RTN_I32:
  case Opcode::DS_MAX_I32:
  case Opcode::DS_MAX_RTN_I32:
  case Opcode::DS_MIN_U32:
  case Opcode::DS_MIN_RTN_U32:
  case Opcode::DS_MAX_U32:
  case Opcode::DS_MAX_RTN_U32:
  case Opcode::DS_AND_B32:
  case Opcode::DS_AND_RTN_B32:
  case Opcode::DS_OR_B32:
  case Opcode::DS_OR_RTN_B32:
  case Opcode::DS_XOR_B32:
  case Opcode::DS_XOR_RTN_B32:
  case Opcode::DS_WRXCHG_RTN_B32:
  case Opcode::DS_SWIZZLE_B32:
  case Opcode::DS_BPERMUTE_B32:
  case Opcode::DS_READ_I8:
  case Opcode::DS_READ_U8:
  case Opcode::DS_READ_I16:
  case Opcode::DS_READ_U16:
  case Opcode::DS_READ_U16_D16:
  case Opcode::DS_READ_U16_D16_HI:
  case Opcode::DS_READ2_B32:
  case Opcode::DS_READ_B32:
  case Opcode::DS_READ_B64:
  case Opcode::DS_READ2_B64:
  case Opcode::DS_READ_B96:
  case Opcode::DS_READ_B128:
  case Opcode::DS_WRITE_B8:
  case Opcode::DS_WRITE_B16:
  case Opcode::DS_WRITE_B16_D16_HI:
  case Opcode::DS_WRITE2_B32:
  case Opcode::DS_WRITE2ST64_B32:
  case Opcode::DS_WRITE_B32:
  case Opcode::DS_WRITE_B64:
  case Opcode::DS_WRITE_B96:
  case Opcode::DS_WRITE_B128:
  case Opcode::DS_WRITE_ADDTID_B32:
  case Opcode::DS_READ_ADDTID_B32:
    return CoverageClass::NeedsMemoryCase;

  case Opcode::IMAGE_GET_RESINFO:
  case Opcode::IMAGE_GET_LOD:
  case Opcode::IMAGE_LOAD:
  case Opcode::IMAGE_LOAD_MIP:
  case Opcode::IMAGE_STORE:
  case Opcode::IMAGE_STORE_MIP:
  case Opcode::IMAGE_ATOMIC_SWAP:
  case Opcode::IMAGE_ATOMIC_ADD:
  case Opcode::IMAGE_ATOMIC_UMIN:
  case Opcode::IMAGE_ATOMIC_AND:
  case Opcode::IMAGE_ATOMIC_OR:
  case Opcode::IMAGE_ATOMIC_XOR:
  case Opcode::IMAGE_SAMPLE:
  case Opcode::IMAGE_GATHER4_LZ:
  case Opcode::IMAGE_GATHER4_C:
  case Opcode::IMAGE_GATHER4_C_LZ:
  case Opcode::IMAGE_GATHER4_LZ_O:
  case Opcode::IMAGE_GATHER4_C_O:
  case Opcode::IMAGE_GATHER4_C_LZ_O:
    return CoverageClass::NeedsImageCase;

  case Opcode::V_INTERP_P1_F32:
  case Opcode::V_INTERP_P2_F32:
  case Opcode::V_INTERP_MOV_F32:
  case Opcode::EXP:
    return CoverageClass::NeedsGraphicsStageCase;

  default:
    return CoverageClass::NeedsAluCase;
  }
}

const char *CoverageClassName(CoverageClass status) {
  switch (status) {
  case CoverageClass::Covered:
    return "covered";
  case CoverageClass::ControlOrMarker:
    return "control";
  case CoverageClass::NeedsAluCase:
    return "alu";
  case CoverageClass::NeedsFloatCase:
    return "float";
  case CoverageClass::NeedsMemoryCase:
    return "memory";
  case CoverageClass::NeedsImageCase:
    return "image";
  case CoverageClass::NeedsGraphicsStageCase:
    return "graphics";
  default:
    return "unknown";
  }
}

void PrintPendingOpcodes(CoverageClass status,
                         const std::vector<ShaderOpcode> &opcodes) {
  if (opcodes.empty()) {
    return;
  }

  std::printf("[coverage] pending_%s:", CoverageClassName(status));
  for (auto opcode : opcodes) {
    const auto name = magic_enum::enum_name(opcode);
    std::printf(" %.*s", static_cast<int>(name.size()), name.data());
  }
  std::printf("\n");
}

void CheckOpcodeCoverage(const std::vector<TestCase> &tests,
                         const std::vector<GraphicsCase> &graphics_tests) {
  using ShaderRecompiler::Decoder::Opcode;

  std::set<Opcode> covered;
  for (const auto &test : tests) {
    for (auto opcode : test.opcodes) {
      covered.insert(opcode);
    }
  }
  for (const auto &test : graphics_tests) {
    for (auto opcode : test.opcodes) {
      covered.insert(opcode);
    }
  }

  uint32_t counts[7] = {};
  std::vector<ShaderOpcode> pending[7];
  for (auto value = static_cast<int>(Opcode::S_MOV_B32);
       value < static_cast<int>(Opcode::COUNT); value++) {
    const auto opcode = static_cast<Opcode>(value);
    const auto status = ClassifyOpcode(opcode, covered);
    counts[static_cast<uint32_t>(status)]++;
    if (status != CoverageClass::Covered &&
        status != CoverageClass::ControlOrMarker) {
      pending[static_cast<uint32_t>(status)].push_back(opcode);
    }
  }

  std::printf(
      "[coverage] decoder opcodes: covered=%u control=%u alu_pending=%u "
      "float_pending=%u memory_pending=%u image_pending=%u "
      "graphics_pending=%u\n",
      counts[static_cast<uint32_t>(CoverageClass::Covered)],
      counts[static_cast<uint32_t>(CoverageClass::ControlOrMarker)],
      counts[static_cast<uint32_t>(CoverageClass::NeedsAluCase)],
      counts[static_cast<uint32_t>(CoverageClass::NeedsFloatCase)],
      counts[static_cast<uint32_t>(CoverageClass::NeedsMemoryCase)],
      counts[static_cast<uint32_t>(CoverageClass::NeedsImageCase)],
      counts[static_cast<uint32_t>(CoverageClass::NeedsGraphicsStageCase)]);
  PrintPendingOpcodes(
      CoverageClass::NeedsAluCase,
      pending[static_cast<uint32_t>(CoverageClass::NeedsAluCase)]);
  PrintPendingOpcodes(
      CoverageClass::NeedsFloatCase,
      pending[static_cast<uint32_t>(CoverageClass::NeedsFloatCase)]);
  PrintPendingOpcodes(
      CoverageClass::NeedsMemoryCase,
      pending[static_cast<uint32_t>(CoverageClass::NeedsMemoryCase)]);
  PrintPendingOpcodes(
      CoverageClass::NeedsImageCase,
      pending[static_cast<uint32_t>(CoverageClass::NeedsImageCase)]);
  PrintPendingOpcodes(
      CoverageClass::NeedsGraphicsStageCase,
      pending[static_cast<uint32_t>(CoverageClass::NeedsGraphicsStageCase)]);
}

TestCase IntegerAddSubMul() {
  using O = ShaderOpcode;

  std::vector<u32> code = {
      EncodeSMovB32(0, InlineU32(7)),
      EncodeSMovB32(1, InlineU32(3)),
      EncodeSop2(0x00, 2, 0, 1),
      EncodeSop2(0x01, 3, 2, InlineU32(1)),
      EncodeSop2(0x26, 4, 3, InlineU32(2)),
      EncodeVop1(0x01, 0, 4),
  };
  AppendBufferStoreDword(&code, 0, 30);
  AppendEnd(&code);
  return {"IntegerAddSubMul",
          code,
          {},
          {18},
          {O::S_MOV_B32, O::S_ADD_U32, O::S_SUB_U32, O::S_MUL_I32, O::V_MOV_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase BitwiseOps() {
  using O = ShaderOpcode;

  std::vector<u32> code = {
      EncodeSMovB32(0, InlineU32(60)), EncodeSMovB32(1, InlineU32(15)),
      EncodeSop2(0x0e, 2, 0, 1),       EncodeSop2(0x10, 3, 0, 1),
      EncodeSop2(0x12, 4, 3, 2),       EncodeVop1(0x37, 0, 4),
  };
  AppendBufferStoreDword(&code, 0, 30);
  AppendEnd(&code);
  return {"BitwiseAndOrXorNot",
          code,
          {},
          {~0x33u},
          {O::S_MOV_B32, O::S_AND_B32, O::S_OR_B32, O::S_XOR_B32, O::V_NOT_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase Shifts() {
  using O = ShaderOpcode;

  std::vector<u32> code = {
      EncodeSMovB32(0, InlineU32(3)),
      EncodeSop2(0x1e, 1, 0, InlineU32(2)),
      EncodeSop2(0x20, 2, 1, InlineU32(1)),
      EncodeVop1(0x01, 0, 2),
  };
  AppendBufferStoreDword(&code, 0, 30);
  AppendEnd(&code);
  return {"Shifts",
          code,
          {},
          {6},
          {O::S_MOV_B32, O::S_LSHL_B32, O::S_LSHR_B32, O::V_MOV_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ExactPushConstantExtent() {
  using O = ShaderOpcode;

  constexpr std::array<u32, 10> values{
      0x10203040u, 0x21314151u, 0x32425262u, 0x43536373u, 0x54647484u,
      0x65758595u, 0x768696a6u, 0x8797a7b7u, 0x98a8b8c8u, 0xa9b9c9d9u};
  std::vector<u32> code;
  for (u32 i = 0; i < values.size(); i++) {
    AppendStoreSgpr(&code, 4u + i, i);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "ExactPushConstantExtent";
  test.code = std::move(code);
  test.initial.resize(values.size());
  test.expected.assign(values.begin(), values.end());
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.user_data =
      MakeStructuredStorageBufferData(0, values.size() * sizeof(u32));
  std::copy(values.begin(), values.end(), test.user_data.begin() + 4);
  test.has_user_data = true;
  return test;
}

TestCase ScalarShiftCountsMaskLowBits() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeSMovB32(0, InlineU32(1)));
  AppendSMovLiteral(&code, 1, 0x80000000u);
  code.push_back(EncodeSMovB32(2, InlineU32(32)));
  code.push_back(EncodeSMovB32(3, InlineU32(33)));
  code.push_back(EncodeSop2(0x1e, 10, 0, 2));
  code.push_back(EncodeSop2(0x1e, 11, 0, 3));
  code.push_back(EncodeSop2(0x20, 12, 1, 2));
  code.push_back(EncodeSop2(0x20, 13, 1, 3));
  code.push_back(EncodeSop2(0x22, 14, 1, 2));
  code.push_back(EncodeSop2(0x22, 15, 1, 3));

  for (u32 i = 0; i < 6u; i++) {
    AppendStoreSgpr(&code, 10u + i, i);
  }
  AppendEnd(&code);

  return {"ScalarShiftCountsMaskLowBits",
          code,
          {},
          {1, 2, 0x80000000u, 0x40000000u, 0x80000000u, 0xc0000000u},
          {O::S_MOV_B32, O::S_LSHL_B32, O::S_LSHR_B32, O::S_ASHR_I32,
           O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase Rdna2ScalarOpcodes() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeSMovB32(2, InlineU32(7)));
  code.push_back(EncodeSMovB32(106, InlineU32(16)));
  code.push_back(EncodeSop1(0x1d, 106, InlineU32(0)));
  AppendStoreSgpr(&code, 106, 0);
  code.push_back(EncodeSopk(0x13, 106, 0x1019u));
  AppendStoreSgpr(&code, 106, 1);
  code.push_back(EncodeSop2(0x02, 106, 2, 239u));
  AppendStoreSgpr(&code, 106, 2);
  code.push_back(EncodeSopp(0x0e, 0));
  code.push_back(EncodeSop2(0x02, 106, 239u, 2));
  AppendStoreSgpr(&code, 106, 3);
  AppendEnd(&code);

  return {"Rdna2ScalarOpcodes",
          code,
          {},
          {0x11u, 0x11u, 7u, 7u},
          {O::S_MOV_B32, O::S_BITSET1_B32, O::S_SETREG_B32, O::S_ADD_I32,
           O::S_SLEEP, O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarTrapDisabledFallsThroughExactRaw() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 0, 7);
  code.push_back(0xbf920001u); // s_trap 1 from the game shader
  AppendVMovU32(&code, 0, 42);
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "ScalarTrapDisabledFallsThroughExactRaw";
  test.code = code;
  test.expected = {42};
  test.opcodes = {O::V_MOV_B32, O::S_TRAP, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"S_TRAP 0x00000001", 1}};
  test.compute_info.threads_num[0] = 1;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.wave_size = 32;
  test.has_compute_info = true;
  return test;
}

TestCase ScalarWaitcntDepctrCapturedVmVsrc() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 7, 7);
  AppendVMovU32(&code, 31, 0);
  AppendBufferStoreDword(&code, 7, 31);
  code.push_back(0xbfa3ffe3u); // s_waitcnt_depctr vm_vsrc(0)
  AppendVMovU32(&code, 7, 42);
  AppendStoreVgpr(&code, 7, 1);
  AppendEnd(&code);

  TestCase test;
  test.name = "ScalarWaitcntDepctrCapturedVmVsrc";
  test.code = std::move(code);
  test.initial = {0, 0};
  test.expected = {7, 42};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_WAITCNT_DEPCTR,
                  O::S_ENDPGM};
  test.decoded_counts = {{"0x00000010: S_WAITCNT_DEPCTR 0x0000ffe3\n", 1}};
  test.forbidden_spirv = {"OpControlBarrier", "OpMemoryBarrier"};
  return test;
}

TestCase ScalarExtendedArithmetic() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendSMovLiteral(&code, 0, 0xffffffffu);
  code.push_back(EncodeSMovB32(1, InlineU32(1)));
  code.push_back(EncodeSop2(0x00, 2, 0, 1));
  code.push_back(EncodeSMovB32(3, InlineU32(5)));
  code.push_back(EncodeSMovB32(4, InlineU32(6)));
  code.push_back(EncodeSop2(0x04, 5, 3, 4));
  code.push_back(EncodeSop2(0x02, 6, InlineU32(7), InlineU32(8)));
  code.push_back(EncodeSop2(0x03, 7, InlineU32(7), InlineU32(9)));
  AppendSMovLiteral(&code, 8, 0xfffffffbu);
  code.push_back(EncodeSMovB32(9, InlineU32(3)));
  code.push_back(EncodeSop2(0x06, 10, 8, 9));
  code.push_back(EncodeSop2(0x08, 11, 8, 9));
  AppendSMovLiteral(&code, 12, 0xfffffffeu);
  code.push_back(EncodeSMovB32(13, InlineU32(3)));
  code.push_back(EncodeSop2(0x07, 14, 12, 13));
  code.push_back(EncodeSop2(0x09, 15, 12, 13));
  code.push_back(EncodeSMovB32(16, 8));
  code.push_back(EncodeSop1(0x34, 16, 16));
  code.push_back(EncodeSopk(0x00, 17, 0xfff5u));
  code.push_back(EncodeSopk(0x10, 17, 0xfffdu));

  const u32 results[] = {2, 5, 6, 7, 10, 11, 14, 15, 16, 17};
  for (u32 i = 0; i < static_cast<u32>(std::size(results)); i++) {
    AppendStoreSgpr(&code, results[i], i);
  }
  AppendEnd(&code);

  return {"ScalarExtendedArithmetic",
          code,
          {},
          {0, 12, 15, 0xfffffffeu, 0xfffffffbu, 3, 3, 0xfffffffeu, 5, 33},
          {O::S_MOV_B32, O::S_ADD_U32, O::S_ADDC_U32, O::S_ADD_I32,
           O::S_SUB_I32, O::S_MIN_I32, O::S_MAX_I32, O::S_MIN_U32, O::S_MAX_U32,
           O::S_ABS_I32, O::S_MOVK_I32, O::S_MULK_I32, O::V_MOV_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarArithmeticSccCarryBorrowOverflow() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  auto set_scc = [&](bool value) {
    code.push_back(EncodeSopc(0x06, InlineU32(1), InlineU32(value ? 1u : 0u)));
  };
  auto capture_scc = [&](u32 dst_sgpr) {
    code.push_back(EncodeSop2(0x0a, dst_sgpr, InlineU32(1), InlineU32(0)));
  };
  auto append_case = [&](bool prior_scc, u32 instruction, u32 out_sgpr) {
    set_scc(prior_scc);
    code.push_back(instruction);
    capture_scc(out_sgpr);
  };

  code.push_back(EncodeSMovB32(0, InlineU32(0)));
  code.push_back(EncodeSMovB32(1, InlineU32(1)));
  append_case(false, EncodeSop2(0x01, 10, 0, 1), 20);

  code.push_back(EncodeSMovB32(2, InlineU32(5)));
  code.push_back(EncodeSMovB32(3, InlineU32(3)));
  append_case(true, EncodeSop2(0x01, 11, 2, 3), 21);

  AppendSMovLiteral(&code, 4, 0x7fffffffu);
  code.push_back(EncodeSMovB32(5, InlineU32(1)));
  append_case(false, EncodeSop2(0x02, 12, 4, 5), 22);

  code.push_back(EncodeSMovB32(6, InlineU32(1)));
  code.push_back(EncodeSMovB32(7, InlineU32(2)));
  append_case(true, EncodeSop2(0x02, 13, 6, 7), 23);

  AppendSMovLiteral(&code, 8, 0x80000000u);
  code.push_back(EncodeSMovB32(9, InlineU32(1)));
  append_case(false, EncodeSop2(0x03, 14, 8, 9), 24);

  code.push_back(EncodeSMovB32(15, InlineU32(5)));
  code.push_back(EncodeSMovB32(16, InlineU32(3)));
  append_case(true, EncodeSop2(0x03, 17, 15, 16), 25);

  AppendSMovLiteral(&code, 18, 0x7fffffffu);
  set_scc(false);
  code.push_back(EncodeSopk(0x0f, 18, 1));
  capture_scc(26);

  code.push_back(EncodeSMovB32(19, InlineU32(4)));
  set_scc(true);
  code.push_back(EncodeSopk(0x0f, 19, 0xfffeu));
  capture_scc(27);

  for (u32 i = 0; i < 8u; i++) {
    AppendStoreSgpr(&code, 20u + i, i);
  }
  AppendEnd(&code);

  return {"ScalarArithmeticSccCarryBorrowOverflow",
          code,
          {},
          {1, 0, 1, 0, 1, 0, 1, 0},
          {O::S_MOV_B32, O::S_SUB_U32, O::S_ADD_I32, O::S_SUB_I32,
           O::S_CMP_EQ_U32, O::S_CSELECT_B32, O::V_MOV_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarMinMaxSccComparisonEdges() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  auto set_scc = [&](bool value) {
    code.push_back(EncodeSopc(0x06, InlineU32(1), InlineU32(value ? 1u : 0u)));
  };
  auto capture_scc = [&](u32 dst_sgpr) {
    code.push_back(EncodeSop2(0x0a, dst_sgpr, InlineU32(1), InlineU32(0)));
  };
  auto append_case = [&](bool prior_scc, u32 instruction, u32 out_sgpr) {
    set_scc(prior_scc);
    code.push_back(instruction);
    capture_scc(out_sgpr);
  };

  AppendSMovLiteral(&code, 0, 0xfffffffeu);
  code.push_back(EncodeSMovB32(1, InlineU32(3)));
  append_case(false, EncodeSop2(0x06, 10, 0, 1), 20);
  append_case(true, EncodeSop2(0x06, 11, 1, 0), 21);
  append_case(false, EncodeSop2(0x08, 12, 1, 0), 22);
  append_case(true, EncodeSop2(0x08, 13, 0, 1), 23);

  code.push_back(EncodeSMovB32(2, InlineU32(2)));
  code.push_back(EncodeSMovB32(3, InlineU32(3)));
  append_case(false, EncodeSop2(0x07, 14, 2, 3), 24);
  append_case(true, EncodeSop2(0x07, 15, 3, 2), 25);
  append_case(false, EncodeSop2(0x09, 16, 3, 2), 26);
  append_case(true, EncodeSop2(0x09, 17, 2, 3), 27);

  for (u32 i = 0; i < 8u; i++) {
    AppendStoreSgpr(&code, 20u + i, i);
  }
  AppendEnd(&code);

  return {"ScalarMinMaxSccComparisonEdges",
          code,
          {},
          {1, 0, 1, 0, 1, 0, 1, 0},
          {O::S_MOV_B32, O::S_MIN_I32, O::S_MAX_I32, O::S_MIN_U32, O::S_MAX_U32,
           O::S_CMP_EQ_U32, O::S_CSELECT_B32, O::V_MOV_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarAbsI32UpdatesScc() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  auto set_scc = [&](bool value) {
    code.push_back(EncodeSopc(0x06, InlineU32(1), InlineU32(value ? 1u : 0u)));
  };
  auto capture_scc = [&](u32 dst_sgpr) {
    code.push_back(EncodeSop2(0x0a, dst_sgpr, InlineU32(1), InlineU32(0)));
  };

  code.push_back(EncodeSMovB32(0, InlineU32(0)));
  set_scc(true);
  code.push_back(EncodeSop1(0x34, 1, 0));
  capture_scc(2);

  AppendSMovLiteral(&code, 3, 0xfffffffbu);
  set_scc(false);
  code.push_back(EncodeSop1(0x34, 4, 3));
  capture_scc(5);

  AppendStoreSgpr(&code, 1, 0);
  AppendStoreSgpr(&code, 2, 1);
  AppendStoreSgpr(&code, 4, 2);
  AppendStoreSgpr(&code, 5, 3);
  AppendEnd(&code);

  return {"ScalarAbsI32UpdatesScc",
          code,
          {},
          {0, 0, 5, 1},
          {O::S_MOV_B32, O::S_CMP_EQ_U32, O::S_ABS_I32, O::S_CSELECT_B32,
           O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarAbsdiffBitset64AndSetprio() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  auto capture_scc = [&](u32 dst_sgpr) {
    code.push_back(
        EncodeSop2(0x0a, dst_sgpr, InlineU32(1), InlineU32(0)));
  };

  code.push_back(EncodeSMovB32(0, InlineU32(2)));
  code.push_back(EncodeSMovB32(1, InlineU32(5)));
  code.push_back(EncodeSop2(0x2c, 10, 0, 1));
  capture_scc(20);
  AppendSMovLiteral(&code, 0, 0xffffffffu);
  code.push_back(EncodeSMovB32(1, InlineU32(0)));
  code.push_back(EncodeSop2(0x2c, 11, 0, 1));
  capture_scc(21);
  AppendSMovLiteral(&code, 0, 0x80000000u);
  code.push_back(EncodeSop2(0x2c, 12, 0, 1));
  capture_scc(22);
  code.push_back(EncodeSMovB32(1, InlineU32(1)));
  code.push_back(EncodeSop2(0x2c, 13, 0, 1));
  capture_scc(23);
  code.push_back(EncodeSop2(0x2c, 14, 0, 0));
  capture_scc(24);

  AppendSMovLiteral(&code, 2, 65u);
  AppendSMovLiteral(&code, 3, 101u);
  code.push_back(EncodeSMovB32(4, InlineU32(0)));
  code.push_back(EncodeSMovB32(5, InlineU32(0)));
  code.push_back(EncodeSop1(0x1e, 4, 2));
  AppendStoreSgprPair(&code, 4, 10);
  code.push_back(EncodeSop1(0x1e, 4, 3));
  AppendStoreSgprPair(&code, 4, 12);
  code.push_back(EncodeSop1(0x1c, 4, 2));
  AppendStoreSgprPair(&code, 4, 14);
  code.push_back(EncodeSop1(0x1c, 4, 3));
  AppendStoreSgprPair(&code, 4, 16);
  code.push_back(EncodeSopp(0x0f, 3));

  AppendStoreSgpr(&code, 10, 0);
  AppendStoreSgpr(&code, 11, 1);
  AppendStoreSgpr(&code, 12, 2);
  AppendStoreSgpr(&code, 13, 3);
  AppendStoreSgpr(&code, 14, 4);
  AppendStoreSgpr(&code, 20, 5);
  AppendStoreSgpr(&code, 21, 6);
  AppendStoreSgpr(&code, 22, 7);
  AppendStoreSgpr(&code, 23, 8);
  AppendStoreSgpr(&code, 24, 9);
  AppendEnd(&code);

  TestCase test;
  test.name = "ScalarAbsdiffBitset64AndSetprio";
  test.code = std::move(code);
  test.expected = {3u, 1u, 0x80000000u, 0x7fffffffu, 0u,
                   1u, 1u, 1u,          1u,          0u,
                   2u, 0u, 2u,          32u,         0u,
                   32u, 0u, 0u};
  test.opcodes = {O::S_MOV_B32,     O::S_ABSDIFF_I32, O::S_CSELECT_B32,
                  O::S_BITSET1_B64, O::S_BITSET0_B64, O::S_SETPRIO,
                  O::V_MOV_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"S_ABSDIFF_I32", 5},
                         {"S_BITSET1_B64", 2},
                         {"S_BITSET0_B64", 2},
                         {"S_SETPRIO 0x00000003", 1}};
  return test;
}

TestCase ScalarShiftLeftAddSccCarryEdges() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  auto set_scc = [&](bool value) {
    code.push_back(EncodeSopc(0x06, InlineU32(1), InlineU32(value ? 1u : 0u)));
  };
  auto capture_scc = [&](u32 dst_sgpr) {
    code.push_back(EncodeSop2(0x0a, dst_sgpr, InlineU32(1), InlineU32(0)));
  };
  auto append_case = [&](bool prior_scc, u32 instruction, u32 out_sgpr) {
    set_scc(prior_scc);
    code.push_back(instruction);
    capture_scc(out_sgpr);
  };

  AppendSMovLiteral(&code, 0, 0x80000000u);
  AppendSMovLiteral(&code, 1, 0x40000000u);
  AppendSMovLiteral(&code, 2, 0x20000000u);
  AppendSMovLiteral(&code, 3, 0x10000000u);
  code.push_back(EncodeSMovB32(4, InlineU32(1)));
  code.push_back(EncodeSMovB32(5, InlineU32(0)));
  append_case(false, EncodeSop2(0x2e, 10, 0, 5), 20);
  append_case(true, EncodeSop2(0x2e, 11, 4, 4), 21);
  append_case(false, EncodeSop2(0x2f, 12, 1, 5), 22);
  append_case(true, EncodeSop2(0x2f, 13, 4, 4), 23);
  append_case(false, EncodeSop2(0x30, 14, 2, 5), 24);
  append_case(true, EncodeSop2(0x30, 15, 4, 4), 25);
  append_case(false, EncodeSop2(0x31, 16, 3, 5), 26);
  append_case(true, EncodeSop2(0x31, 17, 4, 4), 27);

  for (u32 i = 0; i < 8u; i++) {
    AppendStoreSgpr(&code, 20u + i, i);
  }
  AppendEnd(&code);

  return {"ScalarShiftLeftAddSccCarryEdges",
          code,
          {},
          {1, 0, 1, 0, 1, 0, 1, 0},
          {O::S_MOV_B32, O::S_LSHL1_ADD_U32, O::S_LSHL2_ADD_U32,
           O::S_LSHL3_ADD_U32, O::S_LSHL4_ADD_U32, O::S_CMP_EQ_U32,
           O::S_CSELECT_B32, O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarCompareOps() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendSMovLiteral(&code, 0, 0xfffffffeu);
  code.push_back(EncodeSMovB32(1, InlineU32(1)));
  code.push_back(EncodeSMovB32(2, InlineU32(5)));
  code.push_back(EncodeSMovB32(3, InlineU32(2)));
  code.push_back(EncodeSMovB32(4, InlineU32(3)));
  AppendSMovLiteral(&code, 10, 0x00000001u);
  code.push_back(EncodeSMovB32(11, InlineU32(0)));
  code.push_back(EncodeSMovB32(12, InlineU32(2)));
  code.push_back(EncodeSMovB32(13, InlineU32(0)));
  code.push_back(EncodeSMovB32(14, InlineU32(1)));
  code.push_back(EncodeSMovB32(15, InlineU32(1)));

  u32 dst = 20;
  auto append_compare = [&](u32 opcode, u32 src0, u32 src1) {
    code.push_back(EncodeSopc(opcode, src0, src1));
    code.push_back(EncodeSop2(0x0a, dst++, InlineU32(1), InlineU32(0)));
  };

  append_compare(0x00, 2, 2);
  append_compare(0x01, 0, 1);
  append_compare(0x02, 1, 0);
  append_compare(0x03, 1, 1);
  append_compare(0x04, 0, 1);
  append_compare(0x05, 0, 0);
  append_compare(0x07, 3, 4);
  append_compare(0x08, 4, 3);
  append_compare(0x09, 4, 4);
  append_compare(0x0b, 3, 4);
  append_compare(0x12, 10, 10);
  append_compare(0x12, 10, 12);
  append_compare(0x12, 10, 14);
  append_compare(0x13, 10, 12);
  append_compare(0x13, 10, 14);

  for (u32 i = 0; i < 15u; i++) {
    AppendStoreSgpr(&code, 20u + i, i);
  }
  AppendEnd(&code);

  return {"ScalarCompareOps",
          code,
          {},
          {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 1},
          {O::S_MOV_B32, O::S_CMP_EQ_I32, O::S_CMP_LG_I32, O::S_CMP_GT_I32,
           O::S_CMP_GE_I32, O::S_CMP_LT_I32, O::S_CMP_LE_I32, O::S_CMP_LG_U32,
           O::S_CMP_GT_U32, O::S_CMP_GE_U32, O::S_CMP_LE_U32, O::S_CMP_EQ_U64,
           O::S_CMP_LG_U64, O::S_CSELECT_B32, O::V_MOV_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarShiftAddAndMaskOps() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeSMovB32(0, InlineU32(2)));
  code.push_back(EncodeSMovB32(1, InlineU32(3)));
  code.push_back(EncodeSop2(0x2e, 2, 0, 1));
  code.push_back(EncodeSop2(0x2f, 3, 0, 1));
  code.push_back(EncodeSop2(0x30, 4, 0, 1));
  code.push_back(EncodeSop2(0x31, 5, 0, 1));
  AppendSMovLiteral(&code, 6, 0xfffffff8u);
  code.push_back(EncodeSop2(0x22, 7, 6, InlineU32(2)));
  AppendSMovLiteral(&code, 8, 0xffffffffu);
  code.push_back(EncodeSMovB32(9, InlineU32(2)));
  code.push_back(EncodeSop2(0x35, 10, 8, 9));
  AppendSMovLiteral(&code, 12, 0x80000011u);
  AppendSMovLiteral(&code, 13, 0x80000001u);
  code.push_back(EncodeSop1(0x08, 14, 12));
  code.push_back(EncodeSop1(0x0a, 16, 12));

  AppendStoreSgpr(&code, 2, 0);
  AppendStoreSgpr(&code, 3, 1);
  AppendStoreSgpr(&code, 4, 2);
  AppendStoreSgpr(&code, 5, 3);
  AppendStoreSgpr(&code, 7, 4);
  AppendStoreSgpr(&code, 10, 5);
  AppendStoreSgprPair(&code, 14, 6);
  AppendStoreSgprPair(&code, 16, 8);
  AppendEnd(&code);

  return {"ScalarShiftAddAndMaskOps",
          code,
          {},
          {7, 11, 19, 35, 0xfffffffeu, 1, 0x7fffffeeu, 0x7ffffffeu, 0xf00000ffu,
           0xf000000fu},
          {O::S_MOV_B32, O::S_LSHL1_ADD_U32, O::S_LSHL2_ADD_U32,
           O::S_LSHL3_ADD_U32, O::S_LSHL4_ADD_U32, O::S_ASHR_I32,
           O::S_MUL_HI_U32, O::S_NOT_B64, O::S_WQM_B64, O::V_MOV_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarNotB64UpdatesScc() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  auto set_scc = [&](bool value) {
    code.push_back(EncodeSopc(0x06, InlineU32(1), InlineU32(value ? 1u : 0u)));
  };
  auto capture_scc = [&](u32 dst_sgpr) {
    code.push_back(EncodeSop2(0x0a, dst_sgpr, InlineU32(1), InlineU32(0)));
  };

  AppendSMovLiteral(&code, 0, 0xffffffffu);
  AppendSMovLiteral(&code, 1, 0xffffffffu);
  set_scc(true);
  code.push_back(EncodeSop1(0x08, 2, 0));
  capture_scc(4);

  AppendSMovLiteral(&code, 6, 0xfffffffeu);
  AppendSMovLiteral(&code, 7, 0xffffffffu);
  set_scc(false);
  code.push_back(EncodeSop1(0x08, 8, 6));
  capture_scc(10);

  code.push_back(EncodeVopc(0xc2, Vgpr(0), 0));
  code.push_back(EncodeSop1(0x04, 12, 106));
  code.push_back(EncodeSop1(0x08, 14, 12));
  capture_scc(16);

  AppendStoreSgpr(&code, 4, 0);
  AppendStoreSgpr(&code, 10, 1);
  AppendStoreSgprPair(&code, 2, 2);
  AppendStoreSgprPair(&code, 8, 4);
  AppendStoreSgpr(&code, 16, 6);
  AppendStoreSgprPair(&code, 14, 7);
  AppendEnd(&code);

  return {"ScalarNotB64UpdatesScc",
          code,
          {},
          {0, 1, 0, 0, 1, 0, 1, 0xfffffffeu, 0xffffffffu},
          {O::S_MOV_B32, O::S_CMP_EQ_U32, O::S_NOT_B64, O::S_CSELECT_B32,
           O::V_CMP_EQ_U32, O::S_MOV_B64, O::V_MOV_B32, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase ScalarQuadmaskB64() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  auto capture_scc = [&](u32 dst_sgpr) {
    code.push_back(EncodeSop2(0x0a, dst_sgpr, InlineU32(1), InlineU32(0)));
  };

  AppendSMovLiteral(&code, 106, 0x80000011u);
  AppendSMovLiteral(&code, 107, 0x000000f0u);
  code.push_back(EncodeSop1(0x2d, 106, 106));
  capture_scc(0);
  AppendStoreSgprPair(&code, 106, 0);
  AppendStoreSgpr(&code, 0, 2);

  code.push_back(EncodeSMovB32(106, InlineU32(0)));
  code.push_back(EncodeSMovB32(107, InlineU32(0)));
  code.push_back(EncodeSop1(0x2d, 106, 106));
  capture_scc(0);
  AppendStoreSgprPair(&code, 106, 3);
  AppendStoreSgpr(&code, 0, 5);
  AppendEnd(&code);

  return {"ScalarQuadmaskB64",
          code,
          {},
          {0x00000283u, 0, 1, 0, 0, 0},
          {O::S_MOV_B32, O::S_QUADMASK_B64, O::S_CSELECT_B32, O::V_MOV_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarFlbitI32B64Gpu() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendSMovLiteral(&code, 0, 0x00000000u);
  AppendSMovLiteral(&code, 1, 0x80000000u);
  code.push_back(EncodeSop1(0x16, 20, 0));

  AppendSMovLiteral(&code, 2, 0x00008000u);
  AppendSMovLiteral(&code, 3, 0x00000000u);
  code.push_back(EncodeSop1(0x16, 21, 2));

  AppendSMovLiteral(&code, 4, 0x00000000u);
  AppendSMovLiteral(&code, 5, 0x00000000u);
  code.push_back(EncodeSop1(0x16, 22, 4));

  AppendSMovLiteral(&code, 14, 0x00000008u);
  AppendSMovLiteral(&code, 15, 0x00000000u);
  code.push_back(EncodeSop1(0x16, 106, 14));

  AppendStoreSgpr(&code, 20, 0);
  AppendStoreSgpr(&code, 21, 1);
  AppendStoreSgpr(&code, 22, 2);
  AppendStoreSgpr(&code, 106, 3);
  AppendEnd(&code);

  return {"ScalarFlbitI32B64Gpu",
          code,
          {},
          {0, 48, 0xffffffffu, 60},
          {O::S_MOV_B32, O::S_FLBIT_I32_B64, O::V_MOV_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarFlbitI32B32Gpu() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendSMovLiteral(&code, 0, 0x00000000u);
  code.push_back(EncodeSop1(0x15, 20, 0));

  AppendSMovLiteral(&code, 0, 0x0000ccccu);
  code.push_back(EncodeSop1(0x15, 21, 0));

  AppendSMovLiteral(&code, 0, 0x80000000u);
  code.push_back(EncodeSop1(0x15, 22, 0));

  AppendSMovLiteral(&code, 0, 0x7fffffffu);
  code.push_back(EncodeSop1(0x15, 23, 0));

  AppendStoreSgpr(&code, 20, 0);
  AppendStoreSgpr(&code, 21, 1);
  AppendStoreSgpr(&code, 22, 2);
  AppendStoreSgpr(&code, 23, 3);
  AppendEnd(&code);

  return {"ScalarFlbitI32B32Gpu",
          code,
          {},
          {0xffffffffu, 16, 0, 1},
          {O::S_MOV_B32, O::S_FLBIT_I32_B32, O::V_MOV_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarSaveExecOps() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendSMovLiteral(&code, 106, 0xffffffffu);
  AppendSMovLiteral(&code, 107, 0xffffffffu);
  code.push_back(0xbe80246au);
  code.push_back(EncodeSop1(0x28, 2, 106));
  code.push_back(EncodeSMovB32(106, InlineU32(0)));
  code.push_back(EncodeSMovB32(107, InlineU32(0)));
  code.push_back(EncodeSop1(0x37, 4, 106));
  AppendSMovLiteral(&code, 106, 0x00000003u);
  code.push_back(EncodeSop1(0x3c, 8, 106));
  code.push_back(EncodeSop1(0x04, 10, 126));
  code.push_back(EncodeSMovB32(106, InlineU32(1)));
  code.push_back(EncodeSop1(0x44, 12, 106));
  code.push_back(EncodeSop1(0x04, 14, 126));
  AppendSMovLiteral(&code, 126, 0xffffffffu);
  AppendSMovLiteral(&code, 127, 0xffffffffu);

  AppendStoreSgprPair(&code, 0, 0);
  AppendStoreSgprPair(&code, 2, 2);
  AppendStoreSgprPair(&code, 4, 4);
  AppendStoreSgpr(&code, 8, 6);
  AppendStoreSgprPair(&code, 10, 7);
  AppendStoreSgpr(&code, 12, 9);
  AppendStoreSgprPair(&code, 14, 10);
  AppendStoreSgpr(&code, 253, 12);
  AppendEnd(&code);

  return {"ScalarSaveExecOps",
          code,
          {},
          {1, 0, 1, 0, 0xffffffffu, 0xffffffffu, 0xffffffffu,
           3, 0xffffffffu, 3, 2, 0xffffffffu, 1},
          {O::S_MOV_B32, O::S_AND_SAVEEXEC_B64, O::S_ORN2_SAVEEXEC_B64,
           O::S_ANDN1_SAVEEXEC_B64, O::S_AND_SAVEEXEC_B32,
           O::S_ANDN1_SAVEEXEC_B32, O::S_MOV_B64, O::V_MOV_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarOrn2SaveexecUsesSourceOrNotExec() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendSMovLiteral(&code, 126, 0x0000000cu);
  AppendSMovLiteral(&code, 127, 0x80000000u);
  AppendSMovLiteral(&code, 0, 0x00000001u);
  AppendSMovLiteral(&code, 1, 0x00000001u);
  code.push_back(EncodeSop1(0x28, 2, 0));
  code.push_back(EncodeSop1(0x04, 4, 126));
  code.push_back(EncodeSMovB32(126, InlineU32(1)));
  code.push_back(EncodeSMovB32(127, InlineU32(0)));
  AppendStoreSgprPair(&code, 2, 0);
  AppendStoreSgprPair(&code, 4, 2);
  AppendStoreSgpr(&code, 253, 4);
  AppendEnd(&code);

  return {"ScalarOrn2SaveexecUsesSourceOrNotExec",
          code,
          {},
          {0x0000000cu, 0x80000000u, 0xfffffff3u, 0x7fffffffu, 1},
          {O::S_MOV_B32, O::S_ORN2_SAVEEXEC_B64, O::S_MOV_B64, O::V_MOV_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarOrn2SaveexecB32(u32 wave_size, u32 threads) {
  using O = ShaderOpcode;
  constexpr u32 exec_hi = 0xa5a55a5au;
  constexpr u32 vcc_hi = 0x13579bdfu;
  struct Case {
    u32 exec_lo, source, destination, result;
  };
  constexpr Case cases[] = {
      {0x8000000cu, 126, 106, 0xffffffffu}, // Captured vcc_lo, exec_lo.
      {0x0000000fu, 6, 6, 0xfffffff3u},    // Aliased SGPR source/destination.
      {0xffffffffu, 128, 8, 0},            // SCC ignores the nonzero high half.
      {0xffffffffu, 107, 8, vcc_hi},
      {0xffffffffu, 127, 8, exec_hi},
      {0xffffffffu, 253, 8, 1},            // SCC is a scalar value, not a mask.
      {0xffffffffu, 251, 8, 0},            // VCCZ summarizes the whole mask.
      {0x00000001u, 252, 8, 0xfffffffeu},  // EXECZ is uniform across lanes.
  };
  TestCase test;
  test.name = wave_size == 64 ? "ScalarOrn2SaveexecB32Wave64"
              : threads == 32 ? "ScalarOrn2SaveexecB32Wave32"
                              : "ScalarOrn2SaveexecB32PartialWave";
  auto &code = test.code;
  // Zero flags ignore high bits only in wave32 and include inactive low bits.
  constexpr u32 masks[][2] = {{0, 0}, {0x80000000u, 0}, {0, 0x80000000u}};
  for (const auto &mask : masks) {
    AppendSMovLiteral(&code, 106, mask[0]);
    AppendSMovLiteral(&code, 107, mask[1]);
    AppendSMovLiteral(&code, 126, mask[0]);
    AppendSMovLiteral(&code, 127, mask[1]);
    code.push_back(EncodeSMovB32(20, 251));
    code.push_back(EncodeSMovB32(21, 252));
    code.push_back(EncodeSop1(0x04, 126, 193u));
    const u32 zero = mask[0] == 0 && (wave_size == 32 || mask[1] == 0);
    for (u32 reg = 20; reg <= 21; ++reg) {
      AppendStoreSgprAtLaneDwordOffset(&code, reg, 0,
                                      static_cast<u32>(test.expected.size()));
      test.expected.insert(test.expected.end(), threads, zero);
    }
  }
  for (const auto &item : cases) {
    AppendVMovU32(&code, 2, 0);
    AppendSMovLiteral(&code, 126, item.exec_lo);
    AppendSMovLiteral(&code, 127, exec_hi);
    AppendSMovLiteral(&code, 106, 1);
    AppendSMovLiteral(&code, 107, vcc_hi);
    AppendSMovLiteral(&code, 6, 3);
    code.push_back(EncodeSopc(0x06, InlineU32(0), InlineU32(0)));
    code.push_back(item.source == 126 ? 0xbeea407eu
                                     : EncodeSop1(0x40, item.destination, item.source));
    const u32 snapshots[] = {item.destination, 126, 127, 107, 253};
    for (u32 i = 0; i < std::size(snapshots); ++i) {
      code.push_back(EncodeSMovB32(20 + i, snapshots[i]));
    }
    AppendVMovU32(&code, 2, 1);
    code.push_back(EncodeSop1(0x04, 126, 193u)); // Restore EXEC for readback.
    const u32 expected[] = {item.exec_lo, item.result, exec_hi, vcc_hi,
                            item.result != 0 ? 1u : 0u};
    for (u32 i = 0; i < std::size(expected); ++i) {
      AppendStoreSgprAtLaneDwordOffset(&code, 20 + i, 0,
                                      static_cast<u32>(test.expected.size()));
      test.expected.insert(test.expected.end(), threads, expected[i]);
    }
    AppendStoreVgprAtLaneDwordOffset(&code, 2, 0,
                                    static_cast<u32>(test.expected.size()));
    for (u32 lane = 0; lane < threads; ++lane) {
      const u32 mask = lane < 32 ? item.result : exec_hi;
      test.expected.push_back((mask >> (lane % 32)) & 1u);
    }
  }
  AppendEnd(&code);
  test.initial.resize(test.expected.size());
  test.opcodes = {O::S_MOV_B32, O::S_MOV_B64, O::S_CMP_EQ_U32,
                  O::S_ORN2_SAVEEXEC_B32, O::V_MOV_B32, O::V_LSHLREV_B32,
                  O::V_ADD_NC_U32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"S_ORN2_SAVEEXEC_B32 vcc_lo, exec_lo", 1}};
  test.compute_info.threads_num[0] = threads;
  test.compute_info.threads_num[1] = test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.wave_size = wave_size;
  test.has_compute_info = true;
  return test;
}

TestCase ScalarSubvectorLoops(u32 wave_size) {
  using O = ShaderOpcode;
  using namespace ShaderRecompiler::Decoder;
  TestCase test;
  test.name = wave_size == 64 ? "ScalarSubvectorLoopsWave64"
                              : "ScalarSubvectorLoopsWave32";
  // The captured mesh shader's signed SOPK targets are relative to PC + 4.
  std::array<u32, 47> captured{};
  captured[0x30 / 4] = 0xbda60022u;
  captured[0xb8 / 4] = 0xbe26ffdeu;
  Instruction begin, end;
  DecodeInstruction(captured, 0x30 / 4, begin);
  DecodeInstruction(captured, 0xb8 / 4, end);
  Require(test.name, "captured branch decode",
          begin.opcode == O::S_SUBVECTOR_LOOP_BEGIN && begin.dst.reg == 38 &&
              begin.dst.kind == OperandKind::Sgpr && begin.branch_target == 0xbc &&
              end.opcode == O::S_SUBVECTOR_LOOP_END && end.dst.reg == 38 &&
              end.dst.kind == OperandKind::Sgpr && end.branch_target == 0x34 &&
              begin.word_count == 1 && end.word_count == 1,
          "subvector SDST or signed PC-relative target was decoded incorrectly");

  constexpr u32 sentinel = 0x5a13abcdu;
  constexpr u32 low = 0x80000005u, high = 0x42000002u;
  struct Case {
    u32 lo, hi, body_mode, saved, final_lo, final_hi, passes;
  };
  constexpr Case cases[] = {
      {0, 0, 0, sentinel, 0, 0, 0},
      {low, 0, 0, 0, low, 0, 1},
      {0, high, 0, 0, 0, high, 1},
      {low, high, 0, low, low, high, 2},
      {~0u, ~0u, 0, ~0u, ~0u, ~0u, 2},
      // The game resets the full EXEC mask before END, selecting its HI != 0 arm.
      {low, high, 1, high, high, ~0u, 1},
      // END must restore the low mask saved after the body has changed it.
      {low, high, 2, 0, 0, high, 2},
      // BEGIN EXEC_LO first copies HI to its aliased destination, then clears HI.
      {low, high, 3, 0, 0, high, 2},
  };
  auto &code = test.code;
  for (u32 index = 0; index < std::size(cases); ++index) {
    const auto &item = cases[index];
    const u32 scc = index & 1u;
    const u32 saved_reg = item.body_mode == 3 ? 126u : 38u;
    AppendVMovU32(&code, 2, 0);
    AppendVMovU32(&code, 3, 0);
    AppendSMovLiteral(&code, 38, sentinel);
    AppendSMovLiteral(&code, 32, 1); // Scalar 2^passes; MULK preserves SCC.
    AppendSMovLiteral(&code, 33, 0xff);
    AppendSMovLiteral(&code, 126, item.lo);
    AppendSMovLiteral(&code, 127, item.hi);
    code.push_back(EncodeSopc(0x06, InlineU32(0), InlineU32(scc == 0 ? 1 : 0)));
    const auto begin_word = static_cast<u32>(code.size());
    code.push_back(0);
    const auto body_word = static_cast<u32>(code.size());
    code.push_back(EncodeSMovB32(33, 253)); // Observe SCC immediately after BEGIN.
    code.push_back(EncodeSopk(0x10, 32, 2));
    code.push_back(EncodeVop2(0x25, 2, InlineU32(1), 2));
    code.push_back(EncodeVop1(0x01, 3, 32));
    if (item.body_mode == 1) {
      code.push_back(EncodeSop1(0x04, 126, 193)); // S_MOV_B64 EXEC, -1.
    } else if (item.body_mode == 2) {
      code.push_back(EncodeSMovB32(126, InlineU32(0)));
    }
    const auto end_word = static_cast<u32>(code.size());
    code.push_back(EncodeSopk(0x1c, saved_reg, body_word - end_word - 1u));
    code[begin_word] = EncodeSopk(0x1b, saved_reg, end_word - begin_word);
    const u32 sources[] = {saved_reg, 126, 127, 253, 32, 33};
    for (u32 i = 0; i < std::size(sources); ++i) {
      code.push_back(EncodeSMovB32(20 + i, sources[i]));
    }
    code.push_back(EncodeSop1(0x04, 126, 193)); // Restore all lanes for readback.
    const u32 expected[] = {item.saved, item.final_lo, item.final_hi, scc,
                            1u << item.passes, item.passes == 0 ? 0xff : scc};
    for (u32 i = 0; i < std::size(expected); ++i) {
      AppendStoreSgprAtLaneDwordOffset(&code, 20 + i, 0,
                                      static_cast<u32>(test.expected.size()));
      test.expected.insert(test.expected.end(), wave_size, expected[i]);
    }
    for (u32 reg : {2u, 3u}) {
      AppendStoreVgprAtLaneDwordOffset(&code, reg, 0,
                                      static_cast<u32>(test.expected.size()));
      for (u32 lane = 0; lane < wave_size; ++lane) {
        const bool upper = lane >= 32;
        const u32 mask = upper || item.body_mode == 3 ? item.hi : item.lo;
        const bool active = ((mask >> (lane % 32)) & 1u) != 0 &&
                            !(upper && item.body_mode == 1);
        const u32 pass_value = upper && item.lo != 0 ? 4u : 2u;
        test.expected.push_back(active ? (reg == 2 ? 1u : pass_value) : 0u);
      }
    }
  }
  AppendEnd(&code);
  test.initial.resize(test.expected.size());
  test.opcodes = {O::S_SUBVECTOR_LOOP_BEGIN, O::S_SUBVECTOR_LOOP_END,
                  O::S_MOV_B32, O::S_MOV_B64, O::S_MULK_I32, O::S_CMP_EQ_U32,
                  O::V_MOV_B32, O::V_ADD_NC_U32, O::V_LSHLREV_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = wave_size;
  test.compute_info.threads_num[1] = test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.wave_size = wave_size;
  test.has_compute_info = true;
  return test;
}

TestCase ScalarGetpcWritesNextInstructionPc() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeSop1(0x1f, 0, 0));
  AppendStoreSgprPair(&code, 0, 0);
  AppendEnd(&code);

  return {"ScalarGetpcWritesNextInstructionPc",
          code,
          {},
          {4, 0},
          {O::S_GETPC_B64, O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarBitfieldPack() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeSMovB32(0, InlineU32(15)));
  code.push_back(EncodeSop1(0x0b, 1, 0));
  AppendSMovLiteral(&code, 2, 0xf0000000u);
  code.push_back(EncodeSop1(0x10, 3, 0));
  AppendSMovLiteral(&code, 19, 0xf0f00001u);
  code.push_back(EncodeSop1(0x0f, 20, 19));
  code.push_back(EncodeSop2(0x0a, 21, InlineU32(1), InlineU32(0)));
  code.push_back(EncodeSMovB32(22, InlineU32(0)));
  code.push_back(EncodeSop1(0x0f, 23, 22));
  code.push_back(EncodeSop2(0x0a, 24, InlineU32(1), InlineU32(0)));
  code.push_back(EncodeSMovB32(4, InlineU32(3)));
  code.push_back(EncodeSop1(0x3b, 5, 4));
  code.push_back(EncodeSop2(0x24, 7, InlineU32(4), InlineU32(8)));
  AppendSMovLiteral(&code, 8, 0x00f00000u);
  AppendSMovLiteral(&code, 9, 0x00040014u);
  code.push_back(EncodeSop2(0x27, 10, 8, 9));
  AppendSMovLiteral(&code, 11, 0xaaaabbbbu);
  AppendSMovLiteral(&code, 12, 0xccccddddu);
  code.push_back(EncodeSop2(0x32, 13, 11, 12));
  code.push_back(EncodeSop2(0x33, 14, 11, 12));
  code.push_back(EncodeSop2(0x34, 15, 11, 12));
  code.push_back(EncodeSopc(0x0d, InlineU32(4), InlineU32(2)));
  code.push_back(EncodeSop2(0x0a, 17, InlineU32(1), InlineU32(0)));
  code.push_back(EncodeSopc(0x0c, InlineU32(4), InlineU32(1)));
  code.push_back(EncodeSop2(0x0a, 18, InlineU32(1), InlineU32(0)));
  AppendSMovLiteral(&code, 25, 0u);
  AppendSMovLiteral(&code, 26, 0x00000100u);
  code.push_back(EncodeSopc(0x06, InlineU32(0), InlineU32(1)));
  code.push_back(EncodeSop1(0x14, 31, 25));
  code.push_back(EncodeSop2(0x0a, 34, InlineU32(1), InlineU32(0)));
  AppendSMovLiteral(&code, 27, 0x00000020u);
  AppendSMovLiteral(&code, 28, 0x00000100u);
  code.push_back(EncodeSopc(0x06, InlineU32(1), InlineU32(1)));
  code.push_back(EncodeSop1(0x14, 32, 27));
  code.push_back(EncodeSop2(0x0a, 35, InlineU32(1), InlineU32(0)));
  AppendSMovLiteral(&code, 29, 0u);
  AppendSMovLiteral(&code, 30, 0u);
  code.push_back(EncodeSop1(0x14, 33, 29));

  AppendStoreSgpr(&code, 1, 0);
  AppendStoreSgpr(&code, 3, 1);
  AppendStoreSgpr(&code, 20, 2);
  AppendStoreSgpr(&code, 21, 3);
  AppendStoreSgpr(&code, 23, 4);
  AppendStoreSgpr(&code, 24, 5);
  AppendStoreSgprPair(&code, 5, 6);
  AppendStoreSgpr(&code, 7, 8);
  AppendStoreSgpr(&code, 10, 9);
  AppendStoreSgpr(&code, 13, 10);
  AppendStoreSgpr(&code, 14, 11);
  AppendStoreSgpr(&code, 15, 12);
  AppendStoreSgpr(&code, 17, 13);
  AppendStoreSgpr(&code, 18, 14);
  AppendStoreSgpr(&code, 31, 15);
  AppendStoreSgpr(&code, 32, 16);
  AppendStoreSgpr(&code, 33, 17);
  AppendStoreSgpr(&code, 34, 18);
  AppendStoreSgpr(&code, 35, 19);
  AppendEnd(&code);

  return {"ScalarBitfieldPack",
          code,
          {},
          {0xf0000000u, 8,           9,           1,           0,
           0,           0x0000000fu, 0,           0x00000f00u, 0x0000000fu,
           0xddddbbbbu, 0xccccbbbbu, 0xccccaaaau, 1,           1,
           40,          5,           0xffffffffu, 0,           1},
          {O::S_MOV_B32, O::S_BREV_B32, O::S_BCNT1_I32_B32, O::S_BCNT1_I32_B64,
           O::S_FF1_I32_B64, O::S_BITREPLICATE_B64_B32, O::S_BFM_B32,
           O::S_BFE_U32, O::S_PACK_LL_B32_B16, O::S_PACK_LH_B32_B16,
           O::S_PACK_HH_B32_B16, O::S_BITCMP0_B32, O::S_BITCMP1_B32,
           O::S_CSELECT_B32, O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarBrevB32PreservesScc() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  auto set_scc = [&](bool value) {
    code.push_back(EncodeSopc(0x06, InlineU32(1), InlineU32(value ? 1u : 0u)));
  };
  auto capture_scc = [&](u32 dst_sgpr) {
    code.push_back(EncodeSop2(0x0a, dst_sgpr, InlineU32(1), InlineU32(0)));
  };

  code.push_back(EncodeSMovB32(0, InlineU32(1)));
  set_scc(false);
  code.push_back(EncodeSop1(0x0b, 1, 0));
  capture_scc(2);

  code.push_back(EncodeSMovB32(3, InlineU32(0)));
  set_scc(true);
  code.push_back(EncodeSop1(0x0b, 4, 3));
  capture_scc(5);

  AppendStoreSgpr(&code, 1, 0);
  AppendStoreSgpr(&code, 2, 1);
  AppendStoreSgpr(&code, 4, 2);
  AppendStoreSgpr(&code, 5, 3);
  AppendEnd(&code);

  return {"ScalarBrevB32PreservesScc",
          code,
          {},
          {0x80000000u, 0, 0, 1},
          {O::S_MOV_B32, O::S_CMP_EQ_U32, O::S_BREV_B32, O::S_CSELECT_B32,
           O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarBfeI32CapturedRawSignExtends() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendBufferLoadDword(&code, 0, 30);
  code.push_back(EncodeVop1(0x02, 20, Vgpr(0)));
  code.push_back(0x946aff14u); // s_bfe_i32 vcc_lo, s20, literal
  code.push_back(0x0004001cu); // offset 28, width 4
  code.push_back(EncodeSop2(0x0a, 21, InlineU32(1), InlineU32(0)));
  code.push_back(EncodeSop2(0x28, 22, 20, 255u));
  code.push_back(0u); // zero width produces zero and clears SCC
  code.push_back(EncodeSop2(0x0a, 23, InlineU32(1), InlineU32(0)));
  AppendStoreSgpr(&code, 106, 1);
  AppendStoreSgpr(&code, 21, 2);
  AppendStoreSgpr(&code, 22, 3);
  AppendStoreSgpr(&code, 23, 4);
  AppendEnd(&code);

  TestCase test;
  test.name = "ScalarBfeI32CapturedRawSignExtends";
  test.code = std::move(code);
  test.initial = {0xf0000000u, 0, 0, 0, 0};
  test.expected = {0xf0000000u, 0xffffffffu, 1, 0, 0};
  test.opcodes = {O::BUFFER_LOAD_DWORD, O::V_READFIRSTLANE_B32,
                  O::S_BFE_I32,         O::S_CSELECT_B32,
                  O::V_MOV_B32,         O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.required_spirv = {"OpBitFieldSExtract"};
  return test;
}

TestCase BitfieldExtractWidthPastEndEdges() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendSMovLiteral(&code, 0, 0xf0000000u);
  AppendSMovLiteral(&code, 1, (20u << 16u) | 20u);
  code.push_back(EncodeSop2(0x27, 2, 0, 1));
  AppendSMovLiteral(&code, 3, 0x80000000u);
  AppendSMovLiteral(&code, 4, (7u << 16u) | 31u);
  code.push_back(EncodeSop2(0x27, 5, 3, 4));
  AppendVMovLiteral(&code, 6, 0xf0000000u);
  AppendVMovU32(&code, 7, 28);
  AppendVMovU32(&code, 8, 8);
  AppendVop3(&code, 0x148, 9, Vgpr(6), Vgpr(7), Vgpr(8));
  AppendStoreSgpr(&code, 2, 0);
  AppendStoreSgpr(&code, 5, 1);
  AppendStoreVgpr(&code, 9, 2);
  AppendEnd(&code);

  return {"BitfieldExtractWidthPastEndEdges",
          code,
          {},
          {0x00000f00u, 1, 0x0000000fu},
          {O::S_MOV_B32, O::S_BFE_U32, O::V_MOV_B32, O::V_BFE_U32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase Scalar64BitOps() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendSMovLiteral(&code, 0, 0x0f0f0f0fu);
  AppendSMovLiteral(&code, 1, 0x00ff00ffu);
  AppendSMovLiteral(&code, 2, 0x33333333u);
  AppendSMovLiteral(&code, 3, 0x0f0f0f0fu);
  code.push_back(EncodeSop2(0x0f, 4, 0, 2));
  code.push_back(EncodeSop2(0x15, 6, 0, 2));
  code.push_back(EncodeSop2(0x11, 8, 0, 2));
  code.push_back(EncodeSop2(0x17, 10, 0, 2));
  code.push_back(EncodeSop2(0x13, 12, 0, 2));
  code.push_back(EncodeSop2(0x19, 14, 0, 2));
  code.push_back(EncodeSop2(0x1b, 16, 0, 2));
  code.push_back(EncodeSop2(0x1d, 18, 0, 2));
  code.push_back(EncodeSop1(0x04, 20, 0));
  code.push_back(EncodeSop2(0x1f, 22, 0, InlineU32(4)));
  code.push_back(EncodeSop2(0x21, 24, 0, InlineU32(8)));
  code.push_back(EncodeSop2(0x25, 26, InlineU32(36), InlineU32(4)));
  code.push_back(EncodeSop2(0x21, 34, 193u, InlineU32(1)));
  AppendSMovLiteral(&code, 28, 0x000c0004u);
  code.push_back(EncodeSop2(0x29, 30, 0, 28));
  code.push_back(EncodeSopc(0x06, 0, 0));
  code.push_back(EncodeSop2(0x0b, 32, 0, 2));

  const u32 result_pairs[] = {4,  6,  8,  10, 12, 14, 16, 18,
                              20, 22, 24, 26, 34, 30, 32};
  u32 out = 0;
  for (auto sgpr : result_pairs) {
    AppendStoreSgprPair(&code, sgpr, out);
    out += 2;
  }
  AppendEnd(&code);

  return {"Scalar64BitOps",
          code,
          {},
          {0x03030303u, 0x000f000fu, 0x0c0c0c0cu, 0x00f000f0u, 0x3f3f3f3fu,
           0x0fff0fffu, 0xcfcfcfcfu, 0xf0fff0ffu, 0x3c3c3c3cu, 0x0ff00ff0u,
           0xfcfcfcfcu, 0xfff0fff0u, 0xc0c0c0c0u, 0xf000f000u, 0xc3c3c3c3u,
           0xf00ff00fu, 0x0f0f0f0fu, 0x00ff00ffu, 0xf0f0f0f0u, 0x0ff00ff0u,
           0xff0f0f0fu, 0x0000ff00u, 0xfffffff0u, 0x000000ffu, 0xffffffffu,
           0x7fffffffu, 0x000000f0u, 0,           0x0f0f0f0fu, 0x00ff00ffu},
          {O::S_MOV_B32, O::S_MOV_B64, O::S_AND_B64, O::S_ANDN2_B64,
           O::S_OR_B64, O::S_ORN2_B64, O::S_XOR_B64, O::S_NAND_B64,
           O::S_NOR_B64, O::S_XNOR_B64, O::S_LSHL_B64, O::S_LSHR_B64,
           O::S_BFM_B64, O::S_BFE_U64, O::S_CMP_EQ_U32, O::S_CSELECT_B64,
           O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

uint64_t ReferenceAshrI64(uint64_t bits, u32 count) {
  const auto shift = count & 63u;
  // Complementing negative values expresses sign fill using unsigned shifts.
  return (bits & (uint64_t{1} << 63u)) != 0 ? ~(~bits >> shift) : bits >> shift;
}

TestCase ScalarAshrI64Edges(bool dynamic) {
  using O = ShaderOpcode;
  TestCase test;
  test.name =
      dynamic ? "ScalarAshrI64DynamicEdges" : "ScalarAshrI64ConstantEdges";
  constexpr uint64_t sources[] = {0,
                                  1,
                                  0x80000000ull,
                                  0x100000000ull,
                                  0x7fffffffffffffffull,
                                  0x8000000000000000ull,
                                  0xffffffffffffffffull,
                                  0x0123456789abcdefull,
                                  0xfedcba9876543210ull};
  constexpr u32 counts[] = {0,  1,  7,  31, 32,  33,         63,
                            64, 65, 95, 96, 127, 0xffffffffu};
  test.initial.assign(std::begin(counts), std::end(counts));
  for (const auto source : sources) {
    test.initial.push_back(static_cast<u32>(source));
    test.initial.push_back(static_cast<u32>(source >> 32u));
  }
  test.expected = test.initial;
  auto &code = test.code;
  const auto load_scalar = [&](u32 reg, u32 index) {
    AppendVMovU32(&code, 30, index * sizeof(u32));
    AppendBufferLoadDword(&code, 1, 30);
    code.push_back(EncodeVop1(0x02, reg, Vgpr(1)));
  };
  for (u32 source_index = 0; source_index < std::size(sources);
       ++source_index) {
    const auto source = sources[source_index];
    // Runtime sources exercise both constant-count and dynamic-count emission.
    load_scalar(20, static_cast<u32>(std::size(counts)) + source_index * 2u);
    load_scalar(21,
                static_cast<u32>(std::size(counts)) + source_index * 2u + 1u);
    for (u32 index = 0; index < std::size(counts); ++index) {
      const auto expected = ReferenceAshrI64(source, counts[index]);
      if (dynamic) {
        load_scalar(22, index);
      }
      // Start SCC at the opposite value so every result must update it.
      code.push_back(
          EncodeSopc(0x06, InlineU32(0), InlineU32(expected != 0 ? 1u : 0u)));
      const auto count_src = dynamic                ? 22u
                             : counts[index] <= 64u ? InlineU32(counts[index])
                                                    : 255u;
      code.push_back(EncodeSop2(0x23, 24, 20, count_src));
      if (!dynamic && count_src == 255u) {
        code.push_back(counts[index]);
      }
      code.push_back(EncodeSMovB32(26, 253));
      const auto output = static_cast<u32>(test.expected.size());
      AppendStoreSgprPair(&code, 24, output);
      AppendStoreSgpr(&code, 26, output + 2u);
      test.expected.push_back(static_cast<u32>(expected));
      test.expected.push_back(static_cast<u32>(expected >> 32u));
      test.expected.push_back(expected != 0 ? 1u : 0u);
    }
  }
  AppendEnd(&code);
  test.initial.resize(test.expected.size());
  test.opcodes = {O::BUFFER_LOAD_DWORD,  O::V_READFIRSTLANE_B32,
                  O::S_MOV_B32,          O::S_CMP_EQ_U32,
                  O::S_ASHR_I64,         O::V_MOV_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {
      {"S_ASHR_I64", std::size(sources) * std::size(counts)}};
  test.required_spirv = {"OpShiftRightArithmetic"};
  test.forbidden_spirv = {"OpTypeInt 64"};
  return test;
}

TestCase ScalarAshrI64OperandsAndAliases() {
  using O = ShaderOpcode;
  TestCase test;
  test.name = "ScalarAshrI64OperandsAndAliases";
  test.initial = {33}; // Runtime shift for signed literal source tests.
  test.expected = test.initial;
  auto &code = test.code;
  AppendVMovU32(&code, 30, 0);
  AppendBufferLoadDword(&code, 1, 30);
  code.push_back(EncodeVop1(0x02, 22, Vgpr(1)));
  size_t instructions = 0;
  const auto check_result = [&](u32 dst, u32 src0, u32 src1, uint64_t value,
                                u32 count, std::optional<u32> literal = {}) {
    code.push_back(EncodeSop2(0x23, dst, src0, src1));
    if (literal) {
      code.push_back(*literal);
    }
    code.push_back(EncodeSMovB32(26, 253));
    const auto output = static_cast<u32>(test.expected.size());
    AppendStoreSgprPair(&code, dst, output);
    AppendStoreSgpr(&code, 26, output + 2u);
    const auto expected = ReferenceAshrI64(value, count);
    test.expected.push_back(static_cast<u32>(expected));
    test.expected.push_back(static_cast<u32>(expected >> 32u));
    test.expected.push_back(expected != 0 ? 1u : 0u);
    ++instructions;
  };
  for (const u32 literal : {0u, 0x7fffffffu, 0x80000000u, 0xffffffffu}) {
    const uint64_t value =
        literal | ((literal & 0x80000000u) != 0 ? 0xffffffff00000000ull : 0ull);
    for (const u32 count : {0u, 1u, 31u, 32u, 63u, 64u}) {
      check_result(24, 255, InlineU32(count), value, count, literal);
    }
    check_result(24, 255, 22, value, 33, literal);
  }
  for (const u32 source : {128u, 129u, 192u, 193u, 208u, 125u}) {
    const uint64_t value = source == 125u   ? 0ull
                           : source <= 192u ? source - 128u
                                            : uint64_t{192} - source;
    for (const u32 count : {0u, 1u, 32u, 63u}) {
      check_result(24, source, InlineU32(count), value, count);
    }
  }
  for (const u32 scc : {0u, 1u}) {
    // SCC may be either source and must be read before it is overwritten.
    code.push_back(EncodeSopc(0x06, InlineU32(scc), InlineU32(1)));
    check_result(24, 253, InlineU32(1), scc, 1);
    AppendSMovLiteral(&code, 20, 1);
    AppendSMovLiteral(&code, 21, 0);
    code.push_back(EncodeSopc(0x06, InlineU32(scc), InlineU32(1)));
    check_result(24, 20, 253, 1, scc);
  }
  constexpr uint64_t value = 0xfedcba9889abcdefull;
  for (const u32 count : {0u, 1u, 31u, 32u, 33u, 63u, 65u}) {
    AppendSMovLiteral(&code, 20, static_cast<u32>(value));
    AppendSMovLiteral(&code, 21, static_cast<u32>(value >> 32u));
    AppendSMovLiteral(&code, 23, count);
    check_result(20, 20, 23, value, count); // In-place source/destination pair.
    for (const u32 count_reg : {24u, 25u}) {
      AppendSMovLiteral(&code, 20, static_cast<u32>(value));
      AppendSMovLiteral(&code, 21, static_cast<u32>(value >> 32u));
      AppendSMovLiteral(&code, count_reg, count);
      check_result(24, 20, count_reg, value,
                   count); // Count aliases destination.
    }
  }
  for (const u32 count_reg : {20u, 21u}) {
    const uint64_t alias_value =
        count_reg == 20u ? 0x8000000000000021ull : 0x0000002100000001ull;
    AppendSMovLiteral(&code, 20, static_cast<u32>(alias_value));
    AppendSMovLiteral(&code, 21, static_cast<u32>(alias_value >> 32u));
    check_result(20, 20, count_reg, alias_value, 33);
  }
  // Both operands may refer to the single literal word in the instruction.
  check_result(24, 255, 255, 0xffffffffffffffffull, 0xffffffffu, 0xffffffffu);
  for (const u32 source : {0u, 1u}) {
    // Discarding the destination must still update SCC and leave M0 untouched.
    AppendSMovLiteral(&code, 124, 0x5a13abcdu);
    AppendSMovLiteral(&code, 20, 0);
    AppendSMovLiteral(&code, 21, source);
    code.push_back(EncodeSopc(0x06, InlineU32(0), InlineU32(source)));
    code.push_back(EncodeSop2(0x23, 125, 20, InlineU32(0)));
    code.push_back(EncodeSMovB32(26, 253));
    const auto output = static_cast<u32>(test.expected.size());
    AppendStoreSgpr(&code, 26, output);
    AppendStoreSgpr(&code, 124, output + 1u);
    AppendStoreSgprPair(&code, 20, output + 2u);
    test.expected.insert(test.expected.end(), {source, 0x5a13abcdu, 0, source});
    ++instructions;
  }
  AppendEnd(&code);
  test.initial.resize(test.expected.size());
  test.opcodes = {O::BUFFER_LOAD_DWORD,  O::V_READFIRSTLANE_B32,
                  O::S_MOV_B32,          O::S_CMP_EQ_U32,
                  O::S_ASHR_I64,         O::V_MOV_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"S_ASHR_I64", instructions}};
  test.forbidden_spirv = {"OpTypeInt 64"};
  return test;
}

TestCase ScalarAshrI64Masks(u32 wave_size) {
  using O = ShaderOpcode;
  TestCase test;
  test.name =
      wave_size == 64 ? "ScalarAshrI64MasksWave64" : "ScalarAshrI64MasksWave32";
  auto &code = test.code;
  struct Case {
    uint64_t source;
    u32 count;
  };
  constexpr Case cases[] = {
      {0x8000000100000001ull, 1},  {0x8000000100000001ull, 32},
      {0x8000000100000001ull, 63}, {0x0000000100000000ull, 0},
      {0x0000000100000000ull, 32}, {1, 1}};
  for (const u32 mask_reg : {106u, 126u}) {
    for (const auto &item : cases) {
      const auto result = ReferenceAshrI64(item.source, item.count);
      AppendVMovU32(&code, 1, 1);
      AppendVMovU32(&code, 2, 0);
      AppendSMovLiteral(&code, mask_reg, static_cast<u32>(item.source));
      AppendSMovLiteral(&code, mask_reg + 1u,
                        static_cast<u32>(item.source >> 32u));
      code.push_back(
          EncodeSopc(0x06, InlineU32(0), InlineU32(result != 0 ? 1u : 0u)));
      code.push_back(
          EncodeSop2(0x23, mask_reg, mask_reg, InlineU32(item.count)));
      code.push_back(EncodeSMovB32(20, mask_reg));
      code.push_back(EncodeSMovB32(21, mask_reg + 1u));
      code.push_back(EncodeSMovB32(22, 253));
      if (mask_reg == 106u) {
        code.push_back(EncodeVop2(0x01, 2, InlineU32(0), 1));
      } else {
        code.push_back(EncodeVop1(0x01, 2, InlineU32(1)));
      }
      code.push_back(EncodeSop1(0x04, 126, 193)); // Restore EXEC for readback.
      const u32 expected[] = {static_cast<u32>(result),
                              static_cast<u32>(result >> 32u),
                              result != 0 ? 1u : 0u};
      for (u32 i = 0; i < std::size(expected); ++i) {
        AppendStoreSgprAtLaneDwordOffset(
            &code, 20 + i, 0, static_cast<u32>(test.expected.size()));
        test.expected.insert(test.expected.end(), wave_size, expected[i]);
      }
      AppendStoreVgprAtLaneDwordOffset(&code, 2, 0,
                                       static_cast<u32>(test.expected.size()));
      for (u32 lane = 0; lane < wave_size; ++lane) {
        test.expected.push_back(static_cast<u32>((result >> lane) & 1u));
      }
    }
  }
  AppendEnd(&code);
  test.initial.resize(test.expected.size());
  test.opcodes = {O::S_MOV_B32,     O::S_MOV_B64,    O::S_CMP_EQ_U32,
                  O::S_ASHR_I64,    O::V_MOV_B32,    O::V_CNDMASK_B32,
                  O::V_LSHLREV_B32, O::V_ADD_NC_U32, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.decoded_counts = {{"S_ASHR_I64 vcc_lo, vcc_lo", std::size(cases)},
                         {"S_ASHR_I64 exec_lo, exec_lo", std::size(cases)}};
  test.forbidden_spirv = {"OpTypeInt 64"};
  test.compute_info.threads_num[0] = wave_size;
  test.compute_info.threads_num[1] = test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.wave_size = wave_size;
  test.has_compute_info = true;
  return test;
}
TestCase ScalarConditionalMoveB64() {
  using O = ShaderOpcode;
  TestCase test;
  test.name = "ScalarConditionalMoveB64";
  auto &code = test.code;
  for (u32 scc : {0u, 1u}) {
    AppendSMovLiteral(&code, 0, 0x13579bdfu);
    AppendSMovLiteral(&code, 1, 0x2468ace0u);
    AppendSMovLiteral(&code, 2, 0xabcdef01u);
    AppendSMovLiteral(&code, 3, 0xfedcba98u);
    code.push_back(EncodeSopc(0x06, InlineU32(scc), InlineU32(1)));
    code.push_back(EncodeSop1(0x06, 0, 2));
    code.push_back(EncodeSop2(0x0a, 4, InlineU32(1), InlineU32(0)));
    AppendStoreSgprPair(&code, 0, scc * 3);
    AppendStoreSgpr(&code, 4, scc * 3 + 2);
  }
  AppendEnd(&code);
  test.expected = {0x13579bdfu, 0x2468ace0u, 0,
                   0xabcdef01u, 0xfedcba98u, 1};
  test.opcodes = {O::S_MOV_B32, O::S_CMP_EQ_U32, O::S_CMOV_B64,
                  O::S_CSELECT_B32, O::V_MOV_B32, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  return test;
}

TestCase ScalarConditionalMoveB64PreservesMasks() {
  using O = ShaderOpcode;
  TestCase test;
  test.name = "ScalarConditionalMoveB64PreservesMasks";
  auto &code = test.code;
  code.push_back(EncodeSop1(0x04, 16, 126)); // Save full EXEC.
  AppendVMovU32(&code, 1, 3);
  AppendVMovU32(&code, 2, 9);
  u32 offset = 0;
  for (u32 destination : {126u, 106u, 8u}) {
    for (u32 scc : {0u, 1u}) {
      code.push_back(EncodeVopc(0xc2, Vgpr(0), 1)); // Only lane 3.
      code.push_back(EncodeSop1(0x04, destination, 106));
      code.push_back(EncodeSopc(0x06, InlineU32(scc), InlineU32(1)));
      // EXEC encoding is the captured Pathless instruction, 0xbefe06c1.
      code.push_back(EncodeSop1(0x06, destination, 193u));
      code.push_back(EncodeSop2(0x0a, 4, InlineU32(1), InlineU32(0)));
      code.push_back(EncodeSop1(0x04, 126, destination));
      AppendStoreVgprAtLaneDwordOffset(&code, 2, 0, offset);
      code.push_back(EncodeSop1(0x04, 126, 16));
      AppendStoreSgprAtLaneDwordOffset(&code, 4, 0, offset + 64);
      for (u32 lane = 0; lane < 64; ++lane) {
        test.expected.push_back(scc || lane == 3 ? 9u : 0xdeadbeefu);
      }
      test.expected.insert(test.expected.end(), 64, scc);
      offset += 128;
    }
  }
  AppendEnd(&code);
  test.initial.assign(test.expected.size(), 0xdeadbeefu);
  test.opcodes = {O::S_MOV_B64, O::V_MOV_B32, O::V_CMP_EQ_U32,
                  O::S_CMP_EQ_U32, O::S_CMOV_B64, O::S_CSELECT_B32,
                  O::V_LSHLREV_B32, O::V_ADD_NC_U32, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.compute_info.threads_num[0] = 64;
  test.compute_info.threads_num[1] = test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.wave_size = 64;
  test.has_compute_info = true;
  return test;
}

TestCase ScalarAndn2B64SccUsesMaskShadow() {
  using O = ShaderOpcode;

  std::vector<u32> code = {
      EncodeVopc(0xc2, InlineU32(0), 0),
      EncodeSop1(0x04, 0, 106),
      EncodeSop2(0x15, 4, 0, InlineU32(0)),
      EncodeVop1(0x01, 0, InlineU32(1)),
      EncodeSopp(0x04, 1),
      EncodeVop1(0x01, 0, InlineU32(7)),
  };
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  return {"ScalarAndn2B64SccUsesMaskShadow",
          code,
          {},
          {7},
          {O::V_CMP_EQ_U32, O::S_MOV_B64, O::S_ANDN2_B64, O::V_MOV_B32,
           O::S_CBRANCH_SCC0, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarMaskHighWriteInvalidatesProvenance() {
  using O = ShaderOpcode;

  std::vector<u32> code = {
      EncodeVopc(0xc2, Vgpr(0), 0),      EncodeSop1(0x04, 0, 106),
      EncodeSMovB32(1, InlineU32(1)),    EncodeSop1(0x08, 2, 0),
      EncodeVop1(0x01, 0, InlineU32(1)), EncodeSopp(0x04, 1),
      EncodeVop1(0x01, 0, InlineU32(7)),
  };
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  return {"ScalarMaskHighWriteInvalidatesProvenance",
          code,
          {},
          {7},
          {O::V_CMP_EQ_U32, O::S_MOV_B64, O::S_MOV_B32, O::S_NOT_B64,
           O::V_MOV_B32, O::S_CBRANCH_SCC0, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase ScalarSelectB64PreservesMaskProvenance() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  const auto set_scc = [&] {
    code.push_back(EncodeSopc(0x06, InlineU32(1), InlineU32(1)));
  };
  const auto capture_scc = [&](u32 dst) {
    code.push_back(EncodeSop2(0x0a, dst, InlineU32(1), InlineU32(0)));
  };

  AppendSMovLiteral(&code, 0, 0xfffffffeu);
  AppendSMovLiteral(&code, 1, 0xffffffffu);
  code.push_back(EncodeSMovB32(2, InlineU32(0)));
  code.push_back(EncodeSMovB32(3, InlineU32(0)));
  set_scc();
  code.push_back(EncodeSop2(0x0b, 4, 0, 2));
  code.push_back(EncodeSop1(0x08, 6, 4));
  capture_scc(8);

  code.push_back(EncodeVopc(0xc2, Vgpr(0), 0));
  code.push_back(EncodeSop1(0x04, 10, 106));
  set_scc();
  code.push_back(EncodeSop2(0x0b, 12, 10, 2));
  code.push_back(EncodeSop1(0x08, 14, 12));
  capture_scc(16);

  AppendStoreSgpr(&code, 8, 0);
  AppendStoreSgpr(&code, 16, 1);
  AppendEnd(&code);

  return {"ScalarSelectB64PreservesMaskProvenance",
          code,
          {},
          {1, 1},
          {O::S_MOV_B32, O::S_CMP_EQ_U32, O::S_CSELECT_B64, O::S_NOT_B64,
           O::S_CSELECT_B32, O::V_CMP_EQ_U32, O::S_MOV_B64, O::V_MOV_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarWqmB32Masks(u32 wave_size) {
  using O = ShaderOpcode;
  TestCase test;
  test.name = wave_size == 64 ? "ScalarWqmB32MasksWave64" : "ScalarWqmB32MasksWave32";
  auto &code = test.code;
  const auto store_scalar = [&](u32 reg, u32 expected) {
    AppendStoreSgprAtLaneDwordOffset(&code, reg, 0,
                                    static_cast<u32>(test.expected.size()));
    test.expected.insert(test.expected.end(), wave_size, expected);
  };
  const auto store_marker = [&](u32 lo, u32 hi) {
    AppendStoreVgprAtLaneDwordOffset(&code, 2, 0,
                                    static_cast<u32>(test.expected.size()));
    for (u32 lane = 0; lane < wave_size; ++lane) {
      const u32 mask = lane < 32 ? lo : hi;
      test.expected.push_back(((mask >> (lane % 32)) & 1u) != 0 ? 9u : 0u);
    }
  };
  constexpr u32 other_half = 0x2468ace0u;
  constexpr u32 masks[] = {0, 1, 8, 0x10, 0x100, 0x80000000u, 0x12481248u, ~0u};
  for (u32 mask : masks) {
    u32 expanded = 0;
    for (u32 bit = 0; bit < 32; bit += 4) {
      if ((mask & (0xfu << bit)) != 0) expanded |= 0xfu << bit;
    }
    AppendVMovU32(&code, 2, 0);
    AppendSMovLiteral(&code, 126, mask);
    AppendSMovLiteral(&code, 127, other_half);
    code.push_back(EncodeSopc(0x06, InlineU32(0), InlineU32(mask == 0 ? 0 : 1)));
    code.push_back(0xbefe097eu); // Captured S_WQM_B32 EXEC_LO, EXEC_LO.
    code.push_back(EncodeSMovB32(20, 126));
    code.push_back(EncodeSMovB32(21, 127));
    code.push_back(EncodeSMovB32(22, 253));
    AppendVMovU32(&code, 2, 9);
    code.push_back(EncodeSop1(0x04, 126, 193));
    store_scalar(20, expanded);
    store_scalar(21, other_half);
    store_scalar(22, mask != 0 ? 1u : 0u);
    store_marker(expanded, other_half);
  }
  // VALU-produced masks keep WQM dynamic and carry provenance through S_MOV_B64.
  // Updating either word must invalidate an old SGPR-pair predicate and preserve
  // the other word. Wave32 still reads/writes the scalar high half independently.
  for (u32 base : {8u, 106u, 126u}) {
    for (u32 half : {0u, 1u}) {
      AppendVMovU32(&code, 2, 0);
      code.push_back(EncodeVop2(0x1b, 1, InlineU32(31), 0));
      code.push_back(EncodeVopc(0xc2, InlineU32(3), 1)); // Lanes 3 and 35.
      code.push_back(EncodeSop1(0x04, base, 106));
      code.push_back(EncodeSop1(0x09, base + half, base + half));
      code.push_back(EncodeSMovB32(20, base));
      code.push_back(EncodeSMovB32(21, base + 1));
      code.push_back(EncodeSMovB32(22, 253));
      code.push_back(EncodeSop1(0x04, 126, base));
      AppendVMovU32(&code, 2, 9);
      code.push_back(EncodeSop1(0x04, 126, 193));
      const u32 lo = half == 0 ? 0xfu : 8u;
      const u32 hi = wave_size == 32 ? 0u : half == 1 ? 0xfu : 8u;
      store_scalar(20, lo);
      store_scalar(21, hi);
      store_scalar(22, wave_size == 32 && half == 1 ? 0u : 1u);
      store_marker(lo, hi);
    }
  }
  AppendEnd(&code);
  test.initial.resize(test.expected.size());
  test.opcodes = {O::S_WQM_B32, O::S_MOV_B32, O::S_MOV_B64, O::S_CMP_EQ_U32,
                  O::V_CMP_EQ_U32, O::V_MOV_B32, O::V_AND_B32, O::V_ADD_NC_U32,
                  O::V_LSHLREV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"S_WQM_B32 exec_lo, exec_lo", 9}};
  test.compute_info.threads_num[0] = wave_size;
  test.compute_info.threads_num[1] = test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.wave_size = wave_size;
  test.has_compute_info = true;
  return test;
}

TestCase ScalarWqmB64SelectsSccDomain() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  const auto capture_scc = [&](u32 dst) {
    code.push_back(EncodeSop2(0x0a, dst, InlineU32(1), InlineU32(0)));
  };

  code.push_back(EncodeSMovB32(0, InlineU32(0)));
  code.push_back(EncodeSMovB32(1, InlineU32(1)));
  code.push_back(EncodeSop1(0x0a, 2, 0));
  capture_scc(4);

  code.push_back(EncodeVopc(0xc2, Vgpr(0), 0));
  code.push_back(EncodeSop1(0x04, 6, 106));
  code.push_back(EncodeSop1(0x08, 8, 6));
  code.push_back(EncodeSop1(0x0a, 10, 8));
  capture_scc(12);

  AppendStoreSgpr(&code, 4, 0);
  AppendStoreSgpr(&code, 12, 1);
  AppendEnd(&code);

  return {"ScalarWqmB64SelectsSccDomain",
          code,
          {},
          {1, 1},
          {O::S_MOV_B32, O::S_WQM_B64, O::S_CSELECT_B32, O::V_CMP_EQ_U32,
           O::S_MOV_B64, O::S_NOT_B64, O::V_MOV_B32, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase ScalarWqmB64PreservesPartialMasks() {
  using O = ShaderOpcode;
  TestCase test;
  test.name = "ScalarWqmB64PreservesPartialMasks";
  auto &code = test.code;
  code.push_back(EncodeSop1(0x04, 16, 126)); // Save full EXEC.
  AppendVMovU32(&code, 1, 3);
  AppendVMovU32(&code, 2, 9);
  u32 offset = 0;
  for (const u32 destination : {126u, 106u, 8u}) {
    code.push_back(EncodeVopc(0xc2, Vgpr(0), 1)); // Only lane 3.
    code.push_back(EncodeSop1(0x04, destination, 106));
    code.push_back(EncodeSop1(0x0a, destination, destination));
    code.push_back(EncodeSop1(0x04, 126, destination));
    AppendStoreVgprAtLaneDwordOffset(&code, 2, 0, offset);
    code.push_back(EncodeSop1(0x04, 126, 16));
    offset += 64;
  }
  code.push_back(EncodeSMovB32(8, InlineU32(32))); // Raw bits 5 and 33.
  code.push_back(EncodeSMovB32(9, InlineU32(2)));
  code.push_back(EncodeSop1(0x0a, 10, 8));
  code.push_back(EncodeSop1(0x04, 126, 10));
  AppendStoreVgprAtLaneDwordOffset(&code, 2, 0, offset);
  AppendEnd(&code);
  test.initial.assign(256, 0xdeadbeef);
  test.expected = test.initial;
  for (u32 lane = 0; lane < 64; ++lane) {
    for (u32 region = 0; region < 3; ++region) {
      if (lane < 4) test.expected[region * 64 + lane] = 9;
    }
    if ((lane >= 4 && lane < 8) || (lane >= 32 && lane < 36)) {
      test.expected[192 + lane] = 9;
    }
  }
  test.opcodes = {O::S_MOV_B64, O::S_MOV_B32, O::S_WQM_B64, O::V_MOV_B32,
                  O::V_CMP_EQ_U32, O::V_LSHLREV_B32, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.compute_info.threads_num[0] = 64;
  test.compute_info.threads_num[1] = test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase ScalarMaskProvenanceOverlapAndMixedBinary() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  const auto capture_scc = [&](u32 dst) {
    code.push_back(EncodeSop2(0x0a, dst, InlineU32(1), InlineU32(0)));
  };

  code.push_back(EncodeVopc(0xc2, Vgpr(0), 0));
  code.push_back(EncodeSop1(0x04, 0, 106));
  code.push_back(EncodeSop1(0x04, 1, 0));
  code.push_back(EncodeSop1(0x08, 3, 1));
  capture_scc(5);

  code.push_back(EncodeVopc(0xc2, Vgpr(0), 0));
  code.push_back(EncodeSop1(0x04, 8, 106));
  code.push_back(EncodeSMovB32(10, InlineU32(1)));
  code.push_back(EncodeSMovB32(11, InlineU32(0)));
  code.push_back(EncodeSop2(0x19, 12, 8, 10));
  capture_scc(14);

  AppendStoreSgpr(&code, 5, 0);
  AppendStoreSgpr(&code, 14, 1);
  AppendEnd(&code);

  return {"ScalarMaskProvenanceOverlapAndMixedBinary",
          code,
          {},
          {1, 1},
          {O::V_CMP_EQ_U32, O::S_MOV_B64, O::S_NOT_B64, O::S_CSELECT_B32,
           O::S_MOV_B32, O::S_NAND_B64, O::V_MOV_B32, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase ScalarLiteral() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendSMovLiteral(&code, 0, 0x12345678u);
  code.push_back(EncodeVop1(0x01, 0, 0));
  AppendBufferStoreDword(&code, 0, 30);
  AppendEnd(&code);
  return {"ScalarLiteral",
          code,
          {},
          {0x12345678u},
          {O::S_MOV_B32, O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorMoves() {
  using O = ShaderOpcode;

  std::vector<u32> code = {
      EncodeVop1(0x00, 0, 0),
      EncodeVop1(0x01, 0, InlineU32(5)),
      EncodeVop1(0x01, 2, Vgpr(0)),
  };
  AppendBufferStoreDword(&code, 2, 30);
  AppendEnd(&code);
  return {"VectorRegisterMoves",
          code,
          {},
          {5},
          {O::V_NOP, O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorVop3MoveAppliesFloatSourceModifiers() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendSMovLiteral(&code, 24, 0x40000000u);
  AppendVop3(&code, 0x181, 1, 24, 0, 0, 0, 0, false, 0, 0x1);
  AppendStoreVgpr(&code, 1, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorVop3MoveAppliesFloatSourceModifiers";
  test.code = code;
  test.expected = {0xc0000000u};
  test.opcodes = {O::S_MOV_B32, O::V_MOV_B32, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.required_spirv = {"OpFNegate"};
  return test;
}

TestCase VectorIntegerOps() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0xfffffff8u);
  code.push_back(EncodeVop1(0x01, 1, InlineU32(5)));
  code.push_back(EncodeVop1(0x01, 4, InlineU32(7)));
  AppendVMovLiteral(&code, 10, 0x01000001u);
  code.push_back(EncodeVop1(0x01, 11, InlineU32(2)));
  AppendVMovLiteral(&code, 12, 0x0f0f0f0fu);
  AppendVMovLiteral(&code, 13, 0x33333333u);
  AppendVMovLiteral(&code, 14, 0xfffffff0u);
  code.push_back(EncodeVop1(0x01, 15, InlineU32(4)));
  code.push_back(EncodeVop1(0x01, 29, InlineU32(15)));

  code.push_back(EncodeVop2(0x11, 2, Vgpr(0), 1));
  code.push_back(EncodeVop2(0x12, 3, Vgpr(0), 1));
  code.push_back(EncodeVop2(0x13, 5, Vgpr(0), 1));
  code.push_back(EncodeVop2(0x14, 6, Vgpr(0), 1));
  code.push_back(EncodeVop2(0x25, 7, Vgpr(4), 1));
  code.push_back(EncodeVop2(0x26, 8, Vgpr(4), 1));
  code.push_back(EncodeVop2(0x27, 9, InlineU32(3), 4));
  code.push_back(EncodeVop2(0x26, 35, 249, 11));
  code.push_back(EncodeVop2Sdwa(12, 6, 0, 0, 6));
  code.push_back(EncodeVop2(0x27, 36, 249, 11));
  code.push_back(EncodeVop2Sdwa(12, 6, 0, 0, 6));
  code.push_back(EncodeVop2(0x0b, 16, Vgpr(10), 11));
  code.push_back(EncodeVop2(0x09, 37, Vgpr(0), 1));
  code.push_back(EncodeVop2(0x1b, 17, Vgpr(12), 13));
  code.push_back(EncodeVop2(0x1c, 18, Vgpr(12), 13));
  code.push_back(EncodeVop2(0x1d, 19, Vgpr(12), 13));
  code.push_back(EncodeVop2(0x1e, 20, Vgpr(12), 13));
  code.push_back(EncodeVop2(0x19, 21, Vgpr(11), 15));
  code.push_back(EncodeVop2(0x1a, 22, InlineU32(4), 11));
  code.push_back(EncodeVop2(0x15, 23, Vgpr(14), 15));
  code.push_back(EncodeVop2(0x16, 24, InlineU32(4), 14));
  code.push_back(EncodeVop2(0x17, 25, Vgpr(14), 15));
  code.push_back(EncodeVop2(0x18, 26, InlineU32(4), 14));
  code.push_back(EncodeVop1(0x37, 27, Vgpr(12)));
  code.push_back(EncodeVop1(0x38, 28, Vgpr(29)));
  code.push_back(EncodeVop1(0x3a, 30, Vgpr(11)));
  code.push_back(EncodeVop1(0x39, 32, Vgpr(11)));
  code.push_back(EncodeVopc(0xc2, Vgpr(4), 4));
  code.push_back(EncodeVop2(0x01, 33, InlineU32(3), 4));
  code.push_back(EncodeVop2(0x11, 34, 249, 4));
  code.push_back(EncodeVop2Sdwa(0));

  const u32 results[] = {2,  3,  5,  6,  7,  8,  9,  35, 36, 16, 37, 17, 18, 19,
                         20, 21, 22, 23, 24, 25, 26, 27, 28, 30, 32, 33, 34};
  for (u32 i = 0; i < static_cast<u32>(std::size(results)); i++) {
    AppendStoreVgpr(&code, results[i], i);
  }
  AppendEnd(&code);

  return {"VectorIntegerOps",
          code,
          {},
          {0xfffffff8u, 5,           5,           0xfffffff8u, 12,
           2,           4,           13,          0xfffffff3u, 2,
           0xffffffd8u, 0x03030303u, 0x3f3f3f3fu, 0x3c3c3c3cu, 0xc3c3c3c3u,
           32,          32,          0x0fffffffu, 0x0fffffffu, 0xffffffffu,
           0xffffffffu, 0xf0f0f0f0u, 0xf0000000u, 1,           30,
           7,           0xfffffff8u},
          {O::V_MOV_B32,     O::V_MIN_I32,       O::V_MAX_I32,
           O::V_MIN_U32,     O::V_MAX_U32,       O::V_ADD_NC_U32,
           O::V_SUB_NC_U32,  O::V_SUBREV_NC_U32, O::V_MUL_U32_U24,
           O::V_MUL_I32_I24, O::V_AND_B32,       O::V_OR_B32,
           O::V_XOR_B32,     O::V_XNOR_B32,      O::V_LSHL_B32,
           O::V_LSHLREV_B32, O::V_LSHR_B32,      O::V_LSHRREV_B32,
           O::V_ASHR_I32,    O::V_ASHRREV_I32,   O::V_NOT_B32,
           O::V_BFREV_B32,   O::V_FFBL_B32,      O::V_FFBH_U32,
           O::V_CMP_EQ_U32,  O::V_CNDMASK_B32,   O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase VectorFfbhI32NativeAndVop3OnGpu() {
  using O = ShaderOpcode;

  constexpr std::array inputs = {0x00000000u, 0x40000000u, 0x80000000u,
                                 0x0fffffffu, 0xffff0000u, 0xfffffffeu,
                                 0xffffffffu, 0x80000000u};
  std::vector<u32> code;
  for (u32 i = 0; i < inputs.size() - 1u; i++) {
    AppendVMovU32(&code, 30, i * 4u);
    AppendBufferLoadDword(&code, 14, 30);
    code.push_back(0x7e1c770eu); // v_ffbh_i32 v14, v14
    AppendStoreVgpr(&code, 14, i);
  }
  AppendVMovU32(&code, 30, (inputs.size() - 1u) * 4u);
  AppendBufferLoadDword(&code, 14, 30);
  AppendVop3(&code, 0x1bbu, 15, Vgpr(14), 0);
  AppendStoreVgpr(&code, 15, inputs.size() - 1u);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorFfbhI32NativeAndVop3OnGpu";
  test.code = std::move(code);
  test.initial.assign(inputs.begin(), inputs.end());
  test.expected = {0xffffffffu, 1u, 1u, 4u, 16u, 31u, 0xffffffffu, 1u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_DWORD, O::V_FFBH_I32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"V_FFBH_I32 v14, v14", inputs.size() - 1u},
                         {"V_FFBH_I32 v15, v14", 1u}};
  return test;
}

TestCase Vop1SdwaFfblCapturedHighWordSource() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendBufferLoadDword(&code, 2, 30);
  code.push_back(0x7e2074f9u);
  code.push_back(0x00050602u); // v_ffbl_b32 v16, v2.word1
  AppendStoreVgpr(&code, 16, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "Vop1SdwaFfblCapturedHighWordSource";
  test.code = std::move(code);
  test.initial = {0x00400000u};
  test.expected = {6u};
  test.opcodes = {O::BUFFER_LOAD_DWORD, O::V_FFBL_B32, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.decoded_counts = {{"V_FFBL_B32 v16, v2.sdwa(sel=5,sext=0)", 1}};
  test.ir_counts = {{" = BitFieldUExtract ", 1}, {" = FindILsb32 ", 1}};
  test.required_spirv = {"OpBitFieldUExtract"};
  return test;
}

TestCase Vop1SdwaNotCapturedByte0Source() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendBufferLoadDword(&code, 2, 30);
  code.push_back(0x7e046ef9u);
  code.push_back(0x00000602u); // v_not_b32 v2, v2.byte0
  AppendStoreVgpr(&code, 2, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "Vop1SdwaNotCapturedByte0Source";
  test.code = std::move(code);
  test.initial = {0x12345678u};
  test.expected = {0xffffff87u};
  test.opcodes = {O::BUFFER_LOAD_DWORD, O::V_NOT_B32, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.decoded_counts = {{"V_NOT_B32 v2, v2.sdwa(sel=0,sext=0)", 1}};
  test.ir_counts = {{" = BitFieldUExtract ", 1}, {" = BitwiseNot32 ", 1}};
  test.required_spirv = {"OpBitFieldUExtract", "OpNot"};
  return test;
}

TestCase Vop1SdwaMovByteDestinations() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendBufferLoadDword(&code, 3, 30);
  AppendVMovU32(&code, 30, 4);
  AppendBufferLoadDword(&code, 2, 30);
  code.push_back(EncodeVop1(0x01, 1, Vgpr(3)));
  code.push_back(0x7e0202f9u);
  code.push_back(0x00861280u); // Captured v_mov_b32 v1.byte2, 0, preserve.
  AppendStoreVgpr(&code, 1, 2);

  // RDNA2 table 88: select any byte, then pad, sign extend, or preserve.
  for (u32 dst_u = 0; dst_u < 3; dst_u++) {
    for (u32 dst_sel = 0; dst_sel < 4; dst_sel++) {
      code.push_back(EncodeVop1(0x01, 1, Vgpr(3)));
      code.push_back(EncodeVop1(0x01, 1, 249));
      code.push_back(EncodeVop1Sdwa(2, dst_sel, dst_u));
      AppendStoreVgpr(&code, 1, 3 + dst_u * 4 + dst_sel);
    }
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "Vop1SdwaMovByteDestinations";
  test.code = std::move(code);
  test.initial = {0xa1b2c3d4u, 0x12345680u};
  test.expected = {0xa1b2c3d4u, 0x12345680u, 0xa100c3d4u,
                   0x00000080u, 0x00008000u, 0x00800000u, 0x80000000u,
                   0xffffff80u, 0xffff8000u, 0xff800000u, 0x80000000u,
                   0xa1b2c380u, 0xa1b280d4u, 0xa180c3d4u, 0x80b2c3d4u};
  test.initial.resize(test.expected.size());
  test.opcodes = {O::BUFFER_LOAD_DWORD, O::V_MOV_B32, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.decoded_counts = {{"V_MOV_B32 v1.sdwa(sel=2,sext=0), 0", 1}};
  test.required_spirv = {"OpBitFieldInsert", "OpBitFieldSExtract", "OpBitwiseOr"};
  return test;
}

TestCase Vop2SdwaSubNcExactByte2Destination() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 11, 2);
  code.push_back(0x4c1616f9u);
  code.push_back(0x0686128du);
  AppendStoreVgpr(&code, 11, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "Vop2SdwaSubNcExactByte2Destination";
  test.code = code;
  test.expected = {0x000b0002u};
  test.opcodes = {O::V_MOV_B32, O::V_SUB_NC_U32, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  return test;
}

TestCase Vop2SdwaAddNcCapturedHighWordDestination() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendBufferLoadDword(&code, 0, 30);
  code.push_back(EncodeVop1(0x02, 106, Vgpr(0)));
  AppendVMovLiteral(&code, 97, 0x00030004u);
  AppendVMovLiteral(&code, 4, 0xa1b2c3d4u);
  code.push_back(0x4a08c2f9u);
  code.push_back(0x0686156au);
  AppendStoreVgpr(&code, 4, 1);
  AppendEnd(&code);

  TestCase test;
  test.name = "Vop2SdwaAddNcCapturedHighWordDestination";
  test.code = std::move(code);
  test.initial = {0x00010002u, 0};
  test.expected = {0x00010002u, 0x0006c3d4u};
  test.opcodes = {O::BUFFER_LOAD_DWORD, O::V_READFIRSTLANE_B32, O::V_MOV_B32,
                  O::V_ADD_NC_U32,      O::BUFFER_STORE_DWORD,  O::S_ENDPGM};
  test.required_spirv = {"OpIAdd", "OpShiftLeftLogical", "OpBitwiseOr"};
  return test;
}

TestCase Vop2SdwaAshrrevCapturedWord0SignExtends() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendBufferLoadDword(&code, 1, 30);
  code.push_back(0x303202f9u);
  code.push_back(0x0c860686u); // v_ashrrev_i32 v25, 6, sign_extend(v1.word0)
  AppendStoreVgpr(&code, 25, 1);
  AppendEnd(&code);

  TestCase test;
  test.name = "Vop2SdwaAshrrevCapturedWord0SignExtends";
  test.code = std::move(code);
  test.initial = {0xabcd8000u, 0};
  test.expected = {0xabcd8000u, 0xfffffe00u};
  test.opcodes = {O::BUFFER_LOAD_DWORD, O::V_ASHRREV_I32, O::V_MOV_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"V_ASHRREV_I32 v25, 6, v1.sdwa(sel=4,sext=1)", 1}};
  test.ir_counts = {{" = BitFieldSExtract ", 1},
                    {" = ShiftRightArithmetic32 ", 1}};
  test.required_spirv = {"OpBitFieldSExtract", "OpShiftRightArithmetic"};
  return test;
}

TestCase Vop2SdwaLshrrevCapturedByte1Source() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendSMovLiteral(&code, 106, 4);
  AppendBufferLoadDword(&code, 8, 30);
  code.push_back(0x2c1210f9u);
  code.push_back(0x0186066au); // v_lshrrev_b32 v9, vcc_lo, v8.byte1
  AppendStoreVgpr(&code, 9, 1);
  AppendEnd(&code);

  TestCase test;
  test.name = "Vop2SdwaLshrrevCapturedByte1Source";
  test.code = std::move(code);
  test.initial = {0x12348678u, 0};
  test.expected = {0x12348678u, 8};
  test.opcodes = {O::S_MOV_B32, O::BUFFER_LOAD_DWORD, O::V_LSHRREV_B32,
                  O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {
      {"V_LSHRREV_B32 v9, vcc_lo, v8.sdwa(sel=1,sext=0)", 1}};
  test.ir_counts = {{" = BitFieldUExtract ", 1},
                    {" = ShiftRightLogical32 ", 1}};
  test.required_spirv = {"OpBitFieldUExtract", "OpShiftRightLogical"};
  return test;
}

TestCase Vop2SdwaSubNcPreservesByteAndWordDestinations() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 0, 3);
  for (u32 dst = 10; dst <= 15; dst++) {
    AppendVMovLiteral(&code, dst, 0xa1b2c3d4u);
  }
  for (u32 sel = 0; sel <= 5; sel++) {
    code.push_back(EncodeVop2(0x26, 10 + sel, 249, 0));
    code.push_back(
        EncodeVop2Sdwa(InlineU32(20), sel, 2, 6, 6, 0, 0, 0, 0, 0, 0, 1));
    AppendStoreVgpr(&code, 10 + sel, sel);
  }
  AppendEnd(&code);

  return {"Vop2SdwaSubNcPreservesByteAndWordDestinations",
          code,
          {},
          {0xa1b2c311u, 0xa1b211d4u, 0xa111c3d4u, 0x11b2c3d4u, 0xa1b20011u,
           0x0011c3d4u},
          {O::V_MOV_B32, O::V_SUB_NC_U32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase Vop3CvtPkI16I32Captured() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendBufferLoadDword(&code, 7, 30);
  AppendVMovU32(&code, 30, 4);
  AppendBufferLoadDword(&code, 16, 30);
  code.push_back(0xd76b0005u);
  code.push_back(0x00022107u); // v_cvt_pk_i16_i32 v5, v7, v16
  AppendStoreVgpr(&code, 5, 2);
  AppendEnd(&code);

  TestCase test;
  test.name = "Vop3CvtPkI16I32Captured";
  test.code = std::move(code);
  test.initial = {0x00018001u, 0xfffe7ffeu, 0};
  test.expected = {0x00018001u, 0xfffe7ffeu, 0x7ffe8001u};
  test.opcodes = {O::BUFFER_LOAD_DWORD, O::V_MOV_B32, O::V_CVT_PK_I16_I32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"0x00000014: V_CVT_PK_I16_I32 v5, v7, v16\n", 1}};
  test.ir_counts = {{" = BitwiseAnd32 ", 2},
                    {" = ShiftLeftLogical32 ", 1},
                    {" = BitwiseOr32 ", 1}};
  test.required_spirv = {"OpBitwiseAnd", "OpShiftLeftLogical", "OpBitwiseOr"};
  return test;
}

TestCase Vop3MulLoU16CapturedAndSelectors() {
  using O = ShaderOpcode;

  TestCase test;
  test.name = "Vop3MulLoU16CapturedAndSelectors";
  // Distinct runtime halves expose source selection and prevent constant folding.
  test.initial = {0x00138001u, 0x0005ffffu, 0xffffffffu};
  test.expected = {0x00138001u, 0x0005ffffu, 0xffffffffu,
                   0xa5a57fffu, 0xa5a5ffedu, 0xa5a58005u, 0xa5a5005fu,
                   0x7fff1234u, 0xffed1234u, 0x80051234u, 0x005f1234u,
                   0xffff0001u, 0x00231234u};
  auto &code = test.code;
  AppendBufferLoadDword(&code, 12, 30);
  AppendVMovU32(&code, 30, 4);
  AppendBufferLoadDword(&code, 24, 30);
  u32 output = 3;
  for (u32 selectors : {0u, 1u, 2u, 3u, 8u, 9u, 10u, 11u}) {
    AppendVMovLiteral(&code, 2, 0xa5a51234u);
    if (selectors == 8u) {
      code.push_back(0xd7054002u);
      code.push_back(0x0002310cu); // Captured v_mul_lo_u16 v2.hi, v12.lo, v24.lo.
    } else {
      AppendVop3(&code, 0x305, 2, Vgpr(12), Vgpr(24), 0, 0, selectors);
    }
    AppendStoreVgpr(&code, 2, output++);
  }

  // 0xffff * 0xffff wraps to 1; aliasing preserves the original high half.
  AppendVMovU32(&code, 30, 8);
  AppendBufferLoadDword(&code, 12, 30);
  AppendVop3(&code, 0x305, 12, Vgpr(12), Vgpr(12), 0, 0, 1);
  AppendStoreVgpr(&code, 12, output++);

  AppendVMovLiteral(&code, 2, 0xa5a51234u);
  AppendVop3(&code, 0x305, 2, 255, Vgpr(24), 0, 0, 11);
  code.push_back(0x0007deadu); // Select literal high half: 7 * 5 = 35.
  AppendStoreVgpr(&code, 2, output);
  AppendEnd(&code);
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_DWORD, O::V_MUL_LO_U16,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"V_MUL_LO_U16", 10}};
  test.required_spirv = {"OpIMul"};
  return test;
}

TestCase Vop3MadI16CapturedSelectorsAndSaturation() {
  using O = ShaderOpcode;
  struct MadCase {
    u32 lhs, rhs, addend, expected;
    u32 selectors = 0;
    bool clamp = false;
    u32 dst = 1;
  };
  constexpr u32 a = 0x8000fffdu, b = 0xfffe0005u, c = 0xfff90007u;
  const std::array<MadCase, 14> cases{{
      {a, b, c, 0xa5a5fff8u}, // Captured: -3 * 5 + 7 = -8.
      {a, b, c, 0x8007beefu, 9}, // Source 0 high; destination high.
      {a, b, c, 0xa5a5000du, 2}, // Source 1 high: -3 * -2 + 7.
      {a, b, c, 0xa5a5ffeau, 4}, // Source 2 high: -3 * 5 - 7.
      {a, b, c, 0xfff9beefu, 15}, // All high: -32768 * -2 - 7 wraps.
      {a, b, c, 0xfff8fffdu, 8, false, 9}, // Destination aliases source 0.
      {0x7fffu, 1, 1, 0xa5a58000u},
      {0x7fffu, 1, 1, 0x7fffbeefu, 8, true}, // Positive saturation.
      {0x8000u, 1, 0xffffu, 0xa5a57fffu},
      {0x8000u, 1, 0xffffu, 0x8000beefu, 8, true}, // Negative saturation.
      {0x8000u, 0x8000u, 0xffffu, 0xa5a5ffffu},
      {0x8000u, 0x8000u, 0xffffu, 0xa5a57fffu, 0, true},
      {200, 200, 0xd8f0u, 0xa5a57530u, 0, true}, // 40000 - 10000 = 30000.
      {200, 0xff38u, 10000, 0xa5a58ad0u, 0, true}, // -40000 + 10000 = -30000.
  }};
  TestCase test;
  test.name = "Vop3MadI16CapturedSelectorsAndSaturation";
  for (const auto &entry : cases) {
    test.initial.insert(test.initial.end(), {entry.lhs, entry.rhs, entry.addend});
  }
  test.expected = test.initial;
  auto &code = test.code;
  for (u32 i = 0; i < cases.size(); ++i) {
    const auto &entry = cases[i];
    u32 offset = i * 12u;
    for (u32 reg : {9u, 6u, 15u}) {
      AppendVMovU32(&code, 30, offset);
      AppendBufferLoadDword(&code, reg, 30); // Runtime inputs prevent folding.
      offset += 4u;
    }
    AppendVMovLiteral(&code, 1, 0xa5a5beefu);
    if (i == 0u) {
      code.insert(code.end(), {0xd75e0001u, 0x043e0d09u});
    } else {
      AppendVop3(&code, 0x35e, entry.dst, Vgpr(9), Vgpr(6), Vgpr(15), 0,
                  entry.selectors, entry.clamp);
    }
    AppendStoreVgpr(&code, entry.dst, static_cast<u32>(test.initial.size()) + i);
    test.expected.push_back(entry.expected);
  }
  AppendEnd(&code);
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_DWORD, O::V_MAD_I16,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"V_MAD_I16", cases.size()}};
  test.required_spirv = {"OpIMul", "OpIAdd"};
  return test;
}

TestCase Vop3Med3I16Captured() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 5, 0x8ad003e8u);  // high=-30000, low=1000
  AppendSMovLiteral(&code, 25, 0xb1e04e20u); // high=-20000, low=20000
  AppendSMovLiteral(&code, 27, 0x7530fc18u); // high=30000, low=-1000
  AppendVMovLiteral(&code, 3, 0x1234cafeu);
  code.push_back(0xd7584803u);
  code.push_back(0x006c3305u); // v_med3_i16 v3.hi, v5.hi, s25.lo, s27.lo
  AppendStoreVgpr(&code, 3, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "Vop3Med3I16Captured";
  test.code = std::move(code);
  test.expected = {0xfc18cafeu};
  test.opcodes = {O::V_MOV_B32, O::S_MOV_B32, O::V_MED3_I16,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"0x00000020: V_MED3_I16 v3.sdwa(sel=5,sext=0), "
                          "v5.opsel(lo=1,hi=0,neghi=0), s25, s27\n",
                          1}};
  test.required_spirv = {"OpSLessThan"};
  return test;
}

TestCase Vop2SdwaMinU32PreservesWordDestination() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 10, 0xa1b2c3d4u);
  AppendVMovU32(&code, 12, 7);
  code.push_back(0x261418f9u);
  code.push_back(0x0686149fu);
  AppendStoreVgpr(&code, 10, 0);
  AppendVMovLiteral(&code, 10, 0xa1b2c3d4u);
  AppendVMovU32(&code, 12, 64);
  code.push_back(0x261418f9u);
  code.push_back(0x0686149fu);
  AppendStoreVgpr(&code, 10, 1);
  AppendEnd(&code);

  TestCase test;
  test.name = "Vop2SdwaMinU32PreservesWordDestination";
  test.code = code;
  test.expected = {0xa1b20007u, 0xa1b2001fu};
  test.opcodes = {O::V_MOV_B32, O::V_MIN_U32, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.required_spirv = {"OpULessThan", "OpSelect"};
  return test;
}

TestCase VectorShiftCountsMaskLowBits() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 0, 1);
  AppendVMovU32(&code, 1, 32);
  AppendVMovU32(&code, 2, 33);
  AppendVMovLiteral(&code, 3, 0x80000000u);
  code.push_back(EncodeVop2(0x19, 10, Vgpr(0), 1));
  code.push_back(EncodeVop2(0x1a, 11, Vgpr(2), 0));
  code.push_back(EncodeVop2(0x15, 12, Vgpr(3), 1));
  code.push_back(EncodeVop2(0x16, 13, Vgpr(2), 3));
  code.push_back(EncodeVop2(0x17, 14, Vgpr(3), 1));
  code.push_back(EncodeVop2(0x18, 15, Vgpr(2), 3));

  for (u32 i = 0; i < 6u; i++) {
    AppendStoreVgpr(&code, 10u + i, i);
  }
  AppendEnd(&code);

  return {"VectorShiftCountsMaskLowBits",
          code,
          {},
          {1, 2, 0x80000000u, 0x40000000u, 0x80000000u, 0xc0000000u},
          {O::V_MOV_B32, O::V_LSHL_B32, O::V_LSHLREV_B32, O::V_LSHR_B32,
           O::V_LSHRREV_B32, O::V_ASHR_I32, O::V_ASHRREV_I32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorVop3LshrrevB64Captured() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendSMovLiteral(&code, 106, 0x89abcdefu);
  AppendSMovLiteral(&code, 107, 0x01234567u);
  AppendVMovU32(&code, 12, 68);
  code.push_back(0xd7000001u);
  code.push_back(0x0000d50cu); // v_lshrrev_b64 v[1:2], v12, vcc
  AppendStoreVgpr(&code, 1, 0);
  AppendStoreVgpr(&code, 2, 1);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorVop3LshrrevB64Captured";
  test.code = std::move(code);
  test.expected = {0x789abcdeu, 0x00123456u};
  test.opcodes = {O::S_MOV_B32, O::V_MOV_B32, O::V_LSHRREV_B64,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.required_spirv = {"OpShiftRightLogical", "OpSelect"};
  test.forbidden_spirv = {"OpTypeInt 64"};
  return test;
}

TestCase VectorVop3LshlrevB64Captured() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendBufferLoadDword(&code, 3, 30);
  code.push_back(0xd6ff0021u);
  code.push_back(0x00010303u); // v_lshlrev_b64 v[33:34], v3, 1
  AppendStoreVgpr(&code, 33, 1);
  AppendStoreVgpr(&code, 34, 2);
  code.push_back(EncodeVop2(0x03, 3, InlineU32(31), 3));
  code.push_back(0xd6ff0021u);
  code.push_back(0x00010303u);
  AppendStoreVgpr(&code, 33, 3);
  AppendStoreVgpr(&code, 34, 4);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorVop3LshlrevB64Captured";
  test.code = std::move(code);
  test.initial = {33u, 0u, 0u, 0u, 0u};
  test.expected = {33u, 0u, 2u, 1u, 0u};
  test.opcodes = {O::BUFFER_LOAD_DWORD, O::V_LSHLREV_B64, O::V_ADD_NC_U32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.required_spirv = {"OpShiftLeftLogical", "OpSelect"};
  test.forbidden_spirv = {"OpTypeInt 64"};
  return test;
}

TestCase VectorDynamicU64ShiftEdges() {
  using O = ShaderOpcode;
  TestCase test;
  test.name = "VectorDynamicU64ShiftEdges";
  test.initial = {0u, 1u, 31u, 32u, 33u, 63u, 64u, 65u};
  test.expected = test.initial;
  auto& code = test.code;
  for (const uint64_t source : {uint64_t{0}, uint64_t{1},
                               uint64_t{0x8000000000000000ull},
                               uint64_t{0xffffffffffffffffull},
                               uint64_t{0x0123456789abcdefull}}) {
    AppendVMovLiteral(&code, 4, static_cast<u32>(source));
    AppendVMovLiteral(&code, 5, static_cast<u32>(source >> 32u));
    for (u32 index = 0; index < test.initial.size(); ++index) {
      // A buffer load prevents the constant-shift specialization.
      AppendVMovU32(&code, 30, index * sizeof(u32));
      AppendBufferLoadDword(&code, 3, 30);
      for (const bool left : {true, false}) {
        AppendVop3(&code, left ? 0x2ff : 0x300, 33, Vgpr(3), Vgpr(4));
        const auto amount = test.initial[index] & 63u;
        const auto expected = left ? source << amount : source >> amount;
        const auto output = static_cast<u32>(test.expected.size());
        AppendStoreVgpr(&code, 33, output);
        AppendStoreVgpr(&code, 34, output + 1u);
        test.expected.push_back(static_cast<u32>(expected));
        test.expected.push_back(static_cast<u32>(expected >> 32u));
      }
    }
  }
  AppendEnd(&code);
  test.initial.resize(test.expected.size());
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_DWORD, O::V_LSHLREV_B64,
                  O::V_LSHRREV_B64, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.required_spirv = {"OpShiftLeftLogical", "OpShiftRightLogical", "OpSelect"};
  test.forbidden_spirv = {"OpTypeInt 64"};
  return test;
}

TestCase VectorVop3IntegerOps() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeVop1(0x01, 0, InlineU32(2)));
  code.push_back(EncodeVop1(0x01, 1, InlineU32(3)));
  code.push_back(EncodeVop1(0x01, 2, InlineU32(4)));
  AppendVMovLiteral(&code, 3, 0xfffffff8u);
  code.push_back(EncodeVop1(0x01, 4, InlineU32(5)));
  AppendVMovLiteral(&code, 5, 0x11223344u);
  AppendVMovLiteral(&code, 6, 0x55667788u);
  AppendVMovLiteral(&code, 7, 0x0f0f0f0fu);
  AppendVMovLiteral(&code, 8, 0x33333333u);
  AppendVMovLiteral(&code, 9, 0xaaaaaaaau);
  AppendVMovLiteral(&code, 14, 0x00f00000u);
  code.push_back(EncodeVop1(0x01, 15, InlineU32(8)));
  AppendVMovLiteral(&code, 30, 0x00010000u);
  AppendVMovLiteral(&code, 31, 0x00010000u);

  AppendVop3(&code, 0x36d, 10, Vgpr(0), Vgpr(1), Vgpr(2));
  AppendVop3(&code, 0x152, 11, Vgpr(3), Vgpr(4), Vgpr(0));
  AppendVop3(&code, 0x155, 12, Vgpr(3), Vgpr(4), Vgpr(0));
  AppendVop3(&code, 0x158, 13, Vgpr(3), Vgpr(4), Vgpr(0));
  AppendVop3(&code, 0x153, 16, Vgpr(3), Vgpr(4), Vgpr(0));
  AppendVop3(&code, 0x156, 17, Vgpr(3), Vgpr(4), Vgpr(0));
  AppendVop3(&code, 0x159, 18, Vgpr(3), Vgpr(4), Vgpr(0));
  AppendVop3(&code, 0x15d, 19, Vgpr(0), Vgpr(4), Vgpr(2));
  AppendVop3(&code, 0x346, 20, Vgpr(1), Vgpr(0), Vgpr(2));
  AppendVop3(&code, 0x347, 21, Vgpr(0), Vgpr(1), Vgpr(0));
  AppendVop3(&code, 0x345, 22, Vgpr(7), Vgpr(8), Vgpr(0));
  AppendVop3(&code, 0x36f, 23, Vgpr(1), Vgpr(2), Vgpr(0));
  AppendVop3(&code, 0x371, 24, Vgpr(7), Vgpr(8), Vgpr(2));
  AppendVop3(&code, 0x372, 25, Vgpr(7), Vgpr(8), Vgpr(2));
  AppendVop3(&code, 0x178, 26, Vgpr(7), Vgpr(8), Vgpr(2));
  AppendVop3(&code, 0x148, 27, Vgpr(14), InlineU32(20), Vgpr(2));
  AppendVop3(&code, 0x149, 28, Vgpr(3), Vgpr(2), Vgpr(2));
  AppendVop3(&code, 0x14a, 29, Vgpr(8), Vgpr(7), Vgpr(9));
  AppendVop3(&code, 0x14e, 32, Vgpr(5), Vgpr(6), Vgpr(15));
  AppendVop3(&code, 0x363, 33, Vgpr(2), Vgpr(15));
  AppendVop3(&code, 0x169, 34, Vgpr(30), Vgpr(31));
  AppendVop3(&code, 0x16a, 35, Vgpr(30), Vgpr(31));
  AppendVop3(&code, 0x16b, 36, Vgpr(30), Vgpr(31));
  AppendVop3(&code, 0x16c, 44, Vgpr(3), Vgpr(30));
  AppendVop3(&code, 0x142, 37, Vgpr(0), Vgpr(1), Vgpr(2));
  AppendVop3(&code, 0x143, 38, Vgpr(0), Vgpr(1), Vgpr(2));
  AppendVop3(&code, 0x30f, 39, Vgpr(0), Vgpr(1));
  AppendVop3(&code, 0x310, 40, Vgpr(0), Vgpr(1));
  AppendVop3(&code, 0x319, 41, Vgpr(0), Vgpr(1));

  const u32 results[] = {10, 11, 12, 13, 16, 17, 18, 19, 20, 21,
                         22, 23, 24, 25, 26, 27, 28, 29, 32, 33,
                         34, 35, 36, 44, 37, 38, 39, 40, 41};
  for (u32 i = 0; i < static_cast<u32>(std::size(results)); i++) {
    AppendStoreVgpr(&code, results[i], i);
  }
  AppendEnd(&code);

  return {"VectorVop3IntegerOps",
          code,
          {},
          {9,
           0xfffffff8u,
           5,
           2,
           2,
           0xfffffff8u,
           5,
           7,
           16,
           20,
           0x3c3c3c3eu,
           0x32,
           0x03030307u,
           0x3f3f3f3fu,
           0x3c3c3c38u,
           0x0fu,
           0xffffffffu,
           0x8b8b8b8bu,
           0x44556677u,
           0x00000f00u,
           0,
           1,
           0,
           0xffffffffu,
           10,
           10,
           5,
           0xffffffffu,
           1},
          {O::V_MOV_B32,          O::V_ADD3_U32,     O::V_MIN3_I32,
           O::V_MAX3_I32,         O::V_MED3_I32,     O::V_MIN3_U32,
           O::V_MAX3_U32,         O::V_MED3_U32,     O::V_SAD_U32,
           O::V_LSHL_ADD_U32,     O::V_ADD_LSHL_U32, O::V_XAD_U32,
           O::V_LSHL_OR_B32,      O::V_AND_OR_B32,   O::V_OR3_B32,
           O::V_XOR3_B32,         O::V_BFE_U32,      O::V_BFE_I32,
           O::V_BFI_B32,          O::V_ALIGNBIT_B32, O::V_BFM_B32,
           O::V_MUL_LO_U32,       O::V_MUL_HI_U32,   O::V_MUL_LO_I32,
           O::V_MUL_HI_I32,       O::V_MAD_I32_I24,  O::V_MAD_U32_U24,
           O::V_ADD_I32,          O::V_SUB_I32,      O::V_SUBREV_I32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorBfeI32SignExtendsField() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  for (u32 vgpr = 0; vgpr < 6; vgpr++) {
    AppendVMovU32(&code, 30, vgpr * sizeof(u32));
    AppendBufferLoadDword(&code, vgpr, 30);
  }
  AppendVop3(&code, 0x149, 10, Vgpr(0), Vgpr(2), Vgpr(3));
  AppendVop3(&code, 0x149, 11, Vgpr(1), Vgpr(4), Vgpr(5));
  AppendStoreVgpr(&code, 10, 0);
  AppendStoreVgpr(&code, 11, 1);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorBfeI32SignExtendsField";
  test.code = std::move(code);
  test.initial = {0x80000000u, 0xfffffff8u, 31, 1, 3, 4};
  test.expected = {0xffffffffu, 0xffffffffu};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_DWORD, O::V_BFE_I32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.required_spirv = {"OpBitFieldSExtract"};
  return test;
}

TestCase VectorAlignByteUsesFiveBitByteOffset() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x11223344u);
  AppendVMovLiteral(&code, 1, 0x55667788u);
  constexpr u32 offsets[] = {0, 1, 3, 4, 5, 7, 8, 31};
  for (u32 i = 0; i < static_cast<u32>(std::size(offsets)); i++) {
    AppendVMovU32(&code, 2, offsets[i]);
    AppendVop3(&code, 0x14f, 10u + i, Vgpr(0), Vgpr(1), Vgpr(2));
    AppendStoreVgpr(&code, 10u + i, i);
  }
  AppendEnd(&code);

  return {
      "VectorAlignByteUsesFiveBitByteOffset",
      code,
      {},
      {0x55667788u, 0x44556677u, 0x22334455u, 0x11223344u, 0x00112233u,
       0x00000011u, 0u, 0u},
      {O::V_MOV_B32, O::V_ALIGNBYTE_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorCarryAndBitCountOps() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0xffffffffu);
  code.push_back(EncodeVop1(0x01, 1, InlineU32(0)));
  AppendVMovLiteral(&code, 3, 0x0000f0f0u);
  code.push_back(EncodeVop1(0x01, 4, InlineU32(5)));

  code.push_back(EncodeVopc(0xc7, Vgpr(1), 1));
  code.push_back(EncodeVop2(0x28, 2, Vgpr(0), 1));
  code.push_back(EncodeVop2(0x22, 5, Vgpr(3), 4));
  AppendVMovLiteral(&code, 6, 0xffffffffu);
  code.push_back(EncodeVop2(0x23, 7, Vgpr(6), 4));
  code.push_back(EncodeVop2(0x24, 8, Vgpr(6), 4));

  AppendStoreVgpr(&code, 2, 0);
  AppendStoreSgpr(&code, 106, 1);
  AppendStoreVgpr(&code, 5, 2);
  AppendStoreVgpr(&code, 7, 3);
  AppendStoreVgpr(&code, 8, 4);
  AppendEnd(&code);

  return {"VectorCarryAndBitCountOps",
          code,
          {},
          {0, 1, 13, 5, 5},
          {O::V_MOV_B32, O::V_CMP_T_U32, O::V_ADDC_U32, O::V_BCNT_U32_B32,
           O::V_MBCNT_LO_U32_B32, O::V_MBCNT_HI_U32_B32, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase VectorMbcntUsesThreadMask() {
  using O = ShaderOpcode;

  std::vector<u32> code = {
      EncodeVop1(0x01, 1, 0),
      EncodeVop2(0x1a, 1, InlineU32(2), 1),
      EncodeVop2(0x25, 1, Vgpr(0), 1),
      EncodeVop2(0x1a, 3, InlineU32(2), 1),
  };
  AppendVMovLiteral(&code, 2, 0xffffffffu);
  code.push_back(EncodeVop1(0x01, 4, InlineU32(0)));
  code.push_back(EncodeVop2(0x23, 5, Vgpr(2), 4));
  code.push_back(EncodeVop2(0x24, 6, Vgpr(2), 5));
  AppendBufferStoreDword(&code, 6, 3);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorMbcntUsesThreadMask";
  test.code = code;
  test.expected = {0, 1, 2, 3, 0, 1, 2, 3};
  test.opcodes = {O::V_MOV_B32,
                  O::V_LSHLREV_B32,
                  O::V_ADD_NC_U32,
                  O::V_MBCNT_LO_U32_B32,
                  O::V_MBCNT_HI_U32_B32,
                  O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.group_id[0] = true;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.workgroup_register = 0;
  test.has_compute_info = true;
  test.dispatch_x = 2;
  return test;
}

TestCase VectorAddcUsesPerLaneCarryIn() {
  using O = ShaderOpcode;

  std::vector<u32> code = {
      EncodeVop1(0x01, 1, 0),
      EncodeVop2(0x1a, 1, InlineU32(2), 1),
      EncodeVop2(0x25, 1, Vgpr(0), 1),
      EncodeVopc(0xc7, Vgpr(0), 0),
      EncodeVop1(0x01, 2, InlineU32(0)),
      EncodeVop2(0x28, 3, Vgpr(2), 2),
      EncodeVop2(0x1a, 4, InlineU32(2), 1),
  };
  AppendBufferStoreDword(&code, 3, 4);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorAddcUsesPerLaneCarryIn";
  test.code = code;
  test.expected = std::vector<u32>(8, 1);
  test.opcodes = {O::V_MOV_B32,   O::V_LSHLREV_B32, O::V_ADD_NC_U32,
                  O::V_CMP_T_U32, O::V_ADDC_U32,    O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.group_id[0] = true;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.workgroup_register = 0;
  test.has_compute_info = true;
  test.dispatch_x = 2;
  return test;
}

TestCase VectorAddcWritesPerLaneCarryOut() {
  using O = ShaderOpcode;

  std::vector<u32> code = {EncodeVop1(0x01, 1, Vgpr(0)),
                           EncodeVop2(0x1a, 4, InlineU32(2), 1),
                           EncodeVopc(0xc7, Vgpr(0), 0)};
  AppendBufferLoadDword(&code, 26, 4);
  code.push_back(0x500434f9u);
  code.push_back(0x0c860680u);
  code.push_back(EncodeVop1(0x01, 6, 106));
  AppendBufferStoreDword(&code, 6, 4);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorAddcWritesPerLaneCarryOut";
  test.code = code;
  test.initial = {0x0000ffffu, 0u, 0x0000ffffu, 0u};
  test.expected = {5u, 5u, 5u, 5u};
  test.opcodes = {O::V_MOV_B32,         O::V_LSHLREV_B32, O::V_CMP_T_U32,
                  O::BUFFER_LOAD_DWORD, O::V_ADDC_U32,    O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.decoded_counts = {
      {"V_ADDC_U32 v2, vcc_lo, 0, v26.sdwa(sel=4,sext=1), vcc_lo", 1}};
  test.ir_counts = {{" = BitFieldSExtract ", 1}, {" = IAddCarry32 ", 2}};
  test.required_spirv = {"OpBitFieldSExtract"};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase VectorSubCoCiU32CompactAndVop3() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeVop2(0x1a, 4, InlineU32(2), 0));
  AppendBufferLoadDword(&code, 1, 4);
  code.push_back(EncodeVop2(0x25, 5, InlineU32(16), 4));
  AppendBufferLoadDword(&code, 2, 5);
  code.push_back(EncodeVop2(0x1b, 3, InlineU32(1), 0));
  code.push_back(EncodeVopc(0xc5, InlineU32(0), 3));
  code.push_back(EncodeSop1(0x04, 20, 106));
  code.push_back(EncodeVop2(0x29, 10, Vgpr(1), 2));
  AppendVMovU32(&code, 6, 1);
  code.push_back(EncodeVop2(0x01, 11, InlineU32(0), 6));
  AppendStoreVgprAtLaneDwordOffset(&code, 10, 0, 0);
  AppendStoreVgprAtLaneDwordOffset(&code, 11, 0, 4);

  code.push_back(EncodeVopc(0xc2, InlineU32(0), 6));
  AppendVop3B(&code, 0x129u, 12, 22, Vgpr(1), Vgpr(2), 20);
  AppendVop3(&code, 0x101u, 13, InlineU32(0), Vgpr(6), 22);
  code.push_back(EncodeVop2(0x01, 14, InlineU32(0), 6));
  AppendStoreVgprAtLaneDwordOffset(&code, 12, 0, 8);
  AppendStoreVgprAtLaneDwordOffset(&code, 13, 0, 12);
  AppendStoreVgprAtLaneDwordOffset(&code, 14, 0, 16);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorSubCoCiU32CompactAndVop3";
  test.code = std::move(code);
  test.initial = {5u, 5u, 3u, 3u, 3u, 3u, 5u, 3u, 0u, 0u,
                  0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u, 0u};
  test.expected = {2u, 1u, 0xfffffffeu, 0xffffffffu, 0u, 0u, 1u,
                   1u, 2u, 1u, 0xfffffffeu, 0xffffffffu, 0u, 0u,
                   1u, 1u, 0u, 0u, 0u, 0u};
  test.opcodes = {O::V_MOV_B32, O::V_LSHLREV_B32, O::V_ADD_NC_U32,
                  O::V_AND_B32, O::V_CMP_NE_U32, O::V_CMP_EQ_U32,
                  O::V_SUB_CO_CI_U32, O::V_CNDMASK_B32, O::S_MOV_B64,
                  O::BUFFER_LOAD_DWORD, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"V_SUB_CO_CI_U32", 2}};
  test.required_spirv = {"OpISub", "OpUGreaterThan", "OpLogicalOr"};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.wave_size = 32;
  test.has_compute_info = true;
  return test;
}

TestCase VectorSubrevCoCiU32ExactRawOnGpu() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeVop1(0x01, 24, Vgpr(0)));
  code.push_back(EncodeSop1(0x04, 20, 126)); // s_mov_b64 s[20:21], exec
  code.push_back(EncodeVop1(0x01, 1, InlineU32(2)));
  code.push_back(EncodeVop1(0x01, 2, InlineU32(1)));
  code.push_back(EncodeVop2(0x1a, 4, InlineU32(2), 0));
  code.push_back(EncodeVop2(0x25, 5, InlineU32(16), 4));
  code.push_back(EncodeVopc(0xc1, Vgpr(0), 1));
  code.push_back(EncodeSop1(0x04, 22, 106)); // s_mov_b64 s[22:23], vcc
  code.push_back(EncodeVopc(0xc5, InlineU32(0), 0));
  AppendVMovLiteral(&code, 0, 0xdeadbeefu);
  code.push_back(EncodeSop1(0x04, 126, 106)); // s_mov_b64 exec, vcc
  code.push_back(EncodeSop1(0x04, 106, 22));  // s_mov_b64 vcc, s[22:23]
  code.push_back(0x54003080u); // v_subrev_co_ci_u32 v0, vcc, 0, v24, vcc
  code.push_back(EncodeSop1(0x04, 126, 20)); // s_mov_b64 exec, s[20:21]
  code.push_back(EncodeVop2(0x01, 3, InlineU32(0), 2));
  AppendBufferStoreDword(&code, 0, 4);
  AppendBufferStoreDword(&code, 3, 5);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorSubrevCoCiU32ExactRawOnGpu";
  test.code = code;
  test.expected = {0xdeadbeefu, 0, 2, 3, 0, 0, 0, 0};
  test.opcodes = {O::V_MOV_B32,          O::V_LSHLREV_B32,
                  O::V_ADD_NC_U32,       O::V_CMP_LT_U32,
                  O::S_MOV_B64,          O::V_CMP_NE_U32,
                  O::V_SUBREV_CO_CI_U32, O::V_CNDMASK_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.required_spirv = {"OpISub", "OpUGreaterThan"};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.group_id[0] = true;
  test.compute_info.wave_size = 32;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.workgroup_register = 0;
  test.has_compute_info = true;
  return test;
}

TestCase VectorVop3BSubrevCoCiUsesEncodedMasks() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeVop1(0x01, 24, Vgpr(0)));
  code.push_back(EncodeVop2(0x25, 24, InlineU32(3), 24));
  code.push_back(EncodeVop1(0x01, 1, InlineU32(2)));
  code.push_back(EncodeVop1(0x01, 2, InlineU32(1)));
  code.push_back(EncodeVop2(0x1a, 4, InlineU32(2), 0));
  code.push_back(EncodeVop2(0x25, 5, InlineU32(16), 4));
  code.push_back(EncodeVopc(0xc2, InlineU32(1), 0));
  code.push_back(EncodeSop1(0x04, 20, 106)); // s_mov_b64 s[20:21], vcc
  AppendSMovLiteral(&code, 106, 0);
  AppendSMovLiteral(&code, 107, 0);
  AppendVop3B(&code, 0x12au, 10, 22, InlineU32(5), Vgpr(24), 20);
  AppendVop3(&code, 0x101u, 3, InlineU32(0), Vgpr(2), 22);
  AppendBufferStoreDword(&code, 10, 4);
  AppendBufferStoreDword(&code, 3, 5);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorVop3BSubrevCoCiUsesEncodedMasks";
  test.code = code;
  test.expected = {0xfffffffeu, 0xfffffffeu, 0, 1, 1, 1, 0, 0};
  test.opcodes = {O::V_MOV_B32,          O::V_LSHLREV_B32,
                  O::V_ADD_NC_U32,       O::V_CMP_EQ_U32,
                  O::S_MOV_B64,          O::S_MOV_B32,
                  O::V_SUBREV_CO_CI_U32, O::V_CNDMASK_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.group_id[0] = true;
  test.compute_info.wave_size = 32;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.workgroup_register = 0;
  test.has_compute_info = true;
  return test;
}

TestCase VectorVop3BCarryOutWritesSgprMask() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 1, 0xffffffffu);
  AppendVMovU32(&code, 2, 1);
  AppendVMovU32(&code, 3, 0);

  AppendVop3B(&code, 0x30fu, 10, 0, Vgpr(1), Vgpr(2));
  AppendStoreSgprAtLaneDwordOffset(&code, 0, 0, 0);
  AppendVop3B(&code, 0x310u, 11, 0, Vgpr(3), Vgpr(2));
  AppendStoreSgprAtLaneDwordOffset(&code, 0, 0, 4);
  AppendVop3B(&code, 0x319u, 12, 0, Vgpr(2), Vgpr(3));
  AppendStoreSgprAtLaneDwordOffset(&code, 0, 0, 8);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorVop3BCarryOutWritesSgprMask";
  test.code = code;
  test.expected = std::vector<u32>(12, 15u);
  test.opcodes = {O::V_MOV_B32,    O::V_ADD_I32,          O::V_SUB_I32,
                  O::V_SUBREV_I32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.group_id[0] = true;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.workgroup_register = 0;
  test.has_compute_info = true;
  return test;
}

TestCase VectorVop3BCarryOutUsesEncodedSdst() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 1, 0xffffffffu);
  AppendVMovU32(&code, 2, 1);
  AppendVMovU32(&code, 3, 0);

  AppendVop3B(&code, 0x30fu, 10, 20, Vgpr(1), Vgpr(2));
  AppendStoreSgprAtLaneDwordOffset(&code, 20, 0, 0);
  AppendVop3B(&code, 0x310u, 11, 22, Vgpr(3), Vgpr(2));
  AppendStoreSgprAtLaneDwordOffset(&code, 22, 0, 4);
  AppendVop3B(&code, 0x319u, 12, 24, Vgpr(2), Vgpr(3));
  AppendStoreSgprAtLaneDwordOffset(&code, 24, 0, 8);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorVop3BCarryOutUsesEncodedSdst";
  test.code = code;
  test.expected = std::vector<u32>(12, 15u);
  test.opcodes = {O::V_MOV_B32,    O::V_ADD_I32,          O::V_SUB_I32,
                  O::V_SUBREV_I32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.group_id[0] = true;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.workgroup_register = 0;
  test.has_compute_info = true;
  return test;
}

TestCase VectorVop3BSubCoU32UsesRdna2Opcode310() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 1, 0);
  AppendVMovU32(&code, 2, 1);
  AppendVMovU32(&code, 3, 1);
  AppendVMovLiteral(&code, 4, 0xffffffffu);
  AppendVMovLiteral(&code, 5, 0x80000000u);

  code.push_back(EncodeVopc(0xc2, InlineU32(1), 0));
  code.push_back(EncodeVop2(0x01, 1, Vgpr(1), Vgpr(3)));
  code.push_back(EncodeVopc(0xc2, InlineU32(2), 0));
  code.push_back(EncodeVop2(0x01, 1, Vgpr(1), Vgpr(4)));
  code.push_back(EncodeVopc(0xc2, InlineU32(3), 0));
  code.push_back(EncodeVop2(0x01, 1, Vgpr(1), Vgpr(5)));
  code.push_back(EncodeVop2(0x01, 2, Vgpr(2), Vgpr(4)));

  AppendVop3B(&code, 0x310u, 10, 20, Vgpr(1), Vgpr(2));
  AppendStoreVgprAtLaneDwordOffset(&code, 10, 0, 0);
  AppendStoreSgprAtLaneDwordOffset(&code, 20, 0, 4);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorVop3BSubCoU32UsesRdna2Opcode310";
  test.code = code;
  test.expected = {0xffffffffu, 0, 0xfffffffeu, 0x80000001u, 9, 9, 9, 9};
  test.opcodes = {O::V_MOV_B32, O::V_CMP_EQ_U32,       O::V_CNDMASK_B32,
                  O::V_SUB_I32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.group_id[0] = true;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.workgroup_register = 0;
  test.has_compute_info = true;
  return test;
}

TestCase VectorMadU64U32UnsignedCarryOut() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 1, 0xffffffffu);
  AppendVMovU32(&code, 2, 2);
  AppendVMovU32(&code, 4, 2);
  AppendVMovLiteral(&code, 5, 0xffffffffu);
  AppendVop3B(&code, 0x176u, 10, 20, Vgpr(1), Vgpr(2), Vgpr(4));
  AppendStoreVgpr(&code, 10, 0);
  AppendStoreVgpr(&code, 11, 1);
  AppendStoreSgprPair(&code, 20, 2);
  AppendEnd(&code);

  return {"VectorMadU64U32UnsignedCarryOut",
          code,
          {},
          {0x00000000u, 0x00000001u, 0x00000001u, 0x00000000u},
          {O::V_MOV_B32, O::V_MAD_U64_U32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorLaneAndPackedOps() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x12345678u);
  code.push_back(EncodeVop1(0x01, 1, InlineU32(0)));
  AppendVMovLiteral(&code, 4, 0x40003c00u);
  AppendVMovLiteral(&code, 5, 0x44004200u);
  AppendVMovLiteral(&code, 6, 0x3c003c00u);
  AppendVMovLiteral(&code, 7, 0x3f800000u);
  AppendVMovLiteral(&code, 8, 0x40000000u);
  AppendVMovLiteral(&code, 9, 0x12345678u);
  AppendVMovLiteral(&code, 10, 0xabcdef01u);

  code.push_back(EncodeVop1(0x02, 0, Vgpr(0)));
  AppendVop3(&code, 0x360, 1, Vgpr(0), InlineU32(0));
  AppendVop3(&code, 0x361, 1, 0, InlineU32(0));
  AppendVop3(&code, 0x377, 2, Vgpr(0), InlineU32(0), InlineU32(0));
  code.push_back(EncodeVop2(0x2f, 3, Vgpr(7), 8));
  AppendVop3p(&code, 0x0f, 11, Vgpr(4), Vgpr(5), 0, 0x3);
  AppendVop3p(&code, 0x10, 12, Vgpr(4), Vgpr(5), 0, 0x3);
  AppendVop3p(&code, 0x11, 13, Vgpr(4), Vgpr(5), 0, 0x3);
  AppendVop3p(&code, 0x12, 14, Vgpr(4), Vgpr(5), 0, 0x3);
  AppendVop3p(&code, 0x0e, 15, Vgpr(4), Vgpr(5), Vgpr(6), 0x7);
  AppendVop3(&code, 0x362, 16, Vgpr(7), InlineU32(1));
  AppendVop3(&code, 0x36a, 17, Vgpr(9), Vgpr(10));

  AppendStoreSgpr(&code, 0, 0);
  AppendStoreSgpr(&code, 1, 1);
  const u32 results[] = {1, 2, 3, 11, 12, 13, 14, 15, 16, 17};
  for (u32 i = 0; i < static_cast<u32>(std::size(results)); i++) {
    AppendStoreVgpr(&code, results[i], i + 2u);
  }
  AppendEnd(&code);

  return {"VectorLaneAndPackedOps",
          code,
          {},
          {0x12345678u, 0x12345678u, 0x12345678u, 0x12345678u, 0x40003c00u,
           0x46004400u, 0x48004200u, 0x40003c00u, 0x44004200u, 0x48804400u,
           0x40000000u, 0xef015678u},
          {O::V_MOV_B32, O::V_READFIRSTLANE_B32, O::V_READLANE_B32,
           O::V_WRITELANE_B32, O::V_PERMLANE16_B32, O::V_CVT_PKRTZ_F16_F32,
           O::V_PK_ADD_F16, O::V_PK_MUL_F16, O::V_PK_MIN_F16, O::V_PK_MAX_F16,
           O::V_PK_FMA_F16, O::V_LDEXP_F32, O::V_CVT_PK_U16_U32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase Vop2PkFmacF16AccumulatesPackedHalvesIndependently() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x50004c00u); // low=16.0h, high=32.0h
  AppendVMovLiteral(&code, 1, 0x42003c00u); // low=1.0h, high=3.0h
  AppendVMovLiteral(&code, 2, 0x48004400u); // low=4.0h, high=8.0h

  code.push_back(EncodeVop2(0x3c, 0, Vgpr(1), 2));
  AppendStoreVgpr(&code, 0, 0);
  code.push_back(EncodeVop2(0x3c, 0, Vgpr(1), 2));
  AppendStoreVgpr(&code, 0, 1);

  AppendVMovLiteral(&code, 3, 0x50004c00u);
  code.push_back(EncodeVop2(0x3c, 3, 242, 2)); // Inline 1.0h is {1.0h, 0.0h}.
  AppendStoreVgpr(&code, 3, 2);
  AppendEnd(&code);

  return {"Vop2PkFmacF16AccumulatesPackedHalvesIndependently",
          code,
          {},
          {0x53004d00u, 0x55004e00u, 0x50004d00u},
          {O::V_MOV_B32, O::V_PK_FMAC_F16, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase Vop2PkFmacF16DppNegatesBothPackedHalves() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x50004c00u); // low=16.0h, high=32.0h
  AppendVMovLiteral(&code, 1, 0x42003c00u); // low=1.0h, high=3.0h
  AppendVMovLiteral(&code, 2, 0x48004400u); // low=4.0h, high=8.0h

  code.push_back(EncodeVop2(0x3c, 0, 250, 2));
  code.push_back(EncodeVop2Dpp(1, 0, 0xf, 0xf, 1));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  return {"Vop2PkFmacF16DppNegatesBothPackedHalves",
          code,
          {},
          {0x48004a00u},
          {O::V_MOV_B32, O::V_PK_FMAC_F16, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase Vop3pOpselHiUsesArchitecturalSourceBits() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x42003c00u); // low=1.0h, high=3.0h
  AppendVMovLiteral(&code, 1, 0x48004400u); // low=4.0h, high=8.0h
  AppendVMovLiteral(&code, 2, 0x50004c00u); // low=16.0h, high=32.0h

  // Raw V_PK_FMA_F16 words keep this test independent of the encoders above.
  code.insert(code.end(), {0xcc0e000au, 0x0c0a0300u}); // src0 high: 3*4+16=28
  code.insert(code.end(), {0xcc0e000bu, 0x140a0300u}); // src1 high: 1*8+16=24
  code.insert(code.end(), {0xcc0e400cu, 0x040a0300u}); // src2 high: 1*4+32=36

  for (u32 i = 0; i < 3; i++) {
    AppendStoreVgpr(&code, 10 + i, i);
  }
  AppendEnd(&code);

  return {"Vop3pOpselHiUsesArchitecturalSourceBits",
          code,
          {},
          {0x4f004d00u, 0x4e004d00u, 0x50804d00u},
          {O::V_MOV_B32, O::V_PK_FMA_F16, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase Vop3pIntegerNegationCapturedAndSelectedHalves() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 6, 0xfed4ff38u); // (-200, -300)
  AppendVMovLiteral(&code, 3, 0x012c00c8u); // (200, 300)
  // Captured temporal shader: NEG_LO/HI turns 0x7fff into 0xffff (-1).
  // Adding that clamped offset must select (199,299), not collapse to (0,0).
  code.insert(code.end(), {0xcc074107u, 0x30020cffu, 0x00007fffu});
  code.insert(code.end(), {0xcc0a4010u, 0x18020f03u});
  AppendStoreVgpr(&code, 7, 0);
  AppendStoreVgpr(&code, 16, 1);

  AppendVMovLiteral(&code, 0, 0x80011234u);
  AppendVMovLiteral(&code, 1, 0xbeef5678u);
  // Independently negate src0 low and src1 high, then reverse both the
  // modified sources and src1 half selection. NEG flips the selected sign bit.
  AppendVop3p(&code, 0x0a, 10, Vgpr(0), Vgpr(1), 0, 0x3, 0, 0x2, 0x1);
  AppendVop3p(&code, 0x0a, 11, Vgpr(0), Vgpr(1), 0, 0x1, 0x2, 0x1, 0x2);
  AppendStoreVgpr(&code, 10, 2);
  AppendStoreVgpr(&code, 11, 3);
  AppendEnd(&code);

  return {"Vop3pIntegerNegationCapturedAndSelectedHalves",
          code,
          {},
          {0xffffffffu, 0x012b00c7u, 0xbef0e8acu, 0x56795123u},
          {O::V_MOV_B32, O::V_PK_MAX_I16, O::V_PK_ADD_U16,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase CvtPkU8F32PacksSelectedByte() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  // RDNA2 V_CVT_PK_U8_F32: uint8(S0) replaces byte S1[1:0] in S2.
  AppendVMovLiteral(&code, 0, 0x414c0000u); // 12.75f truncates to 12.
  AppendVMovLiteral(&code, 1, 0x43960000u); // 300.0f saturates to 255.
  AppendVMovLiteral(&code, 2, 0xbf800000u); // Negative values saturate to zero.
  AppendVMovLiteral(&code, 3, 0x7fc00000u); // NaN saturates to zero.
  AppendVMovLiteral(&code, 4, 0x11223344u);

  AppendVop3(&code, 0x15eu, 10, Vgpr(0), InlineU32(0), Vgpr(4));
  AppendVop3(&code, 0x15eu, 11, Vgpr(1), InlineU32(5), Vgpr(4));
  AppendVop3(&code, 0x15eu, 12, Vgpr(2), InlineU32(2), Vgpr(4));
  AppendVop3(&code, 0x15eu, 13, Vgpr(3), InlineU32(3), Vgpr(4));
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, 10 + i, i);
  }
  AppendEnd(&code);

  return {
      "CvtPkU8F32PacksSelectedByte",
      code,
      {},
      {0x1122330cu, 0x1122ff44u, 0x11003344u, 0x00223344u},
      {O::V_MOV_B32, O::V_CVT_PK_U8_F32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase CvtPkrtzF16F32SubnormalRoundsTowardZero() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x33c00000u);
  AppendVMovLiteral(&code, 1, 0xb3c00000u);
  code.push_back(EncodeVop2(0x2f, 2, Vgpr(0), 1));
  AppendStoreVgpr(&code, 2, 0);
  AppendEnd(&code);

  return {"CvtPkrtzF16F32SubnormalRoundsTowardZero",
          code,
          {},
          {0x80010001u},
          {O::V_MOV_B32, O::V_CVT_PKRTZ_F16_F32, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase CvtPkrtzF16F32SdwaAndOutputModifiers() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x3f000000u); // 0.5f
  AppendVMovLiteral(&code, 1, 0x40000000u); // 2.0f
  AppendVMovLiteral(&code, 2, 0x3f802000u); // exactly 0x3c01h
  AppendVMovLiteral(&code, 3, 0x00000000u);
  AppendVMovLiteral(&code, 4, 0xbf000000u); // -0.5f
  for (u32 dst = 10; dst <= 18; dst++) {
    AppendVMovLiteral(&code, dst, 0xa1b2c3d4u);
  }

  code.push_back(EncodeVop2(0x2f, 10, 249, 1));
  code.push_back(EncodeVop2Sdwa(0, 6, 2, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0,
                                1));
  code.push_back(EncodeVop2(0x2f, 11, 249, 3));
  code.push_back(EncodeVop2Sdwa(2, 0, 0));
  code.push_back(EncodeVop2(0x2f, 12, 249, 1));
  code.push_back(EncodeVop2Sdwa(0, 6, 0, 3, 5));
  code.push_back(EncodeVop2(0x2f, 13, 249, 1));
  code.push_back(EncodeVop2Sdwa(4, 6, 0, 6, 6, 0, 0, 0, 1, 1));

  code.push_back(EncodeVop2(0x2f, 14, 250, 1));
  code.push_back(EncodeVop2Dpp(0, 0, 0xf, 0xf, 1));
  AppendVop3(&code, 0x12f, 15, Vgpr(0), Vgpr(1), 0, 0, 0, true);
  code.push_back(EncodeVop2(0x2f, 16, 249, 1));
  code.push_back(EncodeVop2Sdwa(0, 4, 2));
  code.push_back(EncodeVop2(0x2f, 17, 249, 1));
  code.push_back(EncodeVop2Sdwa(0, 6, 2, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0,
                                0, 1));
  AppendVop3(&code, 0x12f, 18, Vgpr(0), Vgpr(1), 0, 0, 0, false, 1);

  for (u32 dst = 10; dst <= 18; dst++) {
    AppendStoreVgpr(&code, dst, dst - 10);
  }
  AppendEnd(&code);

  return {"CvtPkrtzF16F32SdwaAndOutputModifiers",
          code,
          {},
          {0x3c003800u, 0x00000001u, 0x00000000u, 0xc0003800u,
           0x4000b800u, 0x3c003800u, 0xa1b23800u, 0x44003c00u,
           0x44003c00u},
          {O::V_MOV_B32, O::V_CVT_PKRTZ_F16_F32, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase PackedMinMaxF16NanAndSignedZeroEdges() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x80004000u);
  AppendVMovLiteral(&code, 1, 0x00007e00u);
  AppendVMovLiteral(&code, 2, 0x00004000u);
  AppendVMovLiteral(&code, 3, 0x80007e00u);
  AppendVMovLiteral(&code, 4, 0x40007d01u);
  AppendVMovLiteral(&code, 5, 0x7d014000u);

  AppendVop3p(&code, 0x11, 10, Vgpr(0), Vgpr(1), 0, 0x3);
  AppendVop3p(&code, 0x12, 11, Vgpr(2), Vgpr(3), 0, 0x3);
  AppendVop3p(&code, 0x11, 12, Vgpr(4), Vgpr(5), 0, 0x3);
  AppendVop3p(&code, 0x12, 13, Vgpr(4), Vgpr(5), 0, 0x3);

  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, 10 + i, i);
  }
  AppendEnd(&code);

  return {"PackedMinMaxF16NanAndSignedZeroEdges",
          code,
          {},
          {0x80004000u, 0x00004000u, 0x7f017f01u, 0x7f017f01u},
          {O::V_MOV_B32, O::V_PK_MIN_F16, O::V_PK_MAX_F16,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorMinMaxF16Ops() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0xaaaa4000u); // low=2.0h
  AppendVMovLiteral(&code, 1, 0xbbbb3c00u); // low=1.0h
  AppendVMovLiteral(&code, 2, 0x12345678u);
  AppendVMovLiteral(&code, 3, 0x87654321u);
  AppendVMovLiteral(&code, 4, 0x5555aaaau);
  AppendVMovLiteral(&code, 5, 0x6666bbbbu);
  AppendVMovLiteral(&code, 6, 0x7777bbbbu);
  AppendVMovLiteral(&code, 7, 0x8888bbbbu);
  AppendVMovLiteral(&code, 8, 0x9999bbbbu);
  AppendVMovLiteral(&code, 9, 0x99990000u);
  code.push_back(EncodeVop2(0x32, 5, Vgpr(0), 1));
  code.push_back(EncodeVop2(0x33, 6, Vgpr(0), 1));
  code.push_back(EncodeVop2(0x34, 7, Vgpr(0), 1));
  code.push_back(EncodeVop2(0x35, 4, Vgpr(0), 1));
  code.push_back(EncodeVop2(0x39, 2, Vgpr(0), 1));
  code.push_back(EncodeVop2(0x3a, 3, Vgpr(0), 1));
  code.push_back(EncodeVop2(0x35, 9, 249, 1));
  code.push_back(EncodeVop2Sdwa(0, 4, 2, 4, 4));
  code.push_back(0x660000f9u);
  code.push_back(EncodeVop2Sdwa(0, 4, 2, 4, 4));
  AppendStoreVgpr(&code, 5, 0);
  AppendStoreVgpr(&code, 6, 1);
  AppendStoreVgpr(&code, 7, 2);
  AppendStoreVgpr(&code, 0, 3);
  AppendStoreVgpr(&code, 4, 4);
  AppendStoreVgpr(&code, 2, 5);
  AppendStoreVgpr(&code, 3, 6);
  AppendStoreVgpr(&code, 9, 7);
  AppendEnd(&code);

  return {"VectorMinMaxF16Ops",
          code,
          {},
          {0x66664200u, 0x77773c00u, 0x8888bc00u, 0xaaaa0000u, 0x55554000u,
           0x12344000u, 0x87653c00u, 0x99994000u},
          {O::V_MOV_B32, O::V_ADD_F16, O::V_SUB_F16, O::V_SUBREV_F16,
           O::V_MUL_F16, O::V_MAX_F16, O::V_MIN_F16, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase VectorCvtU16F16Sdwa() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x45004200u); // low=3.0h, high=5.0h
  AppendVMovLiteral(&code, 1, 0xbc007c00u); // low=+inf, high=-1.0h
  AppendVMovLiteral(&code, 2, 0x00007e00u); // low=qNaN
  AppendVMovLiteral(&code, 10, 0x12345678u);
  AppendVMovLiteral(&code, 11, 0x87654321u);
  AppendVMovLiteral(&code, 12, 0xabcd1111u);
  AppendVMovLiteral(&code, 13, 0x77772222u);
  AppendVMovLiteral(&code, 14, 0x5555aaaau);
  code.push_back(EncodeVop1(0x52, 10, 249));
  code.push_back(EncodeVop1Sdwa(0, 4, 2, 4));
  code.push_back(EncodeVop1(0x52, 11, 249));
  code.push_back(EncodeVop1Sdwa(0, 5, 2, 5));
  code.push_back(EncodeVop1(0x52, 12, 249));
  code.push_back(EncodeVop1Sdwa(1, 4, 2, 4));
  code.push_back(EncodeVop1(0x52, 13, 249));
  code.push_back(EncodeVop1Sdwa(1, 4, 2, 5));
  code.push_back(EncodeVop1(0x52, 14, 249));
  code.push_back(EncodeVop1Sdwa(2, 4, 2, 4));
  for (u32 i = 0; i < 5; i++) {
    AppendStoreVgpr(&code, 10 + i, i);
  }
  AppendEnd(&code);

  return {"VectorCvtU16F16Sdwa",
          code,
          {},
          {0x12340003u, 0x00054321u, 0xabcdffffu, 0x77770000u, 0x55550000u},
          {O::V_MOV_B32, O::V_CVT_U16_F16, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase NativeAndSdwa16BitDestinationWrites() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x3fc00000u); // 1.5f -> 0x3e00h
  AppendVMovLiteral(&code, 1, 0x00004200u); // low=3.0h
  AppendVMovLiteral(&code, 2, 0x0000c000u); // low=-2.0h
  AppendVMovLiteral(&code, 3, 0x00003c00u); // low=1.0h
  AppendVMovLiteral(&code, 4, 0x00004000u); // low=2.0h

  const u32 sentinels[] = {
      0x3c001234u, 0xbbbb2345u, 0xcccc3456u, 0xdddd4567u, 0xeeee5678u,
      0xffff6789u, 0xf00d789au, 0x11118888u, 0x22229999u, 0x3333aaaau,
      0xaaaa0000u, 0xbbbb0000u, 0xcccc0000u, 0xabcd1234u, 0xbcde2345u,
      0xcdef3456u, 0xdef01234u, 0xef012345u, 0xf0123456u, 0x01234567u,
      0xaaaa1234u, 0xbbbb5678u, 0x24681234u, 0x13572468u, 0x89abcdefu,
      0xfedcba98u, 0x0bad1234u,
  };
  // AppendStoreVgpr uses v31 as its address scratch register.
  const auto output_vgpr = [](u32 index) { return 10u + index + (index >= 21u ? 1u : 0u); };
  for (u32 i = 0; i < static_cast<u32>(std::size(sentinels)); i++) {
    AppendVMovLiteral(&code, output_vgpr(i), sentinels[i]);
  }

  code.push_back(EncodeVop1(0x0a, 10, Vgpr(0)));
  code.push_back(EncodeVop1(0x0a, 11, 250));
  code.push_back(EncodeVop1Dpp(0));
  AppendVop3(&code, 0x18a, 12, Vgpr(0), 0);
  code.push_back(EncodeVop1(0x52, 13, Vgpr(1)));
  code.push_back(EncodeVop1(0x53, 14, Vgpr(2)));

  code.push_back(EncodeVop1(0x0a, 15, 249));
  code.push_back(EncodeVop1Sdwa(0));
  code.push_back(EncodeVop1(0x54, 16, 249));
  code.push_back(EncodeVop1Sdwa(10, 4, 2, 5));
  code.push_back(EncodeVop1(0x52, 17, 249));
  code.push_back(EncodeVop1Sdwa(1, 6, 0, 4));
  code.push_back(EncodeVop1(0x52, 18, 249));
  code.push_back(EncodeVop1Sdwa(1, 4, 0, 4));
  code.push_back(EncodeVop1(0x53, 19, 249));
  code.push_back(EncodeVop1Sdwa(2, 4, 1, 4));

  code.push_back(EncodeVop2(0x32, 20, 250, 4));
  code.push_back(EncodeVop2Dpp(3));
  AppendVop3(&code, 0x132, 21, Vgpr(3), Vgpr(4));
  code.push_back(EncodeVop2(0x32, 22, 249, 4));
  code.push_back(EncodeVop2Sdwa(3, 4, 0, 4, 4));

  code.push_back(EncodeVop1(0x0a, 23, 249));
  code.push_back(EncodeVop1Sdwa(0, 4, 2, 3));
  code.push_back(EncodeVop1(0x0a, 24, 249));
  code.push_back(EncodeVop1Sdwa(0, 4, 2, 5));
  code.push_back(EncodeVop1(0x0a, 25, 249));
  code.push_back(EncodeVop1Sdwa(0, 4, 2, 6, 0, 1, 1));

  code.push_back(EncodeVop1(0x0a, 26, 249));
  code.push_back(EncodeVop1Sdwa(0, 4, 2, 6, 0, 0, 0, 0, 0, 1));
  code.push_back(EncodeVop1(0x0a, 27, 249));
  code.push_back(EncodeVop1Sdwa(0, 4, 2, 6, 0, 0, 0, 0, 1));
  AppendVop3(&code, 0x18a, 28, Vgpr(0), 0, 0, 0, 0, false, 1);
  AppendVop3(&code, 0x18a, 29, Vgpr(0), 0, 0, 0, 0, true);
  AppendVop3(&code, 0x34b, 30, Vgpr(3), Vgpr(4), Vgpr(3));
  AppendVop3(&code, 0x34b, 32, Vgpr(3), Vgpr(4), Vgpr(3), 0, 0x8);
  code.push_back(EncodeVop1(0x52, 33, 249));
  code.push_back(EncodeVop1Sdwa(1, 4, 2, 4, 0, 1, 1, 0, 1));
  AppendVop3(&code, 0x1d3, 34, Vgpr(1), 0, 0, 1, 0, true, 0, 1);
  code.push_back(EncodeVop1(0x07, 35, 249));
  code.push_back(EncodeVop1Sdwa(0, 6, 0, 6, 0, 1, 1, 0, 1));
  AppendVop3(&code, 0x188, 36, Vgpr(0), 0, 0, 1, 0, true, 0, 1);
  code.push_back(EncodeVop1(0x54, 37, 249));
  code.push_back(EncodeVop1Sdwa(4, 4, 2, 4, 0, 1, 1));

  for (u32 i = 0; i < static_cast<u32>(std::size(sentinels)); i++) {
    AppendStoreVgpr(&code, output_vgpr(i), i);
  }
  AppendEnd(&code);

  return {"NativeAndSdwa16BitDestinationWrites",
          code,
          {},
          {0x3c003e00u, 0xbbbb3e00u, 0xcccc3e00u, 0xdddd0003u,
           0xeeeefffeu, 0x00003e00u, 0xf00d3c00u, 0x00000003u,
           0x00000003u, 0xfffffffeu, 0xaaaa4200u, 0xbbbb4200u,
           0x00004200u, 0xabcd0000u, 0xbcde0000u, 0xcdefbe00u,
           0xdef04200u, 0xef013c00u, 0xf0124200u, 0x01233c00u,
           0xaaaa4200u, 0x42005678u, 0x24680000u, 0x1357fffdu,
           0x00000000u, 0xffffffffu, 0x0badb800u},
          {O::V_MOV_B32, O::V_CVT_F16_F32, O::V_CVT_U32_F32,
           O::V_CVT_I32_F32, O::V_CVT_U16_F16, O::V_CVT_I16_F16,
           O::V_RCP_F16, O::V_ADD_F16, O::V_FMA_F16, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase VectorMinMaxMed3F16Ops() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x40003c00u); // low=1.0h, high=2.0h
  AppendVMovLiteral(&code, 1, 0x44004200u); // low=3.0h, high=4.0h
  AppendVMovLiteral(&code, 2, 0xc8004000u); // low=2.0h, high=-8.0h
  AppendVMovLiteral(&code, 3, 0x00007e00u); // low=qNaN
  AppendVMovLiteral(&code, 4, 0x00004000u); // low=2.0h
  AppendVMovLiteral(&code, 5, 0x00003c00u); // low=1.0h
  AppendVMovLiteral(&code, 10, 0xaaaa5555u);
  AppendVMovLiteral(&code, 11, 0x12345678u);
  AppendVMovLiteral(&code, 12, 0x77772222u);

  AppendVop3(&code, 0x351, 10, Vgpr(0), Vgpr(1), Vgpr(2));
  AppendVop3(&code, 0x354, 11, Vgpr(0), Vgpr(1), Vgpr(2), 0, 0xf, false, 0,
             0x4);
  AppendVop3(&code, 0x357, 12, Vgpr(3), Vgpr(4), Vgpr(5));
  for (u32 i = 0; i < 3; i++) {
    AppendStoreVgpr(&code, 10 + i, i);
  }
  AppendEnd(&code);

  return {"VectorMinMaxMed3F16Ops",
          code,
          {},
          {0xaaaa3c00u, 0x48005678u, 0x77773c00u},
          {O::V_MOV_B32, O::V_MIN3_F16, O::V_MAX3_F16, O::V_MED3_F16,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorSpecialF16Ops() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0xc000fc00u); // low=-inf, high=-2.0h
  AppendVMovLiteral(&code, 1, 0x00004400u); // low=+4.0h
  AppendVMovLiteral(&code, 2, 0x00003c00u); // low=+1.0h
  AppendVMovLiteral(&code, 3, 0x0000bc00u); // low=-1.0h
  AppendVMovLiteral(&code, 4, 0x0000fc00u); // low=-inf
  AppendVMovLiteral(&code, 11, 0x12345678u);

  code.push_back(EncodeVop1(0x54, 10, Vgpr(0)));
  code.push_back(EncodeVop1(0x54, 11, 249));
  code.push_back(EncodeVop1Sdwa(0, 5, 2, 5));
  code.push_back(EncodeVop1(0x56, 12, Vgpr(1)));
  code.push_back(EncodeVop1(0x57, 13, Vgpr(2)));
  code.push_back(EncodeVop1(0x57, 14, Vgpr(3)));
  code.push_back(EncodeVop1(0x58, 15, Vgpr(4)));
  AppendVop3(&code, 0x1d7, 16, Vgpr(3), 0, 0, 0, 0, true);
  for (u32 i = 0; i < 7; i++) {
    AppendStoreVgpr(&code, 10 + i, i);
  }
  AppendEnd(&code);

  return {"VectorSpecialF16Ops",
          code,
          {},
          {0x00008000u, 0xb8005678u, 0x00003800u, 0x00000000u, 0x0000fe00u,
           0x00000000u, 0x00000000u},
          {O::V_MOV_B32, O::V_RCP_F16, O::V_RSQ_F16, O::V_LOG_F16, O::V_EXP_F16,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorFractF16CapturedAndEdges() {
  using O = ShaderOpcode;

  // RDNA2 section 12.8: x - floor(x), rounded to half precision.
  // Load at runtime to exercise the emitted operation, including half subnormals.
  const std::array<u32, 18> inputs{
      0x3d00u, 0xbd00u, 0x0000u, 0x8000u, 0x0001u, 0x8001u,
      0x03ffu, 0x83ffu, 0x7bffu, 0xfbffu, 0x3800u, 0xb800u,
      0x8c00u, 0x8c01u, 0x7c00u, 0xfc00u, 0x7e55u, 0x7d01u};
  const std::array<u32, 18> fractions{
      0x3400u, 0x3a00u, 0x0000u, 0x0000u, 0x0001u, 0x3c00u,
      0x03ffu, 0x3c00u, 0x0000u, 0x0000u, 0x3800u, 0x3800u,
      0x3c00u, 0x3bffu, 0x7e00u, 0x7e00u, 0x7e00u, 0x7e00u};
  TestCase test;
  test.name = "VectorFractF16CapturedAndEdges";
  for (u32 bits : inputs) {
    test.initial.push_back(0x42000000u | bits); // Distinct high half must be ignored.
  }
  test.expected = test.initial;
  auto &code = test.code;
  for (u32 i = 0; i < inputs.size(); i++) {
    AppendVMovU32(&code, 30, i * 4u);
    AppendBufferLoadDword(&code, 7, 30);
    AppendVMovLiteral(&code, 9, 0xa5a51234u);
    code.push_back(0x7e12bf07u); // Captured v_fract_f16 v9, v7.
    if (i >= 14u) {
      // Check quiet NaN class without constraining its sign or payload.
      code.push_back(EncodeVop2(0x1b, 9, 255u, 9));
      code.push_back(0xffff7e00u);
    }
    AppendStoreVgpr(&code, 9, static_cast<u32>(inputs.size()) + i);
    test.expected.push_back(0xa5a50000u | fractions[i]);
  }
  AppendEnd(&code);
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_DWORD, O::V_FRACT_F16,
                  O::V_AND_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"V_FRACT_F16 v9, v7", inputs.size()}};
  test.ir_counts = {{" = FPFract32 ", inputs.size()}};
  test.required_spirv = {" Fract ", " PackHalf2x16 ", " UnpackHalf2x16 "};
  test.forbidden_spirv = {"OpCapability Float16"};
  return test;
}

TestCase VectorFractF16Modifiers() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 7, 0xbd003d00u); // high=-1.25h, low=+1.25h
  for (u32 dst = 10; dst <= 19; dst++) {
    AppendVMovLiteral(&code, dst, 0xabcd1234u);
  }
  code.push_back(EncodeVop1(0x5f, 10, 249));
  code.push_back(EncodeVop1Sdwa(7, 5, 2, 5)); // high -> high, preserve low
  code.push_back(EncodeVop1(0x5f, 11, 249));
  code.push_back(EncodeVop1Sdwa(7, 4, 0, 5, 0, 1, 1)); // -abs(-1.25), pad high
  code.push_back(EncodeVop1(0x5f, 12, 249));
  code.push_back(EncodeVop1Sdwa(7, 4, 2, 5, 0, 0, 1)); // abs(-1.25)
  code.push_back(EncodeVop1(0x5f, 13, 249));
  code.push_back(EncodeVop1Sdwa(7, 4, 2, 5, 0, 0, 0, 0, 1, 1)); // *2, clamp
  code.push_back(EncodeVop1(0x5f, 14, 250));
  code.push_back(EncodeVop1Dpp(7, 0x0e4) | (1u << 20u)); // DPP identity, negate
  AppendVop3(&code, 0x1df, 15, Vgpr(7), 0, 0, 1, 0, true, 1, 1);
  code.push_back(EncodeVop1(0x5f, 16, 255));
  code.push_back(0x4200bd00u); // literal -1.25h
  code.push_back(EncodeVop1(0x5f, 17, 240)); // inline +0.5, interpreted as FP16
  AppendSMovLiteral(&code, 20, 0x4200bd00u);
  code.push_back(EncodeVop1(0x5f, 18, 20)); // SGPR source
  AppendVop3(&code, 0x1df, 19, Vgpr(7), 0, 0, 0, 0, false, 3); // *0.5
  for (u32 i = 0; i < 10; i++) {
    AppendStoreVgpr(&code, 10 + i, i);
  }
  AppendEnd(&code);

  TestCase test{"VectorFractF16Modifiers", code, {},
                {0x3a001234u, 0x00003a00u, 0xabcd3400u, 0xabcd3c00u,
                 0xabcd3a00u, 0xabcd3c00u, 0xabcd3a00u, 0xabcd3800u,
                 0xabcd3a00u, 0xabcd3000u},
                {O::V_MOV_B32, O::S_MOV_B32, O::V_FRACT_F16,
                 O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
  test.decoded_counts = {{"V_FRACT_F16", 10}};
  test.ir_counts = {{" = FPFract32 ", 10}};
  test.required_spirv = {" Fract ", " PackHalf2x16 "};
  return test;
}

TestCase VectorCosF16CapturedSdwaAndEdges() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 4, 0x34001234u); // high=+0.25h, low sentinel
  code.push_back(0x7e08c2f9u);
  code.push_back(0x00051504u); // captured v_cos_f16 v4.word1, v4.word1
  AppendVMovLiteral(&code, 5, 0x00008000u); // -0.0h
  code.push_back(EncodeVop1(0x61, 6, Vgpr(5)));
  AppendVMovLiteral(&code, 7, 0x00007bffu); // max finite
  code.push_back(EncodeVop1(0x61, 8, Vgpr(7)));
  AppendVMovLiteral(&code, 9, 0x00007c00u); // +inf
  code.push_back(EncodeVop1(0x61, 10, Vgpr(9)));
  AppendVMovLiteral(&code, 11, 0x00000001u); // minimum positive denormal
  code.push_back(EncodeVop1(0x61, 12, Vgpr(11)));
  AppendVMovLiteral(&code, 13, 0x00003800u); // +0.5h
  code.push_back(EncodeVop1(0x61, 14, Vgpr(13)));
  for (u32 i = 0; i < 6; i++) {
    AppendStoreVgpr(&code, 4 + i * 2, i);
  }
  AppendEnd(&code);

  TestCase test{"VectorCosF16CapturedSdwaAndEdges",
                code,
                {},
                {0x00001234u, 0x00003c00u, 0x00003c00u, 0x0000fe00u,
                 0x00003c00u, 0x0000bc00u},
                {O::V_MOV_B32, O::V_COS_F16, O::BUFFER_STORE_DWORD,
                 O::S_ENDPGM}};
  test.decoded_counts = {{"V_COS_F16", 6},
                         {"V_COS_F16 v4.sdwa(sel=5,sext=0), "
                          "v4.sdwa(sel=5,sext=0)",
                          1}};
  test.ir_counts = {{" = FPCos ", 6}};
  test.required_spirv = {" Fract ", " Cos ", " PackHalf2x16 "};
  test.forbidden_spirv = {"OpCapability Float16"};
  return test;
}

TestCase VectorSinF16SdwaAndEdges() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 4, 0x34001234u); // high=+0.25h, low sentinel
  code.push_back(0x7e08c0f9u);
  code.push_back(0x00051504u); // v_sin_f16 v4.word1, v4.word1
  AppendVMovLiteral(&code, 5, 0x00008000u); // -0.0h
  code.push_back(EncodeVop1(0x60, 6, Vgpr(5)));
  AppendVMovLiteral(&code, 7, 0x00007bffu); // max finite
  code.push_back(EncodeVop1(0x60, 8, Vgpr(7)));
  AppendVMovLiteral(&code, 9, 0x0000fbffu); // minimum finite
  code.push_back(EncodeVop1(0x60, 10, Vgpr(9)));
  AppendVMovLiteral(&code, 11, 0x00007c00u); // +inf
  code.push_back(EncodeVop1(0x60, 12, Vgpr(11)));
  AppendVMovLiteral(&code, 13, 0x0000fc00u); // -inf
  code.push_back(EncodeVop1(0x60, 14, Vgpr(13)));
  AppendVMovLiteral(&code, 15, 0x00003800u); // +0.5h
  code.push_back(EncodeVop1(0x60, 16, Vgpr(15)));
  AppendVMovLiteral(&code, 17, 0x00003a00u); // +0.75h
  code.push_back(EncodeVop1(0x60, 18, Vgpr(17)));
  AppendVMovLiteral(&code, 19, 0x00003400u); // +0.25h
  AppendVop3(&code, 0x1e0, 20, Vgpr(19), 0);
  for (u32 i = 0; i < 9; i++) {
    AppendStoreVgpr(&code, 4 + i * 2, i);
  }
  AppendEnd(&code);

  TestCase test{"VectorSinF16SdwaAndEdges",
                code,
                {},
                {0x3c001234u, 0x00008000u, 0x00000000u, 0x00000000u,
                 0x0000fe00u, 0x0000fe00u, 0x00000000u, 0x0000bc00u,
                 0x00003c00u},
                {O::V_MOV_B32, O::V_SIN_F16, O::BUFFER_STORE_DWORD,
                 O::S_ENDPGM}};
  test.decoded_counts = {{"V_SIN_F16", 9},
                         {"V_SIN_F16 v4.sdwa(sel=5,sext=0), "
                          "v4.sdwa(sel=5,sext=0)",
                          1}};
  test.ir_counts = {{" = FPSin ", 9}};
  test.required_spirv = {" Fract ", " Sin ", " PackHalf2x16 "};
  test.forbidden_spirv = {"OpCapability Float16"};
  return test;
}

TestCase VectorWritelaneIgnoresExecMask() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 2, 0xaaaaaaaau);
  AppendSMovLiteral(&code, 4, 0x12345678u);
  code.push_back(EncodeSMovB32(126, InlineU32(1)));
  code.push_back(EncodeSMovB32(127, InlineU32(0)));
  AppendVop3(&code, 0x361, 2, 4, InlineU32(1));
  code.push_back(EncodeSMovB32(126, InlineU32(0xf)));
  code.push_back(EncodeSMovB32(127, InlineU32(0)));
  code.push_back(EncodeVop2(0x1a, 3, InlineU32(2), 0));
  AppendBufferStoreDword(&code, 2, 3);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorWritelaneIgnoresExecMask";
  test.code = code;
  test.expected = {0xaaaaaaaau, 0x12345678u, 0xaaaaaaaau, 0xaaaaaaaau};
  test.opcodes = {O::V_MOV_B32,     O::S_MOV_B32,          O::V_WRITELANE_B32,
                  O::V_LSHLREV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase VectorReadlaneFromInactiveWrittenLane() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendSMovLiteral(&code, 4, 0x12345678u);
  AppendVop3(&code, 0x361, 2, 4, InlineU32(4));
  AppendSMovLiteral(&code, 4, 0xdeadbeefu);
  AppendVop3(&code, 0x360, 5, Vgpr(2), InlineU32(4));
  AppendStoreSgpr(&code, 5, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorReadlaneInactiveWrittenLane";
  test.code = code;
  test.expected = {0x12345678u};
  test.opcodes = {O::S_MOV_B32, O::V_WRITELANE_B32,    O::V_READLANE_B32,
                  O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.forbidden_spirv = {"OpGroupNonUniformShuffle"};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase VectorLaneWave32RuntimeSelectorWraps() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeSop2(0x00, 5, 4, InlineU32(33)));
  AppendSMovLiteral(&code, 6, 0x12345678u);
  AppendVMovU32(&code, 2, 0);
  AppendVop3(&code, 0x361, 2, 6, 5);
  AppendVop3(&code, 0x360, 7, Vgpr(2), InlineU32(1));
  AppendStoreSgpr(&code, 7, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorLaneWave32RuntimeSelectorWraps";
  test.code = code;
  test.expected = {0x12345678u};
  test.opcodes = {O::S_ADD_U32,      O::S_MOV_B32, O::V_WRITELANE_B32,
                  O::V_READLANE_B32, O::V_MOV_B32, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.required_spirv = {"OpGroupNonUniformShuffle"};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.group_id[0] = true;
  test.compute_info.wave_size = 32;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.workgroup_register = 4;
  test.has_compute_info = true;
  return test;
}

TestCase VectorPermlanex16() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 3, 0x76543210u);
  AppendVMovLiteral(&code, 4, 0xfedcba98u);
  code.push_back(EncodeVop2(0x1a, 2, InlineU32(2), 0));
  AppendVMovLiteral(&code, 5, 0xfeedbabeu);
  AppendVop3(&code, 0x378, 1, Vgpr(5), Vgpr(3), Vgpr(4));
  AppendBufferStoreDword(&code, 1, 2);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorPermlanex16";
  test.code = code;
  test.expected = std::vector<u32>(32, 0xfeedbabeu);
  test.opcodes = {O::V_MOV_B32, O::V_PERMLANEX16_B32, O::V_LSHLREV_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 32;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase VectorPermlane16FetchInactiveZero() {
  using O = ShaderOpcode;

  std::vector<u32> code = {
      EncodeVop1(0x01, 1, 0),
      EncodeVop2(0x25, 1, InlineU32(10), 1),
      EncodeVopc(0xc2, InlineU32(0), 0),
      EncodeSop1(0x04, 126, 106),
      EncodeSMovB32(0, InlineU32(1)),
      EncodeSMovB32(1, InlineU32(0)),
  };
  AppendVop3(&code, 0x377, 2, Vgpr(1), 0, 1);
  AppendStoreVgpr(&code, 2, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorPermlane16FetchInactiveZero";
  test.code = code;
  test.expected = {0};
  test.opcodes = {O::V_MOV_B32,          O::V_ADD_NC_U32, O::V_CMP_EQ_U32,
                  O::S_MOV_B64,          O::S_MOV_B32,    O::V_PERMLANE16_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase VectorPermlane16FetchInactiveFi() {
  using O = ShaderOpcode;

  std::vector<u32> code = {
      EncodeVop1(0x01, 1, Vgpr(0)),      EncodeVop2(0x25, 1, InlineU32(10), 1),
      EncodeVopc(0xc2, InlineU32(0), 0), EncodeSop1(0x04, 126, 106),
      EncodeSMovB32(0, InlineU32(1)),    EncodeSMovB32(1, InlineU32(0)),
  };
  AppendVop3(&code, 0x377, 2, Vgpr(1), 0, 1, 0, 1);
  AppendStoreVgpr(&code, 2, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorPermlane16FetchInactiveFi";
  test.code = code;
  test.expected = {11};
  test.opcodes = {O::V_MOV_B32,          O::V_ADD_NC_U32, O::V_CMP_EQ_U32,
                  O::S_MOV_B64,          O::S_MOV_B32,    O::V_PERMLANE16_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase VectorDpp8Captured(bool masked_exec) {
  using O = ShaderOpcode;
  constexpr u32 sentinel = 0xaaaaaaaau;
  const u32 masks[] = {masked_exec ? 0x0f0f0f0fu : 0xffffffffu,
                      masked_exec ? 0xf0f0f0f0u : 0xffffffffu};
  std::vector<u32> code;
  AppendVMovU32(&code, 5, 100);
  code.push_back(EncodeVop2(0x25, 5, Vgpr(0), 5));
  AppendVMovLiteral(&code, 2, sentinel);
  AppendVMovLiteral(&code, 3, sentinel);
  AppendSMovLiteral(&code, 126, masks[0]);
  AppendSMovLiteral(&code, 127, masks[1]);
  // Captured DPP8 selectors broadcast each group's upper/lower four lanes.
  code.push_back(EncodeVop1(0x01, 2, 233));
  code.push_back(0xfacfac05u);
  code.push_back(EncodeVop1(0x01, 3, 233));
  code.push_back(0x68868805u);
  AppendSMovLiteral(&code, 126, 0xffffffffu);
  AppendSMovLiteral(&code, 127, 0xffffffffu);
  code.push_back(EncodeVop2(0x1a, 6, InlineU32(2), 0));
  AppendBufferStoreDword(&code, 2, 6);
  AppendVMovU32(&code, 7, 64u * sizeof(u32));
  code.push_back(EncodeVop2(0x25, 6, Vgpr(7), 6));
  AppendBufferStoreDword(&code, 3, 6);
  AppendEnd(&code);

  TestCase test;
  test.name = masked_exec ? "VectorDpp8CapturedMaskedExec"
                          : "VectorDpp8Captured";
  test.code = std::move(code);
  test.expected.resize(128, sentinel);
  for (u32 lane = 0; lane < 64; ++lane) {
    const auto mask = masks[lane / 32u];
    if ((mask & (1u << (lane % 32u))) == 0) {
      continue;
    }
    const u32 sources[] = {(lane & ~7u) | 4u | (lane & 3u),
                           (lane & ~7u) | (lane & 3u)};
    for (u32 permutation = 0; permutation < 2; ++permutation) {
      const auto source = sources[permutation];
      test.expected[permutation * 64u + lane] =
          (mask & (1u << (source % 32u))) != 0 ? 100u + source : 0u;
    }
  }
  test.opcodes = {O::V_MOV_B32, O::V_ADD_NC_U32, O::S_MOV_B32,
                  O::V_LSHLREV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{".dpp8(", 2}};
  test.compute_info.wave_size = 64;
  test.compute_info.threads_num[0] = 64;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase VectorDppQuadPermuteReverse() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 1, 100);
  code.push_back(EncodeVop2(0x25, 2, 250, 1));
  code.push_back(EncodeVop2Dpp(0, 0x01b));
  code.push_back(EncodeVop2(0x1a, 3, InlineU32(2), 0));
  AppendBufferStoreDword(&code, 2, 3);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorDppQuadPermuteReverse";
  test.code = code;
  test.expected = {103, 102, 101, 100, 107, 106, 105, 104};
  test.opcodes = {O::V_MOV_B32, O::V_ADD_NC_U32, O::V_LSHLREV_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 8;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase VectorDppRowXmask() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 1, 100);
  code.push_back(EncodeVop2(0x25, 2, 250, 1));
  code.push_back(EncodeVop2Dpp(0, 0x164));
  code.push_back(EncodeVop2(0x1a, 3, InlineU32(2), 0));
  AppendBufferStoreDword(&code, 2, 3);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorDppRowXmask";
  test.code = code;
  test.expected = {104, 105, 106, 107, 100, 101, 102, 103};
  test.opcodes = {O::V_MOV_B32, O::V_ADD_NC_U32, O::V_LSHLREV_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 8;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase VectorDppBankMaskPreservesDestination() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 2, 0xaaaaaaaau);
  AppendVMovU32(&code, 1, 100);
  code.push_back(EncodeVop2(0x25, 2, 250, 1));
  code.push_back(EncodeVop2Dpp(0, 0x0e4, 0xf, 0xe));
  code.push_back(EncodeVop2(0x1a, 3, InlineU32(2), 0));
  AppendBufferStoreDword(&code, 2, 3);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorDppBankMaskPreservesDestination";
  test.code = code;
  test.expected = {0xaaaaaaaau, 0xaaaaaaaau, 0xaaaaaaaau, 0xaaaaaaaau,
                   104,         105,         106,         107};
  test.opcodes = {O::V_MOV_B32, O::V_ADD_NC_U32, O::V_LSHLREV_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 8;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase VectorDppBoundsControlZeroPreservesDestination() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 2, 0xaaaaaaaau);
  AppendVMovU32(&code, 1, 100);
  code.push_back(EncodeVop2(0x25, 2, 250, 1));
  code.push_back(EncodeVop2Dpp(0, 0x111));
  code.push_back(EncodeVop2(0x1a, 3, InlineU32(2), 0));
  AppendBufferStoreDword(&code, 2, 3);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorDppBoundsControlZeroPreservesDestination";
  test.code = code;
  test.expected = {0xaaaaaaaau, 100, 101, 102, 103, 104, 105, 106};
  test.opcodes = {O::V_MOV_B32, O::V_ADD_NC_U32, O::V_LSHLREV_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 8;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase Vop3FmacF32NegatedSourceAccumulates() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  constexpr u32 registers[] = {13, 20, 29};
  for (u32 sample = 0; sample < 2; sample++) {
    for (u32 source = 0; source < 3; source++) {
      AppendVMovU32(&code, 30, (sample * 3 + source) * sizeof(u32));
      AppendBufferLoadDword(&code, registers[source], 30);
    }
    code.push_back(0xd52b001du);
    code.push_back(0x4002290du); // v_fmac_f32_e64 v29, v13, -v20
    AppendStoreVgpr(&code, 29, sample);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "Vop3FmacF32NegatedSourceAccumulates";
  test.code = std::move(code);
  test.initial = {0x40000000u, 0x40400000u, 0x41200000u,
                  0x3f800001u, 0x3f7ffffeu, 0x3f800000u};
  // 10 - 2*3 = 4; 1 - (1+2^-23)*(1-2^-23) = 2^-46, not rounded zero.
  test.expected = {0x40800000u, 0x28800000u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_DWORD, O::V_MAC_F32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.required_spirv = {"OpFNegate", "Fma"};
  return test;
}

TestCase Vop3LdexpSourceModifier() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 9, 0xbfc00000u);
  code.push_back(0xd7620107u);
  code.push_back(0x00018509u);
  AppendStoreVgpr(&code, 7, 0);
  AppendEnd(&code);

  return {"Vop3LdexpSourceModifier",
          code,
          {},
          {0x3ec00000u},
          {O::V_MOV_B32, O::V_LDEXP_F32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase Vop1MoveRelSource() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 12, 0x11111111u);
  AppendVMovLiteral(&code, 13, 0x22222222u);
  AppendVMovLiteral(&code, 14, 0x33333333u);
  code.push_back(EncodeSMovB32(124, InlineU32(2)));
  code.push_back(0x7e6e870cu);
  AppendStoreVgpr(&code, 55, 0);
  AppendEnd(&code);

  return {"Vop1MoveRelSource",
          code,
          {},
          {0x33333333u},
          {O::V_MOV_B32, O::S_MOV_B32, O::V_MOVRELS_B32, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase Vop1MoveRelDestination() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 1, 0x12345678u);
  AppendVMovLiteral(&code, 5, 0xaaaaaaaau);
  AppendVMovLiteral(&code, 6, 0xbbbbbbbbu);
  AppendVMovLiteral(&code, 7, 0xccccccccu);
  code.push_back(EncodeSMovB32(124, InlineU32(2)));
  code.push_back(EncodeSop1(0x04, 8, 126));
  code.push_back(EncodeVopc(0xc2, InlineU32(0), 0));
  code.push_back(EncodeSop1(0x04, 126, 106));
  code.push_back(EncodeVop1(0x42, 5, Vgpr(1)));
  code.push_back(EncodeSop1(0x04, 126, 8));
  code.push_back(EncodeVop2(0x1a, 4, InlineU32(2), 0));
  AppendBufferStoreDword(&code, 7, 4);
  AppendEnd(&code);

  TestCase test;
  test.name = "Vop1MoveRelDestination";
  test.code = code;
  test.expected = {0x12345678u, 0xccccccccu, 0xccccccccu, 0xccccccccu};
  test.opcodes = {O::V_MOV_B32,          O::S_MOV_B32,     O::V_CMP_EQ_U32,
                  O::S_MOV_B64,          O::V_MOVRELD_B32, O::V_LSHLREV_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase VectorFloatSpecialOps() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x3f800000u);
  AppendVMovLiteral(&code, 1, 0x40000000u);
  AppendVMovLiteral(&code, 2, 0x40400000u);
  AppendVMovLiteral(&code, 3, 0x40800000u);
  AppendVMovLiteral(&code, 4, 0x40003c00u);
  AppendVMovLiteral(&code, 5, 0x44004200u);
  AppendVMovLiteral(&code, 6, 0x3f800000u);
  AppendVMovLiteral(&code, 7, 0x3f800000u);
  AppendVMovLiteral(&code, 8, 0xbf800000u);
  AppendVMovLiteral(&code, 10, 0x3f000000u);
  AppendVMovLiteral(&code, 12, 0xaaaabbbbu);
  AppendVMovLiteral(&code, 13, 0xaaaabbbbu);

  code.push_back(EncodeVop2(0x02, 6, Vgpr(4), 5));
  AppendVop3(&code, 0x368, 9, Vgpr(7), Vgpr(8));
  AppendVop3(&code, 0x369, 11, Vgpr(7), Vgpr(10));
  AppendVop3p(&code, 0x21, 12, Vgpr(1), Vgpr(2), Vgpr(0));
  AppendVop3p(&code, 0x22, 13, Vgpr(1), Vgpr(2), Vgpr(0));
  AppendVop3(&code, 0x144, 14, Vgpr(0), Vgpr(1), Vgpr(2));
  AppendVop3(&code, 0x145, 15, Vgpr(0), Vgpr(1), Vgpr(2));
  AppendVop3(&code, 0x146, 16, Vgpr(0), Vgpr(1), Vgpr(2));
  AppendVop3(&code, 0x147, 17, Vgpr(0), Vgpr(1), Vgpr(2));

  const u32 results[] = {6, 9, 11, 12, 13, 14, 15, 16, 17};
  for (u32 i = 0; i < static_cast<u32>(std::size(results)); i++) {
    AppendStoreVgpr(&code, results[i], i);
  }
  AppendEnd(&code);

  return {"VectorFloatSpecialOps",
          code,
          {},
          {0x41400000u, 0x80017fffu, 0x8000ffffu, 0xaaaa4700u, 0x4700bbbbu,
           0x40800000u, 0x3f800000u, 0xc0000000u, 0x40c00000u},
          {O::V_MOV_B32, O::V_DOT2C_F32_F16, O::V_CVT_PKNORM_I16_F32,
           O::V_CVT_PKNORM_U16_F32, O::V_MAD_MIXLO_F16, O::V_MAD_MIXHI_F16,
           O::V_CUBEID_F32, O::V_CUBESC_F32, O::V_CUBETC_F32, O::V_CUBEMA_F32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase MadMixF16LiteralHalfSourceUsesOpsel() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x3f800000u);
  AppendVMovLiteral(&code, 12, 0xaaaabbbbu);
  AppendVMovLiteral(&code, 13, 0x11112222u);

  AppendVop3p(&code, 0x21, 12, 255u, Vgpr(0), Vgpr(0), 0x1, 0x1);
  code.push_back(0x40003c00u);
  AppendVop3p(&code, 0x22, 13, 255u, Vgpr(0), Vgpr(0), 0x1, 0x0);
  code.push_back(0x40003c00u);

  AppendStoreVgpr(&code, 12, 0);
  AppendStoreVgpr(&code, 13, 1);
  AppendEnd(&code);

  return {"MadMixF16LiteralHalfSourceUsesOpsel",
          code,
          {},
          {0xaaaa4200u, 0x40002222u},
          {O::V_MOV_B32, O::V_MAD_MIXLO_F16, O::V_MAD_MIXHI_F16,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase MadMixF16NegHiIsAbsAndNegIsIndependent() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x3f800000u);
  AppendVMovLiteral(&code, 1, 0xc0000000u);
  AppendVMovLiteral(&code, 2, 0x40000000u);
  AppendVMovLiteral(&code, 12, 0xaaaabbbbu);
  AppendVMovLiteral(&code, 13, 0x11112222u);

  AppendVop3p(&code, 0x21, 12, Vgpr(1), Vgpr(0), Vgpr(0), 0, 0, 0x1);
  AppendVop3p(&code, 0x22, 13, Vgpr(2), Vgpr(0), Vgpr(0), 0, 0, 0, 0x1);

  AppendStoreVgpr(&code, 12, 0);
  AppendStoreVgpr(&code, 13, 1);
  AppendEnd(&code);

  return {"MadMixF16NegHiIsAbsAndNegIsIndependent",
          code,
          {},
          {0xaaaa4200u, 0xbc002222u},
          {O::V_MOV_B32, O::V_MAD_MIXLO_F16, O::V_MAD_MIXHI_F16,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorVop3FmaF16UsesRdna2Opcode34b() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 1, 0x40003c00u);
  AppendVMovLiteral(&code, 2, 0x44004200u);
  AppendVMovLiteral(&code, 3, 0x3c003c00u);
  AppendVMovLiteral(&code, 10, 0xaaaa5555u);
  AppendVMovLiteral(&code, 11, 0xbbbb5555u);

  AppendVop3(&code, 0x34bu, 10, Vgpr(1), Vgpr(2), Vgpr(3));
  AppendVop3(&code, 0x34bu, 11, Vgpr(1), Vgpr(2), Vgpr(3), 0, 0xfu);

  AppendStoreVgpr(&code, 10, 0);
  AppendStoreVgpr(&code, 11, 1);
  AppendEnd(&code);

  return {"VectorVop3FmaF16UsesRdna2Opcode34b",
          code,
          {},
          {0xaaaa4400u, 0x48805555u},
          {O::V_MOV_B32, O::V_FMA_F16, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase FloatInlineConstantF16UsesNumericValue() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 1, 0x38003800u); // 0.5h, 0.5h
  AppendVMovLiteral(&code, 2, 0x3c003c00u); // 1.0h, 1.0h
  AppendVMovLiteral(&code, 10, 0xaaaa0000u);
  AppendVMovLiteral(&code, 12, 0xbbbb0000u);

  AppendVop3(&code, 0x34bu, 10, 246u, Vgpr(1), Vgpr(2));
  AppendVop3p(&code, 0x0eu, 11, 246u, Vgpr(1), Vgpr(2), 0x1u);
  AppendVop3(&code, 0x34bu, 12, 248u, 242u, 128u);

  AppendStoreVgpr(&code, 10, 0);
  AppendStoreVgpr(&code, 11, 1);
  AppendStoreVgpr(&code, 12, 2);
  AppendEnd(&code);

  TestCase test;
  test.name = "FloatInlineConstantF16UsesNumericValue";
  test.code = std::move(code);
  test.expected = {0xaaaa4200u, 0x3c004200u, 0xbbbb3118u};
  test.opcodes = {O::V_MOV_B32, O::V_FMA_F16, O::V_PK_FMA_F16,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"4.000000", 2}, {"0.159155", 1}};
  return test;
}

TestCase VectorFloatControlContractPreservesInfNan() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeSop2(0x24, 0, InlineU32(8), InlineU32(23)));
  code.push_back(EncodeVop1(0x01, 0, InlineU32(0)));
  AppendVMovU32(&code, 1, 1);
  AppendVMovU32(&code, 2, 3);
  AppendVop3(&code, 0x108, 10, 0, Vgpr(0));
  code.push_back(EncodeVopc(0x88, Vgpr(10), 2));
  code.push_back(EncodeVop2(0x01, 3, InlineU32(0), 1));
  AppendStoreVgpr(&code, 3, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorFloatControlContractPreservesInfNan";
  test.code = std::move(code);
  test.expected = {1u};
  test.opcodes = {O::S_BFM_B32,       O::V_MOV_B32,     O::V_MUL_F32,
                  O::V_CMP_CLASS_F32, O::V_CNDMASK_B32, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.required_spirv = {"SPV_KHR_float_controls",
                         "SignedZeroInfNanPreserve 32"};
  return test;
}

TestCase VectorFloatArithmeticOps() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x3f800000u);
  AppendVMovLiteral(&code, 1, 0x40000000u);
  AppendVMovLiteral(&code, 2, 0x40800000u);
  AppendVMovLiteral(&code, 3, 0x40a00000u);
  AppendVMovLiteral(&code, 4, 0x40400000u);
  AppendVMovLiteral(&code, 11, 0x40800000u);
  AppendVMovLiteral(&code, 17, 0x40800000u);

  code.push_back(EncodeVop2(0x03, 5, Vgpr(0), 1));
  code.push_back(EncodeVop2(0x04, 6, Vgpr(3), 1));
  code.push_back(EncodeVop2(0x05, 7, Vgpr(1), 3));
  code.push_back(EncodeVop2(0x08, 8, Vgpr(1), 2));
  code.push_back(EncodeVop1(0x01, 21, Vgpr(8)));
  code.push_back(EncodeVop2(0x0f, 9, Vgpr(3), 1));
  code.push_back(EncodeVop2(0x10, 10, Vgpr(3), 1));
  code.push_back(EncodeVop2(0x1f, 11, Vgpr(1), 4));
  AppendVop3(&code, 0x141, 12, Vgpr(1), Vgpr(4), Vgpr(2));
  AppendVop3(&code, 0x14b, 13, Vgpr(1), Vgpr(4), Vgpr(2));
  AppendVop3(&code, 0x151, 14, Vgpr(3), Vgpr(1), Vgpr(2));
  AppendVop3(&code, 0x154, 15, Vgpr(3), Vgpr(1), Vgpr(2));
  AppendVop3(&code, 0x157, 16, Vgpr(3), Vgpr(1), Vgpr(2));
  code.push_back(EncodeVop2(0x20, 18, Vgpr(1), 17));
  code.push_back(0x3f800000u);
  code.push_back(EncodeVop2(0x21, 19, Vgpr(1), 4));
  code.push_back(0x40000000u);
  code.push_back(EncodeVop2(0x03, 20, 249, 1));
  code.push_back(EncodeVop2Sdwa(0));
  AppendSMovLiteral(&code, 70, 0x40000000u);
  code.push_back(0x06088cf9u);
  code.push_back(0x868606f2u);
  AppendSMovLiteral(&code, 26, 0x40000000u);
  code.push_back(0x081034f9u);
  code.push_back(0x868606f2u);
  code.push_back(0xd51f8011u);
  code.push_back(0x00020d0bu);
  AppendVMovLiteral(&code, 22, 0xbf800000u);
  code.push_back(EncodeVop2(0x05, 23, 249, 26));
  code.push_back(EncodeVop2Sdwa(22, 6, 0, 6, 6, 0, 0, 0, 1, 0, 0, 0, 1));
  AppendVMovLiteral(&code, 24, 0x3f800000u);
  AppendVMovLiteral(&code, 25, 0x3f800000u);
  code.push_back(EncodeVop2(0x03, 26, 249, 25));
  code.push_back(EncodeVop2Sdwa(24, 6, 0, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1));
  AppendVMovLiteral(&code, 27, 0xbf800000u);
  AppendVMovLiteral(&code, 28, 0x40000000u);
  AppendVop3(&code, 0x104, 29, Vgpr(27), Vgpr(28), 0, 1);
  AppendVop3(&code, 0x103, 30, Vgpr(0), Vgpr(1), 0, 0, 0, false, 1);
  AppendVop3(&code, 0x151, 32, Vgpr(0), Vgpr(1), Vgpr(2), 0, 0, false, 1);
  AppendVMovLiteral(&code, 33, 0xbf800000u);
  AppendVMovLiteral(&code, 34, 0x40000000u);
  code.push_back(EncodeVop2(0x03, 35, 250, 34));
  code.push_back(EncodeVop2Dpp(33, 0, 0xf, 0xf, 0, 1));

  const u32 results[] = {5,  6,  7,  21, 9, 10, 11, 12, 13, 14, 15, 16,
                         18, 19, 20, 4,  8, 17, 23, 26, 29, 30, 32, 35};
  for (u32 i = 0; i < static_cast<u32>(std::size(results)); i++) {
    AppendStoreVgpr(&code, results[i], i);
  }
  AppendEnd(&code);

  return {"VectorFloatArithmeticOps",
          code,
          {},
          {0x40400000u, 0x40400000u, 0x40400000u, 0x41000000u, 0x40000000u,
           0x40a00000u, 0x41200000u, 0x41200000u, 0x41200000u, 0x40000000u,
           0x40a00000u, 0x40800000u, 0x40c00000u, 0x41000000u, 0x40400000u,
           0x40400000u, 0xbf800000u, 0x3f800000u, 0x3f800000u, 0x40800000u,
           0xbf800000u, 0x40c00000u, 0x40000000u, 0x40400000u},
          {O::S_MOV_B32, O::V_MOV_B32, O::V_ADD_F32, O::V_SUB_F32,
           O::V_SUBREV_F32, O::V_MUL_F32, O::V_MIN_F32, O::V_MAX_F32,
           O::V_MAC_F32, O::V_MAD_F32, O::V_FMA_F32, O::V_MIN3_F32,
           O::V_MAX3_F32, O::V_MED3_F32, O::V_MADMK_F32, O::V_MADAK_F32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorMinMaxF32NanAndSignedZeroEdges() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x40000000u);
  AppendVMovLiteral(&code, 1, 0x7fc00000u);
  AppendVMovLiteral(&code, 2, 0x00000000u);
  AppendVMovLiteral(&code, 3, 0x80000000u);
  AppendVMovLiteral(&code, 4, 0x40400000u);
  AppendVMovLiteral(&code, 5, 0x3f800000u);
  AppendVMovLiteral(&code, 6, 0x7fa00001u);

  code.push_back(EncodeVop2(0x0f, 10, Vgpr(0), 1));
  code.push_back(EncodeVop2(0x10, 11, Vgpr(0), 1));
  code.push_back(EncodeVop2(0x0f, 12, Vgpr(3), 2));
  code.push_back(EncodeVop2(0x10, 13, Vgpr(2), 3));
  code.push_back(EncodeVop2(0x0f, 14, Vgpr(6), 0));
  code.push_back(EncodeVop2(0x10, 15, Vgpr(0), 6));
  AppendVop3(&code, 0x151, 16, Vgpr(0), Vgpr(1), Vgpr(4));
  AppendVop3(&code, 0x154, 17, Vgpr(0), Vgpr(1), Vgpr(5));

  for (u32 i = 0; i < 8; i++) {
    AppendStoreVgpr(&code, 10 + i, i);
  }
  AppendEnd(&code);

  return {"VectorMinMaxF32NanAndSignedZeroEdges",
          code,
          {},
          {0x40000000u, 0x40000000u, 0x80000000u, 0x00000000u, 0x40000000u,
           0x40000000u, 0x40000000u, 0x40000000u},
          {O::V_MOV_B32, O::V_MIN_F32, O::V_MAX_F32, O::V_MIN3_F32,
           O::V_MAX3_F32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorMed3F32NanUsesMin3Path() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x40000000u);
  AppendVMovLiteral(&code, 1, 0x40400000u);
  AppendVMovLiteral(&code, 2, 0x7fa00001u);
  AppendVMovLiteral(&code, 3, 0x7fc00000u);

  AppendVop3(&code, 0x157, 10, Vgpr(0), Vgpr(1), Vgpr(2));
  AppendVop3(&code, 0x157, 11, Vgpr(0), Vgpr(1), Vgpr(3));
  AppendVop3(&code, 0x157, 12, Vgpr(2), Vgpr(0), Vgpr(1));

  AppendStoreVgpr(&code, 10, 0);
  AppendStoreVgpr(&code, 11, 1);
  AppendStoreVgpr(&code, 12, 2);
  AppendEnd(&code);

  return {"VectorMed3F32NanUsesMin3Path",
          code,
          {},
          {0x40000000u, 0x40000000u, 0x40000000u},
          {O::V_MOV_B32, O::V_MED3_F32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorFloatConversionOps() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0xfffffffdu);
  code.push_back(EncodeVop1(0x01, 1, InlineU32(7)));
  AppendVMovLiteral(&code, 2, 0x40e00000u);
  AppendVMovLiteral(&code, 3, 0xc0400000u);
  AppendVMovLiteral(&code, 4, 0x3f800000u);
  AppendVMovLiteral(&code, 5, 0x00003c00u);
  AppendVMovLiteral(&code, 6, 0x40700000u);
  AppendVMovLiteral(&code, 7, 0x44332211u);
  AppendVMovLiteral(&code, 8, 0x40000000u);
  AppendVMovLiteral(&code, 9, 0x40800000u);
  AppendVMovLiteral(&code, 10, 0x40100000u);
  AppendVMovLiteral(&code, 11, 0x40300000u);
  code.push_back(EncodeVop1(0x01, 12, InlineU32(0)));
  code.push_back(EncodeVop1(0x01, 37, InlineU32(15)));

  code.push_back(EncodeVop1(0x05, 13, Vgpr(0)));
  code.push_back(EncodeVop1(0x06, 14, Vgpr(1)));
  code.push_back(EncodeVop1(0x07, 15, Vgpr(2)));
  code.push_back(EncodeVop1(0x08, 16, Vgpr(3)));
  code.push_back(EncodeVop1(0x0a, 17, Vgpr(4)));
  code.push_back(EncodeVop1(0x0b, 18, Vgpr(5)));
  code.push_back(EncodeVop1(0x0c, 42, Vgpr(11)));
  code.push_back(EncodeVop1(0x0d, 19, Vgpr(6)));
  code.push_back(EncodeVop1(0x11, 20, Vgpr(7)));
  code.push_back(EncodeVop1(0x12, 21, Vgpr(7)));
  code.push_back(EncodeVop1(0x13, 22, Vgpr(7)));
  code.push_back(EncodeVop1(0x14, 23, Vgpr(7)));
  code.push_back(EncodeVop1(0x2a, 24, Vgpr(8)));
  code.push_back(EncodeVop1(0x20, 25, Vgpr(10)));
  code.push_back(EncodeVop1(0x21, 26, Vgpr(11)));
  code.push_back(EncodeVop1(0x22, 27, Vgpr(10)));
  code.push_back(EncodeVop1(0x23, 28, Vgpr(10)));
  code.push_back(EncodeVop1(0x24, 29, Vgpr(11)));
  code.push_back(EncodeVop1(0x25, 30, Vgpr(4)));
  code.push_back(EncodeVop1(0x27, 36, Vgpr(9)));
  code.push_back(EncodeVop1(0x2e, 32, Vgpr(9)));
  code.push_back(EncodeVop1(0x33, 33, Vgpr(9)));
  code.push_back(EncodeVop1(0x35, 34, Vgpr(12)));
  code.push_back(EncodeVop1(0x36, 35, Vgpr(12)));
  code.push_back(EncodeVop1(0x0e, 38, Vgpr(37)));
  code.push_back(EncodeVop1(0x2a, 39, 249));
  code.push_back(EncodeVop1Sdwa(8, 6, 0, 6, 0, 0, 0, 0, 0, 1));
  AppendVMovLiteral(&code, 40, 0xc0000000u);
  AppendVop3(&code, 0x1aa, 41, Vgpr(40), 0, 0, 1, 0, false, 1);
  AppendVMovLiteral(&code, 2, 0xc0003c00u); // low=1.0h, high=-2.0h
  code.push_back(0x7e1016f9u);
  code.push_back(0x00250602u);

  const u32 results[] = {13, 14, 15, 16, 17, 18, 42, 19, 20, 21, 22, 23, 24, 25,
                         26, 27, 28, 29, 30, 36, 32, 33, 34, 35, 38, 39, 41, 8};
  for (u32 i = 0; i < static_cast<u32>(std::size(results)); i++) {
    AppendStoreVgpr(&code, results[i], i);
  }
  AppendEnd(&code);

  return {"VectorFloatConversionOps",
          code,
          {},
          {0xc0400000u, 0x40e00000u, 7,           0xfffffffdu, 0x00003c00u,
           0x3f800000u, 3,           3,           0x41880000u, 0x42080000u,
           0x424c0000u, 0x42880000u, 0x3f000000u, 0x3e800000u, 0x40000000u,
           0x40400000u, 0x40000000u, 0x40000000u, 0x40000000u, 0x40000000u,
           0x3f000000u, 0x40000000u, 0,           0x3f800000u, 0xbd800000u,
           0x3f800000u, 0x3f800000u, 0x40000000u},
          {O::V_MOV_B32,        O::V_CVT_F32_I32,     O::V_CVT_F32_U32,
           O::V_CVT_U32_F32,    O::V_CVT_I32_F32,     O::V_CVT_F16_F32,
           O::V_CVT_F32_F16,    O::V_CVT_RPI_I32_F32, O::V_CVT_FLR_I32_F32,
           O::V_CVT_OFF_F32_I4, O::V_CVT_F32_UBYTE0,  O::V_CVT_F32_UBYTE1,
           O::V_CVT_F32_UBYTE2, O::V_CVT_F32_UBYTE3,  O::V_RCP_F32,
           O::V_FRACT_F32,      O::V_TRUNC_F32,       O::V_CEIL_F32,
           O::V_RNDNE_F32,      O::V_FLOOR_F32,       O::V_EXP_F32,
           O::V_LOG_F32,        O::V_RSQ_F32,         O::V_SQRT_F32,
           O::V_SIN_F32,        O::V_COS_F32,         O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase VectorFrexpF32Edges() {
  using O = ShaderOpcode;

  const std::vector<u32> inputs = {
      0x00000000u, 0x80000000u, 0x3f000000u, 0xbf800000u, 0x40800000u,
      0xc1000000u, 0x00800000u, 0x007fffffu, 0x00000001u, 0x7f800000u,
      0x7fc00000u, 0xff800000u, 0x7fa00001u,
  };
  std::vector<u32> code;
  for (u32 i = 0; i < static_cast<u32>(inputs.size()); i++) {
    AppendVMovU32(&code, 31, i * sizeof(u32));
    AppendBufferLoadDword(&code, i == 3u ? 23u : i, 31);
  }
  for (u32 i = 0; i < static_cast<u32>(inputs.size()); i++) {
    const auto exponent_dst = i == 3u ? 19u : 32u + i;
    const auto mantissa_dst = i == 3u ? 21u : 48u + i;
    if (i == 3u) {
      code.push_back(0x7e267ef9u); // captured v_frexp_exp_i32_f32 v19, abs(v23)
      code.push_back(0x00260617u);
    } else {
      code.push_back(EncodeVop1(0x3f, exponent_dst, Vgpr(i)));
    }
    AppendStoreVgpr(&code, exponent_dst, i);
    if (i == 3u) {
      code.push_back(0x7e2a80f9u); // captured v_frexp_mant_f32 v21, abs(v23)
      code.push_back(0x00260617u);
    } else {
      code.push_back(EncodeVop1(0x40, mantissa_dst, Vgpr(i)));
    }
    AppendStoreVgpr(&code, mantissa_dst, inputs.size() + i);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorFrexpF32Edges";
  test.code = std::move(code);
  test.initial = inputs;
  test.initial.resize(inputs.size() * 2u);
  test.expected = {
      0u,          0u,          0u,          1u,          3u,
      4u,          0xffffff83u, 0xffffff82u, 0xffffff6cu, 0u,
      0u,          0u,          0u,          0x00000000u, 0x80000000u,
      0x3f000000u, 0x3f000000u, 0x3f000000u, 0xbf000000u, 0x3f000000u,
      0x3f7ffffeu, 0x3f000000u, 0x7f800000u, 0x7fc00000u, 0xff800000u,
      0x7fa00001u,
  };
  test.opcodes = {O::V_MOV_B32,           O::BUFFER_LOAD_DWORD,
                  O::V_FREXP_EXP_I32_F32, O::V_FREXP_MANT_F32,
                  O::BUFFER_STORE_DWORD,  O::S_ENDPGM};
  test.decoded_counts = {{"V_FREXP_EXP_I32_F32", inputs.size()},
                         {"V_FREXP_MANT_F32", inputs.size()}};
  test.required_spirv = {"FindUMsb", "OpBitFieldUExtract",
                         "OpShiftLeftLogical"};
  return test;
}

TestCase CvtF32ToIntSaturatesNaNAndOutOfRange() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x7fc00000u);
  AppendVMovLiteral(&code, 1, 0xbf800000u);
  AppendVMovLiteral(&code, 2, 0x7f800000u);
  AppendVMovLiteral(&code, 3, 0x4f800000u);
  AppendVMovLiteral(&code, 4, 0xff800000u);
  AppendVMovLiteral(&code, 5, 0x4f000000u);

  code.push_back(EncodeVop1(0x07, 10, Vgpr(0)));
  code.push_back(EncodeVop1(0x07, 11, Vgpr(1)));
  code.push_back(EncodeVop1(0x07, 12, Vgpr(2)));
  code.push_back(EncodeVop1(0x07, 13, Vgpr(3)));
  code.push_back(EncodeVop1(0x08, 14, Vgpr(0)));
  code.push_back(EncodeVop1(0x08, 15, Vgpr(2)));
  code.push_back(EncodeVop1(0x08, 16, Vgpr(4)));
  code.push_back(EncodeVop1(0x08, 17, Vgpr(5)));

  for (u32 i = 0; i < 8; i++) {
    AppendStoreVgpr(&code, 10 + i, i);
  }
  AppendEnd(&code);

  return {"CvtF32ToIntSaturatesNaNAndOutOfRange",
          code,
          {},
          {0, 0, 0xffffffffu, 0xffffffffu, 0, 0x7fffffffu, 0x80000000u,
           0x7fffffffu},
          {O::V_MOV_B32, O::V_CVT_U32_F32, O::V_CVT_I32_F32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorSpecialF32FlushesDenormalInputs() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x00000001u);
  code.push_back(EncodeVop1(0x27, 1, Vgpr(0)));
  code.push_back(EncodeVop1(0x2a, 2, Vgpr(0)));
  code.push_back(EncodeVop1(0x2e, 3, Vgpr(0)));
  code.push_back(EncodeVop1(0x33, 4, Vgpr(0)));
  AppendStoreVgpr(&code, 1, 0);
  AppendStoreVgpr(&code, 2, 1);
  AppendStoreVgpr(&code, 3, 2);
  AppendStoreVgpr(&code, 4, 3);
  AppendEnd(&code);

  return {"VectorSpecialF32FlushesDenormalInputs",
          code,
          {},
          {0xff800000u, 0x7f800000u, 0x7f800000u, 0x00000000u},
          {O::V_MOV_B32, O::V_LOG_F32, O::V_RCP_F32, O::V_RSQ_F32,
           O::V_SQRT_F32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorRcpIflagF32IntegerReciprocal() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 0, 0);
  AppendVMovU32(&code, 1, 1);
  AppendVMovU32(&code, 2, 2);
  AppendVMovLiteral(&code, 3, 0xffffffffu);
  for (u32 i = 0; i < 4; i++) {
    code.push_back(EncodeVop1(0x06, 4 + i, Vgpr(i)));
    code.push_back(EncodeVop1(0x2b, 8 + i, Vgpr(4 + i)));
  }
  AppendVMovLiteral(&code, 12, 0xc0000000u);
  AppendVop3(&code, 0x1ab, 13, Vgpr(12), 0, 0, 1, 0, false, 1);
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, 8 + i, i);
  }
  AppendStoreVgpr(&code, 13, 4);
  AppendEnd(&code);

  TestCase test;
  test.name = "VectorRcpIflagF32IntegerReciprocal";
  test.code = std::move(code);
  test.expected = {0x7f800000u, 0x3f800000u, 0x3f000000u, 0x2f800000u,
                   0x3f800000u};
  test.opcodes = {O::V_MOV_B32, O::V_CVT_F32_U32, O::V_RCP_IFLAG_F32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"V_RCP_IFLAG_F32", 5}};
  test.ir_counts = {{"FPRecipIFlag32", 5}};
  test.required_spirv = {"OpConvertUToF", "OpFDiv"};
  test.forbidden_spirv = {"8388608"};
  return test;
}

TestCase VectorSinCosMaxFiniteSpecialCases() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0xff7fffffu);
  code.push_back(EncodeVop1(0x35, 1, Vgpr(0)));
  code.push_back(EncodeVop1(0x36, 2, Vgpr(0)));
  AppendStoreVgpr(&code, 1, 0);
  AppendStoreVgpr(&code, 2, 1);
  AppendEnd(&code);

  return {"VectorSinCosMaxFiniteSpecialCases",
          code,
          {},
          {0x00000000u, 0x3f800000u},
          {O::V_MOV_B32, O::V_SIN_F32, O::V_COS_F32, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase VectorCompareOps() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  std::vector<u32> results;
  std::vector<u32> expected;
  u32 dst = 10;

  code.push_back(EncodeVop1(0x01, 1, InlineU32(1)));
  AppendVMovLiteral(&code, 2, 0x40000000u);
  AppendVMovLiteral(&code, 3, 0x40400000u);
  code.push_back(EncodeVop1(0x01, 4, InlineU32(1)));
  AppendVMovLiteral(&code, 5, 0xffffffffu);

  auto append_compare = [&](u32 opcode, u32 src0, u32 src1, bool value) {
    if (dst == 31u) {
      dst++;
    }
    code.push_back(EncodeVopc(opcode, src0, src1));
    code.push_back(EncodeVop2(0x01, dst, InlineU32(0), 1));
    results.push_back(dst);
    expected.push_back(value ? 1u : 0u);
    dst++;
  };

  append_compare(0x00, Vgpr(2), 3, false);
  append_compare(0x01, Vgpr(2), 3, true);
  append_compare(0x02, Vgpr(2), 3, false);
  append_compare(0x03, Vgpr(2), 3, true);
  append_compare(0x04, Vgpr(2), 3, false);
  append_compare(0x05, Vgpr(2), 3, true);
  append_compare(0x06, Vgpr(2), 3, false);
  append_compare(0x07, Vgpr(2), 3, true);
  append_compare(0x08, Vgpr(2), 3, false);
  append_compare(0x09, Vgpr(2), 3, true);
  append_compare(0x0a, Vgpr(2), 3, false);
  append_compare(0x0b, Vgpr(2), 3, true);
  append_compare(0x0c, Vgpr(2), 3, false);
  append_compare(0x0d, Vgpr(2), 3, true);
  append_compare(0x0e, Vgpr(2), 3, false);
  append_compare(0x0f, Vgpr(2), 3, true);

  append_compare(0x80, Vgpr(5), 4, false);
  append_compare(0x81, Vgpr(5), 4, true);
  append_compare(0x82, Vgpr(5), 4, false);
  append_compare(0x83, Vgpr(5), 4, true);
  append_compare(0x84, Vgpr(5), 4, false);
  append_compare(0x85, Vgpr(5), 4, true);
  append_compare(0x86, Vgpr(5), 4, false);
  append_compare(0x87, Vgpr(5), 4, true);

  append_compare(0xc0, Vgpr(4), 5, false);
  append_compare(0xc1, Vgpr(4), 5, true);
  append_compare(0xc2, Vgpr(4), 5, false);
  append_compare(0xc3, Vgpr(4), 5, true);
  append_compare(0xc4, Vgpr(4), 5, false);
  append_compare(0xc5, Vgpr(4), 5, true);
  append_compare(0xc6, Vgpr(4), 5, false);
  append_compare(0xc7, Vgpr(4), 5, true);

  code.push_back(0x7c1d00f9u);
  code.push_back(0x86069201u);
  code.push_back(EncodeVopc(0x84, 249, 4));
  code.push_back(EncodeVopcSdwa(5, 19, 1));
  code.push_back(EncodeVopc(0x01, 250, 3));
  code.push_back(EncodeVop2Dpp(2));
  AppendVMovLiteral(&code, 6, 0xc0000000u);
  AppendVMovLiteral(&code, 7, 0x3f800000u);
  AppendVop3(&code, 0x04, 20, Vgpr(6), Vgpr(7), 0, 1);
  for (u32 i = 0; i < static_cast<u32>(results.size()); i++) {
    AppendStoreVgpr(&code, results[i], i);
  }
  AppendStoreSgpr(&code, 18, static_cast<u32>(results.size()));
  expected.push_back(1u);
  AppendStoreSgpr(&code, 19, static_cast<u32>(results.size() + 1u));
  expected.push_back(0u);
  AppendStoreSgpr(&code, 106, static_cast<u32>(results.size() + 2u));
  expected.push_back(1u);
  AppendStoreSgpr(&code, 20, static_cast<u32>(results.size() + 3u));
  expected.push_back(1u);
  AppendEnd(&code);

  return {"VectorCompareOps",
          code,
          {},
          expected,
          {O::V_MOV_B32,     O::V_CNDMASK_B32,      O::V_CMP_F_F32,
           O::V_CMP_LT_F32,  O::V_CMP_EQ_F32,       O::V_CMP_LE_F32,
           O::V_CMP_GT_F32,  O::V_CMP_LG_F32,       O::V_CMP_GE_F32,
           O::V_CMP_O_F32,   O::V_CMP_U_F32,        O::V_CMP_NGE_F32,
           O::V_CMP_NLG_F32, O::V_CMP_NGT_F32,      O::V_CMP_NLE_F32,
           O::V_CMP_NEQ_F32, O::V_CMP_NLT_F32,      O::V_CMP_TRU_F32,
           O::V_CMP_F_I32,   O::V_CMP_LT_I32,       O::V_CMP_EQ_I32,
           O::V_CMP_LE_I32,  O::V_CMP_GT_I32,       O::V_CMP_NE_I32,
           O::V_CMP_GE_I32,  O::V_CMP_T_I32,        O::V_CMP_F_U32,
           O::V_CMP_LT_U32,  O::V_CMP_EQ_U32,       O::V_CMP_LE_U32,
           O::V_CMP_GT_U32,  O::V_CMP_NE_U32,       O::V_CMP_GE_U32,
           O::V_CMP_T_U32,   O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorVop3CompareEqU64OnGpu() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeVop1(0x01, 1, InlineU32(1)));

  code.push_back(EncodeSop1(0x04, 106, 126)); // s_mov_b64 vcc, exec
  code.push_back(0xd4e2006au);
  code.push_back(0x0000d47eu); // v_cmp_eq_u64 vcc, exec, vcc
  code.push_back(EncodeVop2(0x01, 2, InlineU32(0), 1));
  AppendStoreVgpr(&code, 2, 0);

  AppendSMovLiteral(&code, 107, 1); // high-dword mismatch
  code.push_back(0xd4e2006au);
  code.push_back(0x0000d47eu); // v_cmp_eq_u64 vcc, exec, vcc
  code.push_back(EncodeVop2(0x01, 3, InlineU32(0), 1));
  AppendStoreVgpr(&code, 3, 1);
  AppendEnd(&code);

  TestCase test{"VectorVop3CompareEqU64OnGpu",
                code,
                {},
                {1, 0},
                {O::V_MOV_B32, O::S_MOV_B64, O::V_CMP_EQ_U64,
                 O::V_CNDMASK_B32, O::S_MOV_B32, O::BUFFER_STORE_DWORD,
                 O::S_ENDPGM}};
  test.decoded_counts = {{"V_CMP_EQ_U64 vcc_lo, exec_lo, vcc_lo", 2}};
  return test;
}

TestCase VectorVop3CompareNeU64OnGpu() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeVop1(0x01, 1, InlineU32(1)));

  code.push_back(EncodeSop1(0x04, 106, 126)); // s_mov_b64 vcc, exec
  code.push_back(0xd4e5006au);
  code.push_back(0x0000d47eu); // v_cmp_ne_u64 vcc, exec, vcc
  code.push_back(EncodeVop2(0x01, 2, InlineU32(0), 1));
  AppendStoreVgpr(&code, 2, 0);

  AppendSMovLiteral(&code, 106, 0);
  AppendSMovLiteral(&code, 107, 0);
  code.push_back(0xd4e5006au);
  code.push_back(0x0000d47eu); // v_cmp_ne_u64 vcc, exec, vcc
  code.push_back(EncodeVop2(0x01, 3, InlineU32(0), 1));
  AppendStoreVgpr(&code, 3, 1);
  AppendEnd(&code);

  return {"VectorVop3CompareNeU64OnGpu",
          code,
          {},
          {0, 1},
          {O::V_MOV_B32, O::S_MOV_B64, O::V_CMP_NE_U64, O::V_CNDMASK_B32,
           O::S_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorVopcCmpxNeU64CapturedExecMask() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 7, 0);
  AppendVMovU32(&code, 8, 0);
  AppendVMovU32(&code, 31, 0);
  code.push_back(0x7dea0e80u); // v_cmpx_ne_u64 exec, 0, v[7:8]
  AppendBufferStoreDword(&code, 8, 31);

  code.push_back(EncodeSMovB32(126, InlineU32(1)));
  AppendVMovU32(&code, 8, 1);
  AppendVMovU32(&code, 31, 4);
  code.push_back(0x7dea0e80u); // v_cmpx_ne_u64 exec, 0, v[7:8]
  AppendBufferStoreDword(&code, 8, 31);

  AppendVMovU32(&code, 2, 0);
  AppendVMovU32(&code, 3, 0);
  AppendVMovU32(&code, 31, 8);
  code.push_back(0x7dea0480u); // v_cmpx_ne_u64 exec, 0, v[2:3]
  AppendBufferStoreDword(&code, 3, 31);

  code.push_back(EncodeSMovB32(126, InlineU32(1)));
  AppendVMovU32(&code, 3, 1);
  AppendVMovU32(&code, 31, 12);
  code.push_back(0x7dea0480u); // v_cmpx_ne_u64 exec, 0, v[2:3]
  AppendBufferStoreDword(&code, 3, 31);
  AppendEnd(&code);

  TestCase test{"VectorVopcCmpxNeU64CapturedExecMask",
                code,
                {0x11223344u, 0x55667788u, 0xaabbccddu, 0xeeff0011u},
                {0x11223344u, 1u, 0xaabbccddu, 1u},
                {O::V_MOV_B32, O::V_CMPX_NE_U64, O::BUFFER_STORE_DWORD,
                 O::S_MOV_B32, O::S_ENDPGM}};
  test.decoded_counts = {{"V_CMPX_NE_U64 exec_lo, 0, v7", 2},
                         {"V_CMPX_NE_U64 exec_lo, 0, v2", 2}};
  return test;
}

TestCase VectorVop3CmpxNeI64CapturedExecMask() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 7, 0);
  AppendVMovU32(&code, 8, 0);
  AppendVMovU32(&code, 31, 0);
  code.push_back(0xd4b5007eu);
  code.push_back(0x00020e80u); // v_cmpx_ne_i64 exec, 0, v[7:8]
  AppendBufferStoreDword(&code, 8, 31);

  code.push_back(EncodeSMovB32(126, InlineU32(1)));
  AppendVMovU32(&code, 8, 1);
  AppendVMovU32(&code, 31, 4);
  code.push_back(0xd4b5007eu);
  code.push_back(0x00020e80u); // v_cmpx_ne_i64 exec, 0, v[7:8]
  AppendBufferStoreDword(&code, 8, 31);
  AppendEnd(&code);

  TestCase test{"VectorVop3CmpxNeI64CapturedExecMask",
                code,
                {0x11223344u, 0x55667788u},
                {0x11223344u, 1u},
                {O::V_MOV_B32, O::V_CMPX_NE_I64, O::BUFFER_STORE_DWORD,
                 O::S_MOV_B32, O::S_ENDPGM}};
  test.decoded_counts = {{"V_CMPX_NE_I64 exec_lo, 0, v7", 2}};
  return test;
}

TestCase VectorVop3CompareGtU64OnGpu() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeVop1(0x01, 1, InlineU32(1)));

  AppendSMovLiteral(&code, 4, 0);
  AppendSMovLiteral(&code, 5, 0x80000000u);
  code.push_back(0xd4e4006au);
  code.push_back(0x00010004u); // v_cmp_gt_u64 vcc, s[4:5], 0
  code.push_back(EncodeVop2(0x01, 2, InlineU32(0), 1));
  AppendStoreVgpr(&code, 2, 0);

  code.push_back(0xd4e4006au);
  code.push_back(0x0001006au); // v_cmp_gt_u64 vcc, vcc, 0
  code.push_back(EncodeVop2(0x01, 3, InlineU32(0), 1));
  AppendStoreVgpr(&code, 3, 1);

  AppendSMovLiteral(&code, 106, 0);
  AppendSMovLiteral(&code, 107, 0);
  code.push_back(0xd4e4006au);
  code.push_back(0x0001006au); // v_cmp_gt_u64 vcc, vcc, 0
  code.push_back(EncodeVop2(0x01, 4, InlineU32(0), 1));
  AppendStoreVgpr(&code, 4, 2);
  AppendEnd(&code);

  TestCase test{"VectorVop3CompareGtU64OnGpu",
                code,
                {},
                {1, 1, 0},
                {O::V_MOV_B32, O::S_MOV_B32, O::V_CMP_GT_U64, O::V_CNDMASK_B32,
                 O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
  test.compute_info.threads_num[0] = 64;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.wave_size = 32;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase VectorVopcCompareLtU64OnGpu() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 0, 5);
  AppendVMovU32(&code, 1, 0);
  AppendVMovU32(&code, 2, 1);

  AppendSMovLiteral(&code, 4, 4);
  AppendSMovLiteral(&code, 5, 0);
  code.push_back(EncodeVopc(0xe1, 4, 0));
  code.push_back(EncodeVop2(0x01, 3, InlineU32(0), 2));
  AppendStoreVgpr(&code, 3, 0);

  AppendSMovLiteral(&code, 4, 6);
  code.push_back(EncodeVopc(0xe1, 4, 0));
  code.push_back(EncodeVop2(0x01, 4, InlineU32(0), 2));
  AppendStoreVgpr(&code, 4, 1);
  AppendEnd(&code);

  TestCase test{"VectorVopcCompareLtU64OnGpu",
                code,
                {},
                {1, 0},
                {O::V_MOV_B32, O::S_MOV_B32, O::V_CMP_LT_U64,
                 O::V_CNDMASK_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
  test.decoded_counts = {{"V_CMP_LT_U64 vcc_lo, s4, v0", 2}};
  return test;
}

TestCase VectorVop3CompareEqI64OnGpu() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeVop1(0x01, 1, InlineU32(1)));
  code.push_back(EncodeSop1(0x04, 4, 126)); // s_mov_b64 s[4:5], exec

  code.push_back(0xd4a2006au);
  code.push_back(0x0000087eu); // v_cmp_eq_i64 vcc, exec, s[4:5]
  code.push_back(EncodeVop2(0x01, 2, InlineU32(0), 1));
  AppendStoreVgpr(&code, 2, 0);

  AppendSMovLiteral(&code, 4, 0);
  code.push_back(0xd4a2006au);
  code.push_back(0x0000087eu); // low dword mismatch
  code.push_back(EncodeVop2(0x01, 3, InlineU32(0), 1));
  AppendStoreVgpr(&code, 3, 1);
  AppendEnd(&code);

  return {"VectorVop3CompareEqI64OnGpu",
          code,
          {},
          {1, 0},
          {O::V_MOV_B32, O::S_MOV_B64, O::V_CMP_EQ_I64, O::V_CNDMASK_B32,
           O::S_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorCompareClassF32() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  std::vector<u32> expected;
  AppendVMovU32(&code, 1, 1);

  u32 out = 0;
  auto append_class = [&](u32 bits, u32 class_mask, bool match) {
    AppendVMovLiteral(&code, 0, bits);
    AppendVMovU32(&code, 2, class_mask);
    code.push_back(EncodeVopc(0x88, Vgpr(0), 2));
    code.push_back(EncodeVop2(0x01, 3, InlineU32(0), 1));
    AppendStoreVgpr(&code, 3, out++);
    expected.push_back(match ? 1u : 0u);
  };

  append_class(0x7fc00000u, 1u << 1u, true);
  append_class(0xff800000u, 1u << 2u, true);
  append_class(0xbf800000u, 1u << 3u, true);
  append_class(0x80000000u, 1u << 5u, true);
  append_class(0x00000000u, 1u << 6u, true);
  append_class(0x40000000u, 1u << 8u, true);
  append_class(0x7f800000u, 1u << 9u, true);
  append_class(0x40000000u, 1u << 3u, false);

  AppendVMovLiteral(&code, 0, 0x3f800000u);
  AppendVMovU32(&code, 2, 1u << 3u);
  AppendVop3(&code, 0x88, 20, Vgpr(0), Vgpr(2), 0, 0, 0, false, 0, 1);
  AppendStoreSgprPair(&code, 20, out);
  expected.push_back(1u);
  expected.push_back(0u);
  AppendEnd(&code);

  return {"VectorCompareClassF32",
          code,
          {},
          expected,
          {O::V_MOV_B32, O::V_CMP_CLASS_F32, O::V_CNDMASK_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorVopcSdwaCmpxClassF32CapturedExecMask() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 13, 0x7fc00000u); // Quiet NaN.
  AppendVMovU32(&code, 3, 7);
  AppendVMovU32(&code, 31, 0);
  code.push_back(EncodeSMovB32(106, InlineU32(2))); // qNaN class mask.
  code.insert(code.end(), {0x7d30d4f9u, 0x8606000du});
  AppendBufferStoreDword(&code, 3, 31);

  code.push_back(EncodeSMovB32(126, InlineU32(1))); // Restore lane-zero EXEC.
  AppendVMovLiteral(&code, 13, 0x3f800000u);        // Positive normal.
  AppendVMovU32(&code, 3, 9);
  AppendVMovU32(&code, 31, 4);
  code.push_back(EncodeSMovB32(106, InlineU32(2))); // qNaN class mask.
  code.insert(code.end(), {0x7d30d4f9u, 0x8606000du});
  AppendBufferStoreDword(&code, 3, 31);
  AppendEnd(&code);

  TestCase test{
      "VectorVopcSdwaCmpxClassF32CapturedExecMask",
      code,
      {0x11111111u, 0x22222222u},
      {7u, 0x22222222u},
      {O::S_MOV_B32, O::V_MOV_B32, O::V_CMPX_CLASS_F32,
       O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
  test.decoded_counts = {
      {"V_CMPX_CLASS_F32 exec_lo, v13, vcc_lo", 2}};
  return test;
}

TestCase Wave32VccMasksPreserveOtherHalf() {
  using O = ShaderOpcode;
  TestCase test;
  test.name = "Wave32VccMasksPreserveOtherHalf";
  auto &code = test.code;
  AppendSMovLiteral(&code, 106, 0x12345678u);
  AppendSMovLiteral(&code, 107, 0x2468ace0u);
  AppendVMovU32(&code, 1, 20);
  u32 offset = 0;
  const auto check_masks = [&](u32 low, u32 high) {
    AppendStoreSgprAtLaneDwordOffset(&code, 106, 0, offset);
    AppendStoreSgprAtLaneDwordOffset(&code, 107, 0, offset + 4);
    AppendVop3(&code, 0x101, 2, InlineU32(10), Vgpr(1), 107);
    code.push_back(EncodeVop2(0x01, 3, InlineU32(10), 1));
    AppendStoreVgprAtLaneDwordOffset(&code, 2, 0, offset + 8);
    AppendStoreVgprAtLaneDwordOffset(&code, 3, 0, offset + 12);
    test.expected.insert(test.expected.end(), 4, low);
    test.expected.insert(test.expected.end(), 4, high);
    for (u32 mask : {high, low}) {
      for (u32 lane = 0; lane < 4; ++lane) {
        test.expected.push_back((mask & (1u << lane)) != 0 ? 20u : 10u);
      }
    }
    offset += 16;
  };
  // PPSA10737 keeps a table offset in VCC_LO while comparing into VCC_HI.
  AppendVop3(&code, 0xc2, 107, InlineU32(1), Vgpr(0));
  check_masks(0x12345678u, 2u);
  AppendVop3(&code, 0xc2, 106, InlineU32(2), Vgpr(0));
  check_masks(4u, 2u);
  code.push_back(EncodeSop2(0x10, 106, 106, 107)); // s_or_b32
  check_masks(6u, 2u);
  code.push_back(EncodeSop1(0x04, 106, 193u)); // Explicit s_mov_b64 writes both.
  check_masks(0xffffffffu, 0xffffffffu);
  AppendEnd(&code);
  test.opcodes = {O::S_MOV_B32, O::S_MOV_B64, O::S_OR_B32, O::V_MOV_B32,
                  O::V_CMP_EQ_U32, O::V_CNDMASK_B32, O::V_LSHLREV_B32,
                  O::V_ADD_NC_U32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.wave_size = 32;
  test.has_compute_info = true;
  return test;
}

TestCase VectorCompareF16Ops() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  std::vector<u32> expected;
  AppendVMovU32(&code, 1, 1);
  AppendVMovLiteral(&code, 2, 0x40003c00u); // low=1.0h, high=2.0h
  AppendVMovLiteral(&code, 3, 0x44004200u); // low=3.0h, high=4.0h
  AppendVMovLiteral(&code, 4, 0x00007e00u); // low=qNaN

  u32 dst = 10;
  u32 out = 0;
  auto append_compare = [&](u32 opcode, u32 src0, u32 src1, bool value) {
    code.push_back(EncodeVopc(opcode, src0, src1));
    code.push_back(EncodeVop2(0x01, dst, InlineU32(0), 1));
    AppendStoreVgpr(&code, dst, out++);
    expected.push_back(value ? 1u : 0u);
    dst++;
  };

  append_compare(0xc9, Vgpr(2), 3, true);
  append_compare(0xca, Vgpr(2), 2, true);
  append_compare(0xcb, Vgpr(2), 3, true);
  append_compare(0xcc, Vgpr(3), 2, true);
  append_compare(0xcd, Vgpr(2), 3, true);
  append_compare(0xce, Vgpr(3), 2, true);
  append_compare(0xed, Vgpr(4), 2, true);

  auto append_cmpx = [&](u32 opcode, u32 src0, u32 src1) {
    code.push_back(EncodeSMovB32(126, InlineU32(1)));
    code.push_back(EncodeVopc(opcode, src0, src1));
    AppendStoreVgpr(&code, 1, out++);
    expected.push_back(1u);
  };

  append_cmpx(0xd9, Vgpr(2), 3);
  append_cmpx(0xda, Vgpr(2), 2);
  append_cmpx(0xdb, Vgpr(2), 3);
  append_cmpx(0xdc, Vgpr(3), 2);
  append_cmpx(0xde, Vgpr(3), 2);
  append_cmpx(0xfd, Vgpr(4), 2);
  append_cmpx(0xfe, Vgpr(2), 2);
  AppendEnd(&code);

  return {"VectorCompareF16Ops",
          code,
          {},
          expected,
          {O::V_MOV_B32, O::S_MOV_B32, O::V_CMP_LT_F16, O::V_CMP_EQ_F16,
           O::V_CMP_LE_F16, O::V_CMP_GT_F16, O::V_CMP_LG_F16, O::V_CMP_GE_F16,
           O::V_CMP_NEQ_F16, O::V_CMPX_LT_F16, O::V_CMPX_EQ_F16,
           O::V_CMPX_LE_F16, O::V_CMPX_GT_F16, O::V_CMPX_GE_F16,
           O::V_CMPX_NEQ_F16, O::V_CMPX_NLT_F16, O::V_CNDMASK_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase Vop2SdwaCndmaskSourceModifier() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 6, 0x00000000u);
  AppendVMovLiteral(&code, 47, 0x12345678u);
  AppendVMovLiteral(&code, 53, 0x3f800000u);
  code.push_back(EncodeVopc(0xc7, Vgpr(6), 6)); // v_cmp_t_u32
  code.push_back(0x025e6af9u);
  code.push_back(0x16060635u);
  AppendStoreVgpr(&code, 47, 0);
  AppendEnd(&code);

  return {"Vop2SdwaCndmaskSourceModifier",
          code,
          {},
          {0xbf800000u},
          {O::V_MOV_B32, O::V_CMP_T_U32, O::V_CNDMASK_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase Vop2SdwaCndmaskCapturedByte3Source() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x55667788u);
  AppendBufferLoadDword(&code, 3, 30);
  code.push_back(EncodeVopc(0xc0, Vgpr(0), 0)); // v_cmp_f_u32
  code.push_back(0x023a00f9u);
  code.push_back(0x06030603u);
  AppendStoreVgpr(&code, 29, 1);
  code.push_back(EncodeVopc(0xc7, Vgpr(0), 0)); // v_cmp_t_u32
  code.push_back(0x023a00f9u);
  code.push_back(0x06030603u);
  AppendStoreVgpr(&code, 29, 2);
  AppendEnd(&code);

  TestCase test;
  test.name = "Vop2SdwaCndmaskCapturedByte3Source";
  test.code = code;
  test.initial = {0xabcd1234u, 0, 0};
  test.expected = {0xabcd1234u, 0x000000abu, 0x55667788u};
  test.opcodes = {O::V_MOV_B32,   O::BUFFER_LOAD_DWORD, O::V_CMP_F_U32,
                  O::V_CMP_T_U32, O::V_CNDMASK_B32,     O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.decoded_counts = {{"V_CNDMASK_B32 v29, v3.sdwa(sel=3,sext=0), v0", 2}};
  test.required_spirv = {"OpBitFieldUExtract", "OpSelect"};
  return test;
}

TestCase Vop3CndmaskUsesSgprMaskLaneBits() {
  using O = ShaderOpcode;

  std::vector<u32> code = {
      EncodeVop1(0x01, 1, 0),          EncodeVop2(0x1a, 1, InlineU32(2), 1),
      EncodeVop2(0x25, 1, Vgpr(0), 1), EncodeVopc(0xc2, InlineU32(0), 0),
      EncodeSop1(0x04, 4, 106),
  };
  AppendVop3(&code, 0x101, 2, InlineU32(10), InlineU32(20), 4);
  code.push_back(EncodeVop2(0x1a, 3, InlineU32(2), 1));
  AppendBufferStoreDword(&code, 2, 3);
  AppendEnd(&code);

  TestCase test;
  test.name = "Vop3CndmaskUsesSgprMaskLaneBits";
  test.code = code;
  test.expected = {20, 10, 10, 10, 20, 10, 10, 10};
  test.opcodes = {O::V_MOV_B32,          O::V_LSHLREV_B32, O::V_ADD_NC_U32,
                  O::V_CMP_EQ_U32,       O::S_MOV_B64,     O::V_CNDMASK_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.group_id[0] = true;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.workgroup_register = 0;
  test.has_compute_info = true;
  test.dispatch_x = 2;
  return test;
}

TestCase Vop3CndmaskAllowsDataSourceModifier() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 7, 0x3f800000u);
  AppendSMovLiteral(&code, 34, 1);
  AppendSMovLiteral(&code, 35, 0);
  code.push_back(0xd5010004u);
  code.push_back(0x408a0f07u);
  AppendStoreVgpr(&code, 4, 0);
  AppendEnd(&code);

  return {"Vop3CndmaskAllowsDataSourceModifier",
          code,
          {},
          {0xbf800000u},
          {O::V_MOV_B32, O::S_MOV_B32, O::V_CNDMASK_B32, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase VectorCompareExecOps() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeVop1(0x01, 1, InlineU32(1)));
  AppendVMovLiteral(&code, 2, 0x40000000u);
  AppendVMovLiteral(&code, 3, 0x40400000u);
  code.push_back(EncodeVop1(0x01, 4, InlineU32(1)));
  AppendVMovLiteral(&code, 5, 0xffffffffu);

  u32 out = 0;
  auto append_cmpx = [&](u32 opcode, u32 src0, u32 src1) {
    code.push_back(EncodeSMovB32(126, InlineU32(1)));
    code.push_back(EncodeVopc(opcode, src0, src1));
    AppendStoreVgpr(&code, 1, out++);
  };

  append_cmpx(0x11, Vgpr(2), 3);
  append_cmpx(0x12, Vgpr(3), 3);
  append_cmpx(0x13, Vgpr(2), 3);
  append_cmpx(0x14, Vgpr(3), 2);
  append_cmpx(0x15, Vgpr(2), 3);
  append_cmpx(0x16, Vgpr(3), 3);
  append_cmpx(0x19, Vgpr(2), 3);
  append_cmpx(0x1a, Vgpr(3), 3);
  append_cmpx(0x1b, Vgpr(2), 3);
  append_cmpx(0x1c, Vgpr(3), 2);
  append_cmpx(0x1d, Vgpr(2), 3);
  append_cmpx(0x1e, Vgpr(3), 3);
  append_cmpx(0x91, Vgpr(5), 4);
  append_cmpx(0x92, Vgpr(4), 4);
  append_cmpx(0x93, Vgpr(5), 4);
  append_cmpx(0x94, Vgpr(4), 5);
  append_cmpx(0x95, Vgpr(5), 4);
  append_cmpx(0x96, Vgpr(4), 4);
  append_cmpx(0xd1, Vgpr(4), 5);
  append_cmpx(0xd2, Vgpr(4), 4);
  append_cmpx(0xd3, Vgpr(4), 5);
  append_cmpx(0xd4, Vgpr(5), 4);
  append_cmpx(0xd5, Vgpr(4), 5);
  append_cmpx(0xd6, Vgpr(4), 4);
  AppendEnd(&code);

  return {"VectorCompareExecOps",
          code,
          {},
          std::vector<u32>(out, 1),
          {O::S_MOV_B32,      O::V_MOV_B32,      O::V_CMPX_LT_F32,
           O::V_CMPX_EQ_F32,  O::V_CMPX_LE_F32,  O::V_CMPX_GT_F32,
           O::V_CMPX_LG_F32,  O::V_CMPX_GE_F32,  O::V_CMPX_NGE_F32,
           O::V_CMPX_NLG_F32, O::V_CMPX_NGT_F32, O::V_CMPX_NLE_F32,
           O::V_CMPX_NEQ_F32, O::V_CMPX_NLT_F32, O::V_CMPX_LT_I32,
           O::V_CMPX_EQ_I32,  O::V_CMPX_LE_I32,  O::V_CMPX_GT_I32,
           O::V_CMPX_NE_I32,  O::V_CMPX_GE_I32,  O::V_CMPX_LT_U32,
           O::V_CMPX_EQ_U32,  O::V_CMPX_LE_U32,  O::V_CMPX_GT_U32,
           O::V_CMPX_NE_U32,  O::V_CMPX_GE_U32,  O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase VectorVop3FloatCompareNegSourceModifier() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x3f800000u);
  AppendVMovU32(&code, 1, 0);
  AppendVop3(&code, 0x01, 20, Vgpr(0), Vgpr(1), 0, 0, 0, false, 0,
             0x1); // -1.0 < 0.0
  AppendStoreSgprPair(&code, 20, 0);
  AppendEnd(&code);

  return {"VectorVop3FloatCompareNegSourceModifier",
          code,
          {},
          {1, 0},
          {O::V_MOV_B32, O::V_CMP_LT_F32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorVop3CmpxWritesExecMask() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 0, 2);
  AppendVMovU32(&code, 1, 1);
  AppendVMovU32(&code, 2, 0);
  AppendVMovU32(&code, 30, 0);
  AppendVop3(&code, 0xd1, 5, Vgpr(0), Vgpr(1)); // v_cmpx_lt_u32, false
  AppendVMovU32(&code, 2, 7);
  AppendBufferStoreDword(&code, 2, 30);
  AppendEnd(&code);

  return {"VectorVop3CmpxWritesExecMask",
          code,
          {0},
          {0},
          {O::V_MOV_B32, O::V_CMPX_LT_U32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorVopcSdwaCmpxWritesExecMask() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 0, 2);
  AppendVMovU32(&code, 1, 1);
  AppendVMovU32(&code, 2, 0);
  AppendVMovU32(&code, 30, 0);
  code.push_back(EncodeVopc(0xd1, 249, 1)); // v_cmpx_lt_u32.sdwa, false
  code.push_back(EncodeVopcSdwa(0));
  AppendVMovU32(&code, 2, 7);
  AppendBufferStoreDword(&code, 2, 30);
  AppendEnd(&code);

  return {"VectorVopcSdwaCmpxWritesExecMask",
          code,
          {0},
          {0},
          {O::V_MOV_B32, O::V_CMPX_LT_U32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase VectorVopcCmpxGtU16CapturedSdwaExecMask() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 2, 0x00008000u);
  AppendVMovU32(&code, 3, 7);
  AppendVMovU32(&code, 31, 0);
  code.insert(code.end(), {0x7d7900f9u, 0x86060002u});
  AppendBufferStoreDword(&code, 3, 31);
  AppendVMovU32(&code, 2, 0x00010000u);
  AppendVMovU32(&code, 3, 9);
  AppendVMovU32(&code, 31, 4);
  code.insert(code.end(), {0x7d7900f9u, 0x86060002u});
  AppendBufferStoreDword(&code, 3, 31);
  AppendEnd(&code);

  TestCase test{"VectorVopcCmpxGtU16CapturedSdwaExecMask",
                code,
                {0x11111111u, 0x22222222u},
                {7, 0x22222222u},
                {O::V_MOV_B32, O::V_CMPX_GT_U16, O::BUFFER_STORE_DWORD,
                 O::S_ENDPGM}};
  test.decoded_counts = {{"V_CMPX_GT_U16", 2}};
  return test;
}

TestCase VectorVopcCmpxLtU16CapturedSdwaExecMask() {
  using O = ShaderOpcode;
  struct CompareCase {
    u32 lhs;
    u32 rhs;
    u32 incoming_exec;
    u32 expected_exec;
    u32 encoding = 0; // Captured SDWA, compact, VOP3, WORD_1 src0/src1.
  };
  const std::array<CompareCase, 12> cases{{
      {0xffff0000u, 0x12340001u, 1, 1}, // Ignore high halves.
      {0xabcd0001u, 0x12340001u, 1, 0}, // Strict comparison: equal is false.
      {0x0000ffffu, 0x12340001u, 1, 0}, // Unsigned, not signed -1.
      {0x00007fffu, 0x12348000u, 1, 1},
      {0x00008000u, 0x12347fffu, 1, 0},
      {0x12340000u, 0x56780000u, 1, 0},
      {0x0000fffeu, 0x1234ffffu, 1, 1},
      {0x00000000u, 0x12340001u, 0, 0}, // CMPX cannot reactivate an inactive lane.
      {0x00008000u, 0x0000ffffu, 1, 1, 1},
      {0x0000ffffu, 0x00008000u, 1, 0, 2},
      {0x0001ffffu, 0x12340002u, 1, 1, 3},
      {0x00000001u, 0x00020000u, 1, 1, 4},
  }};
  constexpr u32 vcc_hi = 0x89abcdefu;
  TestCase test;
  test.name = "VectorVopcCmpxLtU16CapturedSdwaExecMask";
  for (const auto &entry : cases) {
    test.initial.push_back(entry.lhs);
  }
  test.expected = test.initial;
  auto &code = test.code;
  for (u32 i = 0; i < cases.size(); ++i) {
    const auto &entry = cases[i];
    AppendVMovU32(&code, 30, i * 4u);
    AppendBufferLoadDword(&code, 0, 30); // Runtime input prevents constant folding.
    AppendVMovU32(&code, 1, entry.rhs);
    AppendSMovLiteral(&code, 106, entry.rhs);
    AppendSMovLiteral(&code, 107, vcc_hi);
    code.push_back(EncodeSMovB32(126, InlineU32(entry.incoming_exec)));
    switch (entry.encoding) {
    case 1: code.push_back(0x7d720300u); break; // compact v0, v1
    case 2: code.insert(code.end(), {0xd4b9007eu, 0x00020300u}); break;
    case 3: code.insert(code.end(), {0x7d72d4f9u, 0x86050000u}); break;
    case 4: code.insert(code.end(), {0x7d72d4f9u, 0x85060000u}); break;
    default: code.insert(code.end(), {0x7d72d4f9u, 0x86060000u}); break;
    }
    code.push_back(EncodeSMovB32(20, 126)); // Snapshot EXEC before restoring it.
    code.push_back(EncodeSMovB32(21, 127));
    code.push_back(EncodeSMovB32(126, InlineU32(1)));
    const u32 out = static_cast<u32>(cases.size()) + i * 4u;
    AppendStoreSgprPair(&code, 20, out);
    AppendStoreSgprPair(&code, 106, out + 2u); // CMPX must not overwrite either VCC half.
    test.expected.insert(test.expected.end(),
                         {entry.expected_exec, 0u, entry.rhs, vcc_hi});
  }
  AppendEnd(&code);
  test.opcodes = {O::V_MOV_B32, O::S_MOV_B32, O::BUFFER_LOAD_DWORD,
                  O::V_CMPX_LT_U16, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"V_CMPX_LT_U16", cases.size()}};
  test.required_spirv = {"OpULessThan"};
  return test;
}

TestCase VectorVopcCmpNgtF16CapturedSdwaAndEdges() {
  using O = ShaderOpcode;
  enum Encoding { Captured, Compact, Vop3NegAbs, HighWord, ScalarDst, SdwaNegAbs };
  struct CompareCase {
    u32 lhs;
    u32 rhs;
    u32 expected;
    Encoding encoding = Captured;
    u32 exec = 1;
  };
  const std::array<CompareCase, 17> cases{{
      {0x7e003c00u, 0, 0}, // +1; ignore NaN in the upper half.
      {0x3c00bc00u, 0, 1}, // -1
      {0x3c000000u, 0, 1}, // +0
      {0x3c008000u, 0, 1}, // -0
      {0x3c007e00u, 0, 1}, // Quiet NaN: NGT differs from ordered LE.
      {0x3c007c01u, 0, 1}, // Signaling NaN
      {0x00007c00u, 0, 0}, // +infinity
      {0x0000fc00u, 0, 1}, // -infinity
      {0x0000bc00u, 0, 0, Captured, 0}, // Inactive lane contributes no VCC bit.
      {0x00003c00u, 0x00007e00u, 1, Compact}, // NaN in src1.
      {0x00004000u, 0x00003c00u, 0, Compact}, // +2 > +1
      {0x0000bc00u, 0, 1, Vop3NegAbs}, // -abs(-1)
      {0x00003c00u, 0, 1, Vop3NegAbs}, // -abs(+1)
      {0xbc004000u, 0x3c00c000u, 1, HighWord}, // Select both upper halves.
      {0x00004000u, 0x00003c00u, 0, ScalarDst},
      {0x00003c00u, 0x00004000u, 1, ScalarDst},
      {0x0000bc00u, 0, 1, SdwaNegAbs},
  }};
  constexpr u32 vcc_sentinel = 0x89abcdefu;
  TestCase test;
  test.name = "VectorVopcCmpNgtF16CapturedSdwaAndEdges";
  for (const auto &entry : cases) {
    test.initial.insert(test.initial.end(), {entry.lhs, entry.rhs});
  }
  test.expected = test.initial;
  auto &code = test.code;
  for (u32 i = 0; i < cases.size(); ++i) {
    const auto &entry = cases[i];
    AppendVMovU32(&code, 30, i * 8u);
    AppendBufferLoadDword(&code, 21, 30); // Runtime inputs prevent constant folding.
    AppendVMovU32(&code, 30, i * 8u + 4u);
    AppendBufferLoadDword(&code, 1, 30);
    AppendSMovLiteral(&code, 106, vcc_sentinel);
    AppendSMovLiteral(&code, 107, vcc_sentinel);
    code.push_back(EncodeSMovB32(126, InlineU32(entry.exec)));
    switch (entry.encoding) {
    case Captured: code.insert(code.end(), {0x7dd700f9u, 0x86060015u}); break;
    case Compact: code.push_back(EncodeVopc(0xeb, Vgpr(21), 1)); break;
    case Vop3NegAbs:
      AppendVop3(&code, 0xeb, 106, Vgpr(21), Vgpr(1), 0, 1, 0, false, 0, 1);
      break;
    case HighWord:
      code.push_back(EncodeVopc(0xeb, 249, 1));
      code.push_back(EncodeVopcSdwa(21, 0, 0, 5, 5));
      break;
    case ScalarDst:
      code.push_back(EncodeVopc(0xeb, 249, 1));
      code.push_back(EncodeVopcSdwa(21, 22, 1));
      break;
    case SdwaNegAbs:
      code.push_back(EncodeVopc(0xeb, 249, 1));
      code.push_back(EncodeVopcSdwa(21, 0, 0, 6, 6, 0, 0, 1, 1));
      break;
    }
    code.push_back(EncodeSMovB32(20, entry.encoding == ScalarDst ? 22 : 106));
    code.push_back(EncodeSMovB32(21, 126)); // CMP must preserve EXEC even if false.
    code.push_back(EncodeSMovB32(126, InlineU32(1)));
    const u32 out = static_cast<u32>(test.initial.size()) + i * 4u;
    AppendStoreSgprPair(&code, 20, out);
    AppendStoreSgprPair(&code, 106, out + 2u);
    test.expected.insert(test.expected.end(),
                         {entry.expected, entry.exec,
                          entry.encoding == ScalarDst ? vcc_sentinel : entry.expected,
                          vcc_sentinel});
  }
  AppendEnd(&code);
  test.opcodes = {O::V_MOV_B32, O::S_MOV_B32, O::BUFFER_LOAD_DWORD,
                  O::V_CMP_NGT_F16, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"V_CMP_NGT_F16", cases.size()}};
  test.required_spirv = {"OpFUnordLessThanEqual"};
  test.compute_info.wave_size = 32;
  test.has_compute_info = true;
  return test;
}

TestCase VectorVopcCmpNltF16CapturedSdwaAndEdges() {
  using O = ShaderOpcode;
  enum Encoding { Captured, Compact, Vop3NegAbs, SdwaNegAbs };
  struct CompareCase {
    u32 packed; // Captured instruction compares low half against high half.
    u32 expected;
    Encoding encoding = Captured;
    u32 exec = 1;
  };
  const std::array<CompareCase, 16> cases{{
      {0x40003c00u, 0}, // +1 < +2
      {0x3c004000u, 1}, // +2 > +1
      {0x3c003c00u, 1}, // Equal
      {0x80000000u, 1}, // +0 versus -0
      {0x00008000u, 1}, // -0 versus +0
      {0x3c007e00u, 1}, // Quiet NaN in src0: unordered GE, not ordered GE.
      {0x7e003c00u, 1}, // Quiet NaN in src1
      {0x3c007c01u, 1}, // Signaling NaN in src0
      {0x7c013c00u, 1}, // Signaling NaN in src1
      {0xfc007c00u, 1}, // +infinity versus -infinity
      {0x7c00fc00u, 0}, // -infinity versus +infinity
      {0x00003c00u, 0, Captured, 0}, // Inactive lane contributes no mask bit.
      {0x40003c00u, 0, Compact},
      {0x7e003c00u, 1, Compact},
      {0x0000bc00u, 0, Vop3NegAbs}, // -abs(-1) < 0
      {0x0000bc00u, 0, SdwaNegAbs},
  }};
  constexpr u32 sentinel = 0x89abcdefu;
  TestCase test;
  test.name = "VectorVopcCmpNltF16CapturedSdwaAndEdges";
  for (const auto &entry : cases) {
    test.initial.push_back(entry.packed);
  }
  test.expected = test.initial;
  auto &code = test.code;
  code.push_back(EncodeSMovB32(22, 2)); // Preserve the input buffer descriptor.
  code.push_back(EncodeSMovB32(23, 3));
  for (u32 i = 0; i < cases.size(); ++i) {
    const auto &entry = cases[i];
    AppendVMovU32(&code, 30, i * 4u);
    AppendBufferLoadDword(&code, 3, 30); // Runtime input prevents constant folding.
    AppendVMovU32(&code, 1, entry.packed >> 16u);
    for (u32 reg : {3u, 106u, 107u}) {
      AppendSMovLiteral(&code, reg, sentinel);
    }
    code.push_back(EncodeSMovB32(126, InlineU32(entry.exec)));
    switch (entry.encoding) {
    case Captured: code.insert(code.end(), {0x7ddc06f9u, 0x05068203u}); break;
    case Compact: code.push_back(EncodeVopc(0xee, Vgpr(3), 1)); break;
    case Vop3NegAbs:
      AppendVop3(&code, 0xee, 2, Vgpr(3), Vgpr(1), 0, 1, 0, false, 0, 1);
      break;
    case SdwaNegAbs:
      code.insert(code.end(), {0x7ddc06f9u, 0x05368203u});
      break;
    }
    code.push_back(EncodeSMovB32(20, entry.encoding == Compact ? 106 : 2));
    code.push_back(EncodeSMovB32(21, 3)); // Wave32 must preserve adjacent SGPR.
    code.push_back(EncodeSMovB32(24, 126));
    code.push_back(EncodeSMovB32(25, 127));
    code.push_back(EncodeSMovB32(126, InlineU32(1)));
    code.push_back(EncodeSMovB32(2, 22));
    code.push_back(EncodeSMovB32(3, 23));
    const u32 out = static_cast<u32>(cases.size()) + i * 6u;
    AppendStoreSgprPair(&code, 20, out);
    AppendStoreSgprPair(&code, 24, out + 2u);
    AppendStoreSgprPair(&code, 106, out + 4u);
    test.expected.insert(test.expected.end(),
                         {entry.expected, sentinel, entry.exec, 0u,
                          entry.encoding == Compact ? entry.expected : sentinel,
                          sentinel});
  }
  AppendEnd(&code);
  test.opcodes = {O::V_MOV_B32, O::S_MOV_B32, O::BUFFER_LOAD_DWORD,
                  O::V_CMP_NLT_F16, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.decoded_counts = {{"V_CMP_NLT_F16", cases.size()}};
  test.required_spirv = {"OpFUnordGreaterThanEqual"};
  test.compute_info.wave_size = 32;
  test.has_compute_info = true;
  return test;
}

TestCase VectorVopcCmpxNgtF16CapturedSdwaExecMask() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 31, 0x7e003c00u);
  AppendVMovU32(&code, 3, 7);
  AppendVMovU32(&code, 30, 0);
  code.insert(code.end(), {0x7df700f9u, 0x8605001fu});
  AppendBufferStoreDword(&code, 3, 30);
  AppendVMovLiteral(&code, 31, 0x3c007e00u);
  AppendVMovU32(&code, 3, 9);
  AppendVMovU32(&code, 30, 4);
  code.insert(code.end(), {0x7df700f9u, 0x8605001fu});
  AppendBufferStoreDword(&code, 3, 30);
  AppendEnd(&code);

  TestCase test{"VectorVopcCmpxNgtF16CapturedSdwaExecMask",
                code,
                {0x11111111u, 0x22222222u},
                {7, 0x22222222u},
                {O::V_MOV_B32, O::V_CMPX_NGT_F16, O::BUFFER_STORE_DWORD,
                 O::S_ENDPGM}};
  test.decoded_counts = {{"V_CMPX_NGT_F16", 2}};
  return test;
}

TestCase VectorCompareInvertedMaskSelect() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x12345678u);
  code.push_back(EncodeVopc(0xc7, Vgpr(0), 0));      // v_cmp_t_u32 v0, v0
  code.push_back(EncodeSop1(0x08, 106, 106));        // s_not_b64 vcc, vcc
  code.push_back(EncodeVop2(0x01, 1, Vgpr(0), 128)); // v_cndmask_b32 v1, v0, 0
  AppendBufferStoreDword(&code, 1, 30);
  AppendEnd(&code);

  return {"VectorCompareInvertedMaskSelect",
          code,
          {},
          {0x12345678u},
          {O::V_MOV_B32, O::V_CMP_T_U32, O::S_NOT_B64, O::V_CNDMASK_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase BranchSelect() {
  using O = ShaderOpcode;

  std::vector<u32> code = {
      EncodeSMovB32(0, InlineU32(0)),
      EncodeSopc(0x06, 0, InlineU32(0)),
      EncodeSopp(0x05, 2),
      EncodeSMovB32(1, InlineU32(1)),
      EncodeSopp(0x02, 1),
      EncodeSMovB32(1, InlineU32(7)),
      EncodeSop2(0x0a, 2, 1, InlineU32(2)),
      EncodeVop1(0x01, 0, 2),
  };
  AppendBufferStoreDword(&code, 0, 30);
  AppendEnd(&code);
  return {"BranchSelect",
          code,
          {},
          {7},
          {O::S_MOV_B32, O::S_CMP_EQ_U32, O::S_CBRANCH_SCC1, O::S_BRANCH,
           O::S_CSELECT_B32, O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase SimpleLoop() {
  using O = ShaderOpcode;

  std::vector<u32> code = {
      EncodeSMovB32(0, InlineU32(0)),
      EncodeSopc(0x0a, 0, InlineU32(4)),
      EncodeSopp(0x04, 2),
      EncodeSop2(0x00, 0, 0, InlineU32(1)),
      EncodeSopp(0x02, 0xfffcu),
      EncodeVop1(0x01, 0, 0),
  };
  AppendBufferStoreDword(&code, 0, 30);
  AppendEnd(&code);
  return {"SimpleLoop",
          code,
          {},
          {4},
          {O::S_MOV_B32, O::S_CMP_LT_U32, O::S_CBRANCH_SCC0, O::S_ADD_U32,
           O::S_BRANCH, O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase SharedReturnKeepsSelectedValues() {
  using O = ShaderOpcode;

  std::vector<u32> code = {
      EncodeVop1(0x01, 5, 4),
      EncodeVop2(0x1a, 5, InlineU32(6), 5),
      EncodeVop2(0x25, 5, Vgpr(0), 5),
      EncodeSMovB32(8, InlineU32(10)),
      EncodeSopc(0x06, 4, InlineU32(0)),
      0,
      EncodeSMovB32(8, InlineU32(20)),
      EncodeSopc(0x06, 4, InlineU32(1)),
      0,
      EncodeSMovB32(8, InlineU32(30)),
  };
  AppendStoreSgprAtLaneDwordOffset(&code, 8, 5, 0);
  AppendEnd(&code);
  const auto shared_return = static_cast<u32>(code.size());
  AppendStoreSgprAtLaneDwordOffset(&code, 8, 5, 0);
  AppendEnd(&code);
  code[5] = EncodeSopp(0x05, shared_return - 6u);
  code[8] = EncodeSopp(0x05, shared_return - 9u);

  TestCase test;
  test.name = "SharedReturnKeepsSelectedValues";
  test.code = code;
  for (u32 group = 0; group < 3; group++) {
    test.expected.insert(test.expected.end(), 64, (group + 1u) * 10u);
  }
  test.opcodes = {O::V_MOV_B32, O::V_LSHLREV_B32, O::V_ADD_NC_U32,
                  O::S_MOV_B32, O::S_CMP_EQ_U32, O::S_CBRANCH_SCC1,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.required_spirv = {"OpSelectionMerge"};
  test.forbidden_spirv = {"OpSwitch"};
  test.compute_info.threads_num[0] = 64;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.group_id[0] = true;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.workgroup_register = 4;
  test.has_compute_info = true;
  test.dispatch_x = 3;
  return test;
}

TestCase BranchVccnzUsesWaveMask() {
  using O = ShaderOpcode;

  std::vector<u32> code = {
      EncodeVop1(0x01, 1, 0),
      EncodeVop2(0x1a, 1, InlineU32(2), 1),
      EncodeVop2(0x25, 1, Vgpr(0), 1),
      EncodeVop2(0x1a, 3, InlineU32(2), 1),
      EncodeVopc(0xc2, InlineU32(0), 0),
      EncodeSopp(0x07, 2),
      EncodeVop1(0x01, 2, InlineU32(11)),
      EncodeSopp(0x02, 1),
  };
  AppendVMovU32(&code, 2, 42);
  AppendBufferStoreDword(&code, 2, 3);
  AppendEnd(&code);

  TestCase test;
  test.name = "BranchVccnzUsesWaveMask";
  test.code = code;
  test.expected = std::vector<u32>(8, 42);
  test.opcodes = {O::V_MOV_B32,          O::V_LSHLREV_B32,   O::V_ADD_NC_U32,
                  O::V_CMP_EQ_U32,       O::S_CBRANCH_VCCNZ, O::S_BRANCH,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.group_id[0] = true;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.workgroup_register = 0;
  test.has_compute_info = true;
  test.dispatch_x = 2;
  return test;
}

TestCase ScalarMemoryLoadVariants() {
  using O = ShaderOpcode;

  struct Load {
    u32 opcode;
    u32 dst;
    u32 byte_offset;
    u32 dwords;
  };

  const Load s_loads[] = {
      {0x00, 20, 0, 1},  {0x01, 22, 4, 2},   {0x02, 24, 12, 4},
      {0x03, 28, 28, 8}, {0x04, 36, 60, 16},
  };
  const Load s_buffer_loads[] = {
      {0x08, 52, 0, 1},  {0x09, 54, 4, 2},   {0x0a, 56, 12, 4},
      {0x0b, 60, 28, 8}, {0x0c, 68, 60, 16},
  };

  std::vector<u32> code;
  code.push_back(EncodeSMovB32(0, InlineU32(0)));
  for (const auto &load : s_loads) {
    AppendSmemLoadOpcode(&code, load.opcode, load.dst, load.byte_offset);
  }
  for (const auto &load : s_buffer_loads) {
    AppendSmemLoadOpcode(&code, load.opcode, load.dst, load.byte_offset);
  }

  u32 out = 0;
  for (const auto &load : s_loads) {
    for (u32 i = 0; i < load.dwords; i++) {
      AppendStoreSgpr(&code, load.dst + i, out++);
    }
  }
  for (const auto &load : s_buffer_loads) {
    for (u32 i = 0; i < load.dwords; i++) {
      AppendStoreSgpr(&code, load.dst + i, out++);
    }
  }
  AppendEnd(&code);

  std::vector<u32> initial;
  for (u32 i = 0; i < 31u; i++) {
    initial.push_back(0x10000000u + i);
  }
  std::vector<u32> expected = initial;
  expected.insert(expected.end(), initial.begin(), initial.end());

  return {"ScalarMemoryLoadVariants",
          code,
          initial,
          expected,
          {O::S_MOV_B32, O::S_LOAD_DWORD, O::S_LOAD_DWORDX2, O::S_LOAD_DWORDX4,
           O::S_LOAD_DWORDX8, O::S_LOAD_DWORDX16, O::S_BUFFER_LOAD_DWORD,
           O::S_BUFFER_LOAD_DWORDX2, O::S_BUFFER_LOAD_DWORDX4,
           O::S_BUFFER_LOAD_DWORDX8, O::S_BUFFER_LOAD_DWORDX16, O::V_MOV_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase ScalarLoadSignedImmediateOffsetAddsSoffset() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeSMovB32(0, InlineU32(8)));
  code.push_back(EncodeSMovB32(2, InlineU32(0)));
  code.push_back(EncodeSMovB32(3, InlineU32(0)));
  code.push_back(EncodeSmem0(0x00, 1, 1));
  code.push_back(EncodeSmem1(0x1ffffcu, 0));
  AppendStoreSgpr(&code, 1, 0);
  AppendEnd(&code);

  return {"ScalarLoadSignedImmediateOffsetAddsSoffset",
          code,
          {0x11111111u, 0x22222222u},
          {0x22222222u, 0x22222222u},
          {O::S_MOV_B32, O::S_LOAD_DWORD, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase BufferLoadStore() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendBufferLoadDword(&code, 0, 30);
  code.push_back(EncodeVop1(0x01, 31, InlineU32(4)));
  AppendBufferStoreDword(&code, 0, 31);
  AppendEnd(&code);
  return {
      "BufferLoadStore",
      code,
      {0x11223344u, 0},
      {0x11223344u, 0x11223344u},
      {O::BUFFER_LOAD_DWORD, O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase BufferLoadDwordOffenIdxenUsesVaddrPlusOneOffset() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovU32(&code, 21, 8);
  code.push_back(EncodeMubuf0(0x0cu, 0, true, true));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  return {
      "BufferLoadDwordOffenIdxenUsesVaddrPlusOneOffset",
      code,
      {0x11111111u, 0x22222222u, 0x33333333u},
      {0x33333333u, 0x22222222u, 0x33333333u},
      {O::V_MOV_B32, O::BUFFER_LOAD_DWORD, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase BufferStoreDwordOffenIdxenUsesVaddrPlusOneOffset() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovU32(&code, 21, 12);
  AppendVMovLiteral(&code, 0, 0xabcdef01u);
  code.push_back(EncodeMubuf0(0x1cu, 0, true, true));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendEnd(&code);

  return {"BufferStoreDwordOffenIdxenUsesVaddrPlusOneOffset",
          code,
          {0x11111111u, 0x22222222u, 0x33333333u, 0x44444444u},
          {0x11111111u, 0x22222222u, 0x33333333u, 0xabcdef01u},
          {O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase BufferLoadDwordNoAddressFlagsIgnoresVaddr() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 8);
  code.push_back(EncodeMubuf0(0x0cu, 0, false, false));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendStoreVgpr(&code, 0, 3);
  AppendEnd(&code);

  return {
      "BufferLoadDwordNoAddressFlagsIgnoresVaddr",
      code,
      {0x11111111u, 0x22222222u, 0x33333333u, 0},
      {0x11111111u, 0x22222222u, 0x33333333u, 0x11111111u},
      {O::V_MOV_B32, O::BUFFER_LOAD_DWORD, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase BufferLoadDwordIdxenUsesDescriptorStride() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  code.push_back(EncodeMubuf0(0x0cu, 0, true, false));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferLoadDwordIdxenUsesDescriptorStride";
  test.code = code;
  test.initial = {0x11111111u, 0x22222222u, 0x33333333u,
                  0x44444444u, 0x55555555u, 0x66666666u,
                  0x77777777u, 0x88888888u, 0x99aabbccu};
  test.expected = {0x99aabbccu, 0x22222222u, 0x33333333u,
                   0x44444444u, 0x55555555u, 0x66666666u,
                   0x77777777u, 0x88888888u, 0x99aabbccu};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_DWORD, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(16, 3);
  test.has_user_data = true;
  return test;
}

TestCase BufferStoreDwordIdxenUsesDescriptorStride() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  AppendVMovLiteral(&code, 0, 0xabcdef01u);
  code.push_back(EncodeMubuf0(0x1cu, 0, true, false));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferStoreDwordIdxenUsesDescriptorStride";
  test.code = code;
  test.initial = {0x11111111u, 0x22222222u, 0x33333333u,
                  0x44444444u, 0x55555555u, 0x66666666u,
                  0x77777777u, 0x88888888u, 0x99aabbccu};
  test.expected = {0x11111111u, 0x22222222u, 0x33333333u,
                   0x44444444u, 0x55555555u, 0x66666666u,
                   0x77777777u, 0x88888888u, 0xabcdef01u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(16, 3);
  test.has_user_data = true;
  return test;
}

TestCase BufferStoreDwordAppliesHostOffset() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0xabcdef01u);
  code.push_back(EncodeMubuf0(0x1cu, 0, false, false));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferStoreDwordAppliesHostOffset";
  test.code = code;
  test.initial = {0x11111111u, 0x22222222u, 0x33333333u, 0};
  test.expected = {0x11111111u, 0x22222222u, 0x33333333u, 0xabcdef01u};
  test.storage_buffer_range_dwords = 1;
  test.storage_buffer_offsets = {12};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(4, 1);
  test.has_user_data = true;
  return test;
}

TestCase BufferOffsetsUsePackedLaneAndStorageFallback() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  for (u32 base : {0u, 4u}) {
    AppendSMovLiteral(&code, base, 0x1000u + base * 0x1000u);
    AppendSMovLiteral(&code, base + 1u, 4u << 16u);
    AppendSMovLiteral(&code, base + 2u, 1u);
    AppendSMovLiteral(&code, base + 3u, 1u << 24u);
  }
  AppendVMovLiteral(&code, 0, 0x12345678u);
  code.push_back(EncodeMubuf0(0x1cu, 0, false, false));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendVMovLiteral(&code, 1, 0xabcdef01u);
  code.push_back(EncodeMubuf0(0x1cu, 0, false, false));
  code.push_back(EncodeMubuf1(1, 1, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferOffsetsUsePackedLaneAndStorageFallback";
  test.code = std::move(code);
  test.initial = {0, 0, 0, 0};
  test.expected = {0x12345678u, 0, 0, 0xabcdef01u};
  test.storage_buffer_range_dwords = 1;
  test.storage_buffer_offsets = {0, 12};
  test.expand_shader_data_storage = true;
  test.opcodes = {O::S_MOV_B32, O::V_MOV_B32, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  return test;
}

TestCase BufferLoadVariants() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendBufferLoadOpcode(&code, 0x08, 0, 20);
  AppendVMovU32(&code, 20, 2);
  AppendBufferLoadOpcode(&code, 0x09, 1, 20);
  AppendVMovU32(&code, 20, 0);
  AppendBufferLoadOpcode(&code, 0x0a, 2, 20);
  AppendVMovU32(&code, 20, 2);
  AppendBufferLoadOpcode(&code, 0x0b, 3, 20);
  AppendVMovU32(&code, 20, 8);
  AppendBufferLoadOpcode(&code, 0x0d, 4, 20);
  AppendBufferLoadOpcode(&code, 0x0f, 6, 20);
  AppendBufferLoadOpcode(&code, 0x0e, 9, 20);

  for (u32 i = 0; i < 13u; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  return {"BufferLoadVariants",
          code,
          {0x80ff7f01u, 0x00008001u, 0x11223344u, 0x55667788u, 0x99aabbccu,
           0xddeeff00u},
          {0x01u, 0xffffffffu, 0x7f01u, 0xffff80ffu, 0x11223344u, 0x55667788u,
           0x11223344u, 0x55667788u, 0x99aabbccu, 0x11223344u, 0x55667788u,
           0x99aabbccu, 0xddeeff00u},
          {O::BUFFER_LOAD_UBYTE, O::BUFFER_LOAD_SBYTE, O::BUFFER_LOAD_USHORT,
           O::BUFFER_LOAD_SSHORT, O::BUFFER_LOAD_DWORDX2,
           O::BUFFER_LOAD_DWORDX3, O::BUFFER_LOAD_DWORDX4, O::V_MOV_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase BufferLoadDwordx4SnapshotsOverlappingAddress() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 21, 0);
  AppendVMovU32(&code, 22, 0);
  code.push_back(EncodeMubuf0(0x0eu, 0, true, true));
  code.push_back(EncodeMubuf1(21, 0, 21));
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, 21 + i, 4 + i);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferLoadDwordx4SnapshotsOverlappingAddress";
  test.code = std::move(code);
  test.initial = {0x11111111u, 0x22222222u, 0x33333333u, 0x44444444u,
                  0,           0,           0,           0};
  test.expected = {0x11111111u, 0x22222222u, 0x33333333u, 0x44444444u,
                   0x11111111u, 0x22222222u, 0x33333333u, 0x44444444u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_DWORDX4, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(16, 2);
  test.has_user_data = true;
  return test;
}

TestCase BufferLoadDwordx2SnapshotsOverlappingAddress() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 21, 0);
  AppendVMovU32(&code, 22, 0);
  code.push_back(EncodeMubuf0(0x0du, 0, true, true));
  code.push_back(EncodeMubuf1(21, 0, 21));
  for (u32 i = 0; i < 2; i++) {
    AppendStoreVgpr(&code, 21 + i, 2 + i);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferLoadDwordx2SnapshotsOverlappingAddress";
  test.code = std::move(code);
  test.initial = {0x11111111u, 0x22222222u, 0, 0};
  test.expected = {0x11111111u, 0x22222222u, 0x11111111u, 0x22222222u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_DWORDX2, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(8, 2);
  test.has_user_data = true;
  return test;
}

TestCase BufferLoadDwordx3SnapshotsOverlappingAddress() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 21, 0);
  AppendVMovU32(&code, 22, 0);
  code.push_back(EncodeMubuf0(0x0fu, 0, true, true));
  code.push_back(EncodeMubuf1(21, 0, 21));
  for (u32 i = 0; i < 3; i++) {
    AppendStoreVgpr(&code, 21 + i, 3 + i);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferLoadDwordx3SnapshotsOverlappingAddress";
  test.code = std::move(code);
  test.initial = {0x11111111u, 0x22222222u, 0x33333333u, 0, 0, 0};
  test.expected = {0x11111111u, 0x22222222u, 0x33333333u,
                   0x11111111u, 0x22222222u, 0x33333333u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_DWORDX3, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(12, 2);
  test.has_user_data = true;
  return test;
}

TestCase BufferLoadDwordx4ZeroesOnlyOutOfBoundsTail() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 8);
  AppendBufferLoadOpcode(&code, 0x0e, 0, 20);
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferLoadDwordx4ZeroesOnlyOutOfBoundsTail";
  test.code = std::move(code);
  test.initial = {0x11111111u, 0x22222222u, 0x33333333u, 0x44444444u};
  test.expected = {0x33333333u, 0x44444444u, 0u, 0u};
  test.storage_buffer_range_dwords = 4;
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_DWORDX4, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  return test;
}

TestCase BufferStoreDwordx4DropsOnlyOutOfBoundsTail() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0xaaaaaaaau);
  AppendVMovLiteral(&code, 1, 0xbbbbbbbbu);
  AppendVMovLiteral(&code, 2, 0xccccccccu);
  AppendVMovLiteral(&code, 3, 0xddddddddu);
  AppendVMovU32(&code, 20, 8);
  code.push_back(EncodeMubuf0(0x1eu));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferStoreDwordx4DropsOnlyOutOfBoundsTail";
  test.code = std::move(code);
  test.initial = {0x11111111u, 0x22222222u, 0x33333333u, 0x44444444u};
  test.expected = {0x11111111u, 0x22222222u, 0xaaaaaaaau, 0xbbbbbbbbu};
  test.storage_buffer_range_dwords = 4;
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_DWORDX4, O::S_ENDPGM};
  return test;
}

TestCase BufferLoadFormatXyzwRejectsPartialRecord() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 8);
  AppendBufferLoadOpcode(&code, 0x03, 0, 20);
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferLoadFormatXyzwRejectsPartialRecord";
  test.code = std::move(code);
  test.initial = {0x3f800000u, 0x40000000u, 0x40400000u, 0x40800000u};
  test.expected = {0u, 0u, 0u, 0u};
  test.storage_buffer_range_dwords = 4;
  test.user_data = MakeStructuredStorageBufferData(
      0, 4, false, BufferFormat(Prospero::BufferFormat::k32_32_32_32Float));
  test.has_user_data = true;
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_FORMAT_XYZW,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  return test;
}

TestCase BufferStoreFormatXyzwDropsPartialRecord() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0xaaaaaaaau);
  AppendVMovLiteral(&code, 1, 0xbbbbbbbbu);
  AppendVMovLiteral(&code, 2, 0xccccccccu);
  AppendVMovLiteral(&code, 3, 0xddddddddu);
  AppendVMovU32(&code, 20, 8);
  code.push_back(EncodeMubuf0(0x07u));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferStoreFormatXyzwDropsPartialRecord";
  test.code = std::move(code);
  test.initial = {0x11111111u, 0x22222222u, 0x33333333u, 0x44444444u};
  test.expected = test.initial;
  test.storage_buffer_range_dwords = 4;
  test.user_data = MakeStructuredStorageBufferData(
      0, 4, false, BufferFormat(Prospero::BufferFormat::k32_32_32_32Float));
  test.has_user_data = true;
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_FORMAT_XYZW, O::S_ENDPGM};
  return test;
}

TestCase BufferLoadFormatXChecksOnlyTransferredComponent() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 12);
  AppendBufferLoadOpcode(&code, 0x00, 0, 20);
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferLoadFormatXChecksOnlyTransferredComponent";
  test.code = std::move(code);
  test.initial = {0x11111111u, 0x22222222u, 0x33333333u, 0x44444444u};
  test.expected = {0x44444444u, 0x22222222u, 0x33333333u, 0x44444444u};
  test.storage_buffer_range_dwords = 4;
  test.user_data = MakeStructuredStorageBufferData(
      0, 4, false, BufferFormat(Prospero::BufferFormat::k32_32_32_32Float));
  test.has_user_data = true;
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_FORMAT_X, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  return test;
}

TestCase BufferStoreFormatXChecksOnlyTransferredComponent() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0xaaaaaaaau);
  AppendVMovU32(&code, 20, 12);
  code.push_back(EncodeMubuf0(0x04u));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferStoreFormatXChecksOnlyTransferredComponent";
  test.code = std::move(code);
  test.initial = {0x11111111u, 0x22222222u, 0x33333333u, 0x44444444u};
  test.expected = {0x11111111u, 0x22222222u, 0x33333333u, 0xaaaaaaaau};
  test.storage_buffer_range_dwords = 4;
  test.user_data = MakeStructuredStorageBufferData(
      0, 4, false, BufferFormat(Prospero::BufferFormat::k32_32_32_32Float));
  test.has_user_data = true;
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_FORMAT_X, O::S_ENDPGM};
  return test;
}

TestCase BufferLoadFormatXyChecksOnlyTransferredComponents() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 8);
  AppendBufferLoadOpcode(&code, 0x01, 0, 20);
  AppendStoreVgpr(&code, 0, 0);
  AppendStoreVgpr(&code, 1, 1);
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferLoadFormatXyChecksOnlyTransferredComponents";
  test.code = std::move(code);
  test.initial = {0x11111111u, 0x22222222u, 0x33333333u, 0x44444444u};
  test.expected = {0x33333333u, 0x44444444u, 0x33333333u, 0x44444444u};
  test.storage_buffer_range_dwords = 4;
  test.user_data = MakeStructuredStorageBufferData(
      0, 4, false, BufferFormat(Prospero::BufferFormat::k32_32_32_32Float));
  test.has_user_data = true;
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_FORMAT_XY, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  return test;
}

TestCase BufferStoreFormatXyChecksOnlyTransferredComponents() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0xaaaaaaaau);
  AppendVMovLiteral(&code, 1, 0xbbbbbbbbu);
  AppendVMovU32(&code, 20, 8);
  code.push_back(EncodeMubuf0(0x05u));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferStoreFormatXyChecksOnlyTransferredComponents";
  test.code = std::move(code);
  test.initial = {0x11111111u, 0x22222222u, 0x33333333u, 0x44444444u};
  test.expected = {0x11111111u, 0x22222222u, 0xaaaaaaaau, 0xbbbbbbbbu};
  test.storage_buffer_range_dwords = 4;
  test.user_data = MakeStructuredStorageBufferData(
      0, 4, false, BufferFormat(Prospero::BufferFormat::k32_32_32_32Float));
  test.has_user_data = true;
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_FORMAT_XY, O::S_ENDPGM};
  return test;
}

TestCase BufferStoreVariants() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 1);
  AppendVMovU32(&code, 0, 0xaa);
  AppendBufferStoreOpcode(&code, 0x18, 0, 20);
  AppendVMovU32(&code, 20, 2);
  AppendVMovLiteral(&code, 1, 0x0000bbccu);
  AppendBufferStoreOpcode(&code, 0x1a, 1, 20);
  AppendVMovU32(&code, 20, 4);
  AppendVMovLiteral(&code, 2, 0x11111111u);
  AppendVMovLiteral(&code, 3, 0x22222222u);
  AppendBufferStoreOpcode(&code, 0x1d, 2, 20);
  AppendVMovU32(&code, 20, 12);
  AppendVMovLiteral(&code, 4, 0x33333333u);
  AppendVMovLiteral(&code, 5, 0x44444444u);
  AppendVMovLiteral(&code, 6, 0x55555555u);
  AppendBufferStoreOpcode(&code, 0x1f, 4, 20);
  AppendVMovU32(&code, 20, 24);
  AppendVMovLiteral(&code, 7, 0x66666666u);
  AppendVMovLiteral(&code, 8, 0x77777777u);
  AppendVMovLiteral(&code, 9, 0x88888888u);
  AppendVMovLiteral(&code, 10, 0x99999999u);
  AppendBufferStoreOpcode(&code, 0x1e, 7, 20);
  AppendEnd(&code);

  return {"BufferStoreVariants",
          code,
          std::vector<u32>(10, 0),
          {0xbbccaa00u, 0x11111111u, 0x22222222u, 0x33333333u, 0x44444444u,
           0x55555555u, 0x66666666u, 0x77777777u, 0x88888888u, 0x99999999u},
          {O::V_MOV_B32, O::BUFFER_STORE_BYTE, O::BUFFER_STORE_SHORT,
           O::BUFFER_STORE_DWORDX2, O::BUFFER_STORE_DWORDX3,
           O::BUFFER_STORE_DWORDX4, O::S_ENDPGM}};
}

TestCase BufferFormatVariants() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendBufferLoadOpcode(&code, 0x00, 0, 20);
  AppendBufferLoadOpcode(&code, 0x01, 1, 20);
  AppendBufferLoadOpcode(&code, 0x02, 3, 20);
  AppendBufferLoadOpcode(&code, 0x03, 6, 20);
  for (u32 i = 0; i < 10u; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  TestCase load;
  load.name = "BufferFormatLoadVariants";
  load.code = code;
  load.initial = {0x01020304u, 0x11121314u, 0x21222324u, 0x31323334u};
  load.expected = {0x01020304u, 0x01020304u, 0x11121314u, 0x01020304u,
                   0x11121314u, 0x21222324u, 0x01020304u, 0x11121314u,
                   0x21222324u, 0x31323334u};
  load.opcodes = {O::BUFFER_LOAD_FORMAT_X,
                  O::BUFFER_LOAD_FORMAT_XY,
                  O::BUFFER_LOAD_FORMAT_XYZ,
                  O::BUFFER_LOAD_FORMAT_XYZW,
                  O::V_MOV_B32,
                  O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  return load;
}

TestCase BufferLoadFormatXyzwSnapshotsOverlappingAddress() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 21, 0);
  AppendVMovU32(&code, 22, 0);
  code.push_back(EncodeMubuf0(0x03u, 0, true, true));
  code.push_back(EncodeMubuf1(21, 0, 21));
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, 21 + i, 4 + i);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferLoadFormatXyzwSnapshotsOverlappingAddress";
  test.code = std::move(code);
  test.initial = {0x3f800000u, 0x40000000u, 0x40400000u, 0x40800000u,
                  0,           0,           0,           0};
  test.expected = {0x3f800000u, 0x40000000u, 0x40400000u, 0x40800000u,
                   0x3f800000u, 0x40000000u, 0x40400000u, 0x40800000u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_FORMAT_XYZW,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(
      16, 2, false, BufferFormat(Prospero::BufferFormat::k32_32_32_32Float));
  test.has_user_data = true;
  return test;
}

TestCase BufferLoadFormatXyzwResource32_32FloatAppliesXy01() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendBufferLoadOpcode(&code, 0x03, 0, 20);
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferLoadFormatXyzwResource32_32FloatAppliesXy01";
  test.code = std::move(code);
  test.initial = {0x3f800000u, 0x40000000u, 0, 0};
  test.expected = {0x3f800000u, 0x40000000u, 0, 0x3f800000u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_FORMAT_XYZW,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(
      16, 1, false, BufferFormat(Prospero::BufferFormat::k32_32Float));
  test.user_data[3] = (test.user_data[3] & ~0xfffu) | DstSel(4, 5, 0, 1);
  test.has_user_data = true;
  return test;
}

TestCase BufferLoadFormatXyzwResource323232FloatRepeatsSource() {
  using O = ShaderOpcode;
  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendBufferLoadOpcode(&code, 0x03, 0, 20);
  for (u32 i = 0; i < 4; ++i) AppendStoreVgpr(&code, i, i + 4);
  AppendEnd(&code);
  TestCase test;
  test.name = "BufferLoadFormatXyzwResource323232FloatRepeatsSource";
  test.code = std::move(code);
  test.initial = {0x3e800000u, 0x3f000000u, 0x3f400000u, 0xdeadbeefu, 0, 0, 0, 0};
  test.expected = {0x3e800000u, 0x3f000000u, 0x3f400000u, 0xdeadbeefu,
                   0x3e800000u, 0x3f000000u, 0x3f400000u, 0x3e800000u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_FORMAT_XYZW,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(
      0, 32, false, BufferFormat(Prospero::BufferFormat::k32_32_32Float));
  test.has_user_data = true;
  return test;
}

TestCase BufferLoadFormatXyzwResource8_8_8_8UintAppliesWzy1() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendBufferLoadOpcode(&code, 0x03, 0, 20);
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferLoadFormatXyzwResource8_8_8_8UintAppliesWzy1";
  test.code = std::move(code);
  test.initial = {0x11223344u, 0x55667788u, 0x99aabbccu, 0xddeeff00u};
  test.expected = {0x11u, 0x22u, 0x33u, 1u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_FORMAT_XYZW,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(
      16, 1, false, BufferFormat(Prospero::BufferFormat::k8_8_8_8UInt));
  test.user_data[3] = (test.user_data[3] & ~0xfffu) | DstSel(7, 6, 5, 1);
  test.has_user_data = true;
  return test;
}

TestCase BufferLoadFormatXyzwInactiveExecPreservesOverlappingAddress() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 21, 0x11111111u);
  AppendVMovLiteral(&code, 22, 0x22222222u);
  AppendVMovLiteral(&code, 23, 0x33333333u);
  AppendVMovLiteral(&code, 24, 0x44444444u);
  code.push_back(EncodeSop1(0x04, 126, InlineU32(0)));
  code.push_back(EncodeMubuf0(0x03u, 0, true, true));
  code.push_back(EncodeMubuf1(21, 0, 21));
  code.push_back(EncodeSMovB32(126, InlineU32(1)));
  code.push_back(EncodeSMovB32(127, InlineU32(0)));
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, 21 + i, 4 + i);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferLoadFormatXyzwInactiveExecPreservesOverlappingAddress";
  test.code = std::move(code);
  test.initial = {0xaaaaaaaa, 0xbbbbbbbb, 0xcccccccc, 0xdddddddd, 0, 0, 0, 0};
  test.expected = {0xaaaaaaaau, 0xbbbbbbbbu, 0xccccccccu, 0xddddddddu,
                   0x11111111u, 0x22222222u, 0x33333333u, 0x44444444u};
  test.opcodes = {
      O::V_MOV_B32, O::S_MOV_B64,          O::BUFFER_LOAD_FORMAT_XYZW,
      O::S_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(
      16, 2, false, BufferFormat(Prospero::BufferFormat::k32_32_32_32Float));
  test.has_user_data = true;
  return test;
}

TestCase BufferFormatStoreVariants() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovLiteral(&code, 0, 0x01020304u);
  AppendBufferStoreOpcode(&code, 0x04, 0, 20);
  AppendVMovU32(&code, 20, 4);
  AppendVMovLiteral(&code, 1, 0x11121314u);
  AppendVMovLiteral(&code, 2, 0x21222324u);
  AppendBufferStoreOpcode(&code, 0x05, 1, 20);
  AppendVMovU32(&code, 20, 12);
  AppendVMovLiteral(&code, 3, 0x31323334u);
  AppendVMovLiteral(&code, 4, 0x41424344u);
  AppendVMovLiteral(&code, 5, 0x51525354u);
  AppendBufferStoreOpcode(&code, 0x06, 3, 20);
  AppendVMovU32(&code, 20, 24);
  AppendVMovLiteral(&code, 6, 0x61626364u);
  AppendVMovLiteral(&code, 7, 0x71727374u);
  AppendVMovLiteral(&code, 8, 0x81828384u);
  AppendVMovLiteral(&code, 9, 0x91929394u);
  AppendBufferStoreOpcode(&code, 0x07, 6, 20);
  AppendEnd(&code);

  return {"BufferFormatStoreVariants",
          code,
          std::vector<u32>(10, 0),
          {0x01020304u, 0x11121314u, 0x21222324u, 0x31323334u, 0x41424344u,
           0x51525354u, 0x61626364u, 0x71727374u, 0x81828384u, 0x91929394u},
          {O::V_MOV_B32, O::BUFFER_STORE_FORMAT_X, O::BUFFER_STORE_FORMAT_XY,
           O::BUFFER_STORE_FORMAT_XYZ, O::BUFFER_STORE_FORMAT_XYZW,
           O::S_ENDPGM}};
}

TestCase BufferLoadFormatXResource8UintZeroExtendsByte() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  code.push_back(EncodeMubuf0(0x00u));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendStoreVgpr(&code, 0, 1);
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferLoadFormatXResource8UintZeroExtendsByte";
  test.code = code;
  test.initial = {0x11223344u, 0};
  test.expected = {0x11223344u, 0x00000044u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_FORMAT_X, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(0, 8, false, 5);
  test.has_user_data = true;
  return test;
}

TestCase BufferStoreFormatXResource16UintWritesHalfword() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovLiteral(&code, 0, 0x0000aaaau);
  code.push_back(EncodeMubuf0(0x04u));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferStoreFormatXResource16UintWritesHalfword";
  test.code = code;
  test.initial = {0x11223344u};
  test.expected = {0x1122aaaau};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_FORMAT_X, O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(0, 4, false, 11);
  test.has_user_data = true;
  return test;
}

TestCase BufferStoreFormatXResource16UintPreservesAdjacentLanes() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeVop2(0x25, 1, InlineU32(1), 0));
  code.push_back(EncodeMubuf0(0x04u, 0, true, false));
  code.push_back(EncodeMubuf1(1, 0, 0));
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferStoreFormatXResource16UintPreservesAdjacentLanes";
  test.code = code;
  test.initial = std::vector<u32>(32, 0);
  for (u32 index = 0; index < 32; index++) {
    test.expected.push_back(((index * 2 + 2) << 16) | (index * 2 + 1));
  }
  test.opcodes = {O::V_ADD_NC_U32, O::BUFFER_STORE_FORMAT_X, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 64;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.wave_size = 64;
  test.has_compute_info = true;
  test.user_data = MakeStructuredStorageBufferData(2, 64, false, 11);
  test.has_user_data = true;
  test.required_spirv = {"OpAtomicLoad", "OpAtomicCompareExchange"};
  return test;
}

TestCase BufferStoreFormatXyzwSnorm16CapturedSkinningVectors() {
  using O = ShaderOpcode;

  // Normal and tangent from the character skinning dispatch (eadfd178c07feebd).
  constexpr std::array<u32, 8> values = {
      0x3d98f7c5u, 0xbedae712u, 0xbf66a19eu, 0x3f800000u,
      0x3f7e6baeu, 0xbd339a7du, 0x3dd0a2e2u, 0xbf800000u};
  std::vector<u32> code;
  for (u32 record = 0; record < 2; record++) {
    for (u32 component = 0; component < 4; component++) {
      AppendVMovLiteral(&code, component, values[record * 4 + component]);
    }
    AppendVMovU32(&code, 20, record);
    code.push_back(EncodeMubuf0(0x07u, 0, true, false));
    code.push_back(EncodeMubuf1(0, 0, 20));
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferStoreFormatXyzwSnorm16CapturedSkinningVectors";
  test.code = std::move(code);
  test.initial = std::vector<u32>(4, 0xdeadbeefu);
  test.expected = {0xc947098fu, 0x7fff8cb0u, 0xfa637f35u, 0x80010d0au};
  test.user_data = MakeStructuredStorageBufferData(
      8, 2, false, BufferFormat(Prospero::BufferFormat::k16_16_16_16SNorm));
  test.has_user_data = true;
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_FORMAT_XYZW, O::S_ENDPGM};
  return test;
}

TestCase BufferStoreFormatXSnorm16ClampsRoundsAndPreservesHalfwords() {
  using O = ShaderOpcode;

  constexpr std::array<float, 9> values = {
      -2.0f, -1.0f, -0.75f, -0.25f, 0.0f, 0.25f, 0.75f, 1.0f, 2.0f};
  std::vector<u32> code;
  for (u32 i = 0; i < values.size(); i++) {
    AppendVMovLiteral(&code, 0, std::bit_cast<u32>(values[i]));
    AppendVMovU32(&code, 20, i * 2 + 2);
    code.push_back(EncodeMubuf0(0x04u));
    code.push_back(EncodeMubuf1(0, 0, 20));
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferStoreFormatXSnorm16ClampsRoundsAndPreservesHalfwords";
  test.code = std::move(code);
  test.initial = std::vector<u32>(6, 0xdeadbeefu);
  test.expected = {0x8001beefu, 0xa0018001u, 0x0000e000u,
                   0x5fff2000u, 0x7fff7fffu, 0xdeadbeefu};
  test.user_data = MakeStructuredStorageBufferData(
      0, 24, false, BufferFormat(Prospero::BufferFormat::k16SNorm));
  test.has_user_data = true;
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_FORMAT_X, O::S_ENDPGM};
  return test;
}

TestCase BufferLoadFormatXyResource88UintExtractsBytes() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  code.push_back(EncodeMubuf0(0x01u));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendStoreVgpr(&code, 0, 2);
  AppendStoreVgpr(&code, 1, 3);
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferLoadFormatXyResource8_8UintExtractsBytes";
  test.code = code;
  test.initial = {0x0000807fu, 0x55667788u, 0, 0};
  test.expected = {0x0000807fu, 0x55667788u, 0x0000007fu, 0x00000080u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_FORMAT_XY, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(0, 8, false, 18);
  test.has_user_data = true;
  return test;
}

TestCase BufferLoadFormatXyResource8888UnormConvertsFirstTwoComponents() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  code.push_back(EncodeMubuf0(0x01u));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendStoreVgpr(&code, 1, 1);
  AppendEnd(&code);

  TestCase test;
  test.name =
      "BufferLoadFormatXyResource8_8_8_8UnormConvertsFirstTwoComponents";
  test.code = code;
  test.initial = {0x44332211u, 0xdeadbeefu};
  test.expected = {0x3d888889u, 0x3e088889u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_LOAD_FORMAT_XY, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(0, 8, false, 56);
  test.has_user_data = true;
  return test;
}

TestCase BufferStoreFormatXyResource88UintWritesBytes() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovLiteral(&code, 0, 0x000000aau);
  AppendVMovLiteral(&code, 1, 0x000000bbu);
  code.push_back(EncodeMubuf0(0x05u));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferStoreFormatXyResource8_8UintWritesBytes";
  test.code = code;
  test.initial = {0x11223344u, 0x55667788u};
  test.expected = {0x1122bbaau, 0x55667788u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_FORMAT_XY, O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(0, 8, false, 18);
  test.has_user_data = true;
  return test;
}

TestCase BufferStoreFormatXyResource32UintWritesOneDword() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovLiteral(&code, 0, 0xabcdef01u);
  AppendVMovLiteral(&code, 1, 0x12345678u);
  code.push_back(EncodeMubuf0(0x05u));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferStoreFormatXyResource32UintWritesOneDword";
  test.code = code;
  test.initial = {0x11111111u, 0x22222222u};
  test.expected = {0xabcdef01u, 0x22222222u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_FORMAT_XY, O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(0, 8, false, 20);
  test.has_user_data = true;
  return test;
}

TestCase BufferStoreFormatXyzResource3232UintWritesTwoDwords() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovLiteral(&code, 0, 0xabcdef01u);
  AppendVMovLiteral(&code, 1, 0x12345678u);
  AppendVMovLiteral(&code, 2, 0x0badc0deu);
  code.push_back(EncodeMubuf0(0x06u));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferStoreFormatXyzResource32_32UintWritesTwoDwords";
  test.code = code;
  test.initial = {0x11111111u, 0x22222222u, 0x33333333u};
  test.expected = {0xabcdef01u, 0x12345678u, 0x33333333u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_FORMAT_XYZ, O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(0, 8, false, 62);
  test.has_user_data = true;
  return test;
}

TestCase BufferStoreFormatXyzwResource323232UintWritesThreeDwords() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovLiteral(&code, 0, 0xabcdef01u);
  AppendVMovLiteral(&code, 1, 0x12345678u);
  AppendVMovLiteral(&code, 2, 0x0badc0deu);
  AppendVMovLiteral(&code, 3, 0xfeedfaceu);
  code.push_back(EncodeMubuf0(0x07u));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferStoreFormatXyzwResource32_32_32UintWritesThreeDwords";
  test.code = code;
  test.initial = {0x11111111u, 0x22222222u, 0x33333333u, 0x44444444u};
  test.expected = {0xabcdef01u, 0x12345678u, 0x0badc0deu, 0x44444444u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_FORMAT_XYZW, O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(0, 8, false, 72);
  test.has_user_data = true;
  return test;
}

TestCase BufferStoreFormatXyzResource8UintWritesOneByte() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovLiteral(&code, 0, 0x000000aau);
  AppendVMovLiteral(&code, 1, 0x000000bbu);
  AppendVMovLiteral(&code, 2, 0x000000ccu);
  code.push_back(EncodeMubuf0(0x06u));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferStoreFormatXyzResource8UintWritesOneByte";
  test.code = code;
  test.initial = {0x11223344u, 0x55667788u, 0x99aabbccu};
  test.expected = {0x112233aau, 0x55667788u, 0x99aabbccu};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_FORMAT_XYZ, O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(0, 8, false, 5);
  test.has_user_data = true;
  return test;
}

TestCase BufferStoreFormatXAddTidUsesLaneIndex() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x12345678u);
  code.push_back(EncodeMubuf0(0x04u, 0, false, false));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferStoreFormatXAddTidUsesLaneIndex";
  test.code = code;
  test.initial = std::vector<u32>(64, 0);
  test.expected = std::vector<u32>(64, 0);
  std::fill_n(test.expected.begin(), 32, 0x12345678u);
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_FORMAT_X, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 64;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 0;
  test.compute_info.wave_size = 32;
  test.has_compute_info = true;
  test.user_data = MakeStructuredStorageBufferData(4, 64, true);
  test.has_user_data = true;
  test.required_spirv = {"BuiltIn SubgroupLocalInvocationId"};
  test.forbidden_spirv = {"BuiltIn LocalInvocationId",
                          "OpGroupNonUniformBallot"};
  return test;
}

TestCase BufferStoreFormatXDropsOutOfRangeRecord() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 1);
  AppendVMovLiteral(&code, 0, 0xabcdef01u);
  code.push_back(EncodeMubuf0(0x04u, 0, true, false));
  code.push_back(EncodeMubuf1(0, 0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferStoreFormatXDropsOutOfRangeRecord";
  test.code = code;
  test.initial = {0x11111111u, 0x22222222u};
  test.expected = {0x11111111u, 0x22222222u};
  test.storage_buffer_range_dwords = 1;
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_FORMAT_X, O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(4, 1, false, 20);
  test.has_user_data = true;
  return test;
}

TestCase TBufferLoadVariants() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendTBufferLoadOpcode(&code, 0x00, 0, 20);
  AppendTBufferLoadOpcode(&code, 0x01, 1, 20);
  AppendTBufferLoadOpcode(&code, 0x02, 3, 20);
  AppendTBufferLoadOpcode(&code, 0x03, 6, 20);
  for (u32 i = 0; i < 10u; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  return {"TBufferLoadVariants",
          code,
          {0x01020304u, 0x11121314u, 0x21222324u, 0x31323334u},
          {0x01020304u, 0x01020304u, 0x11121314u, 0x01020304u, 0x11121314u,
           0x21222324u, 0x01020304u, 0x11121314u, 0x21222324u, 0x31323334u},
          {O::TBUFFER_LOAD_FORMAT_X, O::TBUFFER_LOAD_FORMAT_XY,
           O::TBUFFER_LOAD_FORMAT_XYZ, O::TBUFFER_LOAD_FORMAT_XYZW,
           O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase TBufferLoadFormatXyzwSnapshotsOverlappingAddress() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 21, 0);
  AppendVMovU32(&code, 22, 0);
  constexpr auto format =
      BufferFormat(Prospero::BufferFormat::k32_32_32_32Float);
  code.push_back(
      EncodeMtbuf0(0x03u, format & 0xfu, (format >> 4u) & 0x7u, 0, true, true));
  code.push_back(EncodeMtbuf1(0x03u, 21, 0, 21));
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, 21 + i, 4 + i);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "TBufferLoadFormatXyzwSnapshotsOverlappingAddress";
  test.code = std::move(code);
  test.initial = {0x3f800000u, 0x40000000u, 0x40400000u, 0x40800000u,
                  0,           0,           0,           0};
  test.expected = {0x3f800000u, 0x40000000u, 0x40400000u, 0x40800000u,
                   0x3f800000u, 0x40000000u, 0x40400000u, 0x40800000u};
  test.opcodes = {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_XYZW,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(16, 2);
  test.has_user_data = true;
  return test;
}

TestCase TBufferLoadFormatXyzwPackedSnapshotsOverlappingAddress() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 21, 0);
  AppendVMovU32(&code, 22, 0);
  constexpr auto format = BufferFormat(Prospero::BufferFormat::k8_8_8_8UInt);
  code.push_back(
      EncodeMtbuf0(0x03u, format & 0xfu, (format >> 4u) & 0x7u, 0, true, true));
  code.push_back(EncodeMtbuf1(0x03u, 21, 0, 21));
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, 21 + i, 4 + i);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "TBufferLoadFormatXyzwPackedSnapshotsOverlappingAddress";
  test.code = std::move(code);
  test.initial = {0x44332211u, 0, 0, 0, 0, 0, 0, 0};
  test.expected = {0x44332211u, 0, 0, 0, 0x11u, 0x22u, 0x33u, 0x44u};
  test.opcodes = {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_XYZW,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(4, 8);
  test.has_user_data = true;
  return test;
}

TestCase TBufferStoreFormatX8UintWritesOneByte() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovU32(&code, 0, 0xaa);
  code.push_back(EncodeMtbuf0(0x04, 5, 0));
  code.push_back(EncodeMtbuf1(0x04, 0, 0, 20));
  AppendEnd(&code);

  return {"TBufferStoreFormatX8UintWritesOneByte",
          code,
          {0x11223344u},
          {0x112233aau},
          {O::V_MOV_B32, O::TBUFFER_STORE_FORMAT_X, O::S_ENDPGM}};
}

TestCase TBufferLoadFormatX8UintZeroExtendsByte() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  code.push_back(EncodeMtbuf0(0x00, 5, 0));
  code.push_back(EncodeMtbuf1(0x00, 0, 0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  return {"TBufferLoadFormatX8UintZeroExtendsByte",
          code,
          {0x11223344u, 0},
          {0x00000044u, 0},
          {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_X, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase TBufferLoadFormatX8888UintExtractsFirstByte() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendTBufferLoadFormatOpcode(&code, 0x00, 0, 20,
                                Prospero::BufferFormat::k8_8_8_8UInt);
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  return {"TBufferLoadFormatX8_8_8_8UintExtractsFirstByte",
          code,
          {0x44332211u, 0},
          {0x00000011u, 0},
          {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_X, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase TBufferLoadFormatXIdxenUsesDescriptorStride() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  code.push_back(EncodeMtbuf0(0x00, 5, 0, 0, true, false));
  code.push_back(EncodeMtbuf1(0x00, 0, 0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "TBufferLoadFormatXIdxenUsesDescriptorStride";
  test.code = code;
  test.initial = {0x01020304u, 0, 0, 0, 0, 0, 0, 0, 0x0000007eu};
  test.expected = {0x0000007eu, 0, 0, 0, 0, 0, 0, 0, 0x0000007eu};
  test.opcodes = {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_X, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.user_data = MakeStructuredStorageBufferData(16, 3);
  test.has_user_data = true;
  return test;
}

TestCase TBufferLoadFormatX16FloatConvertsToFloat() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendTBufferLoadFormatOpcode(&code, 0x00, 0, 20,
                                Prospero::BufferFormat::k16Float);
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  return {"TBufferLoadFormatX16FloatConvertsToFloat",
          code,
          {0x00003c00u, 0},
          {0x3f800000u, 0},
          {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_X, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase TBufferLoadFormatXSintSignExtendsSubDword() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  code.push_back(EncodeMtbuf0(0x00, 6, 0));
  code.push_back(EncodeMtbuf1(0x00, 0, 0, 20));
  AppendVMovU32(&code, 20, 4);
  code.push_back(EncodeMtbuf0(0x00, 12, 0));
  code.push_back(EncodeMtbuf1(0x00, 1, 0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendStoreVgpr(&code, 1, 1);
  AppendEnd(&code);

  return {"TBufferLoadFormatXSintSignExtendsSubDword",
          code,
          {0x00000080u, 0x00008001u},
          {0xffffff80u, 0xffff8001u},
          {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_X, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase TBufferStoreFormatXSintWritesSubDword() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovLiteral(&code, 0, 0xffffff80u);
  code.push_back(EncodeMtbuf0(0x04, 6, 0));
  code.push_back(EncodeMtbuf1(0x04, 0, 0, 20));
  AppendVMovU32(&code, 20, 4);
  AppendVMovLiteral(&code, 1, 0xffff8001u);
  code.push_back(EncodeMtbuf0(0x04, 12, 0));
  code.push_back(EncodeMtbuf1(0x04, 1, 0, 20));
  AppendEnd(&code);

  return {"TBufferStoreFormatXSintWritesSubDword",
          code,
          {0x11223344u, 0x55667788u},
          {0x11223380u, 0x55668001u},
          {O::V_MOV_B32, O::TBUFFER_STORE_FORMAT_X, O::S_ENDPGM}};
}

TestCase TBufferLoadFormatXy88IntegerComponents() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  code.push_back(EncodeMtbuf0(0x01, 2, 1));
  code.push_back(EncodeMtbuf1(0x01, 0, 0, 20));
  AppendVMovU32(&code, 20, 4);
  code.push_back(EncodeMtbuf0(0x01, 3, 1));
  code.push_back(EncodeMtbuf1(0x01, 2, 0, 20));
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  return {"TBufferLoadFormatXy8_8IntegerComponents",
          code,
          {0x0000807fu, 0x00007f80u, 0, 0},
          {0x0000007fu, 0x00000080u, 0xffffff80u, 0x0000007fu},
          {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_XY, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase TBufferStoreFormatXy88IntegerComponents() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovU32(&code, 0, 0xaa);
  AppendVMovU32(&code, 1, 0xbb);
  code.push_back(EncodeMtbuf0(0x05, 2, 1));
  code.push_back(EncodeMtbuf1(0x05, 0, 0, 20));
  AppendVMovU32(&code, 20, 4);
  AppendVMovLiteral(&code, 2, 0xffffff80u);
  AppendVMovU32(&code, 3, 0x7f);
  code.push_back(EncodeMtbuf0(0x05, 3, 1));
  code.push_back(EncodeMtbuf1(0x05, 2, 0, 20));
  AppendEnd(&code);

  return {"TBufferStoreFormatXy8_8IntegerComponents",
          code,
          {0x11223344u, 0x55667788u},
          {0x1122bbaau, 0x55667f80u},
          {O::V_MOV_B32, O::TBUFFER_STORE_FORMAT_XY, O::S_ENDPGM}};
}

TestCase TBufferLoadFormatXy1616IntegerComponents() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  code.push_back(EncodeMtbuf0(0x01, 11, 1));
  code.push_back(EncodeMtbuf1(0x01, 0, 0, 20));
  AppendVMovU32(&code, 20, 4);
  code.push_back(EncodeMtbuf0(0x01, 12, 1));
  code.push_back(EncodeMtbuf1(0x01, 2, 0, 20));
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  return {"TBufferLoadFormatXy16_16IntegerComponents",
          code,
          {0x80017fffu, 0x7fff8000u, 0, 0},
          {0x00007fffu, 0x00008001u, 0xffff8000u, 0x00007fffu},
          {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_XY, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase TBufferStoreFormatXy1616IntegerComponents() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovU32(&code, 0, 0xaaaa);
  AppendVMovU32(&code, 1, 0xbbbb);
  code.push_back(EncodeMtbuf0(0x05, 11, 1));
  code.push_back(EncodeMtbuf1(0x05, 0, 0, 20));
  AppendVMovU32(&code, 20, 4);
  AppendVMovLiteral(&code, 2, 0xffff8000u);
  AppendVMovU32(&code, 3, 0x7fff);
  code.push_back(EncodeMtbuf0(0x05, 12, 1));
  code.push_back(EncodeMtbuf1(0x05, 2, 0, 20));
  AppendEnd(&code);

  return {"TBufferStoreFormatXy16_16IntegerComponents",
          code,
          {0x11223344u, 0x55667788u},
          {0xbbbbaaaau, 0x7fff8000u},
          {O::V_MOV_B32, O::TBUFFER_STORE_FORMAT_XY, O::S_ENDPGM}};
}

TestCase TBufferLoadFormatXyz16161616UintLoadsHalfwords() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendTBufferLoadFormatOpcode(&code, 0x02, 0, 20,
                                Prospero::BufferFormat::k16_16_16_16UInt);
  for (u32 i = 0; i < 3; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  return {"TBufferLoadFormatXyz16_16_16_16UintLoadsHalfwords",
          code,
          {0x22221111u, 0x44443333u, 0},
          {0x00001111u, 0x00002222u, 0x00003333u},
          {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_XYZ, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase TBufferLoadFormatXy88UnormConvertsToFloat() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  code.push_back(EncodeMtbuf0(0x01, 14, 0));
  code.push_back(EncodeMtbuf1(0x01, 0, 0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendStoreVgpr(&code, 1, 1);
  AppendEnd(&code);

  return {"TBufferLoadFormatXy8_8UnormConvertsToFloat",
          code,
          {0x0000ff80u, 0},
          {0x3f008081u, 0x3f800000u},
          {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_XY, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase TBufferLoadFormatXy88SnormConvertsToFloat() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendTBufferLoadFormatOpcode(&code, 0x01, 0, 20,
                                Prospero::BufferFormat::k8_8SNorm);
  AppendStoreVgpr(&code, 0, 0);
  AppendStoreVgpr(&code, 1, 1);
  AppendEnd(&code);

  return {"TBufferLoadFormatXy8_8SnormConvertsToFloat",
          code,
          {0x00007f80u, 0},
          {0xbf800000u, 0x3f800000u},
          {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_XY, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase TBufferLoadFormatXy1616UnormConvertsToFloat() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  code.push_back(EncodeMtbuf0(0x01, 7, 1));
  code.push_back(EncodeMtbuf1(0x01, 0, 0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendStoreVgpr(&code, 1, 1);
  AppendEnd(&code);

  return {"TBufferLoadFormatXy16_16UnormConvertsToFloat",
          code,
          {0xffff8000u, 0},
          {0x3f000080u, 0x3f800000u},
          {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_XY, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase TBufferLoadFormatXy8888UnormConvertsFirstTwoComponents() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  code.push_back(EncodeMtbuf0(0x01, 8, 3));
  code.push_back(EncodeMtbuf1(0x01, 0, 0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendStoreVgpr(&code, 1, 1);
  AppendEnd(&code);

  return {"TBufferLoadFormatXy8_8_8_8UnormConvertsFirstTwoComponents",
          code,
          {0x44332211u, 0xdeadbeefu},
          {0x3d888889u, 0x3e088889u},
          {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_XY, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase TBufferLoadFormatXyzw8888UintExtractsBytes() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendTBufferLoadFormatOpcode(&code, 0x03, 0, 20,
                                Prospero::BufferFormat::k8_8_8_8UInt);
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  return {"TBufferLoadFormatXyzw8_8_8_8UintExtractsBytes",
          code,
          {0x44332211u, 0xaaaaaaaau, 0xbbbbbbbbu, 0xccccccccu},
          {0x00000011u, 0x00000022u, 0x00000033u, 0x00000044u},
          {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_XYZW, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase TBufferLoadFormatXyzw1010102SnormConvertsToFloat() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendTBufferLoadFormatOpcode(&code, 0x03, 0, 20,
                                Prospero::BufferFormat::k10_10_10_2SNorm);
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  return {"TBufferLoadFormatXyzw10_10_10_2SnormConvertsToFloat",
          code,
          {0x800801ffu, 0, 0, 0},
          {0x3f800000u, 0xbf800000u, 0, 0xbf800000u},
          {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_XYZW, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase TBufferLoadFormatXyz111110FloatUnpacks() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendTBufferLoadFormatOpcode(&code, 0x02, 0, 20,
                                Prospero::BufferFormat::k11_11_10Float);
  for (u32 i = 0; i < 3; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  return {"TBufferLoadFormatXyz11_11_10FloatUnpacks",
          code,
          {0x781e03c0u, 0, 0},
          {0x3f800000u, 0x3f800000u, 0x3f800000u},
          {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_XYZ, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase TBufferLoadFormatXyzw3232FloatZerosMissingComponents() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  code.push_back(EncodeMtbuf0(0x03, 0, 4));
  code.push_back(EncodeMtbuf1(0x03, 0, 0, 20));
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  return {"TBufferLoadFormatXyzw32_32FloatZerosMissingComponents",
          code,
          {0x11111111u, 0x22222222u, 0x33333333u, 0x44444444u},
          {0x11111111u, 0x22222222u, 0, 0},
          {O::V_MOV_B32, O::TBUFFER_LOAD_FORMAT_XYZW, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase TBufferStoreFormatXyzw3232FloatWritesOnlyPresentComponents() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovLiteral(&code, 0, 0x3f800000u);
  AppendVMovLiteral(&code, 1, 0x40000000u);
  AppendVMovLiteral(&code, 2, 0x40400000u);
  AppendVMovLiteral(&code, 3, 0x40800000u);
  code.push_back(EncodeMtbuf0(0x07, 0, 4));
  code.push_back(EncodeMtbuf1(0x07, 0, 0, 20));
  AppendEnd(&code);

  return {"TBufferStoreFormatXyzw32_32FloatWritesOnlyPresentComponents",
          code,
          {0xaaaaaaaau, 0xbbbbbbbbu, 0xccccccccu, 0xddddddddu},
          {0x3f800000u, 0x40000000u, 0xccccccccu, 0xddddddddu},
          {O::V_MOV_B32, O::TBUFFER_STORE_FORMAT_XYZW, O::S_ENDPGM}};
}

TestCase TBufferStoreVariants() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovLiteral(&code, 0, 0x01020304u);
  AppendTBufferStoreOpcode(&code, 0x04, 0, 20);
  AppendVMovU32(&code, 20, 4);
  AppendVMovLiteral(&code, 1, 0x11121314u);
  AppendVMovLiteral(&code, 2, 0x21222324u);
  AppendTBufferStoreOpcode(&code, 0x05, 1, 20);
  AppendVMovU32(&code, 20, 12);
  AppendVMovLiteral(&code, 3, 0x31323334u);
  AppendVMovLiteral(&code, 4, 0x41424344u);
  AppendVMovLiteral(&code, 5, 0x51525354u);
  AppendTBufferStoreOpcode(&code, 0x06, 3, 20);
  AppendVMovU32(&code, 20, 24);
  AppendVMovLiteral(&code, 6, 0x61626364u);
  AppendVMovLiteral(&code, 7, 0x71727374u);
  AppendVMovLiteral(&code, 8, 0x81828384u);
  AppendVMovLiteral(&code, 9, 0x91929394u);
  AppendTBufferStoreOpcode(&code, 0x07, 6, 20);
  AppendEnd(&code);

  return {"TBufferStoreVariants",
          code,
          std::vector<u32>(10, 0),
          {0x01020304u, 0x11121314u, 0x21222324u, 0x31323334u, 0x41424344u,
           0x51525354u, 0x61626364u, 0x71727374u, 0x81828384u, 0x91929394u},
          {O::V_MOV_B32, O::TBUFFER_STORE_FORMAT_X, O::TBUFFER_STORE_FORMAT_XY,
           O::TBUFFER_STORE_FORMAT_XYZ, O::TBUFFER_STORE_FORMAT_XYZW,
           O::S_ENDPGM}};
}

TestCase FlatLoadVariants() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovU32(&code, 21, 0);
  code.push_back(EncodeFlat0(0x08, 0, 0));
  code.push_back(EncodeFlat1(0, 0x7d, 0, 20));
  code.push_back(EncodeFlat0(0x09, 0, 2));
  code.push_back(EncodeFlat1(1, 0x7d, 0, 20));
  code.push_back(EncodeFlat0(0x0a, 0, 0));
  code.push_back(EncodeFlat1(2, 0x7d, 0, 20));
  code.push_back(EncodeFlat0(0x0b, 0, 2));
  code.push_back(EncodeFlat1(3, 0x7d, 0, 20));
  code.push_back(EncodeFlat0(0x0c, 0, 8));
  code.push_back(EncodeFlat1(13, 0x7d, 0, 20));
  code.push_back(EncodeFlat0(0x0d, 0, 8));
  code.push_back(EncodeFlat1(4, 0x7d, 0, 20));
  code.push_back(EncodeFlat0(0x0f, 0, 8));
  code.push_back(EncodeFlat1(6, 0x7d, 0, 20));
  code.push_back(EncodeFlat0(0x0e, 0, 8));
  code.push_back(EncodeFlat1(9, 0x7d, 0, 20));

  for (u32 i = 0; i < 14u; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  const std::vector<u32> guest_memory{0x80ff7f01u, 0x00008001u, 0x11223344u,
                                      0x55667788u, 0x99aabbccu, 0xddeeff00u};
  constexpr size_t byte_offset = 8;
  std::vector<u32> host_memory(
      (byte_offset + guest_memory.size() * sizeof(u32) + sizeof(u32) - 1u) /
      sizeof(u32));
  std::memcpy(reinterpret_cast<uint8_t *>(host_memory.data()) + byte_offset,
              guest_memory.data(), guest_memory.size() * sizeof(u32));

  TestCase test{"FlatLoadVariants",
                code,
                std::move(host_memory),
                {0x01u, 0xffffffffu, 0x7f01u, 0xffff80ffu, 0x11223344u,
                 0x55667788u, 0x11223344u, 0x55667788u, 0x99aabbccu,
                 0x11223344u, 0x55667788u, 0x99aabbccu, 0xddeeff00u,
                 0x11223344u},
                {O::V_MOV_B32, O::FLAT_LOAD_UBYTE, O::FLAT_LOAD_SBYTE,
                 O::FLAT_LOAD_USHORT, O::FLAT_LOAD_SSHORT, O::FLAT_LOAD_DWORD,
                 O::FLAT_LOAD_DWORDX2, O::FLAT_LOAD_DWORDX3,
                 O::FLAT_LOAD_DWORDX4, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
  test.bda_mappings = {{0, static_cast<u32>(byte_offset)}};
  return test;
}

TestCase FlatSubdwordLoadsApplyByteOffset() {
  using O = ShaderOpcode;

  constexpr size_t byte_offset = 3;
  std::vector<u32> code;
  AppendVMovU32(&code, 20, static_cast<u32>(byte_offset));
  AppendVMovU32(&code, 21, 0);
  code.push_back(EncodeFlat0(0x08, 0, 0));
  code.push_back(EncodeFlat1(0, 0x7d, 0, 20));
  code.push_back(EncodeFlat0(0x0a, 0, 1));
  code.push_back(EncodeFlat1(1, 0x7d, 0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendStoreVgpr(&code, 1, 1);
  AppendEnd(&code);

  constexpr u32 guest_word = 0x80ff7f01u;
  std::vector<u32> host_memory(
      (byte_offset + sizeof(guest_word) + sizeof(u32) - 1u) / sizeof(u32));
  std::memcpy(reinterpret_cast<uint8_t *>(host_memory.data()) + byte_offset,
              &guest_word, sizeof(guest_word));

  TestCase test;
  test.name = "FlatSubdwordLoadsApplyByteOffset";
  test.code = std::move(code);
  test.initial = std::move(host_memory);
  test.expected = {0x01u, 0x0000ff7fu};
  test.bda_mappings = {{0, 0}};
  test.opcodes = {O::V_MOV_B32, O::FLAT_LOAD_UBYTE, O::FLAT_LOAD_USHORT,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  return test;
}

TestCase BranchVccnzUsesCarryProducedWaveMask() {
  using O = ShaderOpcode;

  std::vector<u32> code = {
      EncodeVop1(0x01, 1, 0),          EncodeVop2(0x1a, 1, InlineU32(2), 1),
      EncodeVop2(0x25, 1, Vgpr(0), 1), EncodeVop2(0x1a, 3, InlineU32(2), 1),
      EncodeVopc(0xc0, Vgpr(0), 0),
  };
  AppendVMovLiteral(&code, 2, 0xffffffffu);
  code.push_back(EncodeVop2(0x28, 5, Vgpr(2), 1));
  code.push_back(EncodeSopp(0x07, 2));
  code.push_back(EncodeVop1(0x01, 2, InlineU32(11)));
  code.push_back(EncodeSopp(0x02, 1));
  AppendVMovU32(&code, 2, 42);
  AppendBufferStoreDword(&code, 2, 3);
  AppendEnd(&code);

  TestCase test;
  test.name = "BranchVccnzUsesCarryProducedWaveMask";
  test.code = code;
  test.expected = std::vector<u32>(8, 42);
  test.opcodes = {O::V_MOV_B32,   O::V_LSHLREV_B32,      O::V_ADD_NC_U32,
                  O::V_CMP_F_U32, O::V_ADDC_U32,         O::S_CBRANCH_VCCNZ,
                  O::S_BRANCH,    O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.group_id[0] = true;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.workgroup_register = 0;
  test.has_compute_info = true;
  test.dispatch_x = 2;
  return test;
}

TestCase ScalarLoadAlignsComponentsAndMasksAddress() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendSMovLiteral(&code, 0, 1u);
  AppendSMovLiteral(&code, 2, 3u);
  AppendSMovLiteral(&code, 3, 0xffff0000u);
  code.push_back(EncodeSmem0(0x00, 1, 1));
  code.push_back(EncodeSmem1(3, 0));
  AppendStoreSgpr(&code, 1, 0);
  AppendEnd(&code);

  return {"ScalarLoadAlignsComponentsAndMasksAddress",
          code,
          {0x11111111u, 0x22222222u},
          {0x11111111u, 0x22222222u},
          {O::S_MOV_B32, O::S_LOAD_DWORD, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase FlatVirtualAddressRebasesGuestAllocation() {
  using O = ShaderOpcode;

  constexpr uint64_t GuestBase = 0x0000000110000000ull;
  std::vector<u32> code;
  AppendVMovLiteral(&code, 20, static_cast<u32>(GuestBase + 4u));
  AppendVMovLiteral(&code, 21, static_cast<u32>(GuestBase >> 32u));
  code.push_back(EncodeFlat0(0x0c, 0, 0));
  code.push_back(EncodeFlat1(0, 0x7d, 0, 20));
  code.push_back(EncodeFlat0(0x0c, 2, 0));
  code.push_back(EncodeFlat1(1, 0x7d, 0, 20));
  AppendVMovLiteral(&code, 21, static_cast<u32>((GuestBase >> 32u) + 1u));
  code.push_back(EncodeFlat0(0x0c, 0, 0));
  code.push_back(EncodeFlat1(2, 0x7d, 0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendStoreVgpr(&code, 1, 1);
  AppendStoreVgpr(&code, 2, 2);
  AppendEnd(&code);

  TestCase test;
  test.name = "FlatVirtualAddressRebasesGuestAllocation";
  test.code = std::move(code);
  test.initial = {0xfeedfaceu, 0xcafebabeu, 0, 0x12345678u};
  test.expected = {0x12345678u, 0x12345678u, 0};
  test.bda_mappings = {{GuestBase, 8}};
  test.opcodes = {O::V_MOV_B32, O::FLAT_LOAD_DWORD, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  return test;
}

TestCase GlobalSignedImmediateRebasesBeforeSaddr() {
  using O = ShaderOpcode;

  constexpr uint64_t GuestBase = 0x0000000110000000ull;
  std::vector<u32> code;
  AppendSMovLiteral(&code, 0, static_cast<u32>(GuestBase));
  AppendSMovLiteral(&code, 1, static_cast<u32>(GuestBase >> 32u));
  AppendVMovU32(&code, 20, 8);
  code.push_back(EncodeFlat0(0x0c, 2, 0xffcu));
  code.push_back(EncodeFlat1(0, 0, 0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "GlobalSignedImmediateRebasesBeforeSaddr";
  test.code = std::move(code);
  test.initial = {0xfeedfaceu, 0xcafebabeu, 0x11111111u, 0x12345678u};
  test.expected = {0x12345678u};
  test.bda_mappings = {{GuestBase, 8}};
  test.opcodes = {O::S_MOV_B32, O::V_MOV_B32, O::FLAT_LOAD_DWORD,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  return test;
}

TestCase FlatSegmentIgnoresSaddrAndMasksOffsetMsb() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeSMovB32(0, InlineU32(4)));
  AppendVMovU32(&code, 20, 0);
  AppendVMovU32(&code, 21, 0);
  code.push_back(EncodeFlat0(0x0c, 0, 4));
  code.push_back(EncodeFlat1(0, 0, 0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendVMovU32(&code, 20, 0);
  code.push_back(EncodeFlat0(0x0c, 0, 0x804));
  code.push_back(EncodeFlat1(1, 0x7d, 0, 20));
  AppendStoreVgpr(&code, 1, 1);
  AppendEnd(&code);

  std::vector<u32> initial(514, 0);
  initial[1] = 0x11111111u;
  initial[2] = 0x22222222u;
  initial[513] = 0x33333333u;

  TestCase test;
  test.name = "FlatSegmentIgnoresSaddrAndMasksOffsetMsb";
  test.code = code;
  test.initial = initial;
  test.expected = {0x11111111u, 0x11111111u};
  test.opcodes = {O::S_MOV_B32, O::V_MOV_B32, O::FLAT_LOAD_DWORD,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.bda_mappings = {{0, 0}};
  return test;
}

TestCase ScratchIsPrivatePerInvocation() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeSMovB32(20, InlineU32(0)));
  AppendVMovU32(&code, 21, 0);
  code.push_back(EncodeFlat0(0x1c, 1, 4));
  code.push_back(EncodeFlat1(0, 20, 0, 21));
  code.push_back(EncodeFlat0(0x0c, 1, 4));
  code.push_back(EncodeFlat1(5, 20, 0, 21));
  AppendStoreVgprAtLaneDwordOffset(&code, 5, 0, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "ScratchIsPrivatePerInvocation";
  test.code = std::move(code);
  for (u32 lane = 0; lane < 64; lane++) {
    test.expected.push_back(lane);
  }
  test.opcodes = {O::S_MOV_B32,          O::V_MOV_B32,
                  O::FLAT_STORE_DWORD,   O::FLAT_LOAD_DWORD,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 64;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.workgroup_register = 0;
  test.compute_info.scratch_size_dwords = 2;
  test.has_compute_info = true;
  return test;
}

#if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS
TestCase FlatStoreVariants() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 21, 0);
  AppendVMovU32(&code, 20, 1);
  AppendVMovU32(&code, 0, 0xaa);
  code.push_back(EncodeFlat0(0x18, 0, 0));
  code.push_back(EncodeFlat1(0, 0x7d, 0, 20));
  AppendVMovU32(&code, 20, 2);
  AppendVMovLiteral(&code, 1, 0x0000bbccu);
  code.push_back(EncodeFlat0(0x1a, 0, 0));
  code.push_back(EncodeFlat1(0, 0x7d, 1, 20));
  AppendVMovU32(&code, 20, 4);
  AppendVMovLiteral(&code, 2, 0x11111111u);
  AppendVMovLiteral(&code, 3, 0x22222222u);
  code.push_back(EncodeFlat0(0x1d, 0, 0));
  code.push_back(EncodeFlat1(0, 0x7d, 2, 20));
  AppendVMovU32(&code, 20, 12);
  AppendVMovLiteral(&code, 4, 0x33333333u);
  AppendVMovLiteral(&code, 5, 0x44444444u);
  AppendVMovLiteral(&code, 6, 0x55555555u);
  code.push_back(EncodeFlat0(0x1f, 0, 0));
  code.push_back(EncodeFlat1(0, 0x7d, 4, 20));
  AppendVMovU32(&code, 20, 24);
  AppendVMovLiteral(&code, 7, 0x66666666u);
  AppendVMovLiteral(&code, 8, 0x77777777u);
  AppendVMovLiteral(&code, 9, 0x88888888u);
  AppendVMovLiteral(&code, 10, 0x99999999u);
  code.push_back(EncodeFlat0(0x1e, 0, 0));
  code.push_back(EncodeFlat1(0, 0x7d, 7, 20));
  AppendVMovU32(&code, 20, 0);
  code.push_back(EncodeFlat0(0x1c, 0, 40));
  code.push_back(EncodeFlat1(0, 0x7d, 2, 20));
  AppendEnd(&code);

  TestCase test{"FlatStoreVariants",
                code,
                std::vector<u32>(12, 0),
                {0xbbccaa00u, 0x11111111u, 0x22222222u, 0x33333333u,
                 0x44444444u, 0x55555555u, 0x66666666u, 0x77777777u,
                 0x88888888u, 0x99999999u, 0x11111111u, 0},
                {O::V_MOV_B32, O::FLAT_STORE_BYTE, O::FLAT_STORE_SHORT,
                 O::FLAT_STORE_DWORD, O::FLAT_STORE_DWORDX2,
                 O::FLAT_STORE_DWORDX3, O::FLAT_STORE_DWORDX4, O::S_ENDPGM}};
  return test;
}
#endif

TestCase DsReadWriteVariants() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 1, 0);
  AppendVMovLiteral(&code, 2, 0x11223344u);
  code.push_back(EncodeDs0(0x0d, 0));
  code.push_back(EncodeDs1(0, 2, 1));
  code.push_back(EncodeDs0(0x36, 0));
  code.push_back(EncodeDs1(3, 0, 1));
  AppendVMovU32(&code, 4, 0xaa);
  code.push_back(EncodeDs0(0x1e, 4));
  code.push_back(EncodeDs1(0, 4, 1));
  code.push_back(EncodeDs0(0x3a, 4));
  code.push_back(EncodeDs1(5, 0, 1));
  code.push_back(EncodeDs0(0x39, 4));
  code.push_back(EncodeDs1(6, 0, 1));
  AppendVMovLiteral(&code, 7, 0x000080ffu);
  code.push_back(EncodeDs0(0x1f, 8));
  code.push_back(EncodeDs1(0, 7, 1));
  code.push_back(EncodeDs0(0x3c, 8));
  code.push_back(EncodeDs1(8, 0, 1));
  code.push_back(EncodeDs0(0x3b, 8));
  code.push_back(EncodeDs1(9, 0, 1));
  AppendVMovLiteral(&code, 10, 0x10101010u);
  AppendVMovLiteral(&code, 11, 0x11111111u);
  code.push_back(EncodeDs0(0x4d, 12));
  code.push_back(EncodeDs1(0, 10, 1));
  code.push_back(EncodeDs0(0x76, 12));
  code.push_back(EncodeDs1(14, 0, 1));
  AppendVMovLiteral(&code, 16, 0x20202020u);
  AppendVMovLiteral(&code, 17, 0x21212121u);
  AppendVMovLiteral(&code, 18, 0x22222222u);
  code.push_back(EncodeDs0(0xde, 20));
  code.push_back(EncodeDs1(0, 16, 1));
  code.push_back(EncodeDs0(0xfe, 20));
  code.push_back(EncodeDs1(19, 0, 1));
  AppendVMovLiteral(&code, 22, 0x30303030u);
  AppendVMovLiteral(&code, 23, 0x31313131u);
  AppendVMovLiteral(&code, 24, 0x32323232u);
  AppendVMovLiteral(&code, 25, 0x33333333u);
  code.push_back(EncodeDs0(0xdf, 32));
  code.push_back(EncodeDs1(0, 22, 1));
  code.push_back(EncodeDs0(0xff, 32));
  code.push_back(EncodeDs1(26, 0, 1));

  const u32 results[] = {3, 5, 6, 8, 9, 14, 15, 19, 20, 21, 26, 27, 28, 29};
  for (u32 i = 0; i < static_cast<u32>(std::size(results)); i++) {
    AppendStoreVgpr(&code, results[i], i);
  }
  AppendEnd(&code);

  return {"DsReadWriteVariants",
          code,
          std::vector<u32>(14, 0),
          {0x11223344u, 0xaau, 0xffffffaau, 0x80ffu, 0xffff80ffu, 0x10101010u,
           0x11111111u, 0x20202020u, 0x21212121u, 0x22222222u, 0x30303030u,
           0x31313131u, 0x32323232u, 0x33333333u},
          {O::V_MOV_B32, O::DS_WRITE_B32, O::DS_READ_B32, O::DS_WRITE_B8,
           O::DS_READ_U8, O::DS_READ_I8, O::DS_WRITE_B16, O::DS_READ_U16,
           O::DS_READ_I16, O::DS_WRITE_B64, O::DS_READ_B64, O::DS_WRITE_B96,
           O::DS_READ_B96, O::DS_WRITE_B128, O::DS_READ_B128,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase DsReadU16D16CapturedPreservesHighHalf() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 1, 0);
  AppendVMovLiteral(&code, 2, 0x89abcdefu);
  code.push_back(EncodeDs0(0x0d));
  code.push_back(EncodeDs1(0, 2, 1)); // ds_write_b32 v2, v1

  AppendVMovLiteral(&code, 3, 0x12345678u);
  code.push_back(EncodeDs0(0xa6));
  code.push_back(EncodeDs1(3, 0, 1)); // ds_read_u16_d16 v3, v1

  AppendVMovU32(&code, 7, 0);
  code.push_back(0xda980000u);
  code.push_back(0x07000007u); // captured ds_read_u16_d16 v7, v7

  AppendStoreVgpr(&code, 3, 0);
  AppendStoreVgpr(&code, 7, 1);
  AppendEnd(&code);

  TestCase test{"DsReadU16D16CapturedPreservesHighHalf",
                code,
                std::vector<u32>(2, 0),
                {0x1234cdefu, 0x0000cdefu},
                {O::V_MOV_B32, O::DS_WRITE_B32, O::DS_READ_U16_D16,
                 O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
  test.decoded_counts = {{"DS_READ_U16_D16", 2}};
  return test;
}

TestCase DsWriteB16D16HiCapturedUsesHighHalf() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 1, 0);
  AppendVMovLiteral(&code, 3, 0xdeadbeefu);
  code.push_back(EncodeDs0(0x0d));
  code.push_back(EncodeDs1(0, 3, 1)); // ds_write_b32 v1, v3

  AppendVMovU32(&code, 20, 2);
  AppendVMovLiteral(&code, 2, 0x1234abcdu);
  AppendVMovLiteral(&code, 0, 0x87654321u);
  code.push_back(0xda840000u);
  code.push_back(0x00000214u); // captured ds_write_b16_d16_hi v20, v2

  code.push_back(EncodeDs0(0x36));
  code.push_back(EncodeDs1(4, 0, 1)); // ds_read_b32 v4, v1
  AppendStoreVgpr(&code, 4, 0);
  AppendStoreVgpr(&code, 0, 1);
  AppendEnd(&code);

  TestCase test{"DsWriteB16D16HiCapturedUsesHighHalf",
                code,
                std::vector<u32>(2, 0),
                {0x1234beefu, 0x87654321u},
                {O::V_MOV_B32, O::DS_WRITE_B32, O::DS_WRITE_B16_D16_HI,
                 O::DS_READ_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
  test.decoded_counts = {{"DS_WRITE_B16_D16_HI", 1}};
  return test;
}

TestCase DsReadU16D16HiCapturedPreservesLowHalf() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 1, 0);
  AppendVMovLiteral(&code, 2, 0x89abcdefu);
  code.push_back(EncodeDs0(0x0d));
  code.push_back(EncodeDs1(0, 2, 1)); // ds_write_b32 v2, v1

  AppendVMovLiteral(&code, 5, 0x12345678u);
  AppendVMovU32(&code, 6, 0);
  code.push_back(0xda9c0000u);
  code.push_back(0x05000006u); // captured ds_read_u16_d16_hi v5, v6

  AppendStoreVgpr(&code, 5, 0);
  AppendEnd(&code);

  TestCase test{"DsReadU16D16HiCapturedPreservesLowHalf",
                code,
                std::vector<u32>(1, 0),
                {0xcdef5678u},
                {O::V_MOV_B32, O::DS_WRITE_B32, O::DS_READ_U16_D16_HI,
                 O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
  test.decoded_counts = {{"DS_READ_U16_D16_HI", 1}};
  return test;
}

TestCase DsReadWrite2Variants() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 1, 0);
  AppendVMovLiteral(&code, 2, 0x11111111u);
  AppendVMovLiteral(&code, 3, 0x22222222u);
  code.push_back(EncodeDs0(0x0e, (3u << 8u) | 1u));
  code.push_back(EncodeDs1Ex(0, 3, 2, 1));
  code.push_back(EncodeDs0(0x37, (3u << 8u) | 1u));
  code.push_back(EncodeDs1Ex(4, 0, 0, 1));
  AppendVMovLiteral(&code, 6, 0x33333333u);
  AppendVMovLiteral(&code, 7, 0x44444444u);
  AppendVMovLiteral(&code, 8, 0x55555555u);
  AppendVMovLiteral(&code, 9, 0x66666666u);
  code.push_back(EncodeDs0(0x4d, 32));
  code.push_back(EncodeDs1(0, 6, 1));
  code.push_back(EncodeDs0(0x4d, 48));
  code.push_back(EncodeDs1(0, 8, 1));
  code.push_back(EncodeDs0(0x77, (6u << 8u) | 4u));
  code.push_back(EncodeDs1Ex(10, 0, 0, 1));
  AppendVMovLiteral(&code, 14, 0x77777777u);
  AppendVMovLiteral(&code, 15, 0x88888888u);
  code.push_back(EncodeDs0(0x0f, (2u << 8u) | 1u));
  code.push_back(EncodeDs1Ex(0, 15, 14, 1));
  code.push_back(EncodeDs0(0x38, (2u << 8u) | 1u));
  code.push_back(EncodeDs1Ex(16, 0, 0, 1));
  AppendVMovLiteral(&code, 18, 0x99999999u);
  AppendVMovLiteral(&code, 19, 0xaaaaaaaau);
  AppendVMovLiteral(&code, 20, 0xbbbbbbbbu);
  AppendVMovLiteral(&code, 21, 0xccccccccu);
  code.push_back(EncodeDs0(0x4e, (10u << 8u) | 8u));
  code.push_back(EncodeDs1Ex(0, 20, 18, 1));
  code.push_back(EncodeDs0(0x77, (10u << 8u) | 8u));
  code.push_back(EncodeDs1Ex(22, 0, 0, 1));
  AppendVMovLiteral(&code, 26, 0xddddddddu);
  AppendVMovLiteral(&code, 27, 0xeeeeeeeeu);
  AppendVMovLiteral(&code, 28, 0xf0f0f0f0u);
  AppendVMovLiteral(&code, 29, 0x12345678u);
  code.push_back(EncodeDs0(0x4f, (2u << 8u) | 1u));
  code.push_back(EncodeDs1Ex(0, 28, 26, 1));
  code.push_back(EncodeDs0(0x78, (2u << 8u) | 1u));
  code.push_back(EncodeDs1Ex(34, 0, 0, 1));

  const u32 results[] = {4,  5,  10, 11, 12, 13, 22, 23,
                         24, 25, 16, 17, 34, 35, 36, 37};
  for (u32 i = 0; i < static_cast<u32>(std::size(results)); i++) {
    AppendStoreVgpr(&code, results[i], i);
  }
  AppendEnd(&code);

  return {"DsReadWrite2Variants",
          code,
          std::vector<u32>(16, 0),
          {0x11111111u, 0x22222222u, 0x33333333u, 0x44444444u, 0x55555555u,
           0x66666666u, 0x99999999u, 0xaaaaaaaau, 0xbbbbbbbbu, 0xccccccccu,
           0x77777777u, 0x88888888u, 0xddddddddu, 0xeeeeeeeeu, 0xf0f0f0f0u,
           0x12345678u},
          {O::V_MOV_B32, O::DS_WRITE2_B32, O::DS_READ2_B32, O::DS_WRITE_B64,
           O::DS_READ2_B64, O::DS_WRITE2_B64, O::DS_WRITE2ST64_B32,
           O::DS_READ2ST64_B32, O::DS_WRITE2ST64_B64, O::DS_READ2ST64_B64,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase DsWideReadSnapshotsOverlappingAddress() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 1, 0);
  AppendVMovLiteral(&code, 6, 0x11111111u);
  AppendVMovLiteral(&code, 7, 0x22222222u);
  code.push_back(EncodeDs0(0x4d, 0));
  code.push_back(EncodeDs1(0, 6, 1));
  AppendVMovLiteral(&code, 8, 0x33333333u);
  AppendVMovLiteral(&code, 9, 0x44444444u);
  code.push_back(EncodeDs0(0x4d, 16));
  code.push_back(EncodeDs1(0, 8, 1));
  code.push_back(EncodeDs0(0x77, 2u << 8u));
  code.push_back(EncodeDs1Ex(1, 0, 0, 1));
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, 1u + i, i);
  }
  AppendEnd(&code);

  return {"DsWideReadSnapshotsOverlappingAddress",
          code,
          std::vector<u32>(4, 0),
          {0x11111111u, 0x22222222u, 0x33333333u, 0x44444444u},
          {O::V_MOV_B32, O::DS_WRITE_B64, O::DS_READ2_B64,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase DsReadWrite2EqualOffsetsUseData0() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 1, 0);
  AppendVMovLiteral(&code, 2, 0x11111111u);
  AppendVMovLiteral(&code, 3, 0x22222222u);
  code.push_back(EncodeDs0(0x0e, (1u << 8u) | 1u));
  code.push_back(EncodeDs1Ex(0, 3, 2, 1));
  AppendVMovLiteral(&code, 4, 0x33333333u);
  AppendVMovLiteral(&code, 5, 0x44444444u);
  AppendVMovLiteral(&code, 6, 0x55555555u);
  AppendVMovLiteral(&code, 7, 0x66666666u);
  code.push_back(EncodeDs0(0x4e, (2u << 8u) | 2u));
  code.push_back(EncodeDs1Ex(0, 6, 4, 1));
  code.push_back(EncodeDs0(0x37, (1u << 8u) | 1u));
  code.push_back(EncodeDs1Ex(8, 0, 0, 1));
  code.push_back(EncodeDs0(0x77, (2u << 8u) | 2u));
  code.push_back(EncodeDs1Ex(10, 0, 0, 1));
  for (u32 i = 0; i < 6; i++) {
    AppendStoreVgpr(&code, 8u + i, i);
  }
  AppendEnd(&code);

  return {"DsReadWrite2EqualOffsetsUseData0",
          code,
          std::vector<u32>(6, 0),
          {0x11111111u, 0x11111111u, 0x33333333u, 0x44444444u, 0x33333333u,
           0x44444444u},
          {O::V_MOV_B32, O::DS_WRITE2_B32, O::DS_WRITE2_B64, O::DS_READ2_B32,
           O::DS_READ2_B64, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase DsWideLdsPartialBounds() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 1, 0);
  AppendVMovLiteral(&code, 2, 0x11111111u);
  AppendVMovLiteral(&code, 3, 0x22222222u);
  AppendVMovLiteral(&code, 4, 0x33333333u);
  AppendVMovLiteral(&code, 5, 0x44444444u);
  code.push_back(EncodeDs0(0xdf));
  code.push_back(EncodeDs1(0, 2, 1));
  code.push_back(EncodeDs0(0xff));
  code.push_back(EncodeDs1(6, 0, 1));
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, 6u + i, i);
  }
  AppendEnd(&code);

  TestCase test{"DsWideLdsPartialBounds",
                code,
                std::vector<u32>(4, 0),
                {0x11111111u, 0x22222222u, 0x33333333u, 0},
                {O::V_MOV_B32, O::DS_WRITE_B128, O::DS_READ_B128,
                 O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
  test.compute_info.lds_size_dwords = 3;
  return test;
}

TestCase DsWideGdsPartialBounds() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 1, 0);
  AppendVMovLiteral(&code, 2, 0x11111111u);
  AppendVMovLiteral(&code, 3, 0x22222222u);
  AppendVMovLiteral(&code, 4, 0x33333333u);
  AppendVMovLiteral(&code, 5, 0x44444444u);
  code.push_back(EncodeDs0(0xdf, 0, true));
  code.push_back(EncodeDs1(0, 2, 1));
  code.push_back(EncodeDs0(0xff, 0, true));
  code.push_back(EncodeDs1(6, 0, 1));
  for (u32 i = 0; i < 4; i++) {
    AppendStoreVgpr(&code, 6u + i, i);
  }
  AppendEnd(&code);

  TestCase test{"DsWideGdsPartialBounds",
                code,
                std::vector<u32>(4, 0),
                {0x11111111u, 0x22222222u, 0x33333333u, 0},
                {O::V_MOV_B32, O::DS_WRITE_B128, O::DS_READ_B128,
                 O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
  test.gds_initial = {0, 0, 0};
  test.expected_gds = {0x11111111u, 0x22222222u, 0x33333333u};
  return test;
}

TestCase DsAtomicNoReturnVariants() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 1, 0);
  const u32 initial[] = {10, 10,      0xfffffff0u, 0xfffffff0u, 10,
                         10, 0xf0f0u, 0xf000u,     0xf00fu};
  const u32 values[] = {5, 3, 5, 5, 5, 20, 0x0ff0u, 0x0f00u, 0x00ffu};
  const u32 ops[] = {0x00, 0x01, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b};
  for (u32 i = 0; i < static_cast<u32>(std::size(values)); i++) {
    AppendVMovLiteral(&code, 2, initial[i]);
    code.push_back(EncodeDs0(0x0d, i * 4u));
    code.push_back(EncodeDs1(0, 2, 1));
    AppendVMovLiteral(&code, 3, values[i]);
    code.push_back(EncodeDs0(ops[i], i * 4u));
    code.push_back(EncodeDs1(0, 3, 1));
    code.push_back(EncodeDs0(0x36, i * 4u));
    code.push_back(EncodeDs1(10u + i, 0, 1));
  }
  for (u32 i = 0; i < static_cast<u32>(std::size(values)); i++) {
    AppendStoreVgpr(&code, 10u + i, i);
  }
  AppendEnd(&code);

  return {"DsAtomicNoReturnVariants",
          code,
          std::vector<u32>(9, 0),
          {15, 7, 0xfffffff0u, 5, 5, 20, 0x00f0u, 0xff00u, 0xf0f0u},
          {O::V_MOV_B32, O::DS_WRITE_B32, O::DS_ADD_U32, O::DS_SUB_U32,
           O::DS_MIN_I32, O::DS_MAX_I32, O::DS_MIN_U32, O::DS_MAX_U32,
           O::DS_AND_B32, O::DS_OR_B32, O::DS_XOR_B32, O::DS_READ_B32,
           O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase DsAtomicReturnVariants() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 1, 0);
  const u32 initial[] = {10, 10,      0xfffffff0u, 0xfffffff0u, 10,
                         10, 0xf0f0u, 0xf000u,     0xf00fu,     10};
  const u32 values[] = {5, 3, 5, 5, 5, 20, 0x0ff0u, 0x0f00u, 0x00ffu, 99};
  const u32 ops[] = {0x20, 0x21, 0x25, 0x26, 0x27,
                     0x28, 0x29, 0x2a, 0x2b, 0x2d};
  for (u32 i = 0; i < static_cast<u32>(std::size(values)); i++) {
    AppendVMovLiteral(&code, 2, initial[i]);
    code.push_back(EncodeDs0(0x0d, i * 4u));
    code.push_back(EncodeDs1(0, 2, 1));
    AppendVMovLiteral(&code, 3, values[i]);
    code.push_back(EncodeDs0(ops[i], i * 4u));
    code.push_back(EncodeDs1(10u + i, 3, 1));
    code.push_back(EncodeDs0(0x36, i * 4u));
    code.push_back(EncodeDs1(20u + i, 0, 1));
  }
  for (u32 i = 0; i < static_cast<u32>(std::size(values)); i++) {
    AppendStoreVgpr(&code, 10u + i, i);
  }
  for (u32 i = 0; i < static_cast<u32>(std::size(values)); i++) {
    AppendStoreVgpr(&code, 20u + i, i + 10u);
  }
  AppendEnd(&code);

  return {
      "DsAtomicReturnVariants",
      code,
      std::vector<u32>(20, 0),
      {10, 10, 0xfffffff0u, 0xfffffff0u, 10, 10, 0xf0f0u, 0xf000u, 0xf00fu, 10,
       15, 7,  0xfffffff0u, 5,           5,  20, 0x00f0u, 0xff00u, 0xf0f0u, 99},
      {O::V_MOV_B32, O::DS_WRITE_B32, O::DS_ADD_RTN_U32, O::DS_SUB_RTN_U32,
       O::DS_MIN_RTN_I32, O::DS_MAX_RTN_I32, O::DS_MIN_RTN_U32,
       O::DS_MAX_RTN_U32, O::DS_AND_RTN_B32, O::DS_OR_RTN_B32,
       O::DS_XOR_RTN_B32, O::DS_WRXCHG_RTN_B32, O::DS_READ_B32,
       O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase DsBoundedAtomicBoundaries(bool decrement, bool gds) {
  using O = ShaderOpcode;
  constexpr u32 guard = 0x13579bdfu;
  struct Boundary {
    u32 before, limit, incremented, decremented;
  };
  constexpr Boundary boundaries[] = {
      {4, 5, 5, 3},
      {5, 5, 0, 4},
      {6, 5, 0, 5},
      {0, 5, 1, 5},
      {0, 0, 0, 0},
      {1, 0, 0, 0},
      {0xffffffffu, 0xffffffffu, 0, 0xfffffffeu},
      {0xfffffffeu, 0xffffffffu, 0xffffffffu, 0xfffffffdu},
      {0, 0xffffffffu, 1, 0xffffffffu},
      {0x80000000u, 0x7fffffffu, 0, 0x7fffffffu},
      {0x7fffffffu, 0x80000000u, 0x80000000u, 0x7ffffffeu},
      {0xffffffffu, 0x80000000u, 0, 0x80000000u}};
  constexpr u32 count = static_cast<u32>(std::size(boundaries));
  const u32 opcode = decrement ? 0x24u : 0x23u;
  TestCase test;
  test.name =
      decrement
          ? (gds ? "DsDecReturnGdsBoundaries" : "DsDecReturnLdsBoundaries")
          : (gds ? "DsIncReturnGdsBoundaries" : "DsIncReturnLdsBoundaries");
  auto &code = test.code;
  AppendVMovU32(&code, 2, 0);
  std::vector<u32> memory(68, guard);
  for (u32 i = 0; i < count; ++i)
    memory[i + 1] = boundaries[i].before;
  if (!gds) {
    for (u32 i = 0; i < memory.size(); ++i) {
      AppendVMovLiteral(&code, 3, memory[i]);
      code.push_back(EncodeDs0(0x0d, i * 4));
      code.push_back(EncodeDs1(0, 3, 2));
    }
  }
  auto StoreResult = [&](u32 vgpr, u32 expected) {
    AppendStoreVgpr(&code, vgpr, static_cast<u32>(test.expected.size()));
    test.expected.push_back(expected);
  };
  for (u32 i = 0; i < count; ++i) {
    AppendVMovU32(&code, 2, i * 4);
    AppendVMovLiteral(&code, 3, boundaries[i].limit);
    // Preserve the captured DATA0/VDST alias and exact increment words in GDS.
    code.push_back(decrement ? EncodeDs0(opcode, 4, gds)
                             : (gds ? 0xd88e0004u : 0xd88c0004u));
    code.push_back(0x03000302u);
    StoreResult(3, boundaries[i].before);
    code.push_back(EncodeDs0(0x36, 4, gds));
    code.push_back(EncodeDs1(4, 0, 2));
    StoreResult(4, decrement ? boundaries[i].decremented
                             : boundaries[i].incremented);
  }

  // EXEC=0 preserves memory and the aliased destination register.
  AppendVMovU32(&code, 2, 0);
  AppendVMovLiteral(&code, 3, 0x12345678u);
  code.push_back(EncodeSop1(0x04, 10, 126));
  code.push_back(EncodeSop1(0x04, 126, InlineU32(0)));
  code.push_back(EncodeDs0(opcode, 4, gds));
  code.push_back(0x03000302u);
  code.push_back(EncodeSop1(0x04, 126, 10));
  StoreResult(3, 0x12345678u);

  // Use both offset bytes and alias VDST with ADDR instead of DATA0.
  AppendVMovU32(&code, 2, 4);
  AppendVMovLiteral(&code, 3, 0xffffffffu);
  code.push_back(EncodeDs0(opcode, 0x104, gds));
  code.push_back(EncodeDs1(2, 3, 2));
  StoreResult(2, guard);

  // Overwriting an unused return must not let DCE discard the atomic update.
  AppendVMovU32(&code, 2, 0);
  code.push_back(EncodeDs0(opcode, 0x108, gds));
  code.push_back(EncodeDs1(4, 3, 2));
  AppendVMovU32(&code, 4, 0);

  // An active access just outside the resource returns zero.
  AppendVMovU32(&code, 2, static_cast<u32>(memory.size() * 4 - 4));
  code.push_back(EncodeDs0(opcode, 4, gds));
  code.push_back(0x03000302u);
  StoreResult(3, 0);

  // Read back all words, including guards around both address ranges.
  AppendVMovU32(&code, 2, 0);
  for (u32 i = 0; i < memory.size(); ++i) {
    u32 expected = memory[i];
    if (i >= 1 && i <= count) {
      expected = decrement ? boundaries[i - 1].decremented
                           : boundaries[i - 1].incremented;
    } else if (i == 66) {
      expected = decrement ? guard - 2 : guard + 2;
    }
    code.push_back(EncodeDs0(0x36, i * 4, gds));
    code.push_back(EncodeDs1(4, 0, 2));
    StoreResult(4, expected);
    if (gds)
      test.expected_gds.push_back(expected);
  }
  AppendEnd(&code);
  test.initial.resize(test.expected.size());
  test.compute_info.lds_size_dwords = static_cast<u32>(memory.size());
  test.opcodes = {
      O::S_MOV_B64,          O::V_MOV_B32,
      O::DS_READ_B32,        decrement ? O::DS_DEC_RTN_U32 : O::DS_INC_RTN_U32,
      O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.required_spirv = {"OpAtomicLoad", "OpAtomicCompareExchange",
                         "OpLoopMerge"};
  if (gds)
    test.gds_initial = memory;
  else
    test.opcodes.push_back(O::DS_WRITE_B32);
  return test;
}

TestCase DsBoundedAtomicContention(bool decrement, bool gds, u32 wave_size) {
  using O = ShaderOpcode;
  constexpr u32 guard = 0x13579bdfu;
  constexpr u32 limit = 15;
  TestCase test;
  if (wave_size == 32) {
    test.name = decrement ? (gds ? "DsDecReturnGdsContentionWave32"
                                 : "DsDecReturnLdsContentionWave32")
                          : (gds ? "DsIncReturnGdsContentionWave32"
                                 : "DsIncReturnLdsContentionWave32");
  } else {
    test.name = decrement ? (gds ? "DsDecReturnGdsContentionWave64"
                                 : "DsDecReturnLdsContentionWave64")
                          : (gds ? "DsIncReturnGdsContentionWave64"
                                 : "DsIncReturnLdsContentionWave64");
  }
  auto &code = test.code;
  AppendVMovU32(&code, 2, 0);
  AppendVMovU32(&code, 3, limit);
  AppendVMovU32(&code, 5, 1);
  AppendVMovLiteral(&code, 6, guard);
  if (!gds) {
    // One lane initializes LDS before every wave in the workgroup uses it.
    code.push_back(EncodeSop1(0x04, 10, 126));
    code.push_back(EncodeVopc(0xc2, InlineU32(0), 0));
    code.push_back(EncodeSop1(0x04, 126, 106));
    code.push_back(EncodeDs0(0x0d, 4));
    code.push_back(EncodeDs1(0, 2, 2));
    code.push_back(EncodeSop1(0x04, 126, 10));
    code.push_back(EncodeSopp(0x0a, 0));
  }
  // Distinct masks in the wave64 halves also check inactive return
  // preservation.
  code.push_back(EncodeSop1(0x04, 10, 126));
  AppendSMovLiteral(&code, 126, 0x55555555u);
  AppendSMovLiteral(&code, 127, 0xaaaaaaaau);
  code.push_back(EncodeDs0(decrement ? 0x24 : 0x23, 4, gds));
  code.push_back(EncodeDs1(6, 3, 2));
  // Returned old values form a histogram; no lane ordering is assumed.
  code.push_back(EncodeVop2(0x1a, 7, InlineU32(2), 6));
  AppendBufferStoreOpcode(&code, 0x32, 5, 7);
  code.push_back(EncodeSop1(0x04, 126, 10));
  AppendVMovLiteral(&code, 7, guard);
  code.push_back(EncodeVopc(0xc2, Vgpr(7), 6));
  code.push_back(EncodeVop2(0x01, 8, InlineU32(0), 5));
  AppendStoreVgprAtLaneDwordOffset(&code, 8, 0, 16);
  code.push_back(EncodeSopp(0x0a, 0));
  // S_BARRIER orders LDS; use atomic add-zero to read GDS consistently.
  code.push_back(EncodeDs0(gds ? 0x20 : 0x36, 4, gds));
  code.push_back(EncodeDs1(9, 2, 2));
  AppendStoreVgprAtLaneDwordOffset(&code, 9, 0, 144);
  AppendEnd(&code);
  test.expected.assign(16, 4); // 64 active lanes, four complete wraps.
  for (u32 lane = 0; lane < 128; ++lane) {
    const uint64_t mask = 0xaaaaaaaa55555555ull;
    test.expected.push_back(
        (mask & (uint64_t{1} << (lane % wave_size))) == 0 ? 1 : 0);
  }
  test.expected.resize(272, 0);
  test.initial.resize(test.expected.size());
  test.compute_info.threads_num[0] = 128;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.wave_size = wave_size;
  test.compute_info.lds_size_dwords = 3;
  test.has_compute_info = true;
  test.opcodes = {O::S_MOV_B32,
                  O::S_MOV_B64,
                  O::S_BARRIER,
                  O::V_MOV_B32,
                  O::V_LSHLREV_B32,
                  O::V_ADD_NC_U32,
                  O::V_CMP_EQ_U32,
                  O::V_CNDMASK_B32,
                  decrement ? O::DS_DEC_RTN_U32 : O::DS_INC_RTN_U32,
                  gds ? O::DS_ADD_RTN_U32 : O::DS_READ_B32,
                  O::BUFFER_ATOMIC_ADD,
                  O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.required_spirv = {"OpAtomicLoad", "OpAtomicCompareExchange",
                         "OpLoopMerge"};
  if (gds) {
    test.gds_initial = {guard, 0, guard};
    test.expected_gds = test.gds_initial;
  } else
    test.opcodes.push_back(O::DS_WRITE_B32);
  return test;
}

TestCase DsMiscVariants() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 0, 0);
  AppendVMovU32(&code, 1, 0);
  AppendVMovLiteral(&code, 2, 0x40800000u);
  code.push_back(EncodeDs0(0x0d, 0));
  code.push_back(EncodeDs1(0, 2, 1));
  AppendVMovLiteral(&code, 3, 0x3f800000u);
  code.push_back(EncodeDs0(0x0d, 4));
  code.push_back(EncodeDs1(0, 3, 1));
  AppendVMovLiteral(&code, 4, 0x40000000u);
  code.push_back(EncodeDs0(0x12, 0));
  code.push_back(EncodeDs1(0, 4, 1));
  AppendVMovLiteral(&code, 5, 0x40400000u);
  code.push_back(EncodeDs0(0x13, 4));
  code.push_back(EncodeDs1(0, 5, 1));
  code.push_back(EncodeDs0(0x36, 0));
  code.push_back(EncodeDs1(6, 0, 1));
  code.push_back(EncodeDs0(0x36, 4));
  code.push_back(EncodeDs1(7, 0, 1));
  AppendVMovLiteral(&code, 8, 0x12345678u);
  code.push_back(EncodeDs0(0x35, 0x001f));
  code.push_back(EncodeDs1(9, 0, 8));
  code.push_back(EncodeSMovB32(124, InlineU32(0)));
  AppendVMovLiteral(&code, 10, 0xabcdef01u);
  code.push_back(EncodeDs0(0xb0, 8));
  code.push_back(EncodeDs1(0, 10, 0));
  code.push_back(EncodeDs0(0xb1, 8));
  code.push_back(EncodeDs1(11, 0, 0));

  const u32 results[] = {6, 7, 9, 11};
  for (u32 i = 0; i < static_cast<u32>(std::size(results)); i++) {
    AppendStoreVgpr(&code, results[i], i);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "DsMiscVariants";
  test.code = code;
  test.initial = std::vector<u32>(4, 0);
  test.expected = {0x40000000u, 0x40400000u, 0x12345678u, 0xabcdef01u};
  test.opcodes = {O::V_MOV_B32,
                  O::S_MOV_B32,
                  O::DS_WRITE_B32,
                  O::DS_MIN_F32,
                  O::DS_MAX_F32,
                  O::DS_READ_B32,
                  O::DS_SWIZZLE_B32,
                  O::DS_WRITE_ADDTID_B32,
                  O::DS_READ_ADDTID_B32,
                  O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.compute_info.threads_num[0] = 1;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.has_compute_info = true;
  return test;
}

TestCase DsFloatMinMaxUsesSeparateCompareOperand() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 1, 0);
  AppendVMovLiteral(&code, 2, 0x40800000u);
  code.push_back(EncodeDs0(0x0d, 0));
  code.push_back(EncodeDs1(0, 2, 1));
  AppendVMovLiteral(&code, 3, 0x40800000u);
  code.push_back(EncodeDs0(0x0d, 4));
  code.push_back(EncodeDs1(0, 3, 1));
  AppendVMovLiteral(&code, 4, 0x41100000u);
  AppendVMovLiteral(&code, 5, 0x40000000u);
  code.push_back(EncodeDs0(0x12, 0));
  code.push_back(EncodeDs1Ex(0, 5, 4, 1));
  AppendVMovLiteral(&code, 6, 0x3f800000u);
  AppendVMovLiteral(&code, 7, 0x40400000u);
  code.push_back(EncodeDs0(0x13, 4));
  code.push_back(EncodeDs1Ex(0, 7, 6, 1));
  code.push_back(EncodeDs0(0x36, 0));
  code.push_back(EncodeDs1(8, 0, 1));
  code.push_back(EncodeDs0(0x36, 4));
  code.push_back(EncodeDs1(9, 0, 1));
  AppendStoreVgpr(&code, 8, 0);
  AppendStoreVgpr(&code, 9, 1);
  AppendEnd(&code);

  TestCase test;
  test.name = "DsFloatMinMaxUsesSeparateCompareOperand";
  test.code = code;
  test.initial = std::vector<u32>(2, 0);
  test.expected = {0x41100000u, 0x3f800000u};
  test.opcodes = {O::V_MOV_B32,  O::DS_WRITE_B32, O::DS_MIN_F32,
                  O::DS_MAX_F32, O::DS_READ_B32,  O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.compute_info.threads_num[0] = 1;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.has_compute_info = true;
  return test;
}

TestCase DsSwizzleInvalidSourceLaneZero() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 1, 100);
  code.push_back(EncodeDs0(0x35, 0x00e0));
  code.push_back(EncodeDs1(2, 0, 1));
  code.push_back(EncodeVop2(0x1a, 3, InlineU32(2), 0));
  AppendBufferStoreDword(&code, 2, 3);
  AppendEnd(&code);

  TestCase test;
  test.name = "DsSwizzleInvalidSourceLaneZero";
  test.code = code;
  test.expected = {0, 0, 0, 0};
  test.opcodes = {O::V_MOV_B32, O::DS_SWIZZLE_B32, O::V_LSHLREV_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase DsBpermuteCapturedExecOffsetAndWrap() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeVop2(0x1a, 30, InlineU32(2), 0));
  AppendBufferLoadDword(&code, 17, 30);
  AppendVMovLiteral(&code, 1, 0xdeadbeefu);
  AppendVMovU32(&code, 3, 100);
  code.push_back(EncodeVop2(0x25, 3, Vgpr(0), 3));
  code.push_back(EncodeSop1(0x04, 4, 126));
  code.push_back(EncodeVop2(0x1b, 18, InlineU32(1), 0));
  code.push_back(EncodeVopc(0xc2, InlineU32(1), 18));
  code.push_back(EncodeSop1(0x04, 126, 106));
  code.push_back(0xdacc0000u);
  code.push_back(0x01000311u); // ds_bpermute_b32 v1, v17, v3
  code.push_back(EncodeSop1(0x04, 126, 4));
  AppendStoreVgprAtLaneDwordOffset(&code, 1, 0, 4);

  AppendVMovU32(&code, 17, 124);
  code.push_back(EncodeDs0(0xb3, 4));
  code.push_back(EncodeDs1(2, 3, 17));
  AppendStoreVgprAtLaneDwordOffset(&code, 2, 0, 8);
  AppendEnd(&code);

  TestCase test;
  test.name = "DsBpermuteCapturedExecOffsetAndWrap";
  test.code = code;
  test.initial = {0, 0, 12, 4, 0, 0, 0, 0, 0, 0, 0, 0};
  test.expected = {0,          0, 12,         4,
                   0xdeadbeefu, 0, 0xdeadbeefu, 101,
                   100,        100, 100,        100};
  test.opcodes = {O::V_LSHLREV_B32,     O::BUFFER_LOAD_DWORD,
                  O::V_MOV_B32,         O::V_ADD_NC_U32,
                  O::V_AND_B32,         O::V_CMP_EQ_U32,
                  O::S_MOV_B64,
                  O::DS_BPERMUTE_B32,   O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.required_spirv = {"OpGroupNonUniformShuffle",
                         "OpGroupNonUniformBallot"};
  test.forbidden_spirv = {" Workgroup", "OpControlBarrier",
                          "OpMemoryBarrier"};
  test.decoded_counts = {{"DS_BPERMUTE_B32", 2}};
  test.ir_counts = {{"BpermuteU32", 2}};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.wave_size = 32;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase DsBpermuteWave64UsesIndependentHalves() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 3, 100);
  code.push_back(EncodeVop2(0x25, 3, Vgpr(0), 3));
  AppendVMovU32(&code, 17, 128);
  code.push_back(0xdacc0000u);
  code.push_back(0x01000311u); // ds_bpermute_b32 v1, v17, v3
  AppendStoreVgprAtLaneDwordOffset(&code, 1, 0, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "DsBpermuteWave64UsesIndependentHalves";
  test.code = code;
  test.initial = std::vector<u32>(64, 0);
  test.expected = std::vector<u32>(32, 100);
  test.expected.insert(test.expected.end(), 32, 132);
  test.opcodes = {O::V_MOV_B32,       O::V_ADD_NC_U32,
                  O::DS_BPERMUTE_B32, O::V_LSHLREV_B32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.required_spirv = {"OpGroupNonUniformShuffle"};
  test.compute_info.threads_num[0] = 64;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.wave_size = 64;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase Wave64CrossHalfLaneAndLds() {
  using O = ShaderOpcode;
  std::vector<u32> code;
  AppendVMovU32(&code, 1, 100);
  code.push_back(EncodeVop2(0x25, 1, Vgpr(0), 1));
  AppendVop3(&code, 0x360, 8, Vgpr(1), InlineU32(47));
  AppendStoreSgprAtLaneDwordOffset(&code, 8, 0, 0);
  code.push_back(EncodeSop1(0x04, 10, 126));
  code.push_back(EncodeVop2(0x1b, 2, InlineU32(63), 0));
  code.push_back(EncodeVopc(0xc2, InlineU32(40), 2));
  code.push_back(EncodeSop1(0x04, 126, 106));
  code.push_back(EncodeVop1(0x02, 9, Vgpr(1)));
  code.push_back(EncodeSop1(0x04, 126, 10));
  AppendStoreSgprAtLaneDwordOffset(&code, 9, 0, 128);
  AppendStoreSgprAtLaneDwordOffset(&code, 106, 0, 256);
  AppendStoreSgprAtLaneDwordOffset(&code, 107, 0, 384);
  code.push_back(EncodeVop2(0x1a, 2, InlineU32(2), 0));
  code.push_back(EncodeDs0(0x0d));
  code.push_back(EncodeDs1(0, 1, 2));
  code.push_back(EncodeSopp(0x0a, 0));
  code.push_back(EncodeVop2(0x1d, 3, InlineU32(64), 0));
  code.push_back(EncodeVop2(0x1a, 3, InlineU32(2), 3));
  code.push_back(EncodeDs0(0x36));
  code.push_back(EncodeDs1(4, 0, 3));
  AppendStoreVgprAtLaneDwordOffset(&code, 4, 0, 512);
  AppendEnd(&code);

  TestCase test;
  test.name = "Wave64CrossHalfLaneAndLds";
  test.code = std::move(code);
  test.initial.resize(640);
  test.expected.insert(test.expected.end(), 64, 147);
  test.expected.insert(test.expected.end(), 64, 211);
  test.expected.insert(test.expected.end(), 64, 140);
  test.expected.insert(test.expected.end(), 64, 204);
  test.expected.insert(test.expected.end(), 128, 0);
  test.expected.insert(test.expected.end(), 128, 256);
  for (u32 lane = 0; lane < 128; lane++) {
    test.expected.push_back(100 + (lane ^ 64));
  }
  test.opcodes = {O::V_MOV_B32, O::V_ADD_NC_U32, O::V_READLANE_B32,
                  O::V_READFIRSTLANE_B32, O::V_CMP_EQ_U32, O::S_MOV_B64,
                  O::V_LSHLREV_B32, O::V_AND_B32, O::V_XOR_B32, O::DS_WRITE_B32,
                  O::S_BARRIER, O::DS_READ_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.required_spirv = {"OpGroupNonUniformBallot", "OpGroupNonUniformShuffle",
                         "OpControlBarrier"};
  test.ir_counts = {{"Barrier", 1}};
  test.compute_info.threads_num[0] = 128;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase Wave64RawMasksAndScalarBranch() {
  using O = ShaderOpcode;
  std::vector<u32> code;
  AppendVMovU32(&code, 1, 7);
  AppendSMovLiteral(&code, 8, 33u << 16u);
  code.push_back(EncodeSop2(0x29, 126, 193u, 8)); // captured ES BFE EXEC,-1,width
  AppendStoreVgprAtLaneDwordOffset(&code, 1, 0, 0);
  code.push_back(EncodeSop2(0x1f, 126, InlineU32(1), InlineU32(32)));
  const auto exec_branch = code.size();
  code.push_back(0);
  code.push_back(EncodeSopp(0x0a, 0));
  code.push_back(EncodeSop1(0x24, 10, 193u)); // s_and_saveexec_b64 s[10:11],-1
  const auto scc_branch = code.size();
  code.push_back(0);
  AppendVMovU32(&code, 1, 9);
  AppendStoreVgprAtLaneDwordOffset(&code, 1, 0, 64);
  const auto restore = code.size();
  code[exec_branch] = EncodeSopp(0x08, restore - exec_branch - 1);
  code[scc_branch] = EncodeSopp(0x04, restore - scc_branch - 1);
  code.push_back(EncodeSop1(0x04, 126, 193u));
  code.push_back(EncodeVopc(0xc2, Vgpr(0), 0));
  code.push_back(EncodeSop1(0x04, 12, 106));
  code.push_back(EncodeSMovB32(13, InlineU32(1)));
  AppendVop3(&code, 0x101, 2, InlineU32(0), InlineU32(11), 12);
  AppendStoreVgprAtLaneDwordOffset(&code, 2, 0, 128);
  code.push_back(EncodeSMovB32(127, InlineU32(1)));
  AppendVMovU32(&code, 3, 13);
  AppendStoreVgprAtLaneDwordOffset(&code, 3, 0, 192);
  code.push_back(EncodeSop1(0x04, 126, InlineU32(1)));
  AppendStoreVgprAtLaneDwordOffset(&code, 3, 0, 256);
  code.push_back(EncodeSMovB32(107, InlineU32(2)));
  code.push_back(EncodeSMovB32(127, 107));
  AppendStoreVgprAtLaneDwordOffset(&code, 1, 0, 320);
  AppendEnd(&code);

  TestCase test;
  test.name = "Wave64RawMasksAndScalarBranch";
  test.code = std::move(code);
  test.initial.assign(384, 0xdeadbeef);
  test.expected = test.initial;
  for (u32 lane = 0; lane < 64; lane++) {
    if (lane < 33) {
      test.expected[lane] = 7;
      test.expected[192 + lane] = 13;
    }
    test.expected[128 + lane] = lane < 33 ? 11 : 0;
  }
  test.expected[64 + 32] = 9;
  test.expected[256] = 13;
  test.expected[320] = 7;
  test.expected[320 + 33] = 7;
  test.opcodes = {O::V_MOV_B32, O::S_MOV_B32, O::S_BFE_U64, O::S_LSHL_B64,
                  O::S_CBRANCH_EXECZ, O::S_AND_SAVEEXEC_B64, O::S_CBRANCH_SCC0,
                  O::S_BARRIER, O::S_MOV_B64, O::V_CMP_EQ_U32, O::V_CNDMASK_B32,
                  O::V_LSHLREV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 64;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase Wave64PartialMultidimensionalWorkgroup() {
  using O = ShaderOpcode;
  std::vector<u32> code;
  code.push_back(EncodeVop2(0x25, 3, Vgpr(2), 2));
  code.push_back(EncodeVop2(0x25, 3, Vgpr(2), 3));
  code.push_back(EncodeVop2(0x25, 3, Vgpr(1), 3));
  code.push_back(EncodeVop2(0x1a, 3, InlineU32(3), 3));
  code.push_back(EncodeVop2(0x25, 3, Vgpr(0), 3));
  code.push_back(EncodeVop2(0x1a, 4, InlineU32(2), 3));
  AppendVMovU32(&code, 5, 1);
  AppendBufferStoreOpcode(&code, 0x32, 5, 4, false);
  AppendEnd(&code);
  TestCase test;
  test.name = "Wave64PartialMultidimensionalWorkgroup";
  test.code = std::move(code);
  test.initial.resize(128);
  test.expected.assign(96, 1);
  test.expected.resize(128);
  test.opcodes = {O::V_ADD_NC_U32, O::V_LSHLREV_B32, O::V_MOV_B32,
                  O::BUFFER_ATOMIC_ADD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 8;
  test.compute_info.threads_num[1] = 3;
  test.compute_info.threads_num[2] = 4;
  test.compute_info.thread_ids_num = 3;
  test.has_compute_info = true;
  return test;
}

TestCase Wave64AppendConsumeHighHalf() {
  using O = ShaderOpcode;
  std::vector<u32> code;
  AppendSMovLiteral(&code, 124, 4);
  code.push_back(EncodeSop2(0x1f, 126, 193u, InlineU32(32)));
  code.push_back(EncodeDs0(0x3e, 0, true));
  code.push_back(EncodeDs1(1, 0, 0));
  AppendStoreVgprAtLaneDwordOffset(&code, 1, 0, 0);
  code.push_back(EncodeDs0(0x3d, 0, true));
  code.push_back(EncodeDs1(2, 0, 0));
  AppendStoreVgprAtLaneDwordOffset(&code, 2, 0, 64);
  AppendEnd(&code);
  TestCase test;
  test.name = "Wave64AppendConsumeHighHalf";
  test.code = std::move(code);
  test.initial.assign(128, 0xdeadbeef);
  test.expected = test.initial;
  for (u32 lane = 32; lane < 64; lane++) {
    test.expected[lane] = 10;
    test.expected[64 + lane] = 42;
  }
  test.gds_initial = {10};
  test.expected_gds = {10};
  test.opcodes = {O::S_MOV_B32, O::S_LSHL_B64, O::DS_APPEND, O::DS_CONSUME,
                  O::V_LSHLREV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 64;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase BufferAtomicVariants() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  const u32 values[] = {100, 5, 3, 5, 5, 5, 20, 0x0ff0u, 0x0f00u, 0x00ffu};
  const u32 ops[] = {0x30, 0x32, 0x33, 0x35, 0x36,
                     0x37, 0x38, 0x39, 0x3a, 0x3b};
  for (u32 i = 0; i < static_cast<u32>(std::size(values)); i++) {
    AppendVMovU32(&code, 20, i * 4u);
    AppendVMovU32(&code, i, values[i]);
    AppendBufferStoreOpcode(&code, ops[i], i, 20, true);
  }
  for (u32 i = 0; i < static_cast<u32>(std::size(values)); i++) {
    AppendStoreVgpr(&code, i, i + 10u);
  }
  AppendEnd(&code);

  return {
      "BufferAtomicVariants",
      code,
      {10, 10, 10, 0xfffffff0u, 10, 0xfffffff0u, 10, 0xf0f0u, 0xf000u, 0xf00fu,
       0,  0,  0,  0,           0,  0,           0,  0,       0,       0},
      {100,     15,          7,       0xfffffff0u, 5,       5,      20,
       0x00f0u, 0xff00u,     0xf0f0u, 10,          10,      10,     0xfffffff0u,
       10,      0xfffffff0u, 10,      0xf0f0u,     0xf000u, 0xf00fu},
      {O::V_MOV_B32, O::BUFFER_ATOMIC_SWAP, O::BUFFER_ATOMIC_ADD,
       O::BUFFER_ATOMIC_SUB, O::BUFFER_ATOMIC_SMIN, O::BUFFER_ATOMIC_UMIN,
       O::BUFFER_ATOMIC_SMAX, O::BUFFER_ATOMIC_UMAX, O::BUFFER_ATOMIC_AND,
       O::BUFFER_ATOMIC_OR, O::BUFFER_ATOMIC_XOR, O::BUFFER_STORE_DWORD,
       O::S_ENDPGM}};
}

TestCase BufferAtomicCmpSwapExactRaw() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  const auto Store = [&](u32 value, u32 index) {
    AppendVMovU32(&code, 31, index * sizeof(u32));
    code.push_back(EncodeMubuf0(0x1cu));
    code.push_back(EncodeMubuf1(value, 8, 31));
  };
  AppendVMovU32(&code, 4, 1);
  AppendVMovLiteral(&code, 1, 0x22222222u);
  AppendVMovLiteral(&code, 2, 0x11111111u);
  code.push_back(0xe0c46000u);
  code.push_back(0x80080104u);
  Store(1, 2);

  AppendVMovLiteral(&code, 1, 0x33333333u);
  AppendVMovLiteral(&code, 2, 0x44444444u);
  code.push_back(0xe0c46000u);
  code.push_back(0x80080104u);
  Store(1, 3);
  Store(2, 4);

  AppendVMovLiteral(&code, 1, 0x55555555u);
  AppendVMovLiteral(&code, 2, 0x22222222u);
  code.push_back(EncodeMubuf0(0x31u, 0, true, false));
  code.push_back(0x80080104u);
  Store(1, 5);
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferAtomicCmpSwapExactRaw";
  test.code = std::move(code);
  test.initial = {0xaaaaaaaau, 0x11111111u, 0, 0, 0, 0};
  test.expected = {0xaaaaaaaau, 0x55555555u, 0x11111111u,
                   0x22222222u, 0x44444444u, 0x55555555u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_ATOMIC_CMPSWAP,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.required_spirv = {"OpAtomicCompareExchange"};
  const auto descriptor = MakeStructuredStorageBufferData(
      sizeof(u32), static_cast<u32>(test.initial.size()));
  std::copy_n(descriptor.begin(), 4, test.user_data.begin() + 32);
  test.has_user_data = true;
  return test;
}

TestCase BufferAtomicGlc0DoesNotReturnOldValue() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovU32(&code, 0, 5);
  AppendBufferStoreOpcode(&code, 0x32, 0, 20);
  AppendStoreVgpr(&code, 0, 1);
  AppendEnd(&code);

  return {
      "BufferAtomicGlc0DoesNotReturnOldValue",
      code,
      {10, 0},
      {15, 5},
      {O::V_MOV_B32, O::BUFFER_ATOMIC_ADD, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase BufferAtomicFMinExactRawGlcModes() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x40000000u); // 2.0
  code.push_back(0xe0fc0000u);
  code.push_back(0x80010000u); // exact failing buffer_atomic_fmin, GLC=0
  AppendStoreVgpr(&code, 0, 1);
  AppendVMovLiteral(&code, 0, 0x3f800000u); // 1.0
  code.push_back(0xe0fc4000u);
  code.push_back(0x80010000u); // same instruction with GLC=1
  AppendStoreVgpr(&code, 0, 2);
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferAtomicFMinExactRawGlcModes";
  test.code = code;
  test.initial = {0x40800000u, 0, 0}; // 4.0
  test.expected = {0x3f800000u, 0x40000000u, 0x40000000u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_ATOMIC_FMIN, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  const auto descriptor = MakeStructuredStorageBufferData(
      0, static_cast<u32>(test.initial.size() * sizeof(u32)));
  std::copy_n(descriptor.begin(), 4, test.user_data.begin() + 4);
  test.user_data[50] = 1u << 20u;
  test.has_user_data = true;
  return test;
}

TestCase BufferAtomicFMinSpecialValues() {
  using O = ShaderOpcode;

  const u32 values[] = {
      0x40000000u, // 2.0
      0x7f800000u, // +infinity
      0xff800000u, // -infinity
      0x3f800000u, // 1.0
      0x7fc00000u, // quiet NaN
      0x00000000u, // +0.0
      0x80000000u, // -0.0
      0x00000000u, // +0.0
      0x80000001u, // smallest negative denorm
  };
  std::vector<u32> code;
  for (u32 i = 0; i < static_cast<u32>(std::size(values)); i++) {
    AppendVMovU32(&code, 20, i * 4u);
    AppendVMovLiteral(&code, i, values[i]);
    AppendBufferStoreOpcode(&code, 0x3f, i, 20, true);
  }
  for (u32 i = 0; i < static_cast<u32>(std::size(values)); i++) {
    AppendStoreVgpr(&code, i, i + static_cast<u32>(std::size(values)));
  }
  AppendEnd(&code);

  return {"BufferAtomicFMinSpecialValues",
          code,
          {0x40800000u, 0xbf800000u, 0x7f800000u, 0x7fc00000u, 0x3f800000u,
           0x80000000u, 0x00000000u, 0x00000001u, 0x00000000u, 0, 0, 0, 0, 0, 0,
           0, 0, 0},
          {0x40000000u, 0xbf800000u, 0xff800000u, 0x7fc00000u, 0x3f800000u,
           0x80000000u, 0x00000000u, 0x00000000u, 0x80000001u, 0x40800000u,
           0xbf800000u, 0x7f800000u, 0x7fc00000u, 0x3f800000u, 0x80000000u,
           0x00000000u, 0x00000001u, 0x00000000u},
          {O::V_MOV_B32, O::BUFFER_ATOMIC_FMIN, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase BufferAtomicFMinContendedWorkgroup() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeVop1(0x06, 1, Vgpr(0))); // v_cvt_f32_u32 v1, thread_id.x
  AppendVMovU32(&code, 20, 0);
  AppendBufferStoreOpcode(&code, 0x3f, 1, 20);
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferAtomicFMinContendedWorkgroup";
  test.code = code;
  test.initial = {0x42c80000u};  // 100.0
  test.expected = {0x00000000u}; // min(100.0, 0.0 .. 63.0)
  test.opcodes = {O::V_CVT_F32_U32, O::V_MOV_B32, O::BUFFER_ATOMIC_FMIN,
                  O::S_ENDPGM};
  test.compute_info.threads_num[0] = 64;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

TestCase BufferAtomicFMaxExactRawGlcModes() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 3, 0x40000000u); // 2.0
  code.push_back(0xe100000cu);
  code.push_back(
      0x80010300u); // exact failing buffer_atomic_fmax v3, offset 12, GLC=0
  AppendStoreVgpr(&code, 3, 4);
  AppendVMovLiteral(&code, 0, 0x40800000u); // 4.0
  code.push_back(0xe100400cu);
  code.push_back(0x80010000u); // same address with GLC=1
  AppendStoreVgpr(&code, 0, 5);
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferAtomicFMaxExactRawGlcModes";
  test.code = code;
  test.initial = {0, 0, 0, 0x3f800000u, 0, 0}; // memory[3] = 1.0
  test.expected = {0, 0, 0, 0x40800000u, 0x40000000u, 0x40000000u};
  test.opcodes = {O::V_MOV_B32, O::BUFFER_ATOMIC_FMAX, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  const auto descriptor = MakeStructuredStorageBufferData(
      0, static_cast<u32>(test.initial.size() * sizeof(u32)));
  std::copy_n(descriptor.begin(), 4, test.user_data.begin() + 4);
  test.user_data[50] = 1u << 20u;
  test.has_user_data = true;
  return test;
}

TestCase BufferAtomicFMaxSpecialValues() {
  using O = ShaderOpcode;

  const u32 values[] = {
      0x40000000u, // 2.0, finite update
      0x40000000u, // 2.0, finite no-update
      0x7f800000u, // incoming +infinity
      0xff800000u, // incoming -infinity
      0x3f800000u, // finite against old +infinity
      0x3f800000u, // finite against old -infinity
      0x3f800000u, // finite against old quiet NaN
      0x7fcabcdeu, // incoming quiet NaN
      0x3f800000u, // finite against old signaling NaN
      0x7faabcdeu, // incoming signaling NaN
      0x00000000u, // +0.0 against old -0.0
      0x80000000u, // -0.0 against old +0.0
      0x80000000u, // -0.0 against a negative denorm
      0x80000001u, // negative denorm against -0.0
      0x00000001u, // positive denorm against +0.0
      0x00000000u, // +0.0 against a positive denorm
  };
  std::vector<u32> code;
  for (u32 i = 0; i < static_cast<u32>(std::size(values)); i++) {
    AppendVMovU32(&code, 20, i * 4u);
    AppendVMovLiteral(&code, i, values[i]);
    AppendBufferStoreOpcode(&code, 0x40, i, 20, true);
  }
  for (u32 i = 0; i < static_cast<u32>(std::size(values)); i++) {
    AppendStoreVgpr(&code, i, i + static_cast<u32>(std::size(values)));
  }
  AppendEnd(&code);

  return {"BufferAtomicFMaxSpecialValues",
          code,
          {0x3f800000u, 0x40800000u, 0xbf800000u, 0x3f800000u,
           0x7f800000u, 0xff800000u, 0x7fc12345u, 0x3f800000u,
           0x7fa54321u, 0x3f800000u, 0x80000000u, 0x00000000u,
           0x80000001u, 0x80000000u, 0x00000000u, 0x00000001u,
           0,           0,           0,           0,
           0,           0,           0,           0,
           0,           0,           0,           0,
           0,           0,           0,           0},
          {0x40000000u, 0x40800000u, 0x7f800000u, 0x3f800000u, 0x7f800000u,
           0x3f800000u, 0x7fc12345u, 0x3f800000u, 0x7fa54321u, 0x3f800000u,
           0x80000000u, 0x00000000u, 0x80000000u, 0x80000000u, 0x00000001u,
           0x00000001u, 0x3f800000u, 0x40800000u, 0xbf800000u, 0x3f800000u,
           0x7f800000u, 0xff800000u, 0x7fc12345u, 0x3f800000u, 0x7fa54321u,
           0x3f800000u, 0x80000000u, 0x00000000u, 0x80000001u, 0x80000000u,
           0x00000000u, 0x00000001u},
          {O::V_MOV_B32, O::BUFFER_ATOMIC_FMAX, O::BUFFER_STORE_DWORD,
           O::S_ENDPGM}};
}

TestCase BufferAtomicFMaxContendedWorkgroup() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeVop1(0x06, 1, Vgpr(0))); // v_cvt_f32_u32 v1, thread_id.x
  AppendVMovU32(&code, 20, 0);
  AppendBufferStoreOpcode(&code, 0x40, 1, 20);
  AppendEnd(&code);

  TestCase test;
  test.name = "BufferAtomicFMaxContendedWorkgroup";
  test.code = code;
  test.initial = {0xc2c80000u};  // -100.0
  test.expected = {0x427c0000u}; // max(-100.0, 0.0 .. 63.0)
  test.opcodes = {O::V_CVT_F32_U32, O::V_MOV_B32, O::BUFFER_ATOMIC_FMAX,
                  O::S_ENDPGM};
  test.compute_info.threads_num[0] = 64;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  return test;
}

std::vector<u32> MakeRgbaImage(u32 width, u32 height, u32 value = 0) {
  return std::vector<u32>(static_cast<size_t>(width) * height * 4u, value);
}

void SetRgbaPixel(std::vector<u32> *image, u32 width, u32 x, u32 y, u32 r,
                  u32 g, u32 b, u32 a) {
  const auto base = static_cast<size_t>((y * width + x) * 4u);
  (*image)[base + 0] = r;
  (*image)[base + 1] = g;
  (*image)[base + 2] = b;
  (*image)[base + 3] = a;
}

TestCase ImageLoadVariants() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  AppendVMovU32(&code, 21, 1);
  AppendVMovU32(&code, 22, 0);
  AppendVMovU32(&code, 23, 0);
  code.push_back(EncodeMimg0(0x00, 0xf));
  code.push_back(EncodeMimg1(0, 20));
  code.push_back(EncodeMimg0(0x01, 0xf));
  code.push_back(EncodeMimg1(4, 20));
  AppendVMovU32(&code, 24, 0);
  code.push_back(EncodeMimg0(0x0e, 0x1));
  code.push_back(EncodeMimg1(8, 24));
  for (u32 i = 0; i < 9u; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  auto image = MakeRgbaImage(4, 4);
  SetRgbaPixel(&image, 4, 2, 1, 0x3f800000u, 0x40000000u, 0x40400000u,
               0x40800000u);

  TestCase test;
  test.name = "ImageLoadVariants";
  test.code = code;
  test.expected = {0x3f800000u, 0x40000000u, 0x40400000u,
                   0x40800000u, 0x3f800000u, 0x40000000u,
                   0x40400000u, 0x40800000u, 4};
  test.opcodes = {O::V_MOV_B32,          O::IMAGE_LOAD,
                  O::IMAGE_LOAD_MIP,     O::IMAGE_GET_RESINFO,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.sampled_image_rgba = image;
  return test;
}

TestCase DsAppendConsumeUsesEncodedLdsSelector() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendSMovLiteral(&code, 124, 0x0000ffffu);
  AppendVMovU32(&code, 1, 0);
  AppendVMovU32(&code, 2, 10);
  code.push_back(EncodeDs0(0x0d, 0));
  code.push_back(EncodeDs1(0, 2, 1));
  code.push_back(EncodeDs0(0x3e, 0));
  code.push_back(EncodeDs1(3, 0, 0));
  code.push_back(EncodeDs0(0x3d, 0));
  code.push_back(EncodeDs1(4, 0, 0));
  AppendSMovLiteral(&code, 124, 0);
  code.push_back(EncodeDs0(0x3e, 0));
  code.push_back(EncodeDs1(5, 0, 0));
  code.push_back(EncodeDs0(0x36, 0));
  code.push_back(EncodeDs1(6, 0, 1));
  AppendStoreVgpr(&code, 3, 0);
  AppendStoreVgpr(&code, 4, 1);
  AppendStoreVgpr(&code, 5, 2);
  AppendStoreVgpr(&code, 6, 3);
  AppendEnd(&code);

  return {"DsAppendConsumeLdsSelector",
          code,
          {},
          {10, 11, 0, 10},
          {O::S_MOV_B32, O::V_MOV_B32, O::DS_WRITE_B32, O::DS_READ_B32,
           O::DS_APPEND, O::DS_CONSUME, O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
}

TestCase DsAppendUsesEncodedGdsSelector() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendSMovLiteral(&code, 124, 0x00000008u);
  code.push_back(EncodeDs0(0x3e, 0, true));
  code.push_back(EncodeDs1(0, 0, 0));
  code.push_back(EncodeDs0(0x3d, 0, true));
  code.push_back(EncodeDs1(1, 0, 0));
  code.push_back(EncodeDs0(0x3e, 4, true));
  code.push_back(EncodeDs1(2, 0, 0));
  code.push_back(EncodeDs0(0x3d, 4, true));
  code.push_back(EncodeDs1(3, 0, 0));
  AppendSMovLiteral(&code, 124, 0x00080008u);
  code.push_back(EncodeDs0(0x3e, 4, true));
  code.push_back(EncodeDs1(4, 0, 0));
  code.push_back(EncodeDs0(0x3d, 4, true));
  code.push_back(EncodeDs1(5, 0, 0));
  AppendStoreVgpr(&code, 0, 0);
  AppendStoreVgpr(&code, 1, 1);
  AppendStoreVgpr(&code, 2, 2);
  AppendStoreVgpr(&code, 3, 3);
  AppendStoreVgpr(&code, 4, 4);
  AppendStoreVgpr(&code, 5, 5);
  AppendEnd(&code);

  TestCase test{"DsAppendGdsSelector",
                code,
                {},
                {10, 11, 20, 21, 40, 41},
                {O::S_MOV_B32, O::DS_APPEND, O::DS_CONSUME,
                 O::BUFFER_STORE_DWORD, O::S_ENDPGM}};
  test.gds_initial = {10, 20, 30, 40};
  test.expected_gds = {10, 20, 30, 40};
  return test;
}

TestCase DsGdsSubdwordAndAtomicWrites() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeVop1(0x01, 1, Vgpr(0)));
  code.push_back(EncodeVop2(0x25, 2, InlineU32(1), 0));
  code.push_back(EncodeDs0(0x1e, 0, true));
  code.push_back(EncodeDs1(0, 2, 1));
  code.push_back(EncodeVop2(0x1a, 8, InlineU32(1), 0));
  code.push_back(EncodeVop2(0x25, 8, InlineU32(12), 8));
  code.push_back(EncodeDs0(0x1f, 0, true));
  code.push_back(EncodeDs1(0, 2, 8));
  AppendVMovU32(&code, 3, 4);
  AppendVMovU32(&code, 4, 1);
  code.push_back(EncodeDs0(0x00, 0, true));
  code.push_back(EncodeDs1(0, 4, 3));
  AppendVMovU32(&code, 5, 8);
  AppendVMovLiteral(&code, 6, 0x40a00000u);
  AppendVMovLiteral(&code, 7, 0x40a00000u);
  code.push_back(EncodeDs0(0x12, 0, true));
  code.push_back(EncodeDs1Ex(0, 7, 6, 5));
  AppendEnd(&code);

  TestCase test;
  test.name = "DsGdsSubdwordAndAtomics";
  test.code = code;
  test.opcodes = {O::V_MOV_B32,   O::V_ADD_NC_U32, O::V_LSHLREV_B32,
                  O::DS_WRITE_B8, O::DS_WRITE_B16, O::DS_ADD_U32,
                  O::DS_MIN_F32,  O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.thread_ids_num = 1;
  test.has_compute_info = true;
  test.gds_initial = {0, 0, 0x42c80000u, 0, 0};
  test.expected_gds = {0x04030201u, 4, 0x40a00000u, 0x00020001u, 0x00040003u};
  return test;
}

TestCase ImageLoadR32UintUsesIntegerSampledImage() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  AppendVMovU32(&code, 21, 1);
  code.push_back(EncodeMimg0(0x00, 0x1));
  code.push_back(EncodeMimg1(0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageLoadR32UintUsesIntegerSampledImage";
  test.code = code;
  test.expected = {0xdeadbeefu};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_LOAD, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.sampled_image_rgba.resize(16);
  test.sampled_image_rgba[6] = 0xdeadbeefu;
  test.sampled_image_format = vk::Format::eR32Uint;
  test.sampled_image_dwords_per_pixel = 1;
  test.user_data = MakeSampledTextureData(Prospero::BufferFormat::k32UInt);
  test.has_user_data = true;
  test.required_spirv = {"image_10", "OpTypeImage %uint",
                         "OpImageFetch %v4uint"};
  return test;
}

TestCase ImageLoadFmaskUsesNativeSampleMapping() {
  auto test = ImageLoadR32UintUsesIntegerSampledImage();
  test.name = "ImageLoadFmaskUsesNativeSampleMapping";
  test.expected = {0x76543210u};
  test.user_data = {0x303ac300u, 0xca100000u, 0x021bc3bfu, 0x91800004u,
                    0u, 0x00700000u, 0u, 0u};
  test.image_descriptor_swizzle = DstSel(4, 0, 0, 0);
  test.sampled_image_rgba.clear();
  test.required_spirv = {"OpConstant %uint 1985229328"};
  test.forbidden_spirv = {"OpTypeImage", "OpImageFetch"};
  return test;
}

TestCase ImageLoadR32SintUsesSignedSampledImage() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  AppendVMovU32(&code, 21, 1);
  code.push_back(EncodeMimg0(0x00, 0x1));
  code.push_back(EncodeMimg1(0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageLoadR32SintUsesSignedSampledImage";
  test.code = code;
  test.expected = {0xffffff80u};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_LOAD, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.sampled_image_rgba.resize(16);
  test.sampled_image_rgba[6] = 0xffffff80u;
  test.sampled_image_format = vk::Format::eR32Sint;
  test.sampled_image_dwords_per_pixel = 1;
  test.user_data = MakeSampledTextureData(Prospero::BufferFormat::k32SInt);
  test.has_user_data = true;
  test.required_spirv = {"image_17", "OpTypeImage %int", "OpImageFetch %v4int",
                         "OpBitcast %uint"};
  return test;
}

TestCase ImageLoadPackedUintUnpacksAndSwizzles() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  AppendVMovU32(&code, 21, 1);
  code.push_back(EncodeMimg0(0x00, 0xf));
  code.push_back(EncodeMimg1(0, 20));
  for (u32 component = 0; component < 4; component++) {
    AppendStoreVgpr(&code, component, component);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageLoadPackedUintUnpacksAndSwizzles";
  test.code = std::move(code);
  test.expected = {0x2abu, 0x456u, 0x321u, 0x321u};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_LOAD, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.sampled_image_rgba.resize(16);
  test.sampled_image_rgba[6] = 0xaae2b321u;
  test.sampled_image_format = vk::Format::eR32Uint;
  test.sampled_image_dwords_per_pixel = 1;
  test.user_data =
      MakeSampledTextureData(Prospero::BufferFormat::k11_11_10UInt);
  test.has_user_data = true;
  test.image_descriptor_swizzle = DstSel(6, 5, 4, 7);
  test.required_spirv = {"OpImageFetch %v4uint", "OpBitFieldUExtract"};
  return test;
}

TestCase ImageSamplePackedUintConvertsSampleAndGather() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 20, 0x3f200000u);
  AppendVMovLiteral(&code, 21, 0x3ec00000u);
  code.push_back(EncodeMimg0(0x20, 0xf));
  code.push_back(EncodeMimg1(0, 20));
  code.push_back(EncodeMimg0(0x47, 0x2));
  code.push_back(EncodeMimg1(4, 20));
  for (u32 component = 0; component < 8; component++) {
    AppendStoreVgpr(&code, component, component);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageSamplePackedUintConvertsSampleAndGather";
  test.code = std::move(code);
  test.expected = {0x2abu, 0x456u, 0x321u, 0x321u,
                   0x456u, 0x456u, 0x456u, 0x456u};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_SAMPLE, O::IMAGE_GATHER4_LZ,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.sampled_image_rgba = std::vector<u32>(16, 0xaae2b321u);
  test.sampled_image_format = vk::Format::eR32Uint;
  test.sampled_image_dwords_per_pixel = 1;
  test.user_data =
      MakeSampledTextureData(Prospero::BufferFormat::k11_11_10UInt);
  test.has_user_data = true;
  test.image_descriptor_swizzle = DstSel(6, 5, 4, 7);
  test.expected_force_point_sampler = true;
  test.required_spirv = {"OpImageSampleExplicitLod", "OpImageGather",
                         "OpBitFieldUExtract"};
  return test;
}

TestCase ImageLoadR128IgnoresAdjacentMaskSgprs() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  AppendVMovU32(&code, 21, 1);
  code.push_back(EncodeSop1(0x04, 4, 126)); // s_mov_b64 s[4:5], exec
  code.push_back(EncodeMimg0(0x00, 0x1, 0, false, 1, true));
  code.push_back(EncodeMimg1(0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageLoadR128IgnoresAdjacentMaskSgprs";
  test.code = code;
  test.expected = {0xdeadbeefu};
  test.opcodes = {O::V_MOV_B32, O::S_MOV_B64, O::IMAGE_LOAD,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.sampled_image_rgba.resize(16);
  test.sampled_image_rgba[6] = 0xdeadbeefu;
  test.sampled_image_format = vk::Format::eR32Uint;
  test.sampled_image_dwords_per_pixel = 1;
  test.user_data = MakeSampledTextureData(Prospero::BufferFormat::k32UInt);
  test.has_user_data = true;
  test.decoded_counts = {{"r128=1", 1}};
  return test;
}

TestCase ImageLoad1DUsesScalarCoordinate() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  code.push_back(EncodeMimg0(0x00, 0x1, 0, false, 0));
  code.push_back(EncodeMimg1(0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageLoad1DUsesScalarCoordinate";
  test.code = code;
  test.expected = {0xdeadbeefu};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_LOAD, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.image_width = 4;
  test.image_height = 1;
  test.sampled_image_rgba = {0, 0, 0xdeadbeefu, 0};
  test.sampled_image_format = vk::Format::eR32Uint;
  test.sampled_image_dwords_per_pixel = 1;
  test.sampled_image_type = vk::ImageType::e1D;
  test.sampled_image_view_type = vk::ImageViewType::e1D;
  test.user_data = MakeSampledTextureData(Prospero::BufferFormat::k32UInt);
  test.user_data[3] = static_cast<uint32_t>(Prospero::ImageType::kColor1D)
                      << 28u;
  test.has_user_data = true;
  test.required_spirv = {"image_8"};
  return test;
}

TestCase ImageGather2DInstructionWith1DDescriptor() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 20, 0x3f000000u);
  AppendVMovLiteral(&code, 21, 0x3f000000u);
  code.push_back(EncodeMimg0(0x47, 0x1));
  code.push_back(EncodeMimg1(0, 20));
  for (u32 i = 0; i < 4u; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  auto image = MakeRgbaImage(4, 1);
  SetRgbaPixel(&image, 4, 1, 0, 0x40000000u, 0, 0, 0);
  SetRgbaPixel(&image, 4, 2, 0, 0x40400000u, 0, 0, 0);

  TestCase test;
  test.name = "ImageGather2DInstructionWith1DDescriptor";
  test.code = code;
  test.expected = {0x40000000u, 0x40400000u, 0x40400000u, 0x40000000u};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_GATHER4_LZ, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.image_width = 4;
  test.image_height = 1;
  test.sampled_image_rgba = image;
  test.sampled_image_type = vk::ImageType::e1D;
  test.sampled_image_view_type = vk::ImageViewType::e1D;
  test.user_data = MakeSampledTextureData(Prospero::BufferFormat::k32Float);
  test.user_data[3] = static_cast<uint32_t>(Prospero::ImageType::kColor1D)
                      << 28u;
  test.has_user_data = true;
  test.required_spirv = {"image_1", "OpImageQuerySizeLod",
                         "OpImageSampleExplicitLod", "Floor"};
  test.forbidden_spirv = {"OpImageGather"};
  return test;
}

TestCase ImageLoad1DArrayUsesLayerCoordinate() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  AppendVMovU32(&code, 21, 1);
  code.push_back(EncodeMimg0(0x00, 0x1, 0, false, 4));
  code.push_back(EncodeMimg1(0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageLoad1DArrayUsesLayerCoordinate";
  test.code = code;
  test.expected = {0xcafebabeu};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_LOAD, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.image_width = 4;
  test.image_height = 1;
  test.sampled_image_rgba = {0, 0, 0, 0, 0, 0, 0xcafebabeu, 0};
  test.sampled_image_format = vk::Format::eR32Uint;
  test.sampled_image_dwords_per_pixel = 1;
  test.sampled_image_type = vk::ImageType::e1D;
  test.sampled_image_view_type = vk::ImageViewType::e1DArray;
  test.sampled_image_layers = 2;
  test.user_data = MakeSampledTextureData(Prospero::BufferFormat::k32UInt);
  test.user_data[3] = static_cast<uint32_t>(Prospero::ImageType::kColor1DArray)
                      << 28u;
  test.has_user_data = true;
  test.required_spirv = {"image_9"};
  return test;
}

TestCase ImageLoad1DArrayDescriptorUsesSelectedLayer() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  code.push_back(EncodeMimg0(0x00, 0x1, 0, false, 0));
  code.push_back(EncodeMimg1(0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageLoad1DArrayDescriptorUsesSelectedLayer";
  test.code = code;
  test.expected = {0xcafebabeu};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_LOAD, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.image_width = 4;
  test.image_height = 1;
  test.sampled_image_rgba = {
      0, 0, 0xdeadbeefu, 0, 0, 0, 0xcafebabeu, 0,
  };
  test.sampled_image_format = vk::Format::eR32Uint;
  test.sampled_image_dwords_per_pixel = 1;
  test.sampled_image_type = vk::ImageType::e1D;
  test.sampled_image_view_type = vk::ImageViewType::e1D;
  test.sampled_image_layers = 2;
  test.sampled_image_view_base_layer = 1;
  test.sampled_image_view_layers = 1;
  test.user_data = MakeSampledTextureData(Prospero::BufferFormat::k32UInt);
  test.user_data[3] = static_cast<uint32_t>(Prospero::ImageType::kColor1DArray)
                      << 28u;
  test.user_data[4] = 1u | (1u << 16u);
  test.has_user_data = true;
  test.required_spirv = {"image_8"};
  return test;
}

TestCase ImageLoadMipUsesVaddr2Lod2D() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 1);
  AppendVMovU32(&code, 21, 1);
  AppendVMovU32(&code, 22, 1);
  AppendVMovU32(&code, 23, 0);
  code.push_back(EncodeMimg0(0x01, 0x1));
  code.push_back(EncodeMimg1(0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  auto base = MakeRgbaImage(4, 4);
  SetRgbaPixel(&base, 4, 1, 1, 0x3f800000u, 0, 0, 0);
  auto mip1 = MakeRgbaImage(2, 2);
  SetRgbaPixel(&mip1, 2, 1, 1, 0x40000000u, 0, 0, 0);

  TestCase test;
  test.name = "ImageLoadMipUsesVaddr2Lod2D";
  test.code = code;
  test.expected = {0x40000000u};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_LOAD_MIP, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.sampled_image_rgba_mips = {base, mip1};
  return test;
}

TestCase ImageLoadMipNsaUsesSelectedAddressVgprs() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 1);
  AppendVMovU32(&code, 21, 0);
  AppendVMovU32(&code, 22, 0);
  AppendVMovU32(&code, 30, 1);
  AppendVMovU32(&code, 31, 1);
  code.push_back(EncodeMimg0(0x01, 0x1, 1));
  code.push_back(EncodeMimg1(0, 20));
  code.push_back((30u << 0u) | (31u << 8u));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  auto base = MakeRgbaImage(4, 4);
  SetRgbaPixel(&base, 4, 1, 0, 0x3f800000u, 0, 0, 0);
  auto mip1 = MakeRgbaImage(2, 2);
  SetRgbaPixel(&mip1, 2, 1, 1, 0x40a00000u, 0, 0, 0);

  TestCase test;
  test.name = "ImageLoadMipNsaUsesSelectedAddressVgprs";
  test.code = code;
  test.expected = {0x40a00000u};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_LOAD_MIP, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.sampled_image_rgba_mips = {base, mip1};
  return test;
}

TestCase ImageLoadA16UintCoordsOnGpu() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 20, 0x00010002u); // x=2, y=1 packed as u16.
  AppendVMovU32(&code, 21, 0);
  code.push_back(EncodeMimg0(0x00, 0xf));
  code.push_back(EncodeMimg1(0, 20, 0, 0, true));
  for (u32 i = 0; i < 4u; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  auto image = MakeRgbaImage(4, 4);
  SetRgbaPixel(&image, 4, 2, 1, 0x3f800000u, 0x40000000u, 0x40400000u,
               0x40800000u);

  TestCase test;
  test.name = "ImageLoadA16UintCoordsOnGpu";
  test.code = code;
  test.expected = {0x3f800000u, 0x40000000u, 0x40400000u, 0x40800000u};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_LOAD, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.sampled_image_rgba = image;
  test.required_spirv = {"OpShiftRightLogical", "OpBitwiseAnd"};
  test.forbidden_spirv = {"UnpackHalf2x16"};
  return test;
}

TestCase ImageGetResinfoDmaskWidthHeight() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 24, 0);
  code.push_back(EncodeMimg0(0x0e, 0x3));
  code.push_back(EncodeMimg1(0, 24));
  AppendStoreVgpr(&code, 0, 0);
  AppendStoreVgpr(&code, 1, 1);
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageGetResinfoDmaskWidthHeight";
  test.code = code;
  test.expected = {4, 2};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_GET_RESINFO, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.image_width = 4;
  test.image_height = 2;
  test.sampled_image_rgba = MakeRgbaImage(test.image_width, test.image_height);
  return test;
}

TestCase ImageGetResinfoDmaskMipLevels() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 24, 0);
  code.push_back(EncodeMimg0(0x0e, 0x8));
  code.push_back(EncodeMimg1(0, 24));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageGetResinfoDmaskMipLevels";
  test.code = code;
  test.expected = {2};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_GET_RESINFO, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  auto base = MakeRgbaImage(4, 4);
  auto mip1 = MakeRgbaImage(2, 2);
  test.sampled_image_rgba_mips = {base, mip1};
  return test;
}

TestCase ImageSampleAndGather() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 20, 0x3f200000u);
  AppendVMovLiteral(&code, 21, 0x3ec00000u);
  AppendVMovU32(&code, 22, 0);
  code.push_back(EncodeMimg0(0x20, 0xf));
  code.push_back(EncodeMimg1(0, 20));
  code.push_back(EncodeMimg0(0x47, 0x1));
  code.push_back(EncodeMimg1(4, 20));
  AppendVMovU32(&code, 24, 0);
  AppendVMovLiteral(&code, 25, 0x3f200000u);
  AppendVMovLiteral(&code, 26, 0x3ec00000u);
  AppendVMovU32(&code, 27, 0);
  code.push_back(EncodeMimg0(0x57, 0x1));
  code.push_back(EncodeMimg1(8, 24));
  code.push_back(EncodeMimg0(0x60, 0x1));
  code.push_back(EncodeMimg1(12, 20));
  for (u32 i = 0; i < 13u; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  auto image = MakeRgbaImage(4, 4);
  for (u32 y = 0; y < 4u; y++) {
    for (u32 x = 0; x < 4u; x++) {
      SetRgbaPixel(&image, 4, x, y, 0x3f800000u, 0, 0, 0);
    }
  }
  SetRgbaPixel(&image, 4, 2, 1, 0x3f800000u, 0x40000000u, 0x40400000u,
               0x40800000u);

  TestCase test;
  test.name = "ImageSampleAndGather";
  test.code = code;
  test.expected = {0x3f800000u,
                   0x40000000u,
                   0x40400000u,
                   0x40800000u,
                   0x3f800000u,
                   0x3f800000u,
                   0x3f800000u,
                   0x3f800000u,
                   0x3f800000u,
                   0x3f800000u,
                   0x3f800000u,
                   0x3f800000u,
                   0};
  test.opcodes = {
      O::V_MOV_B32,        O::IMAGE_SAMPLE,       O::IMAGE_GET_LOD,
      O::IMAGE_GATHER4_LZ, O::IMAGE_GATHER4_LZ_O, O::BUFFER_STORE_DWORD,
      O::S_ENDPGM};
  test.sampled_image_rgba = image;
  return test;
}

TestCase ImageGatherLodApproximatesLevelZero() {
  using O = ShaderOpcode;
  std::vector<u32> code;
  AppendVMovLiteral(&code, 20, 0x3f000000u);
  AppendVMovLiteral(&code, 21, 0x3f000000u);
  AppendVMovLiteral(&code, 22, 0x3f800000u);
  code.push_back(EncodeMimg0(0x44, 0x1));
  code.push_back(EncodeMimg1(0, 20));
  code.push_back(EncodeMimg0(0x24, 0x1));
  code.push_back(EncodeMimg1(4, 20));
  for (u32 i = 0; i < 5u; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageGatherLodApproximatesLevelZero";
  test.code = std::move(code);
  test.opcodes = {O::V_MOV_B32, O::IMAGE_GATHER4_L, O::IMAGE_SAMPLE,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  // Explicit sampling proves mip 1 is accessible; the gather must still read mip 0.
  test.expected = {0x3f800000u, 0x3f800000u, 0x3f800000u, 0x3f800000u, 0x41000000u};
  test.sampled_image_rgba_mips = {std::vector<u32>(4 * 4 * 4, 0x3f800000u),
                                 std::vector<u32>(2 * 2 * 4, 0x41000000u)};
  test.required_spirv = {"OpImageGather", "OpImageSampleExplicitLod"};
  return test;
}

TestCase ImageD16GatherPacksHalfPairs() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 20, 0x3f000000u);
  AppendVMovLiteral(&code, 21, 0x3f000000u);
  AppendVMovU32(&code, 22, 0);
  code.push_back(EncodeMimg0(0x47, 0x1));
  code.push_back(EncodeMimg1(0, 20, 0, 0, false, true));
  AppendStoreVgpr(&code, 0, 0);
  AppendStoreVgpr(&code, 1, 1);
  AppendEnd(&code);

  auto image = MakeRgbaImage(4, 4);
  for (u32 y = 0; y < 4u; y++) {
    for (u32 x = 0; x < 4u; x++) {
      SetRgbaPixel(&image, 4, x, y, 0x3f000000u, 0, 0, 0);
    }
  }

  TestCase test;
  test.name = "ImageD16GatherPacksHalfPairs";
  test.code = code;
  test.expected = {0x38003800u, 0x38003800u};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_GATHER4_LZ, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.sampled_image_rgba = image;
  test.decoded_counts = {{"d16=1", 1}};
  test.required_spirv = {"OpImageGather", "PackHalf2x16"};
  return test;
}

TestCase ImageSampleA16SamplerCoordsOnGpu() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 20, 0x36003900u); // x=0.625, y=0.375 packed as f16.
  AppendVMovU32(&code, 21, 0);
  code.push_back(EncodeMimg0(0x20, 0xf));
  code.push_back(EncodeMimg1(0, 20, 0, 0, true));
  for (u32 i = 0; i < 4u; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  auto image = MakeRgbaImage(4, 4);
  SetRgbaPixel(&image, 4, 2, 1, 0x3f800000u, 0x40000000u, 0x40400000u,
               0x40800000u);

  TestCase test;
  test.name = "ImageSampleA16SamplerCoordsOnGpu";
  test.code = code;
  test.expected = {0x3f800000u, 0x40000000u, 0x40400000u, 0x40800000u};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_SAMPLE, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.sampled_image_rgba = image;
  test.required_spirv = {"UnpackHalf2x16"};
  return test;
}

TestCase ImageSampleOpcodeAliasUsesNormalCoords() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 2, 0x3f000000u);
  AppendVMovLiteral(&code, 3, 0x3f000000u);
  code.push_back(0xf0800109u); // observed image_sample_a v6, v2, s0, s24
  code.push_back(0x00c00602u);
  AppendStoreVgpr(&code, 6, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageSampleOpcodeAliasUsesNormalCoords";
  test.code = code;
  test.opcodes = {O::V_MOV_B32, O::IMAGE_SAMPLE, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.required_spirv = {"OpImageSampleExplicitLod"};
  test.forbidden_spirv = {"UnpackHalf2x16"};
  test.compile_only = true;
  return test;
}

TestCase ImageSampleA16OffsetKeepsTexelOffset32BitOnGpu() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20,
                1); // Non-constant +1 X offset is not a SPIR-V ConstOffset.
  AppendVMovLiteral(&code, 21, 0x36003900u); // x=0.625, y=0.375 packed as f16.
  AppendVMovU32(&code, 22, 0);
  code.push_back(EncodeMimg0(0x30, 0xf));
  code.push_back(EncodeMimg1(0, 20, 0, 0, true));
  for (u32 i = 0; i < 4u; i++) {
    AppendStoreVgpr(&code, i, i);
  }
  AppendEnd(&code);

  auto image = MakeRgbaImage(4, 4);
  SetRgbaPixel(&image, 4, 2, 1, 0x3f800000u, 0x40000000u, 0x40400000u,
               0x40800000u);

  TestCase test;
  test.name = "ImageSampleA16OffsetKeepsTexelOffset32BitOnGpu";
  test.code = code;
  test.expected = {0x3f800000u, 0x40000000u, 0x40400000u, 0x40800000u};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_SAMPLE, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.sampled_image_rgba = image;
  test.required_spirv = {"UnpackHalf2x16"};
  test.forbidden_spirv = {"OpBitFieldSExtract"};
  return test;
}

TestCase ImageSampleA16CompareBiasRdna2AddressOrder() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 20, 0x00003800u); // bias=0.5 as low f16.
  AppendVMovLiteral(&code, 21, 0x3f000000u); // PCF reference stays 32-bit.
  AppendVMovLiteral(&code, 22, 0x36003900u); // x=0.625, y=0.375 packed as f16.
  code.push_back(EncodeMimg0(0x2d, 0x1));
  code.push_back(EncodeMimg1(0, 20, 0, 0, true));
  AppendStoreVgpr(&code, 0, 0);
  // Ordinary and comparison reads of one sharp require distinct SPIR-V image types.
  code.push_back(EncodeMimg0(0x27, 0x1));
  code.push_back(EncodeMimg1(1, 22, 0, 0, true));
  AppendStoreVgpr(&code, 1, 1);
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageSampleA16CompareBiasRdna2AddressOrder";
  test.code = code;
  test.opcodes = {O::V_MOV_B32, O::IMAGE_SAMPLE, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.required_spirv = {"OpTypeImage %float 2D 0", "OpTypeImage %float 2D 1",
                         "OpImageSampleDrefExplicitLod", "OpImageSampleExplicitLod",
                         "UnpackHalf2x16"};
  test.compile_only = true;
  return test;
}

TestCase ImageGatherCompareOpcodes() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovLiteral(&code, 21, 0x3f000000u);
  AppendVMovLiteral(&code, 22, 0x3f200000u);
  AppendVMovLiteral(&code, 23, 0x3ec00000u);
  AppendVMovLiteral(&code, 24, 0x3f000000u);
  AppendVMovLiteral(&code, 25, 0x3f200000u);
  AppendVMovLiteral(&code, 26, 0x3ec00000u);
  AppendVMovLiteral(&code, 28, 0x3f000000u);
  AppendVMovLiteral(&code, 29, 0x3f200000u);
  AppendVMovLiteral(&code, 30, 0x3ec00000u);
  AppendVMovU32(&code, 32, 0);
  AppendVMovLiteral(&code, 33, 0x3f000000u);
  AppendVMovLiteral(&code, 34, 0x3f200000u);
  AppendVMovLiteral(&code, 35, 0x3ec00000u);
  code.push_back(EncodeMimg0(0x48, 0x1));
  code.push_back(EncodeMimg1(4, 24));
  code.push_back(EncodeMimg0(0x4f, 0x1));
  code.push_back(EncodeMimg1(8, 28));
  code.push_back(EncodeMimg0(0x58, 0x1));
  code.push_back(EncodeMimg1(0, 20));
  code.push_back(EncodeMimg0(0x5f, 0x1));
  code.push_back(EncodeMimg1(12, 32));
  AppendStoreVgpr(&code, 4, 0);
  AppendStoreVgpr(&code, 8, 1);
  AppendStoreVgpr(&code, 0, 2);
  AppendStoreVgpr(&code, 12, 3);
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageGatherCompareOpcodes";
  test.code = code;
  test.opcodes = {
      O::V_MOV_B32,         O::IMAGE_GATHER4_C,      O::IMAGE_GATHER4_C_LZ,
      O::IMAGE_GATHER4_C_O, O::IMAGE_GATHER4_C_LZ_O, O::BUFFER_STORE_DWORD,
      O::S_ENDPGM};
  test.required_spirv = {"OpImageDrefGather", "OpBitFieldSExtract"};
  test.compile_only = true;
  return test;
}

TestCase ImageStoreVariants() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 1);
  AppendVMovU32(&code, 21, 2);
  AppendVMovU32(&code, 22, 0);
  AppendVMovLiteral(&code, 0, 0x3f800000u);
  AppendVMovLiteral(&code, 1, 0x40000000u);
  AppendVMovLiteral(&code, 2, 0x40400000u);
  AppendVMovLiteral(&code, 3, 0x40800000u);
  code.push_back(EncodeMimg0(0x08, 0xf));
  code.push_back(EncodeMimg1(0, 20));
  AppendVMovU32(&code, 24, 3);
  AppendVMovU32(&code, 25, 2);
  AppendVMovU32(&code, 26, 0);
  AppendVMovU32(&code, 27, 0);
  AppendVMovLiteral(&code, 4, 0x40a00000u);
  AppendVMovLiteral(&code, 5, 0x40c00000u);
  AppendVMovLiteral(&code, 6, 0x40e00000u);
  AppendVMovLiteral(&code, 7, 0x41000000u);
  code.push_back(EncodeMimg0(0x09, 0xf));
  code.push_back(EncodeMimg1(4, 24));
  AppendVMovLiteral(&code, 8, 0x12345678u);
  AppendStoreVgpr(&code, 8, 0);
  AppendEnd(&code);

  auto expected_image = MakeRgbaImage(4, 4);
  SetRgbaPixel(&expected_image, 4, 1, 2, 0x3f800000u, 0x40000000u, 0x40400000u,
               0x40800000u);
  SetRgbaPixel(&expected_image, 4, 3, 2, 0x40a00000u, 0x40c00000u, 0x40e00000u,
               0x41000000u);

  TestCase test;
  test.name = "ImageStoreVariants";
  test.code = code;
  test.expected = {0x12345678u};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_STORE, O::IMAGE_STORE_MIP,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.storage_image_rgba = MakeRgbaImage(4, 4);
  test.storage_image_r32ui = std::vector<u32>(16, 0);
  test.expected_storage_image_rgba = expected_image;
  return test;
}

TestCase ImageD16StoreUnpacksHalfPairs() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 1);
  AppendVMovU32(&code, 21, 2);
  AppendVMovU32(&code, 22, 0);
  AppendVMovLiteral(&code, 0, 0x38003400u);
  AppendVMovLiteral(&code, 1, 0x3c003a00u);
  code.push_back(EncodeMimg0(0x08, 0xf));
  code.push_back(EncodeMimg1(0, 20, 0, 0, false, true));
  AppendEnd(&code);

  auto expected_image = MakeRgbaImage(4, 4);
  SetRgbaPixel(&expected_image, 4, 1, 2, 0x3e800000u, 0x3f000000u, 0x3f400000u,
               0x3f800000u);

  TestCase test;
  test.name = "ImageD16StoreUnpacksHalfPairs";
  test.code = code;
  test.opcodes = {O::V_MOV_B32, O::IMAGE_STORE, O::S_ENDPGM};
  test.storage_image_rgba = MakeRgbaImage(4, 4);
  test.expected_storage_image_rgba = expected_image;
  test.decoded_counts = {{"d16=1", 1}};
  test.required_spirv = {"UnpackHalf2x16", "OpImageWrite"};
  return test;
}

void CheckIndirectImageKeySwitch() {
  constexpr const char *name = "IndirectImageKeySwitch";
  constexpr uint32_t mapping_capacity = 1793u;
  using namespace ShaderRecompiler::IR;

  Program program{};
  program.stage = ShaderType::Compute;
  program.wave_size = 32;
  program.srt_plan_complete = true;
  program.resource_tracking_complete = true;
  program.shader_info_complete = true;
  program.block_storage.push_back(std::make_unique<Block>());
  auto *block = program.block_storage.back().get();
  program.blocks.push_back(block);
  program.block_info.push_back({.id = 0});

  auto &key = block->AppendNewInst(ValueOpcode::LaneId);
  auto &image =
      block->AppendNewInst(ValueOpcode::GetImageResource,
                           {Value(&key), Value(0u), Value(0u), Value(0u),
                            Value(0u), Value(0u), Value(0u), Value(0u)});
  image.SetFlags<uint32_t>(0u);
  auto &sampler =
      block->AppendNewInst(ValueOpcode::GetSamplerResource,
                           {Value(0u), Value(0u), Value(0u), Value(0u)});
  sampler.SetFlags<uint32_t>(0u);
  auto &address = block->AppendNewInst(
      ValueOpcode::MakeImageAddress,
      {Value(0u), Value(0u), Value(0u), Value(0u), Value(0u), Value(0u),
       Value(0u), Value(0u), Value(0u), Value(0u), Value(0u), Value(0u),
       Value(0u)});
  MemoryInfo memory{};
  memory.kind = ResourceKind::Image;
  memory.resource = 0;
  memory.sampler = 0;
  memory.dmask = 0xf;
  memory.image_sample_flags = ShaderRecompiler::Decoder::ImageSampleFlagLod;
  memory.image_dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2D;
  memory.image_address_components = 3;
  program.memory_info.push_back(memory);
  const MemoryFlags memory_flags{0u, 0x10f0u};
  uint64_t memory_flag_bits = 0;
  std::memcpy(&memory_flag_bits, &memory_flags, sizeof(memory_flags));
  auto &sample = block->AppendNewInst(
      ValueOpcode::ImageSampleRaw,
      {Value(&image), Value(&sampler), Value(&address)}, memory_flag_bits);
  auto &sample_x = block->AppendNewInst(ValueOpcode::CompositeExtractU32x4,
                                        {Value(&sample), Value(0u)});
  block->AppendNewInst(ValueOpcode::ReferenceU32, {Value(&sample_x)});

  program.descriptor_sources.resize(2);
  program.descriptor_sources[0].dword_count = 8;
  program.descriptor_sources[0].indirect_image =
      DescriptorSource::IndirectImage{0u, 0u, 224u, 12u, 0u};
  program.descriptor_sources[1].dword_count = 4;

  ImageResource root{};
  root.source = 0;
  root.first_use_pc = 0x10f0u;
  root.resource_class = ImageResourceClass::Sampled;
  root.numeric_class = Prospero::TextureNumericClass::Float;
  root.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2D;
  root.read = true;
  root.indirect_root = 0;
  root.indirect_mapping_offset = 0;
	root.indirect_search_iterations = std::bit_width(mapping_capacity);
  root.indirect_resources = {0u, 1u};
  auto candidate = root;
	candidate.indirect_search_iterations = 0;
  candidate.indirect_resources.clear();
  program.info.images = {root, candidate};
  program.info.samplers.push_back({1u, 0x10f0u});
  program.info.sampled_pairs.push_back({0u, 0u, 0x10f0u});

  AllocateBindings(program);
  ShaderComputeInputInfo compute{};
  auto spirv = ShaderRecompiler::Spirv::EmitProgram(program,
                                                    {.compute = &compute});
  ValidateSpirv(name, spirv);
  spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_2);
  std::string text;
  Require(name, "SPIR-V disassembly", tools.Disassemble(spirv, &text),
          "failed to disassemble indirect image shader");
  Require(name, "key switch",
          text.find("OpSwitch") != std::string::npos &&
              text.find("OpPhi") != std::string::npos &&
              CountText(text, "OpImageSampleExplicitLod") == 2 &&
              CountText(text, "OpIEqual") == 11,
          "dynamic image key did not use a compact two-sample switch");
}

TestCase ImageStoreMipSelectsPpsa01340Descriptor() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovU32(&code, 21, 0);
  AppendVMovU32(&code, 22, 2);
  AppendVMovU32(&code, 23, 0);
  AppendVMovLiteral(&code, 0, 0x3f800000u);
  AppendVMovLiteral(&code, 1, 0x40000000u);
  AppendVMovLiteral(&code, 2, 0x40400000u);
  AppendVMovLiteral(&code, 3, 0x40800000u);
  code.push_back(EncodeMimg0(0x09, 0xf));
  code.push_back(EncodeMimg1(0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageStoreMipSelectsPpsa01340Descriptor";
  test.code = std::move(code);
  test.opcodes = {O::V_MOV_B32, O::IMAGE_STORE_MIP, O::S_ENDPGM};
  const std::array<u32, 8> descriptor{0x0294dc00u, 0xc4700000u, 0x00b3c13fu,
                                      0x91b31facu, 0x00000000u, 0x00700030u,
                                      0xb07b0000u, 0x0002ac3cu};
  std::copy(descriptor.begin(), descriptor.end(), test.user_data.begin());
  test.has_user_data = true;
  test.compile_only = true;
  test.expected_storage_mip_descriptors = 3;
  test.required_spirv = {"OpSwitch", "OpImageWrite"};
  return test;
}

TestCase ImageStoreRgbOneUsesInverseSwizzle() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 1);
  AppendVMovU32(&code, 21, 2);
  AppendVMovU32(&code, 22, 0);
  AppendVMovLiteral(&code, 0, 0x3f800000u);
  AppendVMovLiteral(&code, 1, 0x3f008081u);
  AppendVMovLiteral(&code, 2, 0x3e808081u);
  AppendVMovLiteral(&code, 3, 0x3f40c0c1u);
  code.push_back(EncodeMimg0(0x08, 0xf));
  code.push_back(EncodeMimg1(0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageStoreRgbOneUsesInverseSwizzle";
  test.code = code;
  test.opcodes = {O::V_MOV_B32, O::IMAGE_STORE, O::S_ENDPGM};
  test.has_user_data = true;
  test.user_data[0] = 0x1000u;
  test.user_data[1] =
      static_cast<uint32_t>(Prospero::BufferFormat::k8_8_8_8UNorm) << 20u;
  test.image_descriptor_swizzle = DstSel(4, 5, 6, 1);
  test.storage_image_format = vk::Format::eR8G8B8A8Unorm;
  test.storage_image_dwords_per_pixel = 1;
  test.storage_image_rgba = std::vector<u32>(16, 0);
  test.expected_storage_image_rgba = std::vector<u32>(16, 0);
  test.expected_storage_image_rgba[2 * 4 + 1] = 0x004080ffu;
  return test;
}

TestCase ImageStoreDuplicateSelectorUsesInverseSwizzle() {
  auto test = ImageStoreRgbOneUsesInverseSwizzle();
  test.name = "ImageStoreDuplicateSelectorUsesInverseSwizzle";
  test.image_descriptor_swizzle = DstSel(4, 4, 6, 7);
  test.expected_storage_image_rgba[2 * 4 + 1] = 0xc04000ffu;
  return test;
}

TestCase ImageStoreBgraUsesInverseSwizzle() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 1);
  AppendVMovU32(&code, 21, 2);
  AppendVMovU32(&code, 22, 0);
  AppendVMovLiteral(&code, 0, 0x3f800000u);
  AppendVMovLiteral(&code, 1, 0x3f008081u); // 128/255
  AppendVMovLiteral(&code, 2, 0x3e808081u); // 64/255
  AppendVMovLiteral(&code, 3, 0x3f3fbfc0u); // 191/255
  code.push_back(EncodeMimg0(0x08, 0xf));
  code.push_back(EncodeMimg1(0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageStoreBgraUsesInverseSwizzle";
  test.code = code;
  test.opcodes = {O::V_MOV_B32, O::IMAGE_STORE, O::S_ENDPGM};
  test.has_user_data = true;
  test.user_data[0] = 0x1000u;
  test.user_data[1] =
      static_cast<uint32_t>(Prospero::BufferFormat::k8_8_8_8UNorm) << 20u;
  test.image_descriptor_swizzle = DstSel(6, 5, 4, 7);
  test.storage_image_format = vk::Format::eR8G8B8A8Unorm;
  test.storage_image_dwords_per_pixel = 1;
  test.storage_image_rgba = std::vector<u32>(16, 0);
  test.expected_storage_image_rgba = std::vector<u32>(16, 0);
  test.expected_storage_image_rgba[2 * 4 + 1] = 0xbfff8040u;
  return test;
}

TestCase ImageStoreYzwxUsesInverseSwizzle() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 1);
  AppendVMovU32(&code, 21, 2);
  AppendVMovU32(&code, 22, 0);
  AppendVMovLiteral(&code, 0, 0x3f800000u);
  AppendVMovLiteral(&code, 1, 0x3f000000u);
  AppendVMovLiteral(&code, 2, 0x3e800000u);
  AppendVMovLiteral(&code, 3, 0x3f400000u);
  code.push_back(EncodeMimg0(0x08, 0xf));
  code.push_back(EncodeMimg1(0, 20));
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageStoreYzwxUsesInverseSwizzle";
  test.code = code;
  test.opcodes = {O::V_MOV_B32, O::IMAGE_STORE, O::S_ENDPGM};
  test.user_data =
      MakeStorageTextureData(Prospero::BufferFormat::k32_32_32_32Float);
  test.has_user_data = true;
  test.image_descriptor_swizzle = DstSel(5, 6, 7, 4);
  test.storage_image_rgba = MakeRgbaImage(4, 4);
  test.expected_storage_image_rgba = MakeRgbaImage(4, 4);
  SetRgbaPixel(&test.expected_storage_image_rgba, 4, 1, 2, 0x3f400000u,
               0x3f800000u, 0x3f000000u, 0x3e800000u);
  return test;
}

TestCase ImageStoreR32FloatUsesFormatlessStorageImage() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  AppendVMovU32(&code, 21, 1);
  AppendVMovU32(&code, 22, 0);
  AppendVMovLiteral(&code, 0, 0x3f800000u);
  code.push_back(EncodeMimg0(0x08, 0x1));
  code.push_back(EncodeMimg1(0, 20));
  AppendEnd(&code);

  std::vector<u32> expected_image(16, 0);
  expected_image[1 * 4 + 2] = 0x3f800000u;

  TestCase test;
  test.name = "ImageStoreR32FloatUsesFormatlessStorageImage";
  test.code = code;
  test.opcodes = {O::V_MOV_B32, O::IMAGE_STORE, O::S_ENDPGM};
  test.storage_image_format = vk::Format::eR32Sfloat;
  test.storage_image_dwords_per_pixel = 1;
  test.storage_image_rgba = std::vector<u32>(16, 0);
  test.expected_storage_image_rgba = expected_image;
  test.required_spirv = {"OpCapability StorageImageWriteWithoutFormat"};
  test.forbidden_spirv = {"OpCapability StorageImageReadWithoutFormat",
                          "Rgba32f", "OpTypeSampler", "OpTypeSampledImage"};
  return test;
}

TestCase ImageStoreR32SintUsesRawUintView() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  AppendVMovU32(&code, 21, 1);
  AppendVMovU32(&code, 22, 0);
  AppendVMovLiteral(&code, 0, 0x80000001u);
  code.push_back(EncodeMimg0(0x08, 0x1));
  code.push_back(EncodeMimg1(0, 20));
  AppendEnd(&code);

  std::vector<u32> expected_image(16, 0);
  expected_image[1 * 4 + 2] = 0x80000001u;

  TestCase test;
  test.name = "ImageStoreR32SintUsesRawUintView";
  test.code = code;
  test.opcodes = {O::V_MOV_B32, O::IMAGE_STORE, O::S_ENDPGM};
  test.user_data = MakeStorageTextureData(Prospero::BufferFormat::k32SInt);
  test.has_user_data = true;
  test.storage_image_r32ui = std::vector<u32>(16, 0);
  test.expected_storage_image_r32ui = expected_image;
  test.required_spirv = {"OpCapability StorageImageWriteWithoutFormat",
                         StorageUint2DImageBindingName(false)};
  test.forbidden_spirv = {"R32ui"};
  return test;
}

TestCase ImageStoreR32UintUsesFormatlessStorageImage() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  AppendVMovU32(&code, 21, 1);
  AppendVMovU32(&code, 22, 0);
  AppendVMovLiteral(&code, 0, 0x12345678u);
  code.push_back(EncodeMimg0(0x08, 0x1));
  code.push_back(EncodeMimg1(0, 20));
  AppendEnd(&code);

  std::vector<u32> expected_image(16, 0);
  expected_image[1 * 4 + 2] = 0x12345678u;

  TestCase test;
  test.name = "ImageStoreR32UintUsesFormatlessStorageImage";
  test.code = code;
  test.opcodes = {O::V_MOV_B32, O::IMAGE_STORE, O::S_ENDPGM};
  test.user_data = MakeStorageTextureData(Prospero::BufferFormat::k32UInt);
  test.has_user_data = true;
  test.storage_image_rgba = MakeRgbaImage(4, 4);
  test.storage_image_r32ui = std::vector<u32>(16, 0);
  test.expected_storage_image_r32ui = expected_image;
  test.required_spirv = {"OpCapability StorageImageWriteWithoutFormat",
                         StorageUint2DImageBindingName(false)};
  test.forbidden_spirv = {"R32ui"};
  return test;
}

TestCase ImageStorePackedUintSaturatesChannels() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  AppendVMovU32(&code, 21, 1);
  AppendVMovU32(&code, 22, 0);
  AppendVMovU32(&code, 0, 0x800u);
  AppendVMovLiteral(&code, 1, UINT32_MAX);
  AppendVMovU32(&code, 2, 0x400u);
  AppendVMovU32(&code, 3, 0x55u);
  code.push_back(EncodeMimg0(0x08, 0xf));
  code.push_back(EncodeMimg1(0, 20));
  AppendEnd(&code);

  std::vector<u32> expected_image(16, 0);
  expected_image[1 * 4 + 2] = UINT32_MAX;

  TestCase test;
  test.name = "ImageStorePackedUintSaturatesChannels";
  test.code = std::move(code);
  test.opcodes = {O::V_MOV_B32, O::IMAGE_STORE, O::S_ENDPGM};
  test.user_data =
      MakeStorageTextureData(Prospero::BufferFormat::k11_11_10UInt);
  test.has_user_data = true;
  test.image_descriptor_swizzle = DstSel(4, 5, 6, 0);
  test.storage_image_r32ui = std::vector<u32>(16, 0);
  test.expected_storage_image_r32ui = std::move(expected_image);
  test.required_spirv = {"OpCapability StorageImageWriteWithoutFormat",
                         StorageUint2DImageBindingName(false), "OpULessThan",
                         "OpSelect"};
  test.forbidden_spirv = {"R32ui"};
  return test;
}

TestCase ImageStorePackedUintHonorsSparseDmask() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  AppendVMovU32(&code, 21, 1);
  AppendVMovU32(&code, 22, 0);
  AppendVMovU32(&code, 0, 0x321u);
  AppendVMovU32(&code, 1, 0x2abu);
  code.push_back(EncodeMimg0(0x08, 0x5));
  code.push_back(EncodeMimg1(0, 20));
  AppendEnd(&code);

  std::vector<u32> expected_image(16, 0);
  expected_image[1 * 4 + 2] = 0xaac00321u;

  TestCase test;
  test.name = "ImageStorePackedUintHonorsSparseDmask";
  test.code = std::move(code);
  test.opcodes = {O::V_MOV_B32, O::IMAGE_STORE, O::S_ENDPGM};
  test.user_data =
      MakeStorageTextureData(Prospero::BufferFormat::k11_11_10UInt);
  test.has_user_data = true;
  test.image_descriptor_swizzle = DstSel(4, 5, 6, 0);
  test.storage_image_r32ui = std::vector<u32>(16, 0);
  test.expected_storage_image_r32ui = std::move(expected_image);
  test.required_spirv = {"OpCapability StorageImageWriteWithoutFormat",
                         StorageUint2DImageBindingName(false)};
  test.forbidden_spirv = {"R32ui"};
  return test;
}

TestCase ComputeTgSizeSgprUsesWaveMetadata() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendStoreSgpr(&code, 2, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "ComputeTgSizeSgprUsesWaveMetadata";
  test.code = code;
  test.opcodes = {O::V_MOV_B32, O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 4;
  test.compute_info.threads_num[2] = 16;
  test.compute_info.group_id[0] = true;
  test.compute_info.group_id[1] = true;
  test.compute_info.wave_size = 32;
  test.compute_info.thread_ids_num = 3;
  test.compute_info.workgroup_register = 0;
  test.compute_info.tg_size_en = true;
  test.has_compute_info = true;
  test.compile_only = true;
  test.required_spirv = {"OpUDiv", "OpShiftLeftLogical", "2147483648"};
  return test;
}

TestCase ImageStoreAndAtomicShareTypedBinding() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  AppendVMovU32(&code, 21, 1);
  AppendVMovU32(&code, 22, 0);
  AppendVMovU32(&code, 0, 5);
  code.push_back(EncodeMimg0(0x08, 0x1));
  code.push_back(EncodeMimg1(0, 20));
  AppendVMovU32(&code, 0, 3);
  code.push_back(EncodeMimg0(0x11, 0x1, 0, true));
  code.push_back(EncodeMimg1(0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  std::vector<u32> expected_image(16, 0);
  expected_image[1 * 4 + 2] = 8;

  TestCase test;
  test.name = "ImageStoreAndAtomicShareTypedBinding";
  test.code = std::move(code);
  test.expected = {5};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_STORE, O::IMAGE_ATOMIC_ADD,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.user_data = MakeStorageTextureData(Prospero::BufferFormat::k32UInt);
  test.has_user_data = true;
  test.storage_image_r32ui = std::vector<u32>(16, 0);
  test.expected_storage_image_r32ui = std::move(expected_image);
  test.required_spirv = {"OpImageWrite", "OpImageTexelPointer", "R32ui",
                         StorageUint2DImageBindingName(true)};
  test.forbidden_spirv = {"StorageImageReadWithoutFormat",
                          "StorageImageWriteWithoutFormat",
                          StorageUint2DImageBindingName(false)};
  return test;
}

TestCase ImageAtomicSwapReturnsPreviousTexel() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  AppendVMovU32(&code, 21, 1);
  AppendVMovU32(&code, 22, 0);
  AppendVMovU32(&code, 0, 5);
  code.push_back(EncodeMimg0(0x08, 0x1));
  code.push_back(EncodeMimg1(0, 20));
  AppendVMovU32(&code, 0, 3);
  code.push_back(EncodeMimg0(0x0f, 0x1, 0, true));
  code.push_back(EncodeMimg1(0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  std::vector<u32> expected_image(16, 0);
  expected_image[1 * 4 + 2] = 3;

  TestCase test;
  test.name = "ImageAtomicSwapReturnsPreviousTexel";
  test.code = std::move(code);
  test.expected = {5};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_STORE, O::IMAGE_ATOMIC_SWAP,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.user_data = MakeStorageTextureData(Prospero::BufferFormat::k32UInt);
  test.has_user_data = true;
  test.storage_image_r32ui = std::vector<u32>(16, 0);
  test.expected_storage_image_r32ui = std::move(expected_image);
  test.required_spirv = {"OpAtomicExchange", "OpImageTexelPointer"};
  return test;
}

TestCase ImageStoreAndAtomicUseSeparateBindings() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 2);
  AppendVMovU32(&code, 21, 1);
  AppendVMovU32(&code, 22, 0);
  AppendVMovU32(&code, 0, 5);
  code.push_back(EncodeMimg0(0x08, 0x1));
  code.push_back(EncodeMimg1(0, 20, 0));
  AppendVMovU32(&code, 0, 3);
  code.push_back(EncodeMimg0(0x11, 0x1, 0, true));
  code.push_back(EncodeMimg1(0, 20, 2));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  auto user_data = MakeStorageTextureData(Prospero::BufferFormat::k32UInt);
  std::copy_n(user_data.begin(), 8, user_data.begin() + 8);
  std::vector<u32> expected_image(16, 0);
  expected_image[1 * 4 + 2] = 8;

  TestCase test;
  test.name = "ImageStoreAndAtomicUseSeparateBindings";
  test.code = std::move(code);
  test.expected = {5};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_STORE, O::IMAGE_ATOMIC_ADD,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.user_data = user_data;
  test.has_user_data = true;
  test.storage_image_r32ui = std::vector<u32>(16, 0);
  test.expected_storage_image_r32ui = std::move(expected_image);
  test.required_spirv = {"OpCapability StorageImageWriteWithoutFormat",
                         "OpImageWrite",
                         "OpImageTexelPointer",
                         "R32ui",
                         StorageUint2DImageBindingName(false),
                         StorageUint2DImageBindingName(true)};
  return test;
}

TestCase ImageAtomicVariants() {
  using O = ShaderOpcode;

  const u32 initial[] = {10, 10, 0xf0f0u, 0xf000u, 0xf00fu};
  const u32 values[] = {5, 5, 0x0ff0u, 0x0f00u, 0x00ffu};
  const u32 ops[] = {0x11, 0x15, 0x18, 0x19, 0x1a};

  std::vector<u32> code;
  for (u32 i = 0; i < static_cast<u32>(std::size(values)); i++) {
    AppendVMovU32(&code, 20, i & 3u);
    AppendVMovU32(&code, 21, i >> 2u);
    AppendVMovU32(&code, 22, 0);
    AppendVMovLiteral(&code, 0, values[i]);
    code.push_back(EncodeMimg0(ops[i], 0x1, 0, true));
    code.push_back(EncodeMimg1(0, 20));
    AppendStoreVgpr(&code, 0, i);
  }
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageAtomicVariants";
  test.code = code;
  test.expected = {10, 10, 0xf0f0u, 0xf000u, 0xf00fu};
  test.opcodes = {O::V_MOV_B32,          O::IMAGE_ATOMIC_ADD,
                  O::IMAGE_ATOMIC_UMIN,  O::IMAGE_ATOMIC_AND,
                  O::IMAGE_ATOMIC_OR,    O::IMAGE_ATOMIC_XOR,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.required_spirv = {"OpImageTexelPointer", "R32ui",
                         StorageUint2DImageBindingName(true)};
  test.forbidden_spirv = {"OpTypeSampler", "OpTypeSampledImage",
                          "StorageImageReadWithoutFormat",
                          "StorageImageWriteWithoutFormat",
                          StorageUint2DImageBindingName(false)};
  test.storage_image_rgba = MakeRgbaImage(4, 4);
  test.storage_image_r32ui = std::vector<u32>(16, 0);
  for (u32 i = 0; i < static_cast<u32>(std::size(initial)); i++) {
    test.storage_image_r32ui[i] = initial[i];
  }
  test.expected_storage_image_r32ui = std::vector<u32>(16, 0);
  test.expected_storage_image_r32ui[0] = 15;
  test.expected_storage_image_r32ui[1] = 5;
  test.expected_storage_image_r32ui[2] = 0x00f0u;
  test.expected_storage_image_r32ui[3] = 0xff00u;
  test.expected_storage_image_r32ui[4] = 0xf0f0u;
  return test;
}

TestCase ImageAtomicGlc0DoesNotReturnOldValue() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovU32(&code, 20, 0);
  AppendVMovU32(&code, 21, 0);
  AppendVMovU32(&code, 22, 0);
  AppendVMovU32(&code, 0, 5);
  code.push_back(EncodeMimg0(0x11, 0x1));
  code.push_back(EncodeMimg1(0, 20));
  AppendStoreVgpr(&code, 0, 0);
  AppendEnd(&code);

  TestCase test;
  test.name = "ImageAtomicGlc0DoesNotReturnOldValue";
  test.code = code;
  test.expected = {5};
  test.opcodes = {O::V_MOV_B32, O::IMAGE_ATOMIC_ADD, O::BUFFER_STORE_DWORD,
                  O::S_ENDPGM};
  test.storage_image_rgba = MakeRgbaImage(4, 4);
  test.storage_image_r32ui = std::vector<u32>(16, 0);
  test.storage_image_r32ui[0] = 10;
  test.expected_storage_image_r32ui = std::vector<u32>(16, 0);
  test.expected_storage_image_r32ui[0] = 15;
  return test;
}

GraphicsCase GraphicsInterpolationExport() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeVintrp(0x00, 0, 0, 0, 0));
  code.push_back(EncodeVintrp(0x01, 0, 0, 0, 0));
  code.push_back(EncodeVintrp(0x02, 1, 0, 1, 2));
  AppendVMovLiteral(&code, 2, 0x3f400000u);
  AppendVMovLiteral(&code, 3, 0x3f800000u);
  code.push_back(EncodeExp0(0x00, 0xf));
  code.push_back(EncodeExp1(0, 1, 2, 3));
  AppendEnd(&code);

  return {"GraphicsInterpolationExport",
          code,
          {0x3e800000u, 0x3f000000u, 0x3f400000u, 0x3f800000u},
          {O::V_INTERP_P1_F32, O::V_INTERP_P2_F32, O::V_INTERP_MOV_F32,
           O::V_MOV_B32, O::EXP, O::S_ENDPGM}};
}

GraphicsCase GraphicsPositionWExport() {
  GraphicsCase test;
  test.name = "GraphicsPositionWExport";
  test.pixel_position_w = true;
  test.vertex_clip_w = 4.0f;
  // POS_W occupies v2; the rasterizer supplies FragCoord.w=1/4 for this triangle.
  test.fragment_code = {EncodeExp0(0x00, 0xf), EncodeExp1(2, 2, 2, 2)};
  AppendEnd(&test.fragment_code);
  test.expected_pixel = {0x40800000u, 0x40800000u, 0x40800000u, 0x40800000u};
  test.opcodes = {ShaderOpcode::EXP, ShaderOpcode::S_ENDPGM};
  return test;
}

GraphicsCase GraphicsPackedHalfCentroid() {
  GraphicsCase test;
  test.name = "GraphicsPackedHalfCentroid";
  test.pixel_perspective_centroid_vgpr = 0;
  test.pixel_custom_interpolation_mask = 1;
  test.pixel_interpolator_settings = {0x420u};
  // Captured ab810715011baef3 interpolation, with attr3.x remapped to attr0.x.
  test.fragment_code = {
      0xc8120002u, 0xc80e0000u,             // raw vertex0/vertex1 packed halves
      0xcc204007u, 0x9c1206f2u,             // low(vertex1) - low(vertex0)
      0xcc207005u, 0x9c1206f2u,             // high(vertex1) - high(vertex0)
      0xc80a0001u,                         // raw vertex2
      0xcc204006u, 0x9c1204f2u,
      0xcc207003u, 0x9c1204f2u,
      0xcc20400eu, 0x04120f00u,             // low = I * delta10 + vertex0
      0xcc20600fu, 0x04120b00u,             // high = I * delta10 + vertex0
      0x3e1c0306u, 0x3e1e0303u,             // += J * delta20
      EncodeExp0(0x00, 0xf), EncodeExp1(14, 15, 14, 15)};
  AppendEnd(&test.fragment_code);
  // At the pixel center the vertex weights are (5/8, 1/8, 1/4).
  // Packed values are (0,1), (1,2), (3,3): expected result (0.875, 1.625).
  test.vertices = {
      0xbf800000u, 0xbf800000u, 0x3c000000u, 0, 0, 0,
      0x40e00000u, 0xbf800000u, 0x40003c00u, 0, 0, 0,
      0xbf800000u, 0x40400000u, 0x42004200u, 0, 0, 0};
  test.expected_pixel = {0x3f600000u, 0x3fd00000u, 0x3f600000u, 0x3fd00000u};
  test.opcodes = {ShaderOpcode::V_INTERP_MOV_F32, ShaderOpcode::V_FMA_F32, ShaderOpcode::V_MAC_F32,
                  ShaderOpcode::EXP, ShaderOpcode::S_ENDPGM};
  return test;
}

GraphicsCase GraphicsPackedHalfInputAlias(bool second_weights) {
  auto test = GraphicsPackedHalfCentroid();
  test.name = second_weights ? "GraphicsPackedHalfAliasSecondWeights"
                            : "GraphicsPackedHalfInputAlias";
  test.pixel_custom_interpolation_mask = 2u;
  test.pixel_interpolator_settings = {0u, 0x420u};
  // The head shader reads one exported vec4 through two logical inputs:
  // ordinary interpolation and raw per-vertex packed-half interpolation.
  // Move the captured raw attr0.x loads to logical attr1.x, still mapped to 0.
  for (const auto word : {0u, 1u, 6u}) {
    test.fragment_code[word] |= 1u << 10u;
  }
  test.fragment_code.resize(test.fragment_code.size() - 3u);
  test.fragment_code.push_back(EncodeVintrp(0x00, 16, 0, 1, 0));
  test.fragment_code.push_back(EncodeVintrp(0x01, 16, 0, 1, 1));
  AppendVMovLiteral(&test.fragment_code, 17, 0x3f800000u);
  test.fragment_code.push_back(EncodeExp0(0x00, 0xf));
  test.fragment_code.push_back(EncodeExp1(14, 15, 16, 17));
  AppendEnd(&test.fragment_code);
  // The smooth component (2,4,8) must vary independently of packed UVs.
  test.vertices[3] = 0x40000000u;
  test.vertices[9] = 0x40800000u;
  test.vertices[15] = 0x41000000u;
  if (second_weights) {
    // Change the right vertex from x=7 to x=3: weights become (1/2,1/4,1/4).
    test.vertices[6] = 0x40400000u;
    test.expected_pixel = {0x3f800000u, 0x3fe00000u, 0x40800000u, 0x3f800000u};
  } else {
    test.expected_pixel = {0x3f600000u, 0x3fd00000u, 0x40700000u, 0x3f800000u};
  }
  test.opcodes.insert(test.opcodes.end(),
                      {ShaderOpcode::V_INTERP_P1_F32, ShaderOpcode::V_INTERP_P2_F32,
                       ShaderOpcode::V_MOV_B32});
  return test;
}

GraphicsCase GraphicsSmoothRawInputAlias() {
  auto test = GraphicsPackedHalfInputAlias(false);
  test.name = "GraphicsSmoothRawInputAlias";
  test.pixel_perspective_centroid_vgpr = UINT32_MAX;
  // No explicit barycentric builtin: alias promotion must discover that the
  // ordinary input needs weights while the raw alias returns vertex zero.
  test.fragment_code = {EncodeVintrp(0x00, 0, 0, 1, 0),
                        EncodeVintrp(0x01, 0, 0, 1, 1),
                        EncodeVintrp(0x02, 1, 1, 1, 2),
                        EncodeExp0(0x00, 0xf), EncodeExp1(0, 1, 0, 1)};
  AppendEnd(&test.fragment_code);
  test.expected_pixel = {0x40700000u, 0x40000000u, 0x40700000u, 0x40000000u};
  test.opcodes = {ShaderOpcode::V_INTERP_P1_F32, ShaderOpcode::V_INTERP_P2_F32,
                  ShaderOpcode::V_INTERP_MOV_F32, ShaderOpcode::EXP,
                  ShaderOpcode::S_ENDPGM};
  return test;
}

GraphicsCase GraphicsAncillaryLayer(bool front_face) {
  GraphicsCase test;
  test.name = front_face ? "GraphicsAncillaryAfterFrontFace" : "GraphicsAncillaryLayer";
  test.pixel_ancillary = true;
  test.pixel_front_face = front_face;
  test.layers = 8;
  const auto ancillary = Vgpr(front_face ? 3 : 2);
  test.fragment_code.push_back(EncodeSop1(0x04, 8, 126));
  test.fragment_code.push_back(EncodeSop1(0x0a, 126, 126));
  AppendVop3(&test.fragment_code, 0x148, 4, ancillary, InlineU32(16), InlineU32(11));
  AppendVop3(&test.fragment_code, 0x149, 5, ancillary, InlineU32(16), InlineU32(3));
  test.fragment_code.push_back(EncodeSop1(0x04, 126, 8));
  AppendVMovU32(&test.fragment_code, 6, test.layers);
  test.fragment_code.push_back(EncodeVopc(0xc1, Vgpr(4), 6)); // Dynamic layer < count.
  test.fragment_code.push_back(EncodeSop1(0x04, 126, 106));
  test.fragment_code.push_back(EncodeVop1(0x06, 0, Vgpr(4))); // float(unsigned layer)
  test.fragment_code.push_back(EncodeVop1(0x05, 1, Vgpr(5))); // float(signed low 3 bits)
  AppendVMovLiteral(&test.fragment_code, 2, 0);
  AppendVMovLiteral(&test.fragment_code, 3, 0x3f800000u);
  test.fragment_code.push_back(EncodeExp0(0x00, 0xf));
  test.fragment_code.push_back(EncodeExp1(0, 1, 2, 3));
  AppendEnd(&test.fragment_code);
  test.opcodes = {ShaderOpcode::V_BFE_U32, ShaderOpcode::V_BFE_I32,
                  ShaderOpcode::V_CVT_F32_U32, ShaderOpcode::V_CVT_F32_I32,
                  ShaderOpcode::V_MOV_B32, ShaderOpcode::S_MOV_B64,
                  ShaderOpcode::S_WQM_B64, ShaderOpcode::V_CMP_LT_U32,
                  ShaderOpcode::EXP, ShaderOpcode::S_ENDPGM};
  for (u32 layer = 0; layer < test.layers; ++layer) {
    const auto signed_bits = layer < 4 ? static_cast<int>(layer) : static_cast<int>(layer) - 8;
    test.expected_pixel.insert(test.expected_pixel.end(),
        {std::bit_cast<u32>(static_cast<float>(layer)),
         std::bit_cast<u32>(static_cast<float>(signed_bits)), 0, 0x3f800000u});
  }
  return test;
}

GraphicsCase GraphicsAncillarySampleId() {
  GraphicsCase test;
  test.name = "GraphicsAncillarySampleId";
  test.pixel_ancillary = true;
  test.samples = vk::SampleCountFlagBits::e4;
  AppendVop3(&test.fragment_code, 0x148, 4, Vgpr(2), InlineU32(8), InlineU32(4));
  AppendVop3(&test.fragment_code, 0x149, 5, Vgpr(2), InlineU32(8), InlineU32(2));
  AppendVop3(&test.fragment_code, 0x148, 6, Vgpr(2), InlineU32(9), InlineU32(1));
  test.fragment_code.push_back(EncodeVop1(0x06, 0, Vgpr(4)));
  test.fragment_code.push_back(EncodeVop1(0x05, 1, Vgpr(5)));
  test.fragment_code.push_back(EncodeVop1(0x06, 2, Vgpr(6)));
  AppendVMovLiteral(&test.fragment_code, 3, 0x3f800000u);
  test.fragment_code.push_back(EncodeExp0(0x00, 0xf));
  test.fragment_code.push_back(EncodeExp1(0, 1, 2, 3));
  AppendEnd(&test.fragment_code);
  test.opcodes = {ShaderOpcode::V_BFE_U32, ShaderOpcode::V_BFE_I32,
                  ShaderOpcode::V_CVT_F32_U32, ShaderOpcode::V_CVT_F32_I32,
                  ShaderOpcode::V_MOV_B32, ShaderOpcode::EXP, ShaderOpcode::S_ENDPGM};
  // Average samples 0..3, their signed low two bits, and their second bit.
  test.expected_pixel = {0x3fc00000u, 0xbf000000u, 0x3f000000u, 0x3f800000u};
  return test;
}

GraphicsCase GraphicsFlatInterpolatorExport() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeVintrp(0x02, 0, 0, 0, 2));
  AppendVMovLiteral(&code, 1, 0x00000000u);
  AppendVMovLiteral(&code, 2, 0x00000000u);
  AppendVMovLiteral(&code, 3, 0x3f800000u);
  code.push_back(EncodeExp0(0x00, 0xf));
  code.push_back(EncodeExp1(0, 1, 2, 3));
  AppendEnd(&code);

  GraphicsCase test;
  test.name = "GraphicsFlatInterpolatorExport";
  test.fragment_code = code;
  test.expected_pixel = {0x3e800000u, 0x00000000u, 0x00000000u, 0x3f800000u};
  test.opcodes = {O::V_INTERP_MOV_F32, O::V_MOV_B32, O::EXP, O::S_ENDPGM};
  test.pixel_interpolator_settings = {0x00000400u};
  test.vertices = {
      0xbf800000u, 0xbf800000u, 0x3e800000u, 0x00000000u, 0x00000000u,
      0x3f800000u, 0x40400000u, 0xbf800000u, 0x3f400000u, 0x00000000u,
      0x00000000u, 0x3f800000u, 0xbf800000u, 0x40400000u, 0x3e800000u,
      0x00000000u, 0x00000000u, 0x3f800000u,
  };
  return test;
}

GraphicsCase GraphicsDsAddtidScratchExport() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeSMovB32(124, InlineU32(0)));
  AppendVMovLiteral(&code, 0, 0x3f000000u);
  code.push_back(EncodeDs0(0xb0, 0));
  code.push_back(EncodeDs1(0, 0, 0));
  code.push_back(EncodeDs0(0xb1, 0));
  code.push_back(EncodeDs1(4, 0, 0));
  code.push_back(EncodeExp0(0x00, 0xf));
  code.push_back(EncodeExp1(4, 4, 4, 4));
  AppendEnd(&code);

  return {"GraphicsDsAddtidScratchExport",
          code,
          {0x3f000000u, 0x3f000000u, 0x3f000000u, 0x3f000000u},
          {O::S_MOV_B32, O::V_MOV_B32, O::DS_WRITE_ADDTID_B32,
           O::DS_READ_ADDTID_B32, O::EXP, O::S_ENDPGM}};
}

GraphicsCase GraphicsDirectSgprPushConstantExport() {
  using O = ShaderOpcode;

  const std::vector<u32> values = {0x3e800000u, 0x3f000000u, 0x3f400000u,
                                   0x3f800000u};

  std::vector<u32> code;
  code.push_back(EncodeVop1(0x01, 0, 0));
  code.push_back(EncodeVop1(0x01, 1, 1));
  code.push_back(EncodeVop1(0x01, 2, 2));
  code.push_back(EncodeVop1(0x01, 3, 3));
  code.push_back(EncodeExp0(0x00, 0xf));
  code.push_back(EncodeExp1(0, 1, 2, 3));
  AppendEnd(&code);

  GraphicsCase test;
  test.name = "GraphicsDirectSgprPushConstantExport";
  test.fragment_code = code;
  test.expected_pixel = values;
  test.opcodes = {O::V_MOV_B32, O::EXP, O::S_ENDPGM};

  for (size_t i = 0; i < values.size(); i++) {
    test.user_data[i] = values[i];
  }
  test.has_user_data = true;
  test.push_constants = values;
  return test;
}

GraphicsCase GraphicsInlineSrtScalarPromotionExport() {
  using O = ShaderOpcode;

  const std::vector<u32> values = {0x00000000u, 0x00000000u, 0x00000000u,
                                   0x3f800000u};

  std::vector<u32> code;
  AppendVop3(&code, 0x12fu, 0, 0, 1);
  AppendVop3(&code, 0x12fu, 1, 2, 3);
  code.push_back(EncodeExp0(0x00, 0xf, true, true, true));
  code.push_back(EncodeExp1(0, 1, 0, 0));
  AppendEnd(&code);

  GraphicsCase test;
  test.name = "GraphicsInlineSrtScalarPromotionExport";
  test.fragment_code = code;
  test.expected_pixel = values;
  test.opcodes = {O::V_CVT_PKRTZ_F16_F32, O::EXP, O::S_ENDPGM};

  for (size_t i = 0; i < values.size(); i++) {
    test.user_data[i] = values[i];
  }
  test.has_user_data = true;
  test.push_constants = values;
  return test;
}

GraphicsCase GraphicsNullVmExportDiscardsInactiveExec() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x3f000000u);
  AppendVMovLiteral(&code, 1, 0x3f400000u);
  AppendVMovLiteral(&code, 2, 0x3f800000u);
  AppendVMovLiteral(&code, 3, 0x40000000u);
  code.push_back(EncodeExp0(0x00, 0xf, false));
  code.push_back(EncodeExp1(0, 1, 2, 3));
  code.push_back(EncodeSop1(0x04, 126, InlineU32(0)));
  code.push_back(EncodeExp0(0x09, 0x0, true, false, true));
  code.push_back(EncodeExp1(0, 0, 0, 0));
  AppendEnd(&code);

  return {"GraphicsNullVmExportDiscardsInactiveExec",
          code,
          {0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u},
          {O::V_MOV_B32, O::EXP, O::S_MOV_B64, O::S_ENDPGM}};
}

GraphicsCase GraphicsMrt0OffVmExportDiscardsInactiveExec() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x3f000000u);
  AppendVMovLiteral(&code, 1, 0x3f400000u);
  AppendVMovLiteral(&code, 2, 0x3f800000u);
  AppendVMovLiteral(&code, 3, 0x40000000u);
  code.push_back(EncodeExp0(0x00, 0xf, false));
  code.push_back(EncodeExp1(0, 1, 2, 3));
  code.push_back(EncodeSop1(0x04, 126, InlineU32(0)));
  code.push_back(EncodeExp0(0x00, 0x0, true, true, true));
  code.push_back(EncodeExp1(0, 0, 0, 0));
  AppendEnd(&code);

  return {"GraphicsMrt0OffVmExportDiscardsInactiveExec",
          code,
          {0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u},
          {O::V_MOV_B32, O::EXP, O::S_MOV_B64, O::S_ENDPGM}};
}

GraphicsCase GraphicsFinalVmExportSupersedesEarlierVmMask() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x3f000000u);
  AppendVMovLiteral(&code, 1, 0x3f400000u);
  AppendVMovLiteral(&code, 2, 0x3f800000u);
  AppendVMovLiteral(&code, 3, 0x40000000u);
  code.push_back(EncodeSop1(0x04, 126, InlineU32(0)));
  code.push_back(EncodeExp0(0x00, 0xf, false, false, true));
  code.push_back(EncodeExp1(0, 1, 2, 3));
  code.push_back(EncodeSMovB32(126, 193u));
  code.push_back(EncodeSMovB32(127, 193u));
  AppendVMovLiteral(&code, 4, 0x40400000u);
  AppendVMovLiteral(&code, 5, 0x40800000u);
  AppendVMovLiteral(&code, 6, 0x40a00000u);
  AppendVMovLiteral(&code, 7, 0x40c00000u);
  code.push_back(EncodeExp0(0x00, 0xf, true, false, true));
  code.push_back(EncodeExp1(4, 5, 6, 7));
  AppendEnd(&code);

  return {"GraphicsFinalVmExportSupersedesEarlierVmMask",
          code,
          {0x40400000u, 0x40800000u, 0x40a00000u, 0x40c00000u},
          {O::V_MOV_B32, O::S_MOV_B64, O::EXP, O::S_MOV_B32, O::S_ENDPGM}};
}

GraphicsCase GraphicsBranchPathFinalVmExportDiscardsInactiveExec() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  AppendVMovLiteral(&code, 0, 0x3f000000u);
  AppendVMovLiteral(&code, 1, 0x3f400000u);
  AppendVMovLiteral(&code, 2, 0x3f800000u);
  AppendVMovLiteral(&code, 3, 0x40000000u);
  code.push_back(EncodeExp0(0x00, 0xf, false));
  code.push_back(EncodeExp1(0, 1, 2, 3));
  code.push_back(EncodeSop1(0x04, 126, InlineU32(0)));
  code.push_back(EncodeExp0(0x09, 0x0, true, false, true));
  code.push_back(EncodeExp1(0, 0, 0, 0));
  code.push_back(EncodeSopc(0x06, InlineU32(0), InlineU32(1)));
  const auto branch_index = code.size();
  code.push_back(0);
  AppendEnd(&code);
  const auto later_export_index = code.size();
  code[branch_index] = EncodeSopp(
      0x05, static_cast<u32>(later_export_index - branch_index - 1u));
  code.push_back(EncodeSMovB32(126, 193u));
  code.push_back(EncodeSMovB32(127, 193u));
  AppendVMovLiteral(&code, 4, 0x40400000u);
  AppendVMovLiteral(&code, 5, 0x40800000u);
  AppendVMovLiteral(&code, 6, 0x40a00000u);
  AppendVMovLiteral(&code, 7, 0x40c00000u);
  code.push_back(EncodeExp0(0x00, 0xf, true, false, true));
  code.push_back(EncodeExp1(4, 5, 6, 7));
  AppendEnd(&code);

  return {"GraphicsBranchPathFinalVmExportDiscardsInactiveExec",
          code,
          {0x00000000u, 0x00000000u, 0x00000000u, 0x00000000u},
          {O::V_MOV_B32, O::EXP, O::S_MOV_B64, O::S_CMP_EQ_U32,
           O::S_CBRANCH_SCC1, O::S_MOV_B32, O::S_ENDPGM}};
}

TestCase MultipleWorkitemsGlobalId() {
  using O = ShaderOpcode;

  std::vector<u32> code = {
      EncodeVop1(0x01, 1, 0),
      EncodeVop2(0x1a, 1, InlineU32(2), 1),
      EncodeVop2(0x25, 1, Vgpr(0), 1),
      EncodeVop2(0x25, 2, InlineU32(64), 1),
      EncodeVop2(0x1a, 3, InlineU32(2), 1),
  };
  AppendBufferStoreDword(&code, 2, 3);
  AppendEnd(&code);

  TestCase test;
  test.name = "MultipleWorkitemsGlobalId";
  test.code = code;
  test.expected = {64, 65, 66, 67, 68, 69, 70, 71};
  test.opcodes = {O::V_MOV_B32, O::V_LSHLREV_B32, O::V_ADD_NC_U32,
                  O::BUFFER_STORE_DWORD, O::S_ENDPGM};
  test.compute_info.threads_num[0] = 4;
  test.compute_info.threads_num[1] = 1;
  test.compute_info.threads_num[2] = 1;
  test.compute_info.group_id[0] = true;
  test.compute_info.thread_ids_num = 1;
  test.compute_info.workgroup_register = 0;
  test.has_compute_info = true;
  test.dispatch_x = 2;
  return test;
}

TestCase DispatcherIrreducibleControlFlow() {
  using O = ShaderOpcode;

  std::vector<u32> code;
  code.push_back(EncodeSopp(0x05, 5)); // entry -> B, fallthrough A
  AppendVMovU32(&code, 0, 7);
  AppendStoreVgpr(&code, 0, 0);
  code.push_back(EncodeSopp(0x04, 1)); // A exits while SCC is initially zero
  code.push_back(EncodeSopp(0x02, 0xfffau)); // B -> A
  AppendEnd(&code);

  TestCase test;
  test.name = "DispatcherIrreducibleControlFlow";
  test.code = code;
  test.expected = {7};
  test.opcodes = {O::S_CBRANCH_SCC1, O::V_MOV_B32, O::BUFFER_STORE_DWORD,
                  O::S_CBRANCH_SCC0, O::S_BRANCH,  O::S_ENDPGM};
  return test;
}

std::vector<TestCase> MakeCases() {
  std::vector<TestCase> cases;
  cases.reserve(128);
  auto AddCase = [&cases](TestCase (*factory)()) {
    cases.push_back(factory());
  };

  AddCase(IntegerAddSubMul);
  AddCase(BitwiseOps);
  AddCase(Shifts);
  AddCase(ExactPushConstantExtent);
  AddCase(ScalarShiftCountsMaskLowBits);
  AddCase(Rdna2ScalarOpcodes);
  AddCase(ScalarTrapDisabledFallsThroughExactRaw);
  AddCase(ScalarWaitcntDepctrCapturedVmVsrc);
  AddCase(ScalarExtendedArithmetic);
  AddCase(ScalarArithmeticSccCarryBorrowOverflow);
  AddCase(ScalarMinMaxSccComparisonEdges);
  AddCase(ScalarAbsI32UpdatesScc);
  AddCase(ScalarAbsdiffBitset64AndSetprio);
  AddCase(ScalarShiftLeftAddSccCarryEdges);
  AddCase(ScalarCompareOps);
  AddCase(ScalarShiftAddAndMaskOps);
  AddCase(ScalarNotB64UpdatesScc);
  AddCase(ScalarQuadmaskB64);
  AddCase(ScalarFlbitI32B64Gpu);
  AddCase(ScalarFlbitI32B32Gpu);
  AddCase(ScalarSaveExecOps);
  AddCase(ScalarOrn2SaveexecUsesSourceOrNotExec);
  cases.push_back(ScalarOrn2SaveexecB32(32, 32));
  cases.push_back(ScalarOrn2SaveexecB32(64, 64));
  cases.push_back(ScalarOrn2SaveexecB32(32, 4));
  cases.push_back(ScalarSubvectorLoops(32));
  cases.push_back(ScalarSubvectorLoops(64));
  AddCase(ScalarGetpcWritesNextInstructionPc);
  AddCase(ScalarBitfieldPack);
  AddCase(ScalarBrevB32PreservesScc);
  AddCase(ScalarBfeI32CapturedRawSignExtends);
  AddCase(BitfieldExtractWidthPastEndEdges);
  AddCase(Scalar64BitOps);
  cases.push_back(ScalarAshrI64Edges(false));
  cases.push_back(ScalarAshrI64Edges(true));
  AddCase(ScalarAshrI64OperandsAndAliases);
  cases.push_back(ScalarAshrI64Masks(32));
  cases.push_back(ScalarAshrI64Masks(64));
  AddCase(VectorDynamicU64ShiftEdges);
  AddCase(ScalarConditionalMoveB64);
  AddCase(ScalarConditionalMoveB64PreservesMasks);
  AddCase(ScalarAndn2B64SccUsesMaskShadow);
  AddCase(ScalarMaskHighWriteInvalidatesProvenance);
  AddCase(ScalarSelectB64PreservesMaskProvenance);
  AddCase(ScalarWqmB64SelectsSccDomain);
  AddCase(ScalarWqmB64PreservesPartialMasks);
  cases.push_back(ScalarWqmB32Masks(32));
  cases.push_back(ScalarWqmB32Masks(64));
  AddCase(ScalarMaskProvenanceOverlapAndMixedBinary);
  AddCase(ScalarLiteral);
  AddCase(VectorMoves);
  AddCase(VectorVop3MoveAppliesFloatSourceModifiers);
  AddCase(VectorIntegerOps);
  AddCase(VectorFfbhI32NativeAndVop3OnGpu);
  AddCase(Vop1SdwaFfblCapturedHighWordSource);
  AddCase(Vop1SdwaNotCapturedByte0Source);
  AddCase(Vop1SdwaMovByteDestinations);
  AddCase(Vop2SdwaSubNcExactByte2Destination);
  AddCase(Vop2SdwaAddNcCapturedHighWordDestination);
  AddCase(Vop2SdwaAshrrevCapturedWord0SignExtends);
  AddCase(Vop2SdwaLshrrevCapturedByte1Source);
  AddCase(Vop2SdwaSubNcPreservesByteAndWordDestinations);
  AddCase(Vop3CvtPkI16I32Captured);
  AddCase(Vop3MulLoU16CapturedAndSelectors);
  AddCase(Vop3MadI16CapturedSelectorsAndSaturation);
  AddCase(Vop3Med3I16Captured);
  AddCase(Vop2SdwaMinU32PreservesWordDestination);
  AddCase(VectorShiftCountsMaskLowBits);
  AddCase(VectorVop3LshrrevB64Captured);
  AddCase(VectorVop3LshlrevB64Captured);
  AddCase(VectorVop3IntegerOps);
  AddCase(VectorBfeI32SignExtendsField);
  AddCase(VectorAlignByteUsesFiveBitByteOffset);
  AddCase(VectorCarryAndBitCountOps);
  AddCase(VectorMbcntUsesThreadMask);
  AddCase(VectorAddcWritesPerLaneCarryOut);
  AddCase(VectorAddcUsesPerLaneCarryIn);
  AddCase(VectorSubCoCiU32CompactAndVop3);
  AddCase(VectorSubrevCoCiU32ExactRawOnGpu);
  AddCase(VectorVop3BSubrevCoCiUsesEncodedMasks);
  AddCase(VectorVop3BCarryOutWritesSgprMask);
  AddCase(VectorVop3BCarryOutUsesEncodedSdst);
  AddCase(VectorVop3BSubCoU32UsesRdna2Opcode310);
  AddCase(VectorMadU64U32UnsignedCarryOut);
  AddCase(VectorLaneAndPackedOps);
  AddCase(Vop2PkFmacF16AccumulatesPackedHalvesIndependently);
  AddCase(Vop2PkFmacF16DppNegatesBothPackedHalves);
  AddCase(Vop3pOpselHiUsesArchitecturalSourceBits);
  AddCase(Vop3pIntegerNegationCapturedAndSelectedHalves);
  AddCase(CvtPkU8F32PacksSelectedByte);
  AddCase(CvtPkrtzF16F32SubnormalRoundsTowardZero);
  AddCase(CvtPkrtzF16F32SdwaAndOutputModifiers);
  AddCase(PackedMinMaxF16NanAndSignedZeroEdges);
  AddCase(VectorMinMaxF16Ops);
  AddCase(VectorCvtU16F16Sdwa);
  AddCase(NativeAndSdwa16BitDestinationWrites);
  AddCase(VectorMinMaxMed3F16Ops);
  AddCase(VectorSpecialF16Ops);
  AddCase(VectorFractF16CapturedAndEdges);
  AddCase(VectorFractF16Modifiers);
  AddCase(VectorCosF16CapturedSdwaAndEdges);
  AddCase(VectorSinF16SdwaAndEdges);
  AddCase(VectorWritelaneIgnoresExecMask);
  AddCase(VectorReadlaneFromInactiveWrittenLane);
  AddCase(VectorLaneWave32RuntimeSelectorWraps);
  AddCase(VectorPermlanex16);
  AddCase(VectorPermlane16FetchInactiveZero);
  AddCase(VectorPermlane16FetchInactiveFi);
  cases.push_back(VectorDpp8Captured(false));
  cases.push_back(VectorDpp8Captured(true));
  AddCase(VectorDppQuadPermuteReverse);
  AddCase(VectorDppRowXmask);
  AddCase(VectorDppBankMaskPreservesDestination);
  AddCase(VectorDppBoundsControlZeroPreservesDestination);
  AddCase(Vop3FmacF32NegatedSourceAccumulates);
  AddCase(Vop3LdexpSourceModifier);
  AddCase(Vop1MoveRelSource);
  AddCase(Vop1MoveRelDestination);
  AddCase(VectorFloatSpecialOps);
  AddCase(MadMixF16LiteralHalfSourceUsesOpsel);
  AddCase(MadMixF16NegHiIsAbsAndNegIsIndependent);
  AddCase(VectorVop3FmaF16UsesRdna2Opcode34b);
  AddCase(FloatInlineConstantF16UsesNumericValue);
  AddCase(VectorFloatControlContractPreservesInfNan);
  AddCase(VectorFloatArithmeticOps);
  AddCase(VectorMinMaxF32NanAndSignedZeroEdges);
  AddCase(VectorMed3F32NanUsesMin3Path);
  AddCase(VectorFloatConversionOps);
  AddCase(VectorFrexpF32Edges);
  AddCase(CvtF32ToIntSaturatesNaNAndOutOfRange);
  AddCase(VectorSpecialF32FlushesDenormalInputs);
  AddCase(VectorRcpIflagF32IntegerReciprocal);
  AddCase(VectorSinCosMaxFiniteSpecialCases);
  AddCase(VectorCompareOps);
  AddCase(VectorVop3CompareEqI64OnGpu);
  AddCase(VectorVop3CompareEqU64OnGpu);
  AddCase(VectorVop3CompareGtU64OnGpu);
  AddCase(VectorVopcCompareLtU64OnGpu);
  AddCase(VectorVop3CompareNeU64OnGpu);
  AddCase(VectorVopcCmpxNeU64CapturedExecMask);
  AddCase(VectorVop3CmpxNeI64CapturedExecMask);
  AddCase(VectorCompareClassF32);
  AddCase(VectorVopcSdwaCmpxClassF32CapturedExecMask);
  AddCase(VectorCompareF16Ops);
  AddCase(Wave32VccMasksPreserveOtherHalf);
  AddCase(Vop2SdwaCndmaskSourceModifier);
  AddCase(Vop2SdwaCndmaskCapturedByte3Source);
  AddCase(Vop3CndmaskUsesSgprMaskLaneBits);
  AddCase(Vop3CndmaskAllowsDataSourceModifier);
  AddCase(VectorCompareExecOps);
  AddCase(VectorVop3FloatCompareNegSourceModifier);
  AddCase(VectorVop3CmpxWritesExecMask);
  AddCase(VectorVopcSdwaCmpxWritesExecMask);
  AddCase(VectorVopcCmpxGtU16CapturedSdwaExecMask);
  AddCase(VectorVopcCmpxLtU16CapturedSdwaExecMask);
  AddCase(VectorVopcCmpNgtF16CapturedSdwaAndEdges);
  AddCase(VectorVopcCmpNltF16CapturedSdwaAndEdges);
  AddCase(VectorVopcCmpxNgtF16CapturedSdwaExecMask);
  AddCase(VectorCompareInvertedMaskSelect);
  AddCase(BranchSelect);
  AddCase(SimpleLoop);
  AddCase(SharedReturnKeepsSelectedValues);
  AddCase(BranchVccnzUsesWaveMask);
  AddCase(BranchVccnzUsesCarryProducedWaveMask);
  AddCase(ScalarMemoryLoadVariants);
  AddCase(ScalarLoadSignedImmediateOffsetAddsSoffset);
  AddCase(ScalarLoadAlignsComponentsAndMasksAddress);
  AddCase(BufferLoadStore);
  AddCase(BufferLoadDwordOffenIdxenUsesVaddrPlusOneOffset);
  AddCase(BufferStoreDwordOffenIdxenUsesVaddrPlusOneOffset);
  AddCase(BufferLoadDwordNoAddressFlagsIgnoresVaddr);
  AddCase(BufferLoadDwordIdxenUsesDescriptorStride);
  AddCase(BufferStoreDwordIdxenUsesDescriptorStride);
  AddCase(BufferStoreDwordAppliesHostOffset);
  AddCase(BufferOffsetsUsePackedLaneAndStorageFallback);
  AddCase(BufferLoadVariants);
  AddCase(BufferLoadDwordx2SnapshotsOverlappingAddress);
  AddCase(BufferLoadDwordx3SnapshotsOverlappingAddress);
  AddCase(BufferLoadDwordx4SnapshotsOverlappingAddress);
  AddCase(BufferLoadDwordx4ZeroesOnlyOutOfBoundsTail);
  AddCase(BufferStoreDwordx4DropsOnlyOutOfBoundsTail);
  AddCase(BufferLoadFormatXyzwRejectsPartialRecord);
  AddCase(BufferStoreFormatXyzwDropsPartialRecord);
  AddCase(BufferLoadFormatXChecksOnlyTransferredComponent);
  AddCase(BufferStoreFormatXChecksOnlyTransferredComponent);
  AddCase(BufferLoadFormatXyChecksOnlyTransferredComponents);
  AddCase(BufferStoreFormatXyChecksOnlyTransferredComponents);
  AddCase(BufferStoreVariants);
  AddCase(BufferFormatVariants);
  AddCase(BufferLoadFormatXyzwSnapshotsOverlappingAddress);
  AddCase(BufferLoadFormatXyzwResource32_32FloatAppliesXy01);
  AddCase(BufferLoadFormatXyzwResource323232FloatRepeatsSource);
  AddCase(BufferLoadFormatXyzwResource8_8_8_8UintAppliesWzy1);
  AddCase(BufferLoadFormatXyzwInactiveExecPreservesOverlappingAddress);
  AddCase(BufferFormatStoreVariants);
  AddCase(BufferStoreFormatXResource16UintWritesHalfword);
  AddCase(BufferStoreFormatXResource16UintPreservesAdjacentLanes);
  AddCase(BufferStoreFormatXyzwSnorm16CapturedSkinningVectors);
  AddCase(BufferStoreFormatXSnorm16ClampsRoundsAndPreservesHalfwords);
  AddCase(BufferLoadFormatXResource8UintZeroExtendsByte);
  AddCase(BufferLoadFormatXyResource88UintExtractsBytes);
  AddCase(BufferLoadFormatXyResource8888UnormConvertsFirstTwoComponents);
  AddCase(BufferStoreFormatXyResource88UintWritesBytes);
  AddCase(BufferStoreFormatXyzResource3232UintWritesTwoDwords);
  AddCase(BufferStoreFormatXyzwResource323232UintWritesThreeDwords);
  AddCase(BufferStoreFormatXyResource32UintWritesOneDword);
  AddCase(BufferStoreFormatXyzResource8UintWritesOneByte);
  AddCase(BufferStoreFormatXAddTidUsesLaneIndex);
  AddCase(BufferStoreFormatXDropsOutOfRangeRecord);
  AddCase(TBufferLoadVariants);
  AddCase(TBufferLoadFormatXyzwSnapshotsOverlappingAddress);
  AddCase(TBufferLoadFormatXyzwPackedSnapshotsOverlappingAddress);
  AddCase(TBufferLoadFormatX8UintZeroExtendsByte);
  AddCase(TBufferLoadFormatX8888UintExtractsFirstByte);
  AddCase(TBufferLoadFormatXIdxenUsesDescriptorStride);
  AddCase(TBufferLoadFormatX16FloatConvertsToFloat);
  AddCase(TBufferStoreFormatX8UintWritesOneByte);
  AddCase(TBufferStoreFormatXSintWritesSubDword);
  AddCase(TBufferLoadFormatXSintSignExtendsSubDword);
  AddCase(TBufferLoadFormatXy1616IntegerComponents);
  AddCase(TBufferStoreFormatXy1616IntegerComponents);
  AddCase(TBufferLoadFormatXyz16161616UintLoadsHalfwords);
  AddCase(TBufferLoadFormatXy1616UnormConvertsToFloat);
  AddCase(TBufferLoadFormatXy88UnormConvertsToFloat);
  AddCase(TBufferLoadFormatXy88SnormConvertsToFloat);
  AddCase(TBufferLoadFormatXy8888UnormConvertsFirstTwoComponents);
  AddCase(TBufferLoadFormatXyzw8888UintExtractsBytes);
  AddCase(TBufferLoadFormatXyzw1010102SnormConvertsToFloat);
  AddCase(TBufferLoadFormatXyz111110FloatUnpacks);
  AddCase(TBufferLoadFormatXyzw3232FloatZerosMissingComponents);
  AddCase(TBufferStoreFormatXyzw3232FloatWritesOnlyPresentComponents);
  AddCase(TBufferStoreFormatXy88IntegerComponents);
  AddCase(TBufferLoadFormatXy88IntegerComponents);
  AddCase(TBufferStoreVariants);
  AddCase(FlatLoadVariants);
  AddCase(FlatSubdwordLoadsApplyByteOffset);
  AddCase(FlatVirtualAddressRebasesGuestAllocation);
  AddCase(GlobalSignedImmediateRebasesBeforeSaddr);
  AddCase(FlatSegmentIgnoresSaddrAndMasksOffsetMsb);
  AddCase(ScratchIsPrivatePerInvocation);
  AddCase(DsReadWriteVariants);
  AddCase(DsWriteB16D16HiCapturedUsesHighHalf);
  AddCase(DsReadU16D16CapturedPreservesHighHalf);
  AddCase(DsReadU16D16HiCapturedPreservesLowHalf);
  AddCase(DsAppendConsumeUsesEncodedLdsSelector);
  AddCase(DsAppendUsesEncodedGdsSelector);
  AddCase(DsGdsSubdwordAndAtomicWrites);
  AddCase(DsReadWrite2Variants);
  AddCase(DsWideReadSnapshotsOverlappingAddress);
  AddCase(DsReadWrite2EqualOffsetsUseData0);
  AddCase(DsWideLdsPartialBounds);
  AddCase(DsWideGdsPartialBounds);
  AddCase(DsAtomicNoReturnVariants);
  AddCase(DsAtomicReturnVariants);
  for (bool decrement : {false, true}) {
    for (bool gds : {false, true}) {
      cases.push_back(DsBoundedAtomicBoundaries(decrement, gds));
      for (u32 wave_size : {32u, 64u}) {
        cases.push_back(DsBoundedAtomicContention(decrement, gds, wave_size));
      }
    }
  }
  AddCase(DsMiscVariants);
  AddCase(DsFloatMinMaxUsesSeparateCompareOperand);
  AddCase(DsSwizzleInvalidSourceLaneZero);
  AddCase(DsBpermuteCapturedExecOffsetAndWrap);
  AddCase(DsBpermuteWave64UsesIndependentHalves);
  AddCase(Wave64CrossHalfLaneAndLds);
  AddCase(Wave64RawMasksAndScalarBranch);
  AddCase(Wave64PartialMultidimensionalWorkgroup);
  AddCase(Wave64AppendConsumeHighHalf);
  AddCase(BufferAtomicVariants);
  AddCase(BufferAtomicCmpSwapExactRaw);
  AddCase(BufferAtomicGlc0DoesNotReturnOldValue);
  AddCase(BufferAtomicFMinExactRawGlcModes);
  AddCase(BufferAtomicFMinSpecialValues);
  AddCase(BufferAtomicFMinContendedWorkgroup);
  AddCase(BufferAtomicFMaxExactRawGlcModes);
  AddCase(BufferAtomicFMaxSpecialValues);
  AddCase(BufferAtomicFMaxContendedWorkgroup);
  AddCase(ImageLoadVariants);
  AddCase(ImageLoadR32UintUsesIntegerSampledImage);
  AddCase(ImageLoadFmaskUsesNativeSampleMapping);
  AddCase(ImageLoadR32SintUsesSignedSampledImage);
  AddCase(ImageLoadPackedUintUnpacksAndSwizzles);
  AddCase(ImageSamplePackedUintConvertsSampleAndGather);
  AddCase(ImageLoadR128IgnoresAdjacentMaskSgprs);
  AddCase(ImageLoad1DUsesScalarCoordinate);
  AddCase(ImageGather2DInstructionWith1DDescriptor);
  AddCase(ImageLoad1DArrayUsesLayerCoordinate);
  AddCase(ImageLoad1DArrayDescriptorUsesSelectedLayer);
  AddCase(ImageLoadMipUsesVaddr2Lod2D);
  AddCase(ImageLoadMipNsaUsesSelectedAddressVgprs);
  AddCase(ImageLoadA16UintCoordsOnGpu);
  AddCase(ImageGetResinfoDmaskWidthHeight);
  AddCase(ImageGetResinfoDmaskMipLevels);
  AddCase(ImageSampleAndGather);
  AddCase(ImageGatherLodApproximatesLevelZero);
  AddCase(ImageD16GatherPacksHalfPairs);
  AddCase(ImageSampleA16SamplerCoordsOnGpu);
  AddCase(ImageSampleOpcodeAliasUsesNormalCoords);
  AddCase(ImageSampleA16OffsetKeepsTexelOffset32BitOnGpu);
  AddCase(ImageSampleA16CompareBiasRdna2AddressOrder);
  AddCase(ImageGatherCompareOpcodes);
  AddCase(ImageStoreVariants);
  AddCase(ImageD16StoreUnpacksHalfPairs);
  AddCase(ImageStoreMipSelectsPpsa01340Descriptor);
  AddCase(ImageStoreRgbOneUsesInverseSwizzle);
  AddCase(ImageStoreDuplicateSelectorUsesInverseSwizzle);
  AddCase(ImageStoreBgraUsesInverseSwizzle);
  AddCase(ImageStoreYzwxUsesInverseSwizzle);
  AddCase(ImageStoreR32FloatUsesFormatlessStorageImage);
  AddCase(ImageStoreR32SintUsesRawUintView);
  AddCase(ImageStoreR32UintUsesFormatlessStorageImage);
  AddCase(ImageStorePackedUintSaturatesChannels);
  AddCase(ImageStorePackedUintHonorsSparseDmask);
  AddCase(ComputeTgSizeSgprUsesWaveMetadata);
  AddCase(ImageStoreAndAtomicShareTypedBinding);
  AddCase(ImageAtomicSwapReturnsPreviousTexel);
  AddCase(ImageStoreAndAtomicUseSeparateBindings);
  AddCase(ImageAtomicVariants);
  AddCase(ImageAtomicGlc0DoesNotReturnOldValue);
  AddCase(MultipleWorkitemsGlobalId);
  AddCase(DispatcherIrreducibleControlFlow);

  return cases;
}

std::vector<GraphicsCase> MakeGraphicsCases() {
  return {
      GraphicsInterpolationExport(),
      GraphicsPositionWExport(),
      GraphicsPackedHalfCentroid(),
      GraphicsPackedHalfInputAlias(false),
      GraphicsPackedHalfInputAlias(true),
      GraphicsSmoothRawInputAlias(),
      GraphicsAncillaryLayer(false),
      GraphicsAncillaryLayer(true),
      GraphicsAncillarySampleId(),
      GraphicsFlatInterpolatorExport(),
      GraphicsDsAddtidScratchExport(),
      GraphicsDirectSgprPushConstantExport(),
      GraphicsInlineSrtScalarPromotionExport(),
      GraphicsNullVmExportDiscardsInactiveExec(),
      GraphicsMrt0OffVmExportDiscardsInactiveExec(),
      GraphicsFinalVmExportSupersedesEarlierVmMask(),
      GraphicsBranchPathFinalVmExportDiscardsInactiveExec(),
  };
}

void CheckPs5GameExampleImageClearRuntimeShape() {
  const auto MakeCode = [] {
    std::vector<u32> code;
    AppendVop3(&code, 0x346u, 4, 8, InlineU32(6), Vgpr(0));
    for (u32 i = 0; i < 4; i++) {
      code.push_back(EncodeVop1(0x01u, i, i + 4u));
    }
    code.push_back(EncodeMubuf0(0x07u, 0, true, false));
    code.push_back(EncodeMubuf1(0, 0, 4));
    AppendEnd(&code);
    return code;
  };
  std::array<u32, 8> user_data{};
  user_data[0] = 0x00010000u;
  user_data[1] = 16u << 16u;
  user_data[2] = 64;
  user_data[3] =
      (static_cast<uint32_t>(Prospero::BufferFormat::k32_32_32_32UInt) << 12u) |
      4u | (5u << 3u) | (6u << 6u) | (7u << 9u);
  std::fill(user_data.begin() + 4, user_data.end(), 0xff000000u);
  ShaderComputeInputInfo compute{};
  compute.threads_num[0] = 64;
  compute.threads_num[1] = 1;
  compute.threads_num[2] = 1;
  compute.dispatch_threads_num[0] = 64;
  compute.dispatch_threads_num[1] = 1;
  compute.dispatch_threads_num[2] = 1;
  compute.group_id[0] = true;
  compute.dispatch_thread_dimensions = true;
  compute.wave_size = 64;
  compute.thread_ids_num = 1;
  compute.workgroup_register = 8;
  u32 scalar_clear = 0x40404040u;
  bool clean_scalar = false;

  const auto Compile = [&](const std::vector<u32> &code) {
    ShaderRecompiler::CompileOptions options;
    options.stage = ShaderType::Compute;
    options.wave_size = 64;
    options.user_data_base = 0;
    options.user_data = user_data;
    options.input_info.compute = &compute;
    options.dump_ir = false;
    auto translated = ShaderRecompiler::TranslateProgram(code, options);
    auto resource_plan =
        ShaderRecompiler::IR::ExtractResourcePlan(translated.program);
    ShaderRecompiler::IR::ResourceSnapshot resources;
    ShaderRecompiler::IR::ResourceSpecialization specialization;
    const ShaderRecompiler::IR::SrtRuntime runtime{
        .user_data = options.user_data,
        .shader_base = reinterpret_cast<uint64_t>(code.data()),
        .userdata = &scalar_clear,
        .read_specialization_memory = clean_scalar
            ? +[](void *data, uint64_t address, uint32_t *word) {
                if (address != reinterpret_cast<uint64_t>(data)) return false;
                *word = *static_cast<uint32_t *>(data);
                return true;
              } : nullptr,
    };
    Require("Ps5GameExampleImageClear", "resource materialization",
            ShaderRecompiler::IR::MaterializeResources(
                resource_plan, runtime, resources, specialization),
            "runtime clear resources could not be materialized");
    auto result = ShaderRecompiler::CompileProgram(
        std::move(translated), options, specialization);
    ValidateSpirv("Ps5GameExampleImageClear", result.spirv);
    return resources;
  };

  const auto code = MakeCode();
  auto positive = Compile(code);

  compute.stage.resources = positive;
  ShaderBufferResource descriptor{};
  u32 packed_clear = 0;
  uint64_t size = 0;
  Require("Ps5GameExampleImageClear", "runtime shape",
          ResolveComputeBufferFill(compute, 64, 1, 1, 0x61u, descriptor,
                                   packed_clear, size) &&
              descriptor.Base48() == 0x10000u && size == 64u * 16u &&
              packed_clear == 0xff000000u,
          "exact Prospero runtime binding did not resolve to a complete clear");

  auto wrong_index = code;
  wrong_index[0] = (wrong_index[0] & ~(0x3ffu << 16u)) | (0x347u << 16u);
  compute.stage.resources = Compile(wrong_index);
  Require("Ps5GameExampleImageClear", "add-before-shift address",
          !ResolveComputeBufferFill(compute, 64, 1, 1, 0x61u, descriptor,
                                    packed_clear, size),
          "V_ADD_LSHL was mistaken for V_LSHL_ADD contiguous coverage");

  user_data[7] ^= 1u;
  compute.stage.resources = Compile(code);
  Require("Ps5GameExampleImageClear", "non-repeated clear",
          !ResolveComputeBufferFill(compute, 64, 1, 1, 0x61u, descriptor,
                                    packed_clear, size),
          "non-uniform uint4 data was replaced with a color clear");
  compute.stage.resources = positive;
  compute.dispatch_threads_num[0] = 32;
  Require("Ps5GameExampleImageClear", "partial dispatch",
          !ResolveComputeBufferFill(compute, 32, 1, 1, 0x61u, descriptor,
                                    packed_clear, size),
          "partial buffer coverage was classified as a complete clear");

  // Same descriptor/dispatch as GTA3, with the stored value encoded in the
  // shader.
  user_data = {0x00200000u, 4u << 16u, 64u, 0x14204u};
  compute.workgroup_register = 4;
  compute.dispatch_thread_dimensions = false;
  std::vector<u32> scalar_code;
  AppendVop3(&scalar_code, 0x346u, 0, 4, InlineU32(6), Vgpr(0));
  scalar_code.push_back(EncodeVop1(0x01u, 1, InlineU32(0)));
  scalar_code.push_back(EncodeMubuf0(0x04u, 0, true, false));
  scalar_code.push_back(EncodeMubuf1(1, 0, 0));
  AppendEnd(&scalar_code);
  auto scalar = Compile(scalar_code);
  compute.stage.resources = scalar;
  Require("Ps5GameExampleImageClear", "inline scalar fill",
          ResolveComputeBufferFill(compute, 1, 1, 1, 0x41u, descriptor,
                                   packed_clear, size) &&
              descriptor.Base48() == 0x200000u && size == 256u &&
              packed_clear == 0u,
          "GTA3's actual scalar store was not recognized from IR");
  Require("Ps5GameExampleImageClear", "excess dispatch",
          !ResolveComputeBufferFill(compute, 2, 1, 1, 0x41u, descriptor,
                                    packed_clear, size),
          "excess invocation coverage was accepted as a fill");
  auto alias = scalar.buffers.front();
  compute.stage.resources.buffers.push_back(alias);
  Require("Ps5GameExampleImageClear", "aliased scalar input",
          !ResolveComputeBufferFill(compute, 1, 1, 1, 0x41u, descriptor,
                                    packed_clear, size),
          "a scalar read aliasing the destination was accepted as uniform");
  compute.stage.resources = scalar;
  compute.stage.resources.buffers[0].dwords[3] =
      (static_cast<u32>(Prospero::BufferFormat::k32Float) << 12u) | 0x204u;
  Require("Ps5GameExampleImageClear", "wrong store format",
          !ResolveComputeBufferFill(compute, 1, 1, 1, 0x41u, descriptor,
                                    packed_clear, size),
          "a format that changes the stored value was accepted as a uint fill");
  // A body change preserving every descriptor and dispatch field must change
  // the result.
  scalar_code[2] = EncodeVop1(0x01u, 1, InlineU32(7));
  compute.stage.resources = Compile(scalar_code);
  Require("Ps5GameExampleImageClear", "changed store value",
          ResolveComputeBufferFill(compute, 1, 1, 1, 0x41u, descriptor,
                                   packed_clear, size) &&
              packed_clear == 7u,
          "clear recognition ignored the shader's actual stored value");
  scalar_code[2] = EncodeVop1(0x01u, 1, Vgpr(0));
  compute.stage.resources = Compile(scalar_code);
  Require("Ps5GameExampleImageClear", "varying store value",
          !ResolveComputeBufferFill(compute, 1, 1, 1, 0x41u, descriptor,
                                    packed_clear, size),
          "a varying store with identical resources was treated as a fill");

  const auto scalar_address = reinterpret_cast<uint64_t>(&scalar_clear);
  user_data[4] = static_cast<u32>(scalar_address);
  user_data[5] = static_cast<u32>(scalar_address >> 32u) | (16u << 16u);
  user_data[6] = 1;
  user_data[7] = 0x4dfacu;
  compute.workgroup_register = 8;
  scalar_code.clear();
  AppendVop3(&scalar_code, 0x346u, 0, 8, InlineU32(6), Vgpr(0));
  scalar_code.push_back(EncodeSmem0(0x08u, 106, 2));
  scalar_code.push_back(EncodeSmem1(0, 125));
  scalar_code.push_back(EncodeVop1(0x01u, 1, 106));
  scalar_code.push_back(EncodeMubuf0(0x04u, 0, true, false));
  scalar_code.push_back(EncodeMubuf1(1, 0, 0));
  AppendEnd(&scalar_code);
  clean_scalar = true;
  auto loaded = Compile(scalar_code);
  compute.stage.resources = loaded;
  Require("Ps5GameExampleImageClear", "scalar-loaded fill",
          ResolveComputeBufferFill(compute, 1, 1, 1, 0x41u, descriptor,
                                   packed_clear, size) &&
              packed_clear == scalar_clear && descriptor.Base48() == 0x200000u,
          "GTA3's scalar input was confused with its destination");
  clean_scalar = false;
  compute.stage.resources = Compile(scalar_code);
  Require("Ps5GameExampleImageClear", "unavailable clean scalar",
          !ResolveComputeBufferFill(compute, 1, 1, 1, 0x41u, descriptor,
                                    packed_clear, size),
          "a scalar without a clean reader was replaced by a fill");
  std::printf("[host]    %-32s ok\n", "Ps5GameExampleImageClear");
}

void CheckTessellationProgram(const char *name, u32 ls_stride, u32 hs_stride) {
  using namespace ShaderRecompiler;
  const bool multiplied_stride = hs_stride == 112;
  const u32 local_address = multiplied_stride ? 18 : 21;
  const u32 control_point = multiplied_stride ? 30 : 34;
  const u32 relative_patch = multiplied_stride ? 28 : 32;
  const u32 output_address = multiplied_stride ? 31 : 35;
  const u32 input_address = multiplied_stride ? 25 : 29;
  std::array<std::vector<u32>, 3> code;
  auto &local = code[0];
  // The fused LS addresses one control point using its v3 ordinal.
  local.push_back(EncodeVop2(0x0b, local_address, 255u, 3));
  local.push_back(ls_stride);
  local.push_back(EncodeDs0(0x0e, (3u << 8u) | 1u));
  local.push_back(EncodeDs1Ex(0, 5, 2, local_address));
  local.push_back(EncodeSop1(0x20, 0, 6));
  local.push_back(0xffffffffu); // Shader footer is not executable after LS handoff.

  auto &control = code[1];
  AppendVop3(&control, 0x365, 0, 193u, InlineU32(0));
  AppendVop3(&control, 0x366, 0, 193u, Vgpr(0));
  control.push_back(EncodeSopp(0x0a));
  control.push_back(EncodeVopc(0xd1, 249u, 3));
  control.push_back(EncodeVopcSdwa(0, 0, 0, 6, 1, 0, 0, 0, 0, 0, 0, 0, 1));
  AppendVop3(&control, 0x148, control_point, Vgpr(1), InlineU32(8),
             InlineU32(5));
  AppendVop3(&control, 0x148, relative_patch, Vgpr(1), InlineU32(0),
             InlineU32(8));
  if (multiplied_stride) {
    // The later patch writes 112-byte outputs but reads 108-byte LS records.
    // The second multiply overwrites packed v1; only memory consumers identify
    // which of the two independently computed addresses supplies each stride.
    control.push_back(EncodeVop2(0x0b, 0, 255u, control_point));
    control.push_back(hs_stride);
    control.push_back(EncodeVop2(0x0b, 1, 255u, control_point));
    control.push_back(ls_stride);
    AppendVop3(&control, 0x143, output_address, 255u, Vgpr(relative_patch),
               Vgpr(0));
    control.push_back(3 * hs_stride);
    AppendVop3(&control, 0x143, input_address, 255u, Vgpr(relative_patch),
               Vgpr(1));
    control.push_back(3 * ls_stride);
  } else {
    control.push_back(EncodeSopk(0x00, 106, 3 * hs_stride));
    control.push_back(EncodeVop2(0x0b, 2, 249u, 1));
    control.push_back(EncodeVop2Sdwa(106, 6, 0, 6, 0, 0, 0, 0, 0, 0, 0, 1));
    AppendVop3(&control, 0x346, output_address, Vgpr(control_point), InlineU32(7),
               Vgpr(2));
    control.push_back(EncodeVop2(0x0b, input_address, 255u, control_point));
    control.push_back(ls_stride);
  }
  control.push_back(EncodeDs0(0x37, (3u << 8u) | 1u));
  control.push_back(EncodeDs1Ex(10, 0, 0, input_address));
  control.push_back(EncodeMubuf0(0x1d, 28));
  control.push_back(EncodeMubuf1(10, 2, output_address, 2));
  // Keep the control-point-dependent value and the last written dword live.
  control.push_back(EncodeMubuf0(0x1c, hs_stride - 8));
  control.push_back(EncodeMubuf1(0, 2, output_address, 2));
  // The game reuses previously written data VGPRs for CP0-only ring addresses.
  AppendVMovLiteral(&control, 4, 0x42280000u);
  AppendVMovLiteral(&control, 5, 0x422c0000u);
  control.push_back(EncodeVopc(0xd4, InlineU32(1), control_point));
  control.push_back(EncodeVop2(0x1a, 4, InlineU32(4), relative_patch));
  control.push_back(EncodeVop2(0x1a, 6, InlineU32(6), relative_patch));
  control.push_back(EncodeVop2(0x26, 5, 255u, 6));
  control.push_back(0x7fc0);
  for (u32 i = 0; i < 4; i++) {
    AppendVMovLiteral(&control, i, std::bit_cast<u32>(static_cast<float>(i + 1)));
  }
  control.push_back(EncodeMubuf0(0x1e));
  control.push_back(EncodeMubuf1(0, 2, 4, 4));
  for (u32 i = 0; i < 4; i++) {
    control.push_back(EncodeMubuf0(0x1c, i * 16));
    control.push_back(EncodeMubuf1(i, 2, 5, 2));
  }
  AppendEnd(&control);

  auto &evaluation = code[2];
  AppendVop3(&evaluation, 0x169, 24, 255u, Vgpr(7));
  evaluation.push_back(3 * hs_stride);
  evaluation.push_back(EncodeMubuf0(0x0d, 28));
  evaluation.push_back(EncodeMubuf1(10, 2, 24, 4));
  evaluation.push_back(EncodeMubuf0(0x0d, 2 * hs_stride + 28));
  evaluation.push_back(EncodeMubuf1(12, 2, 24, 4));
  evaluation.push_back(EncodeExp0(0x0c, 0xf));
  evaluation.push_back(EncodeExp1(5, 6, 10, 12));
  AppendEnd(&evaluation);

  ShaderTessellationInputInfo tess{.input_control_points = 3,
                                  .output_control_points = 3,
                                  .domain = 1,
                                  .partitioning = 2,
                                  .output_topology = 2};
  AnalyzeTessellationPrograms(local, control, tess);
  Require(name, "decoded interface",
          tess.ls_stride == ls_stride && tess.hs_stride == hs_stride,
          "captured LS and HS address arithmetic must produce distinct strides");

  constexpr std::array stages{ShaderType::Local, ShaderType::TessellationControl,
                              ShaderType::TessellationEvaluation};
  for (u32 stage = 0; stage < stages.size(); stage++) {
    ShaderVertexInputInfo vertex;
    vertex.logical_stage = stages[stage];
    vertex.tess = tess;
    CompileOptions options;
    options.stage = stages[stage];
    options.input_info.vertex = &vertex;
    auto translated = TranslateProgram(code[stage], options);
    std::set<u32> local_offsets, evaluation_offsets, factor_offsets, patch_offsets;
    for (const auto *block : translated.program.blocks) {
      for (const auto &inst : *block) {
        if (inst.GetOpcode() != IR::ValueOpcode::GetTessellationAttribute &&
            inst.GetOpcode() != IR::ValueOpcode::SetTessellationAttribute) {
          continue;
        }
        if (!inst.Arg(1).IsImmediate()) {
          continue;
        }
        switch (static_cast<IR::TessellationAttribute>(inst.Arg(0).U32())) {
        case IR::TessellationAttribute::LocalOutput:
          local_offsets.insert(inst.Arg(1).U32());
          break;
        case IR::TessellationAttribute::EvaluationInput:
          evaluation_offsets.insert(inst.Arg(1).U32());
          break;
        case IR::TessellationAttribute::Factor:
          factor_offsets.insert(inst.Arg(1).U32());
          break;
        case IR::TessellationAttribute::PatchOutput:
          patch_offsets.insert(inst.Arg(1).U32());
          break;
        default:
          break;
        }
      }
    }
    Require(name, "separate DS offsets", stage != 0 || local_offsets == std::set<u32>{4, 12},
            "DS_WRITE2 must preserve both independently encoded offsets");
    Require(name, "offchip component addressing",
            stage != 2 ||
                evaluation_offsets == std::set<u32>{28, 2 * hs_stride + 28},
            "TES control point and component offsets must survive lowering");
    Require(name, "triangle factor layout",
            stage != 1 || factor_offsets == std::set<u32>{0, 4, 8, 12},
            "the four packed guest factors must retain their order");
    Require(name, "predicated patch addresses",
            stage != 1 || patch_offsets == std::set<u32>{0x7fc0, 0x7fd0, 0x7fe0, 0x7ff0},
            "CP0 patch stores must use the address assigned on their active predicate");
    auto result = CompileProgram(std::move(translated), options, {});
    ValidateSpirv(name, result.spirv);
    spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_2);
    std::string assembly;
    Require(name, "disassembly", tools.Disassemble(result.spirv, &assembly),
            "failed to disassemble tessellation shader");
    Require(name, "native local inputs",
            stage != 0 || (assembly.find("VertexIndex") != std::string::npos &&
                           assembly.find("InstanceIndex") != std::string::npos),
            "LS v2/v5 must read native vertex/instance indices");
    Require(name, "control point lane",
            stage != 1 || (assembly.find("InvocationId") != std::string::npos &&
                           assembly.find("SubgroupLocalInvocationId") == std::string::npos),
            "HS lane masks must use control point invocation IDs");
    Require(name, "control point barrier",
            stage != 1 || (assembly.find("OpMemoryModel Logical GLSL450") != std::string::npos &&
                           assembly.find("OpControlBarrier %uint_2 %uint_4 %uint_0") != std::string::npos),
            "HS barriers must match GLSL450 control point synchronization semantics");
    Require(name, "factor builtins",
            stage != 1 || (assembly.find("TessLevelOuter") != std::string::npos &&
                           assembly.find("TessLevelInner") != std::string::npos),
            "triangle factors require outer[4] and inner[2] Vulkan builtins");
    Require(name, "native domain and winding",
            stage != 2 || (assembly.find("TessCoord") != std::string::npos &&
                           assembly.find("Triangles") != std::string::npos &&
                           assembly.find("SpacingFractionalOdd") != std::string::npos &&
                           assembly.find("VertexOrderCw") != std::string::npos),
            "TES must preserve guest triangle domain, partitioning, and winding");
  }
  std::printf("[host]    %-32s ok\n", name);
}

void CheckTessellationPrograms() {
  CheckTessellationProgram("TessellationShiftedStride", 124, 128);
  CheckTessellationProgram("TessellationMultipliedStride", 108, 112);
}

void CheckEmbeddedFetchVertexOffset() {
  const auto MakeFetch = [](std::initializer_list<std::pair<u32, u32>> adds,
                            std::optional<std::pair<u32, u32>> late_add = {},
                            u32 accumulator_vgpr = 0, bool ngg_sad = false,
                            bool local = false) {
    std::vector<u32> code;
    code.push_back(EncodeSMovB32(0, InlineU32(0)));
    code.push_back(EncodeSmem0(0x02u, 20, 4));
    code.push_back(EncodeSmem1(0));
    const auto AppendOffsets = [&]() {
      for (const auto [sgpr, index_vgpr] : adds) {
        if (ngg_sad) {
          AppendVop3(&code, 0x15du, accumulator_vgpr, sgpr, InlineU32(0),
                     Vgpr(index_vgpr));
        } else {
          AppendVop3B(&code, 0x30fu, accumulator_vgpr, 0, sgpr,
                      Vgpr(index_vgpr));
        }
      }
    };
    if (ngg_sad) {
      AppendOffsets();
    }
    code.push_back(EncodeVop2(0x01u, 0, Vgpr(local ? 5 : 8), local ? 2 : 5));
    if (!ngg_sad) {
      AppendOffsets();
    }
    code.push_back(EncodeMubuf0(0x03u, 0, true));
    code.push_back(EncodeMubuf1(9, 5, 0));
    if (late_add.has_value()) {
      AppendVop3B(&code, 0x30fu, 0, 0, late_add->first, Vgpr(late_add->second));
    }
    if (local) {
      AppendVMovU32(&code, 20, 0);
      code.push_back(EncodeDs0(0x0e, 1u << 8u));
      code.push_back(EncodeDs1Ex(0, 10, 9, 20));
      code.push_back(EncodeDs0(0x0e, (3u << 8u) | 2u));
      code.push_back(EncodeDs1Ex(0, 12, 11, 20));
      code.push_back(EncodeSop1(0x20, 0, 6));
      code.push_back(0xffffffffu);
    } else {
      AppendEnd(&code);
    }
    return code;
  };

  const auto Compile = [&](const char *name, const std::vector<u32> &code,
                           u32 slot10, ShaderType stage = ShaderType::Vertex,
                           Prospero::BufferFormat format = Prospero::BufferFormat::k32_32_32_32Float) {
    std::array<u32, 11> user_data{};
    user_data[10] = slot10;
    ShaderVertexInputInfo vertex;
    vertex.logical_stage = stage;
    vertex.tess = {.input_control_points = 3, .output_control_points = 3,
                   .ls_stride = 124, .hs_stride = 128, .domain = 1,
                   .partitioning = 2, .output_topology = 2};
    vertex.fetch_embedded = true;
    vertex.fetch_buffer_reg = 0;
    vertex.fetch_attrib_reg = 2;
    vertex.resources_num = 1;
    vertex.resources[0].fields[3] =
        BufferFormat(format) << 12u | DstSel(4, 5, 6, 7);
    vertex.resources_dst[0].attr_id = 0;
    vertex.resources_dst[0].registers_num = 4;

    ShaderRecompiler::CompileOptions options;
    options.stage = stage;
    options.user_data_base = 8;
    options.user_data = user_data;
    options.input_info.vertex = &vertex;

    auto translated = ShaderRecompiler::TranslateProgram(code, options);
    auto resource_plan =
        ShaderRecompiler::IR::ExtractResourcePlan(translated.program);
    ShaderRecompiler::IR::ResourceSnapshot resources;
    ShaderRecompiler::IR::ResourceSpecialization specialization;
    const ShaderRecompiler::IR::SrtRuntime runtime{
        .user_data = options.user_data,
        .shader_base = reinterpret_cast<uint64_t>(code.data()),
    };
    Require(name, "resource materialization",
            ShaderRecompiler::IR::MaterializeResources(
                resource_plan, runtime, resources, specialization),
            "embedded fetch resources could not be materialized");
    auto result = ShaderRecompiler::CompileProgram(
        std::move(translated), options, specialization);
    Require(name, "fetch rewrite",
            result.program.info.vertex_fetch_components[0] == 4,
            "encoded fetch sequence was not recognized and rewritten");
    return CompiledShader{std::move(result.spirv), std::move(result.program),
                          std::move(resources), {}};
  };

  const auto Resolve = [](const CompiledShader &result,
                          u32 index_offset) {
    ShaderVertexInputInfo vertex;
    vertex.fetch_embedded = true;
    ShaderRecompiler::IR::CompiledShaderInfo program{};
    program.user_data_base = result.program.user_data_base;
    program.info.vertex_offset_sgpr = result.program.info.vertex_offset_sgpr;
    vertex.stage.program = &program;
    vertex.stage.resources = result.resources;
    return ResolveDrawOffsets(index_offset, vertex).first;
  };

  const auto ResolveInstance = [](const CompiledShader &result) {
    ShaderVertexInputInfo vertex;
    vertex.fetch_embedded = true;
    ShaderRecompiler::IR::CompiledShaderInfo program{};
    program.user_data_base = result.program.user_data_base;
    program.info.instance_offset_sgpr =
        result.program.info.instance_offset_sgpr;
    vertex.stage.program = &program;
    vertex.stage.resources = result.resources;
    return ResolveDrawOffsets(0, vertex).second;
  };

  for (const auto format : {Prospero::BufferFormat::k32_32_32_32Float,
                            Prospero::BufferFormat::k32_32_32_32UInt}) {
    const auto local = Compile("LocalEmbeddedFetch", MakeFetch({}, {}, 0, false, true),
                               0, ShaderType::Local, format);
    ValidateSpirv("LocalEmbeddedFetch", local.spirv);
    Require("LocalEmbeddedFetch", "live vertex attributes",
            std::ranges::any_of(local.program.info.inputs, [](const auto &input) {
              return input.kind == ShaderRecompiler::IR::StageInputKind::Parameter &&
                     input.location == 0;
            }), "LS indexed fetch must consume native vertex attributes");
    if (format == Prospero::BufferFormat::k32_32_32_32UInt) {
      spvtools::SpirvTools tools(SPV_ENV_VULKAN_1_2);
      std::string assembly;
      Require("LocalEmbeddedFetch", "disassembly", tools.Disassemble(local.spirv, &assembly),
              "failed to disassemble unsigned LS fetch");
      Require("LocalEmbeddedFetch", "unsigned input type",
              assembly.find("OpTypePointer Input %v4uint") != std::string::npos &&
                  assembly.find("OpConvertUToF") == std::string::npos,
              "unsigned LS attributes must preserve their native integer bits");
    }
  }

  const auto valid =
      Compile("EmbeddedFetchVertexOffset", MakeFetch({{18, 0}}), 7);
  Require(
      "EmbeddedFetchVertexOffset", "parse",
      valid.program.info.vertex_offset_sgpr == 18 && Resolve(valid, 0) == 7 &&
          Resolve(valid, 5) == 5,
      "canonical fetch offset or register index-offset precedence is wrong");

  const auto ngg_code = MakeFetch({{18, 5}}, {}, 5, true);
  Require("EmbeddedFetchNggVertexOffset", "encoding",
          ngg_code[3] == 0xd55d0005u && ngg_code[4] == 0x04150012u,
          "test does not encode the PS5 V_SAD_U32 vertex-offset prolog");
  const auto ngg = Compile("EmbeddedFetchNggVertexOffset", ngg_code, 8);
  Require("EmbeddedFetchNggVertexOffset", "parse",
          ngg.program.info.vertex_offset_sgpr == 18 && Resolve(ngg, 0) == 8 &&
              Resolve(ngg, 5) == 5,
          "PS5 NGG vertex-index offset or register index-offset precedence is "
          "wrong");

  const auto ngg_instance =
      Compile("EmbeddedFetchNggInstanceOffset",
              MakeFetch({{18, 8}}, {}, 8, true), 81);
  Require("EmbeddedFetchNggInstanceOffset", "parse",
          ngg_instance.program.info.vertex_offset_sgpr == -1 &&
              ngg_instance.program.info.instance_offset_sgpr == 18 &&
              ResolveInstance(ngg_instance) == 81,
          "PS5 NGG instance-index offset was not detected or resolved");

  const auto instance_conflict = Compile(
      "EmbeddedFetchConflictingInstanceOffset",
      MakeFetch({{17, 8}, {18, 8}}, {}, 8, true), 81);
  const auto instance_malformed =
      Compile("EmbeddedFetchMalformedInstanceOffset",
              MakeFetch({{18, 7}}, {}, 7, true), 81);
  const auto instance_outside =
      Compile("EmbeddedFetchOutsideInstanceOffset",
              MakeFetch({{19, 8}}, {}, 8, true), 81);
  for (const auto *result :
       {&instance_conflict, &instance_malformed, &instance_outside}) {
    Require("EmbeddedFetchNggInstanceOffset", "fail closed",
            result->program.info.instance_offset_sgpr == -1 &&
                ResolveInstance(*result) == 0,
            "conflicting, malformed, or out-of-window instance add was "
            "classified");
  }

  const auto pointer = 0x5b7c5100u;
  const auto late = Compile("EmbeddedFetchLateOffset",
                            MakeFetch({}, std::pair<u32, u32>{18, 0}), pointer);
  const auto conflict = Compile("EmbeddedFetchConflictingOffset",
                                MakeFetch({{17, 0}, {18, 0}}), pointer);
  const auto malformed =
      Compile("EmbeddedFetchMalformedOffset", MakeFetch({{18, 1}}), pointer);
  const auto outside =
      Compile("EmbeddedFetchOutsideOffset", MakeFetch({{19, 0}}), pointer);
  for (const auto *result : {&late, &conflict, &malformed, &outside}) {
    Require("EmbeddedFetchVertexOffset", "fail closed",
            result->program.info.vertex_offset_sgpr == -1 &&
                Resolve(*result, 0) == 0,
            "non-prolog, conflicting, malformed, or out-of-window add was "
            "classified");
  }
  std::printf("[host]    %-32s ok\n", "EmbeddedFetchVertexOffset");
}

[[noreturn]] void RunReverseRenderTargetDeathCase() {
  (void)TextureGetRenderTargetFormat(Prospero::ChannelLayout::k16_16_16_16,
                                     Prospero::ChannelType::kSrgb,
                                     Prospero::ChannelOrder::kStandard);
  std::_Exit(0x7f);
}

#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
void CheckRenderTargetFormatContract() {
  const auto r8_uint = TextureGetRenderTargetFormat(
      Prospero::ChannelLayout::k8, Prospero::ChannelType::kUInt,
      Prospero::ChannelOrder::kStandard);
  Require("RenderTargetFormat", "R8 uint",
          r8_uint.format == vk::Format::eR8Uint &&
              r8_uint.bytes_per_element == 1u &&
              r8_uint.export_mapping.IsIdentity(),
          "R8 uint render-target tuple was rejected");

  const auto rgb565 = TextureGetRenderTargetFormat(
      Prospero::ChannelLayout::k5_6_5, Prospero::ChannelType::kUNorm,
      Prospero::ChannelOrder::kStandard);
  Require("RenderTargetFormat", "RGB565 UNorm",
          rgb565.format == vk::Format::eB5G6R5UnormPack16 &&
              rgb565.bytes_per_element == 2u &&
              rgb565.export_mapping.IsIdentity(),
          "RGB565 UNorm render-target tuple was rejected");

  const auto uint_format = TextureGetRenderTargetFormat(
      Prospero::ChannelLayout::k16_16_16_16, Prospero::ChannelType::kUInt,
      Prospero::ChannelOrder::kStandard);
  Require("RenderTargetFormat", "RGBA16 uint",
          uint_format.format == vk::Format::eR16G16B16A16Uint &&
              uint_format.bytes_per_element == 8u &&
              uint_format.export_mapping.IsIdentity(),
          "RGBA16 uint render-target tuple was rejected");

  const auto format = TextureGetRenderTargetFormat(
      Prospero::ChannelLayout::k16_16_16_16, Prospero::ChannelType::kFloat,
      Prospero::ChannelOrder::kReversed);
  Require("ReverseRenderTarget", "exact format",
          format.format == vk::Format::eR16G16B16A16Sfloat &&
              format.bytes_per_element == 8u &&
              format.export_mapping == Prospero::ColorMappingAbgr,
          "exact reverse RGBA16F render-target tuple was rejected");
  Require("ReverseRenderTarget", "write masks",
          format.export_mapping.ApplyMask(0x1u) == 0x8u &&
              format.export_mapping.ApplyMask(0x2u) == 0x4u &&
              format.export_mapping.ApplyMask(0x4u) == 0x2u &&
              format.export_mapping.ApplyMask(0x8u) == 0x1u &&
              format.export_mapping.ApplyMask(0xfu) == 0xfu,
          "reverse RGBA16F component mask was not mapped exactly once");

  const auto rg32 = TextureGetRenderTargetFormat(
      Prospero::ChannelLayout::k32_32, Prospero::ChannelType::kFloat,
      Prospero::ChannelOrder::kReversed);
  Require(
      "ReverseRenderTarget", "GR32 float",
      rg32.format == vk::Format::eR32G32Sfloat &&
          rg32.bytes_per_element == 8u &&
          rg32.export_mapping == Prospero::ColorMappingGr &&
          rg32.export_mapping.ApplyMask(0x1u) == 0x2u &&
          rg32.export_mapping.ApplyMask(0x2u) == 0x1u &&
          rg32.export_mapping.ApplyMask(0x3u) == 0x3u &&
          rg32.export_mapping.ApplyMask(0xfu) == 0xfu,
      "reverse GR32F render-target export or write-mask mapping is incorrect");

  const auto argb = TextureGetRenderTargetFormat(
      Prospero::ChannelLayout::k16_16_16_16, Prospero::ChannelType::kFloat,
      Prospero::ChannelOrder::kAltReversed);
  Require(
      "ReverseRenderTarget", "ARGB float",
      argb.format == vk::Format::eR16G16B16A16Sfloat &&
          argb.export_mapping == Prospero::ColorMappingArgb &&
          argb.export_mapping.ApplyMask(0x1u) == 0x2u &&
          argb.export_mapping.ApplyMask(0x2u) == 0x4u &&
          argb.export_mapping.ApplyMask(0x4u) == 0x8u &&
          argb.export_mapping.ApplyMask(0x8u) == 0x1u,
      "alternate-reversed render-target mapping did not invert its ARGB cycle");

  char path[MAX_PATH]{};
  Require("ReverseRenderTarget", "host",
          GetModuleFileNameA(nullptr, path, MAX_PATH) != 0,
          "GetModuleFileName failed");
  std::string command = std::string("\"") + path + "\" --reverse-rt-death";
  std::vector<char> mutable_command(command.begin(), command.end());
  mutable_command.push_back('\0');
  STARTUPINFOA startup{sizeof(startup)};
  PROCESS_INFORMATION process{};
  Require("ReverseRenderTarget", "host",
          CreateProcessA(nullptr, mutable_command.data(), nullptr, nullptr,
                         FALSE, CREATE_NO_WINDOW, nullptr, nullptr, &startup,
                         &process) != 0,
          "CreateProcess failed");
  Require("ReverseRenderTarget", "host",
          WaitForSingleObject(process.hProcess, 10000) == WAIT_OBJECT_0,
          "unsupported adjacent render-target tuple timed out");
  DWORD exit_code = 0;
  const bool exited = GetExitCodeProcess(process.hProcess, &exit_code) != 0;
  CloseHandle(process.hThread);
  CloseHandle(process.hProcess);
  Require("ReverseRenderTarget", "hard failure", exited && exit_code == 321,
          "invalid render-target tuple did not retain the fatal guard");
  std::printf("[host]    %-32s ok\n", "RenderTargetFormat");
}
#endif

[[noreturn]] void RunImageViewDeathCase(const char *kind) {
  if (std::strcmp(kind, "sampled-invalid-selector") == 0) {
    (void)SelectSampledColorView(vk::Format::eR8G8B8A8Unorm,
                                 vk::Format::eR8G8B8A8Unorm,
                                 DstSel(4, 5, 6, 2));
  } else if (std::strcmp(kind, "sampled-incompatible-format") == 0) {
    (void)SelectSampledColorView(vk::Format::eR8Unorm, vk::Format::eR16Unorm,
                                 DstSel(4, 0, 0, 1));
  } else if (std::strcmp(kind, "sampled-invalid-high") == 0) {
    (void)SelectSampledColorView(vk::Format::eR8G8B8A8Unorm,
                                 vk::Format::eR8G8B8A8Unorm,
                                 DstSel(7, 6, 5, 3));
  } else if (std::strcmp(kind, "storage-incompatible-format") == 0) {
    ValidateStorageColorView(vk::Format::eR8G8B8A8Srgb,
                             vk::Format::eR16G16B16A16Unorm,
                             DstSel(4, 5, 6, 7));
  } else if (std::strcmp(kind, "volume-mip-count") == 0 ||
             std::strcmp(kind, "volume-slice-range") == 0) {
    VulkanHarness vulkan;
    auto &graphics = vulkan.RuntimeContext();
    CommandScheduler scheduler(vulkan.RuntimeRenderer(), graphics);
    ImageInfo volume_info{};
    volume_info.pixel_format = vk::Format::eR8G8B8A8Unorm;
    volume_info.guest_format = Prospero::BufferFormat::k8_8_8_8UNorm;
    volume_info.type = Prospero::ImageType::kColor3D;
    volume_info.extent = {8, 8, 4};
    volume_info.resources = {2, 1};
    volume_info.pitch = 8;
    volume_info.bytes_per_block = 4;
    volume_info.samples = 1;
    volume_info.tile_mode = Prospero::TileMode::kLinear;
    Libs::Graphics::Image volume(graphics, scheduler, volume_info);
    ImageViewInfo view{};
    view.format = volume_info.pixel_format;
    view.type = vk::ImageViewType::e2DArray;
    view.aspect = vk::ImageAspectFlagBits::eColor;
    view.base_level = 1;
    view.level_count = 1;
    view.layer_count = 1;
    view.usage = vk::ImageUsageFlagBits::eSampled;
    if (std::strcmp(kind, "volume-mip-count") == 0) {
      view.base_level = 0;
      view.level_count = 2;
    } else {
      view.base_layer = 1;
      view.layer_count = 2;
    }
    (void)volume.FindView(view);
  } else {
    ShaderRecompiler::IR::ImageResource resource{};
    resource.resource_class = ShaderRecompiler::IR::ImageResourceClass::Storage;
    resource.numeric_class = Prospero::TextureNumericClass::Float;
    resource.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2D;
    resource.written = true;
    if (std::strcmp(kind, "storage-kind") == 0) {
      resource.resource_class =
          ShaderRecompiler::IR::ImageResourceClass::Sampled;
    } else if (std::strcmp(kind, "storage-no-write") == 0) {
      resource.written = false;
    } else if (std::strcmp(kind, "storage-nonuint-atomic") == 0) {
      resource.atomic = true;
    } else if (std::strcmp(kind, "storage-compare") == 0) {
      resource.depth_compare = true;
    } else if (std::strcmp(kind, "storage-dimension") == 0) {
      resource.dimension = ShaderRecompiler::Decoder::ImageDimension::Unknown;
    } else {
      std::_Exit(0x7e);
    }
    ValidateStorageImageResource(resource);
  }
  std::_Exit(0x7f);
}

#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
void CheckSampledColorViews() {
  Require("SampledColorViews", "identity",
          SelectSampledColorView(vk::Format::eR8G8B8A8Unorm,
                                 vk::Format::eR8G8B8A8Unorm,
                                 DstSel(4, 5, 6, 7)) == DstSel(4, 5, 6, 7),
          "RGBA did not select the identity view");
  uint32_t valid_swizzles = 0;
  for (uint32_t swizzle = 0; swizzle <= 0xfffu; swizzle++) {
    bool expected = true;
    for (uint32_t channel = 0; channel < 4; channel++) {
      const auto selector = GetDstSel(swizzle, channel);
      if (selector == 2 || selector == 3) {
        expected = false;
      }
    }
    const bool valid = IsValidImageSwizzle(swizzle);
    const bool supported = IsSupportedSampledColorView(
        vk::Format::eR8G8B8A8Unorm, vk::Format::eR8G8B8A8Unorm, swizzle);
    Require("SampledColorViews", "exhaustive read swizzle domain",
            valid == expected && supported == expected,
            "sampled swizzle validator disagreed with the PS5 selector domain");
    valid_swizzles += valid;
  }
  Require("SampledColorViews", "all PS5 read swizzles",
          valid_swizzles == 1296 && !IsValidImageSwizzle(DstSel(4, 5, 6, 2)) &&
              !IsValidImageSwizzle(DstSel(4, 5, 6, 3)) &&
              !IsValidImageSwizzle(0x1000),
          "valid PS5 sampled mappings were rejected or reserved selectors were "
          "admitted");
  const auto arbitrary = DstSel(5, 1, 7, 0);
  const auto components = TextureGetComponentMapping(arbitrary, {});
  Require("SampledColorViews", "generic Vulkan component mapping",
          SelectSampledColorView(vk::Format::eR8G8B8A8Unorm,
                                 vk::Format::eR8G8B8A8Unorm,
                                 arbitrary) == arbitrary &&
              components.r == vk::ComponentSwizzle::eG &&
              components.g == vk::ComponentSwizzle::eOne &&
              components.b == vk::ComponentSwizzle::eA &&
              components.a == vk::ComponentSwizzle::eZero,
          "arbitrary valid sampled mapping did not use the generic view path");
  Require("SampledColorViews", "R8 R001",
          SelectSampledColorView(vk::Format::eR8Unorm, vk::Format::eR8Unorm,
                                 DstSel(4, 0, 0, 1)) == DstSel(4, 0, 0, 1),
          "R8 did not select its R001 view");
  Require("SampledColorViews", "R8 000R",
          SelectSampledColorView(vk::Format::eR8Unorm, vk::Format::eR8Unorm,
                                 DstSel(0, 0, 0, 4)) == DstSel(0, 0, 0, 4),
          "R8 did not select its 000R component-mapped view");
  Require("SampledColorViews", "mutable R8 uint/unorm 000R",
          SelectSampledColorView(vk::Format::eR8Uint, vk::Format::eR8Unorm,
                                 DstSel(0, 0, 0, 4)) == DstSel(0, 0, 0, 4),
          "compatible R8 integer target sampled view was rejected");
  Require("SampledColorViews", "R16G16 RG01",
          SelectSampledColorView(vk::Format::eR16G16Sfloat,
                                 vk::Format::eR16G16Sfloat,
                                 DstSel(4, 5, 0, 1)) == DstSel(4, 5, 0, 1),
          "R16G16 did not select its RG01 view");
  Require("SampledColorViews", "alpha one",
          SelectSampledColorView(vk::Format::eR8G8B8A8Unorm,
                                 vk::Format::eR8G8B8A8Unorm,
                                 DstSel(4, 5, 6, 1)) == DstSel(4, 5, 6, 1),
          "RGB1 did not select the alpha-one view");
  Require("SampledColorViews", "mutable BGRA target",
          SelectSampledColorView(vk::Format::eB8G8R8A8Unorm,
                                 vk::Format::eR8G8B8A8Unorm,
                                 DstSel(6, 5, 4, 7)) == DstSel(6, 5, 4, 7),
          "BGRA target did not select the exact RGBA/BGRA mutable view");
  Require(
      "SampledColorViews", "mutable sRGB view of UNORM BGRA target",
      SelectSampledColorView(vk::Format::eB8G8R8A8Unorm,
                             vk::Format::eR8G8B8A8Srgb,
                             DstSel(6, 5, 4, 7)) == DstSel(6, 5, 4, 7),
      "UNORM BGRA target did not select its compatible sRGB RGBA sampled view");
  Require("SampledColorViews", "mutable sRGB BGRA target",
          SelectSampledColorView(vk::Format::eB8G8R8A8Srgb,
                                 vk::Format::eR8G8B8A8Srgb,
                                 DstSel(6, 5, 4, 7)) == DstSel(6, 5, 4, 7),
          "sRGB BGRA target did not select its matching mutable RGBA view");
  constexpr auto colorspace_swizzle = DstSel(5, 1, 7, 0);
  Require("SampledColorViews", "mutable sRGB/UNORM views",
          SelectSampledColorView(vk::Format::eR8G8B8A8Srgb,
                                 vk::Format::eR8G8B8A8Unorm,
                                 DstSel(4, 5, 6, 7)) == DstSel(4, 5, 6, 7) &&
              SelectSampledColorView(vk::Format::eB8G8R8A8Unorm,
                                     vk::Format::eB8G8R8A8Srgb,
                                     colorspace_swizzle) == colorspace_swizzle,
          "same-order mutable sRGB/UNORM sampled views were rejected");
  Require("SampledColorViews", "mutable packed RGB10 view",
          SelectSampledColorView(vk::Format::eA2R10G10B10UnormPack32,
                                 vk::Format::eA2B10G10R10UnormPack32,
                                 DstSel(6, 5, 4, 7)) == DstSel(6, 5, 4, 7),
          "packed RGB10 target did not select its matching mutable "
          "channel-order view");
  Require(
      "SampledColorViews", "reverse RGBA16F sampled view",
      SelectSampledColorView(vk::Format::eR16G16B16A16Sfloat,
                             vk::Format::eR16G16B16A16Sfloat,
                             DstSel(7, 6, 5, 4)) == DstSel(7, 6, 5, 4),
      "reverse RGBA16F target did not select its reciprocal ABGR sampled view");
  Require("SampledColorViews", "mutable integer-class views",
          SelectSampledColorView(vk::Format::eR16G16B16A16Sfloat,
                                 vk::Format::eR16G16B16A16Uint,
                                 DstSel(4, 5, 6, 7)) == DstSel(4, 5, 6, 7) &&
              SelectSampledColorView(
                  vk::Format::eR8G8B8A8Unorm, vk::Format::eR8G8B8A8Uint,
                  DstSel(4, 5, 6, 7)) == DstSel(4, 5, 6, 7) &&
              SelectSampledColorView(vk::Format::eR8G8B8A8Uint,
                                     vk::Format::eR8G8B8A8Unorm,
                                     DstSel(4, 5, 6, 7)) == DstSel(4, 5, 6, 7),
          "compatible integer render-target sampled view was rejected");
  Require("SampledColorViews", "invalid depth format",
          !IsSupportedSampledDepthView(vk::Format::eD24UnormS8Uint,
                                       vk::Format::eR8Unorm,
                                       DstSel(4, 4, 4, 4)),
          "incompatible sampled depth format was accepted");
  Require("SampledColorViews", "invalid depth swizzle",
          !IsSupportedSampledDepthView(vk::Format::eD32SfloatS8Uint,
                                       vk::Format::eR32Sfloat,
                                       DstSel(4, 5, 6, 7)),
          "incompatible sampled depth swizzle was accepted");
  Require("SampledColorViews", "D32 depth target",
          IsSupportedSampledDepthView(vk::Format::eD32SfloatS8Uint,
                                      vk::Format::eR32Sfloat,
                                      DstSel(4, 4, 4, 4)),
          "D32 depth target did not select its depth-aspect view");
  Require("SampledColorViews", "D16 R000 depth target",
          IsSupportedSampledDepthView(
              vk::Format::eD16Unorm, vk::Format::eR16Unorm, DstSel(4, 0, 0, 0)),
          "D16 depth target did not select its R000 depth-aspect view");
  Require("SampledColorViews", "D16S8 R001 depth target",
          IsSupportedSampledDepthView(vk::Format::eD16UnormS8Uint,
                                      vk::Format::eR16Unorm,
                                      DstSel(4, 0, 0, 1)),
          "D16S8 depth target did not select its R001 depth-aspect view");
  Require("SampledColorViews", "promoted D24S8 R001 depth target",
          IsSupportedSampledDepthView(vk::Format::eD24UnormS8Uint,
                                      vk::Format::eR16Unorm,
                                      DstSel(4, 0, 0, 1)),
          "D24S8 host fallback did not preserve the guest R16 depth view");
  Require("SampledColorViews", "promoted D32S8 R001 depth target",
          IsSupportedSampledDepthView(vk::Format::eD32SfloatS8Uint,
                                      vk::Format::eR16Unorm,
                                      DstSel(4, 0, 0, 1)),
          "D32S8 host fallback did not preserve the guest R16 depth view");
  Require("SampledColorViews", "D32S8 R001 depth target",
          IsSupportedSampledDepthView(vk::Format::eD32SfloatS8Uint,
                                      vk::Format::eR32Sfloat,
                                      DstSel(4, 0, 0, 1)),
          "D32S8 depth target did not select its R001 depth-aspect view");
  ShaderRecompiler::IR::ImageResource storage_resource{};
  storage_resource.resource_class =
      ShaderRecompiler::IR::ImageResourceClass::Storage;
  storage_resource.numeric_class = Prospero::TextureNumericClass::Float;
  storage_resource.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2D;
  storage_resource.written = true;
  Require("SampledColorViews", "storage resource",
          IsSupportedStorageImageResource(storage_resource),
          "exact storage resource contract was rejected");
  storage_resource.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim3D;
  storage_resource.read = true;
  Require("SampledColorViews", "read-write 3D storage resource",
          IsSupportedStorageImageResource(storage_resource),
          "basic read-write 3D storage resource was rejected");
  storage_resource.dimension =
      ShaderRecompiler::Decoder::ImageDimension::Dim2DArray;
  storage_resource.read = false;
  Require("SampledColorViews", "write-only 2D-array storage resource",
          IsSupportedStorageImageResource(storage_resource),
          "basic write-only 2D-array storage resource was rejected");
  storage_resource.numeric_class = Prospero::TextureNumericClass::Uint;
  Require("SampledColorViews", "write-only uint 2D-array storage resource",
          IsSupportedStorageImageResource(storage_resource),
          "basic write-only uint 2D-array storage resource was rejected");
  storage_resource.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2D;
  storage_resource.read = true;
  storage_resource.atomic = true;
  Require("SampledColorViews", "atomic uint 2D storage resource",
          IsSupportedStorageImageResource(storage_resource),
          "atomic uint storage resource was rejected");
  storage_resource.atomic = false;
  storage_resource.mip_mode =
      ShaderRecompiler::IR::ImageMipMode::DynamicStorage;
  storage_resource.mip_count = 3;
  Require("SampledColorViews", "dynamic storage mip resource",
          IsSupportedStorageImageResource(storage_resource),
          "dynamic storage mip resource was rejected");

  char path[MAX_PATH]{};
  Require("SampledColorViews", "host",
          GetModuleFileNameA(nullptr, path, MAX_PATH) != 0,
          "GetModuleFileName failed");
  for (const char *kind :
       {"sampled-invalid-selector", "sampled-incompatible-format",
        "sampled-invalid-high", "storage-incompatible-format", "storage-kind",
        "storage-no-write", "storage-nonuint-atomic", "storage-compare",
        "storage-dimension", "volume-mip-count", "volume-slice-range"}) {
    std::string command =
        std::string("\"") + path + "\" --image-view-death " + kind;
    std::vector<char> mutable_command(command.begin(), command.end());
    mutable_command.push_back('\0');
    STARTUPINFOA startup{sizeof(startup)};
    PROCESS_INFORMATION process{};
    Require("SampledColorViews", "host",
            CreateProcessA(nullptr, mutable_command.data(), nullptr, nullptr,
                           FALSE, CREATE_NO_WINDOW, nullptr, nullptr, &startup,
                           &process) != 0,
            "CreateProcess failed");
    Require("SampledColorViews", "host",
            WaitForSingleObject(process.hProcess, 10000) == WAIT_OBJECT_0,
            "unsupported view death case timed out");
    DWORD exit_code = 0;
    const bool exited = GetExitCodeProcess(process.hProcess, &exit_code) != 0;
    CloseHandle(process.hThread);
    CloseHandle(process.hProcess);
    Require("SampledColorViews", "host", exited && exit_code == 321,
            std::string(kind) +
                " component mapping did not report a fatal error");
  }
  std::printf("[host]    %-32s ok\n", "SampledColorRenderTargetViews");
}
#endif

void CheckSampledDepthResource() {
  ShaderRecompiler::IR::ImageResource resource{};
  resource.resource_class = ShaderRecompiler::IR::ImageResourceClass::Sampled;
  resource.numeric_class = Prospero::TextureNumericClass::Float;
  resource.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2D;
  resource.read = true;
  resource.depth_compare = true;
  Require("SampledDepthResource", "comparison read",
          IsSupportedSampledDepthResource(resource),
          "basic comparison-sampled depth resource was rejected");

  resource.depth_compare = false;
  Require("SampledDepthResource", "ordinary read",
          IsSupportedSampledDepthResource(resource),
          "basic non-comparison depth read was rejected");

  const auto basic = resource;
  resource.read = false;
  Require("SampledDepthResource", "read required",
          !IsSupportedSampledDepthResource(resource),
          "non-reading depth resource was accepted");
  resource = basic;
  resource.written = true;
  Require("SampledDepthResource", "write rejected",
          !IsSupportedSampledDepthResource(resource),
          "writable depth resource was accepted");
  resource = basic;
  resource.atomic = true;
  Require("SampledDepthResource", "atomic rejected",
          !IsSupportedSampledDepthResource(resource),
          "atomic depth resource was accepted");
  resource = basic;
  resource.mip_mode = ShaderRecompiler::IR::ImageMipMode::DynamicStorage;
  Require("SampledDepthResource", "dynamic mip rejected",
          !IsSupportedSampledDepthResource(resource),
          "dynamic-storage mip depth resource was accepted");
  resource = basic;
  resource.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2DArray;
  Require("SampledDepthResource", "singleton array accepted",
          IsSupportedSampledDepthResource(resource),
          "array depth resource was rejected");
  resource = basic;
  resource.numeric_class = Prospero::TextureNumericClass::Uint;
  Require("SampledDepthResource", "integer read",
          IsSupportedSampledDepthResource(resource),
          "read-only uint depth resource was rejected");
  resource.depth_compare = true;
  Require("SampledDepthResource", "integer comparison rejected",
          !IsSupportedSampledDepthResource(resource),
          "uint depth resource accepted comparison sampling");
  Require("SampledDepthResource", "R32 uint depth view",
          IsSupportedSampledDepthFormat(vk::Format::eD32Sfloat,
                                        vk::Format::eR32Uint) &&
              !IsSupportedSampledDepthFormat(vk::Format::eR32Uint,
                                             vk::Format::eR32Uint),
          "R32 uint depth-view compatibility diverged from its backing role");
  std::printf("[host]    %-32s ok\n", "SampledDepthResource");
}

void CheckImageTransitionState(RenderContext &renderer) {
  constexpr const char *name = "ImageTransitionState";
  auto &context = renderer.GetGraphics();
  CommandScheduler scheduler(renderer, context);
  const auto MakeInfo = [](vk::Format format, uint32_t levels,
                           uint32_t layers) {
    ImageInfo info{};
    info.pixel_format = format;
    info.guest_format = Prospero::BufferFormat::k8UNorm;
    info.type = Prospero::ImageType::kColor2D;
    info.extent = {4, 4, 1};
    info.resources = {levels, layers};
    info.pitch = 4;
    info.bytes_per_block = 1;
    info.samples = 1;
    info.tile_mode = Prospero::TileMode::kLinear;
    return info;
  };
  const auto graphics_stage = vk::PipelineStageFlagBits2::eAllGraphics |
                              vk::PipelineStageFlagBits2::eComputeShader;
  constexpr uint64_t copy_capacity = 128ull << 20;
  Require(
      name, "buffered-copy capacity bands",
      ImageTestAccess::CopyRows(32ull << 10, 4096, copy_capacity) == 4096 &&
          ImageTestAccess::CopyRows(32ull << 10, 4097, copy_capacity) == 4096 &&
          ImageTestAccess::CopyRows(copy_capacity + 4, 1, copy_capacity) == 0,
      "buffered image copy does not split at the fixed scratch capacity");

  Image image(context, scheduler, MakeInfo(vk::Format::eR8Unorm, 2, 3));
  auto barriers =
      image.GetBarriers(vk::ImageLayout::eShaderReadOnlyOptimal,
                        vk::AccessFlagBits2::eShaderRead, graphics_stage, {});
  Require(
      name, "initial full state",
      barriers.size() == 1 &&
          barriers[0].srcStageMask ==
              vk::PipelineStageFlagBits2::eAllCommands &&
          barriers[0].srcAccessMask == vk::AccessFlagBits2::eNone &&
          barriers[0].dstStageMask == graphics_stage &&
          barriers[0].dstAccessMask == vk::AccessFlagBits2::eShaderRead &&
          barriers[0].oldLayout == vk::ImageLayout::eUndefined &&
          barriers[0].newLayout == vk::ImageLayout::eShaderReadOnlyOptimal &&
          barriers[0].subresourceRange.aspectMask ==
              vk::ImageAspectFlagBits::eColor &&
          barriers[0].subresourceRange.levelCount == VK_REMAINING_MIP_LEVELS &&
          barriers[0].subresourceRange.layerCount ==
              VK_REMAINING_ARRAY_LAYERS &&
          image.backing.state.layout ==
              vk::ImageLayout::eShaderReadOnlyOptimal &&
          image.backing.state.access_mask == vk::AccessFlagBits2::eShaderRead &&
          image.backing.state.pl_stage == graphics_stage,
      "initial transition did not record or retain pinned state");
  Require(name, "repeat read elision",
          image
              .GetBarriers(vk::ImageLayout::eShaderReadOnlyOptimal,
                           vk::AccessFlagBits2::eShaderRead, graphics_stage, {})
              .empty(),
          "identical read-only transition emitted a barrier");
  barriers = image.GetBarriers(vk::ImageLayout::eShaderReadOnlyOptimal,
                               vk::AccessFlagBits2::eShaderRead |
                                   vk::AccessFlagBits2::eTransferRead,
                               graphics_stage, {});
  Require(name, "access-only transition",
          barriers.size() == 1 &&
              barriers[0].oldLayout == barriers[0].newLayout &&
              barriers[0].srcAccessMask == vk::AccessFlagBits2::eShaderRead,
          "same-layout access change was lost");

  const auto CheckRepeatedWrite = [&](vk::AccessFlagBits2 access,
                                      const char *label) {
    image.backing.state = {};
    image.backing.subresource_states.clear();
    (void)image.GetBarriers(vk::ImageLayout::eGeneral, access, graphics_stage,
                            {});
    Require(
        name, label,
        image.GetBarriers(vk::ImageLayout::eGeneral, access, graphics_stage, {})
                .size() == 1,
        "pinned repeated-write dependency was elided");
  };
  CheckRepeatedWrite(vk::AccessFlagBits2::eTransferWrite,
                     "repeat transfer write");
  CheckRepeatedWrite(vk::AccessFlagBits2::eShaderWrite, "repeat shader write");
  CheckRepeatedWrite(vk::AccessFlagBits2::eMemoryWrite, "repeat memory write");
  image.backing.state = {};
  image.backing.subresource_states.clear();
  const auto attachment_access = vk::AccessFlagBits2::eColorAttachmentRead |
                                 vk::AccessFlagBits2::eColorAttachmentWrite;
  (void)image.GetBarriers(vk::ImageLayout::eColorAttachmentOptimal,
                          attachment_access, graphics_stage, {});
  Require(name, "pinned attachment-write quirk",
          image
              .GetBarriers(vk::ImageLayout::eColorAttachmentOptimal,
                           attachment_access, graphics_stage, {})
              .empty(),
          "attachment writes diverged from the pinned repeated-write set");

  image.backing.state = {};
  image.backing.subresource_states.clear();
  (void)image.GetBarriers(vk::ImageLayout::eShaderReadOnlyOptimal,
                          vk::AccessFlagBits2::eShaderRead, graphics_stage, {});
  constexpr ImageSubresourceRange mip1_layer0{1, 1, 0, 1};
  barriers = image.GetBarriers(vk::ImageLayout::eGeneral,
                               vk::AccessFlagBits2::eShaderWrite,
                               graphics_stage, mip1_layer0);
  Require(name, "first partial",
          barriers.size() == 1 &&
              barriers[0].subresourceRange.baseMipLevel == 1 &&
              barriers[0].subresourceRange.baseArrayLayer == 0 &&
              image.backing.subresource_states.size() == 6 &&
              image.backing.subresource_states[3].layout ==
                  vk::ImageLayout::eGeneral &&
              image.backing.subresource_states[3].access_mask ==
                  vk::AccessFlagBits2::eShaderWrite &&
              image.backing.subresource_states[1].layout ==
                  vk::ImageLayout::eShaderReadOnlyOptimal,
          "partial state did not use mip-major indexing");
  constexpr ImageSubresourceRange mip0_layer1{0, 1, 1, 1};
  barriers = image.GetBarriers(
      vk::ImageLayout::eTransferDstOptimal, vk::AccessFlagBits2::eTransferWrite,
      vk::PipelineStageFlagBits2::eTransfer, mip0_layer1);
  Require(name, "second partial",
          barriers.size() == 1 &&
              barriers[0].subresourceRange.baseMipLevel == 0 &&
              barriers[0].subresourceRange.baseArrayLayer == 1 &&
              image.backing.subresource_states[1].layout ==
                  vk::ImageLayout::eTransferDstOptimal &&
              image.backing.subresource_states[1].access_mask ==
                  vk::AccessFlagBits2::eTransferWrite &&
              image.backing.subresource_states[3].layout ==
                  vk::ImageLayout::eGeneral,
          "second partial transition changed the wrong cell");
  const ImageSubresourceRange explicit_full{0, 2, 0, 3};
  barriers = image.GetBarriers(vk::ImageLayout::eShaderReadOnlyOptimal,
                               vk::AccessFlagBits2::eShaderRead, graphics_stage,
                               explicit_full);
  bool saw_mip0_layer1 = false;
  bool saw_mip1_layer0 = false;
  for (const auto &barrier : barriers) {
    saw_mip0_layer1 |=
        barrier.subresourceRange.baseMipLevel == 0 &&
        barrier.subresourceRange.baseArrayLayer == 1 &&
        barrier.oldLayout == vk::ImageLayout::eTransferDstOptimal &&
        barrier.srcStageMask == vk::PipelineStageFlagBits2::eTransfer;
    saw_mip1_layer0 |=
        barrier.subresourceRange.baseMipLevel == 1 &&
        barrier.subresourceRange.baseArrayLayer == 0 &&
        barrier.oldLayout == vk::ImageLayout::eGeneral &&
        barrier.srcAccessMask == vk::AccessFlagBits2::eShaderWrite;
  }
  Require(name, "partial normalization",
          barriers.size() == 2 && saw_mip0_layer1 && saw_mip1_layer0 &&
              image.backing.subresource_states.empty() &&
              image.backing.state.layout ==
                  vk::ImageLayout::eShaderReadOnlyOptimal &&
              image.backing.state.access_mask ==
                  vk::AccessFlagBits2::eShaderRead &&
              image.backing.state.pl_stage == graphics_stage,
          "full transition did not reconcile and collapse split state");
  barriers = image.GetBarriers(vk::ImageLayout::eTransferSrcOptimal,
                               vk::AccessFlagBits2::eTransferRead,
                               vk::PipelineStageFlagBits2::eTransfer, {});
  Require(name, "normalized full transition",
          barriers.size() == 1 &&
              barriers[0].subresourceRange.levelCount ==
                  VK_REMAINING_MIP_LEVELS &&
              barriers[0].subresourceRange.layerCount ==
                  VK_REMAINING_ARRAY_LAYERS &&
              barriers[0].srcStageMask == graphics_stage &&
              barriers[0].dstStageMask == vk::PipelineStageFlagBits2::eTransfer,
          "normalized state did not return to one full barrier");

  auto depth_info = MakeInfo(vk::Format::eD32SfloatS8Uint, 1, 1);
  depth_info.guest_format = Prospero::BufferFormat::k32Float;
  depth_info.bytes_per_block = 4;
  depth_info.tile_mode = Prospero::TileMode::kDepth;
  Image depth(context, scheduler, depth_info);
  barriers =
      depth.GetBarriers(vk::ImageLayout::eDepthStencilReadOnlyOptimal,
                        vk::AccessFlagBits2::eShaderRead, graphics_stage, {});
  Require(name, "depth stencil aspects",
          barriers.size() == 1 && barriers[0].subresourceRange.aspectMask ==
                                      (vk::ImageAspectFlagBits::eDepth |
                                       vk::ImageAspectFlagBits::eStencil),
          "depth/stencil transition did not use the full image aspect");

  HW::Context registers{};
  HW::UserConfig user_config{};
  HW::Shader shaders{};
  scheduler.Begin(registers, user_config, shaders);
  image.backing.state = {};
  image.backing.subresource_states.clear();
  image.Transit(vk::ImageLayout::eGeneral,
                vk::AccessFlagBits2::eShaderRead |
                    vk::AccessFlagBits2::eTransferRead,
                {}, scheduler.Current().Handle());
  Require(name, "mixed access stages",
          image.backing.state.pl_stage ==
              (graphics_stage | vk::PipelineStageFlagBits2::eTransfer),
          "mixed shader/transfer access omitted a required pipeline stage");

  auto source_info = depth_info;
  source_info.extent = {2, 2, 1};
  source_info.pitch = 2;
  source_info.stencil = {0x1000, 4};
  auto destination_info = depth_info;
  destination_info.resources.levels = 2;
  destination_info.stencil = {0x2000, 16};
  Image source(context, scheduler, source_info);
  Image destination(context, scheduler, destination_info);
  StreamBuffer upload(context, scheduler, MemoryUsage::Upload, 4096);
  StreamBuffer download(context, scheduler, MemoryUsage::Download, 4096);
  const auto [upload_data, upload_offset] = upload.Map(128, 4);
  Require(name, "depth/stencil upload map", upload_data != nullptr,
          "combined depth/stencil upload allocation failed");
  constexpr std::array<uint32_t, 4> expected_depth{0x3e800000u, 0x3f000000u,
                                                   0x3f400000u, 0x3f800000u};
  constexpr std::array<uint8_t, 4> expected_stencil{0x12, 0x34, 0x56, 0x78};
  std::memcpy(upload_data, expected_depth.data(), sizeof(expected_depth));
  std::memcpy(upload_data + 64, expected_stencil.data(),
              sizeof(expected_stencil));
  upload.Commit();
  std::array<vk::BufferImageCopy, 2> source_copies{};
  source_copies[0].bufferOffset = upload_offset;
  source_copies[0].imageSubresource = {vk::ImageAspectFlagBits::eDepth, 0, 0,
                                       1};
  source_copies[0].imageExtent = {2, 2, 1};
  source_copies[1].bufferOffset = upload_offset + 64;
  source_copies[1].imageSubresource = {vk::ImageAspectFlagBits::eStencil, 0, 0,
                                       1};
  source_copies[1].imageExtent = {2, 2, 1};
  source.Upload(source_copies, upload.Handle(), upload_offset, 128);
  destination.CopyMip(source, 1, 0);

  const auto [download_data, download_offset] = download.Map(128, 4);
  Require(name, "depth/stencil download map", download_data != nullptr,
          "combined depth/stencil download allocation failed");
  download.Commit();
  auto destination_copies = source_copies;
  destination_copies[0].bufferOffset = download_offset;
  destination_copies[0].imageSubresource.mipLevel = 1;
  destination_copies[1].bufferOffset = download_offset + 64;
  destination_copies[1].imageSubresource.mipLevel = 1;
  destination.Download(destination_copies, download.Handle(), download_offset,
                       128);

  auto buffered_info = MakeInfo(vk::Format::eR8Unorm, 1, 1);
  buffered_info.extent = {8, 4, 1};
  buffered_info.pitch = 8;
  buffered_info.mip_layout[0] = {0, 32, 8, 4};
  Image buffered_source(context, scheduler, buffered_info);
  Image buffered_destination(context, scheduler, buffered_info);
  constexpr std::array<uint8_t, 32> buffered_expected{
      0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99, 0xaa,
      0xbb, 0xcc, 0xdd, 0xee, 0xff, 0x10, 0x21, 0x32, 0x43, 0x54, 0x65,
      0x76, 0x87, 0x98, 0xa9, 0xba, 0xcb, 0xdc, 0xed, 0xfe, 0x0f};
  const auto [buffered_upload_data, buffered_upload_offset] =
      upload.Map(buffered_expected.size(), 4);
  Require(name, "buffered-copy upload map", buffered_upload_data != nullptr,
          "buffered-copy source allocation failed");
  std::memcpy(buffered_upload_data, buffered_expected.data(),
              buffered_expected.size());
  upload.Commit();
  vk::BufferImageCopy buffered_region{};
  buffered_region.bufferOffset = buffered_upload_offset;
  buffered_region.bufferRowLength = buffered_info.pitch;
  buffered_region.bufferImageHeight = buffered_info.extent.height;
  buffered_region.imageSubresource = {vk::ImageAspectFlagBits::eColor, 0, 0, 1};
  buffered_region.imageExtent = buffered_info.extent;
  buffered_source.Upload(std::span{&buffered_region, 1}, upload.Handle(),
                         buffered_upload_offset, buffered_expected.size());
  Buffer copy_scratch(context, scheduler, MemoryUsage::DeviceLocal, 0, AllFlags,
                      16);
  buffered_destination.CopyImageWithBuffer(buffered_source, copy_scratch);
  const auto [buffered_download_data, buffered_download_offset] =
      download.Map(buffered_expected.size(), 4);
  Require(name, "buffered-copy download map", buffered_download_data != nullptr,
          "buffered-copy destination allocation failed");
  download.Commit();
  buffered_region.bufferOffset = buffered_download_offset;
  buffered_destination.Download(std::span{&buffered_region, 1},
                                download.Handle(), buffered_download_offset,
                                buffered_expected.size());
  scheduler.Finish();
  download.Invalidate(download_offset, 128);
  download.Invalidate(buffered_download_offset, buffered_expected.size());
  Require(name, "depth/stencil mip contents",
          std::memcmp(download_data, expected_depth.data(),
                      sizeof(expected_depth)) == 0 &&
              std::memcmp(download_data + 64, expected_stencil.data(),
                          sizeof(expected_stencil)) == 0,
          "combined depth/stencil mip copy lost an aspect");
  Require(name, "buffered-copy chunk contents",
          std::memcmp(buffered_download_data, buffered_expected.data(),
                      buffered_expected.size()) == 0,
          "real buffered image copy lost a row across its scratch boundary");

  std::printf("[host]    %-32s ok\n", name);
}

void CheckDepthTextureEncoding() {
  const ShaderTextureResource disabled_sampler_tweaks{{
      0x05135600u,
      0xc1600000u,
      0x010dc1dfu,
      0x91800924u,
      0x00000000u,
      0x00000000u,
      0x00000000u,
      0x00000000u,
  }};
  Require("DepthTextureEncoding", "disabled sampler tweaks",
          disabled_sampler_tweaks.PerfMod5() == 0 &&
              IsSupportedDepthTextureEncoding(disabled_sampler_tweaks),
          "valid sampler modulation factor zero was rejected");

  const ShaderTextureResource uncompressed_msaa{{
      0x00705d00u,
      0xc1600000u,
      0x010dc1dfu,
      0xe1810924u,
      0x00000000u,
      0x00700010u,
      0x00000000u,
      0x00000000u,
  }};
  Require("DepthTextureEncoding", "uncompressed 2x MSAA depth",
          IsSupportedDepthTextureEncoding(uncompressed_msaa),
          "valid uncompressed MSAA depth descriptor required an HTILE "
          "compatibility flag");

  auto r128_msaa = uncompressed_msaa;
  std::fill(r128_msaa.fields + 4, r128_msaa.fields + 8, 0u);
  Require("DepthTextureEncoding", "R128 uncompressed 2x MSAA depth",
          IsSupportedDepthTextureEncoding(r128_msaa, true),
          "valid R128 MSAA depth descriptor required omitted dwords");

  const ShaderTextureResource compressed_descriptor{{
      0x0104d500u,
      0xc1600000u,
      0x021bc3bfu,
      0x91800924u,
      0x00000000u,
      0x00700000u,
      0x80280000u,
      0x000106d4u,
  }};
  Require("DepthTextureEncoding", "compressed HTILE descriptor",
          IsSupportedDepthTextureEncoding(compressed_descriptor),
          "valid compressed depth descriptor required a prior depth target");

  const ShaderTextureResource first_use_depth{{
      0x0225fc00u, 0x01600000u, 0x00000000u, 0x91800924u,
      0x00000000u, 0x00700000u, 0x80280000u, 0x000225fdu,
  }};
  Require("DepthTextureEncoding", "PPSA30490 first-use 1x1 depth",
          IsSupportedDepthTextureEncoding(first_use_depth),
          "captured comparison texture required tracked HTILE metadata");

  auto missing_metadata = compressed_descriptor;
  missing_metadata.fields[6] &= 0x00ffffffu;
  missing_metadata.fields[7] = 0;
  auto out_of_range_metadata = compressed_descriptor;
  out_of_range_metadata.fields[7] = TRACKER_ADDRESS_SIZE >> 16u;
  auto unaligned_metadata = compressed_descriptor;
  unaligned_metadata.fields[6] ^= 1u << 24u;
  auto dcc_only_control = compressed_descriptor;
  dcc_only_control.fields[6] |= 1u << 22u;
  auto non_msaa_iterate_256 = compressed_descriptor;
  non_msaa_iterate_256.fields[6] |= 1u << 10u;
  Require(
      "DepthTextureEncoding", "invalid HTILE encoding",
      !IsSupportedDepthTextureEncoding(missing_metadata) &&
          !IsSupportedDepthTextureEncoding(out_of_range_metadata) &&
          !IsSupportedDepthTextureEncoding(unaligned_metadata) &&
          !IsSupportedDepthTextureEncoding(dcc_only_control) &&
          !IsSupportedDepthTextureEncoding(non_msaa_iterate_256),
      "compressed sampled depth accepted an unsupported address or control");

  std::printf("[host]    %-32s ok\n", "DepthTextureEncoding");
}

ShaderRecompiler::IR::ImageResource BasicStorageTextureResource() {
  ShaderRecompiler::IR::ImageResource resource{};
  resource.resource_class = ShaderRecompiler::IR::ImageResourceClass::Storage;
  resource.numeric_class = Prospero::TextureNumericClass::Float;
  resource.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim3D;
  resource.read = true;
  resource.written = true;
  return resource;
}

ShaderTextureResource BasicStorageTextureDescriptor() {
  return {{0x00785d00u, 0x04700000u, 0x00080008u, 0xa1b00facu, 0x00000020u,
           0x00700000u, 0x00000000u, 0x00000000u}};
}

ShaderRecompiler::IR::ImageResource BasicLinearStorageTextureResource() {
  auto resource = BasicStorageTextureResource();
  resource.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2D;
  resource.read = false;
  return resource;
}

ShaderTextureResource BasicLinearStorageTextureDescriptor() {
  return {{0x04bcc401u, 0xc3800000u, 0x021bc3bfu, 0x900003acu, 0x00000000u,
           0x00700000u, 0x00000000u, 0x00000000u}};
}

ShaderRecompiler::IR::ImageResource BasicBgraStorageTextureResource() {
  auto resource = BasicStorageTextureResource();
  resource.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2D;
  resource.read = false;
  return resource;
}

ShaderTextureResource BasicBgraStorageTextureDescriptor() {
  return {{0x007c6500u, 0xc3800000u, 0x010dc1dfu, 0x91b00f2eu, 0x00000000u,
           0x00700000u, 0x00000000u, 0x00000000u}};
}

ShaderTextureResource Ppsa06228R11G11B10StorageTextureDescriptor() {
  return {{0x10c6b500u, 0xc2400000u, 0x010dc1dfu, 0x91b003acu, 0x00000000u,
           0x00700000u, 0x00000000u, 0x00000000u}};
}

ShaderTextureResource Ppsa01530MaxMipStorageTextureDescriptor() {
  return {{0x04a42900u, 0xc3e00000u, 0x000fc00fu, 0x91b0022cu, 0x00000000u,
           0x00700050u, 0x00000000u, 0x00000000u}};
}

ShaderTextureResource Ppsa01340MipRangeStorageTextureDescriptor() {
  return {{0x0294dc00u, 0xc4700000u, 0x00b3c13fu, 0x91b31facu, 0x00000000u,
           0x00700030u, 0xb07b0000u, 0x0002ac3cu}};
}

ShaderTextureResource Ppsa01340OverwideMipStorageTextureDescriptor() {
  return {{0x0346c000u, 0xc4b00000u, 0x007fc07fu, 0x90990facu, 0x00000000u,
           0x00700080u, 0x00000000u, 0x00000000u}};
}

ShaderRecompiler::IR::ImageResource Ppsa01530MaxMipStorageTextureResource() {
  auto resource = BasicBgraStorageTextureResource();
  resource.numeric_class = Prospero::TextureNumericClass::Uint;
  return resource;
}

ShaderTextureResource Ppsa02527R16FloatStorageTextureDescriptor() {
  return {{0x00ce3500u, 0xc0d00000u, 0x010dc1dfu, 0x91b00204u, 0x00000000u,
           0x00700000u, 0x00000000u, 0x00000000u}};
}

ShaderTextureResource Ppsa02527R32FloatStorageTextureDescriptor() {
  return {{0x00cea900u, 0xc1600000u, 0x0086c0efu, 0x91b00204u, 0x00000000u,
           0x00700000u, 0x00000000u, 0x00000000u}};
}

ShaderTextureResource Ppsa02527R8UnormStorageTextureDescriptor() {
  return {{0x00c7d500u, 0xc0100000u, 0x0086c0efu, 0x91b00204u, 0x00000000u,
           0x00700000u, 0x00000000u, 0x00000000u}};
}

ShaderTextureResource BasicYzwxStorageTextureDescriptor() {
  return {{0x00627801u, 0xc4d00000u, 0x0001c001u, 0x900009f5u, 0x00000000u,
           0x00700000u, 0x00000000u, 0x00000000u}};
}

ShaderRecompiler::IR::ImageResource BasicArrayStorageTextureResource() {
  auto resource = BasicLinearStorageTextureResource();
  resource.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2DArray;
  return resource;
}

ShaderTextureResource BasicArrayStorageTextureDescriptor() {
  return {{0x20179000u, 0x03800000u, 0x00000000u, 0xd1b00f2eu, 0x00000000u,
           0x00700000u, 0x00000000u, 0x00000000u}};
}

ShaderRecompiler::IR::ImageResource BasicUintArrayStorageTextureResource() {
  auto resource = BasicArrayStorageTextureResource();
  resource.numeric_class = Prospero::TextureNumericClass::Uint;
  return resource;
}

ShaderTextureResource BasicUintArrayStorageTextureDescriptor() {
  return {{0x20179200u, 0x01400000u, 0x00000000u, 0xd1b00204u, 0x00000000u,
           0x00700000u, 0x00000000u, 0x00000000u}};
}

ShaderTextureResource Standard4KBUintArrayStorageTextureDescriptor() {
  return {{0x006c6600u, 0x01400000u, 0x00000000u, 0xd0500204u, 0x00000000u,
           0x00700000u, 0x00000000u, 0x00000000u}};
}

ShaderTextureResource Standard64KBStorageTextureDescriptor() {
  return {{0x011fab00u, 0xc3800000u, 0x0003c003u, 0xd0900facu, 0x00000000u,
           0x00700000u, 0x00000000u, 0x00000000u}};
}

ShaderRecompiler::IR::ImageResource Ppsa14053DepthTileStorageTextureResource() {
  return BasicUintArrayStorageTextureResource();
}

ShaderTextureResource Ppsa14053DepthTileStorageTextureDescriptor() {
  return {{0x20144c00u, 0x00500000u, 0x00000000u, 0xd1800204u, 0x00000000u,
           0x00700000u, 0x00000000u, 0x00000000u}};
}

ShaderTextureResource Ppsa10112D16StorageTextureDescriptor() {
  return {{0x205b9000u, 0xc0700000u, 0x0021803bu, 0xd1800204u, 0x00000000u,
           0x00700000u, 0x00000000u, 0x00000000u}};
}

ShaderRecompiler::IR::ImageResource BasicUintVolumeStorageTextureResource() {
  auto resource = BasicStorageTextureResource();
  resource.numeric_class = Prospero::TextureNumericClass::Uint;
  resource.read = false;
  return resource;
}

ShaderTextureResource BasicUintVolumeStorageTextureDescriptor() {
  return {{0x20180600u, 0xc0b00000u, 0x0003c003u, 0xa0000004u, 0x0000000fu,
           0x00700000u, 0x00000000u, 0x00000000u}};
}

ShaderRecompiler::IR::ImageResource AtomicStorageTextureResource() {
  auto resource = BasicLinearStorageTextureResource();
  resource.numeric_class = Prospero::TextureNumericClass::Uint;
  resource.read = true;
  resource.atomic = true;
  return resource;
}

ShaderTextureResource AtomicStorageTextureDescriptor() {
  return {{0x304bb700u, 0xc1400000u, 0x0000001fu, 0x91b00204u, 0x00000000u,
           0x00700000u, 0x00000000u, 0x00000000u}};
}

[[noreturn]] void RunStorageTextureDescriptorDeathCase(const char *kind) {
  auto resource = BasicStorageTextureResource();
  auto descriptor = BasicStorageTextureDescriptor();
  if (std::strcmp(kind, "linear-rgb1-read") == 0) {
    resource = BasicLinearStorageTextureResource();
    descriptor = BasicLinearStorageTextureDescriptor();
    resource.read = true;
  } else if (std::strcmp(kind, "bgra-read") == 0) {
    resource = BasicBgraStorageTextureResource();
    descriptor = BasicBgraStorageTextureDescriptor();
    resource.read = true;
  } else if (std::strcmp(kind, "r16-float-read") == 0) {
    resource = BasicBgraStorageTextureResource();
    descriptor = Ppsa02527R16FloatStorageTextureDescriptor();
    resource.read = true;
  } else if (std::strcmp(kind, "r8-unorm-read") == 0) {
    resource = BasicBgraStorageTextureResource();
    descriptor = Ppsa02527R8UnormStorageTextureDescriptor();
    resource.read = true;
  } else if (std::strcmp(kind, "yzwx-read") == 0) {
    resource = BasicLinearStorageTextureResource();
    descriptor = BasicYzwxStorageTextureDescriptor();
    resource.read = true;
  } else if (std::strcmp(kind, "reserved-swizzle") == 0) {
    resource = BasicLinearStorageTextureResource();
    descriptor = BasicLinearStorageTextureDescriptor();
    descriptor.fields[3] =
        (descriptor.fields[3] & ~0xfffu) | DstSel(4, 5, 6, 2);
  } else if (std::strcmp(kind, "resource") == 0) {
    resource.written = false;
  } else if (std::strcmp(kind, "type") == 0) {
    descriptor.fields[3] =
        (descriptor.fields[3] & 0x0fffffffu) |
        (static_cast<uint32_t>(Prospero::ImageType::kColor2D) << 28u);
  } else if (std::strcmp(kind, "standard256b-volume") == 0) {
    descriptor.fields[3] =
        (descriptor.fields[3] & ~(0x1fu << 20u)) |
        (static_cast<uint32_t>(Prospero::TileMode::kStandard256B) << 20u);
  } else if (std::strcmp(kind, "inverted-mip-range") == 0) {
    descriptor.fields[3] |= 1u << 12u;
    descriptor.fields[5] |= 1u << 4u;
  } else if (std::strcmp(kind, "swizzle") == 0) {
    descriptor.fields[3] =
        (descriptor.fields[3] & ~0xfffu) | DstSel(4, 5, 6, 1);
  } else if (std::strcmp(kind, "array-base-out-of-range") == 0) {
    resource = BasicArrayStorageTextureResource();
    descriptor = BasicArrayStorageTextureDescriptor();
    descriptor.fields[4] |= 1u << 16u;
  } else if (std::strcmp(kind, "reserved") == 0) {
    descriptor.fields[1] |= 1u << 29u;
  } else if (std::strcmp(kind, "uint-format") == 0) {
    descriptor.fields[1] =
        (descriptor.fields[1] & ~0x1ff00000u) |
        (static_cast<uint32_t>(Prospero::BufferFormat::k8_8_8_8UInt) << 20u);
  } else if (std::strcmp(kind, "uint-resource-float-format") == 0) {
    resource = BasicUintArrayStorageTextureResource();
    descriptor = BasicArrayStorageTextureDescriptor();
  } else if (std::strcmp(kind, "atomic-format") == 0) {
    resource = AtomicStorageTextureResource();
    descriptor = AtomicStorageTextureDescriptor();
    descriptor.fields[1] =
        (descriptor.fields[1] & ~0x1ff00000u) |
        (static_cast<uint32_t>(Prospero::BufferFormat::k8UInt) << 20u);
  } else if (std::strcmp(kind, "depth-tile-read") == 0) {
    resource = Ppsa14053DepthTileStorageTextureResource();
    descriptor = Ppsa14053DepthTileStorageTextureDescriptor();
    resource.read = true;
  } else if (std::strcmp(kind, "depth-tile-extent") == 0) {
    resource = Ppsa14053DepthTileStorageTextureResource();
    descriptor = Ppsa14053DepthTileStorageTextureDescriptor();
    resource.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2D;
    descriptor.fields[3] =
        (descriptor.fields[3] & 0x0fffffffu) |
        (static_cast<uint32_t>(Prospero::ImageType::kColor2D) << 28u);
    descriptor.fields[4] |= 1u;
  } else if (std::strcmp(kind, "depth-tile-fmask") == 0) {
    resource = BasicArrayStorageTextureResource();
    descriptor = Ppsa10112D16StorageTextureDescriptor();
    descriptor.fields[1] =
        (descriptor.fields[1] & ~(0x1ffu << 20u)) |
        (static_cast<uint32_t>(Prospero::BufferFormat::kFmask8_S4_F4) << 20u);
  } else {
    std::_Exit(0x7e);
  }
  ValidateStorageTexture(resource, descriptor, 0x10000);
  std::_Exit(0x7f);
}

#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
void CheckBasicStorageTextureDescriptor() {
  const auto descriptor = BasicStorageTextureDescriptor();
  Require("BasicStorageTexture", "descriptor",
          descriptor.Base40() == 0x785d0000ull &&
              descriptor.Width5() + 1u == 33 &&
              descriptor.Height5() + 1u == 33 && descriptor.Depth() + 1u == 33,
          "basic 3D storage descriptor fixture is malformed");
  ValidateStorageTexture(BasicStorageTextureResource(), descriptor, 0x10000);

  const ShaderTextureResource extended{{0x204aca00u, 0xc4700000u, 0x000fc00fu,
                                        0xa1b00facu, 0x0000003fu, 0x00700000u,
                                        0x006b0000u, 0x00204b0au}};
  auto extended_resource = BasicStorageTextureResource();
  extended_resource.read = false;
  Require("BasicStorageTexture", "extended descriptor",
          extended.fields[6] != 0 && extended.fields[7] != 0,
          "extended 3D storage descriptor fixture is malformed");
  ValidateStorageTexture(extended_resource, extended, 0x400000);

  const auto linear = BasicLinearStorageTextureDescriptor();
  Require("BasicStorageTexture", "linear descriptor",
          linear.Base40() == 0x4bcc40100ull && linear.Width5() + 1u == 3840 &&
              linear.Height5() + 1u == 2160 && linear.Depth() + 1u == 1 &&
              linear.Format() == Prospero::BufferFormat::k8_8_8_8UNorm &&
              linear.TileMode() == Prospero::TileMode::kLinear,
          "PPSA07429 linear 2D storage descriptor fixture is malformed");
  ValidateStorageTexture(BasicLinearStorageTextureResource(), linear,
                         0x1fa4000);

  const auto bgra = BasicBgraStorageTextureDescriptor();
  Require("BasicStorageTexture", "BGRA descriptor",
          bgra.Base40() == 0x7c650000ull && bgra.Width5() + 1u == 1920 &&
              bgra.Height5() + 1u == 1080 && bgra.Depth() + 1u == 1 &&
              bgra.Format() == Prospero::BufferFormat::k8_8_8_8UNorm &&
              bgra.TileMode() == Prospero::TileMode::kRenderTarget &&
              bgra.DstSelXYZW() == DstSel(6, 5, 4, 7),
          "PPSA02604 BGRA 2D storage descriptor fixture is malformed");
  ValidateStorageTexture(BasicBgraStorageTextureResource(), bgra, 0x870000);

  const ShaderTextureResource r128{
      {0x0202e500u, 0xc8200000u, 0x010dc1dfu, 0x91b00facu, 0, 0, 0, 0}};
  auto r128_resource = BasicBgraStorageTextureResource();
  r128_resource.r128 = true;
  Require("BasicStorageTexture", "PPSA01736 R128 descriptor",
          r128.Base40() == 0x202e50000ull && r128.Width5() + 1u == 1920 &&
              r128.Height5() + 1u == 1080 && r128.Depth() + 1u == 1 &&
              r128.Format() == Prospero::BufferFormat::k8_8_8_8Srgb &&
              r128.TileMode() == Prospero::TileMode::kRenderTarget &&
              r128.DstSelXYZW() == DstSel(4, 5, 6, 7),
          "PPSA01736 R128 storage descriptor fixture is malformed");
  ValidateStorageTexture(r128_resource, r128, 0x870000);

  const auto r11g11b10 = Ppsa06228R11G11B10StorageTextureDescriptor();
  Require("BasicStorageTexture", "PPSA06228 R11G11B10 descriptor",
          r11g11b10.Base40() == 0x10c6b50000ull &&
              r11g11b10.Width5() + 1u == 1920 &&
              r11g11b10.Height5() + 1u == 1080 && r11g11b10.Depth() + 1u == 1 &&
              r11g11b10.Format() == Prospero::BufferFormat::k11_11_10Float &&
              r11g11b10.TileMode() == Prospero::TileMode::kRenderTarget &&
              r11g11b10.DstSelXYZW() == DstSel(4, 5, 6, 1),
          "PPSA06228 R11G11B10 storage descriptor fixture is malformed");
  ValidateStorageTexture(BasicBgraStorageTextureResource(), r11g11b10,
                         0x870000);
  ValidateStorageColorView(vk::Format::eB8G8R8A8Unorm,
                           vk::Format::eB10G11R11UfloatPack32,
                           r11g11b10.DstSelXYZW());

  const auto max_mip = Ppsa01530MaxMipStorageTextureDescriptor();
  Require("BasicStorageTexture", "PPSA01530 max-mip descriptor",
          max_mip.Base40() == 0x4a4290000ull && max_mip.Width5() + 1u == 64 &&
              max_mip.Height5() + 1u == 64 && max_mip.Depth() + 1u == 1 &&
              max_mip.BaseLevel() == 0 && max_mip.LastLevel() == 0 &&
              max_mip.MaxMip() == 5 &&
              max_mip.Format() == Prospero::BufferFormat::k32_32UInt &&
              max_mip.TileMode() == Prospero::TileMode::kRenderTarget &&
              max_mip.DstSelXYZW() == DstSel(4, 5, 0, 1),
          "PPSA01530 max-mip storage descriptor fixture is malformed");
  ValidateStorageTexture(Ppsa01530MaxMipStorageTextureResource(), max_mip,
                         0x20000);
  auto mip_one = max_mip;
  mip_one.fields[3] |= (1u << 12u) | (1u << 16u);
  Require("BasicStorageTexture", "PPSA01530 mip-one descriptor",
          mip_one.BaseLevel() == 1 && mip_one.LastLevel() == 1 &&
              mip_one.MaxMip() == 5,
          "PPSA01530 mip-one storage descriptor fixture is malformed");
  ValidateStorageTexture(Ppsa01530MaxMipStorageTextureResource(), mip_one,
                         0x20000);

  const auto mip_range = Ppsa01340MipRangeStorageTextureDescriptor();
  Require("BasicStorageTexture", "PPSA01340 mip-range descriptor",
          mip_range.Base40() == 0x294dc0000ull &&
              mip_range.Width5() + 1u == 1280 &&
              mip_range.Height5() + 1u == 720 && mip_range.Depth() + 1u == 1 &&
              mip_range.BaseLevel() == 1 && mip_range.LastLevel() == 3 &&
              mip_range.MaxMip() == 3 &&
              mip_range.Format() == Prospero::BufferFormat::k16_16_16_16Float &&
              mip_range.TileMode() == Prospero::TileMode::kRenderTarget &&
              mip_range.DstSelXYZW() == DstSel(4, 5, 6, 7),
          "PPSA01340 mip-range storage descriptor fixture is malformed");
  ValidateStorageTexture(BasicBgraStorageTextureResource(), mip_range,
                         0xa30000);

  const auto overwide_mip = Ppsa01340OverwideMipStorageTextureDescriptor();
  Require(
      "BasicStorageTexture", "PPSA01340 over-wide mip view",
      overwide_mip.Base40() == 0x346c00000ull &&
          overwide_mip.Width5() + 1u == 512 &&
          overwide_mip.Height5() + 1u == 512 && overwide_mip.BaseLevel() == 0 &&
          overwide_mip.LastLevel() == 9 && overwide_mip.MaxMip() == 8 &&
          overwide_mip.Format() == Prospero::BufferFormat::k32_32_32_32UInt &&
          overwide_mip.TileMode() == Prospero::TileMode::kStandard64KB,
      "captured over-wide storage mip view is malformed");
  TileSizeAlign overwide_size{};
  TileGetTextureTotalSize(overwide_mip.Format(), overwide_mip.Width5() + 1u,
                          overwide_mip.Height5() + 1u, 1,
                          overwide_mip.MaxMip() + 1u, overwide_mip.TileMode(),
                          false, overwide_size);
  Require("BasicStorageTexture", "PPSA01340 over-wide mip footprint",
          overwide_size.size == 0x560000 && overwide_size.align == 0x10000,
          "captured nine-level Standard64KB footprint changed");
  ValidateStorageTexture(Ppsa01530MaxMipStorageTextureResource(), overwide_mip,
                         overwide_size.size);

  const auto r16_float = Ppsa02527R16FloatStorageTextureDescriptor();
  Require("BasicStorageTexture", "PPSA02527 R16F descriptor",
          r16_float.Base40() == 0xce350000ull &&
              r16_float.Width5() + 1u == 1920 &&
              r16_float.Height5() + 1u == 1080 && r16_float.Depth() + 1u == 1 &&
              r16_float.Format() == Prospero::BufferFormat::k16Float &&
              r16_float.TileMode() == Prospero::TileMode::kRenderTarget &&
              r16_float.DstSelXYZW() == DstSel(4, 0, 0, 1),
          "PPSA02527 R16F 2D storage descriptor fixture is malformed");
  ValidateStorageTexture(BasicBgraStorageTextureResource(), r16_float,
                         0x480000);

  const auto r32_float = Ppsa02527R32FloatStorageTextureDescriptor();
  Require("BasicStorageTexture", "PPSA02527 R32F descriptor",
          r32_float.Base40() == 0xcea90000ull &&
              r32_float.Width5() + 1u == 960 &&
              r32_float.Height5() + 1u == 540 && r32_float.Depth() + 1u == 1 &&
              r32_float.Format() == Prospero::BufferFormat::k32Float &&
              r32_float.TileMode() == Prospero::TileMode::kRenderTarget &&
              r32_float.DstSelXYZW() == DstSel(4, 0, 0, 1),
          "PPSA02527 R32F 2D storage descriptor fixture is malformed");
  ValidateStorageTexture(BasicBgraStorageTextureResource(), r32_float,
                         0x280000);

  const auto r8_unorm = Ppsa02527R8UnormStorageTextureDescriptor();
  Require("BasicStorageTexture", "PPSA02527 R8 UNORM descriptor",
          r8_unorm.Base40() == 0xc7d50000ull && r8_unorm.Width5() + 1u == 960 &&
              r8_unorm.Height5() + 1u == 540 && r8_unorm.Depth() + 1u == 1 &&
              r8_unorm.Format() == Prospero::BufferFormat::k8UNorm &&
              r8_unorm.TileMode() == Prospero::TileMode::kRenderTarget &&
              r8_unorm.DstSelXYZW() == DstSel(4, 0, 0, 1),
          "PPSA02527 R8 UNORM 2D storage descriptor fixture is malformed");
  ValidateStorageTexture(BasicBgraStorageTextureResource(), r8_unorm, 0xc0000);

  const auto yzwx = BasicYzwxStorageTextureDescriptor();
  Require("BasicStorageTexture", "YZWX descriptor",
          yzwx.Base40() == 0x62780100ull && yzwx.Width5() + 1u == 8 &&
              yzwx.Height5() + 1u == 8 && yzwx.Depth() + 1u == 1 &&
              yzwx.Format() == Prospero::BufferFormat::k32_32_32_32Float &&
              yzwx.TileMode() == Prospero::TileMode::kLinear &&
              yzwx.DstSelXYZW() == DstSel(5, 6, 7, 4),
          "PPSA04181 linear YZWX storage descriptor fixture is malformed");
  ValidateStorageTexture(BasicLinearStorageTextureResource(), yzwx, 0x800);
  auto all_swizzles = yzwx;
  all_swizzles.fields[1] =
      (all_swizzles.fields[1] & ~0x1ff00000u) |
      (static_cast<uint32_t>(Prospero::BufferFormat::k16_16_16_16Float) << 20u);
  uint32_t valid_storage_swizzles = 0;
  for (uint32_t swizzle = 0; swizzle <= 0xfffu; swizzle++) {
    if (!IsValidImageSwizzle(swizzle)) {
      continue;
    }
    all_swizzles.fields[3] = (all_swizzles.fields[3] & ~0xfffu) | swizzle;
    ValidateStorageTexture(BasicLinearStorageTextureResource(), all_swizzles,
                           0x800);
    ValidateStorageColorView(vk::Format::eR16G16B16A16Sfloat,
                             vk::Format::eR16G16B16A16Sfloat, swizzle);
    ValidateStorageColorView(vk::Format::eR8G8B8A8Srgb,
                             vk::Format::eR8G8B8A8Unorm, swizzle);
    ValidateStorageColorView(vk::Format::eB8G8R8A8Srgb,
                             vk::Format::eR8G8B8A8Unorm, swizzle);
    valid_storage_swizzles++;
  }
  Require("BasicStorageTexture", "all write swizzles",
          valid_storage_swizzles == 1296,
          "valid write-only storage image mappings were rejected");

  const ShaderTextureResource cube{{0x025bca00u, 0xc4700000u, 0x003fc03fu,
                                    0xb1b00facu, 0x00000005u, 0x00700080u,
                                    0x00000000u, 0x00000000u}};
  auto cube_resource = BasicArrayStorageTextureResource();
  cube_resource.cube = true;
  Require("BasicStorageTexture", "PPSA07429 cube descriptor",
          cube.Base40() == 0x25bca0000ull && cube.Width5() + 1u == 256 &&
              cube.Height5() + 1u == 256 && cube.Depth() + 1u == 6 &&
              cube.BaseArray5() == 0 && cube.MaxMip() == 8 &&
              cube.Type() == Prospero::ImageType::kCube &&
              cube.Format() == Prospero::BufferFormat::k16_16_16_16Float &&
              cube.TileMode() == Prospero::TileMode::kRenderTarget &&
              cube.DstSelXYZW() == DstSel(4, 5, 6, 7),
          "PPSA07429 cube storage descriptor fixture is malformed");
  ValidateStorageTexture(cube_resource, cube, 0x420000);

  const auto array = BasicArrayStorageTextureDescriptor();
  Require("BasicStorageTexture", "2D-array descriptor",
          array.Base40() == 0x2017900000ull && array.Width5() + 1u == 1 &&
              array.Height5() + 1u == 1 && array.Depth() + 1u == 1 &&
              array.BaseArray5() == 0 &&
              array.Type() == Prospero::ImageType::kColor2DArray &&
              array.Format() == Prospero::BufferFormat::k8_8_8_8UNorm &&
              array.TileMode() == Prospero::TileMode::kRenderTarget &&
              array.DstSelXYZW() == DstSel(6, 5, 4, 7),
          "PPSA21268 2D-array storage descriptor fixture is malformed");
  ValidateStorageTexture(BasicArrayStorageTextureResource(), array, 0x10000);
  const ShaderTextureResource mip_array{{0x20268d00u, 0xc4700000u, 0x001fc01fu,
                                         0xd1b11facu, 0x00000000u, 0x00700070u,
                                         0x00000000u, 0x00000000u}};
  Require("BasicStorageTexture", "PPSA14457 mip-one 2D-array descriptor",
          mip_array.BaseLevel() == 1 && mip_array.LastLevel() == 1 &&
              mip_array.MaxMip() == 7 &&
              mip_array.Type() == Prospero::ImageType::kColor2DArray &&
              mip_array.Depth() == 0 && mip_array.BaseArray5() == 0,
          "PPSA14457 mip-one 2D-array storage descriptor fixture is malformed");
  ValidateStorageTexture(BasicArrayStorageTextureResource(), mip_array,
                         0x30000);

  const auto uint_array = BasicUintArrayStorageTextureDescriptor();
  Require("BasicStorageTexture", "uint 2D-array descriptor",
          uint_array.Base40() == 0x2017920000ull &&
              uint_array.Width5() + 1u == 1 && uint_array.Height5() + 1u == 1 &&
              uint_array.Depth() + 1u == 1 && uint_array.BaseArray5() == 0 &&
              uint_array.Type() == Prospero::ImageType::kColor2DArray &&
              uint_array.Format() == Prospero::BufferFormat::k32UInt &&
              uint_array.TileMode() == Prospero::TileMode::kRenderTarget &&
              uint_array.DstSelXYZW() == DstSel(4, 0, 0, 1),
          "PPSA21268 uint 2D-array storage descriptor fixture is malformed");
  ValidateStorageTexture(BasicUintArrayStorageTextureResource(), uint_array,
                         0x10000);

  const ShaderTextureResource standard256b{{
      0x204e4900u,
      0x43c00000u,
      0x00004000u,
      0x90100facu,
      0x00000000u,
      0x00700000u,
      0x00000000u,
      0x00000000u,
  }};
  auto standard256b_resource = BasicBgraStorageTextureResource();
  standard256b_resource.numeric_class = Prospero::TextureNumericClass::Uint;
  TileSizeAlign standard256b_size{};
  TileGetTextureTotalSize(standard256b.Format(), standard256b.Width5() + 1u,
                          standard256b.Height5() + 1u,
                          standard256b.Depth() + 1u, 1, standard256b.TileMode(),
                          false, standard256b_size);
  Require("BasicStorageTexture", "Standard256B uint 2D descriptor",
          standard256b.Width5() + 1u == 2 && standard256b.Height5() + 1u == 2 &&
              standard256b.Depth() + 1u == 1 &&
              standard256b.Type() == Prospero::ImageType::kColor2D &&
              standard256b.Format() == Prospero::BufferFormat::k8_8_8_8UInt &&
              standard256b.TileMode() == Prospero::TileMode::kStandard256B &&
              standard256b.DstSelXYZW() == DstSel(4, 5, 6, 7) &&
              standard256b_size.size == 0x100 &&
              standard256b_size.align == 0x100,
          "captured PPSA08511 Standard256B storage descriptor is malformed");
  ValidateStorageTexture(standard256b_resource, standard256b,
                         standard256b_size.size);

  const auto standard4kb_array = Standard4KBUintArrayStorageTextureDescriptor();
  TileSizeAlign standard4kb_size{};
  TileGetTextureTotalSize(standard4kb_array.Format(), 1, 1, 1, 1,
                          standard4kb_array.TileMode(), false,
                          standard4kb_size);
  Require(
      "BasicStorageTexture", "Standard4KB uint 2D-array descriptor",
      standard4kb_array.Type() == Prospero::ImageType::kColor2DArray &&
          standard4kb_array.Format() == Prospero::BufferFormat::k32UInt &&
          standard4kb_array.TileMode() == Prospero::TileMode::kStandard4KB &&
          standard4kb_array.DstSelXYZW() == DstSel(4, 0, 0, 1) &&
          standard4kb_size.size == 0x1000 && standard4kb_size.align == 0x1000,
      "captured Standard4KB uint 2D-array descriptor is malformed");
  ValidateStorageTexture(BasicUintArrayStorageTextureResource(),
                         standard4kb_array, standard4kb_size.size);

  auto based_standard4kb_array = standard4kb_array;
  based_standard4kb_array.fields[0] = 0x006c6800u;
  based_standard4kb_array.fields[4] = 0x00010001u;
  TileSizeAlign based_standard4kb_size{};
  TileGetTextureTotalSize(based_standard4kb_array.Format(), 1, 1,
                          based_standard4kb_array.Depth() + 1u, 1,
                          based_standard4kb_array.TileMode(), false,
                          based_standard4kb_size);
  Require("BasicStorageTexture", "based Standard4KB array view",
          based_standard4kb_array.Base40() == 0x6c680000ull &&
              based_standard4kb_array.BaseArray5() == 1 &&
              based_standard4kb_array.Depth() == 1 &&
              based_standard4kb_size.size == 0x2000 &&
              based_standard4kb_size.align == 0x1000,
          "captured based Standard4KB array view is malformed");
  ValidateStorageTexture(BasicUintArrayStorageTextureResource(),
                         based_standard4kb_array, based_standard4kb_size.size);

  const auto standard64kb = Standard64KBStorageTextureDescriptor();
  TileSizeAlign standard64kb_size{};
  TileGetTextureTotalSize(standard64kb.Format(), standard64kb.Width5() + 1u,
                          standard64kb.Height5() + 1u,
                          standard64kb.Depth() + 1u, 1, standard64kb.TileMode(),
                          false, standard64kb_size);
  Require("BasicStorageTexture", "Standard64KB 2D descriptor",
          standard64kb.Type() == Prospero::ImageType::kColor2DArray &&
              standard64kb.Format() == Prospero::BufferFormat::k8_8_8_8UNorm &&
              standard64kb.TileMode() == Prospero::TileMode::kStandard64KB &&
              standard64kb.DstSelXYZW() == DstSel(4, 5, 6, 7) &&
              standard64kb_size.size == 0x10000 &&
              standard64kb_size.align == 0x10000,
          "captured Standard64KB storage descriptor is malformed");
  ValidateStorageTexture(BasicBgraStorageTextureResource(), standard64kb,
                         standard64kb_size.size);

  const auto uint_volume = BasicUintVolumeStorageTextureDescriptor();
  Require("BasicStorageTexture", "uint 3D descriptor",
          uint_volume.Base40() == 0x2018060000ull &&
              uint_volume.Width5() + 1u == 16 &&
              uint_volume.Height5() + 1u == 16 &&
              uint_volume.Depth() + 1u == 16 && uint_volume.BaseArray5() == 0 &&
              uint_volume.Type() == Prospero::ImageType::kColor3D &&
              uint_volume.Format() == Prospero::BufferFormat::k16UInt &&
              uint_volume.TileMode() == Prospero::TileMode::kLinear &&
              uint_volume.DstSelXYZW() == DstSel(4, 0, 0, 0),
          "PPSA21268 uint 3D storage descriptor fixture is malformed");
  ValidateStorageTexture(BasicUintVolumeStorageTextureResource(), uint_volume,
                         0x10000);

  const ShaderTextureResource tiled_uint_volume{
      {0x1ac0e530u, 0xc0b00000u, 0x0003c003u, 0xa0500004u, 0x0000000fu,
       0x00700000u, 0x00000000u, 0x00000000u}};
  Require("BasicStorageTexture", "tiled uint 3D descriptor",
          tiled_uint_volume.Width5() + 1u == 16 &&
              tiled_uint_volume.Height5() + 1u == 16 &&
              tiled_uint_volume.Depth() + 1u == 16 &&
              tiled_uint_volume.Type() == Prospero::ImageType::kColor3D &&
              tiled_uint_volume.TileMode() == Prospero::TileMode::kStandard4KB,
          "captured tiled uint 3D storage descriptor fixture is malformed");
  ValidateStorageTexture(BasicUintVolumeStorageTextureResource(),
                         tiled_uint_volume, 0x2000);

  const auto depth_tile = Ppsa14053DepthTileStorageTextureDescriptor();
  Require("BasicStorageTexture", "PPSA14053 depth-tile descriptor",
          depth_tile.Base40() == 0x20144c0000ull &&
              depth_tile.Width5() + 1u == 1 && depth_tile.Height5() + 1u == 1 &&
              depth_tile.Depth() + 1u == 1 && depth_tile.BaseArray5() == 0 &&
              depth_tile.Type() == Prospero::ImageType::kColor2DArray &&
              depth_tile.Format() == Prospero::BufferFormat::k8UInt &&
              depth_tile.TileMode() == Prospero::TileMode::kDepth &&
              depth_tile.DstSelXYZW() == DstSel(4, 0, 0, 1),
          "PPSA14053 write-only depth-tile storage descriptor fixture is "
          "malformed");
  ValidateStorageTexture(Ppsa14053DepthTileStorageTextureResource(), depth_tile,
                         0x10000);
  const auto d16_depth_tile = Ppsa10112D16StorageTextureDescriptor();
  Require("BasicStorageTexture", "PPSA10112 D16 depth-tile descriptor",
          d16_depth_tile.Base40() == 0x205b900000ull &&
              d16_depth_tile.Width5() + 1u == 240 &&
              d16_depth_tile.Height5() + 1u == 135 &&
              d16_depth_tile.Depth() + 1u == 1 &&
              d16_depth_tile.Type() == Prospero::ImageType::kColor2DArray &&
              d16_depth_tile.Format() == Prospero::BufferFormat::k16UNorm &&
              d16_depth_tile.TileMode() == Prospero::TileMode::kDepth &&
              d16_depth_tile.DstSelXYZW() == DstSel(4, 0, 0, 1),
          "PPSA10112 writable D16 depth-plane descriptor fixture is malformed");
  const auto d16_pitch =
      TileGetTexturePitch(d16_depth_tile.Format(), d16_depth_tile.Width5() + 1u,
                          d16_depth_tile.TileMode());
  TileSizeAlign d16_size{};
  TileGetTextureTotalSize(d16_depth_tile.Format(), d16_depth_tile.Width5() + 1u,
                          d16_depth_tile.Height5() + 1u,
                          d16_depth_tile.Depth() + 1u, 1,
                          d16_depth_tile.TileMode(), false, d16_size);
  Require("BasicStorageTexture", "PPSA10112 D16 depth-tile footprint",
          d16_pitch == 256 && d16_size.size == 0x20000 &&
              d16_size.align == 0x10000,
          "PPSA10112 writable D16 depth-plane footprint is incorrect");
  ValidateStorageTexture(BasicArrayStorageTextureResource(), d16_depth_tile,
                         d16_size.size);
  auto depth_tile_r32 = depth_tile;
  depth_tile_r32.fields[1] =
      (depth_tile_r32.fields[1] & ~(0x1ffu << 20u)) |
      (static_cast<uint32_t>(Prospero::BufferFormat::k32UInt) << 20u);
  depth_tile_r32.fields[3] =
      (depth_tile_r32.fields[3] & ~(0xfu << 28u)) |
      (static_cast<uint32_t>(Prospero::ImageType::kColor2D) << 28u);
  auto depth_tile_r32_resource = Ppsa14053DepthTileStorageTextureResource();
  depth_tile_r32_resource.dimension =
      ShaderRecompiler::Decoder::ImageDimension::Dim2D;
  ValidateStorageTexture(depth_tile_r32_resource, depth_tile_r32, 0x10000);
  Require("BasicStorageTexture", "R32_UINT replicated write mapping",
          IsValidImageSwizzle(DstSel(4, 4, 4, 4)),
          "single-channel replicated destination selection was rejected");

  const auto atomic = AtomicStorageTextureDescriptor();
  Require("BasicStorageTexture", "atomic R32_UINT descriptor",
          atomic.Width5() + 1u == 128 && atomic.Height5() + 1u == 1 &&
              atomic.Depth() + 1u == 1 &&
              atomic.Type() == Prospero::ImageType::kColor2D &&
              atomic.Format() == Prospero::BufferFormat::k32UInt &&
              atomic.DstSelXYZW() == DstSel(4, 0, 0, 1),
          "PPSA22102 image-atomic descriptor fixture is malformed");
  ValidateStorageTexture(AtomicStorageTextureResource(), atomic, 0x10000);

  char path[MAX_PATH]{};
  Require("BasicStorageTexture", "host",
          GetModuleFileNameA(nullptr, path, MAX_PATH) != 0,
          "GetModuleFileName failed");
  for (const char *kind : {"resource",
                           "type",
                           "standard256b-volume",
                           "inverted-mip-range",
                           "swizzle",
                           "linear-rgb1-read",
                           "bgra-read",
                           "r16-float-read",
                           "r8-unorm-read",
                           "yzwx-read",
                           "reserved-swizzle",
                           "array-base-out-of-range",
                           "reserved",
                           "uint-format",
                           "uint-resource-float-format",
                           "atomic-format",
                           "depth-tile-read",
                           "depth-tile-extent",
                           "depth-tile-fmask"}) {
    std::string command = std::string("\"") + path +
                          "\" --storage-texture-descriptor-death " + kind;
    std::vector<char> mutable_command(command.begin(), command.end());
    mutable_command.push_back('\0');
    STARTUPINFOA startup{sizeof(startup)};
    PROCESS_INFORMATION process{};
    Require("BasicStorageTexture", "host",
            CreateProcessA(nullptr, mutable_command.data(), nullptr, nullptr,
                           FALSE, CREATE_NO_WINDOW, nullptr, nullptr, &startup,
                           &process) != 0,
            "CreateProcess failed");
    Require("BasicStorageTexture", "host",
            WaitForSingleObject(process.hProcess, 10000) == WAIT_OBJECT_0,
            "descriptor death case timed out");
    DWORD exit_code = 0;
    const bool exited = GetExitCodeProcess(process.hProcess, &exit_code) != 0;
    CloseHandle(process.hThread);
    CloseHandle(process.hProcess);
    Require("BasicStorageTexture", "host", exited && exit_code == 321,
            std::string(kind) +
                " storage descriptor did not report a fatal error");
  }
  std::printf("[host]    %-32s ok\n", "BasicStorageTextureDescriptor");
}
#endif

void CheckStorageTextureLinearUploadLayout() {
  constexpr auto format = Prospero::BufferFormat::k8_8_8_8UNorm;
  constexpr uint32_t width = 3840;
  constexpr uint32_t height = 2160;
  constexpr uint32_t depth = 1;
  constexpr auto tile = Prospero::TileMode::kLinear;
  const auto pitch = TileGetTexturePitch(format, width, tile);
  TileSizeAlign total{};
  TileGetTextureTotalSize(format, width, height, depth, 1, tile, false, total);
  const auto layout =
      TextureCalcUploadLayout(format, width, height, 1, depth, tile, total.size,
                              true, false, "StorageTextureLinearTest");
  const auto regions = TextureBuildImageCopies(layout);
  Require("StorageTextureLinearUpload", "layout",
          pitch == width && total.size == 0x1fa4000 && total.align == 256 &&
              layout.surface.description.tile_mode == tile &&
              layout.pitch == width && layout.slice_stride == total.size &&
              regions.size() == 1 && regions[0].bufferOffset == 0 &&
              regions[0].imageExtent.width == width &&
              regions[0].imageExtent.height == height &&
              regions[0].bufferRowLength == width,
          "linear RGBA8 storage upload lost Prospero pitch or allocation size");
  std::printf("[host]    %-32s ok\n", "StorageTextureLinearUpload");
}

void CheckStorageTextureDepthTileUploadLayout() {
  constexpr auto format = Prospero::BufferFormat::k8UInt;
  constexpr uint32_t width = 1;
  constexpr uint32_t height = 1;
  constexpr uint32_t depth = 1;
  constexpr auto tile = Prospero::TileMode::kDepth;
  const auto pitch = TileGetTexturePitch(format, width, tile);
  TileSizeAlign slice{};
  TileSizeAlign total{};
  TileSizeOffset level{};
  TilePaddedSize padded{};
  TileGetTextureSize(format, width, height, 1, tile, &slice, &level, &padded);
  TileGetTextureTotalSize(format, width, height, depth, 1, tile, false, total);
  const auto layout =
      TextureCalcUploadLayout(format, width, height, 1, depth, tile, total.size,
                              true, false, "StorageTextureDepthTileTest");
  const auto regions = TextureBuildImageCopies(layout);
  Require("StorageTextureDepthTileUpload", "PPSA14053 layout",
          pitch == 256 && padded.width == 256 && padded.height == 256 &&
              slice.size == 0x10000 && slice.align == 0x10000 &&
              level.size == slice.size && level.offset == 0 &&
              total.size == slice.size && total.align == slice.align &&
              layout.surface.description.tile_mode == tile &&
              layout.surface.texture.block.family ==
                  TileBlockFamily::Depth64KB &&
              layout.pitch == pitch && layout.slice_stride == pitch &&
              layout.source_slice_stride == total.size &&
              layout.mips[0].size == pitch &&
              layout.surface.mips[0].size == total.size &&
              regions.size() == 1 && regions[0].bufferOffset == 0 &&
              regions[0].imageExtent.width == width &&
              regions[0].imageExtent.height == height &&
              regions[0].bufferRowLength == pitch,
          "1x1 R8_UINT depth tile lost its 64 KiB source footprint");
  std::printf("[host]    %-32s ok\n", "StorageTextureDepthTileUpload");
}

void CheckImageSamplerSpecialization() {
  ShaderSamplerResource filtered_sampler{};
  filtered_sampler.fields[2] =
      (1u << 20u) | (3u << 22u) | (2u << 24u) | (2u << 26u);
  filtered_sampler.SetPointFiltering();
  Require("ImageSamplerSpecialization", "forced point sampler",
          filtered_sampler.XyMagFilter() == 0u &&
              filtered_sampler.XyMinFilter() == 0u &&
              filtered_sampler.ZFilter() == 1u &&
              filtered_sampler.MipFilter() == 1u,
          "point-only image format retained a filtered sampler mode");

  ShaderSamplerResource base_mip_sampler{};
  base_mip_sampler.fields[2] = (3u << 20u) | (1u << 22u) | (2u << 24u);
  base_mip_sampler.SetPointFiltering();
  Require("ImageSamplerSpecialization", "base-mip point sampler",
          base_mip_sampler.XyMagFilter() == 0u &&
              base_mip_sampler.XyMinFilter() == 0u &&
              base_mip_sampler.ZFilter() == 1u &&
              base_mip_sampler.MipFilter() == 0u,
          "forcing point filtering enabled mipmapping on a base-mip sampler");

  ShaderRecompiler::IR::Program mixed_sampler_program;
  mixed_sampler_program.resource_tracking_complete = true;
  ShaderRecompiler::IR::ImageResource sampled_image;
  sampled_image.resource_class =
      ShaderRecompiler::IR::ImageResourceClass::Sampled;
  sampled_image.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2D;
  sampled_image.read = true;
  mixed_sampler_program.info.images = {sampled_image, sampled_image,
                                       sampled_image};
  mixed_sampler_program.info.samplers.push_back({0u, 4u});
  mixed_sampler_program.info.sampled_pairs = {
      {0u, 0u, 8u}, {1u, 0u, 12u}, {2u, 0u, 16u}};
  ShaderRecompiler::IR::MemoryInfo signed_memory;
  signed_memory.kind = ShaderRecompiler::IR::ResourceKind::Image;
  signed_memory.resource = 2u;
  signed_memory.sampler = 0u;
  mixed_sampler_program.memory_info.push_back(signed_memory);
  mixed_sampler_program.block_storage.push_back(
      std::make_unique<ShaderRecompiler::IR::Block>());
  auto *mixed_sampler_block = mixed_sampler_program.block_storage.back().get();
  mixed_sampler_program.blocks.push_back(mixed_sampler_block);
  using ShaderRecompiler::IR::Value;
  using ShaderRecompiler::IR::ValueOpcode;
  auto &image_handle = mixed_sampler_block->AppendNewInst(
      ValueOpcode::GetImageResource,
      {Value(0u), Value(0u), Value(0u), Value(0u), Value(0u), Value(0u),
       Value(0u), Value(0u)});
  auto &sampler_handle = mixed_sampler_block->AppendNewInst(
      ValueOpcode::GetSamplerResource,
      {Value(0u), Value(0u), Value(0u), Value(0u)});
  auto &image_address = mixed_sampler_block->AppendNewInst(
      ValueOpcode::MakeImageAddress,
      {Value(0u), Value(0u), Value(0u), Value(0u), Value(0u), Value(0u),
       Value(0u), Value(0u), Value(0u), Value(0u), Value(0u), Value(0u),
       Value(0u)});
  const ShaderRecompiler::IR::MemoryFlags signed_memory_flags{0u, 16u};
  uint64_t signed_memory_flag_bits = 0;
  std::memcpy(&signed_memory_flag_bits, &signed_memory_flags,
              sizeof(signed_memory_flags));
  mixed_sampler_block->AppendNewInst(
      ValueOpcode::ImageSampleRaw,
      {Value(&image_handle), Value(&sampler_handle), Value(&image_address)},
      signed_memory_flag_bits);

  ShaderRecompiler::IR::DescriptorValue native_image_descriptor{};
  native_image_descriptor.dword_count = 8;
  native_image_descriptor.dwords[0] = 0x1000u;
  native_image_descriptor.dwords[1] =
      static_cast<uint32_t>(Prospero::BufferFormat::k32Float) << 20u;
  native_image_descriptor.dwords[2] = 3u | (3u << 14u);
  native_image_descriptor.dwords[3] =
      DstSel(4, 5, 6, 7) |
      (static_cast<uint32_t>(Prospero::ImageType::kColor2D) << 28u);
  auto packed_image_descriptor = native_image_descriptor;
  packed_image_descriptor.dwords[0] = 0x2000u;
  packed_image_descriptor.dwords[1] =
      static_cast<uint32_t>(Prospero::BufferFormat::k11_11_10UInt) << 20u;
  auto signed_image_descriptor = native_image_descriptor;
  signed_image_descriptor.dwords[0] = 0x3000u;
  signed_image_descriptor.dwords[1] =
      static_cast<uint32_t>(Prospero::BufferFormat::k32SInt) << 20u;

  ShaderRecompiler::IR::DescriptorValue sampler_descriptor{};
  sampler_descriptor.dword_count = 4;
  const std::array descriptors{native_image_descriptor, packed_image_descriptor,
                               signed_image_descriptor, sampler_descriptor};
  mixed_sampler_program.descriptor_sources.resize(descriptors.size());
  for (u32 source = 0; source < descriptors.size(); source++) {
    auto &destination = mixed_sampler_program.descriptor_sources[source];
    destination.dword_count = descriptors[source].dword_count;
    for (u32 dword = 0; dword < destination.dword_count; dword++) {
      destination.dwords[dword] = Value(descriptors[source].dwords[dword]);
    }
  }
  for (u32 image = 0; image < mixed_sampler_program.info.images.size(); image++) {
    mixed_sampler_program.info.images[image].source = image;
  }
  mixed_sampler_program.info.samplers[0].source = 3;
  mixed_sampler_program.srt_plan_complete = true;
  auto mixed_sampler_plan =
      ShaderRecompiler::IR::ExtractResourcePlan(mixed_sampler_program);
  ShaderRecompiler::IR::ResourceSnapshot mixed_sampler_snapshot;
  ShaderRecompiler::IR::ResourceSpecialization mixed_sampler_specialization;
  Require("ImageSamplerSpecialization", "resource materialization",
          ShaderRecompiler::IR::MaterializeResources(
              mixed_sampler_plan, {}, mixed_sampler_snapshot,
              mixed_sampler_specialization),
          "mixed sampler descriptors could not be materialized");
  ShaderRecompiler::IR::ApplyResourceSpecialization(
      mixed_sampler_program, mixed_sampler_specialization);
  Require("ImageSamplerSpecialization", "mixed sampler variant",
          mixed_sampler_program.info.samplers.size() == 2u &&
              !mixed_sampler_program.info.samplers[0].force_point_filtering &&
              mixed_sampler_program.info.samplers[1].force_point_filtering &&
              mixed_sampler_program.info.sampled_pairs[0].sampler == 0u &&
              mixed_sampler_program.info.sampled_pairs[1].sampler == 1u &&
              mixed_sampler_program.info.sampled_pairs[2].sampler == 1u &&
              mixed_sampler_program.memory_info[0].sampler == 1u &&
              mixed_sampler_snapshot.samplers.size() == 2u,
          "a shared float/integer sampler was not split into point and native "
          "variants or the signed instruction retained the native sampler");

  std::printf("[host]    %-32s ok\n", "ImageSpecializationPipelineId");
}

void CheckNativeImageDescriptorTypes() {
  using ShaderRecompiler::IR::DescriptorBindingKind;
  using ShaderRecompiler::IR::FirstImageBinding;
  using ShaderRecompiler::IR::FirstStorageImageBinding;

  for (uint32_t value = FirstImageBinding;
       value < static_cast<uint32_t>(DescriptorBindingKind::Samplers);
       value++) {
    const auto expected = value < FirstStorageImageBinding
                              ? vk::DescriptorType::eSampledImage
                              : vk::DescriptorType::eStorageImage;
    Require("NativeImageDescriptorTypes", "image binding",
            NativeDescriptorType(static_cast<DescriptorBindingKind>(value)) ==
                expected,
            "generated image binding has the wrong Vulkan descriptor type");
  }
  Require("NativeImageDescriptorTypes", "non-image bindings",
          NativeDescriptorType(DescriptorBindingKind::Samplers) ==
                  vk::DescriptorType::eSampler &&
              NativeDescriptorType(DescriptorBindingKind::Buffers) ==
                  vk::DescriptorType::eStorageBuffer &&
              NativeDescriptorType(DescriptorBindingKind::Gds) ==
                  vk::DescriptorType::eStorageBuffer &&
              NativeDescriptorType(DescriptorBindingKind::BdaPagetable) ==
                  vk::DescriptorType::eStorageBuffer &&
              NativeDescriptorType(DescriptorBindingKind::FaultBuffer) ==
                  vk::DescriptorType::eStorageBuffer &&
              NativeDescriptorType(DescriptorBindingKind::FlattenedSrt) ==
                  vk::DescriptorType::eStorageBuffer &&
              NativeDescriptorType(DescriptorBindingKind::ShaderData) ==
                  vk::DescriptorType::eStorageBuffer,
          "non-image binding has the wrong Vulkan descriptor type");
  std::printf("[host]    %-32s ok\n", "NativeImageDescriptorTypes");
}

#if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS
void CheckShaderRecompilerFatalContracts() {
  ExpectFatal("InvalidDescriptorBindingRejection", [] {
    (void)NativeDescriptorType(
        ShaderRecompiler::IR::DescriptorBindingKind::Count);
  });

  ExpectFatal("WritableFlatStoreRejection", [] {
    const auto test = FlatStoreVariants();
    (void)CompileCase(test);
  });

  {
    ShaderRecompiler::IR::Program program;
    program.resource_tracking_complete = true;

    ShaderRecompiler::IR::ImageResource image;
    image.resource_class = ShaderRecompiler::IR::ImageResourceClass::Storage;
    image.numeric_class = Prospero::TextureNumericClass::Uint;
    image.dimension = ShaderRecompiler::Decoder::ImageDimension::Dim2D;
    image.read = true;
    image.written = true;
    image.atomic = true;
    program.info.images.push_back(image);

    ShaderRecompiler::IR::DescriptorValue descriptor{};
    descriptor.dword_count = 8;
    descriptor.dwords[0] = 0x2000u;
    descriptor.dwords[1] =
        static_cast<uint32_t>(Prospero::BufferFormat::k11_11_10UInt) << 20u;
    descriptor.dwords[2] = 3u | (3u << 14u);
    descriptor.dwords[3] =
        DstSel(4, 5, 6, 7) |
        (static_cast<uint32_t>(Prospero::ImageType::kColor2D) << 28u);

    image.source = 0;
    program.info.images[0].source = 0;
    program.descriptor_sources.resize(1);
    program.descriptor_sources[0].dword_count = descriptor.dword_count;
    for (u32 dword = 0; dword < descriptor.dword_count; dword++) {
      program.descriptor_sources[0].dwords[dword] =
          ShaderRecompiler::IR::Value(descriptor.dwords[dword]);
    }
    program.srt_plan_complete = true;
    auto plan = ShaderRecompiler::IR::ExtractResourcePlan(program);
    ShaderRecompiler::IR::ResourceSnapshot snapshot;
    ShaderRecompiler::IR::ResourceSpecialization specialization;
    Require("PackedAtomicImageRejection", "resource materialization",
            !ShaderRecompiler::IR::MaterializeResources(
                plan, {}, snapshot, specialization),
            "packed atomic image descriptor was accepted");
  }
}
#endif

void CheckStorageTextureVolumeUploadLayout() {
  constexpr auto format = Prospero::BufferFormat::k16_16_16_16Float;
  constexpr uint32_t width = 33;
  constexpr uint32_t height = 33;
  constexpr uint32_t depth = 33;
  const auto pitch =
      TileGetTexturePitch(format, width, Prospero::TileMode::kRenderTarget);
  TileSizeAlign total{};
  TileGetTextureTotalSize(format, width, height, depth, 1,
                          Prospero::TileMode::kRenderTarget, true, total);
  const auto layout = TextureCalcUploadLayout(
      format, width, height, 1, depth, Prospero::TileMode::kRenderTarget,
      total.size, true, true, "StorageTextureVolumeTest");
  const auto regions = TextureBuildImageCopies(layout);
  Require(
      "StorageTextureVolumeUpload", "layout",
      pitch == 128 && total.size == 0x210000 && layout.slice_stride == 0x2208 &&
          layout.source_slice_stride == 0 && layout.mips[0].size == 0x2208 &&
          layout.surface.mips[0].size == 0x10000 && regions.size() == depth,
      "3D render-target upload did not preserve its compact linear layout");

  std::vector<GpuTileInfo> infos;
  Require("StorageTextureVolumeUpload", "GPU records",
          TextureBuildGpuTileInfos(total.size, regions, layout, 1, infos) &&
              infos.size() == depth,
          "3D render-target GPU records were not built");
  for (const uint32_t z : {0u, 1u, depth - 1u}) {
    Require("StorageTextureVolumeUpload", "slice offsets",
            infos[z].linear_offset == static_cast<uint64_t>(z) * 0x2208 &&
                infos[z].tiled_offset == static_cast<uint64_t>(z) * 0x10000 &&
                infos[z].surface_z == z && infos[z].pitch == width,
            "volume slice lost its linear stride, block slice, or Z swizzle");
  }
  std::printf("[host]    %-32s ok\n", "StorageTextureVolumeUpload");
}

void CheckStorageTextureVolumeMipRegions() {
  constexpr auto format = Prospero::BufferFormat::k8_8_8_8UNorm;
  constexpr uint32_t width = 8;
  constexpr uint32_t height = 4;
  constexpr uint32_t depth = 5;
  constexpr uint32_t levels = 3;
  constexpr auto tile = Prospero::TileMode::kLinear;
  TileSizeAlign total{};
  TileGetTextureTotalSize(format, width, height, depth, levels, tile, true,
                          total);
  const auto layout = TextureCalcUploadLayout(
      format, width, height, levels, depth, tile, total.size, true, true,
      "StorageTextureVolumeMipTest");
  const auto copies = TextureBuildImageCopies(layout);

  bool valid = copies.size() == 8;
  size_t index = 0;
  for (uint32_t level = 0; level < levels && valid; level++) {
    const uint32_t mip_depth = std::max(depth >> level, 1u);
    const uint32_t mip_width = std::max(width >> level, 1u);
    const uint32_t mip_height = std::max(height >> level, 1u);
    for (uint32_t z = 0; z < mip_depth; z++, index++) {
      const auto &copy = copies[index];
      valid &= copy.imageSubresource.mipLevel == level &&
               copy.imageOffset.z == static_cast<int>(z) &&
               copy.imageExtent.width == mip_width &&
               copy.imageExtent.height == mip_height &&
               copy.bufferOffset ==
                   layout.mips[level].offset + z * layout.slice_stride &&
               copy.bufferRowLength == layout.mips[level].row_length &&
               copy.bufferImageHeight == layout.mips[level].image_height;
    }
  }
  valid &= index == copies.size();
  Require("StorageTextureVolumeMipRegions", "per-mip depth", valid,
          "direction-neutral image copies did not shrink depth or preserve "
          "Vulkan Z coordinates");
  std::printf("[host]    %-32s ok\n", "StorageTextureVolumeMipRegions");
}
void CheckStandard64RenderTargetTileRoundTrip() {
  constexpr auto format = Prospero::BufferFormat::k32Float;
  constexpr auto tile = Prospero::TileMode::kStandard64KB;

  constexpr uint32_t observed_width = 3840;
  constexpr uint32_t observed_height = 2160;
  const auto observed_pitch = TileGetTexturePitch(format, observed_width, tile);
  TileSizeAlign observed{};
  TileGetTextureSize(format, observed_width, observed_height, 1, tile,
                     &observed, nullptr, nullptr);
  Require("Standard64RenderTarget", "observed layout",
          observed_pitch == 3840 && observed.size == 0x1fe0000 &&
              observed.align == 0x10000,
          "PPSA02721 Standard64KB render-target footprint changed");

  constexpr uint32_t width = 257;
  constexpr uint32_t height = 131;
  const auto pitch = TileGetTexturePitch(format, width, tile);
  TileSizeAlign storage{};
  TileGetTextureSize(format, width, height, 1, tile, &storage, nullptr,
                     nullptr);
  Require("Standard64RenderTarget", "partial layout",
          pitch == 384 && storage.size == 0x60000 && storage.align == 0x10000,
          "partial Standard64KB footprint was not padded in 128x128 blocks");

  std::printf("[host]    %-32s ok\n", "Standard64RenderTarget");
}

#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
void CheckStorageTextureGpuOwnedRebindState() {
  constexpr uintptr_t base = 0x0000000200200000ull;
  constexpr uint64_t size = 0x10000;
  const auto guest_memory = Libs::LibKernel::Memory::AllocateRuntimeMemory(
      base, size, Common::VirtualMemory::Mode::ReadWrite,
      "storage_texture_gpu_owned_rebind", true);
  auto *memory = reinterpret_cast<uint8_t *>(guest_memory);
  Require("StorageTextureGpuOwnedRebind", "allocation", guest_memory == base,
          "fixed guest-owner allocation failed");
  PageManager page_manager;
  MemoryTracker tracker(page_manager);
  tracker.ForEachUploadRange(
      base, size, true, [](uint64_t, uint64_t) noexcept {}, []() noexcept {});
  uint64_t readable = 0;
  uint64_t mapped = 0;
  MEMORY_BASIC_INFORMATION protection{};
  Require(
      "StorageTextureGpuOwnedRebind", "owned",
      tracker.IsRegionGpuModified(base, size) &&
          (!HostMemoryQueryReadable(base, size, readable) || readable < size) &&
          HostMemoryQueryRange(base, size, HostMemoryAccess::Mapped, mapped) &&
          mapped == size &&
          VirtualQuery(memory, &protection, sizeof(protection)) != 0 &&
          protection.Protect == PAGE_NOACCESS,
      "GPU-owned storage pages remained host-readable or lost tracker "
      "identity");

  tracker.UnmarkRegionAsGpuModified(base, size);
  readable = 0;
  Require("StorageTextureGpuOwnedRebind", "clean readback",
          !tracker.IsRegionGpuModified(base, size) &&
              !tracker.IsRegionCpuModified(base, size) &&
              HostMemoryQueryReadable(base, size, readable) && readable == size,
          "clean storage readback did not publish readable coherent backing");
  tracker.MarkRegionAsGpuModified(base, size);
  readable = 0;
  Require(
      "StorageTextureGpuOwnedRebind", "clean reclaim",
      tracker.IsRegionGpuModified(base, size) &&
          !tracker.IsRegionCpuModified(base, size) &&
          (!HostMemoryQueryReadable(base, size, readable) || readable < size),
      "clean storage rebind did not reclaim GPU ownership without an upload");

  tracker.UnmarkRegionAsGpuModified(base, size);
  tracker.MarkRegionAsCpuModified(base, size);
  uint32_t dirty_ranges = 0;
  bool upload_called = false;
  tracker.ForEachUploadRange(
      base, size, true, [&](uint64_t, uint64_t) noexcept { dirty_ranges++; },
      [&]() noexcept { upload_called = true; });
  readable = 0;
  Require(
      "StorageTextureGpuOwnedRebind", "dirty refresh",
      dirty_ranges == 1 && upload_called &&
          tracker.IsRegionGpuModified(base, size) &&
          !tracker.IsRegionCpuModified(base, size) &&
          (!HostMemoryQueryReadable(base, size, readable) || readable < size),
      "CPU-dirty storage rebind did not refresh once and reclaim GPU "
      "ownership");

  tracker.UnmarkRegionAsGpuModified(base, size);
  tracker.UntrackMemory(base, size);
  Require("StorageTextureGpuOwnedRebind", "free",
          Libs::LibKernel::Memory::FreeGuestMemory(base, size),
          "guest-owner free failed");
  std::printf("[host]    %-32s ok\n", "StorageTextureGpuOwnedRebind");
}
#endif

void CheckNativeMsaaState() {
  Require("NativeMsaaState", "sample encoding",
          render_sample_count(0) == 1 && render_sample_count(1) == 2 &&
              render_sample_count(2) == 4 && render_sample_count(3) == 8 &&
              render_sample_count(4) == 0,
          "PS5 sample encodings were not mapped exactly");
  Require("NativeMsaaState", "Vulkan sample mapping",
          vulkan_sample_count(1) == vk::SampleCountFlagBits::e1 &&
              vulkan_sample_count(2) == vk::SampleCountFlagBits::e2 &&
              vulkan_sample_count(4) == vk::SampleCountFlagBits::e4 &&
              vulkan_sample_count(8) == vk::SampleCountFlagBits::e8 &&
              vulkan_sample_count(3) == vk::SampleCountFlagBits{},
          "native sample counts were not mapped exactly to Vulkan");

  TileSizeAlign color{};
  const auto color_pitch = TileGetRenderTargetPitch(1920, 8, 3);
  Require("NativeMsaaState", "8x color footprint",
          color_pitch == 1920 &&
              TileGetRenderTargetSize(1920, 1080, color_pitch, 8, color, 3) &&
              color.align == 0x10000 && color.size == 0x07f80000,
          "8x R16G16B16A16 color footprint was not preserved");

  TileSizeAlign depth{};
  TileSizeAlign stencil{};
  TileSizeAlign htile{};
  Require("NativeMsaaState", "8x depth/stencil footprint",
          TileGetDepthPitch(1920, 4, 3) == 1920 &&
              TileGetDepthSize(1920, 1080, 0, Prospero::DepthFormat::kZ32F,
                               Prospero::StencilFormat::k8UInt, true, stencil,
                               htile, depth, 3) &&
              depth.align == 0x10000 && depth.size == 0x03fc0000 &&
              stencil.align == 0x10000 && stencil.size == 0x010e0000 &&
              htile.align == 0x8000 && htile.size == 0x00030000,
          "8x depth/stencil or fragment-independent HTile footprint regressed");
  std::printf("[host]    %-32s ok\n", "NativeMsaaState");
}

void CheckDepthHtileStencilCompatibility() {
  Require("DepthHtileStencilCompatibility", "inactive stencil plane",
          depth_htile_stencil_acceleration_compatible(false, true, false),
          "inactive Hi-Stencil state was treated as an attachment");
  Require("DepthHtileStencilCompatibility", "disabled acceleration",
          depth_htile_stencil_acceleration_compatible(true, false, true),
          "disabled Hi-Stencil state was rejected");
  Require("DepthHtileStencilCompatibility", "PS5 stencil plus HTile",
          depth_htile_stencil_acceleration_compatible(true, true, false),
          "valid PS5 Hi-Stencil attachment was rejected");
  Require("DepthHtileStencilCompatibility", "missing HTile metadata",
          !depth_htile_stencil_acceleration_compatible(true, false, false),
          "active Hi-Stencil without HTile metadata was admitted");
  std::printf("[host]    %-32s ok\n", "DepthHtileStencilCompatibility");
}

void CheckPs5DepthRegisterDecoding() {
  constexpr uint32_t captured_z = 0x22900803u;
  constexpr uint32_t captured_stencil = 0x00100801u;
  const auto z = HW::DepthZInfo::Decode(captured_z);
  const auto stencil = HW::DepthStencilInfo::Decode(captured_stencil);
  Require(
      "Ps5DepthRegisterDecoding", "captured texture-compatible state",
      z.format == Prospero::DepthFormat::kZ32F && z.num_samples == 0 &&
          z.htile_acceleration && !z.expclear_enabled &&
          !z.partially_resident && z.max_mip_level == 0 &&
          z.z_compare_base == Prospero::ZCompareBase::kZMin &&
          z.texture_compatibility ==
              Prospero::TextureCompatiblePlaneCompression::kEnable &&
          z.HasValidTextureCompatibility() &&
          stencil.format == Prospero::StencilFormat::k8UInt &&
          !stencil.htile_stencil_disabled && !stencil.expclear_enabled &&
          !stencil.partially_resident &&
          stencil.texture_compatibility ==
              Prospero::TextureCompatibleStencil::kEnable &&
          stencil.HasValidTextureCompatibility(),
      "valid PS5 depth/stencil aggregate encodings were not decoded exactly");

  const auto malformed_z = HW::DepthZInfo::Decode(0x00000803u);
  const auto malformed_stencil = HW::DepthStencilInfo::Decode(0x00100001u);
  Require("Ps5DepthRegisterDecoding", "malformed aggregate state",
          !malformed_z.HasValidTextureCompatibility() &&
              !malformed_stencil.HasValidTextureCompatibility(),
          "partial texture-compatible aggregate encodings were accepted");
  std::printf("[host]    %-32s ok\n", "Ps5DepthRegisterDecoding");
}

void CheckDepthAttachmentWrites() {
  RenderDepthInfo target{};
  target.desc.view_info.format = vk::Format::eD32SfloatS8Uint;
  Require("DepthAttachmentWrites", "disabled depth test",
          !target.AttachmentWriteAspects(),
          "disabled depth testing claimed a depth write");

  target.depth_test_enable = true;
  target.depth_write_enable = true;
  target.depth_compare_op = vk::CompareOp::eLess;
  Require("DepthAttachmentWrites", "depth write",
          target.AttachmentWriteAspects() == vk::ImageAspectFlagBits::eDepth,
          "write-enabled depth testing did not claim depth");

  target.depth_test_enable = false;
  target.depth_write_enable = false;
  target.depth_load_clear_enable = true;
  Require("DepthAttachmentWrites", "depth clear",
          target.AttachmentWriteAspects() == vk::ImageAspectFlagBits::eDepth,
          "depth attachment clear did not claim depth");

  target.depth_load_clear_enable = false;
  target.stencil_test_enable = true;
  target.stencil_front = {vk::StencilOp::eKeep, vk::StencilOp::eKeep,
                          vk::StencilOp::eKeep, vk::CompareOp::eAlways, 0xff, 0xff, 0};
  target.stencil_back = target.stencil_front;
  Require("DepthAttachmentWrites", "stencil keep",
          !target.AttachmentWriteAspects(),
          "KEEP-only stencil state claimed a stencil write");

  target.stencil_front.failOp = vk::StencilOp::eZero;
  Require("DepthAttachmentWrites", "unreachable stencil fail",
          !target.AttachmentWriteAspects(),
          "ALWAYS comparison claimed an unreachable fail operation");

  target.stencil_front.failOp = vk::StencilOp::eKeep;
  target.stencil_front.passOp = vk::StencilOp::eReplace;
  Require("DepthAttachmentWrites", "stencil pass write",
          target.AttachmentWriteAspects() == vk::ImageAspectFlagBits::eStencil,
          "write-capable stencil pass did not claim stencil");

  target.stencil_front.writeMask = 0;
  Require("DepthAttachmentWrites", "back-face keep",
          !target.AttachmentWriteAspects(),
          "masked front write or KEEP-only back face claimed stencil");

  target.stencil_test_enable = false;
  target.stencil_clear_enable = true;
  Require("DepthAttachmentWrites", "stencil clear",
          target.AttachmentWriteAspects() == vk::ImageAspectFlagBits::eStencil,
          "stencil attachment clear did not claim stencil");

  target.desc.view_info.format = vk::Format::eD32Sfloat;
  Require("DepthAttachmentWrites", "missing stencil aspect",
          !target.AttachmentWriteAspects(),
          "depth-only format claimed a stencil write");
  std::printf("[host]    %-32s ok\n", "DepthAttachmentWrites");
}

void CheckDynamicRenderingState() {
  RenderState first{};
  first.width = 64;
  first.height = 32;
  first.num_layers = 2;
  first.num_color_attachments = 1;
  first.color_attachments[0].image_layout =
      vk::ImageLayout::eColorAttachmentOptimal;
  first.color_attachments[0].clear_value = {1, 2, 3, 4};
  first.color_attachments[0].is_clear = true;
  auto changed = first;
  Require("DynamicRenderingState", "identical state", first == changed,
          "fieldwise RenderState identity rejected an identical scope");
  changed.color_attachments[0].is_clear = false;
  Require("DynamicRenderingState", "clear identity", first != changed,
          "clear/load state did not participate in rendering identity");
  changed = first;
  changed.num_layers = 1;
  Require("DynamicRenderingState", "layer identity", first != changed,
          "layer count did not participate in rendering identity");
  changed = first;
  changed.color_attachments[0].image_layout = vk::ImageLayout::eGeneral;
  Require("DynamicRenderingState", "layout identity", first != changed,
          "attachment layout did not participate in rendering identity");

  PipelineRenderingState rgba{};
  rgba.color_count = 1;
  rgba.color_formats[0] = vk::Format::eR8G8B8A8Unorm;
  auto uint_color = rgba;
  uint_color.color_formats[0] = vk::Format::eR8G8B8A8Uint;
  Require("DynamicRenderingState", "pipeline color format identity",
          rgba != uint_color,
          "distinct dynamic-rendering formats can alias one pipeline key");
  auto depth = rgba;
  depth.depth_format = vk::Format::eD32SfloatS8Uint;
  depth.stencil_format = vk::Format::eD32SfloatS8Uint;
  Require("DynamicRenderingState", "pipeline depth/stencil identity",
          rgba != depth,
          "depth/stencil formats did not participate in pipeline identity");

  RenderDepthInfo attachment{};
  attachment.desc.view_info.format = vk::Format::eD32SfloatS8Uint;
  Require("DynamicRenderingState", "read-only depth/stencil layout",
          depth_attachment_layout(attachment) ==
              vk::ImageLayout::eDepthStencilReadOnlyOptimal,
          "fully read-only depth/stencil used a writable layout");
  attachment.depth_load_clear_enable = true;
  Require("DynamicRenderingState", "read-only deferred depth clear",
          depth_attachment_layout(attachment) ==
              vk::ImageLayout::eDepthStencilReadOnlyOptimal,
          "a load clear changed the guest depth-write layout");
  attachment.depth_test_enable = true;
  attachment.depth_write_enable = true;
  Require("DynamicRenderingState", "depth-write stencil-read layout",
          depth_attachment_layout(attachment) ==
              vk::ImageLayout::eDepthAttachmentStencilReadOnlyOptimal,
          "depth-only writes did not retain read-only stencil");
  attachment.depth_load_clear_enable = false;
  attachment.depth_write_enable = false;
  attachment.stencil_clear_enable = true;
  Require("DynamicRenderingState", "depth-read stencil-write layout",
          depth_attachment_layout(attachment) ==
              vk::ImageLayout::eDepthReadOnlyStencilAttachmentOptimal,
          "stencil-only writes did not retain read-only depth");
  attachment.depth_write_enable = true;
  Require("DynamicRenderingState", "writable depth/stencil layout",
          depth_attachment_layout(attachment) ==
              vk::ImageLayout::eDepthStencilAttachmentOptimal,
          "combined depth/stencil writes did not use the writable layout");
  std::printf("[host]    %-32s ok\n", "DynamicRenderingState");
}

void CheckDepthTargetFootprints() {
  TileSizeAlign stencil{};
  TileSizeAlign htile{};
  TileSizeAlign depth{};
  struct AttachmentFormatCase {
    const char *name;
    Prospero::DepthFormat depth_format;
    Prospero::StencilFormat stencil_format;
    vk::Format expected;
  };
  constexpr AttachmentFormatCase attachment_cases[] = {
      {"Z16", Prospero::DepthFormat::kZ16, Prospero::StencilFormat::kInvalid,
       vk::Format::eD16Unorm},
      {"Z16S8", Prospero::DepthFormat::kZ16, Prospero::StencilFormat::k8UInt,
       vk::Format::eD16UnormS8Uint},
      {"Z32", Prospero::DepthFormat::kZ32F, Prospero::StencilFormat::kInvalid,
       vk::Format::eD32Sfloat},
      {"Z32S8", Prospero::DepthFormat::kZ32F, Prospero::StencilFormat::k8UInt,
       vk::Format::eD32SfloatS8Uint},
      {"invalid depth", static_cast<Prospero::DepthFormat>(2u),
       Prospero::StencilFormat::k8UInt, vk::Format::eUndefined},
      {"invalid stencil", Prospero::DepthFormat::kZ16,
       static_cast<Prospero::StencilFormat>(2u), vk::Format::eUndefined},
  };
  for (const auto &test : attachment_cases) {
    Require("DepthTargetFootprints", test.name,
            DepthAttachmentFormat(test.depth_format, test.stencil_format) ==
                test.expected,
            "PS5 depth/stencil attachment mapping changed");
  }
  Require("DepthTargetFootprints", "1920x1080 Z16S8 without HTile",
          TileGetDepthSize(1920, 1080, 0, Prospero::DepthFormat::kZ16,
                           Prospero::StencilFormat::k8UInt, false, stencil,
                           htile, depth) &&
              depth.size == 0x480000 && depth.align == 0x10000 &&
              stencil.size == 0x280000 && stencil.align == 0x10000 &&
              htile.size == 0,
          "captured Z16S8 footprint disagrees with Prospero block rules");
  struct TargetFormatCase {
    const char *name;
    vk::Format host_format;
    Prospero::BufferFormat guest_format;
    uint32_t bytes_per_element;
    bool stencil;
    bool supported;
    bool readback;
  };
  constexpr TargetFormatCase target_cases[] = {
      {"D16", vk::Format::eD16Unorm, Prospero::BufferFormat::k16UNorm, 2, false,
       true, true},
      {"D16S8", vk::Format::eD16UnormS8Uint, Prospero::BufferFormat::k16UNorm,
       2, true, true, true},
      {"D16 via D24S8", vk::Format::eD24UnormS8Uint,
       Prospero::BufferFormat::k16UNorm, 2, true, true, true},
      {"D16 via D32S8", vk::Format::eD32SfloatS8Uint,
       Prospero::BufferFormat::k16UNorm, 2, true, true, true},
      {"D32", vk::Format::eD32Sfloat, Prospero::BufferFormat::k32Float, 4,
       false, true, true},
      {"D32S8", vk::Format::eD32SfloatS8Uint, Prospero::BufferFormat::k32Float,
       4, true, true, true},
      {"D16 plus stencil mismatch", vk::Format::eD16Unorm,
       Prospero::BufferFormat::k16UNorm, 2, true, false, false},
      {"fallback without stencil", vk::Format::eD24UnormS8Uint,
       Prospero::BufferFormat::k16UNorm, 2, false, false, false},
      {"D32 guest via D24", vk::Format::eD24UnormS8Uint,
       Prospero::BufferFormat::k32Float, 4, true, false, false},
      {"D16 byte mismatch", vk::Format::eD16Unorm,
       Prospero::BufferFormat::k16UNorm, 4, false, false, false},
  };
  for (const auto &test : target_cases) {
    ImageInfo target{};
    target.pixel_format = test.host_format;
    target.guest_format = test.guest_format;
    target.bytes_per_block = test.bytes_per_element;
    target.stencil = test.stencil ? GuestRange{0x10000, 0x10000} : GuestRange{};
    Require("DepthTargetFootprints", test.name,
            IsSupportedDepthTargetFormat(target) == test.supported &&
                IsSupportedDepthPlaneReadback(target) == test.readback,
            "host/guest depth format or exact readback policy changed");
  }
  ImageInfo compressed_stencil{};
  compressed_stencil.pixel_format = vk::Format::eD32SfloatS8Uint;
  compressed_stencil.guest_format = Prospero::BufferFormat::k32Float;
  compressed_stencil.bytes_per_block = 4;
  compressed_stencil.stencil = {0x10000, 0x10000};
  compressed_stencil.metadata.stencil_compressed = true;
  Require("DepthTargetFootprints", "compressed stencil depth-plane readback",
          IsSupportedDepthTargetFormat(compressed_stencil) &&
              IsSupportedDepthPlaneReadback(compressed_stencil),
          "stencil metadata incorrectly blocked independent depth-plane "
          "readback");
  Require("DepthTargetFootprints", "lexicographic subresource comparison",
          ImageSubresources{2, 1} > ImageSubresources{1, 4} &&
              ImageSubresources{1, 4} < ImageSubresources{2, 1},
          "subresource ordering diverged from required overlap semantics");
  struct TransferPlaneCase {
    const char *name;
    vk::Format attachment;
    vk::Format transfer;
    uint32_t bytes;
  };
  constexpr TransferPlaneCase transfer_cases[] = {
      {"D16S8 transfer", vk::Format::eD16UnormS8Uint, vk::Format::eD16Unorm, 2},
      {"D24S8 transfer", vk::Format::eD24UnormS8Uint,
       vk::Format::eX8D24UnormPack32, 4},
      {"D32S8 transfer", vk::Format::eD32SfloatS8Uint, vk::Format::eD32Sfloat,
       4},
      {"invalid transfer", vk::Format::eR16Unorm, vk::Format::eUndefined, 0},
  };
  for (const auto &test : transfer_cases) {
    Require("DepthTargetFootprints", test.name,
            DepthAspectTransferFormat(test.attachment) == test.transfer &&
                DepthAspectTransferBytes(test.attachment) == test.bytes,
            "combined depth transfer-plane layout changed");
  }
  struct PromotionCase {
    const char *name;
    uint16_t source;
    uint32_t d24;
    uint32_t d32;
  };
  constexpr PromotionCase promotion_cases[] = {
      {"zero", 0, 0, 0},
      {"midpoint", 0x8000, 0x00800080, 0x3f000080},
      {"maximum", 0xffff, 0x00ffffff, 0x3f800000},
  };
  for (const auto &test : promotion_cases) {
    Require("DepthTargetFootprints", test.name,
            EncodeD16AsD24(test.source) == test.d24 &&
                EncodeD16AsD32(test.source) == test.d32,
            "D16 host promotion changed the represented depth value");
  }
  Require("DepthTargetFootprints", "640x360 Z32S8 without HTile",
          TileGetDepthSize(640, 360, 0, Prospero::DepthFormat::kZ32F,
                           Prospero::StencilFormat::k8UInt, false, stencil,
                           htile, depth),
          "valid non-HTile depth/stencil footprint was rejected");
  Require(
      "DepthTargetFootprints", "640x360 Prospero block sizes",
      depth.size == 0xf0000 && depth.align == 0x10000 &&
          stencil.size == 0x60000 && stencil.align == 0x10000 &&
          htile.size == 0 && htile.align == 0,
      "non-HTile depth/stencil footprint disagrees with Prospero block rules");

  const auto depth_pitch = TileGetTexturePitch(Prospero::BufferFormat::k32Float,
                                               640, Prospero::TileMode::kDepth);
  TileSizeAlign texture_depth{};
  TileGetTextureTotalSize(Prospero::BufferFormat::k32Float, 640, 360, 1, 1,
                          Prospero::TileMode::kDepth, false, texture_depth);
  Require("DepthTargetFootprints", "640x360 generic depth tile",
          depth_pitch == 640 && texture_depth.size == 0xf0000 &&
              texture_depth.align == 0x10000,
          "generic depth texture sizing bypassed 64 KiB block padding");

  Require(
      "DepthTargetFootprints", "960x540 Z32S8 with HTile",
      TileGetDepthSize(960, 540, 0, Prospero::DepthFormat::kZ32F,
                       Prospero::StencilFormat::k8UInt, true, stencil, htile,
                       depth) &&
          depth.size == 0x280000 && depth.align == 0x10000 &&
          stencil.size == 0xc0000 && stencil.align == 0x10000 &&
          htile.size == 0x10000 && htile.align == 0x8000,
      "generic Prospero HTile block calculation rejected the title footprint");
  Require("DepthTargetFootprints", "known HTile extent",
          TileGetDepthSize(1280, 720, 0, Prospero::DepthFormat::kZ32F,
                           Prospero::StencilFormat::k8UInt, true, stencil,
                           htile, depth) &&
              depth.size == 0x3c0000 && stencil.size == 0xf0000 &&
              htile.size == 0x20000,
          "validated 1280x720 HTile footprint regressed");
  Require("DepthTargetFootprints", "PPSA06228 3840x2160 Z32S8 with HTile",
          TileGetDepthSize(3840, 2160, 0, Prospero::DepthFormat::kZ32F,
                           Prospero::StencilFormat::k8UInt, true, stencil,
                           htile, depth) &&
              depth.size == 0x1fe0000 && depth.align == 0x10000 &&
              stencil.size == 0x870000 && stencil.align == 0x10000 &&
              htile.size == 0xa0000 && htile.align == 0x8000,
          "captured 3840x2160 depth/stencil/HTile footprint disagrees with "
          "Prospero rules");
  Require("DepthTargetFootprints", "invalid depth format",
          !TileGetDepthSize(960, 540, 0, static_cast<Prospero::DepthFormat>(2u),
                            Prospero::StencilFormat::k8UInt, true, stencil,
                            htile, depth),
          "unsupported depth format was silently admitted");
  Require("DepthTargetFootprints", "invalid stencil format",
          !TileGetDepthSize(960, 540, 0, Prospero::DepthFormat::kZ32F,
                            static_cast<Prospero::StencilFormat>(2u), true,
                            stencil, htile, depth),
          "unsupported stencil format was silently admitted");
  Require("DepthTargetFootprints", "invalid extent",
          !TileGetDepthSize(0, 540, 0, Prospero::DepthFormat::kZ32F,
                            Prospero::StencilFormat::k8UInt, true, stencil,
                            htile, depth) &&
              !TileGetDepthSize(16385, 540, 0, Prospero::DepthFormat::kZ32F,
                                Prospero::StencilFormat::k8UInt, true, stencil,
                                htile, depth),
          "invalid HTile extent was silently admitted");
  std::printf("[host]    %-32s ok\n", "DepthTargetFootprints");
}

struct SlotLifetimeProbe {
  explicit SlotLifetimeProbe(bool *destroyed) : destroyed(destroyed) {
    if (destroyed == nullptr || *destroyed) {
      EXIT("fence-lifetime probe has invalid construction state\n");
    }
  }
  ~SlotLifetimeProbe() { *destroyed = true; }

  bool *destroyed = nullptr;
};

void CheckSlotVectorLifetime() {
  bool destroyed = false;
  Common::SlotVector<SlotLifetimeProbe> slots;
  const auto first = slots.insert(&destroyed);
  Require("SlotVectorLifetime", "inserted",
          slots.is_allocated(first) && slots.try_get(first) != nullptr &&
              !destroyed,
          "slot insertion did not expose its cache-owned object");
  slots.erase(first);
  const bool first_destroyed = destroyed;
  destroyed = false;
  const auto second = slots.insert(&destroyed);
  Require("SlotVectorLifetime", "generation",
          first_destroyed && !destroyed && first.index == second.index &&
              first != second && !slots.is_allocated(first) &&
              slots.is_allocated(second),
          "reused slot accepted a stale cache resource id");
  std::printf("[host]    %-32s ok\n", "SlotVectorLifetime");
}

void CheckEmbeddedFetchLaneSpill() {
  std::vector<u32> code;
  code.push_back(EncodeSMovB32(0, InlineU32(0)));
  code.push_back(EncodeSmem0(0x02u, 20, 4));
  code.push_back(EncodeSmem1(0)); // s_load_dwordx4 s[20:23], s[8:9]
  AppendVop3(&code, 0x361u, 6, 20, InlineU32(0)); // v_writelane_b32 v6, s20, 0
  code.push_back(EncodeSMovB32(20, InlineU32(0)));
  AppendVop3(&code, 0x360u, 20, Vgpr(6),
             InlineU32(0)); // v_readlane_b32 s20, v6, 0
  code.push_back(EncodeVop2(0x01u, 0, Vgpr(8), 5));
  code.push_back(EncodeMubuf0(0x03u, 0, true));
  code.push_back(EncodeMubuf1(9, 5, 0));
  AppendEnd(&code);

  std::array<u32, 11> user_data{};
  ShaderVertexInputInfo vertex;
  vertex.fetch_embedded = true;
  vertex.fetch_buffer_reg = 0;
  vertex.resources_num = 1;
  vertex.resources[0].fields[3] =
      BufferFormat(Prospero::BufferFormat::k32_32_32_32Float) << 12u | DstSel(4, 5, 6, 7);
  vertex.resources_dst[0].attr_id = 0;
  vertex.resources_dst[0].registers_num = 4;

  ShaderRecompiler::CompileOptions options;
  options.stage = ShaderType::Vertex;
  options.user_data_base = 8;
  options.user_data = user_data;
  options.input_info.vertex = &vertex;

  auto translated = ShaderRecompiler::TranslateProgram(code, options);
  auto resource_plan =
      ShaderRecompiler::IR::ExtractResourcePlan(translated.program);
  ShaderRecompiler::IR::ResourceSnapshot resources;
  ShaderRecompiler::IR::ResourceSpecialization specialization;
  const ShaderRecompiler::IR::SrtRuntime runtime{
      .user_data = options.user_data,
      .shader_base = reinterpret_cast<uint64_t>(code.data()),
  };
  Require("EmbeddedFetchLaneSpill", "resource materialization",
          ShaderRecompiler::IR::MaterializeResources(
              resource_plan, runtime, resources, specialization),
          "lane-spilled fetch resources could not be materialized");
  auto result = ShaderRecompiler::CompileProgram(
      std::move(translated), options, specialization);
  Require("EmbeddedFetchLaneSpill", "fetch rewrite",
          result.program.info.vertex_fetch_components[0] == 4,
          "lane-spilled fetch descriptor was not recognized and rewritten");
  std::printf("[host]    %-32s ok\n", "EmbeddedFetchLaneSpill");
}

void CheckReferenceClockScale() {
  uint64_t value = 0;
  Require("ReferenceClockScale", "zero",
          Sync::ScaleReferenceClock(0, 3000000000ull, value) && value == 0,
          "zero host tick did not produce a zero GPU clock");
  Require("ReferenceClockScale", "fractional second",
          Sync::ScaleReferenceClock(1500000000ull, 3000000000ull, value) &&
              value == 50000000ull,
          "host half-second did not scale to 50,000,000 ticks");
  Require("ReferenceClockScale", "whole and fractional",
          Sync::ScaleReferenceClock(3750000000ull, 3000000000ull, value) &&
              value == 125000000ull,
          "host 1.25 seconds did not scale to 125,000,000 ticks");
  Require("ReferenceClockScale", "monotonic floor",
          Sync::ScaleReferenceClock(3750000001ull, 3000000000ull, value) &&
              value == 125000000ull,
          "sub-reference-tick increment did not use a monotonic floor");
  Require("ReferenceClockScale", "guards",
          !Sync::ScaleReferenceClock(1, 0, value) &&
              !Sync::ScaleReferenceClock(UINT64_MAX, 1, value),
          "invalid frequency or overflow was accepted");
  std::printf("[host]    %-32s ok\n", "ReferenceClockScale");
}

void CheckClipControlDepthClipState() {
  HW::ClipControl clip;
  Require("ClipControlDepthClipState", "default", clip.IsZClipEnabled(),
          "default paired Z clipping was not enabled");

  clip.min_z_clip_disable = true;
  Require("ClipControlDepthClipState", "asymmetric near",
          !clip.IsZClipEnabled(),
          "near-plane disable did not disable paired host Z clipping");

  clip.min_z_clip_disable = false;
  clip.max_z_clip_disable = true;
  Require("ClipControlDepthClipState", "asymmetric far", !clip.IsZClipEnabled(),
          "far-plane disable did not disable paired host Z clipping");

  clip.min_z_clip_disable = true;
  Require("ClipControlDepthClipState", "both disabled", !clip.IsZClipEnabled(),
          "paired Z-clip disable was not represented");
  std::printf("[host]    %-32s ok\n", "ClipControlDepthClipState");
}

void CheckVulkan13FeatureRequirements() {
  const auto features = WindowContext::RequiredVulkan13Features();
  Require(
      "Vulkan13FeatureRequirements", "production requirements",
      features.sType == vk::StructureType::ePhysicalDeviceVulkan13Features &&
          features.pNext == nullptr && features.dynamicRendering == VK_TRUE &&
          features.synchronization2 == VK_TRUE,
      "production device creation did not require dynamic rendering and "
      "synchronization2 from one feature declaration");
  std::printf("[host]    %-32s ok\n", "Vulkan13FeatureRequirements");
}

void CheckPm4AcquireMemNoOp(RenderContext &renderer) {
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);
  const std::array<uint32_t, 6> standard_payload{0x00400000u, 1u, 0u,
                                                 0u,          0u, 10u};
  const std::array<uint32_t, 7> custom_payload{
      0xdeadbeefu, 0xffffffffu, 0x80000000u, 0x13579bdfu,
      0x2468ace0u, 0xaaaaaaaau, 0x55555555u};
  const auto standard_before = standard_payload;
  const auto custom_before = custom_payload;
  Require("Pm4AcquireMemNoOp", "recognized packets",
          CpOpAcquireMem(processor, 0xC0055800u, standard_payload.data(), 0,
                         0) == 6 &&
              CpOpAcquireMem(processor, 0xc0061050u, custom_payload.data(), 0,
                             0) == 7 &&
              standard_payload == standard_before &&
              custom_payload == custom_before,
          "ACQUIRE_MEM did not consume both pinned packet forms as "
          "side-effect-free "
          "no-ops");
  std::printf("[host]    %-32s ok\n", "Pm4AcquireMemNoOp");
}

void CheckPm4SyntheticOcclusionCounterDump(RenderContext &renderer) {
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);
  constexpr uint64_t untouched = 0x1122334455667788ull;
  constexpr uint64_t ready_bit = 1ull << 63u;
  alignas(16) std::array<std::array<uint64_t, 2>, 16> results;
  for (auto &pair : results) {
    pair.fill(untouched);
  }

  const auto dump = [&](uint64_t *address) {
    const auto raw_address = reinterpret_cast<uint64_t>(address);
    std::array<uint32_t, 4> packet{
        KYTY_PM4(4, Pm4::IT_EVENT_WRITE, Pm4::R_ZERO), 0x00000139u,
        static_cast<uint32_t>(raw_address),
        static_cast<uint32_t>(raw_address >> 32u)};
    Pm4Execution execution;
    return processor.Process(execution, packet);
  };

  const auto begin_result = dump(&results[0][0]);
  bool begin_written = begin_result == Pm4ProcessResult::Complete;
  for (const auto &pair : results) {
    begin_written &= pair[0] == ready_bit && pair[1] == untouched;
  }

  const auto end_result = dump(&results[0][1]);
  bool end_written = end_result == Pm4ProcessResult::Complete;
  uint64_t visible_samples = 0;
  for (const auto &pair : results) {
    end_written &= pair[0] == ready_bit && pair[1] == (ready_bit | 1u);
    visible_samples += pair[1] - pair[0];
  }

  Require("Pm4SyntheticOcclusionCounterDump", "always-visible result",
          begin_written && end_written && visible_samples == results.size(),
          "EVENT_WRITE did not publish valid nonzero begin/end counters to "
          "every PS5 DB");
  std::printf("[host]    %-32s ok\n", "Pm4SyntheticOcclusionCounterDump");
}

void CheckPm4Predication(RenderContext &renderer) {
  constexpr const char *name = "Pm4Predication";
  constexpr uint64_t ready = 1ull << 63u;
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);
  processor.BufferInit();
  alignas(16) std::array<uint64_t, 32> query{};
  alignas(16) uint64_t boolean = 0;
  uint32_t predicated = 0;
  uint32_t unconditional = 0;
  const auto commands = [&](uint32_t op, uint32_t condition, uint32_t wait,
                            const void *source) {
    const auto address = reinterpret_cast<uint64_t>(source);
    const auto predicated_address = reinterpret_cast<uint64_t>(&predicated);
    const auto unconditional_address = reinterpret_cast<uint64_t>(&unconditional);
    return std::array<uint32_t, 14>{
        // Captured AGC form: c0022000 00010100 <query low> <query high>.
        0xc0022000u, (op << 16u) | (wait << 12u) | (condition << 8u),
        static_cast<uint32_t>(address), static_cast<uint32_t>(address >> 32u),
        KYTY_PM4(5, Pm4::IT_WRITE_DATA, 0) | 1u, 0,
        static_cast<uint32_t>(predicated_address),
        static_cast<uint32_t>(predicated_address >> 32u), 11,
        KYTY_PM4(5, Pm4::IT_WRITE_DATA, 0), 0,
        static_cast<uint32_t>(unconditional_address),
        static_cast<uint32_t>(unconditional_address >> 32u), 22};
  };
  const auto check = [&](const char *stage, uint32_t op, uint32_t condition,
                         uint32_t wait, const void *source, bool skip) {
    predicated = unconditional = 0;
    const auto packet = commands(op, condition, wait, source);
    Pm4Execution execution;
    Require(name, stage,
            processor.Process(execution, packet) == Pm4ProcessResult::Complete &&
                processor.ShouldSkipPredicatedPackets() == skip &&
                predicated == (skip ? 0u : 11u) && unconditional == 22,
            "predicate polarity, tagged packet execution, or packet consumption is wrong");
  };
  struct Case {
    uint64_t delta;
    uint32_t condition;
    bool skip;
  };
  constexpr Case cases[]{{1, 1, false}, {1, 0, true},
                         {0, 1, true}, {0, 0, false}};
  for (const auto &test : cases) {
    query.fill(ready | 0x344u);
    for (size_t db = 0; db < 16; db++) {
      query[db * 2 + 1] += test.delta;
    }
    boolean = test.delta;
    for (uint32_t wait : {0u, 1u}) {
      check("ready Z-pass", 1, test.condition, wait, query.data(), test.skip);
      check("bool preservation", 3, test.condition, wait, &boolean, test.skip);
    }
  }
  query.fill(ready | 0x344u);
  query[31]++;
  check("only last DB visible", 1, 1, 0, query.data(), false);
  check("inverse last DB visibility", 1, 0, 0, query.data(), true);
  check("clear", 0, 0, 0, nullptr, false);

  // Every begin AND end counter must be ready; no-wait must discard old skip state.
  for (size_t missing = 0; missing < query.size(); missing++) {
    query.fill(ready | 0x344u);
    query[missing] &= ~ready;
    for (uint32_t condition : {0u, 1u}) {
      boolean = 0;
      processor.SetPredication(1, 3, 0, &boolean, 0);
      check("unavailable no-wait", 1, condition, 1, query.data(), false);
    }
  }

  // Retry the same packet when its last DB's begin or end arrives later.
  for (size_t missing : {30u, 31u}) {
    query.fill(ready | 0x344u);
    query[31]++;
    query[missing] &= ~ready;
    boolean = 0;
    processor.SetPredication(1, 3, 0, &boolean, 0);
    predicated = unconditional = 0;
    const auto packet = commands(1, 1, 0, query.data());
    Pm4Execution execution;
    for (int retry = 0; retry < 2; retry++) {
      Require(name, "pending wait suspends",
              processor.Process(execution, packet) == Pm4ProcessResult::Blocked &&
                  !execution.MadeProgress() && predicated == 0 && unconditional == 0 &&
                  processor.ShouldSkipPredicatedPackets(),
              "pending query advanced its packet or changed the prior predicate");
    }
    query[missing] |= ready;
    Require(name, "ready wait resumes",
            processor.Process(execution, packet) == Pm4ProcessResult::Complete &&
                execution.MadeProgress() && predicated == 11 && unconditional == 22 &&
                !processor.ShouldSkipPredicatedPackets(),
            "ready query did not reevaluate and execute the suspended packet's suffix");
  }
  processor.BufferWait();
  std::printf("[host]    %-32s ok\n", name);
}

void CheckPm4StencilInfoValueLane(RenderContext &renderer) {
  CommandProcessor processor(renderer, 0);
  constexpr std::array<uint32_t, 2> payload{0x00100801u, 0x28000000u};
  const auto consumed = HwCtxSetStencilInfo(
      processor, 0xC0016900u, Pm4::DB_STENCIL_INFO, payload.data(), 1);
  const auto &stencil = processor.GetCtx().GetDepthStencilInfo();
  Require("Pm4StencilInfoValueLane", "standalone register value",
          consumed == 1 && stencil.format == Prospero::StencilFormat::k8UInt &&
              stencil.texture_compatibility ==
                  Prospero::TextureCompatibleStencil::kEnable &&
              !stencil.expclear_enabled && !stencil.htile_stencil_disabled,
          "standalone DB_STENCIL_INFO did not decode its sole payload value");
  std::printf("[host]    %-32s ok\n", "Pm4StencilInfoValueLane");
}

void CheckPm4NativeTargetGeometryRegisters(RenderContext &renderer) {
  GraphicsInitJmpTables();
  CommandProcessor packet(renderer, 0);
  CommandProcessor indirect(renderer, 0);

  const auto write_context = [](CommandProcessor &processor, uint32_t offset,
                                uint32_t value) {
    std::array<uint32_t, 3> command{
        KYTY_PM4(3, Pm4::IT_SET_CONTEXT_REG, Pm4::R_ZERO), offset, value};
    Pm4Execution execution;
    return processor.Process(execution, command) == Pm4ProcessResult::Complete;
  };

  constexpr uint32_t color_slot = 7;
  constexpr uint32_t width_minus_one = 1919;
  constexpr uint32_t height_minus_one = 1079;
  constexpr uint32_t depth_minus_one = 5;
  constexpr uint32_t max_mip = 3;
  constexpr uint32_t dimension_3d = 2;
  constexpr uint32_t attrib2_value =
      height_minus_one | (width_minus_one << 14u) | (max_mip << 28u);
  constexpr uint32_t attrib3_value =
      depth_minus_one |
      (static_cast<uint32_t>(Prospero::TileMode::kStandard64KB) << 14u) |
      (dimension_3d << 24u) | (1u << 26u) | (1u << 30u);

  const bool color_packets_complete =
      write_context(packet, Pm4::CB_COLOR7_ATTRIB2, attrib2_value) &&
      write_context(packet, Pm4::CB_COLOR7_ATTRIB3, attrib3_value);
  g_hw_ctx_indirect_func[Pm4::CB_COLOR7_ATTRIB2](
      indirect, Pm4::CB_COLOR7_ATTRIB2, attrib2_value);
  g_hw_ctx_indirect_func[Pm4::CB_COLOR7_ATTRIB3](
      indirect, Pm4::CB_COLOR7_ATTRIB3, attrib3_value);

  const auto color_matches = [](const HW::RenderTarget &target) {
    return target.attrib2.width == width_minus_one &&
           target.attrib2.height == height_minus_one &&
           target.attrib2.num_mip_levels == max_mip &&
           target.attrib3.depth == depth_minus_one &&
           target.attrib3.tile_mode == Prospero::TileMode::kStandard64KB &&
           target.attrib3.dimension == dimension_3d &&
           target.attrib3.metadata_pipe_aligned;
  };
  Require("Pm4NativeTargetGeometry", "sparse color geometry",
          color_packets_complete &&
              color_matches(packet.GetCtx().GetRenderTarget(color_slot)) &&
              color_matches(indirect.GetCtx().GetRenderTarget(color_slot)) &&
              !color_matches(packet.GetCtx().GetRenderTarget(0)) &&
              !color_matches(indirect.GetCtx().GetRenderTarget(0)),
          "ATTRIB2/ATTRIB3 did not provide native color extent and layout");

  constexpr uint32_t depth_size_value =
      width_minus_one | (height_minus_one << 16u);
  const bool depth_packet_complete =
      write_context(packet, Pm4::DB_DEPTH_SIZE_XY, depth_size_value);
  g_hw_ctx_indirect_func[Pm4::DB_DEPTH_SIZE_XY](indirect, Pm4::DB_DEPTH_SIZE_XY,
                                                depth_size_value);
  const auto depth_matches = [](const HW::DepthRenderTarget &target) {
    return target.size.valid && target.size.x_max == width_minus_one &&
           target.size.y_max == height_minus_one;
  };
  Require("Pm4NativeTargetGeometry", "native depth geometry",
          depth_packet_complete &&
              depth_matches(packet.GetCtx().GetDepthRenderTarget()) &&
              depth_matches(indirect.GetCtx().GetDepthRenderTarget()),
          "DB_DEPTH_SIZE_XY did not provide the native depth extent");

  bool legacy_slots_are_unhandled = true;
  for (uint32_t slot = 0; slot < 8; slot++) {
    const auto stride = slot * 15u;
    const std::array legacy_color_slots{
        Pm4::CB_COLOR0_BASE + stride + 1u,
        Pm4::CB_COLOR0_BASE + stride + 2u,
        Pm4::CB_COLOR0_CMASK + stride + 1u,
        Pm4::CB_COLOR0_FMASK + stride + 1u,
    };
    for (const auto offset : legacy_color_slots) {
      legacy_slots_are_unhandled &= g_hw_ctx_func[offset] == nullptr &&
                                    g_hw_ctx_indirect_func[offset] == nullptr;
    }
  }
  // These offsets are the removed GCN DB_DEPTH_INFO, DB_DEPTH_SIZE, and
  // DB_DEPTH_SLICE holes. Keep them numeric so deleting their legacy PM4 names
  // does not weaken this dispatch-table regression check.
  constexpr std::array<uint32_t, 3> legacy_depth_slots{0x000fu, 0x0016u,
                                                       0x0017u};
  for (const auto offset : legacy_depth_slots) {
    legacy_slots_are_unhandled &= g_hw_ctx_func[offset] == nullptr &&
                                  g_hw_ctx_indirect_func[offset] == nullptr;
  }
  // Removed GCN PA_SC_NGG_MODE_CNTL.
  legacy_slots_are_unhandled &= g_hw_ctx_func[0x0314u] == nullptr &&
                                g_hw_ctx_indirect_func[0x0314u] == nullptr;

  // Removed GCN shader resource/checksum/queue registers. Numeric offsets keep
  // this check independent of the deleted legacy names.
  constexpr std::array<uint32_t, 19> legacy_shader_slots{
      0x000u, 0x001u, 0x002u, 0x003u, 0x030u, 0x0b0u, 0x0bcu, 0x130u,
      0x14au, 0x14bu, 0x20eu, 0x20fu, 0x210u, 0x211u, 0x216u, 0x217u,
      0x219u, 0x21au, 0x27du,
  };
  for (const auto offset : legacy_shader_slots) {
    legacy_slots_are_unhandled &= g_hw_sh_func[offset] == nullptr &&
                                  g_hw_sh_indirect_func[offset] == nullptr;
  }
  // Restoring shader state after Toolkit rendering still emits the compiler's
  // GS-front allocation metadata at 0xca.
  for (uint32_t offset = 0x0cbu; offset <= 0x0ebu; offset++) {
    legacy_slots_are_unhandled &= g_hw_sh_func[offset] == nullptr &&
                                  g_hw_sh_indirect_func[offset] == nullptr;
  }

  std::array<uint32_t, 3> index_size_packet{
      KYTY_PM4(3, Pm4::IT_SET_UCONFIG_REG_INDEX, Pm4::R_ZERO),
      0x20000000u | Pm4::VGT_INDEX_TYPE,
      0x441u,
  };
  Pm4Execution index_size_execution;
  const bool native_index_size_packet_complete =
      packet.Process(index_size_execution, index_size_packet) ==
          Pm4ProcessResult::Complete &&
      g_hw_uc_func[Pm4::VGT_INDEX_TYPE] != nullptr &&
      g_hw_uc_indirect_func[Pm4::VGT_INDEX_TYPE] != nullptr &&
      g_hw_uc_func[Pm4::IA_MULTI_VGT_PARAM] != nullptr &&
      g_hw_uc_indirect_func[Pm4::IA_MULTI_VGT_PARAM] != nullptr;

  const bool native_pace_slots_are_handled =
      g_hw_sh_indirect_func[Pm4::SPI_SHADER_PACE_ID_PS] != nullptr &&
      g_hw_sh_indirect_func[Pm4::SPI_SHADER_PACE_ID_GS] != nullptr &&
      g_hw_sh_indirect_func[Pm4::COMPUTE_PACE_ID] != nullptr;
  Require("Pm4NativeTargetGeometry", "legacy register holes",
          legacy_slots_are_unhandled && native_pace_slots_are_handled &&
              native_index_size_packet_complete,
          "a removed GCN register has a handler or a native packet is not handled");
  std::printf("[host]    %-32s ok\n", "Pm4NativeTargetGeometry");
}

void CheckPm4PrivateAgcShaderRegisters(RenderContext &renderer) {
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);
  std::array<uint32_t, 24> registers{
      Pm4::SPI_SHADER_PGM_RSRC4_GS, 0x0badc0deu,
      Pm4::SPI_SHADER_PGM_CHKSUM_HS, 0x12345678u,
      Pm4::SPI_SHADER_PGM_RSRC4_HS, 0x87654321u,
      Pm4::SPI_SHADER_PGM_LO_ES, 0x050025e5u,
      Pm4::SPI_SHADER_PGM_HI_ES, 0u,
      Pm4::SPI_SHADER_PGM_RSRC1_GS, 0x60000002u,
      Pm4::SPI_SHADER_PGM_RSRC2_GS, 0x00030008u,
      0x000000cau, 0x03000002u,
      Pm4::SPI_SHADER_PGM_LO_PS, 0x05000104u,
      Pm4::SPI_SHADER_PGM_HI_PS, 0u,
      Pm4::SPI_SHADER_PGM_RSRC1_PS, 0x022c018du,
      Pm4::SPI_SHADER_PGM_RSRC2_PS, 0x0000003cu,
  };
  const auto address = reinterpret_cast<uint64_t>(registers.data());
  std::array<uint32_t, 5> command{
      KYTY_PM4(5, Pm4::IT_SET_SH_REG_INDIRECT, Pm4::R_ZERO),
      static_cast<uint32_t>(address), static_cast<uint32_t>(address >> 32u),
      0x80000000u, static_cast<uint32_t>(registers.size() / 2u),
  };
  Pm4Execution execution;
  const bool handlers_present =
      g_hw_sh_indirect_func[Pm4::SPI_SHADER_PGM_RSRC4_GS] != nullptr &&
      g_hw_sh_indirect_func[Pm4::SPI_SHADER_PGM_CHKSUM_HS] != nullptr &&
      g_hw_sh_indirect_func[Pm4::SPI_SHADER_PGM_RSRC4_HS] != nullptr;
  Require("Pm4PrivateAgcShaderRegisters", "private shader register stream",
          handlers_present &&
              processor.Process(execution, command) == Pm4ProcessResult::Complete,
          "private AGC shader registers were rejected by SET_SH_REG_INDIRECT");
  const auto &vs = processor.GetShCtx().GetVs();
  const auto &ps = processor.GetShCtx().GetPs().ps_regs;
  Require("Pm4PrivateAgcShaderRegisters", "native state around front metadata",
          vs.es_regs.data_addr == 0x50025e500ull &&
              vs.gs_regs.rsrc1.vgprs == 2u &&
              vs.gs_regs.rsrc1.gs_vgpr_component_count == 3u &&
              vs.gs_regs.rsrc2.es_vgpr_component_count == 3u &&
              vs.gs_regs.rsrc2.user_sgpr == 4u &&
              ps.data_addr == 0x500010400ull && ps.rsrc1.vgprs == 13u &&
              ps.rsrc2.user_sgpr == 30u,
          "GS-front metadata changed native GS state or prevented later PS writes");
  std::printf("[host]    %-32s ok\n", "Pm4PrivateAgcShaderRegisters");
}

void CheckPm4PrivateAgcUconfigRegisters(RenderContext &renderer) {
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);
  std::array<uint32_t, 2> registers{
      Pm4::UC_PARAMETER_OVERSUBSCRIPTION, 0x12345678u,
  };
  const auto address = reinterpret_cast<uint64_t>(registers.data());
  std::array<uint32_t, 5> command{
      KYTY_PM4(5, Pm4::IT_SET_UCONFIG_REG_INDIRECT, Pm4::R_ZERO),
      static_cast<uint32_t>(address), static_cast<uint32_t>(address >> 32u),
      0x80000000u, 1u,
  };
  Pm4Execution execution;
  const bool handler_present =
      g_hw_uc_indirect_func[Pm4::UC_PARAMETER_OVERSUBSCRIPTION] != nullptr;
  Require("Pm4PrivateAgcUconfigRegisters", "private UCONFIG register stream",
          handler_present &&
              processor.Process(execution, command) == Pm4ProcessResult::Complete,
          "private AGC UCONFIG register was rejected by SET_UCONFIG_REG_INDIRECT");
  std::printf("[host]    %-32s ok\n", "Pm4PrivateAgcUconfigRegisters");
}

void CheckPm4DirectShaderRegisterFallback(RenderContext &renderer) {
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);
  constexpr uint64_t shader_address = 0x0000123456789a00ull;
  std::array<uint32_t, 4> packet{
      KYTY_PM4(4, Pm4::IT_SET_SH_REG, Pm4::R_ZERO),
      Pm4::SPI_SHADER_PGM_LO_ES,
      static_cast<uint32_t>(shader_address >> 8u),
      static_cast<uint32_t>(shader_address >> 40u),
  };
  Pm4Execution execution;
  Require("Pm4DirectShaderRegisterFallback", "ES program base",
          processor.Process(execution, packet) == Pm4ProcessResult::Complete &&
              processor.GetShCtx().GetVs().es_regs.data_addr == shader_address,
          "direct SET_SH_REG did not route its ES base pair through the "
          "register handlers");
  std::printf("[host]    %-32s ok\n", "Pm4DirectShaderRegisterFallback");
}

void CheckPm4GuardBandRegisterRanges(RenderContext &renderer) {
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);
  processor.GetCtx().SetGuardBands(2.0f, 3.0f, 4.0f, 5.0f);

  std::array<uint32_t, 3> single{
      KYTY_PM4(3, Pm4::IT_SET_CONTEXT_REG, Pm4::R_ZERO),
      Pm4::PA_CL_GB_VERT_CLIP_ADJ,
      std::bit_cast<uint32_t>(6.0f),
  };
  Pm4Execution single_execution;
  const auto single_result = processor.Process(single_execution, single);
  const auto &single_viewport = processor.GetCtx().GetScreenViewport();
  Require("Pm4GuardBandRegisterRanges", "single register",
          single_result == Pm4ProcessResult::Complete &&
              single_viewport.guard_band_horz_clip == 2.0f &&
              single_viewport.guard_band_vert_clip == 6.0f &&
              single_viewport.guard_band_horz_discard == 4.0f &&
              single_viewport.guard_band_vert_discard == 5.0f,
          "single guard-band write changed the wrong context state");

  std::array<uint32_t, 6> range{
      KYTY_PM4(6, Pm4::IT_SET_CONTEXT_REG, Pm4::R_ZERO),
      Pm4::PA_CL_GB_VERT_CLIP_ADJ,
      std::bit_cast<uint32_t>(7.0f),
      std::bit_cast<uint32_t>(8.0f),
      std::bit_cast<uint32_t>(9.0f),
      std::bit_cast<uint32_t>(10.0f),
  };
  Pm4Execution range_execution;
  const auto range_result = processor.Process(range_execution, range);
  const auto &range_viewport = processor.GetCtx().GetScreenViewport();
  Require("Pm4GuardBandRegisterRanges", "full range",
          range_result == Pm4ProcessResult::Complete &&
              range_viewport.guard_band_horz_clip == 9.0f &&
              range_viewport.guard_band_vert_clip == 7.0f &&
              range_viewport.guard_band_horz_discard == 10.0f &&
              range_viewport.guard_band_vert_discard == 8.0f,
          "full guard-band range did not preserve hardware register order");
  std::printf("[host]    %-32s ok\n", "Pm4GuardBandRegisterRanges");
}

void CheckPm4BlendColorRegisterRanges(RenderContext &renderer) {
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);
  processor.GetCtx().SetBlendColor({1.0f, 2.0f, 3.0f, 4.0f});

  constexpr std::array<std::pair<uint32_t, float>, 4> singleton_values{{
      {Pm4::CB_BLEND_RED, 5.0f},
      {Pm4::CB_BLEND_BLUE, 7.0f},
      {Pm4::CB_BLEND_GREEN, 6.0f},
      {Pm4::CB_BLEND_ALPHA, 8.0f},
  }};
  bool singletons_complete = true;
  for (const auto &[offset, value] : singleton_values) {
    std::array<uint32_t, 3> packet{
        KYTY_PM4(3, Pm4::IT_SET_CONTEXT_REG, Pm4::R_ZERO),
        offset,
        std::bit_cast<uint32_t>(value),
    };
    Pm4Execution execution;
    singletons_complete &=
        processor.Process(execution, packet) == Pm4ProcessResult::Complete;
  }
  const auto &singletons = processor.GetCtx().GetBlendColor();
  Require("Pm4BlendColorRegisterRanges", "single registers",
          singletons_complete && singletons.red == 5.0f &&
              singletons.green == 6.0f && singletons.blue == 7.0f &&
              singletons.alpha == 8.0f,
          "single blend-color writes did not follow native PS5 register order");

  std::array<uint32_t, 4> partial{
      KYTY_PM4(4, Pm4::IT_SET_CONTEXT_REG, Pm4::R_ZERO),
      Pm4::CB_BLEND_BLUE,
      std::bit_cast<uint32_t>(9.0f),
      std::bit_cast<uint32_t>(10.0f),
  };
  Pm4Execution partial_execution;
  const auto partial_result = processor.Process(partial_execution, partial);
  const auto &partial_color = processor.GetCtx().GetBlendColor();
  Require("Pm4BlendColorRegisterRanges", "partial range",
          partial_result == Pm4ProcessResult::Complete &&
              partial_color.red == 5.0f && partial_color.green == 10.0f &&
              partial_color.blue == 9.0f && partial_color.alpha == 8.0f,
          "partial blend-color range changed the wrong channels");

  std::array<uint32_t, 6> full{
      KYTY_PM4(6, Pm4::IT_SET_CONTEXT_REG, Pm4::R_ZERO),
      Pm4::CB_BLEND_RED,
      std::bit_cast<uint32_t>(11.0f),
      std::bit_cast<uint32_t>(13.0f),
      std::bit_cast<uint32_t>(12.0f),
      std::bit_cast<uint32_t>(14.0f),
  };
  Pm4Execution full_execution;
  const auto full_result = processor.Process(full_execution, full);
  const auto &full_color = processor.GetCtx().GetBlendColor();
  Require("Pm4BlendColorRegisterRanges", "full range",
          full_result == Pm4ProcessResult::Complete &&
              full_color.red == 11.0f && full_color.green == 12.0f &&
              full_color.blue == 13.0f && full_color.alpha == 14.0f,
          "full blend-color range did not preserve native PS5 register order");
  std::printf("[host]    %-32s ok\n", "Pm4BlendColorRegisterRanges");
}

void CheckPm4PolygonOffsetRegisters(RenderContext &renderer) {
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);
  const auto &defaults = processor.GetCtx().GetPolyOffset();
  Require("Pm4PolygonOffset", "format defaults",
          defaults.neg_num_db_bits == -23 && defaults.db_is_float_fmt,
          "polygon offset Z format did not default to D32F");

  constexpr std::array<uint32_t, 6> payload{0x000000f0u,
                                            std::bit_cast<uint32_t>(2.5f),
                                            std::bit_cast<uint32_t>(16.0f),
                                            std::bit_cast<uint32_t>(-3.25f),
                                            std::bit_cast<uint32_t>(32.0f),
                                            std::bit_cast<uint32_t>(4.5f)};
  const auto consumed = HwCtxSetPolyOffsetRegisters(
      processor, KYTY_PM4(8, Pm4::IT_SET_CONTEXT_REG, Pm4::R_ZERO),
      Pm4::PA_SU_POLY_OFFSET_DB_FMT_CNTL, payload.data(), 0);
  const auto &direct = processor.GetCtx().GetPolyOffset();
  Require("Pm4PolygonOffset", "direct registers",
          consumed == payload.size() && direct.neg_num_db_bits == -16 &&
              !direct.db_is_float_fmt && direct.clamp == 2.5f &&
              direct.front_scale == 16.0f && direct.front_offset == -3.25f &&
              direct.back_scale == 32.0f && direct.back_offset == 4.5f,
          "direct polygon offset register packet was decoded incorrectly");

  g_hw_ctx_indirect_func[Pm4::PA_SU_POLY_OFFSET_DB_FMT_CNTL](
      processor, Pm4::PA_SU_POLY_OFFSET_DB_FMT_CNTL, 0x000001e9u);
  g_hw_ctx_indirect_func[Pm4::PA_SU_POLY_OFFSET_FRONT_SCALE](
      processor, Pm4::PA_SU_POLY_OFFSET_FRONT_SCALE,
      std::bit_cast<uint32_t>(24.0f));
  const auto &indirect = processor.GetCtx().GetPolyOffset();
  Require("Pm4PolygonOffset", "indirect registers",
          indirect.neg_num_db_bits == -23 && indirect.db_is_float_fmt &&
              indirect.front_scale == 24.0f && indirect.front_offset == -3.25f,
          "indirect polygon offset register write was decoded incorrectly");
  std::printf("[host]    %-32s ok\n", "Pm4PolygonOffset");
}

void CheckPm4DepthControlHighBits(RenderContext &renderer) {
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);

  std::array<uint32_t, 3> direct{
      KYTY_PM4(3, Pm4::IT_SET_CONTEXT_REG, Pm4::R_ZERO),
      Pm4::DB_DEPTH_CONTROL,
      0x80000072u,
  };
  Pm4Execution direct_execution;
  const bool direct_complete =
      processor.Process(direct_execution, direct) == Pm4ProcessResult::Complete;
  const auto &direct_control = processor.GetCtx().GetDepthControl();
  const bool direct_decoded =
      !direct_control.stencil_enable && direct_control.z_enable &&
      !direct_control.z_write_enable && !direct_control.depth_bounds_enable &&
      direct_control.zfunc == 7u && !direct_control.backface_enable &&
      direct_control.stencilfunc == 0u && direct_control.stencilfunc_bf == 0u;

  std::array<uint32_t, 2> registers{
      Pm4::DB_DEPTH_CONTROL,
      0x4070078du,
  };
  const auto address = reinterpret_cast<uint64_t>(registers.data());
  std::array<uint32_t, 5> indirect{
      KYTY_PM4(5, Pm4::IT_SET_CONTEXT_REG_INDIRECT, Pm4::R_ZERO),
      static_cast<uint32_t>(address), static_cast<uint32_t>(address >> 32u),
      0x80000000u, 1u,
  };
  Pm4Execution indirect_execution;
  const bool indirect_complete =
      processor.Process(indirect_execution, indirect) ==
      Pm4ProcessResult::Complete;
  const auto &indirect_control = processor.GetCtx().GetDepthControl();
  const bool indirect_decoded =
      indirect_control.stencil_enable && !indirect_control.z_enable &&
      indirect_control.z_write_enable && indirect_control.depth_bounds_enable &&
      indirect_control.zfunc == 0u && indirect_control.backface_enable &&
      indirect_control.stencilfunc == 7u &&
      indirect_control.stencilfunc_bf == 7u;

  Require("Pm4DepthControlHighBits", "preserved high bits",
          direct_complete && direct_decoded && indirect_complete &&
              indirect_decoded,
          "DB_DEPTH_CONTROL high bits rejected or changed decoded PS5 state");
  std::printf("[host]    %-32s ok\n", "Pm4DepthControlHighBits");
}

void CheckPm4DepthRenderOverride(RenderContext &renderer) {
  constexpr const char *name = "Pm4DepthRenderOverride";
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);
  struct Case {
    uint32_t value;
    HW::DepthRenderOverride expected;
  };
  constexpr std::array cases{Case{0x28000000u, {true, true, false, false}},
                             Case{0x50000000u, {false, false, true, true}},
                             Case{0x18000000u, {false, true, false, true}},
                             Case{0x60000000u, {true, false, true, false}},
                             Case{0xf8000000u, {true, true, true, true}},
                             Case{0x82001a0fu, {false, false, false, false}}};
  for (const bool indirect : {false, true}) {
    for (const auto &test : cases) {
      std::array<uint32_t, 2> registers{Pm4::DB_RENDER_OVERRIDE, test.value};
      const auto address = reinterpret_cast<uint64_t>(registers.data());
      const std::array<uint32_t, 3> direct_packet{
          KYTY_PM4(3, Pm4::IT_SET_CONTEXT_REG, Pm4::R_ZERO),
          Pm4::DB_RENDER_OVERRIDE, test.value};
      const std::array<uint32_t, 5> indirect_packet{
          KYTY_PM4(5, Pm4::IT_SET_CONTEXT_REG_INDIRECT, Pm4::R_ZERO),
          static_cast<uint32_t>(address), static_cast<uint32_t>(address >> 32u),
          0x80000000u, 1u};
      Pm4Execution execution;
      const auto result = processor.Process(
          execution, indirect ? std::span<const uint32_t>{indirect_packet}
                              : std::span<const uint32_t>{direct_packet});
      const auto &actual = processor.GetCtx().GetDepthRenderOverride();
      Require(
          name, indirect ? "indirect register" : "direct register",
          result == Pm4ProcessResult::Complete &&
              actual.force_z_valid == test.expected.force_z_valid &&
              actual.force_z_dirty == test.expected.force_z_dirty &&
              actual.force_stencil_valid == test.expected.force_stencil_valid &&
              actual.force_stencil_dirty == test.expected.force_stencil_dirty,
          "DB_RENDER_OVERRIDE lost, exchanged, or retained force flags");
    }
  }
  std::printf("[host]    %-32s ok\n", name);
}

void CheckAgcShaderFusion() {
  struct Case {
    bool gs;
    uint32_t front1, front2, back1, back2, fused1, fused2, older2;
  };
  // Register results from both exports in the supplied libSceAgc.sprx.
  constexpr Case cases[]{
      {true, 0x600c0007, 0x00030010, 0x600c0007, 0x008b0000,
       0x600c0007, 0x008b0010, 0x008b0010}, // Captured volume ES + GS.
      {true, 0x20ac0003, 0xf805004a, 0x40ec0007, 0x028b003e,
       0x40ec0007, 0x1a8f000a, 0xfa8f000a},
      {false, 0x20ac0003, 0xf805004a, 0x10ec0007, 0x028b003e,
       0x20ec0007, 0x1a8b000a, 0xfa8b000a},
  };
  ShaderUserData user_data{};
  ShaderSpecialRegs specials{};
  for (const auto &c : cases) {
    const auto checksum = c.gs ? Pm4::SPI_SHADER_PGM_CHKSUM_GS : Pm4::SPI_SHADER_PGM_CHKSUM_HS;
    const auto rsrc1 = c.gs ? Pm4::SPI_SHADER_PGM_RSRC1_GS : Pm4::SPI_SHADER_PGM_RSRC1_HS;
    const auto rsrc2 = c.gs ? Pm4::SPI_SHADER_PGM_RSRC2_GS : Pm4::SPI_SHADER_PGM_RSRC2_HS;
    const auto lo = c.gs ? Pm4::SPI_SHADER_PGM_LO_ES : Pm4::SPI_SHADER_PGM_LO_LS;
    std::array<ShaderRegister, 6> front_regs{{
        {checksum, 0x1234}, {checksum, 0x5678}, {rsrc1, c.front1},
        {rsrc2, c.front2}, {lo, 0}, {lo + 1u, 0}}};
    const std::array<ShaderRegister, 6> back_regs{{
        {checksum, 0}, {checksum, 0}, {rsrc1, c.back1},
        {rsrc2, c.back2}, {lo, 0}, {lo + 1u, 0xabcdef00}}};
    Shader front{};
    front.user_data = &user_data;
    front.code = reinterpret_cast<const void *>(0x12580e91c00ull);
    front.sh_registers = front_regs.data();
    front.specials = &specials;
    front.type = static_cast<uint8_t>(c.gs ? Prospero::ShaderBinaryType::kGsFront
                                         : Prospero::ShaderBinaryType::kHsFront);
    front.num_sh_registers = front_regs.size();
    for (const bool older : {false, true}) {
      for (const bool in_place : {false, true}) {
        auto registers = back_regs;
        std::array<ShaderRegister, 6> scratch{};
        Shader back = front;
        back.sh_registers = registers.data();
        back.type = static_cast<uint8_t>(c.gs ? Prospero::ShaderBinaryType::kGsBack
                                            : Prospero::ShaderBinaryType::kHsBack);
        Shader fused{};
        const auto fuse = older ? Gen5::AgcUnknownNApJjpKNBl4 : Gen5::AgcUnknownFuseShaderHalves;
        const auto result = fuse(&fused, &front, &back, in_place ? nullptr : scratch.data());
        const auto *regs = fused.sh_registers;
        Require("AgcShaderFusion", "native fused registers",
                result == 0 && regs == (in_place ? registers.data() : scratch.data()) &&
                    regs[0].value == 0x1234 && regs[1].value == 0x5678 &&
                    regs[2].value == c.fused1 && regs[3].value == (older ? c.older2 : c.fused2) &&
                    regs[4].value == 0x2580e91c && regs[5].value == 0xabcdef01 &&
                    fused.type == static_cast<uint8_t>(c.gs ? Prospero::ShaderBinaryType::kGs
                                                            : Prospero::ShaderBinaryType::kHs) &&
                    fused.user_data == (older ? &user_data : nullptr) &&
                    (in_place || std::memcmp(registers.data(), back_regs.data(), sizeof(registers)) == 0),
                "AGC lost front resources or changed the export's allocation/metadata behavior");
      }
    }
  }
  std::printf("[host]    %-32s ok\n", "AgcShaderFusion");
}

struct AgcCommandBufferLayout {
  using Callback = KYTY_SYSV_ABI bool (*)(Gen5::CommandBuffer *, uint32_t,
                                          void *);

  uint32_t *bottom;
  uint32_t *top;
  uint32_t *cursor_up;
  uint32_t *cursor_down;
  Callback callback;
  void *user_data;
  uint32_t reserved_dw;
};
static_assert(offsetof(AgcCommandBufferLayout, cursor_up) == 0x10);
static_assert(offsetof(AgcCommandBufferLayout, reserved_dw) == 0x30);

void CheckAgcWaitPackets(RenderContext &renderer) {
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);
  constexpr auto packet_mismatch = static_cast<int>(0x8a6c000cu);
  const auto execute = [&](uint32_t *packet, uint32_t size_dw) {
    Pm4Execution execution;
    return processor.Process(execution, {packet, size_dw}) ==
           Pm4ProcessResult::Complete;
  };

  alignas(8) uint32_t label32 = 0x11223344u;
  std::array<uint32_t, 16> packet32{};
  AgcCommandBufferLayout dcb32{packet32.data(),
                               packet32.data() + packet32.size(),
                               packet32.data(),
                               packet32.data() + packet32.size(),
                               nullptr,
                               nullptr,
                               0};
  const auto address32 = reinterpret_cast<uint64_t>(&label32);
  auto *emitted32 =
      Gen5::AgcDcbWaitRegMem(reinterpret_cast<Gen5::CommandBuffer *>(&dcb32), 0,
                             3, 0, 0, &label32, label32, UINT32_MAX, 400);
  Require("AgcWaitPackets", "native 32-bit packet",
          Gen5::AgcDcbWaitOnAddressGetSize(0) == 56 &&
              emitted32 == packet32.data() &&
              dcb32.cursor_up == packet32.data() + 14 &&
              packet32[0] == 0xc0027904u && packet32[1] == 0x342u &&
              packet32[2] ==
                  (0xc8010000u |
                   (static_cast<uint32_t>(address32 >> 32u) & 0xffffu)) &&
              packet32[3] == static_cast<uint32_t>(address32) &&
              packet32[4] == 0xc0053c00u && packet32[5] == 0x13u &&
              packet32[6] == (static_cast<uint32_t>(address32) & ~0x3u) &&
              packet32[7] ==
                  (static_cast<uint32_t>(address32 >> 32u) & 0x3ffffu) &&
              packet32[8] == label32 && packet32[9] == UINT32_MAX &&
              packet32[10] == 25u && packet32[11] == 0xc0017904u &&
              packet32[12] == 0x342u && packet32[13] == 0xc8000000u &&
              execute(packet32.data(), 14),
          "32-bit waitOnAddress stream differs from native AGC");

  alignas(8) uint32_t patched_label32 = 0xaabbccddu;
  const auto patched_address32 = reinterpret_cast<uint64_t>(&patched_label32);
  packet32[6] |= 0x2u;
  packet32[7] |= 0xa5a40000u;
  Require(
      "AgcWaitPackets", "native 32-bit patch",
      Gen5::AgcWaitRegMemPatchAddress(packet32.data(), &patched_label32) == 0 &&
          Gen5::AgcWaitRegMemPatchReference(packet32.data(), patched_label32) ==
              0 &&
          packet32[2] ==
              (0xc8010000u |
               (static_cast<uint32_t>(patched_address32 >> 32u) & 0xffffu)) &&
          packet32[3] == static_cast<uint32_t>(patched_address32) &&
          packet32[6] ==
              ((static_cast<uint32_t>(patched_address32) & ~0x3u) | 0x2u) &&
          packet32[7] ==
              ((static_cast<uint32_t>(patched_address32 >> 32u) & 0x3ffffu) |
               0xa5a40000u) &&
          packet32[8] == patched_label32 && execute(packet32.data(), 14),
      "32-bit native wait patch did not update metadata and hardware packet");

  alignas(8) uint64_t label64 = 0x1122334455667788ull;
  std::array<uint32_t, 16> packet64{};
  AgcCommandBufferLayout dcb64{packet64.data(),
                               packet64.data() + packet64.size(),
                               packet64.data(),
                               packet64.data() + packet64.size(),
                               nullptr,
                               nullptr,
                               0};
  const auto address64 = reinterpret_cast<uint64_t>(&label64);
  auto *emitted64 =
      Gen5::AgcDcbWaitRegMem(reinterpret_cast<Gen5::CommandBuffer *>(&dcb64), 1,
                             3, 0, 0, &label64, label64, UINT64_MAX, 400);
  Require("AgcWaitPackets", "native 64-bit packet",
          Gen5::AgcDcbWaitOnAddressGetSize(1) == 64 &&
              Gen5::AgcDcbWaitOnAddressGetSize(2) == 0 &&
              emitted64 == packet64.data() &&
              dcb64.cursor_up == packet64.data() + packet64.size() &&
              packet64[0] == 0xc0027904u && packet64[1] == 0x342u &&
              packet64[2] ==
                  (0xc8020000u |
                   (static_cast<uint32_t>(address64 >> 32u) & 0xffffu)) &&
              packet64[3] == static_cast<uint32_t>(address64) &&
              packet64[4] == 0xc0079300u && packet64[5] == 0x13u &&
              packet64[6] == (static_cast<uint32_t>(address64) & ~0x7u) &&
              packet64[7] ==
                  (static_cast<uint32_t>(address64 >> 32u) & 0x3ffffu) &&
              packet64[8] == static_cast<uint32_t>(label64) &&
              packet64[9] == static_cast<uint32_t>(label64 >> 32u) &&
              packet64[10] == UINT32_MAX && packet64[11] == UINT32_MAX &&
              packet64[12] == 25u && packet64[13] == 0xc0017904u &&
              packet64[14] == 0x342u && packet64[15] == 0xc8000000u &&
              execute(packet64.data(), packet64.size()),
          "64-bit waitOnAddress stream differs from native AGC");

  alignas(8) uint64_t patched_label64 = 0x11223344aabbccddull;
  const auto patched_address64 = reinterpret_cast<uint64_t>(&patched_label64);
  packet64[6] |= 0x5u;
  packet64[7] |= 0x5a580000u;
  Require(
      "AgcWaitPackets", "native 64-bit patch",
      Gen5::AgcWaitRegMemPatchAddress(packet64.data(), &patched_label64) == 0 &&
          Gen5::AgcWaitRegMemPatchReference(packet64.data(),
                                            0xdeadbeefaabbccddull) == 0 &&
          packet64[2] ==
              (0xc8020000u |
               (static_cast<uint32_t>(patched_address64 >> 32u) & 0xffffu)) &&
          packet64[3] == static_cast<uint32_t>(patched_address64) &&
          packet64[6] ==
              ((static_cast<uint32_t>(patched_address64) & ~0x7u) | 0x5u) &&
          packet64[7] ==
              ((static_cast<uint32_t>(patched_address64 >> 32u) & 0x3ffffu) |
               0x5a580000u) &&
          packet64[8] == 0xaabbccddu && packet64[9] == 0x11223344u &&
          execute(packet64.data(), packet64.size()),
      "64-bit native wait patch did not preserve the native high reference "
      "DWORD");

  std::array<uint32_t, 16> invalid{};
  const uint32_t short_payload = 0x342u;
  Require(
      "AgcWaitPackets", "invalid packet",
      Gen5::AgcWaitRegMemPatchAddress(invalid.data(), &label32) ==
              packet_mismatch &&
          Gen5::AgcWaitRegMemPatchReference(invalid.data(), label32) ==
              packet_mismatch &&
          !Gen5::AgcIsInternalDataPacket(
              KYTY_PM4(2, Pm4::IT_SET_UCONFIG_REG, 1), &short_payload),
      "native wait patch accepted a packet without the AGC metadata prefix");
  std::printf("[host]    %-32s ok\n", "AgcWaitPackets");
}

void CheckAgcDrawIndirectMultiPacket(RenderContext &renderer) {
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);
  const auto execute = [&](uint32_t *packet, uint32_t size_dw) {
    Pm4Execution execution;
    return processor.Process(execution, {packet, size_dw}) ==
           Pm4ProcessResult::Complete;
  };

  constexpr uint64_t modifier = 0x0000000069380b1dull;
  constexpr auto packet_mismatch = static_cast<int>(0x8a6c000cu);
  const auto *count_address = reinterpret_cast<const volatile void *>(
      static_cast<uintptr_t>(0x123456789abcdef3ull));
  constexpr std::array<uint32_t, 16> expected{
      0xc0017904u, 0x00000342u, 0xc6000008u, 0xc0082c00u,
      0x11223344u, 0x00000111u, 0x00000113u, 0xc8000115u,
      0x55667788u, 0x9abcdef0u, 0x12345678u, 0xaabbccddu,
      0x00000022u, 0xc0017904u, 0x00000342u, 0xc6000000u};

  std::array<uint32_t, 16> packet{};
  AgcCommandBufferLayout dcb{packet.data(),
                             packet.data() + packet.size(),
                             packet.data(),
                             packet.data() + packet.size(),
                             nullptr,
                             nullptr,
                             0};
  auto *emitted = Gen5::AgcDcbDrawIndirectMulti(
      reinterpret_cast<Gen5::CommandBuffer *>(&dcb), 0x11223344u, 1u,
      0x55667788u, count_address, 0xaabbccddu, modifier);

  const uint32_t invalid_payload[]{0x342u, 0xc6000010u};
  Require("AgcDrawIndirectMulti", "native packet",
          emitted == packet.data() &&
              dcb.cursor_up == packet.data() + packet.size() &&
              packet == expected && execute(packet.data(), 3u) &&
              execute(packet.data() + 13u, 3u) &&
              Gen5::AgcWaitRegMemPatchAddress(packet.data(), count_address) ==
                  packet_mismatch &&
              Gen5::AgcWaitRegMemPatchReference(packet.data(), 0x12345678u) ==
                  packet_mismatch &&
              !Gen5::AgcIsInternalDataPacket(0xc0017904u, invalid_payload),
          "drawIndirectMulti stream differs from native AGC");
  std::printf("[host]    %-32s ok\n", "AgcDrawIndirectMulti");
}

void CheckPm4ContextStateOperations(RenderContext &renderer) {
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);
  constexpr auto primitive_type = static_cast<Prospero::PrimitiveType>(0x35u);

  HW::RenderControl original_control{};
  original_control.depth_clear_enable = true;
  original_control.stencil_clear_enable = true;
  processor.GetCtx().SetRenderControl(original_control);
  processor.GetCtx().SetRenderTargetMask(0x1234abcd);
  processor.GetUcfg().SetPrimitiveType(primitive_type);
  g_hw_sh_indirect_func[Pm4::SPI_SHADER_PGM_LO_PS](
      processor, Pm4::SPI_SHADER_PGM_LO_PS, 0x00123456);
  const auto shader_address = processor.GetShCtx().GetPs().ps_regs.data_addr;
  const auto invoke = [&](ContextStateOperation operation) {
    std::array<uint32_t, 32> packet{};
    std::array<uint32_t, 6> segment_sizes{};
    AgcCommandBufferLayout dcb{packet.data(),
                               packet.data() + packet.size(),
                               packet.data(),
                               packet.data() + packet.size(),
                               nullptr,
                               nullptr,
                               0};
    const auto operation_value = static_cast<uint32_t>(operation);
    size_t segment_count = 0;
    switch (operation) {
    case ContextStateOperation::Clear:
      segment_sizes = {5};
      segment_count = 1;
      break;
    case ContextStateOperation::Push:
      segment_sizes = {5, 8, 9, 3, 2};
      segment_count = 5;
      break;
    case ContextStateOperation::Pop:
      segment_sizes = {3, 5, 8, 9, 2};
      segment_count = 5;
      break;
    case ContextStateOperation::PushClear:
      segment_sizes = {5, 8, 9, 3, 2, 5};
      segment_count = 6;
      break;
    }
    const auto size_dw = static_cast<size_t>(
        Gen5::AgcDcbContextStateOpGetSize(operation_value) / 4);
    auto *emitted = Gen5::AgcDcbContextStateOp(
        reinterpret_cast<Gen5::CommandBuffer *>(&dcb), operation_value);
    bool packet_matches = true;
    size_t segment_offset = 0;
    for (size_t i = 0; i < segment_count; i++) {
      const auto segment_size = segment_sizes[i];
      const auto selector = (i == 0 ? Pm4::R_CONTEXT_STATE : Pm4::R_ZERO);
      packet_matches &= packet[segment_offset] ==
                        KYTY_PM4(segment_size, Pm4::IT_NOP, selector);
      for (size_t j = 1; j < segment_size; j++) {
        packet_matches &= packet[segment_offset + j] ==
                          (i == 0 && j == 1 ? operation_value : 0u);
      }
      segment_offset += segment_size;
    }
    Require("Pm4ContextState", "HLE packet",
            emitted == packet.data() &&
                dcb.cursor_up == packet.data() + size_dw &&
                segment_offset == size_dw && packet_matches,
            "context-state HLE packet does not match its real allocation size");
    Pm4Execution execution;
    return processor.Process(execution, {packet.data(), size_dw});
  };

  Require("Pm4ContextState", "push-clear",
          invoke(ContextStateOperation::PushClear) ==
                  Pm4ProcessResult::Complete &&
              !processor.GetCtx().GetRenderControl().depth_clear_enable &&
              !processor.GetCtx().GetRenderControl().stencil_clear_enable &&
              processor.GetCtx().GetRenderTargetMask() ==
                  HW::Context{}.GetRenderTargetMask() &&
              processor.GetUcfg().GetPrimType() == primitive_type &&
              processor.GetShCtx().GetPs().ps_regs.data_addr == shader_address,
          "push-clear did not save and clear only Cx state");

  processor.GetCtx().SetRenderTargetMask(0x55aa55aa);
  Require("Pm4ContextState", "pop",
          invoke(ContextStateOperation::Pop) == Pm4ProcessResult::Complete &&
              processor.GetCtx().GetRenderControl().depth_clear_enable &&
              processor.GetCtx().GetRenderControl().stencil_clear_enable &&
              processor.GetCtx().GetRenderTargetMask() == 0x1234abcd,
          "pop did not restore the complete saved Cx state");

  Require("Pm4ContextState", "push",
          invoke(ContextStateOperation::Push) == Pm4ProcessResult::Complete &&
              processor.GetCtx().GetRenderTargetMask() == 0x1234abcd,
          "push changed live Cx state");
  processor.GetCtx().SetRenderTargetMask(0x01020304);
  Require("Pm4ContextState", "push-pop restore",
          invoke(ContextStateOperation::Pop) == Pm4ProcessResult::Complete &&
              processor.GetCtx().GetRenderTargetMask() == 0x1234abcd,
          "ordinary push/pop did not restore Cx state");

  Require("Pm4ContextState", "clear",
          invoke(ContextStateOperation::Clear) == Pm4ProcessResult::Complete &&
              !processor.GetCtx().GetRenderControl().depth_clear_enable &&
              processor.GetCtx().GetRenderTargetMask() ==
                  HW::Context{}.GetRenderTargetMask() &&
              processor.GetUcfg().GetPrimType() == primitive_type &&
              processor.GetShCtx().GetPs().ps_regs.data_addr == shader_address,
          "clear reset state outside the Cx register domain");

  processor.GetCtx().SetRenderTargetMask(0x0badc0de);
  Require("Pm4ContextState", "push before clear-state packet",
          invoke(ContextStateOperation::Push) == Pm4ProcessResult::Complete,
          "push before CLEAR_STATE failed");
  processor.GetCtx().SetRenderTargetMask(0xfeedface);
  std::array<uint32_t, 2> clear_state_packet{0xc0001200, 0};
  Pm4Execution clear_state_execution;
  Require("Pm4ContextState", "clear-state packet",
          processor.Process(clear_state_execution, clear_state_packet) ==
                  Pm4ProcessResult::Complete &&
              processor.GetCtx().GetRenderTargetMask() ==
                  HW::Context{}.GetRenderTargetMask(),
          "CLEAR_STATE did not clear the current Cx state");
  Require("Pm4ContextState", "pop after clear-state packet",
          invoke(ContextStateOperation::Pop) == Pm4ProcessResult::Complete &&
              processor.GetCtx().GetRenderTargetMask() == 0x0badc0de,
          "CLEAR_STATE discarded the pushed Cx state");

  // AGC CLEAR_STATE restores the viewport, scissor, and guard-band register defaults.
  processor.GetCtx().SetScreenScissor(1, 2, 3, 4);
  processor.GetCtx().SetGuardBands(2.0f, 3.0f, 4.0f, 5.0f);
  Pm4Execution scissor_reset;
  Require("Pm4ContextState", "scissor reset packet",
          processor.Process(scissor_reset, clear_state_packet) == Pm4ProcessResult::Complete,
          "CLEAR_STATE could not reset the rasterization state");
  const auto &viewport = processor.GetCtx().GetScreenViewport();
  const auto defaults = calc_final_scissor(viewport, {}, {20000, 20000}, 0);
  Require("Pm4ContextState", "Rasterization defaults",
          defaults.left == 0 && defaults.top == 0 && defaults.right == 16384 &&
              defaults.bottom == 16384 && viewport.guard_band_horz_clip == 1.0f &&
              viewport.guard_band_vert_clip == 1.0f &&
              viewport.guard_band_horz_discard == 1.0f &&
              viewport.guard_band_vert_discard == 1.0f &&
              std::ranges::all_of(viewport.viewports, [](const auto &slot) {
                return slot.xscale == 1.0f && slot.yscale == 1.0f && slot.zscale == 1.0f &&
                       slot.viewport_scissor_right == 16384 &&
                       slot.viewport_scissor_bottom == 16384 &&
                       !slot.viewport_scissor_window_offset_enable;
              }),
          "CLEAR_STATE did not restore scissor and guard-band defaults");
  const std::array scissor_registers{
      std::pair{Pm4::PA_SC_SCREEN_SCISSOR_TL, Pm4::PA_SC_SCREEN_SCISSOR_BR},
      std::pair{Pm4::PA_SC_WINDOW_SCISSOR_TL, Pm4::PA_SC_WINDOW_SCISSOR_BR},
      std::pair{Pm4::PA_SC_GENERIC_SCISSOR_TL, Pm4::PA_SC_GENERIC_SCISSOR_BR},
      std::pair{Pm4::PA_SC_VPORT_SCISSOR_0_TL, Pm4::PA_SC_VPORT_SCISSOR_0_BR}};
  for (const auto &[tl, br] : scissor_registers) {
    processor.GetCtx().Reset();
    g_hw_ctx_indirect_func[tl](processor, tl, 0);
    g_hw_ctx_indirect_func[br](processor, br, 0);
    HW::ScanModeControl scan{};
    scan.vport_scissor_enable = tl == Pm4::PA_SC_VPORT_SCISSOR_0_TL;
    const auto empty = calc_final_scissor(processor.GetCtx().GetScreenViewport(),
                                         scan, {3840, 2160}, 0);
    Require("Pm4ContextState", "explicit empty scissor",
            empty.right == empty.left && empty.bottom == empty.top,
            "an explicitly empty scissor was expanded or ignored");
  }

  processor.GetCtx().SetRenderTargetMask(0xabcdef01);
  Require("Pm4ContextState", "push before processor reset",
          invoke(ContextStateOperation::Push) == Pm4ProcessResult::Complete,
          "push before reset failed");
  processor.Reset();
  processor.GetCtx().SetRenderTargetMask(0x76543210);
  Require("Pm4ContextState", "processor reset discards push",
          invoke(ContextStateOperation::Push) == Pm4ProcessResult::Complete &&
              invoke(ContextStateOperation::Pop) ==
                  Pm4ProcessResult::Complete &&
              processor.GetCtx().GetRenderTargetMask() == 0x76543210,
          "processor reset retained an invalid saved Cx state");

  Require("Pm4ContextState", "HLE packet size",
          Gen5::AgcDcbContextStateOpGetSize(0) == 20 &&
              Gen5::AgcDcbContextStateOpGetSize(1) == 108 &&
              Gen5::AgcDcbContextStateOpGetSize(2) == 108 &&
              Gen5::AgcDcbContextStateOpGetSize(3) == 128 &&
              Gen5::AgcDcbContextStateOpGetSize(4) == 0,
          "context-state HLE sizes do not match libSceAgc");
  std::printf("[host]    %-32s ok\n", "Pm4ContextState");
}

void CheckPm4IndirectControlFlow(RenderContext &renderer) {
  constexpr const char *name = "Pm4IndirectControlFlow";
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);
  uint32_t selected = 0;
  uint32_t returned = 0;
  const auto address = [](const void *value) {
    return reinterpret_cast<uint64_t>(value);
  };
  const auto write = [&](uint32_t *destination, uint32_t value) {
    return std::array<uint32_t, 5>{
        KYTY_PM4(5, Pm4::IT_WRITE_DATA, 0), 0,
        static_cast<uint32_t>(address(destination)),
        static_cast<uint32_t>(address(destination) >> 32u), value};
  };
  const auto indirect = [&](std::span<const uint32_t> target, bool chain) {
    uint32_t control = 0x0f200000u | static_cast<uint32_t>(target.size());
    if (chain) {
      control |= 1u << 20u;
    }
    return std::array<uint32_t, 4>{
        KYTY_PM4(4, Pm4::IT_INDIRECT_BUFFER, 0),
        static_cast<uint32_t>(address(target.data())),
        static_cast<uint32_t>(address(target.data()) >> 32u), control};
  };
  const auto then_commands = write(&selected, 11);
  const auto else_commands = write(&selected, 33);
  const auto branch_suffix = write(&selected, 44);
  const auto caller_suffix = write(&returned, 22);
  alignas(8) uint64_t condition = 0;
  std::array<uint32_t, 19> branch{
      KYTY_PM4(14, Pm4::IT_INDIRECT_BUFFER, 0), 0,
      static_cast<uint32_t>(address(&condition)),
      static_cast<uint32_t>(address(&condition) >> 32u), UINT32_MAX,
      UINT32_MAX, 1, 0,
      static_cast<uint32_t>(address(then_commands.data())),
      static_cast<uint32_t>(address(then_commands.data()) >> 32u),
      static_cast<uint32_t>(then_commands.size()),
      static_cast<uint32_t>(address(else_commands.data())),
      static_cast<uint32_t>(address(else_commands.data()) >> 32u),
      static_cast<uint32_t>(else_commands.size())};
  std::copy(branch_suffix.begin(), branch_suffix.end(), branch.begin() + 14);
  std::array<uint32_t, 9> caller{};
  const auto call_branch = indirect(branch, false);
  std::copy(call_branch.begin(), call_branch.end(), caller.begin());
  std::copy(caller_suffix.begin(), caller_suffix.end(), caller.begin() + 4);
  for (uint32_t mode : {1u, 2u}) {
    branch[1] = mode | (3u << 8u);
    for (uint64_t value : {0ull, 1ull}) {
      condition = value;
      selected = returned = 0;
      uint32_t expected = 44;
      if (value == 1) {
        expected = 11;
      } else if (mode == 2) {
        expected = 33;
      }
      Pm4Execution execution;
      Require(name, "conditional fetcher replacement",
              processor.Process(execution, caller) == Pm4ProcessResult::Complete &&
                  selected == expected && returned == 22,
              "taken branch resumed its discarded suffix or lost the caller's return");
    }
  }

  // This stream exceeds native recursion capacity, while chains need one fetcher cursor.
  std::vector<std::array<uint32_t, 4>> links(65536);
  std::span<const uint32_t> target = then_commands;
  for (auto &link : links) {
    link = indirect(target, true);
    target = link;
  }
  const auto call_chain = indirect(target, false);
  std::copy(call_chain.begin(), call_chain.end(), caller.begin());
  selected = returned = 0;
  Pm4Execution execution;
  Require(name, "long chain and call return",
          processor.Process(execution, caller) == Pm4ProcessResult::Complete &&
              selected == 11 && returned == 22,
          "long chain did not complete and return to the original caller");
  std::printf("[host]    %-32s ok\n", name);
}

void CheckPm4WaitResume(RenderContext &renderer) {
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);

  uint32_t label = 0;
  uint32_t prefix = 0;
  uint32_t child_observation = UINT32_MAX;
  uint32_t suffix = 0;
  const auto address = [](const void *value) {
    return reinterpret_cast<uint64_t>(value);
  };

  std::array<uint32_t, 12> child{};
  child[0] = KYTY_PM4(5, Pm4::IT_WRITE_DATA, 0);
  child[1] = 0;
  child[2] = static_cast<uint32_t>(address(&child_observation));
  child[3] = static_cast<uint32_t>(address(&child_observation) >> 32u);
  child[4] = 0;
  child[5] = KYTY_PM4(7, Pm4::IT_WAIT_REG_MEM, 0);
  child[6] = 0x10u | 3u;
  child[7] = static_cast<uint32_t>(address(&label));
  child[8] = static_cast<uint32_t>(address(&label) >> 32u);
  child[9] = 1;
  child[10] = UINT32_MAX;

  std::array<uint32_t, 4> nested{};
  nested[0] = KYTY_PM4(4, Pm4::IT_INDIRECT_BUFFER, 0);
  nested[1] = static_cast<uint32_t>(address(child.data()));
  nested[2] = static_cast<uint32_t>(address(child.data()) >> 32u);
  nested[3] = 0x0f300000u | static_cast<uint32_t>(child.size());

  std::array<uint32_t, 14> commands{};
  commands[0] = KYTY_PM4(5, Pm4::IT_WRITE_DATA, 0);
  commands[1] = 0;
  commands[2] = static_cast<uint32_t>(address(&prefix));
  commands[3] = static_cast<uint32_t>(address(&prefix) >> 32u);
  commands[4] = 11;
  commands[5] = KYTY_PM4(4, Pm4::IT_INDIRECT_BUFFER, 0);
  commands[6] = static_cast<uint32_t>(address(nested.data()));
  commands[7] = static_cast<uint32_t>(address(nested.data()) >> 32u);
  commands[8] = 0x0f200000u | static_cast<uint32_t>(nested.size());
  commands[9] = KYTY_PM4(5, Pm4::IT_WRITE_DATA, 0);
  commands[10] = 0;
  commands[11] = static_cast<uint32_t>(address(&suffix));
  commands[12] = static_cast<uint32_t>(address(&suffix) >> 32u);
  commands[13] = 22;

  Pm4Execution execution;
  Require("Pm4WaitResume", "suspend",
          processor.Process(execution, commands) == Pm4ProcessResult::Blocked &&
              prefix == 11 && child_observation == 0 && suffix == 0,
          "blocked indirect wait did not preserve its command position");
  Require("Pm4WaitResume", "still blocked",
          processor.Process(execution, commands) == Pm4ProcessResult::Blocked &&
              !execution.MadeProgress() && suffix == 0,
          "blocked wait advanced or replayed its caller");

  label = 1;
  child[4] = 1;
  Require(
      "Pm4WaitResume", "resume",
      processor.Process(execution, commands) == Pm4ProcessResult::Complete &&
          prefix == 11 && child_observation == 0 && suffix == 22,
      "resumed indirect wait replayed a child or did not finish its parent");
  std::printf("[host]    %-32s ok\n", "Pm4WaitResume");
}

void CheckPm4RewindResume(RenderContext &renderer) {
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);

  uint32_t suffix = 0;
  const auto address = reinterpret_cast<uint64_t>(&suffix);
  std::array<uint32_t, 7> commands{};
  commands[0] = KYTY_PM4(2, Pm4::IT_REWIND, 0);
  commands[1] = 0;
  commands[2] = KYTY_PM4(5, Pm4::IT_WRITE_DATA, 0);
  commands[3] = 0;
  commands[4] = static_cast<uint32_t>(address);
  commands[5] = static_cast<uint32_t>(address >> 32u);
  commands[6] = 33;

  Pm4Execution execution;
  Require("Pm4RewindResume", "pending",
          processor.Process(execution, commands) == Pm4ProcessResult::Blocked &&
              suffix == 0,
          "pending rewind did not preserve its command position");
  Require("Pm4RewindResume", "patch valid",
          Gen5::AgcRewindPatchSetRewindState(commands.data(), 1) == 0 &&
              commands[1] == 0x80000000u,
          "rewind state patch did not set the valid bit");
  Require("Pm4RewindResume", "resume",
          processor.Process(execution, commands) ==
                  Pm4ProcessResult::Complete &&
              suffix == 33,
          "valid rewind did not resume at the following packet");
  std::printf("[host]    %-32s ok\n", "Pm4RewindResume");
}

void CheckPm4CeCompletion(RenderContext &renderer) {
  GraphicsInitJmpTables();
  CommandProcessor processor(renderer, 0);
  uint32_t suffix = 0;
  const auto address = reinterpret_cast<uint64_t>(&suffix);

  std::array<uint32_t, 9> commands{};
  commands[0] = 0xc0008600u;
  commands[1] = 1;
  commands[2] = 0xc0008500u;
  commands[3] = 0;
  commands[4] = KYTY_PM4(5, Pm4::IT_WRITE_DATA, 0);
  commands[5] = 0;
  commands[6] = static_cast<uint32_t>(address);
  commands[7] = static_cast<uint32_t>(address >> 32u);
  commands[8] = 33;

  processor.ResetDeCe();
  Pm4Execution execution;
  Require("Pm4CeCompletion", "wait",
          processor.Process(execution, commands) == Pm4ProcessResult::Blocked &&
              suffix == 0,
          "DE did not wait for an active CE stream");

  std::array<uint32_t, 2> ce_increment{0xc0008400u, 1};
  Pm4Execution ce_execution;
  Require("Pm4CeCompletion", "CE increment",
          processor.Process(ce_execution, ce_increment) ==
              Pm4ProcessResult::Complete,
          "CE counter increment did not complete");
  Require(
      "Pm4CeCompletion", "counter gate",
      processor.Process(execution, commands) == Pm4ProcessResult::Complete &&
          suffix == 33,
      "DE did not resume after CE advanced or failed to increment its counter");

  suffix = 0;
  Pm4Execution balanced_execution;
  Require("Pm4CeCompletion", "balanced wait",
          processor.Process(balanced_execution, commands) ==
                  Pm4ProcessResult::Blocked &&
              suffix == 0,
          "balanced CE/DE counters did not gate the next DE packet");
  processor.SetCeComplete(true);
  Require("Pm4CeCompletion", "stream complete",
          processor.Process(balanced_execution, commands) ==
                  Pm4ProcessResult::Complete &&
              suffix == 33,
          "DE remained blocked after the CE stream completed");
  std::printf("[host]    %-32s ok\n", "Pm4CeCompletion");
}

} // namespace
} // namespace Libs::Graphics

int main(int argc, char **argv) {
  using namespace Libs::Graphics;

  std::setvbuf(stdout, nullptr, _IONBF, 0);
  EnsureConfigInitialized();
  CheckLeastRecentlyUsedCacheOrdering();
  if (argc == 2 && std::strcmp(argv[1], "--packed-integer-neg-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, Vop3pIntegerNegationCapturedAndSelectedHalves());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--dpp-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, VectorDpp8Captured(false));
    RunCase(&vulkan, VectorDpp8Captured(true));
    RunCase(&vulkan, VectorDppQuadPermuteReverse());
    RunCase(&vulkan, VectorDppRowXmask());
    RunCase(&vulkan, VectorDppBankMaskPreservesDestination());
    RunCase(&vulkan, VectorDppBoundsControlZeroPreservesDestination());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--buffer-snorm-store-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, BufferStoreFormatXyzwSnorm16CapturedSkinningVectors());
    RunCase(&vulkan, BufferStoreFormatXSnorm16ClampsRoundsAndPreservesHalfwords());
    RunCase(&vulkan, BufferStoreFormatXResource16UintWritesHalfword());
    RunCase(&vulkan, BufferStoreFormatXResource16UintPreservesAdjacentLanes());
    RunCase(&vulkan, BufferStoreFormatXyResource88UintWritesBytes());
    RunCase(&vulkan, BufferStoreFormatXyzwDropsPartialRecord());
    RunCase(&vulkan, BufferStoreFormatXChecksOnlyTransferredComponent());
    RunCase(&vulkan, BufferFormatStoreVariants());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--s-ashr-i64-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, ScalarAshrI64Edges(false));
    RunCase(&vulkan, ScalarAshrI64Edges(true));
    RunCase(&vulkan, ScalarAshrI64OperandsAndAliases());
    RunCase(&vulkan, ScalarAshrI64Masks(32));
    RunCase(&vulkan, ScalarAshrI64Masks(64));
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--tessellation-only") == 0) {
    CheckTessellationPrograms();
    CheckEmbeddedFetchVertexOffset();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--cmpx-lt-u16-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, VectorVopcCmpxLtU16CapturedSdwaExecMask());
    RunCase(&vulkan, VectorVopcCmpxGtU16CapturedSdwaExecMask());
    RunCase(&vulkan, VectorVopcSdwaCmpxWritesExecMask());
    RunCase(&vulkan, VectorVop3CmpxWritesExecMask());
    RunCase(&vulkan, VectorVopcSdwaCmpxClassF32CapturedExecMask());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--cmp-ngt-f16-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, VectorVopcCmpNgtF16CapturedSdwaAndEdges());
    RunCase(&vulkan, VectorVopcCmpxNgtF16CapturedSdwaExecMask());
    RunCase(&vulkan, VectorCompareF16Ops());
    RunCase(&vulkan, Wave32VccMasksPreserveOtherHalf());
    RunCase(&vulkan, VectorVop3FloatCompareNegSourceModifier());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--cmp-nlt-f16-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, VectorVopcCmpNltF16CapturedSdwaAndEdges());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--fract-f16-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, VectorFractF16CapturedAndEdges());
    RunCase(&vulkan, VectorFractF16Modifiers());
    RunCase(&vulkan, NativeAndSdwa16BitDestinationWrites());
    RunCase(&vulkan, VectorSpecialF16Ops());
    RunCase(&vulkan, VectorCosF16CapturedSdwaAndEdges());
    RunCase(&vulkan, VectorSinF16SdwaAndEdges());
    RunCase(&vulkan, VectorFloatConversionOps());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--packed-texture-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckPackedTextureComponents();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--error-dialog-only") == 0) {
    CheckErrorDialogLifecycle();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--fmask-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, ImageLoadFmaskUsesNativeSampleMapping());
    RunCase(&vulkan, ImageLoadR32UintUsesIntegerSampledImage());
    return 0;
  }
#if KYTY_PLATFORM != KYTY_PLATFORM_WINDOWS
  if (argc == 2 && std::strcmp(argv[1], "--shader-fatal-only") == 0) {
    CheckShaderRecompilerFatalContracts();
    return 0;
  }
#endif
  if (argc == 2 && std::strcmp(argv[1], "--wave64-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, Wave32VccMasksPreserveOtherHalf());
    RunCase(&vulkan, DsBpermuteWave64UsesIndependentHalves());
    RunCase(&vulkan, Wave64CrossHalfLaneAndLds());
    RunCase(&vulkan, Wave64RawMasksAndScalarBranch());
    RunCase(&vulkan, Wave64PartialMultidimensionalWorkgroup());
    RunCase(&vulkan, Wave64AppendConsumeHighHalf());
    RunCase(&vulkan, VectorAddcWritesPerLaneCarryOut());
    RunCase(&vulkan, VectorVop3BCarryOutWritesSgprMask());
    RunCase(&vulkan, VectorVop3BCarryOutUsesEncodedSdst());
    RunCase(&vulkan, DispatcherIrreducibleControlFlow());
    RunCase(&vulkan, ScalarSaveExecOps());
    RunCase(&vulkan, ScalarOrn2SaveexecUsesSourceOrNotExec());
    RunCase(&vulkan, ScalarOrn2SaveexecB32(32, 32));
    RunCase(&vulkan, ScalarOrn2SaveexecB32(64, 64));
    RunCase(&vulkan, ScalarOrn2SaveexecB32(32, 4));
    RunCase(&vulkan, ScalarSubvectorLoops(32));
    RunCase(&vulkan, ScalarSubvectorLoops(64));
    RunCase(&vulkan, ScalarNotB64UpdatesScc());
    RunCase(&vulkan, ScalarSelectB64PreservesMaskProvenance());
    RunCase(&vulkan, ScalarConditionalMoveB64());
    RunCase(&vulkan, ScalarConditionalMoveB64PreservesMasks());
    RunCase(&vulkan, ScalarWqmB64SelectsSccDomain());
    RunCase(&vulkan, ScalarWqmB64PreservesPartialMasks());
    RunCase(&vulkan, ScalarWqmB32Masks(32));
    RunCase(&vulkan, ScalarWqmB32Masks(64));
    RunCase(&vulkan, ScalarMaskProvenanceOverlapAndMixedBinary());
    RunCase(&vulkan, ScratchIsPrivatePerInvocation());
    RunCase(&vulkan, Vop1MoveRelDestination());
    RunCase(&vulkan, BranchVccnzUsesWaveMask());
    RunCase(&vulkan, BranchVccnzUsesCarryProducedWaveMask());
    RunCase(&vulkan, ImageSampleAndGather());
    RunCase(&vulkan, ImageGatherLodApproximatesLevelZero());
    RunCase(&vulkan, SharedReturnKeepsSelectedValues());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--position-w-only") == 0) {
    VulkanHarness vulkan;
    RunGraphicsCase(&vulkan, GraphicsPositionWExport());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--centroid-only") == 0) {
    VulkanHarness vulkan;
    RunGraphicsCase(&vulkan, GraphicsPackedHalfCentroid());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--pixel-alias-only") == 0) {
    CheckPixelParameterAliases();
    CheckRectListShaders();
    VulkanHarness vulkan;
    RunGraphicsCase(&vulkan, GraphicsPackedHalfCentroid());
    RunGraphicsCase(&vulkan, GraphicsPackedHalfInputAlias(false));
    RunGraphicsCase(&vulkan, GraphicsPackedHalfInputAlias(true));
    RunGraphicsCase(&vulkan, GraphicsSmoothRawInputAlias());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--clip-control-only") == 0) {
    CheckClipControlDepthClipState();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--reference-clock-only") == 0) {
    CheckReferenceClockScale();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--scheduler-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckSchedulerTimeline();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--host-image-allocation-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckHostImageAllocation();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--occlusion-dump-only") == 0) {
    VulkanHarness vulkan;
    CheckPm4SyntheticOcclusionCounterDump(vulkan.RuntimeRenderer());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--predication-only") == 0) {
    VulkanHarness vulkan;
    CheckPm4Predication(vulkan.RuntimeRenderer());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--descriptor-heap-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckDescriptorHeapLargeSet();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--push-constant-bank-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckGraphicsPushConstantBank();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--shader-data-storage-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, BufferOffsetsUsePackedLaneAndStorageFallback());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--buffer-cmpswap-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, BufferAtomicCmpSwapExactRaw());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--ds-atomics-only") == 0) {
    VulkanHarness vulkan;
    for (const auto &test : MakeCases()) {
      if (std::string_view(test.name).starts_with("Ds") ||
          std::string_view(test.name).starts_with("BufferAtomic")) {
        RunCase(&vulkan, test);
      }
    }
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--mapped-range-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckGpuMappedRangeLifecycle();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--stream-buffer-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckStreamBufferRing();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--gpu-tiler-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckGpuTilerCpuParity();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--gpu-command-lane-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckGpuCommandLane();
    CheckPm4IndirectControlFlow(vulkan.RuntimeRenderer());
    CheckPm4WaitResume(vulkan.RuntimeRenderer());
    CheckPm4RewindResume(vulkan.RuntimeRenderer());
    CheckPm4CeCompletion(vulkan.RuntimeRenderer());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--alignbyte-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, VectorAlignByteUsesFiveBitByteOffset());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--sdwa-mov-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, Vop1SdwaMovByteDestinations());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--sdwa-ashr-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, Vop2SdwaAshrrevCapturedWord0SignExtends());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--sdwa-addc-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, VectorAddcWritesPerLaneCarryOut());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--cvt-pk-i16-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, Vop3CvtPkI16I32Captured());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--med3-i16-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, Vop3Med3I16Captured());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--mul-lo-u16-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, Vop3MulLoU16CapturedAndSelectors());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--mad-i16-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, Vop3MadI16CapturedSelectorsAndSaturation());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--waitcnt-depctr-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, ScalarWaitcntDepctrCapturedVmVsrc());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--sff1-b64-only") == 0) {
    VulkanHarness vulkan;
    RunCase(&vulkan, ScalarBitfieldPack());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--context-state-only") == 0) {
    VulkanHarness vulkan;
    CheckAgcShaderFusion();
    CheckPm4NativeTargetGeometryRegisters(vulkan.RuntimeRenderer());
    CheckPm4PrivateAgcShaderRegisters(vulkan.RuntimeRenderer());
    CheckPm4PrivateAgcUconfigRegisters(vulkan.RuntimeRenderer());
    CheckPm4BlendColorRegisterRanges(vulkan.RuntimeRenderer());
    CheckPm4PolygonOffsetRegisters(vulkan.RuntimeRenderer());
    CheckPm4DepthControlHighBits(vulkan.RuntimeRenderer());
    CheckPm4DepthRenderOverride(vulkan.RuntimeRenderer());
    CheckPm4ContextStateOperations(vulkan.RuntimeRenderer());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--agc-wait-only") == 0) {
    VulkanHarness vulkan;
    CheckAgcWaitPackets(vulkan.RuntimeRenderer());
    CheckPm4WaitResume(vulkan.RuntimeRenderer());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--agc-draw-multi-only") == 0) {
    VulkanHarness vulkan;
    CheckAgcDrawIndirectMultiPacket(vulkan.RuntimeRenderer());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--rewind-only") == 0) {
    VulkanHarness vulkan;
    CheckPm4RewindResume(vulkan.RuntimeRenderer());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--image-overlap-only") == 0) {
    CheckDepthAttachmentWrites();
    CheckDynamicRenderingState();
    VulkanHarness vulkan;
    vulkan.CheckRasterization(false);
    vulkan.CheckRenderExecutorColorDiscovery();
    vulkan.CheckRenderExecutorColorVolumeDiscovery();
    vulkan.CheckRenderExecutorDccFixedClearFloat();
    vulkan.CheckSampledDccClear();
    vulkan.CheckRenderExecutorColorDepthTileDiscovery();
    vulkan.CheckRenderExecutorStencilBindingDiscovery();
    vulkan.CheckUnifiedTextureCacheFlow();
    vulkan.CheckBgra16Readback();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--draw-offset-only") == 0) {
    CheckEmbeddedFetchVertexOffset();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--polygon-mode-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckRasterization(false);
    vulkan.CheckRasterization(false, true);
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--htile-clear-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckUnifiedTextureCacheFlow();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--dcc-clear-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckRenderExecutorDccFixedClearFloat();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--compute-meta-clear-only") == 0) {
    CheckDynamicRenderingState();
    VulkanHarness vulkan;
    vulkan.CheckComputeMetaClearClassification();
    vulkan.CheckRenderExecutorColorVolumeDiscovery();
    vulkan.CheckRenderExecutorDccFixedClearFloat();
    vulkan.CheckSampledDccClear();
    vulkan.CheckRenderExecutorStencilBindingDiscovery();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--layered-image-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckUnifiedImageViewCache();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--image-view-cache-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckUnifiedImageViewCache();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--storage-sampled-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckUnifiedImageViewCache();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--depth-readback-only") == 0) {
    CheckDepthTargetFootprints();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--buffer-cache-range-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckUnifiedTextureCacheFlow();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--buffer-cache-gc-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckBufferCacheDirtyGarbageCollection();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--sampled-depth-resource-only") == 0) {
    VulkanHarness vulkan;
    CheckSampledDepthResource();
    CheckDepthTextureEncoding();
    vulkan.CheckComparisonDepthTexture();
    vulkan.CheckRasterization(true);
    RunCase(nullptr, ImageSampleA16CompareBiasRdna2AddressOrder());
    return 0;
  }
#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
  if (argc == 2 && std::strcmp(argv[1], "--reverse-rt-death") == 0) {
    RunReverseRenderTargetDeathCase();
  }
  if (argc == 2 && std::strcmp(argv[1], "--reverse-rt-only") == 0) {
    CheckRenderTargetFormatContract();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--standard64-rt-only") == 0) {
    CheckStandard64RenderTargetTileRoundTrip();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--standard-tile-rt-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckRenderExecutorColorStandardTileDiscovery();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--image-view-only") == 0) {
    VulkanHarness vulkan;
    CheckSampledColorViews();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--image-transition-only") == 0) {
    VulkanHarness vulkan;
    CheckImageTransitionState(vulkan.RuntimeRenderer());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--storage-bgra-only") == 0) {
    CheckSampledColorViews();
    CheckBasicStorageTextureDescriptor();
    VulkanHarness vulkan;
    vulkan.CheckUnifiedImageViewCache();
    RunCase(&vulkan, ImageStoreBgraUsesInverseSwizzle());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--indirect-image-only") == 0) {
    CheckImageSamplerSpecialization();
    CheckIndirectImageKeySwitch();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--storage-mip-host-only") == 0) {
    VulkanHarness vulkan;
    vulkan.CheckRenderExecutorStencilBindingDiscovery();
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--storage-mip-only") == 0) {
    RunCase(nullptr, ImageStoreMipSelectsPpsa01340Descriptor());
    return 0;
  }
  if (argc == 2 && std::strcmp(argv[1], "--storage-yzwx-only") == 0) {
    CheckSampledColorViews();
    CheckBasicStorageTextureDescriptor();
    CheckStorageTextureGpuOwnedRebindState();
    VulkanHarness vulkan;
    RunCase(&vulkan, ImageStoreYzwxUsesInverseSwizzle());
    return 0;
  }
  if (argc == 3 && std::strcmp(argv[1], "--image-view-death") == 0) {
    RunImageViewDeathCase(argv[2]);
  }
  if (argc == 3 &&
      std::strcmp(argv[1], "--storage-texture-descriptor-death") == 0) {
    RunStorageTextureDescriptorDeathCase(argv[2]);
  }
  if (argc != 1) {
    std::fprintf(stderr, "unknown test selector: %s\n", argv[1]);
    return 2;
  }
  VulkanHarness vulkan;
  CheckRenderTargetFormatContract();
  CheckSampledColorViews();
  CheckImageTransitionState(vulkan.RuntimeRenderer());
  CheckSampledDepthResource();
  CheckDepthTextureEncoding();
  vulkan.CheckComparisonDepthTexture();
  vulkan.CheckRasterization(true);
  CheckBasicStorageTextureDescriptor();
  CheckStorageTextureLinearUploadLayout();
  CheckStorageTextureDepthTileUploadLayout();
  CheckStandard64RenderTargetTileRoundTrip();
  CheckStorageTextureVolumeUploadLayout();
  CheckStorageTextureVolumeMipRegions();
  CheckStorageTextureGpuOwnedRebindState();
  CheckNativeMsaaState();
  CheckPs5DepthRegisterDecoding();
  CheckDepthHtileStencilCompatibility();
  CheckDepthAttachmentWrites();
  CheckDynamicRenderingState();
  CheckDepthTargetFootprints();
  CheckSlotVectorLifetime();
#else
  if (argc != 1) {
    std::fprintf(stderr, "unknown test selector: %s\n", argv[1]);
    return 2;
  }
  CheckShaderRecompilerFatalContracts();
  VulkanHarness vulkan;
#endif
  CheckImageSamplerSpecialization();
  CheckNativeImageDescriptorTypes();
  CheckClipControlDepthClipState();
  CheckReferenceClockScale();
  CheckErrorDialogLifecycle();
  CheckVulkan13FeatureRequirements();
  CheckPm4AcquireMemNoOp(vulkan.RuntimeRenderer());
  CheckPm4SyntheticOcclusionCounterDump(vulkan.RuntimeRenderer());
  CheckPm4Predication(vulkan.RuntimeRenderer());
  CheckPm4StencilInfoValueLane(vulkan.RuntimeRenderer());
  CheckPm4NativeTargetGeometryRegisters(vulkan.RuntimeRenderer());
  CheckPm4PrivateAgcShaderRegisters(vulkan.RuntimeRenderer());
  CheckPm4PrivateAgcUconfigRegisters(vulkan.RuntimeRenderer());
  CheckPm4DirectShaderRegisterFallback(vulkan.RuntimeRenderer());
  CheckPm4GuardBandRegisterRanges(vulkan.RuntimeRenderer());
  CheckPm4BlendColorRegisterRanges(vulkan.RuntimeRenderer());
  CheckPm4PolygonOffsetRegisters(vulkan.RuntimeRenderer());
  CheckPm4DepthControlHighBits(vulkan.RuntimeRenderer());
  CheckPm4DepthRenderOverride(vulkan.RuntimeRenderer());
  CheckAgcShaderFusion();
  CheckAgcWaitPackets(vulkan.RuntimeRenderer());
  CheckAgcDrawIndirectMultiPacket(vulkan.RuntimeRenderer());
  CheckPm4ContextStateOperations(vulkan.RuntimeRenderer());
  CheckPm4IndirectControlFlow(vulkan.RuntimeRenderer());
  CheckPm4WaitResume(vulkan.RuntimeRenderer());
  CheckPm4RewindResume(vulkan.RuntimeRenderer());
  CheckPm4CeCompletion(vulkan.RuntimeRenderer());
  CheckEmbeddedFetchVertexOffset();
  CheckEmbeddedFetchLaneSpill();
  CheckTessellationPrograms();
  CheckPixelParameterAliases();
  CheckRectListShaders();
  CheckIndirectImageKeySwitch();
  CheckPs5GameExampleImageClearRuntimeShape();
  vulkan.CheckSchedulerTimeline();
  vulkan.CheckHostImageAllocation();
  vulkan.CheckDescriptorHeapLargeSet();
  vulkan.CheckGraphicsPushConstantBank();
  vulkan.CheckGpuMappedRangeLifecycle();
  vulkan.CheckStreamBufferRing();
  vulkan.CheckGpuTilerCpuParity();
#if KYTY_PLATFORM == KYTY_PLATFORM_WINDOWS
  vulkan.CheckRenderExecutorColorDiscovery();
  vulkan.CheckRenderExecutorColorVolumeDiscovery();
  vulkan.CheckRenderExecutorDccFixedClearFloat();
  vulkan.CheckSampledDccClear();
  vulkan.CheckRenderExecutorColorStandardTileDiscovery();
  vulkan.CheckRenderExecutorColorDepthTileDiscovery();
  vulkan.CheckRenderExecutorStencilBindingDiscovery();
  vulkan.CheckUnifiedTextureCacheFlow();
  vulkan.CheckBgra16Readback();
  vulkan.CheckRasterization(false);
  vulkan.CheckRasterization(false, true);
  vulkan.CheckBufferCacheDirtyGarbageCollection();
#endif
  vulkan.CheckUnifiedImageViewCache();
  vulkan.CheckPackedTextureComponents();
  const auto tests = MakeCases();
  const auto graphics_tests = MakeGraphicsCases();
  CheckOpcodeCoverage(tests, graphics_tests);
  for (const auto &test : tests) {
    RunCase(&vulkan, test);
  }
  for (const auto &test : graphics_tests) {
    RunGraphicsCase(&vulkan, test);
  }
  vulkan.CheckGpuCommandLane();
  std::printf("ShaderRecompilerComputeTests: all cases passed\n");
  return 0;
}