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

@@ -2251,12 +2251,33 @@ 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) {
-        // AS descriptor binding lands in the AS-bind commit; this loop runs
-        // its dedicated path then continues. Advance HeapIndex so subsequent
-        // resources land in the slots the shader's root signature expects.
         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;
         }

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(
@@ -1349,10 +1356,48 @@ class MTLDevice : public offloadtest::Device {
     uint32_t HeapIndex = 0;
     for (auto &T : IS.DescTables) {
       for (auto &R : T.Resources) {
-        // AS descriptor binding lands in the AS-bind commit; this loop runs
-        // its dedicated path then continues. Advance HeapIndex so subsequent
-        // resources land in the slots the shader's argument buffer expects.
         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;
         }
@@ -1415,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],
@@ -2144,6 +2195,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);
@@ -2458,19 +2514,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];
@@ -2484,12 +2541,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

@@ -849,8 +849,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());
@@ -1396,12 +1399,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;
@@ -1413,6 +1420,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);
@@ -1485,6 +1498,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 =
@@ -3184,11 +3205,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) {
-        // TODO: AS descriptors need a separate pool size entry.
-        if (R.isAccelerationStructure())
+        if (R.isAccelerationStructure()) {
+          ASDescriptorCount += R.getArraySize();
           continue;
+        }
         DescriptorCounts[getDescriptorType(R.Kind)] += R.getArraySize();
         if (R.HasCounter)
           DescriptorCounts[VK_DESCRIPTOR_TYPE_STORAGE_BUFFER] +=
@@ -3206,6 +3231,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 = {};
@@ -3249,11 +3280,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) {
-        // TODO: Count AS descriptors when binding is implemented.
-        if (R.isAccelerationStructure())
+        if (R.isAccelerationStructure()) {
+          ASInfoCount += 1;
+          ASHandleCount += R.getArraySize();
           continue;
+        }
         if (R.isSampler()) {
           ImageInfoCount += 1;
           continue;
@@ -3275,23 +3310,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];
-        // TODO: Write AS descriptors when binding is implemented.
-        if (R.isAccelerationStructure())
+        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();

test/Feature/InlineRT/indexed-triangle-setup.test

@@ -1,12 +1,19 @@
 #--- source.hlsl
 
-RaytracingAccelerationStructure Scene : register(t0);
-RWStructuredBuffer<uint> Output : register(u0);
+[[vk::binding(0, 0)]] RaytracingAccelerationStructure Scene : register(t0);
+[[vk::binding(1, 0)]] RWStructuredBuffer<uint> Output : register(u0);
 
 [numthreads(1,1,1)]
 void main() {
-  // Placeholder: will use TraceRayInline when available
-  Output[0] = 1;
+  RayDesc Ray;
+  Ray.Origin = float3(0, 0, 1);
+  Ray.Direction = float3(0, 0, -1);
+  Ray.TMin = 0.0;
+  Ray.TMax = 100.0;
+  RayQuery<RAY_FLAG_NONE> Q;
+  Q.TraceRayInline(Scene, RAY_FLAG_NONE, 0xFF, Ray);
+  Q.Proceed();
+  Output[0] = Q.CommittedStatus() == COMMITTED_TRIANGLE_HIT ? 1 : 0;
 }
 //--- pipeline.yaml
 ---
@@ -76,9 +83,6 @@ Results:
 # REQUIRES: acceleration-structure
 # XFAIL: Clang
 
-# Unimplemented: https://github.com/llvm/offload-test-suite/issues/1158
-# XFAIL: *
-
 # RUN: split-file %s %t
 # RUN: %dxc_target -T cs_6_5 -Fo %t.o %t/source.hlsl
 # RUN: %offloader %t/pipeline.yaml %t.o