Reflect SPV_EXT_descriptor_heap heap accesses per entry point

Parses the SPV_EXT_descriptor_heap and SPV_KHR_untyped_pointers opcodes
that Slang and DXC emit for bindless descriptor-heap access, and
surfaces the result per entry point as two new arrays on
SpvReflectEntryPoint:

  resource_heap_accesses[] -- one entry per distinct
      (heap variable, OpTypeRuntimeArray) pair reached from the entry
      point's static call graph, classified into a Vulkan descriptor
      type (sampled image, storage image, uniform/storage texel buffer,
      uniform/storage buffer, acceleration structure).
  sampler_heap_accesses[] -- same shape for the sampler heap.

Each entry records the heap variable name, the runtime-array type id,
the array stride (UINT32_MAX when the stride is supplied at runtime via
OpConstantSizeOfEXT rather than as a literal), the descriptor type, and
a pointer to the concrete struct type description when the slot is a
StructuredBuffer/ConstantBuffer reinterpreted through OpBufferPointerEXT.

Parser additions in spirv_reflect.c:
  - OpUntypedVariableKHR with the ResourceHeapEXT / SamplerHeapEXT
    builtins is recognised as a heap-root variable.
  - OpUntypedAccessChainKHR rooted at one of those variables is the
    point of access; result ids are now captured so downstream opcodes
    can match against them.
  - OpTypeBufferEXT is a recognised type whose StorageClass operand
    drives uniform-buffer vs storage-buffer descriptor classification.
  - OpBufferPointerEXT is followed at the access site to recover the
    concrete struct type used when the heap slot is the opaque buffer
    descriptor placeholder.
  - OpConstantSizeOfEXT no longer poisons the constant table; its
    driver-supplied value is treated as unknown.
  - ArrayStrideIdEXT resolves its constant operand to a literal stride
    when the operand is OpConstant, falling back to UINT32_MAX when it
    is OpConstantSizeOfEXT.

YAML emission in common/output_stream.cpp grows an
entry_point_heap_accesses block to expose the new arrays.

Out of scope for this change: per-resource enumeration of which heap
indices are touched, OpUntypedImageTexelPointerEXT, OpMemberDecorateIdEXT,
OffsetIdEXT, and a Pointer-style follow-up of OpUntypedAccessChainKHR
through the existing access-chain machinery.

Companion test fixtures and golden YAMLs are added in the parent PR.

Author: chaoticbob

common/output_stream.cpp

@@ -1666,6 +1666,72 @@ void WriteReflection(const spv_reflect::ShaderModule& obj, bool flatten_cbuffers
       }
     }
   }
+
+  // SPV_EXT_descriptor_heap accesses (per entry point).
+  {
+    const SpvReflectShaderModule& sm = obj.GetShaderModule();
+    uint32_t total_resource_accesses = 0;
+    uint32_t total_sampler_accesses = 0;
+    for (uint32_t ep = 0; ep < sm.entry_point_count; ++ep) {
+      total_resource_accesses += sm.entry_points[ep].resource_heap_access_count;
+      total_sampler_accesses += sm.entry_points[ep].sampler_heap_access_count;
+    }
+    auto print_stride = [&](uint32_t stride) {
+      os << stride;
+      if (stride == UINT32_MAX) {
+        os << " (implicit)";
+      }
+    };
+    if (total_resource_accesses > 0) {
+      os << "\n";
+      os << "\n";
+      os << "\n";
+      os << t << "Resource heap accesses: " << total_resource_accesses << "\n\n";
+      uint32_t flat_idx = 0;
+      for (uint32_t ep = 0; ep < sm.entry_point_count; ++ep) {
+        const auto& e = sm.entry_points[ep];
+        for (uint32_t i = 0; i < e.resource_heap_access_count; ++i) {
+          const auto& a = e.resource_heap_accesses[i];
+          os << tt << flat_idx << ":\n";
+          os << ttt << "entry                 : " << (e.name ? e.name : "") << "\n";
+          os << ttt << "heap_name             : " << (a.heap_name ? a.heap_name : "") << "\n";
+          os << ttt << "descriptor_type       : " << ToStringDescriptorType(a.descriptor_type) << "\n";
+          os << ttt << "stride                : ";
+          print_stride(a.stride);
+          os << "\n";
+          os << ttt << "runtime_array_type_id : " << a.runtime_array_type_id << "\n";
+          if (flat_idx < total_resource_accesses - 1) {
+            os << "\n";
+          }
+          ++flat_idx;
+        }
+      }
+    }
+    if (total_sampler_accesses > 0) {
+      os << "\n";
+      os << "\n";
+      os << "\n";
+      os << t << "Sampler heap accesses: " << total_sampler_accesses << "\n\n";
+      uint32_t flat_idx = 0;
+      for (uint32_t ep = 0; ep < sm.entry_point_count; ++ep) {
+        const auto& e = sm.entry_points[ep];
+        for (uint32_t i = 0; i < e.sampler_heap_access_count; ++i) {
+          const auto& a = e.sampler_heap_accesses[i];
+          os << tt << flat_idx << ":\n";
+          os << ttt << "entry                 : " << (e.name ? e.name : "") << "\n";
+          os << ttt << "heap_name             : " << (a.heap_name ? a.heap_name : "") << "\n";
+          os << ttt << "stride                : ";
+          print_stride(a.stride);
+          os << "\n";
+          os << ttt << "runtime_array_type_id : " << a.runtime_array_type_id << "\n";
+          if (flat_idx < total_sampler_accesses - 1) {
+            os << "\n";
+          }
+          ++flat_idx;
+        }
+      }
+    }
+  }
 }
 
 //////////////////////////////////
