Add bindless resource metadata usage query (#11436)

Fixes #10439

## Motivation

`ShaderReflection::getBindlessSpaceIndex()` reports a layout
reservation, not final
target-code usage. Since bindless space allocation moved into frontend
layout, a shader
can keep a non-negative bindless space index even when later
optimization removes every
descriptor-handle heap path. A host that treats `getBindlessSpaceIndex()
>= 0` as "bind
the descriptor heap" can therefore do unnecessary bindless setup for
ordinary shaders.

The motivating shape is a compute shader with only ordinary resources,
such as
`RWStructuredBuffer` inputs and outputs, or a shader that declares a
`DescriptorHandle`
inside a parameter block but never reads it. Both shapes can reserve a
bindless space in
layout while producing target IR with no surviving bindless heap use.

## Proposed solution

Add `slang::IBindlessResourceMetadata` as a side interface on emitted
artifact metadata.
Callers keep using `getBindlessSpaceIndex()` to learn which space layout
reserved, then
cast target metadata to `IBindlessResourceMetadata` and call
`usesBindlessResourceHeap()` to learn whether the compiled target IR
still contains a
descriptor-handle or bindless resource path.

This keeps the public `IMetadata` vtable stable by adding a separate
castable interface
instead of appending methods to `IMetadata`. It also keeps the usage
query tied to the
late IR that code generation actually sees, rather than inferring usage
from frontend
syntax or from the existence of a layout reservation.

## Change summary

- Public API: `include/slang.h:3735` and
`include/slang-deprecated.h:1054`
clarify that `getBindlessSpaceIndex()` reports reserved layout space.
The new
`IBindlessResourceMetadata` interface and `usesBindlessResourceHeap()`
query are
  declared in `include/slang.h:4549`.
- Metadata object: `ArtifactPostEmitMetadata` implements
`IBindlessResourceMetadata`, exposes it from `getInterface()`, and
stores
  `m_usesBindlessResourceHeap` in
  `source/compiler-core/slang-artifact-associated-impl.h:221` and
  `source/compiler-core/slang-artifact-associated-impl.cpp:292`.
- Metadata collection: `collectMetadata()` now takes `TargetProgram*`,
obtains the
existing layout with `TargetProgram::getExistingLayout()`, scans final
IR with
`doesInstAndChildrenUseBindlessResourceHeap()`, and stores the result in
  `source/slang/slang-ir-metadata.cpp:278`.
- Bindless heap detection: `_isBindlessResourceHeapGlobalParam()`
identifies the
lowered synthetic heap from its unbounded descriptor-table layout in the
reserved
bindless space, and `_instUsesBindlessResourceHeap()` recognizes the
descriptor-heap
opcodes and descriptor-handle cast opcodes in
`source/slang/slang-ir-metadata.cpp:122`
  and `source/slang/slang-ir-metadata.cpp:157`.
- Dynamic heap lowering: `getBindlessSpaceIndex()` now asserts that
layout exists and
that it reserved a bindless space before `lowerDynamicResourceHeap()`
synthesizes the
heap global in
`source/slang/slang-ir-lower-dynamic-resource-heap.cpp:16`.
- Emit pipeline: `linkAndOptimizeIR()` realizes layout before post-emit
metadata for
descriptor-handle-capable non-PyTorch targets, then calls
`collectMetadata()` in
  `source/slang/slang-emit.cpp:2411`.
- Tests and docs: bindless metadata coverage lives in
`tools/slang-unit-test/unit-test-bindless-space-reflection.cpp:200`,
vtable
  stability coverage for the new interface is in
`tools/slang-unit-test/unit-test-vtable-stability.cpp:918`, IR metadata
checks are in
`tests/language-feature/descriptor-handle/`, and user-facing docs are
updated in
  `docs/user-guide/09-reflection.md:1568` and
  `docs/user-guide/03-convenience-features.md:672`.

## Concepts and vocabulary

- Bindless space index: the descriptor set or register space reserved by
program layout
for Slang's bindless resource heap. It is intentionally stable and can
survive even
  when final target code does not use the heap.
- Bindless resource heap usage: a post-lowering code-generation signal
that final IR
still contains descriptor-handle, descriptor-heap, or lowered synthetic
heap access.
- Synthetic resource heap global: the global parameter created by
`lowerDynamicResourceHeap()` after it replaces `GetDynamicResourceHeap`.
Metadata must
  identify it from semantic layout data, not only from a name hint.

## Process report

The API change separates layout reservation from target-code usage. The
old public
contract encouraged hosts to infer runtime heap setup from
`ShaderReflection::getBindlessSpaceIndex()`. That is not precise after
frontend layout
starts reserving bindless space before optimization, so this PR
documents the old query
as a layout signal in `include/slang.h:3735` and adds the target
metadata side query in
`include/slang.h:4549`.

The metadata implementation uses a side interface because `IMetadata` is
already a
public COM-style interface. `ArtifactPostEmitMetadata` inherits
`IBindlessResourceMetadata` in
`source/compiler-core/slang-artifact-associated-impl.h:221`
and returns it from `getInterface()` in
`source/compiler-core/slang-artifact-associated-impl.cpp:292`; this
makes
`metadata->castAs(IBindlessResourceMetadata::getTypeGuid())` the
extension mechanism
without changing existing `IMetadata` slots.

The usage bit is computed in `collectMetadata()` after target-specific
lowering, in
`source/slang/slang-ir-metadata.cpp:278`. The scan first asks the target
program for an
existing layout; when no layout exists, `bindlessSpaceIndex` remains
`-1` and the
bindless scan is skipped. That no-layout shape is intentional for
targets such as
PyTorch binding emission, where forcing layout solely for metadata would
be the wrong
layer. For descriptor-handle-capable non-PyTorch targets,
`source/slang/slang-emit.cpp:2411`
realizes layout before metadata so the reserved bindless space is
available.

The synthetic heap-global case is handled by layout, not by a new IR
marker. After
`lowerDynamicResourceHeap()` replaces `GetDynamicResourceHeap` with a
global parameter,
opcode scanning alone can no longer see the original intrinsic. The
helper at
`source/slang/slang-ir-metadata.cpp:122` identifies that global only
when it has an
infinite `DescriptorTableSlot` layout in the reserved bindless space.
That keeps normal
user-declared unbounded resource arrays from being mistaken for Slang's
heap, including
the case where the user array occupies the originally requested bindless
space and
layout moves the system heap to another space.

The opcode scan at `source/slang/slang-ir-metadata.cpp:157` covers
target-independent
heap loads, SPIR-V descriptor heap operations, texel-pointer heap
operations, and
descriptor-handle cast opcodes that can survive to emit for native
targets. The scan is
recursive via `doesInstAndChildrenUseBindlessResourceHeap()` in
`source/slang/slang-ir-metadata.cpp:188`, so handle usage inside helper
functions is
covered directly through instruction children.

The dynamic-resource-heap lowering path now treats layout as its
contract. The helper at
`source/slang/slang-ir-lower-dynamic-resource-heap.cpp:16` asserts that
`TargetProgram`
and its existing layout are present, and that the layout reserved a
bindless space. The
pass still returns early at
`source/slang/slang-ir-lower-dynamic-resource-heap.cpp:59`
when there are no `GetDynamicResourceHeap` instructions, so targets
without heap work do
not pay the capability or layout checks.

The tests exercise the truth table that motivated the fix. The shared
unit-test helper
casts target metadata and checks both layout reservation and
`usesBindlessResourceHeap()` in
`tools/slang-unit-test/unit-test-bindless-space-reflection.cpp:200`.
Negative cases cover
ordinary resources, dead descriptor handles, no reserved space,
unbounded user arrays,
and metadata queried before explicit layout. Positive cases cover SPIR-V
descriptor heap
paths, SPIR-V NV paths, WGSL dynamic resource heap, HLSL resource and
sampler handles,
native handle casts, texel-pointer heap usage, stripped name hints, and
helper-function
handle use. The vtable probe in
`tools/slang-unit-test/unit-test-vtable-stability.cpp:918`
pins the new side interface slot.

## Reviewer Directives (maintained by agent)

- [human @jkwak-work] Avoid a dedicated `BindlessResourceHeapDecoration`
and module-version bump when existing layout metadata can identify the
lowered resource heap; only reintroduce a marker if the existing layout
signal proves insufficient.
(#11436 (comment))
- [human @jkwak-work] Treat `CastDescriptorHandleToResource` as
`usesBindlessResourceHeap()` usage unconditionally, regardless of target
or capability. This supersedes the earlier SPIR-V `spvBindlessTextureNV`
gating directive.
(#11436 (comment))
- [human @jkwak-work] Keep `collectMetadata` generic by passing
`TargetProgram*` rather than bindless-specific parameters, and avoid
requiring information from `TargetRequest` for the bindless metadata
query.
(#11436 (comment))
- [human @jkwak-work] Use `TargetProgram::getExistingLayout()` directly
as the optional layout probe for metadata; do not keep a separate
`hasExistingLayout()` accessor. Dynamic-resource-heap lowering should
assert its required layout/bindless-space invariants inside
`getBindlessSpaceIndex()`.
(#11436 (comment))
- [human @jkwak-work] Keep the dynamic-resource-heap bindless-space
helper returning `UInt`, and assert required layout/bindless-space
invariants inside the helper instead of returning a nullable/boolean
result.
(#11436 (comment))
- [human @jkwak-work] Do not call helper functions such as
`getBindlessSpaceIndex()` inside assertion expressions; compute the
result first and assert the stored value when a caller-side assertion is
needed.
(#11436 (comment))
- [human @jkwak-work] Treat `bindlessSpaceIndex >= 0` as a caller
contract for bindless heap global-param detection: callers should
early-out when no bindless space is reserved, and the helper should
assert the invariant with `SLANG_ASSERT(bindlessSpaceIndex >= 0)`.
(#11436 (comment),
#11436 (comment))
- [human @csyonghe] Use direct recursive instruction-child traversal for
the bindless metadata scan, name the helper
`doesInstAndChildrenUseBindlessResourceHeap()`, and include comments
explaining the synthetic heap/global and cast-opcode detection.
(#11436 (comment),
#11436 (comment),
#11436 (comment))
- [bot github-actions] For post-emit bindless metadata, keep
`collectMetadata` generic over `TargetProgram*`:
descriptor-handle-capable targets may realize layout before metadata,
but targets without an existing layout use `bindlessSpaceIndex == -1`;
do not force layout for PyTorch binding emission just to collect
bindless metadata.
(#11436 (comment))

Author: jkwak-work

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

@@ -668,6 +668,12 @@ Without requesting `spvDescriptorHeapEXT`, Slang introduces a global array of de
 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.
 
+Reflection reports this value as a reserved bindless space for descriptor-handle-capable targets.
+That reservation can be present even when optimization and target lowering remove all descriptor
+handle uses from the emitted shader. Hosts that need to decide whether to bind a descriptor heap
+should query target metadata for `IBindlessResourceMetadata::usesBindlessResourceHeap()` instead of
+using `getBindlessSpaceIndex() >= 0` as the usage test.
+
 Default behavior assigns binding indices based on descriptor types:
 
 | Enum Value             | Vulkan Descriptor Type                    | Binding Index |

docs/user-guide/09-reflection.md

@@ -1564,6 +1564,34 @@ program->getEntryPointMetadata(
         &entryPointMetadata);
 ```
 
+Target-wide post-emit metadata is queried through `IComponentType::getTargetMetadata()`. For
+`DescriptorHandle<T>`, `ProgramLayout::getBindlessSpaceIndex()` reports the frontend-reserved
+bindless space, which can be non-negative even when the emitted target does not use a descriptor
+heap path. Hosts should cast target metadata to `IBindlessResourceMetadata` and use
+`usesBindlessResourceHeap()` as a post-lowering signal, then combine it with the target binding
+model when deciding whether an explicit bindless resource heap binding is required:
+
+```c++
+slang::IComponentType* program = ...;
+Slang::ComPtr<slang::IMetadata> targetMetadata;
+Slang::ComPtr<slang::IBlob> diagnostics;
+if (SLANG_FAILED(program->getTargetMetadata(
+        0, // target index
+        targetMetadata.writeRef(),
+        diagnostics.writeRef())))
+{
+    // Handle error.
+    return;
+}
+
+auto bindlessMetadata = static_cast<slang::IBindlessResourceMetadata*>(
+    targetMetadata->castAs(slang::IBindlessResourceMetadata::getTypeGuid()));
+if (bindlessMetadata && bindlessMetadata->usesBindlessResourceHeap())
+{
+    // Bind the descriptor heap for this compiled target.
+}
+```
+
 When traversal of reflection data reaches a leaf parameter, the application can use `IMetadata::isParameterLocationUsed()` with the absolute location of that parameter for a given layout unit:
 
 ```c++

include/slang-deprecated.h

@@ -1047,8 +1047,15 @@ extern "C"
         SlangCompileRequest* request,
         int translationUnitIndex);
 
-    /** Get the descriptor set/space index allocated for the bindless resource heap.
-     *  Returns -1 if the program does not use bindless resource heap.
+    /** Get the descriptor set/space index reserved for the bindless resource heap.
+     *
+     * This is a layout/reflection reservation made before final target lowering and
+     * optimization. It can remain non-negative even when the emitted target code no
+     * longer uses a bindless heap/resource-handle path. Query `IBindlessResourceMetadata`
+     * from target metadata to determine whether such a path survived in the compiled
+     * target IR.
+     *
+     * Returns -1 only when no bindless heap space was reserved for the program layout.
      */
     SLANG_API SlangInt spReflection_getBindlessSpaceIndex(SlangReflection* reflection);
 #ifdef __cplusplus

include/slang.h

@@ -3759,8 +3759,15 @@ struct ShaderReflection
         return spReflection_ToJson((SlangReflection*)this, nullptr, outBlob);
     }
 
-    /** Get the descriptor set/space index allocated for the bindless resource heap.
-     *  Returns -1 if the program does not use bindless resource heap.
+    /** Get the descriptor set/space index reserved for the bindless resource heap.
+     *
+     * This is a layout/reflection reservation made before final target lowering and
+     * optimization. It can remain non-negative even when the emitted target code no
+     * longer uses a bindless heap/resource-handle path. Query `IBindlessResourceMetadata`
+     * from target metadata to determine whether such a path survived in the compiled
+     * target IR.
+     *
+     * Returns -1 only when no bindless heap space was reserved for the program layout.
      */
     SlangInt getBindlessSpaceIndex()
     {
@@ -4566,6 +4573,39 @@ struct IMetadata : public ISlangCastable
 };
     #define SLANG_UUID_IMetadata IMetadata::getTypeGuid()
 
+/** Bindless resource metadata produced for a compiled target.
+
+The bindless space index reported through program reflection is a frontend-predicted reserved
+descriptor space. It remains stable even when later optimization or target lowering removes all
+descriptor-handle heap use from the emitted shader. This metadata interface reports the
+post-lowering usage signal instead.
+
+`usesBindlessResourceHeap()` reports whether the final target IR still contains the
+descriptor-handle/bindless resource path after target-specific lowering. This is a code-generation
+signal, not a complete cross-target host binding policy: targets that lower descriptor handles to
+native resource handles or addresses may not require an explicit descriptor-heap binding even when
+this returns true. Hosts should combine this query with their target binding model when deciding
+whether to bind a heap.
+
+Cast from an artifact-associated `IMetadata*` using `castAs()`.
+*/
+struct IBindlessResourceMetadata : public ISlangCastable
+{
+    SLANG_COM_INTERFACE(
+        0xeafa96d3,
+        0x2352,
+        0x4bf4,
+        {0x88, 0x64, 0x32, 0x28, 0xa4, 0x07, 0x7a, 0x83})
+
+    /// Returns true when the compiled target IR still contains a bindless
+    /// descriptor-heap/resource-handle path after target-specific lowering. This is a
+    /// code-generation signal, not a complete cross-target host binding policy; targets
+    /// that lower descriptor handles to native resource handles or addresses may not require
+    /// an explicit descriptor-heap binding even when this returns true.
+    virtual SLANG_NO_THROW bool SLANG_MCALL usesBindlessResourceHeap() = 0;
+};
+    #define SLANG_UUID_IBindlessResourceMetadata IBindlessResourceMetadata::getTypeGuid()
+
 /** Coverage tracing metadata produced when any shader coverage mode is active.
 
 The current implementation reports line, function-entry, and branch-arm

source/compiler-core/slang-artifact-associated-impl.cpp

@@ -289,6 +289,8 @@ void* ArtifactPostEmitMetadata::getInterface(const Guid& guid)
     }
     if (guid == slang::IMetadata::getTypeGuid())
         return static_cast<slang::IMetadata*>(this);
+    if (guid == slang::IBindlessResourceMetadata::getTypeGuid())
+        return static_cast<slang::IBindlessResourceMetadata*>(this);
     if (guid == slang::ICoverageTracingMetadata::getTypeGuid())
     {
         return static_cast<slang::ICoverageTracingMetadata*>(this);
@@ -356,6 +358,11 @@ const char* ArtifactPostEmitMetadata::getDebugBuildIdentifier()
     return m_debugBuildIdentifier.getBuffer();
 }
 
+bool ArtifactPostEmitMetadata::usesBindlessResourceHeap()
+{
+    return m_usesBindlessResourceHeap;
+}
+
 uint32_t ArtifactPostEmitMetadata::getCounterCount()
 {
     return m_coverageCounterCount;

source/compiler-core/slang-artifact-associated-impl.h

@@ -220,6 +220,7 @@ enum class SyntheticResourceKnownID : uint32_t
 
 class ArtifactPostEmitMetadata : public ComBaseObject,
                                  public IArtifactPostEmitMetadata,
+                                 public slang::IBindlessResourceMetadata,
                                  public slang::ICoverageTracingMetadata,
                                  public slang::ISyntheticResourceMetadata,
                                  public slang::ICooperativeTypesMetadata
@@ -249,6 +250,9 @@ class ArtifactPostEmitMetadata : public ComBaseObject,
 
     SLANG_NO_THROW virtual const char* SLANG_MCALL getDebugBuildIdentifier() SLANG_OVERRIDE;
 
+    // IBindlessResourceMetadata
+    SLANG_NO_THROW virtual bool SLANG_MCALL usesBindlessResourceHeap() SLANG_OVERRIDE;
+
     // ICoverageTracingMetadata
     SLANG_NO_THROW virtual uint32_t SLANG_MCALL getCounterCount() SLANG_OVERRIDE;
     SLANG_NO_THROW virtual SlangResult SLANG_MCALL
@@ -299,6 +303,7 @@ class ArtifactPostEmitMetadata : public ComBaseObject,
     List<slang::CooperativeVectorTypeUsageInfo> m_cooperativeVectorTypes;
     List<slang::CooperativeVectorCombination> m_cooperativeVectorCombinations;
     String m_debugBuildIdentifier;
+    bool m_usesBindlessResourceHeap = false;
 
     // Coverage tracing data, populated by `instrumentCoverage` when
     // `-trace-coverage` is active. Empty otherwise.

source/slang/slang-emit.cpp

@@ -9,6 +9,7 @@
 #include "../core/slang-performance-profiler.h"
 #include "../core/slang-type-text-util.h"
 #include "../core/slang-writer.h"
+#include "slang-capability.h"
 #include "slang-check-out-of-bound-access.h"
 #include "slang-emit-c-like.h"
 #include "slang-emit-cpp.h"
@@ -2516,7 +2517,17 @@ Result linkAndOptimizeIR(
         SLANG_PASS(unexportNonEmbeddableIR, target);
     }
 
-    SLANG_PASS(collectMetadata, *metadata);
+    {
+        auto targetCaps = targetRequest->getTargetCaps();
+        if (target != CodeGenTarget::PyTorchCppBinding &&
+            targetCaps.atLeastOneSetImpliedInOther(CapabilitySet(
+                CapabilityName::descriptor_handle)) == CapabilitySet::ImpliesReturnFlags::Implied)
+        {
+            if (!targetProgram->getOrCreateLayout(sink))
+                return SLANG_FAIL;
+        }
+    }
+    SLANG_PASS(collectMetadata, targetProgram, *metadata);
 
     if (!targetProgram->getOptionSet().shouldPerformMinimumOptimizations())
         SLANG_PASS(checkUnsupportedInst, codeGenContext->getTargetReq(), sink);

source/slang/slang-ir-lower-dynamic-resource-heap.cpp

@@ -15,17 +15,15 @@ namespace Slang
 /// ensuring consistency with reflection data.
 UInt getBindlessSpaceIndex(TargetProgram* targetProgram)
 {
-    // Get the bindless space index from the program layout.
-    // This is always allocated during generateParameterBindings().
-    if (auto programLayout = targetProgram->getExistingLayout())
-    {
-        SLANG_ASSERT(programLayout->bindlessSpaceIndex >= 0);
-        return (UInt)programLayout->bindlessSpaceIndex;
-    }
+    SLANG_RELEASE_ASSERT(targetProgram);
+    auto programLayout = targetProgram->getExistingLayout();
+    SLANG_RELEASE_ASSERT(programLayout);
 
-    // Fallback: if no layout exists yet, use the user-specified index or default to 0.
-    // This shouldn't normally happen since layout is generated before this pass runs.
-    return (UInt)targetProgram->getOptionSet().getIntOption(CompilerOptionName::BindlessSpaceIndex);
+    // Do not fall back to the requested option here; only layout knows the
+    // bindless space that was actually reserved after conflict resolution.
+    SLANG_RELEASE_ASSERT(programLayout->bindlessSpaceIndex >= 0);
+
+    return (UInt)programLayout->bindlessSpaceIndex;
 }
 
 IRVarLayout* createResourceHeapVarLayoutWithSpaceAndBinding(
@@ -58,9 +56,11 @@ void lowerDynamicResourceHeap(IRModule* module, TargetProgram* targetProgram, Di
         }
     }
 
+    if (workList.getCount() == 0)
+        return;
+
     // If there are GetDynamicResourceHeap instructions, verify that the target
     // supports descriptor_handle capability.
-    if (workList.getCount() > 0)
     {
         auto targetCaps = targetProgram->getTargetReq()->getTargetCaps();
         if (targetCaps.atLeastOneSetImpliedInOther(CapabilitySet(

source/slang/slang-ir-metadata.cpp

@@ -5,6 +5,7 @@
 #include "slang-ir-insts.h"
 #include "slang-ir.h"
 #include "slang-rich-diagnostics.h"
+#include "slang-target-program.h"
 
 #include <utility>
 
@@ -118,6 +119,88 @@ static void _insertBinding(
     ranges.add(newRange);
 }
 
+static bool _isBindlessResourceHeapGlobalParam(IRInst* inst, SlangInt bindlessSpaceIndex)
+{
+    SLANG_ASSERT(bindlessSpaceIndex >= 0);
+
+    auto globalParam = as<IRGlobalParam>(inst);
+    if (!globalParam)
+        return false;
+
+    auto layoutDecoration = globalParam->findDecoration<IRLayoutDecoration>();
+    if (!layoutDecoration)
+        return false;
+
+    auto varLayout = as<IRVarLayout>(layoutDecoration->getLayout());
+    if (!varLayout)
+        return false;
+
+    auto descriptorTableSlotOffset =
+        varLayout->findOffsetAttr(LayoutResourceKind::DescriptorTableSlot);
+    if (!descriptorTableSlotOffset)
+        return false;
+
+    UInt spaceIndex = descriptorTableSlotOffset->getSpace();
+    if (auto spaceAttr = varLayout->findOffsetAttr(LayoutResourceKind::RegisterSpace))
+        spaceIndex += spaceAttr->getOffset();
+    if (spaceIndex != (UInt)bindlessSpaceIndex)
+        return false;
+
+    // `lowerDynamicResourceHeap` replaces the intrinsic with a synthetic global param in the
+    // reserved bindless space, so opcode checks alone no longer see the heap after lowering.
+    auto typeLayout = varLayout->getTypeLayout();
+    auto descriptorTableSlotSize =
+        typeLayout ? typeLayout->findSizeAttr(LayoutResourceKind::DescriptorTableSlot) : nullptr;
+    return descriptorTableSlotSize && descriptorTableSlotSize->getSize().isInfinite();
+}
+
+static bool _instUsesBindlessResourceHeap(IRInst* inst, SlangInt bindlessSpaceIndex)
+{
+    SLANG_ASSERT(bindlessSpaceIndex >= 0);
+
+    // Dynamic-resource-heap lowering can replace the heap intrinsic with a synthetic global
+    // parameter, so check for that lowered form before looking at opcode uses.
+    if (_isBindlessResourceHeapGlobalParam(inst, bindlessSpaceIndex))
+        return true;
+
+    switch (inst->getOp())
+    {
+    case kIROp_GetDynamicResourceHeap:
+    case kIROp_LoadResourceDescriptorFromHeap:
+    case kIROp_LoadSamplerDescriptorFromHeap:
+    case kIROp_SPIRVLoadDescriptorFromHeap:
+    case kIROp_SPIRVLoadTexelPointerFromHeap:
+    case kIROp_SPIRVResourceHeap:
+    case kIROp_SPIRVSamplerHeap:
+        // Target-independent and SPIR-V descriptor-heap ops can still be present when metadata
+        // is collected; SPIR-V descriptor-heap extension tests cover these cases.
+        return true;
+    case kIROp_CastDescriptorHandleToResource:
+    case kIROp_CastResourceToDescriptorHandle:
+    case kIROp_CastUInt2ToDescriptorHandle:
+    case kIROp_CastDescriptorHandleToUInt2:
+    case kIROp_CastUInt64ToDescriptorHandle:
+    case kIROp_CastDescriptorHandleToUInt64:
+        // These casts can survive into target IR and still indicate a descriptor-handle path that
+        // needs the bindless resource heap.
+        return true;
+    default:
+        return false;
+    }
+}
+
+static bool doesInstAndChildrenUseBindlessResourceHeap(IRInst* inst, SlangInt bindlessSpaceIndex)
+{
+    if (_instUsesBindlessResourceHeap(inst, bindlessSpaceIndex))
+        return true;
+
+    for (auto child : inst->getChildren())
+        if (doesInstAndChildrenUseBindlessResourceHeap(child, bindlessSpaceIndex))
+            return true;
+
+    return false;
+}
+
 void collectMetadataFromInst(IRInst* param, ArtifactPostEmitMetadata& outMetadata)
 {
     auto layoutDecoration = param->findDecoration<IRLayoutDecoration>();
@@ -190,12 +273,30 @@ void collectMetadataFromInst(IRInst* param, ArtifactPostEmitMetadata& outMetadat
 }
 
 // Collects the metadata from the provided IR module, saves it in outMetadata.
-void collectMetadata(const IRModule* irModule, ArtifactPostEmitMetadata& outMetadata)
+void collectMetadata(
+    const IRModule* irModule,
+    TargetProgram* targetProgram,
+    ArtifactPostEmitMetadata& outMetadata)
 {
+    SLANG_ASSERT(targetProgram);
+
+    SlangInt bindlessSpaceIndex = -1;
+    if (auto programLayout = targetProgram->getExistingLayout())
+    {
+        bindlessSpaceIndex = programLayout->bindlessSpaceIndex;
+    }
+
     // Scan the instructions looking for global resource declarations
     // and exported functions.
+    bool usesBindlessResourceHeap = false;
     for (const auto& inst : irModule->getGlobalInsts())
     {
+        if (bindlessSpaceIndex >= 0 && !usesBindlessResourceHeap)
+        {
+            if (doesInstAndChildrenUseBindlessResourceHeap(inst, bindlessSpaceIndex))
+                usesBindlessResourceHeap = true;
+        }
+
         if (auto func = as<IRFunc>(inst))
         {
             if (func->findDecoration<IRDownstreamModuleExportDecoration>())
@@ -216,6 +317,7 @@ void collectMetadata(const IRModule* irModule, ArtifactPostEmitMetadata& outMeta
             continue;
         collectMetadataFromInst(param, outMetadata);
     }
+    outMetadata.m_usesBindlessResourceHeap = usesBindlessResourceHeap;
 }
 
 static SlangScalarType _getScalarTypeFromIRType(IRType* type)

source/slang/slang-ir-metadata.h

@@ -7,6 +7,7 @@ namespace Slang
 class ArtifactPostEmitMetadata;
 class DiagnosticSink;
 struct IRModule;
+class TargetProgram;
 
 // Walks `irModule` and records metadata for the target-visible cooperative
 // matrix/vector types and combinations. For each cooperative operation, the
@@ -17,6 +18,9 @@ void collectCooperativeMetadata(
     DiagnosticSink* sink,
     ArtifactPostEmitMetadata& outMetadata);
 
-void collectMetadata(const IRModule* irModule, ArtifactPostEmitMetadata& outMetadata);
+void collectMetadata(
+    const IRModule* irModule,
+    TargetProgram* targetProgram,
+    ArtifactPostEmitMetadata& outMetadata);
 
 } // namespace Slang