Use uint64 AS descriptor heap stride (#11494)

Fixes #11231

## Motivation

`DescriptorHandle<RaytracingAccelerationStructure>` descriptor-heap
loads are materialized as 64-bit device-address loads followed by
`OpConvertUToAccelerationStructureKHR`. The AS-specific load path is
selected before the ordinary descriptor heap load at
`source/slang/slang-emit-spirv.cpp:4920`, and
`emitAccelerationStructureFromDescriptorHeap` emits the access chain,
`uint64` load, and conversion at
`source/slang/slang-emit-spirv.cpp:7206`,
`source/slang/slang-emit-spirv.cpp:7215`, and
`source/slang/slang-emit-spirv.cpp:7219`.

Before this PR, the descriptor heap base type for acceleration
structures could still be an `OpTypeAccelerationStructureKHR` runtime
array. That made the access-chain stride describe the opaque
acceleration-structure type while the actual heap load consumed an
8-byte device address. Nonzero heap indices could therefore address the
wrong heap entry unless users pinned `-spirv-resource-heap-stride`.

A minimal motivating shader is:

```slang
DescriptorHandle<RaytracingAccelerationStructure> accelerationStructure;
RaytracingAccelerationStructure scene =
    RaytracingAccelerationStructure(accelerationStructure);
```

## Proposed solution

Route `kIROp_RaytracingAccelerationStructureType` through the shared
descriptor runtime-array helper with a caller-computed AS stride.
`getDescriptorHeapBaseType` now materializes AS heap entries as `uint64`
elements at `source/slang/slang-emit-spirv.cpp:7175`, computes the AS
stride with `getAccelerationStructureDescriptorHeapStride`, and calls
`getDescriptorRuntimeArrayType` with that explicit stride.

The shared helper builds an `OpTypeRuntimeArray` whose element type is
`uint64` for AS heap entries, matching the device address that is
actually loaded. A zero `SPIRVResourceHeapStride` becomes a
caller-supplied literal 8-byte `ArrayStride` for AS heap entries; a
nonzero stride is still honored when it is at least 8 bytes. Undersized
explicit AS strides are diagnosed once per emit context and clamped
internally so Slang does not emit invalid SPIR-V.

This is a SPIR-V emission fix rather than a front-end or IR producer fix
because the AS descriptor-handle input shape is valid: descriptor-heap
AS entries are represented as device addresses and converted after
loading. The incorrect layer was the SPIR-V heap array type used for the
access chain.

## Change summary

- `source/slang/slang-emit-spirv.cpp:7077`: adds
`getDescriptorHeapArrayStride`, so non-AS descriptor heap call sites
calculate the resource/sampler stride before calling the runtime-array
helper.
- `source/slang/slang-emit-spirv.cpp:7089`: makes
`getDescriptorRuntimeArrayType` take an explicit stride and cache
runtime arrays by both descriptor element type and stride, while
preserving the existing `OpConstantSizeOfEXT(ResourceType)` path when
the caller passes zero.
- `source/slang/slang-emit-spirv.cpp:7141`: adds
`getAccelerationStructureDescriptorHeapStride`, which applies the 8-byte
AS default stride and validates explicit AS strides without repeating
the diagnostic for every AS heap load.
- `source/slang/slang-emit-spirv.cpp:7175`: routes
`kIROp_RaytracingAccelerationStructureType` to a `uint64` heap element
type and the shared descriptor-array path with the AS stride override.
- `source/slang/slang-diagnostics.lua:5258`: adds diagnostic `E57005`
for explicit AS resource heap strides smaller than the fixed 8-byte
entry width.
- `source/slang/slang-options.cpp:882`,
`docs/command-line-slangc-reference.md:611`,
`docs/user-guide/03-convenience-features.md:697`, and
`docs/user-guide/08-compiling.md:1092`: document the AS-specific
zero-stride behavior, the explicit override behavior, and the 8-byte
minimum.
- `tests/spirv/descriptor-heap-acceleration-structure.slang:2`: covers
the RayQueryKHR compute path for the default 8-byte stride, an explicit
32-byte override, rejection of a 4-byte stride, single-diagnostic
behavior with multiple AS heap loads, and verifies the rejected stride
is not emitted as `ArrayStride 4`.
- `tests/spirv/descriptor-heap-acceleration-structure-raygen.slang:5`:
covers the RayTracingKHR raygeneration path for the default 8-byte
stride and explicit 32-byte override.

## Concepts and vocabulary

- Descriptor heap: the `spvDescriptorHeapEXT` global resource or sampler
heap that `DescriptorHandle<T>` indexes with `OpUntypedAccessChainKHR`.
- AS heap entry: a `RaytracingAccelerationStructure` descriptor heap
entry represented as a 64-bit device address, then converted to the
opaque acceleration-structure handle with
`OpConvertUToAccelerationStructureKHR`.
- `ArrayStrideIdEXT`: the descriptor-heap stride decoration path that
uses `OpConstantSizeOfEXT(ResourceType)` for descriptor-typed runtime
arrays.
- Literal `ArrayStride`: the fixed numeric stride decoration used for
the AS `uint64` runtime array because its element type is a plain
integer device address, not a descriptor type.

## Process report

The code trace starts at `kIROp_SPIRVLoadDescriptorFromHeap`: AS loads
are detected at `source/slang/slang-emit-spirv.cpp:4920` and dispatched
to `emitAccelerationStructureFromDescriptorHeap`. That function
constructs an access chain from `getDescriptorHeapBaseType`, then
performs `OpLoad %uint64` and `OpConvertUToAccelerationStructureKHR` at
`source/slang/slang-emit-spirv.cpp:7212`,
`source/slang/slang-emit-spirv.cpp:7215`, and
`source/slang/slang-emit-spirv.cpp:7219`. The access-chain base type
therefore must have the same element width as the value being loaded. A
runtime array of opaque AS handles is the wrong representation for this
heap path; a runtime array of `uint64` device addresses is the
representation that matches the later load and conversion.

The AS special case is represented as a caller-computed literal stride
passed to `getDescriptorRuntimeArrayType`: descriptor-typed resources
still use `OpConstantSizeOfEXT(ResourceType)` through `ArrayStrideIdEXT`
when their call site passes zero, while AS heap entries pass an explicit
stride because their heap element is a `uint64` device address rather
than the opaque AS descriptor type. The explicit `SLANG_RELEASE_ASSERT`
at `source/slang/slang-emit-spirv.cpp:7091` documents that boundary and
makes a future accidental AS fallthrough fail close to the cause.

The input-shape check is intentional:
`DescriptorHandle<RaytracingAccelerationStructure>` under
`spvDescriptorHeapEXT` is a valid input shape, and the producer should
continue to express an acceleration-structure value at the source level.
The layer that knows the SPIR-V heap entry is a device address is the
SPIR-V emitter, specifically
`emitAccelerationStructureFromDescriptorHeap`; that is why the fix
belongs in the descriptor heap base-type selection and not in the
front-end type producer.

Explicit stride validation is added because the AS heap entry width is
statically known to be 8 bytes. A nonzero stride below 8 cannot safely
index a `uint64` runtime array, so
`getAccelerationStructureDescriptorHeapStride` diagnoses it at
`source/slang/slang-emit-spirv.cpp:7155` using `E57005` from
`source/slang/slang-diagnostics.lua:5258`, then clamps the internal
emission value to 8 to avoid producing invalid SPIR-V after reporting
the error. The diagnostic is gated by
`m_didDiagnoseAccelerationStructureDescriptorHeapStrideTooSmall`, so
shaders with multiple AS heap loads report the option error once while
still clamping every load path. The compute and raygen regression tests
pin the default and override shapes, and the compute test also pins the
undersized-stride diagnostic, verifies `ArrayStride 4` is not emitted,
and verifies the diagnostic is not repeated for the second AS heap load.

## Reviewer Directives (maintained by agent)

- [human @jkwak-work] Keep `arrayStride` calculation at descriptor-heap
call sites; `getDescriptorRuntimeArrayType` should accept a
caller-provided stride rather than reading compiler options or using
special-case defaults internally.
(#11494 (comment))

Author: jkwak-work

docs/command-line-slangc-reference.md

@@ -633,7 +633,7 @@ Specify the space index for the system defined global bindless resource array.
 
 **-spirv-resource-heap-stride <stride>**
 
-Specify the byte stride for the resource descriptor heap when generating SPIRV with spvDescriptorHeapEXT. Defaults to 0, which will use OpConstantSizeOfEXT(ResourceType). 
+Specify the byte stride for the resource descriptor heap when generating SPIRV with spvDescriptorHeapEXT. Defaults to 0, which will use OpConstantSizeOfEXT(ResourceType); for RaytracingAccelerationStructure entries, the 0 default emits a literal 8-byte ArrayStride for the uint64 device address elements. An explicit stride value still overrides these defaults; for acceleration-structure entries it must be at least 8 bytes. 
 
 
 <a id="spirv-sampler-heap-stride"></a>

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

@@ -697,14 +697,16 @@ 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.
+stride with the `-spirv-resource-heap-stride` or `-spirv-sampler-heap-stride` compiler options. For
+acceleration-structure entries, an explicit resource heap stride must be at least 8 bytes.
 
 > **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.
+> `OpConvertUToAccelerationStructureKHR`. The heap entry type is `uint64_t`, so the default heap stride is
+> based on the address width rather than the opaque acceleration structure type. 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
 

docs/user-guide/08-compiling.md

@@ -1089,7 +1089,7 @@ meanings of their `CompilerOptionValue` encodings.
 | GenerateWholeProgram | When set will emit target code for the entire program instead of for a specific entry point. `intValue0` specifies a bool value for the setting. |
 | UseUpToDateBinaryModule | When set will only load precompiled modules if it is up-to-date with its source. `intValue0` specifies a bool value for the setting. |
 | ValidateUniformity | When set will perform [uniformity analysis](a1-05-uniformity.md).|
-| SPIRVResourceHeapStride | Specifies the byte stride for the resource descriptor heap when generating SPIR-V with `spvDescriptorHeapEXT`. `intValue0` encodes the stride in bytes; use 0 to let the driver compute the stride via `OpConstantSizeOfEXT`. |
+| SPIRVResourceHeapStride | Specifies the byte stride for the resource descriptor heap when generating SPIR-V with `spvDescriptorHeapEXT`. `intValue0` encodes the stride in bytes; use 0 to emit `OpConstantSizeOfEXT(ResourceType)` as the default stride. For `RaytracingAccelerationStructure` entries, the 0 default emits a literal 8-byte `ArrayStride` for the `uint64` device address elements; explicit stride values still override these defaults, but must be at least 8 bytes for acceleration-structure entries. |
 | SPIRVSamplerHeapStride | Specifies the byte stride for the sampler descriptor heap when generating SPIR-V with `spvDescriptorHeapEXT`. `intValue0` encodes the stride in bytes; use 0 to let the driver compute the stride via `OpConstantSizeOfEXT`. |
 | ForceDXLayout | When set forces the compiler to use DirectX-compatible (HLSL register packing) rules when laying out buffer struct fields during code generation. `intValue0` specifies a bool value for the setting. |
 | ForceCLayout | When set forces the compiler to use C struct layout rules (natural alignment, no HLSL/GLSL padding) when laying out buffer struct fields during code generation. `intValue0` specifies a bool value for the setting. |

source/slang/slang-diagnostics.lua

@@ -5397,7 +5397,7 @@ err(
     span { loc = "location", message = "SubpassInput cannot be placed inside a ParameterBlock on Metal; framebuffer fetch inputs must be direct entry-point parameters." }
 )
 
--- SPIRV (57001-57004)
+-- SPIRV (57001-57005)
 
 warning(
     "spirv-opt-failed",
@@ -5427,6 +5427,12 @@ err(
     span { loc = "location", message = "output SPIR-V contains no exported symbols. Please make sure to specify at least one entrypoint." }
 )
 
+err(
+    "spirv-resource-heap-stride-too-small",
+    57005,
+    "SPIR-V resource heap stride '~stride:Int' is too small for RaytracingAccelerationStructure descriptor heap entries; expected at least '~minimumStride:Int' bytes."
+)
+
 -- GLSL Compatibility (58001-58003)
 
 err(

source/slang/slang-emit-spirv.cpp

@@ -4960,7 +4960,10 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex
             {
                 auto loadDesc = as<IRSPIRVLoadTexelPointerFromHeap>(inst);
                 auto resourceType = loadDesc->getTextureType();
-                auto resourceArrayType = getDescriptorRuntimeArrayType(ensureInst(resourceType));
+                auto descriptorElementType = ensureInst(resourceType);
+                auto resourceArrayType = getDescriptorRuntimeArrayType(
+                    descriptorElementType,
+                    getDescriptorHeapArrayStride(descriptorElementType));
                 auto imagePtr = emitInst(
                     parent,
                     nullptr,
@@ -6965,9 +6968,29 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex
         }
     };
     Dictionary<BuiltinSpvVarKey, SpvInst*> m_builtinGlobalVars;
+    struct DescriptorRuntimeArrayKey
+    {
+        SpvInst* descriptorElementType = nullptr;
+        int arrayStride = 0;
+
+        bool operator==(const DescriptorRuntimeArrayKey& other) const
+        {
+            return descriptorElementType == other.descriptorElementType &&
+                   arrayStride == other.arrayStride;
+        }
+
+        HashCode getHashCode() const
+        {
+            return combineHash(
+                Slang::getHashCode(descriptorElementType),
+                Slang::getHashCode(arrayStride));
+        }
+    };
+
     SpvInst* m_descriptorHeapUntypedPointerType = nullptr;
     Dictionary<SpvStorageClass, SpvInst*> m_descriptorHeapBufferDescriptorTypes;
-    Dictionary<SpvInst*, SpvInst*> m_descriptorHeapRuntimeArrayTypes;
+    Dictionary<DescriptorRuntimeArrayKey, SpvInst*> m_descriptorHeapRuntimeArrayTypes;
+    bool m_didDiagnoseAccelerationStructureDescriptorHeapStrideTooSmall = false;
 
 
     bool isInstUsedInStage(IRInst* inst, Stage s)
@@ -7140,24 +7163,40 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex
         return type;
     }
 
-    SpvInst* getDescriptorRuntimeArrayType(SpvInst* descriptorElementType)
+    // Selects the configured heap stride for a non-acceleration-structure descriptor element.
+    // Keeping this lookup at the call site makes `getDescriptorRuntimeArrayType` consume only a
+    // caller-chosen stride; for example, sampler heaps use `SPIRVSamplerHeapStride`, while
+    // texture and buffer resource heaps use `SPIRVResourceHeapStride`.
+    int getDescriptorHeapArrayStride(SpvInst* descriptorElementType)
     {
-        if (auto found = m_descriptorHeapRuntimeArrayTypes.tryGetValue(descriptorElementType))
-            return *found;
-
-        SpvInst* stride = nullptr;
-        int userDefinedStride = 0;
         if (descriptorElementType->opcode == SpvOpTypeSampler)
         {
-            userDefinedStride = m_targetProgram->getOptionSet().getIntOption(
+            return m_targetProgram->getOptionSet().getIntOption(
                 CompilerOptionName::SPIRVSamplerHeapStride);
         }
-        else
-        {
-            userDefinedStride = m_targetProgram->getOptionSet().getIntOption(
-                CompilerOptionName::SPIRVResourceHeapStride);
-        }
-        if (userDefinedStride == 0)
+
+        return m_targetProgram->getOptionSet().getIntOption(
+            CompilerOptionName::SPIRVResourceHeapStride);
+    }
+
+    // Builds or reuses the descriptor runtime array for a specific element type and stride.
+    // A zero stride emits an `ArrayStrideIdEXT` from `OpConstantSizeOfEXT` for descriptor-typed
+    // resources, while acceleration-structure heap entries pass the explicit `uint64` stride
+    // computed by `getAccelerationStructureDescriptorHeapStride`.
+    SpvInst* getDescriptorRuntimeArrayType(SpvInst* descriptorElementType, int arrayStride)
+    {
+        SLANG_RELEASE_ASSERT(
+            descriptorElementType->opcode != SpvOpTypeAccelerationStructureKHR &&
+            "acceleration structure descriptor heaps must use uint64 elements");
+
+        DescriptorRuntimeArrayKey key;
+        key.descriptorElementType = descriptorElementType;
+        key.arrayStride = arrayStride;
+        if (auto found = m_descriptorHeapRuntimeArrayTypes.tryGetValue(key))
+            return *found;
+
+        SpvInst* stride = nullptr;
+        if (arrayStride == 0)
         {
             IRBuilder builder(m_irModule);
             builder.setInsertInto(m_irModule->getModuleInst());
@@ -7166,7 +7205,7 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex
         }
 
         auto runtimeArrayType = emitOpTypeRuntimeArray(nullptr, descriptorElementType);
-        m_descriptorHeapRuntimeArrayTypes[descriptorElementType] = runtimeArrayType;
+        m_descriptorHeapRuntimeArrayTypes[key] = runtimeArrayType;
 
         if (stride)
         {
@@ -7182,23 +7221,62 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex
                 getSection(SpvLogicalSectionID::Annotations),
                 nullptr,
                 runtimeArrayType,
-                SpvLiteralInteger::from32(userDefinedStride));
+                SpvLiteralInteger::from32(arrayStride));
         }
         return runtimeArrayType;
     }
 
+    int getAccelerationStructureDescriptorHeapStride()
+    {
+        static const int kAccelerationStructureDescriptorHeapStride = 8;
+
+        auto userDefinedStride = m_targetProgram->getOptionSet().getIntOption(
+            CompilerOptionName::SPIRVResourceHeapStride);
+        if (userDefinedStride == 0)
+        {
+            userDefinedStride = kAccelerationStructureDescriptorHeapStride;
+        }
+        else if (userDefinedStride < kAccelerationStructureDescriptorHeapStride)
+        {
+            if (!m_didDiagnoseAccelerationStructureDescriptorHeapStrideTooSmall)
+            {
+                m_sink->diagnose(Diagnostics::SpirvResourceHeapStrideTooSmall{
+                    .stride = userDefinedStride,
+                    .minimumStride = kAccelerationStructureDescriptorHeapStride,
+                });
+                m_didDiagnoseAccelerationStructureDescriptorHeapStrideTooSmall = true;
+            }
+            userDefinedStride = kAccelerationStructureDescriptorHeapStride;
+        }
+
+        return userDefinedStride;
+    }
+
     SpvInst* getDescriptorHeapBaseType(IRType* valueType, bool* outIsBufferResource = nullptr)
     {
         SpvInst* descriptorElementType = nullptr;
         bool isBufferResource = false;
         switch (valueType->getOp())
         {
         case kIROp_TextureType:
-        case kIROp_RaytracingAccelerationStructureType:
         case kIROp_SamplerStateType:
         case kIROp_SamplerComparisonStateType:
             descriptorElementType = ensureInst(valueType);
             break;
+        case kIROp_RaytracingAccelerationStructureType:
+            {
+                if (outIsBufferResource)
+                    *outIsBufferResource = false;
+
+                IRBuilder builder(m_irModule);
+                builder.setInsertInto(m_irModule->getModuleInst());
+
+                // Acceleration structure heap entries are 64-bit device addresses that are
+                // converted to acceleration structure handles after loading.
+                descriptorElementType = ensureInst(builder.getUInt64Type());
+                auto arrayStride = getAccelerationStructureDescriptorHeapStride();
+                return getDescriptorRuntimeArrayType(descriptorElementType, arrayStride);
+            }
         default:
             isBufferResource = true;
             descriptorElementType = ensureDescriptorHeapBufferDescriptorType(
@@ -7209,7 +7287,8 @@ struct SPIRVEmitContext : public SourceEmitterBase, public SPIRVEmitSharedContex
         if (outIsBufferResource)
             *outIsBufferResource = isBufferResource;
 
-        return getDescriptorRuntimeArrayType(descriptorElementType);
+        auto arrayStride = getDescriptorHeapArrayStride(descriptorElementType);
+        return getDescriptorRuntimeArrayType(descriptorElementType, arrayStride);
     }
 
     SpvInst* emitAccelerationStructureFromDescriptorHeap(

source/slang/slang-options.cpp

@@ -915,7 +915,11 @@ void initCommandOptions(CommandOptions& options)
          "-spirv-resource-heap-stride",
          "-spirv-resource-heap-stride <stride>",
          "Specify the byte stride for the resource descriptor heap when generating SPIRV with "
-         "spvDescriptorHeapEXT. Defaults to 0, which will use OpConstantSizeOfEXT(ResourceType)."},
+         "spvDescriptorHeapEXT. Defaults to 0, which will use OpConstantSizeOfEXT(ResourceType); "
+         "for RaytracingAccelerationStructure entries, the 0 default emits a literal 8-byte "
+         "ArrayStride for the uint64 device address elements. An explicit stride value still "
+         "overrides these defaults; for acceleration-structure entries it must be at least 8 "
+         "bytes."},
         {OptionKind::SPIRVSamplerHeapStride,
          "-spirv-sampler-heap-stride",
          "-spirv-sampler-heap-stride <stride>",

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

@@ -2,7 +2,8 @@
 // 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
+//TEST:SIMPLE(filecheck=CHECK): -target spirv-asm -stage raygeneration -entry rayGenMain -profile sm_6_6 -capability spvDescriptorHeapEXT
+//TEST:SIMPLE(filecheck=OVERRIDE): -target spirv-asm -stage raygeneration -entry rayGenMain -profile sm_6_6 -capability spvDescriptorHeapEXT -spirv-resource-heap-stride 32
 
 struct PushConstants
 {
@@ -20,8 +21,12 @@ 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: %[[AS_HEAP_ARRAY:[A-Za-z0-9_]+]] = OpTypeRuntimeArray %[[U64]]
+    // CHECK-DAG: OpDecorate %[[AS_HEAP_ARRAY]] ArrayStride 8
+    // OVERRIDE-DAG: %[[OVERRIDE_U64:[A-Za-z0-9_]+]] = OpTypeInt 64 0
+    // OVERRIDE-DAG: %[[OVERRIDE_AS_TYPE:[A-Za-z0-9_]+]] = OpTypeAccelerationStructureKHR
+    // OVERRIDE-DAG: %[[OVERRIDE_AS_HEAP_ARRAY:[A-Za-z0-9_]+]] = OpTypeRuntimeArray %[[OVERRIDE_U64]]
+    // OVERRIDE-DAG: OpDecorate %[[OVERRIDE_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]]

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

@@ -1,9 +1,16 @@
-// 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
+// Regression test for GitHub issues #10671 and #11231.
+//TEST:SIMPLE(filecheck=CHECK): -target spirv-asm -stage compute -entry computeMain -profile sm_6_6 -capability spvDescriptorHeapEXT -capability spvRayQueryKHR
+//TEST:SIMPLE(filecheck=OVERRIDE): -target spirv-asm -stage compute -entry computeMain -profile sm_6_6 -capability spvDescriptorHeapEXT -capability spvRayQueryKHR -spirv-resource-heap-stride 32
+//TEST:SIMPLE(filecheck=TOO_SMALL): -target spirv-asm -stage compute -entry computeMain -profile sm_6_6 -capability spvDescriptorHeapEXT -capability spvRayQueryKHR -spirv-resource-heap-stride 4
+// TOO_SMALL-NOT: ArrayStride 4
+// TOO_SMALL: error[E57005]: SPIR-V resource heap stride '4' is too small for RaytracingAccelerationStructure descriptor heap entries; expected at least '8' bytes.
+// TOO_SMALL-NOT: SPIR-V resource heap stride '4' is too small
+// TOO_SMALL-NOT: ArrayStride 4
 
 struct PushConstants
 {
     DescriptorHandle<RaytracingAccelerationStructure> accelerationStructure;
+    DescriptorHandle<RaytracingAccelerationStructure> secondaryAccelerationStructure;
     DescriptorHandle<RWTexture2D<float4>> outputTexture;
 }
 
@@ -39,8 +46,12 @@ void computeMain(uint3 dispatchThreadID: SV_DispatchThreadID, uniform PushConsta
 {
     // 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: %[[AS_HEAP_ARRAY:[A-Za-z0-9_]+]] = OpTypeRuntimeArray %[[U64]]
+    // CHECK-DAG: OpDecorate %[[AS_HEAP_ARRAY]] ArrayStride 8
+    // OVERRIDE-DAG: %[[OVERRIDE_U64:[A-Za-z0-9_]+]] = OpTypeInt 64 0
+    // OVERRIDE-DAG: %[[OVERRIDE_AS_TYPE:[A-Za-z0-9_]+]] = OpTypeAccelerationStructureKHR
+    // OVERRIDE-DAG: %[[OVERRIDE_AS_HEAP_ARRAY:[A-Za-z0-9_]+]] = OpTypeRuntimeArray %[[OVERRIDE_U64]]
+    // OVERRIDE-DAG: OpDecorate %[[OVERRIDE_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]]
@@ -53,6 +64,13 @@ void computeMain(uint3 dispatchThreadID: SV_DispatchThreadID, uniform PushConsta
         float3(0.0, 0.0, 1.0),
         t);
 
+    float secondaryT = 0.0;
+    traceRayClosestHit(
+        RaytracingAccelerationStructure(pushConstants.secondaryAccelerationStructure),
+        float3(0.2, 0.2, 0.0),
+        float3(0.0, 0.0, 1.0),
+        secondaryT);
+
     RWTexture2D<float4> outputTexture = pushConstants.outputTexture;
-    outputTexture[dispatchThreadID.xy] = t;
+    outputTexture[dispatchThreadID.xy] = t + secondaryT;
 }