@@ -2217,6 +2283,23 @@ void SpvReflectToYaml::Write(std::ostream& os) {
     for (uint32_t i = 0; i < sm_.output_variable_count; ++i) {
       WriteInterfaceVariableTypes(os, *sm_.output_variables[i], indent_level + 1);
     }
+    // SPV_EXT_descriptor_heap: register the descriptor element type for every
+    // distinct heap access so it gets an anchor in all_type_descriptions.
+    for (uint32_t ep = 0; ep < sm_.entry_point_count; ++ep) {
+      const SpvReflectEntryPoint& e = sm_.entry_points[ep];
+      for (uint32_t i = 0; i < e.resource_heap_access_count; ++i) {
+        const auto* td = e.resource_heap_accesses[i].type_description;
+        if (td && type_description_to_index_.find(td) == type_description_to_index_.end()) {
+          WriteTypeDescription(os, *td, indent_level + 1);
+        }
+      }
+      for (uint32_t i = 0; i < e.sampler_heap_access_count; ++i) {
+        const auto* td = e.sampler_heap_accesses[i].type_description;
+        if (td && type_description_to_index_.find(td) == type_description_to_index_.end()) {
+          WriteTypeDescription(os, *td, indent_level + 1);
+        }
+      }
+    }
   }
 
   block_variable_to_index_.clear();
@@ -2328,6 +2411,42 @@ void SpvReflectToYaml::Write(std::ostream& os) {
     os << t3 << "  constant_id: " << sm_.spec_constants[i].constant_id << std::endl;
   }
 
+  // SPV_EXT_descriptor_heap: per-entry-point distinct heap access patterns.
+  os << "entry_point_heap_accesses:" << std::endl;
+  for (uint32_t ep = 0; ep < sm_.entry_point_count; ++ep) {
+    const SpvReflectEntryPoint& e = sm_.entry_points[ep];
+    os << t1 << "- entry: " << SafeString(e.name) << std::endl;
+    os << t1 << "  resource_heap_access_count: " << e.resource_heap_access_count << std::endl;
+    os << t1 << "  resource_heap_accesses:" << std::endl;
+    for (uint32_t i = 0; i < e.resource_heap_access_count; ++i) {
+      const SpvReflectEntryPointResourceHeapAccess& a = e.resource_heap_accesses[i];
+      os << t3 << "- heap_name: " << SafeString(a.heap_name) << std::endl;
+      os << t3 << "  runtime_array_type_id: " << a.runtime_array_type_id << std::endl;
+      os << t3 << "  stride: " << a.stride << std::endl;
+      os << t3 << "  descriptor_type: " << a.descriptor_type << " # " << ToStringDescriptorType(a.descriptor_type) << std::endl;
+      if (a.type_description != nullptr) {
+        auto itor = type_description_to_index_.find(a.type_description);
+        if (itor != type_description_to_index_.end()) {
+          os << t3 << "  type_description: *td" << itor->second << std::endl;
+        }
+      }
+    }
+    os << t1 << "  sampler_heap_access_count: " << e.sampler_heap_access_count << std::endl;
+    os << t1 << "  sampler_heap_accesses:" << std::endl;
+    for (uint32_t i = 0; i < e.sampler_heap_access_count; ++i) {
+      const SpvReflectEntryPointSamplerHeapAccess& a = e.sampler_heap_accesses[i];
+      os << t3 << "- heap_name: " << SafeString(a.heap_name) << std::endl;
+      os << t3 << "  runtime_array_type_id: " << a.runtime_array_type_id << std::endl;
+      os << t3 << "  stride: " << a.stride << std::endl;
+      if (a.type_description != nullptr) {
+        auto itor = type_description_to_index_.find(a.type_description);
+        if (itor != type_description_to_index_.end()) {
+          os << t3 << "  type_description: *td" << itor->second << std::endl;
+        }
+      }
+    }
+  }
+
   if (verbosity_ >= 2) {
     // struct Internal {
     os << t1 << "_internal:" << std::endl;