Fix descriptor heap acceleration structure loads (#11209)

Fixes #10671

## Summary

Fixes #10671 — `DescriptorHandle<RaytracingAccelerationStructure>` with
`spvDescriptorHeapEXT` produced invalid SPIR-V (missing
`OpConvertUToAccelerationStructureKHR`), causing `VK_ERROR_DEVICE_LOST`
at runtime.

- **SPIR-V emitter**: add `emitAccelerationStructureFromDescriptorHeap`
that emits `OpUntypedAccessChainKHR` + `OpLoad` +
`OpConvertUToAccelerationStructureKHR` when loading a
`RaytracingAccelerationStructure` from a descriptor heap. Route
`kIROp_SPIRVLoadDescriptorFromHeap` instructions to this path when the
(unwrapped) data type is `kIROp_RaytracingAccelerationStructureType`.
- **Capability/extension**: use
`requireSPIRVAnyCapability({RayTracingKHR, RayQueryKHR})` and
`ensureAnyExtensionDeclaration({"SPV_KHR_ray_tracing",
"SPV_KHR_ray_query"})` to match how the AS type itself is declared,
supporting both ray-tracing and ray-query targets.
- **render-test**: guard `assignAccelerationStructure` — when the cursor
expects a descriptor handle type, return `SLANG_E_NOT_AVAILABLE` if the
acceleration structure is null (device doesn't support ray tracing), and
propagate `getDescriptorHandle` failure rather than silently falling
back to `setBinding`.
- **Regression test**:
`tests/spirv/descriptor-heap-acceleration-structure.slang` verifies the
correct SPIR-V sequence is emitted.

## Test plan

- [ ] `slang-test
tests/spirv/descriptor-heap-acceleration-structure.slang` passes
- [ ] CI passes on SPIR-V targets

## Labels

pr: non-breaking

Author: jkwak-work

docs/user-guide/03-convenience-features.md

@@ -661,10 +661,12 @@ void test()
 
 When targeting SPIR-V, Slang can generate two flavors of code for descriptor handles depending on whether
 the `spvDescriptorHeapEXT` capability is declared or requested on the compilation request.
-By default (without requesting `spvDescriptorHeapEXT`), Slang introduces a global array of descriptors and
-fetches from the global array.
-The descriptor set ID of the global descriptor array can be configured with the `-bindless-space-index`
-(or `CompilerOptionName::BindlessSpaceIndex` when using the API) option.
+
+### Default Slang Behavior
+
+Without requesting `spvDescriptorHeapEXT`, Slang introduces a global array of descriptors and fetches
+from it. The descriptor set ID of the global descriptor array can be configured with the
+`-bindless-space-index` (or `CompilerOptionName::BindlessSpaceIndex` when using the API) option.
 
 Default behavior assigns binding indices based on descriptor types:
 
@@ -682,13 +684,32 @@ Default behavior assigns binding indices based on descriptor types:
 
 > `ACCELERATION_STRUCTURE` is excluded from the list of types since Slang by default uses the handle to a `RaytracingAccelerationStructure` as a GPU address, casting the handle to a `RaytracingAccelerationStructure`. This removes the need for a binding-slot of `RaytracingAccelerationStructure`.
 
-When the `spvDescriptorHeapEXT` capability is requested (either via the `-capability` command-line option or via the compilation API), Slang will map descriptor handles to the `SPV_EXT_descriptor_heap` extension
-without declaring any explicit descriptor sets. Descriptor handles are still lowered to `uint2`.
-For resources other than `CombinedTextureSampler`, Slang uses `uint2.x` as the index to access the global sampler or resource heap.
-For `CombinedTextureSampler` handles, Slang uses `uint2.x` to index into the resource heap to obtain the texture, and `uint2.y` to index into the sampler
-heap to obtain the sampler state, and combines the objects with an `OpSampledImage` instruction. By default, when using the `spvDescriptorHeapEXT` capability, Slang will reinterpret the resource or sampler heap as an array of requested resource type, whose stride is defined by the resource type, obtained from `OpConstantSizeOfEXT` instruction. The user can override this behavior and specify a different stride with the `-spirv-resource-heap-stride` or `-spirv-sampler-heap-stride` compiler options.
+### SPIR-V with `spvDescriptorHeapEXT`
 
-Additionally, if none of the above behaviors are desired, users can customize the conversion logic from descriptor handle to resource objects by providing a `getDescriptorFromHandle` in user code. For example:
+When the `spvDescriptorHeapEXT` capability is requested (either via the `-capability` command-line option
+or via the compilation API), Slang maps descriptor handles to the `SPV_EXT_descriptor_heap` extension
+without declaring any explicit descriptor sets. Descriptor handles are still lowered to `uint2`.
+For resources other than `CombinedTextureSampler`, Slang uses `uint2.x` as the index to access the global
+sampler or resource heap. For `CombinedTextureSampler` handles, Slang uses `uint2.x` to index into the
+resource heap to obtain the texture, and `uint2.y` to index into the sampler heap to obtain the sampler
+state, and combines the objects with an `OpSampledImage` instruction.
+
+By default, when using the `spvDescriptorHeapEXT` capability, Slang reinterprets the resource or sampler
+heap as an array of the requested resource type, whose stride is defined by the resource type and obtained
+from the `OpConstantSizeOfEXT` instruction. The user can override this behavior and specify a different
+stride with the `-spirv-resource-heap-stride` or `-spirv-sampler-heap-stride` compiler options.
+
+> **Note on `RaytracingAccelerationStructure`:** When the `spvDescriptorHeapEXT` capability is active and
+> a `DescriptorHandle<RaytracingAccelerationStructure>` is dereferenced, Slang loads a 64-bit device address
+> from the descriptor heap and converts it to an acceleration structure handle via
+> `OpConvertUToAccelerationStructureKHR`. This matches how GPU drivers expose acceleration structure
+> descriptors in the heap (as device addresses), and requires either the `SPV_KHR_ray_tracing` or
+> `SPV_KHR_ray_query` extension.
+
+### Custom Descriptor Fetch
+
+If none of the above behaviors are desired, users can customize the conversion logic from descriptor handle
+to resource objects by providing a `getDescriptorFromHandle` in user code. For example:
 
 ```slang
 // All texture and buffer handles are defined in descriptor set 100.

source/slang/slang-emit-spirv.cpp

@@ -4917,6 +4917,16 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex
         case kIROp_SPIRVLoadDescriptorFromHeap:
             {
                 auto loadDesc = as<IRSPIRVLoadDescriptorFromHeap>(inst);
+                if (unwrapAttributedType(inst->getDataType())->getOp() ==
+                    kIROp_RaytracingAccelerationStructureType)
+                {
+                    result = emitAccelerationStructureFromDescriptorHeap(
+                        parent,
+                        inst,
+                        loadDesc->getHeap(),
+                        loadDesc->getIndex());
+                    break;
+                }
                 result =
                     emitDescriptorHeapLoad(parent, inst, loadDesc->getHeap(), loadDesc->getIndex());
                 break;
@@ -7114,6 +7124,38 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex
         return getDescriptorRuntimeArrayType(descriptorElementType);
     }
 
+    SpvInst* emitAccelerationStructureFromDescriptorHeap(
+        SpvInstParent* parent,
+        IRInst* inst,
+        IRInst* heap,
+        IRInst* index)
+    {
+        requireSPIRVAnyCapability({SpvCapabilityRayTracingKHR, SpvCapabilityRayQueryKHR});
+        ensureAnyExtensionDeclaration(
+            {UnownedStringSlice("SPV_KHR_ray_tracing"), UnownedStringSlice("SPV_KHR_ray_query")});
+
+        IRBuilder builder(m_irModule);
+        builder.setInsertInto(m_irModule->getModuleInst());
+        auto addressType = builder.getUInt64Type();
+        auto valuePtr = emitInst(
+            parent,
+            nullptr,
+            SpvOpUntypedAccessChainKHR,
+            ensureUntypedPointerType(SpvStorageClassUniformConstant),
+            kResultID,
+            getDescriptorHeapBaseType(as<IRType>(unwrapAttributedType(inst->getDataType()))),
+            heap,
+            index);
+        auto address = emitOpLoad(parent, nullptr, addressType, valuePtr);
+        return emitInst(
+            parent,
+            inst,
+            SpvOpConvertUToAccelerationStructureKHR,
+            inst->getDataType(),
+            kResultID,
+            address);
+    }
+
     SpvInst* emitDescriptorHeapLoad(
         SpvInstParent* parent,
         IRInst* inst,

tests/spirv/descriptor-heap-acceleration-structure-raygen.slang

@@ -0,0 +1,43 @@
+// Companion to descriptor-heap-acceleration-structure.slang.
+// Exercises the RayTracingKHR branch of requireSPIRVAnyCapability when
+// loading a RaytracingAccelerationStructure from a descriptor heap in a
+// raygeneration shader (which already requires SpvCapabilityRayTracingKHR).
+//TEST:SIMPLE(filecheck=CHECK): -target spirv-asm -stage raygeneration -entry rayGenMain -profile sm_6_6 -capability spvDescriptorHeapEXT -spirv-resource-heap-stride 32
+
+struct PushConstants
+{
+    DescriptorHandle<RaytracingAccelerationStructure> accelerationStructure;
+    DescriptorHandle<RWTexture2D<float4>> outputTexture;
+}
+
+struct RayPayload
+{
+    float t;
+}
+
+[shader("raygeneration")]
+void rayGenMain(uniform PushConstants pushConstants)
+{
+    // CHECK-DAG: %[[U64:[A-Za-z0-9_]+]] = OpTypeInt 64 0
+    // CHECK-DAG: %[[AS_TYPE:[A-Za-z0-9_]+]] = OpTypeAccelerationStructureKHR
+    // CHECK-DAG: %[[AS_HEAP_ARRAY:[A-Za-z0-9_]+]] = OpTypeRuntimeArray %[[AS_TYPE]]
+    // CHECK-DAG: OpDecorate %[[AS_HEAP_ARRAY]] ArrayStride 32
+    // CHECK-DAG: OpCapability RayTracingKHR
+    // CHECK: OpUntypedAccessChainKHR %_ptr_UniformConstant %[[AS_HEAP_ARRAY]] %slang_resourceHeap
+    // CHECK-NEXT: %[[AS_ADDR:[A-Za-z0-9_]+]] = OpLoad %[[U64]]
+    // CHECK-NEXT: OpConvertUToAccelerationStructureKHR %[[AS_TYPE]] %[[AS_ADDR]]
+    // CHECK: OpTraceRayKHR
+    RaytracingAccelerationStructure scene =
+        RaytracingAccelerationStructure(pushConstants.accelerationStructure);
+
+    RayPayload payload = { 0.0 };
+    RayDesc ray;
+    ray.Origin = float3(0.1, 0.1, 0.0);
+    ray.TMin = 0.01f;
+    ray.Direction = float3(0.0, 0.0, 1.0);
+    ray.TMax = 1e4f;
+    TraceRay(scene, RAY_FLAG_NONE, 0xff, 0, 1, 0, ray, payload);
+
+    RWTexture2D<float4> outputTexture = pushConstants.outputTexture;
+    outputTexture[uint2(0, 0)] = float4(payload.t, 0, 0, 1);
+}

tests/spirv/descriptor-heap-acceleration-structure.slang

@@ -0,0 +1,58 @@
+// Regression test for GitHub issue #10671.
+//TEST:SIMPLE(filecheck=CHECK): -target spirv-asm -stage compute -entry computeMain -profile sm_6_6 -capability spvDescriptorHeapEXT -capability spvRayQueryKHR -spirv-resource-heap-stride 32
+
+struct PushConstants
+{
+    DescriptorHandle<RaytracingAccelerationStructure> accelerationStructure;
+    DescriptorHandle<RWTexture2D<float4>> outputTexture;
+}
+
+bool traceRayClosestHit(
+    RaytracingAccelerationStructure scene,
+    float3 rayOrigin,
+    float3 rayDirection,
+    out float t)
+{
+    RayDesc ray;
+    ray.Origin = rayOrigin;
+    ray.TMin = 0.01f;
+    ray.Direction = rayDirection;
+    ray.TMax = 1e4f;
+
+    RayQuery<RAY_FLAG_NONE> rayQuery;
+    rayQuery.TraceRayInline(scene, RAY_FLAG_NONE, 0xff, ray);
+    rayQuery.Proceed();
+
+    if (rayQuery.CommittedStatus() == COMMITTED_TRIANGLE_HIT)
+    {
+        t = rayQuery.CommittedRayT();
+        return true;
+    }
+
+    unused(t);
+    return false;
+}
+
+[shader("compute")]
+[numthreads(1, 1, 1)]
+void computeMain(uint3 dispatchThreadID: SV_DispatchThreadID, uniform PushConstants pushConstants)
+{
+    // CHECK-DAG: %[[U64:[A-Za-z0-9_]+]] = OpTypeInt 64 0
+    // CHECK-DAG: %[[AS_TYPE:[A-Za-z0-9_]+]] = OpTypeAccelerationStructureKHR
+    // CHECK-DAG: %[[AS_HEAP_ARRAY:[A-Za-z0-9_]+]] = OpTypeRuntimeArray %[[AS_TYPE]]
+    // CHECK-DAG: OpDecorate %[[AS_HEAP_ARRAY]] ArrayStride 32
+    // CHECK-DAG: OpCapability RayQueryKHR
+    // CHECK: OpUntypedAccessChainKHR %_ptr_UniformConstant %[[AS_HEAP_ARRAY]] %slang_resourceHeap
+    // CHECK-NEXT: %[[AS_ADDR:[A-Za-z0-9_]+]] = OpLoad %[[U64]]
+    // CHECK-NEXT: OpConvertUToAccelerationStructureKHR %[[AS_TYPE]] %[[AS_ADDR]]
+    // CHECK: OpRayQueryInitializeKHR
+    float t = 0.0;
+    traceRayClosestHit(
+        RaytracingAccelerationStructure(pushConstants.accelerationStructure),
+        float3(0.1, 0.1, 0.0),
+        float3(0.0, 0.0, 1.0),
+        t);
+
+    RWTexture2D<float4> outputTexture = pushConstants.outputTexture;
+    outputTexture[dispatchThreadID.xy] = t;
+}

tools/render-test/render-test-main.cpp

@@ -862,6 +862,17 @@ struct AssignValsFromLayoutContext
         ShaderCursor const& dstCursor,
         ShaderInputLayout::AccelerationStructureVal* srcVal)
     {
+        SLANG_UNUSED(srcVal);
+        if (isDescriptorHandleType(dstCursor))
+        {
+            if (!accelerationStructure)
+                return SLANG_E_NOT_AVAILABLE;
+            DescriptorHandle handle;
+            SLANG_RETURN_ON_FAIL(accelerationStructure->getDescriptorHandle(&handle));
+            SLANG_RETURN_ON_FAIL(dstCursor.setDescriptorHandle(handle));
+            return SLANG_OK;
+        }
+
         dstCursor.setBinding(accelerationStructure);
         return SLANG_OK;
     }