Bind acceleration structures and enable the InlineRT tests

Wire up acceleration-structure descriptor binding end-to-end across
all three backends so shaders can actually consume the TLAS that
buildPipelineAccelerationStructures produced — completing the stack
and promoting the three InlineRT tests from XFAIL to passing.

Vulkan: createDescriptorPool counts AS descriptors in a separate
scalar (the KHR enum value 1000150000 doesn't fit in the indexed
array used for the core types) and emits one VkDescriptorPoolSize
for them. createDescriptorSets resolves each AS resource via
Resource::TLASPtr, locates the matching VulkanAccelerationStructure
in InvocationState::AccelStructs (BLASes-then-TLASes layout, matching
the helper's documented declaration order), and writes the handle
through a VkWriteDescriptorSetAccelerationStructureKHR chained on the
descriptor write's pNext. The dispatch's pre-barrier dst access now
includes VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR so the prior
AS-build's writes are made visible to the shader's RayQuery reads.
Device creation also enables VK_KHR_ray_query when supported so the
RayQuery shader instructions actually function.

DX12: writes a D3D12_SRV_DIMENSION_RAYTRACING_ACCELERATION_STRUCTURE
SRV with the AS GPU virtual address as Location into the heap slot
that createBuffers reserved (CreateShaderResourceView with a null
resource — the AS data lives in the buffer pointed to by Location).

Metal: the Metal shader converter doesn't bind the AS directly; the
shader reads a buffer containing an IRRaytracingAccelerationStructure-
GPUHeader that holds the AS's gpuResourceID plus a pointer to an
instance-contributions array. createBuffers allocates and fills both
buffers per AS-descriptor entry, then points the descriptor at the
header buffer's GPU address. The TLAS itself is built with the UserID
instance-descriptor variant so HLSL CommittedInstanceID() returns the
YAML-specified per-instance ID instead of the array index.

The three InlineRT tests now actually exercise the AS end-to-end:
TraceRayInline issues a RayQuery against `Scene` and writes a
hit-dependent value into `Output` (the instance ID for multi-instance,
1/0 otherwise). The catch-all `XFAIL: *` is dropped; `XFAIL: Clang`
remains. The test shaders gain explicit `[[vk::binding]]` annotations
since their `t0`/`u0` registers would otherwise collide under the
default dxc HLSL→SPIR-V mapping.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: MarijnS95

lib/API/DX/Device.cpp

@@ -2169,6 +2169,12 @@ class DXDevice : public offloadtest::Device {
         [&IS,
          this](Resource &R,
                llvm::SmallVectorImpl<ResourcePair> &Resources) -> llvm::Error {
+      // Acceleration structures are created separately; descriptor binding for
+      // AS resources is wired up in the per-table binding loop below.
+      if (R.isAccelerationStructure()) {
+        Resources.push_back(std::make_pair(&R, ResourceBundle{}));
+        return llvm::Error::success();
+      }
       switch (getDescriptorKind(R.Kind)) {
       case DescriptorKind::SRV: {
         auto ExRes = createSRV(R, IS);
@@ -2209,8 +2215,36 @@ class DXDevice : public offloadtest::Device {
 
     // Bind descriptors in descriptor tables.
     uint32_t HeapIndex = 0;
+    const uint32_t DescIncSize = Device->GetDescriptorHandleIncrementSize(
+        D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV);
     for (auto &T : IS.DescTables) {
       for (auto &R : T.Resources) {
+        if (R.first->isAccelerationStructure()) {
+          assert(R.first->TLASPtr && "AS resource must be resolved to a TLAS");
+          assert(R.first->getArraySize() == 1 && "AS arrays not yet supported");
+          // OutAS layout from buildPipelineAccelerationStructures: BLASes
+          // first, then TLASes — both in P.AccelStructs declaration order.
+          const size_t TLASIdx = R.first->TLASPtr - &P.AccelStructs.TLAS[0];
+          const size_t ASIdx = P.AccelStructs.BLAS.size() + TLASIdx;
+          auto *DXAS =
+              llvm::cast<DXAccelerationStructure>(IS.AccelStructs[ASIdx].get());
+          D3D12_SHADER_RESOURCE_VIEW_DESC SRVDesc = {};
+          SRVDesc.Format = DXGI_FORMAT_UNKNOWN;
+          SRVDesc.ViewDimension =
+              D3D12_SRV_DIMENSION_RAYTRACING_ACCELERATION_STRUCTURE;
+          SRVDesc.Shader4ComponentMapping =
+              D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING;
+          SRVDesc.RaytracingAccelerationStructure.Location =
+              DXAS->getGPUVirtualAddress();
+          D3D12_CPU_DESCRIPTOR_HANDLE Handle =
+              IS.DescHeap->GetCPUDescriptorHandleForHeapStart();
+          Handle.ptr += HeapIndex * DescIncSize;
+          // AS SRVs are created with a null resource; the AS lives in the
+          // buffer referenced by Location.
+          Device->CreateShaderResourceView(nullptr, &SRVDesc, Handle);
+          HeapIndex += R.first->getArraySize();
+          continue;
+        }
         switch (getDescriptorKind(R.first->Kind)) {
         case DescriptorKind::SRV:
           HeapIndex = bindSRV(*(R.first), IS, HeapIndex, R.second);

lib/API/MTL/MTLDevice.cpp

@@ -17,6 +17,9 @@
 #define IR_PRIVATE_IMPLEMENTATION
 #include "metal_irconverter.h"
 #include "metal_irconverter_runtime.h"
+// ir_raytracing.h depends on types defined in metal_irconverter_runtime.h —
+// keep this include in its own block so clang-format won't sort it above.
+#include "ir_raytracing.h"
 
 #include "API/Device.h"
 #include "API/Encoder.h"
@@ -962,6 +965,10 @@ class MTLDevice : public offloadtest::Device {
         AccelStructs;
     // Vertex/index buffers consumed during AS builds; must outlive submission.
     llvm::SmallVector<std::unique_ptr<offloadtest::Buffer>> ASInputBuffers;
+    // Per-AS-descriptor header + instance-contribution buffers backing inline
+    // RT bindings; must be resident on the dispatch encoder so the shader can
+    // read the header.
+    llvm::SmallVector<MTL::Buffer *> ASDescriptorBuffers;
   };
 
   llvm::Error createRootSignature(
@@ -1301,6 +1308,12 @@ class MTLDevice : public offloadtest::Device {
         [&IS,
          this](Resource &R,
                llvm::SmallVectorImpl<ResourcePair> &Resources) -> llvm::Error {
+      // Acceleration structures are created separately; descriptor binding for
+      // AS resources is wired up in the per-table binding loop below.
+      if (R.isAccelerationStructure()) {
+        Resources.emplace_back(&R, ResourceBundle{});
+        return llvm::Error::success();
+      }
       switch (getDescriptorKind(R.Kind)) {
       case DescriptorKind::SRV: {
         auto ExRes = createSRV(R, IS);
@@ -1343,6 +1356,51 @@ class MTLDevice : public offloadtest::Device {
     uint32_t HeapIndex = 0;
     for (auto &T : IS.DescTables) {
       for (auto &R : T.Resources) {
+        if (R.first->isAccelerationStructure()) {
+          assert(R.first->TLASPtr && "AS resource must be resolved to a TLAS");
+          assert(R.first->getArraySize() == 1 && "AS arrays not yet supported");
+          // OutAS layout from buildPipelineAccelerationStructures:
+          // BLASes first, then TLASes — both in declaration order.
+          const size_t TLASIdx = R.first->TLASPtr - &P.AccelStructs.TLAS[0];
+          const size_t ASIdx = P.AccelStructs.BLAS.size() + TLASIdx;
+          auto *MTLAS = llvm::cast<MetalAccelerationStructure>(
+              IS.AccelStructs[ASIdx].get());
+
+          // Metal shader converter doesn't bind the AS directly; the shader
+          // reads a buffer containing an IRRaytracingAccelerationStructureGPU-
+          // Header that holds the AS's gpuResourceID plus a pointer to an
+          // instance-contributions array (one uint32 per instance, supplying
+          // the equivalent of D3D12's InstanceContributionToHitGroupIndex).
+          // Build both buffers here and point the descriptor entry at the
+          // header buffer's GPU address.
+          const uint32_t InstCount =
+              static_cast<uint32_t>(R.first->TLASPtr->Instances.size());
+          llvm::SmallVector<uint32_t> Contributions(InstCount, 0);
+          MTL::Buffer *ContribBuf = Device->newBuffer(
+              Contributions.data(), InstCount * sizeof(uint32_t),
+              MTL::ResourceStorageModeShared);
+          MTL::Buffer *HeaderBuf = Device->newBuffer(
+              sizeof(IRRaytracingAccelerationStructureGPUHeader),
+              MTL::ResourceStorageModeShared);
+          IRRaytracingSetAccelerationStructure(
+              static_cast<uint8_t *>(HeaderBuf->contents()),
+              MTLAS->AccelStruct->gpuResourceID(),
+              static_cast<uint8_t *>(ContribBuf->contents()),
+              ContribBuf->gpuAddress(), Contributions.data(), InstCount);
+          IS.CB->KeepAliveMTLBuffers.push_back(HeaderBuf);
+          IS.CB->KeepAliveMTLBuffers.push_back(ContribBuf);
+          // Only the header is read by the shader (via the descriptor's gpuVA).
+          // The contribution buffer is read indirectly via the header's
+          // addressOfInstanceContributions pointer, so both must be resident
+          // during dispatch.
+          IS.ASDescriptorBuffers.push_back(HeaderBuf);
+          IS.ASDescriptorBuffers.push_back(ContribBuf);
+
+          IRDescriptorTableSetAccelerationStructure(
+              IS.DescHeap->getEntryHandle(HeapIndex), HeaderBuf->gpuAddress());
+          HeapIndex += R.first->getArraySize();
+          continue;
+        }
         switch (getDescriptorKind(R.first->Kind)) {
         case DescriptorKind::SRV:
           HeapIndex = bindSRV(*(R.first), IS, HeapIndex, R.second);
@@ -1402,6 +1460,12 @@ class MTLDevice : public offloadtest::Device {
           NativeEncoder->useResource(ResSet.Resource.get(),
                                      MTL::ResourceUsageRead |
                                          MTL::ResourceUsageWrite);
+    for (auto &AS : IS.AccelStructs) {
+      auto *MTLAS = llvm::cast<MetalAccelerationStructure>(AS.get());
+      NativeEncoder->useResource(MTLAS->AccelStruct, MTL::ResourceUsageRead);
+    }
+    for (MTL::Buffer *B : IS.ASDescriptorBuffers)
+      NativeEncoder->useResource(B, MTL::ResourceUsageRead);
 
     if (auto Err = Encoder.dispatch(*IS.Pipeline.get(),
                                     P.DispatchParameters.DispatchGroupCount[0],
@@ -1534,6 +1598,9 @@ class MTLDevice : public offloadtest::Device {
   llvm::Error copyBack(Pipeline &P, InvocationState &IS) {
     auto MemCpyBack = [](ResourcePair &Pair) -> llvm::Error {
       const Resource &R = *Pair.first;
+      // AS resources don't have CPU-side readback data.
+      if (R.isAccelerationStructure())
+        return llvm::Error::success();
       if (!R.isReadWrite())
         return llvm::Error::success();
 
@@ -2122,6 +2189,11 @@ class MTLDevice : public offloadtest::Device {
     auto *Descriptor =
         MTL::InstanceAccelerationStructureDescriptor::alloc()->init();
     Descriptor->setInstanceCount(Instances.size());
+    // UserID descriptor type so per-instance InstanceID survives the
+    // build and is returned by HLSL CommittedInstanceID()/InstanceIndex()
+    // semantics on the shader side.
+    Descriptor->setInstanceDescriptorType(
+        MTL::AccelerationStructureInstanceDescriptorTypeUserID);
 
     MTL::AccelerationStructureSizes Sizes =
         Device->accelerationStructureSizes(Descriptor);
@@ -2436,19 +2508,20 @@ llvm::Error MTLComputeEncoder::batchBuildAS(llvm::ArrayRef<ASBuildItem> Items) {
         InstanceASIdx.push_back(Idx);
       }
 
-      // Pack instance descriptors. Layout differs from VK/DX12: 32-byte
-      // entries with an index instead of a GPU address.
+      // Pack instance descriptors. Layout differs from VK/DX12: indexed
+      // BLAS references with an extra userID slot so HLSL InstanceID()
+      // survives across the build.
       const size_t InstByteSize =
           TLAS->Instances.size() *
-          sizeof(MTL::AccelerationStructureInstanceDescriptor);
+          sizeof(MTL::AccelerationStructureUserIDInstanceDescriptor);
       MTL::Buffer *InstBuf =
           MTLDev->newBuffer(InstByteSize, MTL::ResourceStorageModeShared);
       if (!InstBuf)
         return llvm::createStringError(
             std::errc::not_enough_memory,
             "Failed to allocate TLAS instance buffer.");
       auto *InstPtr =
-          static_cast<MTL::AccelerationStructureInstanceDescriptor *>(
+          static_cast<MTL::AccelerationStructureUserIDInstanceDescriptor *>(
               InstBuf->contents());
       for (size_t I = 0; I < TLAS->Instances.size(); ++I) {
         const auto &Src = TLAS->Instances[I];
@@ -2462,12 +2535,15 @@ llvm::Error MTLComputeEncoder::batchBuildAS(llvm::ArrayRef<ASBuildItem> Items) {
         D.mask = Src.InstanceMask;
         D.intersectionFunctionTableOffset = 0;
         D.accelerationStructureIndex = InstanceASIdx[I];
+        D.userID = Src.InstanceID;
       }
       CB->KeepAliveMTLBuffers.push_back(InstBuf);
 
       auto *ID = MTL::InstanceAccelerationStructureDescriptor::alloc()->init();
       ID->setInstanceDescriptorBuffer(InstBuf);
       ID->setInstanceCount(TLAS->Instances.size());
+      ID->setInstanceDescriptorType(
+          MTL::AccelerationStructureInstanceDescriptorTypeUserID);
       NS::Array *BLASArr = NS::Array::array(
           reinterpret_cast<NS::Object *const *>(UniqueBLASes.data()),
           UniqueBLASes.size());

lib/API/VK/Device.cpp

@@ -837,8 +837,11 @@ class VKComputeEncoder : public offloadtest::ComputeEncoder {
                        uint32_t GroupCountX, uint32_t GroupCountY,
                        uint32_t GroupCountZ) override {
     const auto &VKPSO = llvm::cast<VulkanPipelineState>(PSO);
+    // Include AS_READ so dispatches that issue RayQuery against a TLAS get a
+    // proper hand-off from the prior AS-build's AS_WRITE.
     addDstBarrier(VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT,
-                  VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT);
+                  VK_ACCESS_SHADER_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT |
+                      VK_ACCESS_ACCELERATION_STRUCTURE_READ_BIT_KHR);
     insertDebugSignpost(llvm::formatv("Dispatch [{0},{1},{2}]", GroupCountX,
                                       GroupCountY, GroupCountZ)
                             .str());
@@ -1390,12 +1393,16 @@ class VulkanDevice : public offloadtest::Device {
         (HasVulkan12 ||
          isExtensionSupported(AvailableDeviceExtensions,
                               VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME));
+    const bool HasRayQueryExt =
+        HasASExts && isExtensionSupported(AvailableDeviceExtensions,
+                                          VK_KHR_RAY_QUERY_EXTENSION_NAME);
 
     VkPhysicalDeviceAccelerationStructureFeaturesKHR ASFeatures{};
     // On Vulkan 1.1 we need a separate BDA features struct; on 1.2+
     // bufferDeviceAddress lives in VkPhysicalDeviceVulkan12Features which is
     // already in the chain, and adding a duplicate is a validation error.
     VkPhysicalDeviceBufferDeviceAddressFeatures BDAFeatures{};
+    VkPhysicalDeviceRayQueryFeaturesKHR RayQueryFeatures{};
     if (HasASExts) {
       ASFeatures.sType =
           VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ACCELERATION_STRUCTURE_FEATURES_KHR;
@@ -1407,6 +1414,12 @@ class VulkanDevice : public offloadtest::Device {
         BDAFeatures.pNext = Features.pNext;
         Features.pNext = &BDAFeatures;
       }
+      if (HasRayQueryExt) {
+        RayQueryFeatures.sType =
+            VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_QUERY_FEATURES_KHR;
+        RayQueryFeatures.pNext = Features.pNext;
+        Features.pNext = &RayQueryFeatures;
+      }
     }
 
     vkGetPhysicalDeviceFeatures2(PhysicalDevice, &Features);
@@ -1479,6 +1492,14 @@ class VulkanDevice : public offloadtest::Device {
       if (!HasVulkan12)
         EnabledDeviceExtensions.push_back(
             VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME);
+      if (HasRayQueryExt) {
+        if (!RayQueryFeatures.rayQuery)
+          return llvm::createStringError(
+              std::errc::not_supported,
+              "Device advertises %s but reports rayQuery=0",
+              VK_KHR_RAY_QUERY_EXTENSION_NAME);
+        EnabledDeviceExtensions.push_back(VK_KHR_RAY_QUERY_EXTENSION_NAME);
+      }
     }
 
     DeviceInfo.enabledExtensionCount =
@@ -3009,6 +3030,14 @@ class VulkanDevice : public offloadtest::Device {
   }
 
   llvm::Error createResource(Resource &R, InvocationState &IS) {
+    // Acceleration structures are created separately; push a placeholder so
+    // the resource index stays in sync with the descriptor set layout.
+    if (R.isAccelerationStructure()) {
+      const ResourceBundle Bundle{getDescriptorType(R.Kind), 0, nullptr};
+      IS.Resources.push_back(Bundle);
+      return llvm::Error::success();
+    }
+
     // Samplers don't have backing data buffers, so handle them separately
     if (R.isSampler()) {
       ResourceBundle Bundle{getDescriptorType(R.Kind), 0, nullptr};
@@ -3170,8 +3199,15 @@ class VulkanDevice : public offloadtest::Device {
     constexpr size_t DescriptorTypesSize =
         sizeof(DescriptorTypes) / sizeof(VkDescriptorType);
     uint32_t DescriptorCounts[DescriptorTypesSize] = {0};
+    // VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR has an out-of-range enum
+    // value (1000150000), so it can't share the indexed array above.
+    uint32_t ASDescriptorCount = 0;
     for (const auto &S : P.Sets) {
       for (const auto &R : S.Resources) {
+        if (R.isAccelerationStructure()) {
+          ASDescriptorCount += R.getArraySize();
+          continue;
+        }
         DescriptorCounts[getDescriptorType(R.Kind)] += R.getArraySize();
         if (R.HasCounter)
           DescriptorCounts[VK_DESCRIPTOR_TYPE_STORAGE_BUFFER] +=
@@ -3189,6 +3225,12 @@ class VulkanDevice : public offloadtest::Device {
         PoolSizes.push_back(PoolSize);
       }
     }
+    if (ASDescriptorCount > 0) {
+      llvm::outs() << "Descriptors: { type = ACCELERATION_STRUCTURE_KHR"
+                   << ", count = " << ASDescriptorCount << " }\n";
+      PoolSizes.push_back(
+          {VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR, ASDescriptorCount});
+    }
 
     if (P.Sets.size() > 0) {
       VkDescriptorPoolCreateInfo PoolCreateInfo = {};
@@ -3232,8 +3274,15 @@ class VulkanDevice : public offloadtest::Device {
     uint32_t ImageInfoCount = 0;
     uint32_t BufferInfoCount = 0;
     uint32_t BufferViewCount = 0;
+    uint32_t ASInfoCount = 0;
+    uint32_t ASHandleCount = 0;
     for (auto &D : P.Sets) {
       for (auto &R : D.Resources) {
+        if (R.isAccelerationStructure()) {
+          ASInfoCount += 1;
+          ASHandleCount += R.getArraySize();
+          continue;
+        }
         if (R.isSampler()) {
           ImageInfoCount += 1;
           continue;
@@ -3255,20 +3304,54 @@ class VulkanDevice : public offloadtest::Device {
     llvm::SmallVector<VkDescriptorImageInfo> ImageInfos;
     llvm::SmallVector<VkDescriptorBufferInfo> BufferInfos;
     llvm::SmallVector<VkBufferView> BufferViews;
+    llvm::SmallVector<VkWriteDescriptorSetAccelerationStructureKHR> ASInfos;
+    llvm::SmallVector<VkAccelerationStructureKHR> ASHandles;
     ImageInfos.reserve(ImageInfoCount);
     BufferInfos.reserve(BufferInfoCount);
     BufferViews.reserve(BufferViewCount);
+    ASInfos.reserve(ASInfoCount);
+    ASHandles.reserve(ASHandleCount);
 
     llvm::SmallVector<VkWriteDescriptorSet> WriteDescriptors;
     WriteDescriptors.reserve(ImageInfoCount + BufferInfoCount +
-                             BufferViewCount);
+                             BufferViewCount + ASInfoCount);
     assert(IS.BufferViews.empty());
 
     uint32_t OverallResIdx = 0;
     for (uint32_t SetIdx = 0; SetIdx < P.Sets.size(); ++SetIdx) {
       for (uint32_t RIdx = 0; RIdx < P.Sets[SetIdx].Resources.size();
            ++RIdx, ++OverallResIdx) {
         const Resource &R = P.Sets[SetIdx].Resources[RIdx];
+        if (R.isAccelerationStructure()) {
+          assert(R.TLASPtr && "AS resource must be resolved to a TLAS");
+          assert(R.getArraySize() == 1 && "AS arrays not yet supported");
+          // OutAS layout from buildPipelineAccelerationStructures: BLASes
+          // first, then TLASes — both in P.AccelStructs declaration order.
+          const size_t TLASIdx = R.TLASPtr - &P.AccelStructs.TLAS[0];
+          const size_t ASIdx = P.AccelStructs.BLAS.size() + TLASIdx;
+          auto *VkAS = llvm::cast<VulkanAccelerationStructure>(
+              IS.AccelStructs[ASIdx].get());
+          const size_t HandleStart = ASHandles.size();
+          ASHandles.push_back(VkAS->AccelStruct);
+          VkWriteDescriptorSetAccelerationStructureKHR ASWrite = {};
+          ASWrite.sType =
+              VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_ACCELERATION_STRUCTURE_KHR;
+          ASWrite.accelerationStructureCount = 1;
+          ASWrite.pAccelerationStructures = &ASHandles[HandleStart];
+          ASInfos.push_back(ASWrite);
+
+          VkWriteDescriptorSet WDS = {};
+          WDS.sType = VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET;
+          WDS.pNext = &ASInfos.back();
+          WDS.dstSet = IS.DescriptorSets[SetIdx];
+          WDS.dstBinding = R.VKBinding->Binding;
+          WDS.descriptorCount = 1;
+          WDS.descriptorType = VK_DESCRIPTOR_TYPE_ACCELERATION_STRUCTURE_KHR;
+          llvm::outs() << "Updating AS Descriptor [" << OverallResIdx << "] { "
+                       << SetIdx << ", " << RIdx << " }\n";
+          WriteDescriptors.push_back(WDS);
+          continue;
+        }
         uint32_t IndexOfFirstBufferDataInArray;
         if (R.isSampler()) {
           IndexOfFirstBufferDataInArray = ImageInfos.size();