https://github.com/joaosaffran updated https://github.com/llvm/llvm-project/pull/146785
>From 76d633d2b2b70ae6eaa1e7c40ef09e5f6ef9ae74 Mon Sep 17 00:00:00 2001 From: joaosaffran <joao.saff...@microsoft.com> Date: Thu, 26 Jun 2025 19:28:01 +0000 Subject: [PATCH 1/5] refactoring --- .../lib/Target/DirectX/DXContainerGlobals.cpp | 9 ++-- llvm/lib/Target/DirectX/DXILRootSignature.cpp | 12 ++--- llvm/lib/Target/DirectX/DXILRootSignature.h | 45 ++++++++++++++----- 3 files changed, 44 insertions(+), 22 deletions(-) diff --git a/llvm/lib/Target/DirectX/DXContainerGlobals.cpp b/llvm/lib/Target/DirectX/DXContainerGlobals.cpp index 9c38901f6821f..fa27c4665cfbe 100644 --- a/llvm/lib/Target/DirectX/DXContainerGlobals.cpp +++ b/llvm/lib/Target/DirectX/DXContainerGlobals.cpp @@ -160,18 +160,17 @@ void DXContainerGlobals::addRootSignature(Module &M, assert(MMI.EntryPropertyVec.size() == 1); - auto &RSA = getAnalysis<RootSignatureAnalysisWrapper>(); + auto &RSA = getAnalysis<RootSignatureAnalysisWrapper>().getRSInfo(); const Function *EntryFunction = MMI.EntryPropertyVec[0].Entry; - const auto &FuncRs = RSA.find(EntryFunction); + const auto &RS = RSA.getDescForFunction(EntryFunction); - if (FuncRs == RSA.end()) + if (!RS ) return; - const RootSignatureDesc &RS = FuncRs->second; SmallString<256> Data; raw_svector_ostream OS(Data); - RS.write(OS); + RS->write(OS); Constant *Constant = ConstantDataArray::getString(M.getContext(), Data, /*AddNull*/ false); diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp index 29e78fcce5262..4094df160ef6f 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp +++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp @@ -554,9 +554,9 @@ analyzeModule(Module &M) { AnalysisKey RootSignatureAnalysis::Key; -SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> -RootSignatureAnalysis::run(Module &M, ModuleAnalysisManager &AM) { - return analyzeModule(M); +RootSignatureBindingInfo RootSignatureAnalysis::run(Module &M, + ModuleAnalysisManager &AM) { + return RootSignatureBindingInfo(analyzeModule(M)); } //===----------------------------------------------------------------------===// @@ -564,8 +564,7 @@ RootSignatureAnalysis::run(Module &M, ModuleAnalysisManager &AM) { PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M, ModuleAnalysisManager &AM) { - SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> &RSDMap = - AM.getResult<RootSignatureAnalysis>(M); + RootSignatureBindingInfo &RSDMap = AM.getResult<RootSignatureAnalysis>(M); OS << "Root Signature Definitions" << "\n"; @@ -636,7 +635,8 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M, //===----------------------------------------------------------------------===// bool RootSignatureAnalysisWrapper::runOnModule(Module &M) { - FuncToRsMap = analyzeModule(M); + FuncToRsMap = std::make_unique<RootSignatureBindingInfo>( + RootSignatureBindingInfo(analyzeModule(M))); return false; } diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.h b/llvm/lib/Target/DirectX/DXILRootSignature.h index b45cebc15fd39..fef933811f840 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.h +++ b/llvm/lib/Target/DirectX/DXILRootSignature.h @@ -33,16 +33,43 @@ enum class RootSignatureElementKind { CBV = 5, DescriptorTable = 6, }; + +class RootSignatureBindingInfo { + private: + SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> FuncToRsMap; + + public: + using iterator = + SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc>::iterator; + + RootSignatureBindingInfo () = default; + RootSignatureBindingInfo(SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> Map) : FuncToRsMap(Map) {}; + + iterator find(const Function *F) { return FuncToRsMap.find(F); } + + iterator end() { return FuncToRsMap.end(); } + + std::optional<mcdxbc::RootSignatureDesc> getDescForFunction(const Function* F) { + const auto FuncRs = find(F); + if (FuncRs == end()) + return std::nullopt; + + return FuncRs->second; + } + +}; + class RootSignatureAnalysis : public AnalysisInfoMixin<RootSignatureAnalysis> { friend AnalysisInfoMixin<RootSignatureAnalysis>; static AnalysisKey Key; public: - RootSignatureAnalysis() = default; - using Result = SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc>; +RootSignatureAnalysis() = default; - SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> + using Result = RootSignatureBindingInfo; + + RootSignatureBindingInfo run(Module &M, ModuleAnalysisManager &AM); }; @@ -52,20 +79,16 @@ class RootSignatureAnalysis : public AnalysisInfoMixin<RootSignatureAnalysis> { /// passes which run through the legacy pass manager. class RootSignatureAnalysisWrapper : public ModulePass { private: - SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> FuncToRsMap; + std::unique_ptr<RootSignatureBindingInfo> FuncToRsMap; public: static char ID; + using Result = RootSignatureBindingInfo; RootSignatureAnalysisWrapper() : ModulePass(ID) {} - using iterator = - SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc>::iterator; - - iterator find(const Function *F) { return FuncToRsMap.find(F); } - - iterator end() { return FuncToRsMap.end(); } - + RootSignatureBindingInfo& getRSInfo() {return *FuncToRsMap;} + bool runOnModule(Module &M) override; void getAnalysisUsage(AnalysisUsage &AU) const override; >From 75d070360b11589a9a71e5711e3e807943f3b8f3 Mon Sep 17 00:00:00 2001 From: joaosaffran <joao.saff...@microsoft.com> Date: Thu, 26 Jun 2025 21:37:11 +0000 Subject: [PATCH 2/5] init refactoring --- .../SemaHLSL/RootSignature-Validation.hlsl | 42 +++++++++++++++++ .../lib/Target/DirectX/DXContainerGlobals.cpp | 2 +- .../DXILPostOptimizationValidation.cpp | 47 +++++++++++++++++-- llvm/lib/Target/DirectX/DXILRootSignature.h | 30 ++++++------ 4 files changed, 102 insertions(+), 19 deletions(-) create mode 100644 clang/test/SemaHLSL/RootSignature-Validation.hlsl diff --git a/clang/test/SemaHLSL/RootSignature-Validation.hlsl b/clang/test/SemaHLSL/RootSignature-Validation.hlsl new file mode 100644 index 0000000000000..8a4a97f87cb65 --- /dev/null +++ b/clang/test/SemaHLSL/RootSignature-Validation.hlsl @@ -0,0 +1,42 @@ +// RUN: %clang_dxc -triple dxil-pc-shadermodel6.3-library -x hlsl -o - %s -verify + +#define ROOT_SIGNATURE \ + "RootFlags(ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT), " \ + "CBV(b0, visibility=SHADER_VISIBILITY_ALL), " \ + "DescriptorTable(SRV(t0, numDescriptors=3), visibility=SHADER_VISIBILITY_PIXEL), " \ + "DescriptorTable(Sampler(s0, numDescriptors=2), visibility=SHADER_VISIBILITY_PIXEL), " \ + "DescriptorTable(UAV(u0, numDescriptors=1), visibility=SHADER_VISIBILITY_ALL)" + +cbuffer CB : register(b3, space2) { + float a; +} + +StructuredBuffer<int> In : register(t0); +RWStructuredBuffer<int> Out : register(u0); + +RWBuffer<float> UAV : register(u3); + +RWBuffer<float> UAV1 : register(u2), UAV2 : register(u4); + +RWBuffer<float> UAV3 : register(space5); + +float f : register(c5); + +int4 intv : register(c2); + +double dar[5] : register(c3); + +struct S { + int a; +}; + +S s : register(c10); + +// Compute Shader for UAV testing +[numthreads(8, 8, 1)] +[RootSignature(ROOT_SIGNATURE)] +void CSMain(uint3 id : SV_DispatchThreadID) +{ + In[0] = id; + Out[0] = In[0]; +} diff --git a/llvm/lib/Target/DirectX/DXContainerGlobals.cpp b/llvm/lib/Target/DirectX/DXContainerGlobals.cpp index fa27c4665cfbe..6c8ae8eaaea77 100644 --- a/llvm/lib/Target/DirectX/DXContainerGlobals.cpp +++ b/llvm/lib/Target/DirectX/DXContainerGlobals.cpp @@ -164,7 +164,7 @@ void DXContainerGlobals::addRootSignature(Module &M, const Function *EntryFunction = MMI.EntryPropertyVec[0].Entry; const auto &RS = RSA.getDescForFunction(EntryFunction); - if (!RS ) + if (!RS) return; SmallString<256> Data; diff --git a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp index 398dcbb8d1737..daf53fefe5f17 100644 --- a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp +++ b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp @@ -7,11 +7,14 @@ //===----------------------------------------------------------------------===// #include "DXILPostOptimizationValidation.h" +#include "DXILRootSignature.h" #include "DXILShaderFlags.h" #include "DirectX.h" +#include "llvm/ADT/STLForwardCompat.h" #include "llvm/ADT/SmallString.h" #include "llvm/Analysis/DXILMetadataAnalysis.h" #include "llvm/Analysis/DXILResource.h" +#include "llvm/BinaryFormat/DXContainer.h" #include "llvm/IR/DiagnosticInfo.h" #include "llvm/IR/Instructions.h" #include "llvm/IR/IntrinsicsDirectX.h" @@ -85,7 +88,9 @@ static void reportOverlappingBinding(Module &M, DXILResourceMap &DRM) { } static void reportErrors(Module &M, DXILResourceMap &DRM, - DXILResourceBindingInfo &DRBI) { + DXILResourceBindingInfo &DRBI, + RootSignatureBindingInfo &RSBI, + dxil::ModuleMetadataInfo &MMI) { if (DRM.hasInvalidCounterDirection()) reportInvalidDirection(M, DRM); @@ -94,6 +99,30 @@ static void reportErrors(Module &M, DXILResourceMap &DRM, assert(!DRBI.hasImplicitBinding() && "implicit bindings should be handled in " "DXILResourceImplicitBinding pass"); + // Assuming this is used to validate only the root signature assigned to the + // entry function. + std::optional<mcdxbc::RootSignatureDesc> RootSigDesc = + RSBI.getDescForFunction(MMI.EntryPropertyVec[0].Entry); + if (!RootSigDesc) + return; + + for (const mcdxbc::RootParameterInfo &Info : + RootSigDesc->ParametersContainer) { + const auto &[Type, Loc] = + RootSigDesc->ParametersContainer.getTypeAndLocForParameter( + Info.Location); + switch (Type) { + case llvm::to_underlying(dxbc::RootParameterType::CBV): + dxbc::RTS0::v2::RootDescriptor Desc = + RootSigDesc->ParametersContainer.getRootDescriptor(Loc); + + llvm::dxil::ResourceInfo::ResourceBinding Binding; + Binding.LowerBound = Desc.ShaderRegister; + Binding.Space = Desc.RegisterSpace; + Binding.Size = 1; + break; + } + } } } // namespace @@ -101,7 +130,10 @@ PreservedAnalyses DXILPostOptimizationValidation::run(Module &M, ModuleAnalysisManager &MAM) { DXILResourceMap &DRM = MAM.getResult<DXILResourceAnalysis>(M); DXILResourceBindingInfo &DRBI = MAM.getResult<DXILResourceBindingAnalysis>(M); - reportErrors(M, DRM, DRBI); + RootSignatureBindingInfo &RSBI = MAM.getResult<RootSignatureAnalysis>(M); + ModuleMetadataInfo &MMI = MAM.getResult<DXILMetadataAnalysis>(M); + + reportErrors(M, DRM, DRBI, RSBI, MMI); return PreservedAnalyses::all(); } @@ -113,7 +145,13 @@ class DXILPostOptimizationValidationLegacy : public ModulePass { getAnalysis<DXILResourceWrapperPass>().getResourceMap(); DXILResourceBindingInfo &DRBI = getAnalysis<DXILResourceBindingWrapperPass>().getBindingInfo(); - reportErrors(M, DRM, DRBI); + + RootSignatureBindingInfo &RSBI = + getAnalysis<RootSignatureAnalysisWrapper>().getRSInfo(); + dxil::ModuleMetadataInfo &MMI = + getAnalysis<DXILMetadataAnalysisWrapperPass>().getModuleMetadata(); + + reportErrors(M, DRM, DRBI, RSBI, MMI); return false; } StringRef getPassName() const override { @@ -125,10 +163,13 @@ class DXILPostOptimizationValidationLegacy : public ModulePass { void getAnalysisUsage(llvm::AnalysisUsage &AU) const override { AU.addRequired<DXILResourceWrapperPass>(); AU.addRequired<DXILResourceBindingWrapperPass>(); + AU.addRequired<RootSignatureAnalysisWrapper>(); + AU.addRequired<DXILMetadataAnalysisWrapperPass>(); AU.addPreserved<DXILResourceWrapperPass>(); AU.addPreserved<DXILResourceBindingWrapperPass>(); AU.addPreserved<DXILMetadataAnalysisWrapperPass>(); AU.addPreserved<ShaderFlagsAnalysisWrapper>(); + AU.addPreserved<RootSignatureAnalysisWrapper>(); } }; char DXILPostOptimizationValidationLegacy::ID = 0; diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.h b/llvm/lib/Target/DirectX/DXILRootSignature.h index fef933811f840..c29413d21036c 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.h +++ b/llvm/lib/Target/DirectX/DXILRootSignature.h @@ -35,28 +35,30 @@ enum class RootSignatureElementKind { }; class RootSignatureBindingInfo { - private: - SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> FuncToRsMap; +private: + SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> FuncToRsMap; - public: +public: using iterator = - SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc>::iterator; + SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc>::iterator; - RootSignatureBindingInfo () = default; - RootSignatureBindingInfo(SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> Map) : FuncToRsMap(Map) {}; + RootSignatureBindingInfo() = default; + RootSignatureBindingInfo( + SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> Map) + : FuncToRsMap(Map){}; iterator find(const Function *F) { return FuncToRsMap.find(F); } iterator end() { return FuncToRsMap.end(); } - std::optional<mcdxbc::RootSignatureDesc> getDescForFunction(const Function* F) { + std::optional<mcdxbc::RootSignatureDesc> + getDescForFunction(const Function *F) { const auto FuncRs = find(F); if (FuncRs == end()) return std::nullopt; return FuncRs->second; } - }; class RootSignatureAnalysis : public AnalysisInfoMixin<RootSignatureAnalysis> { @@ -64,13 +66,11 @@ class RootSignatureAnalysis : public AnalysisInfoMixin<RootSignatureAnalysis> { static AnalysisKey Key; public: - -RootSignatureAnalysis() = default; + RootSignatureAnalysis() = default; using Result = RootSignatureBindingInfo; - - RootSignatureBindingInfo - run(Module &M, ModuleAnalysisManager &AM); + + RootSignatureBindingInfo run(Module &M, ModuleAnalysisManager &AM); }; /// Wrapper pass for the legacy pass manager. @@ -87,8 +87,8 @@ class RootSignatureAnalysisWrapper : public ModulePass { RootSignatureAnalysisWrapper() : ModulePass(ID) {} - RootSignatureBindingInfo& getRSInfo() {return *FuncToRsMap;} - + RootSignatureBindingInfo &getRSInfo() { return *FuncToRsMap; } + bool runOnModule(Module &M) override; void getAnalysisUsage(AnalysisUsage &AU) const override; >From dd2f7ca9a2b1033e74e90350c6815ae50341a713 Mon Sep 17 00:00:00 2001 From: joaosaffran <joao.saff...@microsoft.com> Date: Wed, 2 Jul 2025 17:58:56 +0000 Subject: [PATCH 3/5] adding validation --- .../SemaHLSL/RootSignature-Validation.hlsl | 28 ++++--------- .../DXILPostOptimizationValidation.cpp | 42 +++++++++++++++---- 2 files changed, 43 insertions(+), 27 deletions(-) diff --git a/clang/test/SemaHLSL/RootSignature-Validation.hlsl b/clang/test/SemaHLSL/RootSignature-Validation.hlsl index 8a4a97f87cb65..62ba704b95c7d 100644 --- a/clang/test/SemaHLSL/RootSignature-Validation.hlsl +++ b/clang/test/SemaHLSL/RootSignature-Validation.hlsl @@ -1,42 +1,30 @@ -// RUN: %clang_dxc -triple dxil-pc-shadermodel6.3-library -x hlsl -o - %s -verify #define ROOT_SIGNATURE \ "RootFlags(ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT), " \ - "CBV(b0, visibility=SHADER_VISIBILITY_ALL), " \ - "DescriptorTable(SRV(t0, numDescriptors=3), visibility=SHADER_VISIBILITY_PIXEL), " \ - "DescriptorTable(Sampler(s0, numDescriptors=2), visibility=SHADER_VISIBILITY_PIXEL), " \ - "DescriptorTable(UAV(u0, numDescriptors=1), visibility=SHADER_VISIBILITY_ALL)" + "CBV(b3, space=1, visibility=SHADER_VISIBILITY_ALL), " \ + "DescriptorTable(SRV(t0, space=0, numDescriptors=1), visibility=SHADER_VISIBILITY_ALL), " \ + "DescriptorTable(Sampler(s0, numDescriptors=2), visibility=SHADER_VISIBILITY_ALL), " \ + "DescriptorTable(UAV(u0, numDescriptors=unbounded), visibility=SHADER_VISIBILITY_ALL)" cbuffer CB : register(b3, space2) { float a; } -StructuredBuffer<int> In : register(t0); +StructuredBuffer<int> In : register(t0, space0); RWStructuredBuffer<int> Out : register(u0); RWBuffer<float> UAV : register(u3); RWBuffer<float> UAV1 : register(u2), UAV2 : register(u4); -RWBuffer<float> UAV3 : register(space5); +RWBuffer<float> UAV3 : register(space0); -float f : register(c5); -int4 intv : register(c2); - -double dar[5] : register(c3); - -struct S { - int a; -}; - -S s : register(c10); // Compute Shader for UAV testing [numthreads(8, 8, 1)] [RootSignature(ROOT_SIGNATURE)] -void CSMain(uint3 id : SV_DispatchThreadID) +void CSMain(uint id : SV_GroupID) { - In[0] = id; - Out[0] = In[0]; + Out[0] = a + id + In[0] + UAV[0] + UAV1[0] + UAV3[0]; } diff --git a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp index daf53fefe5f17..3e542e502c2d5 100644 --- a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp +++ b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp @@ -10,6 +10,7 @@ #include "DXILRootSignature.h" #include "DXILShaderFlags.h" #include "DirectX.h" +#include "llvm/ADT/IntervalMap.h" #include "llvm/ADT/STLForwardCompat.h" #include "llvm/ADT/SmallString.h" #include "llvm/Analysis/DXILMetadataAnalysis.h" @@ -86,7 +87,9 @@ static void reportOverlappingBinding(Module &M, DXILResourceMap &DRM) { } } } - + uint64_t combine_uint32_to_uint64(uint32_t high, uint32_t low) { + return (static_cast<uint64_t>(high) << 32) | low; + } static void reportErrors(Module &M, DXILResourceMap &DRM, DXILResourceBindingInfo &DRBI, RootSignatureBindingInfo &RSBI, @@ -101,18 +104,24 @@ static void reportErrors(Module &M, DXILResourceMap &DRM, "DXILResourceImplicitBinding pass"); // Assuming this is used to validate only the root signature assigned to the // entry function. + //Start test stuff + if(MMI.EntryPropertyVec.size() == 0) + return; + std::optional<mcdxbc::RootSignatureDesc> RootSigDesc = RSBI.getDescForFunction(MMI.EntryPropertyVec[0].Entry); if (!RootSigDesc) return; - for (const mcdxbc::RootParameterInfo &Info : - RootSigDesc->ParametersContainer) { + using MapT = llvm::IntervalMap<uint64_t, llvm::dxil::ResourceInfo::ResourceBinding, sizeof(llvm::dxil::ResourceInfo::ResourceBinding), llvm::IntervalMapInfo<uint64_t>>; + MapT::Allocator Allocator; + MapT BindingsMap(Allocator); + auto RSD = *RootSigDesc; + for (size_t I = 0; I < RSD.ParametersContainer.size(); I++) { const auto &[Type, Loc] = - RootSigDesc->ParametersContainer.getTypeAndLocForParameter( - Info.Location); + RootSigDesc->ParametersContainer.getTypeAndLocForParameter(I); switch (Type) { - case llvm::to_underlying(dxbc::RootParameterType::CBV): + case llvm::to_underlying(dxbc::RootParameterType::CBV):{ dxbc::RTS0::v2::RootDescriptor Desc = RootSigDesc->ParametersContainer.getRootDescriptor(Loc); @@ -120,8 +129,27 @@ static void reportErrors(Module &M, DXILResourceMap &DRM, Binding.LowerBound = Desc.ShaderRegister; Binding.Space = Desc.RegisterSpace; Binding.Size = 1; + + BindingsMap.insert(combine_uint32_to_uint64(Binding.Space, Binding.LowerBound), combine_uint32_to_uint64(Binding.Space, Binding.LowerBound + Binding.Size -1), Binding); break; } + // case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable):{ + // mcdxbc::DescriptorTable Table = + // RootSigDesc->ParametersContainer.getDescriptorTable(Loc); + // for (const dxbc::RTS0::v2::DescriptorRange &Range : Table){ + // Range. + // } + + // break; + // } + } + + } + + for(const auto &CBuf : DRM.cbuffers()) { + auto Binding = CBuf.getBinding(); + if(!BindingsMap.overlaps(combine_uint32_to_uint64(Binding.Space, Binding.LowerBound), combine_uint32_to_uint64(Binding.Space, Binding.LowerBound + Binding.Size -1))) + auto X = 1; } } } // namespace @@ -146,7 +174,7 @@ class DXILPostOptimizationValidationLegacy : public ModulePass { DXILResourceBindingInfo &DRBI = getAnalysis<DXILResourceBindingWrapperPass>().getBindingInfo(); - RootSignatureBindingInfo &RSBI = + RootSignatureBindingInfo& RSBI = getAnalysis<RootSignatureAnalysisWrapper>().getRSInfo(); dxil::ModuleMetadataInfo &MMI = getAnalysis<DXILMetadataAnalysisWrapperPass>().getModuleMetadata(); >From 545372b87ffa358c410174d6f594def97f833691 Mon Sep 17 00:00:00 2001 From: joaosaffran <joao.saff...@microsoft.com> Date: Wed, 2 Jul 2025 21:19:37 +0000 Subject: [PATCH 4/5] clean --- .../DXILPostOptimizationValidation.cpp | 4 ---- .../DirectX/DXILPostOptimizationValidation.h | 4 ---- llvm/lib/Target/DirectX/DXILRootSignature.h | 24 +++++++++---------- 3 files changed, 11 insertions(+), 21 deletions(-) diff --git a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp index a239aa2633a9f..b5ea6d8e0257a 100644 --- a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp +++ b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp @@ -9,17 +9,14 @@ #include "DXILPostOptimizationValidation.h" #include "DXILShaderFlags.h" #include "DirectX.h" -#include "llvm/ADT/STLForwardCompat.h" #include "llvm/ADT/SmallString.h" #include "llvm/Analysis/DXILMetadataAnalysis.h" #include "llvm/Analysis/DXILResource.h" -#include "llvm/BinaryFormat/DXContainer.h" #include "llvm/IR/DiagnosticInfo.h" #include "llvm/IR/Instructions.h" #include "llvm/IR/IntrinsicsDirectX.h" #include "llvm/IR/Module.h" #include "llvm/InitializePasses.h" -#include <optional> #define DEBUG_TYPE "dxil-post-optimization-validation" @@ -168,7 +165,6 @@ class DXILPostOptimizationValidationLegacy : public ModulePass { getAnalysis<DXILResourceWrapperPass>().getResourceMap(); DXILResourceBindingInfo &DRBI = getAnalysis<DXILResourceBindingWrapperPass>().getBindingInfo(); - RootSignatureBindingInfo &RSBI = getAnalysis<RootSignatureAnalysisWrapper>().getRSInfo(); dxil::ModuleMetadataInfo &MMI = diff --git a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.h b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.h index b254b5e99c8e5..12c9bb2ffbbe6 100644 --- a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.h +++ b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.h @@ -16,12 +16,8 @@ #include "DXILRootSignature.h" #include "llvm/ADT/IntervalMap.h" -#include "llvm/ADT/STLForwardCompat.h" #include "llvm/Analysis/DXILResource.h" -#include "llvm/BinaryFormat/DXContainer.h" #include "llvm/IR/PassManager.h" -#include "llvm/Support/ErrorHandling.h" -#include <cstdint> namespace llvm { diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.h b/llvm/lib/Target/DirectX/DXILRootSignature.h index b84da7b999301..c28873a7fc3df 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.h +++ b/llvm/lib/Target/DirectX/DXILRootSignature.h @@ -36,30 +36,28 @@ enum class RootSignatureElementKind { }; class RootSignatureBindingInfo { -private: - SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> FuncToRsMap; + private: + SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> FuncToRsMap; -public: + public: using iterator = - SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc>::iterator; + SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc>::iterator; - RootSignatureBindingInfo() = default; - RootSignatureBindingInfo( - SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> Map) - : FuncToRsMap(Map){}; +RootSignatureBindingInfo () = default; + RootSignatureBindingInfo(SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> Map) : FuncToRsMap(Map) {}; iterator find(const Function *F) { return FuncToRsMap.find(F); } iterator end() { return FuncToRsMap.end(); } - std::optional<mcdxbc::RootSignatureDesc> - getDescForFunction(const Function *F) { + std::optional<mcdxbc::RootSignatureDesc> getDescForFunction(const Function *F) { const auto FuncRs = find(F); if (FuncRs == end()) return std::nullopt; return FuncRs->second; } + }; class RootSignatureAnalysis : public AnalysisInfoMixin<RootSignatureAnalysis> { @@ -67,7 +65,7 @@ class RootSignatureAnalysis : public AnalysisInfoMixin<RootSignatureAnalysis> { static AnalysisKey Key; public: - RootSignatureAnalysis() = default; +RootSignatureAnalysis() = default; using Result = RootSignatureBindingInfo; @@ -91,8 +89,8 @@ class RootSignatureAnalysisWrapper : public ModulePass { using Result = RootSignatureBindingInfo; RootSignatureAnalysisWrapper() : ModulePass(ID) {} - - RootSignatureBindingInfo &getRSInfo() { return *FuncToRsMap; } + + RootSignatureBindingInfo& getRSInfo() {return *FuncToRsMap;} bool runOnModule(Module &M) override; >From 07aeb7f6048b60061b58cd6e1cea5ea1b2e5a75a Mon Sep 17 00:00:00 2001 From: joaosaffran <joao.saff...@microsoft.com> Date: Fri, 4 Jul 2025 02:03:26 +0000 Subject: [PATCH 5/5] implementing --- .../RootSignature-Validation-Fail.hlsl | 35 +++++ .../SemaHLSL/RootSignature-Validation.hlsl | 11 +- .../DXILPostOptimizationValidation.cpp | 120 +++++++++++++++--- .../DirectX/DXILPostOptimizationValidation.h | 77 +++++------ llvm/lib/Target/DirectX/DXILRootSignature.h | 24 ++-- .../RootSignature-DescriptorTable.ll | 4 +- 6 files changed, 197 insertions(+), 74 deletions(-) create mode 100644 clang/test/SemaHLSL/RootSignature-Validation-Fail.hlsl diff --git a/clang/test/SemaHLSL/RootSignature-Validation-Fail.hlsl b/clang/test/SemaHLSL/RootSignature-Validation-Fail.hlsl new file mode 100644 index 0000000000000..b590ed67e7085 --- /dev/null +++ b/clang/test/SemaHLSL/RootSignature-Validation-Fail.hlsl @@ -0,0 +1,35 @@ +// RUN: not %clang_dxc -T cs_6_6 -E CSMain %s 2>&1 | FileCheck %s + +// CHECK: error: register cbuffer (space=665, register=3) is not defined in Root Signature +// CHECK: error: register srv (space=0, register=0) is not defined in Root Signature +// CHECK: error: register uav (space=0, register=4294967295) is not defined in Root Signature + + +#define ROOT_SIGNATURE \ + "CBV(b3, space=666, visibility=SHADER_VISIBILITY_ALL), " \ + "DescriptorTable(SRV(t0, space=0, numDescriptors=1), visibility=SHADER_VISIBILITY_VERTEX), " \ + "DescriptorTable(Sampler(s0, numDescriptors=2), visibility=SHADER_VISIBILITY_ALL), " \ + "DescriptorTable(UAV(u0, numDescriptors=unbounded), visibility=SHADER_VISIBILITY_ALL)" + +cbuffer CB : register(b3, space665) { + float a; +} + +StructuredBuffer<int> In : register(t0, space0); +RWStructuredBuffer<int> Out : register(u0); + +RWBuffer<float> UAV : register(u4294967295); + +RWBuffer<float> UAV1 : register(u2), UAV2 : register(u4); + +RWBuffer<float> UAV3 : register(space0); + + + +// Compute Shader for UAV testing +[numthreads(8, 8, 1)] +[RootSignature(ROOT_SIGNATURE)] +void CSMain(uint id : SV_GroupID) +{ + Out[0] = a + id + In[0] + UAV[0] + UAV1[0] + UAV3[0]; +} diff --git a/clang/test/SemaHLSL/RootSignature-Validation.hlsl b/clang/test/SemaHLSL/RootSignature-Validation.hlsl index 62ba704b95c7d..5a7f5baf00619 100644 --- a/clang/test/SemaHLSL/RootSignature-Validation.hlsl +++ b/clang/test/SemaHLSL/RootSignature-Validation.hlsl @@ -1,19 +1,22 @@ +// RUN: %clang_dxc -T cs_6_6 -E CSMain %s 2>&1 + +// expected-no-diagnostics + #define ROOT_SIGNATURE \ - "RootFlags(ALLOW_INPUT_ASSEMBLER_INPUT_LAYOUT), " \ "CBV(b3, space=1, visibility=SHADER_VISIBILITY_ALL), " \ "DescriptorTable(SRV(t0, space=0, numDescriptors=1), visibility=SHADER_VISIBILITY_ALL), " \ - "DescriptorTable(Sampler(s0, numDescriptors=2), visibility=SHADER_VISIBILITY_ALL), " \ + "DescriptorTable(Sampler(s0, numDescriptors=2), visibility=SHADER_VISIBILITY_VERTEX), " \ "DescriptorTable(UAV(u0, numDescriptors=unbounded), visibility=SHADER_VISIBILITY_ALL)" -cbuffer CB : register(b3, space2) { +cbuffer CB : register(b3, space1) { float a; } StructuredBuffer<int> In : register(t0, space0); RWStructuredBuffer<int> Out : register(u0); -RWBuffer<float> UAV : register(u3); +RWBuffer<float> UAV : register(u4294967294); RWBuffer<float> UAV1 : register(u2), UAV2 : register(u4); diff --git a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp index b5ea6d8e0257a..82f061cf61ad7 100644 --- a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp +++ b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp @@ -84,9 +84,42 @@ static void reportOverlappingBinding(Module &M, DXILResourceMap &DRM) { } } -static void reportRegNotBound(Module &M, +static void reportRegNotBound(Module &M, Twine Type, ResourceInfo::ResourceBinding Binding) { - // TODO + SmallString<128> Message; + raw_svector_ostream OS(Message); + OS << "register " << Type << " (space=" << Binding.Space + << ", register=" << Binding.LowerBound << ")" + << " is not defined in Root Signature"; + M.getContext().diagnose(DiagnosticInfoGeneric(Message)); +} + +static dxbc::ShaderVisibility +tripleToVisibility(llvm::Triple::EnvironmentType ET) { + assert((ET == Triple::Pixel || ET == Triple::Vertex || + ET == Triple::Geometry || ET == Triple::Hull || + ET == Triple::Domain || ET == Triple::Mesh || + ET == Triple::Compute) && + "Invalid Triple to shader stage conversion"); + + switch (ET) { + case Triple::Pixel: + return dxbc::ShaderVisibility::Pixel; + case Triple::Vertex: + return dxbc::ShaderVisibility::Vertex; + case Triple::Geometry: + return dxbc::ShaderVisibility::Geometry; + case Triple::Hull: + return dxbc::ShaderVisibility::Hull; + case Triple::Domain: + return dxbc::ShaderVisibility::Domain; + case Triple::Mesh: + return dxbc::ShaderVisibility::Mesh; + case Triple::Compute: + return dxbc::ShaderVisibility::All; + default: + llvm_unreachable("Invalid triple to shader stage conversion"); + } } std::optional<mcdxbc::RootSignatureDesc> @@ -117,35 +150,92 @@ static void reportErrors(Module &M, DXILResourceMap &DRM, if (auto RSD = getRootSignature(RSBI, MMI)) { RootSignatureBindingValidation Validation; - Validation.addRsBindingInfo(*RSD); + Validation.addRsBindingInfo(*RSD, tripleToVisibility(MMI.ShaderProfile)); for (const auto &CBuf : DRM.cbuffers()) { ResourceInfo::ResourceBinding Binding = CBuf.getBinding(); - if (!Validation.checkCregBinding(Binding.Space, Binding.LowerBound, - Binding.Space, - Binding.LowerBound + Binding.Size - 1)) - reportRegNotBound(M, Binding); + if (!Validation.checkCregBinding(Binding)) + reportRegNotBound(M, "cbuffer", Binding); } for (const auto &CBuf : DRM.srvs()) { ResourceInfo::ResourceBinding Binding = CBuf.getBinding(); - if (!Validation.checkTRegBinding(Binding.Space, Binding.LowerBound, - Binding.Space, - Binding.LowerBound + Binding.Size - 1)) - reportRegNotBound(M, Binding); + if (!Validation.checkTRegBinding(Binding)) + reportRegNotBound(M, "srv", Binding); } for (const auto &CBuf : DRM.uavs()) { ResourceInfo::ResourceBinding Binding = CBuf.getBinding(); - if (!Validation.checkURegBinding(Binding.Space, Binding.LowerBound, - Binding.Space, - Binding.LowerBound + Binding.Size - 1)) - reportRegNotBound(M, Binding); + if (!Validation.checkURegBinding(Binding)) + reportRegNotBound(M, "uav", Binding); } } } } // namespace +void RootSignatureBindingValidation::addRsBindingInfo( + mcdxbc::RootSignatureDesc &RSD, dxbc::ShaderVisibility Visibility) { + for (size_t I = 0; I < RSD.ParametersContainer.size(); I++) { + const auto &[Type, Loc] = + RSD.ParametersContainer.getTypeAndLocForParameter(I); + + const auto &Header = RSD.ParametersContainer.getHeader(I); + switch (Type) { + case llvm::to_underlying(dxbc::RootParameterType::SRV): + case llvm::to_underlying(dxbc::RootParameterType::UAV): + case llvm::to_underlying(dxbc::RootParameterType::CBV): { + dxbc::RTS0::v2::RootDescriptor Desc = + RSD.ParametersContainer.getRootDescriptor(Loc); + + if (Header.ShaderVisibility == + llvm::to_underlying(dxbc::ShaderVisibility::All) || + Header.ShaderVisibility == llvm::to_underlying(Visibility)) + addRange(Desc, Type); + break; + } + case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): { + const mcdxbc::DescriptorTable &Table = + RSD.ParametersContainer.getDescriptorTable(Loc); + + for (const dxbc::RTS0::v2::DescriptorRange &Range : Table.Ranges) { + if (Range.RangeType == + llvm::to_underlying(dxbc::DescriptorRangeType::Sampler)) + continue; + + if (Header.ShaderVisibility == + llvm::to_underlying(dxbc::ShaderVisibility::All) || + Header.ShaderVisibility == llvm::to_underlying(Visibility)) + addRange(Range); + } + break; + } + } + } +} + +bool RootSignatureBindingValidation::checkCregBinding( + ResourceInfo::ResourceBinding Binding) { + return CRegBindingsMap.overlaps( + combineUint32ToUint64(Binding.Space, Binding.LowerBound), + combineUint32ToUint64(Binding.Space, + Binding.LowerBound + Binding.Size - 1)); +} + +bool RootSignatureBindingValidation::checkTRegBinding( + ResourceInfo::ResourceBinding Binding) { + return TRegBindingsMap.overlaps( + combineUint32ToUint64(Binding.Space, Binding.LowerBound), + combineUint32ToUint64(Binding.Space, Binding.LowerBound + Binding.Size)); +} + +bool RootSignatureBindingValidation::checkURegBinding( + ResourceInfo::ResourceBinding Binding) { + return URegBindingsMap.overlaps( + combineUint32ToUint64(Binding.Space, Binding.LowerBound), + combineUint32ToUint64(Binding.Space, + Binding.LowerBound + Binding.Size - 1)); +} + PreservedAnalyses DXILPostOptimizationValidation::run(Module &M, ModuleAnalysisManager &MAM) { DXILResourceMap &DRM = MAM.getResult<DXILResourceAnalysis>(M); diff --git a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.h b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.h index 12c9bb2ffbbe6..58113bf9f93c7 100644 --- a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.h +++ b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.h @@ -25,7 +25,6 @@ static uint64_t combineUint32ToUint64(uint32_t High, uint32_t Low) { return (static_cast<uint64_t>(High) << 32) | Low; } -// This should be somewhere else class RootSignatureBindingValidation { using MapT = llvm::IntervalMap<uint64_t, dxil::ResourceInfo::ResourceBinding, @@ -38,7 +37,7 @@ class RootSignatureBindingValidation { MapT TRegBindingsMap; MapT URegBindingsMap; - void addRange(dxbc::RTS0::v2::RootDescriptor Desc, uint32_t Type) { + void addRange(const dxbc::RTS0::v2::RootDescriptor &Desc, uint32_t Type) { assert((Type == llvm::to_underlying(dxbc::RootParameterType::CBV) || Type == llvm::to_underlying(dxbc::RootParameterType::SRV) || Type == llvm::to_underlying(dxbc::RootParameterType::UAV)) && @@ -58,13 +57,39 @@ class RootSignatureBindingValidation { case llvm::to_underlying(dxbc::RootParameterType::CBV): CRegBindingsMap.insert(LowRange, HighRange, Binding); - break; + return; case llvm::to_underlying(dxbc::RootParameterType::SRV): TRegBindingsMap.insert(LowRange, HighRange, Binding); - break; + return; case llvm::to_underlying(dxbc::RootParameterType::UAV): URegBindingsMap.insert(LowRange, HighRange, Binding); - break; + return; + } + llvm_unreachable("Invalid Type in add Range Method"); + } + + void addRange(const dxbc::RTS0::v2::DescriptorRange &Range) { + + llvm::dxil::ResourceInfo::ResourceBinding Binding; + Binding.LowerBound = Range.BaseShaderRegister; + Binding.Space = Range.RegisterSpace; + Binding.Size = Range.NumDescriptors; + + uint64_t LowRange = + combineUint32ToUint64(Binding.Space, Binding.LowerBound); + uint64_t HighRange = combineUint32ToUint64( + Binding.Space, Binding.LowerBound + Binding.Size - 1); + + switch (Range.RangeType) { + case llvm::to_underlying(dxbc::DescriptorRangeType::CBV): + CRegBindingsMap.insert(LowRange, HighRange, Binding); + return; + case llvm::to_underlying(dxbc::DescriptorRangeType::SRV): + TRegBindingsMap.insert(LowRange, HighRange, Binding); + return; + case llvm::to_underlying(dxbc::DescriptorRangeType::UAV): + URegBindingsMap.insert(LowRange, HighRange, Binding); + return; } llvm_unreachable("Invalid Type in add Range Method"); } @@ -74,46 +99,14 @@ class RootSignatureBindingValidation { : Allocator(), CRegBindingsMap(Allocator), TRegBindingsMap(Allocator), URegBindingsMap(Allocator) {} - void addRsBindingInfo(mcdxbc::RootSignatureDesc &RSD) { - for (size_t I = 0; I < RSD.ParametersContainer.size(); I++) { - const auto &[Type, Loc] = - RSD.ParametersContainer.getTypeAndLocForParameter(I); - - switch (Type) { - case llvm::to_underlying(dxbc::RootParameterType::SRV): - case llvm::to_underlying(dxbc::RootParameterType::UAV): - case llvm::to_underlying(dxbc::RootParameterType::CBV): { - dxbc::RTS0::v2::RootDescriptor Desc = - RSD.ParametersContainer.getRootDescriptor(Loc); - - addRange(Desc, Type); - break; - } - case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): { - // TODO; - break; - } - } - } - } + void addRsBindingInfo(mcdxbc::RootSignatureDesc &RSD, + dxbc::ShaderVisibility Visibility); - bool checkCregBinding(uint32_t StartSpace, uint32_t StartReg, - uint32_t EndSpace, uint32_t EndReg) { - return CRegBindingsMap.overlaps(combineUint32ToUint64(StartSpace, StartReg), - combineUint32ToUint64(EndSpace, EndReg)); - } + bool checkCregBinding(dxil::ResourceInfo::ResourceBinding Binding); - bool checkTRegBinding(uint32_t StartSpace, uint32_t StartReg, - uint32_t EndSpace, uint32_t EndReg) { - return TRegBindingsMap.overlaps(combineUint32ToUint64(StartSpace, StartReg), - combineUint32ToUint64(EndSpace, EndReg)); - } + bool checkTRegBinding(dxil::ResourceInfo::ResourceBinding Binding); - bool checkURegBinding(uint32_t StartSpace, uint32_t StartReg, - uint32_t EndSpace, uint32_t EndReg) { - return URegBindingsMap.overlaps(combineUint32ToUint64(StartSpace, StartReg), - combineUint32ToUint64(EndSpace, EndReg)); - } + bool checkURegBinding(dxil::ResourceInfo::ResourceBinding Binding); }; class DXILPostOptimizationValidation diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.h b/llvm/lib/Target/DirectX/DXILRootSignature.h index c28873a7fc3df..b84da7b999301 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.h +++ b/llvm/lib/Target/DirectX/DXILRootSignature.h @@ -36,28 +36,30 @@ enum class RootSignatureElementKind { }; class RootSignatureBindingInfo { - private: - SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> FuncToRsMap; +private: + SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> FuncToRsMap; - public: +public: using iterator = - SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc>::iterator; + SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc>::iterator; -RootSignatureBindingInfo () = default; - RootSignatureBindingInfo(SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> Map) : FuncToRsMap(Map) {}; + RootSignatureBindingInfo() = default; + RootSignatureBindingInfo( + SmallDenseMap<const Function *, mcdxbc::RootSignatureDesc> Map) + : FuncToRsMap(Map){}; iterator find(const Function *F) { return FuncToRsMap.find(F); } iterator end() { return FuncToRsMap.end(); } - std::optional<mcdxbc::RootSignatureDesc> getDescForFunction(const Function *F) { + std::optional<mcdxbc::RootSignatureDesc> + getDescForFunction(const Function *F) { const auto FuncRs = find(F); if (FuncRs == end()) return std::nullopt; return FuncRs->second; } - }; class RootSignatureAnalysis : public AnalysisInfoMixin<RootSignatureAnalysis> { @@ -65,7 +67,7 @@ class RootSignatureAnalysis : public AnalysisInfoMixin<RootSignatureAnalysis> { static AnalysisKey Key; public: -RootSignatureAnalysis() = default; + RootSignatureAnalysis() = default; using Result = RootSignatureBindingInfo; @@ -89,8 +91,8 @@ class RootSignatureAnalysisWrapper : public ModulePass { using Result = RootSignatureBindingInfo; RootSignatureAnalysisWrapper() : ModulePass(ID) {} - - RootSignatureBindingInfo& getRSInfo() {return *FuncToRsMap;} + + RootSignatureBindingInfo &getRSInfo() { return *FuncToRsMap; } bool runOnModule(Module &M) override; diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable.ll index b516d66180247..8e9b4b43b11a6 100644 --- a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable.ll +++ b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable.ll @@ -16,7 +16,7 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } !2 = !{ ptr @main, !3, i32 2 } ; function, root signature !3 = !{ !5 } ; list of root signature elements !5 = !{ !"DescriptorTable", i32 0, !6, !7 } -!6 = !{ !"SRV", i32 0, i32 1, i32 0, i32 -1, i32 4 } +!6 = !{ !"SRV", i32 1, i32 1, i32 0, i32 -1, i32 4 } !7 = !{ !"UAV", i32 5, i32 1, i32 10, i32 5, i32 2 } ; DXC: - Name: RTS0 @@ -35,7 +35,7 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } ; DXC-NEXT: RangesOffset: 44 ; DXC-NEXT: Ranges: ; DXC-NEXT: - RangeType: 0 -; DXC-NEXT: NumDescriptors: 0 +; DXC-NEXT: NumDescriptors: 1 ; DXC-NEXT: BaseShaderRegister: 1 ; DXC-NEXT: RegisterSpace: 0 ; DXC-NEXT: OffsetInDescriptorsFromTableStart: 4294967295 _______________________________________________ llvm-branch-commits mailing list llvm-branch-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits