tests: More Descriptor Buffer examples

spencer-lunarg · spencer-lunarg · commit fee7b2b4a926 · 2025-07-11T17:45:56.000-04:00
diff --git a/layers/core_checks/cc_buffer_address.h b/layers/core_checks/cc_buffer_address.h
@@ -22,6 +22,7 @@
 
 #include <array>
 #include <functional>
+#include <sstream>
 #include <string>
 #include <string_view>
 
@@ -75,25 +76,25 @@ class BufferAddressValidation {
     [[nodiscard]] bool HasInvalidBuffer(vvl::span<vvl::Buffer* const> buffer_list) const noexcept;
     // For every vuid, build an error mentioning every buffer from buffer_list that violates it, then log this error
     // using details provided by the other parameters.
-    [[nodiscard]] bool LogInvalidBuffers(const CoreChecks& checker, vvl::span<vvl::Buffer* const> buffer_list,
+    [[nodiscard]] bool LogInvalidBuffers(const CoreChecks& validator, vvl::span<vvl::Buffer* const> buffer_list,
                                          const Location& device_address_loc, const LogObjectList& objlist,
                                          VkDeviceAddress device_address) const noexcept;
 
-    [[nodiscard]] bool LogErrorsIfNoValidBuffer(const CoreChecks& checker, vvl::span<vvl::Buffer* const> buffer_list,
+    [[nodiscard]] bool LogErrorsIfNoValidBuffer(const CoreChecks& validator, vvl::span<vvl::Buffer* const> buffer_list,
                                                 const Location& device_address_loc, const LogObjectList& objlist,
                                                 VkDeviceAddress device_address) const noexcept {
         bool skip = false;
         if (!HasValidBuffer(buffer_list)) {
-            skip |= LogInvalidBuffers(checker, buffer_list, device_address_loc, objlist, device_address);
+            skip |= LogInvalidBuffers(validator, buffer_list, device_address_loc, objlist, device_address);
         }
         return skip;
     }
-    [[nodiscard]] bool LogErrorsIfInvalidBufferFound(const CoreChecks& checker, vvl::span<vvl::Buffer* const> buffer_list,
+    [[nodiscard]] bool LogErrorsIfInvalidBufferFound(const CoreChecks& validator, vvl::span<vvl::Buffer* const> buffer_list,
                                                      const Location& device_address_loc, const LogObjectList& objlist,
                                                      VkDeviceAddress device_address) const noexcept {
         bool skip = false;
         if (HasInvalidBuffer(buffer_list)) {
-            skip |= LogInvalidBuffers(checker, buffer_list, device_address_loc, objlist, device_address);
+            skip |= LogInvalidBuffers(validator, buffer_list, device_address_loc, objlist, device_address);
         }
         return skip;
     }
@@ -175,7 +176,7 @@ bool BufferAddressValidation<ChecksCount>::HasInvalidBuffer(vvl::span<vvl::Buffe
 }
 
 template <size_t ChecksCount>
-bool BufferAddressValidation<ChecksCount>::LogInvalidBuffers(const CoreChecks& checker, vvl::span<vvl::Buffer* const> buffer_list,
+bool BufferAddressValidation<ChecksCount>::LogInvalidBuffers(const CoreChecks& validator, vvl::span<vvl::Buffer* const> buffer_list,
                                                              const Location& device_address_loc, const LogObjectList& objlist,
                                                              VkDeviceAddress device_address) const noexcept {
     std::array<Error, ChecksCount> errors;
@@ -190,9 +191,7 @@ bool BufferAddressValidation<ChecksCount>::LogInvalidBuffers(const CoreChecks& c
         }();
         error_msg_beginning += "(";
         error_msg_beginning += address_string;
-        error_msg_beginning +=
-            ") has no buffer(s) associated to it such that valid usage passes. "
-            "At least one buffer associated to this device address must be valid.\n";
+        error_msg_beginning += ") has no buffer(s) associated that are valid.\n";
     }
 
     // For each buffer, and for each violated VUID, build an error message
@@ -223,7 +222,8 @@ bool BufferAddressValidation<ChecksCount>::LogInvalidBuffers(const CoreChecks& c
                     error_msg += '\n';
                 }
 
-                error_msg += checker.FormatHandle(buffer->Handle());
+                error_msg += "  ";  // small indent help to visualize
+                error_msg += validator.FormatHandle(buffer->Handle());
                 error_msg += ": ";
                 error_msg += buffer_error;
             }
@@ -236,10 +236,19 @@ bool BufferAddressValidation<ChecksCount>::LogInvalidBuffers(const CoreChecks& c
         const auto& vuidAndValidation = vuidsAndValidationFunctions[i];
         const auto& error = errors[i];
         if (!error.Empty()) {
-            skip |=
-                checker.LogError(vuidAndValidation.vuid.data(), error.objlist, device_address_loc, "%s\n", error.error_msg.c_str());
+            skip |= validator.LogError(vuidAndValidation.vuid.data(), error.objlist, device_address_loc, "%s\n",
+                                       error.error_msg.c_str());
         }
     }
 
     return skip;
 }
+
+[[maybe_unused]] static std::string PrintBufferRanges(const CoreChecks& validator, vvl::span<vvl::Buffer* const> buffers) {
+    std::ostringstream ss;
+    for (const auto& buffer : buffers) {
+        ss << "  " << validator.FormatHandle(buffer->Handle()) << " : range " << string_range_hex(buffer->DeviceAddressRange())
+           << '\n';
+    }
+    return ss.str();
+}
diff --git a/layers/core_checks/cc_descriptor.cpp b/layers/core_checks/cc_descriptor.cpp
@@ -23,6 +23,7 @@
 #include <sstream>
 #include <valarray>
 
+#include "containers/range.h"
 #include "core_validation.h"
 #include "error_message/error_location.h"
 #include "error_message/logging.h"
@@ -2432,15 +2433,18 @@ bool CoreChecks::ValidateCmdSetDescriptorBufferOffsets(const vvl::CommandBuffer
         }
 
         if (!valid_binding) {
+            const vvl::range<VkDeviceAddress> access_range = {start + offset, start + offset + set_layout_size};
             const char *vuid = is_2 ? "VUID-VkSetDescriptorBufferOffsetsInfoEXT-pOffsets-08063"
                                     : "VUID-vkCmdSetDescriptorBufferOffsetsEXT-pOffsets-08063";
             const LogObjectList objlist(cb_state.Handle(), set_layout->Handle(), pipeline_layout->Handle());
             skip |=
                 LogError(vuid, objlist, loc.dot(Field::pBufferIndices, i),
                          "(%" PRIu32 ") points to descriptor buffer at VkDescriptorBufferBindingInfoEXT::address (0x%" PRIxLEAST64
                          ") and the pOffsets[%" PRIu32 "] (%" PRIu64 ") with a VkDescriptorSetLayout size %" PRIu64
-                         " is not within any VkBuffer range",
-                         buffer_index, start, i, offset, set_layout_size);
+                         " is not within any VkBuffer range.\nThe invalid access is at %s\nThe following are the possible buffer "
+                         "ranges it could be at:\n%s",
+                         buffer_index, start, i, offset, set_layout_size, vvl::string_range_hex(access_range).c_str(),
+                         PrintBufferRanges(*this, buffer_states).c_str());
         }
     }
 
@@ -2603,8 +2607,8 @@ bool CoreChecks::PreCallValidateCmdBindDescriptorBuffersEXT(VkCommandBuffer comm
                      return true;
                  },
                  [buffer_usage, i]() {
-                     return "The following buffers have a usage that does not match pBindingInfos[" + std::to_string(i) +
-                            "].usage (" + string_VkBufferUsageFlags2(buffer_usage) + "):";
+                     return "pBindingInfos[" + std::to_string(i) + "].usage is " + string_VkBufferUsageFlags2(buffer_usage) +
+                            " but none of the following buffers contain it:";
                  }},
 
                 {"VUID-VkDescriptorBufferBindingInfoEXT-usage-08122",
diff --git a/tests/framework/descriptor_helper.cpp b/tests/framework/descriptor_helper.cpp
@@ -11,6 +11,8 @@
  */
 
 #include "descriptor_helper.h"
+#include <vulkan/utility/vk_struct_helper.hpp>
+#include "binding.h"
 
 OneOffDescriptorSet::OneOffDescriptorSet(vkt::Device *device, const std::vector<VkDescriptorSetLayoutBinding> &bindings,
                                          VkDescriptorSetLayoutCreateFlags layout_flags, void *layout_pnext,
@@ -196,3 +198,53 @@ void OneOffDescriptorSet::UpdateDescriptorSets() {
     }
     vk::UpdateDescriptorSets(device_->handle(), descriptor_writes.size(), descriptor_writes.data(), 0, NULL);
 }
+
+namespace vkt {
+DescriptorGetInfo::DescriptorGetInfo(VkSampler *sampler) {
+    get_info.type = VK_DESCRIPTOR_TYPE_SAMPLER;
+    get_info.data.pSampler = sampler;
+}
+
+DescriptorGetInfo::DescriptorGetInfo(VkDeviceAddress address) {
+    get_info.type = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR;
+    get_info.data.accelerationStructure = address;
+}
+
+DescriptorGetInfo::DescriptorGetInfo(VkDescriptorType type, VkSampler sampler, VkImageView image_view, VkImageLayout image_layout) {
+    image_info = {sampler, image_view, image_layout};
+    get_info.type = type;
+    if (type == VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER) {
+        get_info.data.pCombinedImageSampler = &image_info;
+    } else if (type == VK_DESCRIPTOR_TYPE_INPUT_ATTACHMENT) {
+        get_info.data.pInputAttachmentImage = &image_info;
+    } else if (type == VK_DESCRIPTOR_TYPE_SAMPLED_IMAGE) {
+        get_info.data.pSampledImage = &image_info;
+    } else if (type == VK_DESCRIPTOR_TYPE_STORAGE_IMAGE) {
+        get_info.data.pStorageImage = &image_info;
+    } else {
+        assert(false);
+    }
+}
+
+DescriptorGetInfo::DescriptorGetInfo(VkDescriptorType type, VkDeviceAddress address, VkDeviceSize range, VkFormat format) {
+    address_info = vku::InitStructHelper();
+    address_info.address = address;
+    address_info.range = range;
+    address_info.format = format;
+    get_info.type = type;
+    if (type == VK_DESCRIPTOR_TYPE_UNIFORM_TEXEL_BUFFER) {
+        get_info.data.pUniformTexelBuffer = &address_info;
+    } else if (type == VK_DESCRIPTOR_TYPE_STORAGE_TEXEL_BUFFER) {
+        get_info.data.pStorageTexelBuffer = &address_info;
+    } else if (type == VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER) {
+        get_info.data.pUniformBuffer = &address_info;
+    } else if (type == VK_DESCRIPTOR_TYPE_STORAGE_BUFFER) {
+        get_info.data.pStorageBuffer = &address_info;
+    } else {
+        assert(false);
+    }
+}
+
+DescriptorGetInfo::DescriptorGetInfo(VkDescriptorType type, const vkt::Buffer &buffer, VkDeviceSize range, VkFormat format)
+    : DescriptorGetInfo(type, buffer.Address(), range, format) {}
+}  // namespace vkt
diff --git a/tests/framework/descriptor_helper.h b/tests/framework/descriptor_helper.h
@@ -12,6 +12,8 @@
 
 #pragma once
 
+#include <vulkan/vulkan_core.h>
+#include <vulkan/utility/vk_struct_helper.hpp>
 #include "layer_validation_tests.h"
 
 class OneOffDescriptorSet {
@@ -78,4 +80,25 @@ class OneOffDescriptorIndexingSet : public OneOffDescriptorSet {
 
     OneOffDescriptorIndexingSet(vkt::Device *device, const Bindings &bindings, void *allocate_pnext = nullptr,
                                 void *create_pool_pnext = nullptr);
-};
+};
+
+namespace vkt {
+class Buffer;
+
+// VK_EXT_descriptor_buffer
+struct DescriptorGetInfo {
+    explicit DescriptorGetInfo(VkSampler *sampler);       // VK_DESCRIPTOR_TYPE_SAMPLER
+    explicit DescriptorGetInfo(VkDeviceAddress address);  // VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR
+    DescriptorGetInfo(VkDescriptorType type, VkSampler sampler, VkImageView image_view, VkImageLayout image_layout);
+    DescriptorGetInfo(VkDescriptorType type, VkDeviceAddress address, VkDeviceSize range, VkFormat format = VK_FORMAT_UNDEFINED);
+    DescriptorGetInfo(VkDescriptorType type, const vkt::Buffer &buffer, VkDeviceSize range, VkFormat format = VK_FORMAT_UNDEFINED);
+
+    VkDescriptorGetInfoEXT get_info = vku::InitStructHelper();
+    VkSampler sampler_handle;
+    VkDescriptorImageInfo image_info;
+    VkDescriptorAddressInfoEXT address_info;
+
+    operator VkDescriptorGetInfoEXT *() { return &get_info; }
+};
+
+}  // namespace vkt
diff --git a/tests/unit/descriptor_buffer_positive.cpp b/tests/unit/descriptor_buffer_positive.cpp
