From 31ec5e50ff36ba6d963443e8908f8fb58d7b89bf Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Mon, 18 Aug 2025 18:49:45 -0700 Subject: [PATCH 01/29] making parameter type and shader visibility use enums --- .../llvm/MC/DXContainerRootSignature.h | 27 ++++--- .../Frontend/HLSL/RootSignatureMetadata.cpp | 76 +++++++++++-------- llvm/lib/MC/DXContainerRootSignature.cpp | 20 ++--- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 19 +++-- llvm/lib/Target/DirectX/DXILRootSignature.cpp | 21 +++-- .../ContainerData/RootSignature-Parameters.ll | 60 +++++++-------- 6 files changed, 122 insertions(+), 101 deletions(-) diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index 3c7c886e79fc3..757ab8bc83129 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -19,13 +19,19 @@ namespace llvm { class raw_ostream; namespace mcdxbc { +struct RootParameterHeader { + dxbc::RootParameterType ParameterType; + dxbc::ShaderVisibility ShaderVisibility; + uint32_t ParameterOffset; +}; + struct RootParameterInfo { - dxbc::RTS0::v1::RootParameterHeader Header; + RootParameterHeader Header; size_t Location; RootParameterInfo() = default; - RootParameterInfo(dxbc::RTS0::v1::RootParameterHeader Header, size_t Location) + RootParameterInfo(RootParameterHeader Header, size_t Location) : Header(Header), Location(Location) {} }; @@ -46,39 +52,36 @@ struct RootParametersContainer { SmallVector Descriptors; SmallVector Tables; - void addInfo(dxbc::RTS0::v1::RootParameterHeader Header, size_t Location) { + void addInfo(RootParameterHeader Header, size_t Location) { ParametersInfo.push_back(RootParameterInfo(Header, Location)); } - void addParameter(dxbc::RTS0::v1::RootParameterHeader Header, + void addParameter(RootParameterHeader Header, dxbc::RTS0::v1::RootConstants Constant) { addInfo(Header, Constants.size()); Constants.push_back(Constant); } - void addInvalidParameter(dxbc::RTS0::v1::RootParameterHeader Header) { - addInfo(Header, -1); - } + void addInvalidParameter(RootParameterHeader Header) { addInfo(Header, -1); } - void addParameter(dxbc::RTS0::v1::RootParameterHeader Header, + void addParameter(RootParameterHeader Header, dxbc::RTS0::v2::RootDescriptor Descriptor) { addInfo(Header, Descriptors.size()); Descriptors.push_back(Descriptor); } - void addParameter(dxbc::RTS0::v1::RootParameterHeader Header, - DescriptorTable Table) { + void addParameter(RootParameterHeader Header, DescriptorTable Table) { addInfo(Header, Tables.size()); Tables.push_back(Table); } - std::pair + std::pair getTypeAndLocForParameter(uint32_t Location) const { const RootParameterInfo &Info = ParametersInfo[Location]; return {Info.Header.ParameterType, Info.Location}; } - const dxbc::RTS0::v1::RootParameterHeader &getHeader(size_t Location) const { + const RootParameterHeader &getHeader(size_t Location) const { const RootParameterInfo &Info = ParametersInfo[Location]; return Info.Header; } diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index 157bfc665b207..8b9c0d24c34f3 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -12,9 +12,11 @@ //===----------------------------------------------------------------------===// #include "llvm/Frontend/HLSL/RootSignatureMetadata.h" +#include "llvm/BinaryFormat/DXContainer.h" #include "llvm/Frontend/HLSL/RootSignatureValidations.h" #include "llvm/IR/IRBuilder.h" #include "llvm/IR/Metadata.h" +#include "llvm/Support/Error.h" #include "llvm/Support/ScopedPrinter.h" using namespace llvm; @@ -51,6 +53,17 @@ static std::optional extractMdStringValue(MDNode *Node, return NodeText->getString(); } +static Expected +extractShaderVisibility(MDNode *Node, unsigned int OpId) { + if (std::optional Val = extractMdIntValue(Node, OpId)) { + if (!dxbc::isValidShaderVisibility(*Val)) + return make_error>( + "ShaderVisibility", *Val); + return static_cast(*Val); + } + return make_error("ShaderVisibility"); +} + namespace { // We use the OverloadVisit with std::visit to ensure the compiler catches if a @@ -224,15 +237,16 @@ Error MetadataParser::parseRootConstants(mcdxbc::RootSignatureDesc &RSD, if (RootConstantNode->getNumOperands() != 5) return make_error("RootConstants Element"); - dxbc::RTS0::v1::RootParameterHeader Header; + mcdxbc::RootParameterHeader Header; // The parameter offset doesn't matter here - we recalculate it during // serialization Header.ParameterOffset = 0; - Header.ParameterType = to_underlying(dxbc::RootParameterType::Constants32Bit); + Header.ParameterType = dxbc::RootParameterType::Constants32Bit; - if (std::optional Val = extractMdIntValue(RootConstantNode, 1)) - Header.ShaderVisibility = *Val; - else - return make_error("ShaderVisibility"); + Expected VisibilityOrErr = + extractShaderVisibility(RootConstantNode, 1); + if (auto E = VisibilityOrErr.takeError()) + return Error(std::move(E)); + Header.ShaderVisibility = *VisibilityOrErr; dxbc::RTS0::v1::RootConstants Constants; if (std::optional Val = extractMdIntValue(RootConstantNode, 2)) @@ -266,26 +280,27 @@ Error MetadataParser::parseRootDescriptors( if (RootDescriptorNode->getNumOperands() != 5) return make_error("Root Descriptor Element"); - dxbc::RTS0::v1::RootParameterHeader Header; + mcdxbc::RootParameterHeader Header; switch (ElementKind) { case RootSignatureElementKind::SRV: - Header.ParameterType = to_underlying(dxbc::RootParameterType::SRV); + Header.ParameterType = dxbc::RootParameterType::SRV; break; case RootSignatureElementKind::UAV: - Header.ParameterType = to_underlying(dxbc::RootParameterType::UAV); + Header.ParameterType = dxbc::RootParameterType::UAV; break; case RootSignatureElementKind::CBV: - Header.ParameterType = to_underlying(dxbc::RootParameterType::CBV); + Header.ParameterType = dxbc::RootParameterType::CBV; break; default: llvm_unreachable("invalid Root Descriptor kind"); break; } - if (std::optional Val = extractMdIntValue(RootDescriptorNode, 1)) - Header.ShaderVisibility = *Val; - else - return make_error("ShaderVisibility"); + Expected VisibilityOrErr = + extractShaderVisibility(RootDescriptorNode, 1); + if (auto E = VisibilityOrErr.takeError()) + return Error(std::move(E)); + Header.ShaderVisibility = *VisibilityOrErr; dxbc::RTS0::v2::RootDescriptor Descriptor; if (std::optional Val = extractMdIntValue(RootDescriptorNode, 2)) @@ -375,15 +390,16 @@ Error MetadataParser::parseDescriptorTable(mcdxbc::RootSignatureDesc &RSD, if (NumOperands < 2) return make_error("Descriptor Table"); - dxbc::RTS0::v1::RootParameterHeader Header; - if (std::optional Val = extractMdIntValue(DescriptorTableNode, 1)) - Header.ShaderVisibility = *Val; - else - return make_error("ShaderVisibility"); + mcdxbc::RootParameterHeader Header; + + Expected VisibilityOrErr = + extractShaderVisibility(DescriptorTableNode, 1); + if (auto E = VisibilityOrErr.takeError()) + return Error(std::move(E)); + Header.ShaderVisibility = *VisibilityOrErr; mcdxbc::DescriptorTable Table; - Header.ParameterType = - to_underlying(dxbc::RootParameterType::DescriptorTable); + Header.ParameterType = dxbc::RootParameterType::DescriptorTable; for (unsigned int I = 2; I < NumOperands; I++) { MDNode *Element = dyn_cast(DescriptorTableNode->getOperand(I)); @@ -531,20 +547,14 @@ Error MetadataParser::validateRootSignature( } for (const mcdxbc::RootParameterInfo &Info : RSD.ParametersContainer) { - if (!dxbc::isValidShaderVisibility(Info.Header.ShaderVisibility)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "ShaderVisibility", Info.Header.ShaderVisibility)); - - assert(dxbc::isValidParameterType(Info.Header.ParameterType) && - "Invalid value for ParameterType"); switch (Info.Header.ParameterType) { + case dxbc::RootParameterType::Constants32Bit: + break; - case to_underlying(dxbc::RootParameterType::CBV): - case to_underlying(dxbc::RootParameterType::UAV): - case to_underlying(dxbc::RootParameterType::SRV): { + case dxbc::RootParameterType::CBV: + case dxbc::RootParameterType::UAV: + case dxbc::RootParameterType::SRV: { const dxbc::RTS0::v2::RootDescriptor &Descriptor = RSD.ParametersContainer.getRootDescriptor(Info.Location); if (!hlsl::rootsig::verifyRegisterValue(Descriptor.ShaderRegister)) @@ -569,7 +579,7 @@ Error MetadataParser::validateRootSignature( } break; } - case to_underlying(dxbc::RootParameterType::DescriptorTable): { + case dxbc::RootParameterType::DescriptorTable: { const mcdxbc::DescriptorTable &Table = RSD.ParametersContainer.getDescriptorTable(Info.Location); for (const dxbc::RTS0::v2::DescriptorRange &Range : Table) { diff --git a/llvm/lib/MC/DXContainerRootSignature.cpp b/llvm/lib/MC/DXContainerRootSignature.cpp index 482280b5ef289..c7be78149a32b 100644 --- a/llvm/lib/MC/DXContainerRootSignature.cpp +++ b/llvm/lib/MC/DXContainerRootSignature.cpp @@ -36,19 +36,19 @@ size_t RootSignatureDesc::getSize() const { for (const RootParameterInfo &I : ParametersContainer) { switch (I.Header.ParameterType) { - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): + case dxbc::RootParameterType::Constants32Bit: Size += sizeof(dxbc::RTS0::v1::RootConstants); break; - case llvm::to_underlying(dxbc::RootParameterType::CBV): - case llvm::to_underlying(dxbc::RootParameterType::SRV): - case llvm::to_underlying(dxbc::RootParameterType::UAV): + case dxbc::RootParameterType::CBV: + case dxbc::RootParameterType::SRV: + case dxbc::RootParameterType::UAV: if (Version == 1) Size += sizeof(dxbc::RTS0::v1::RootDescriptor); else Size += sizeof(dxbc::RTS0::v2::RootDescriptor); break; - case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): + case dxbc::RootParameterType::DescriptorTable: const DescriptorTable &Table = ParametersContainer.getDescriptorTable(I.Location); @@ -98,7 +98,7 @@ void RootSignatureDesc::write(raw_ostream &OS) const { rewriteOffsetToCurrentByte(BOS, ParamsOffsets[I]); const auto &[Type, Loc] = ParametersContainer.getTypeAndLocForParameter(I); switch (Type) { - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): { + case dxbc::RootParameterType::Constants32Bit: { const dxbc::RTS0::v1::RootConstants &Constants = ParametersContainer.getConstant(Loc); support::endian::write(BOS, Constants.ShaderRegister, @@ -109,9 +109,9 @@ void RootSignatureDesc::write(raw_ostream &OS) const { llvm::endianness::little); break; } - case llvm::to_underlying(dxbc::RootParameterType::CBV): - case llvm::to_underlying(dxbc::RootParameterType::SRV): - case llvm::to_underlying(dxbc::RootParameterType::UAV): { + case dxbc::RootParameterType::CBV: + case dxbc::RootParameterType::SRV: + case dxbc::RootParameterType::UAV: { const dxbc::RTS0::v2::RootDescriptor &Descriptor = ParametersContainer.getRootDescriptor(Loc); @@ -123,7 +123,7 @@ void RootSignatureDesc::write(raw_ostream &OS) const { support::endian::write(BOS, Descriptor.Flags, llvm::endianness::little); break; } - case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): { + case dxbc::RootParameterType::DescriptorTable: { const DescriptorTable &Table = ParametersContainer.getDescriptorTable(Loc); support::endian::write(BOS, (uint32_t)Table.Ranges.size(), diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index 043b575a43b11..0eb73d4c0beb5 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -275,11 +275,14 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { for (DXContainerYAML::RootParameterLocationYaml &L : P.RootSignature->Parameters.Locations) { - dxbc::RTS0::v1::RootParameterHeader Header{L.Header.Type, L.Header.Visibility, - L.Header.Offset}; - switch (L.Header.Type) { - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): { + mcdxbc::RootParameterHeader Header{ + static_cast(L.Header.Type), + static_cast(L.Header.Visibility), + L.Header.Offset}; + + switch (Header.ParameterType) { + case dxbc::RootParameterType::Constants32Bit: { const DXContainerYAML::RootConstantsYaml &ConstantYaml = P.RootSignature->Parameters.getOrInsertConstants(L); dxbc::RTS0::v1::RootConstants Constants; @@ -289,9 +292,9 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { RS.ParametersContainer.addParameter(Header, Constants); break; } - case llvm::to_underlying(dxbc::RootParameterType::CBV): - case llvm::to_underlying(dxbc::RootParameterType::SRV): - case llvm::to_underlying(dxbc::RootParameterType::UAV): { + case dxbc::RootParameterType::CBV: + case dxbc::RootParameterType::SRV: + case dxbc::RootParameterType::UAV: { const DXContainerYAML::RootDescriptorYaml &DescriptorYaml = P.RootSignature->Parameters.getOrInsertDescriptor(L); @@ -303,7 +306,7 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { RS.ParametersContainer.addParameter(Header, Descriptor); break; } - case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): { + case dxbc::RootParameterType::DescriptorTable: { const DXContainerYAML::DescriptorTableYaml &TableYaml = P.RootSignature->Parameters.getOrInsertTable(L); mcdxbc::DescriptorTable Table; diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp index a4f5086c2f428..b31f811d76bf9 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp +++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp @@ -27,6 +27,7 @@ #include "llvm/Pass.h" #include "llvm/Support/Error.h" #include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/raw_ostream.h" #include @@ -173,14 +174,18 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M, for (size_t I = 0; I < RS.ParametersContainer.size(); I++) { const auto &[Type, Loc] = RS.ParametersContainer.getTypeAndLocForParameter(I); - const dxbc::RTS0::v1::RootParameterHeader Header = + const mcdxbc::RootParameterHeader Header = RS.ParametersContainer.getHeader(I); - OS << "- Parameter Type: " << Type << "\n" - << " Shader Visibility: " << Header.ShaderVisibility << "\n"; + OS << "- Parameter Type: " + << enumToStringRef(Type, dxbc::getRootParameterTypes()) << "\n" + << " Shader Visibility: " + << enumToStringRef(Header.ShaderVisibility, + dxbc::getShaderVisibility()) + << "\n"; switch (Type) { - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): { + case dxbc::RootParameterType::Constants32Bit: { const dxbc::RTS0::v1::RootConstants &Constants = RS.ParametersContainer.getConstant(Loc); OS << " Register Space: " << Constants.RegisterSpace << "\n" @@ -188,9 +193,9 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M, << " Num 32 Bit Values: " << Constants.Num32BitValues << "\n"; break; } - case llvm::to_underlying(dxbc::RootParameterType::CBV): - case llvm::to_underlying(dxbc::RootParameterType::UAV): - case llvm::to_underlying(dxbc::RootParameterType::SRV): { + case dxbc::RootParameterType::CBV: + case dxbc::RootParameterType::UAV: + case dxbc::RootParameterType::SRV: { const dxbc::RTS0::v2::RootDescriptor &Descriptor = RS.ParametersContainer.getRootDescriptor(Loc); OS << " Register Space: " << Descriptor.RegisterSpace << "\n" @@ -199,7 +204,7 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M, OS << " Flags: " << Descriptor.Flags << "\n"; break; } - case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): { + case dxbc::RootParameterType::DescriptorTable: { const mcdxbc::DescriptorTable &Table = RS.ParametersContainer.getDescriptorTable(Loc); OS << " NumRanges: " << Table.Ranges.size() << "\n"; diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll index 6477ad397c32d..fd3dbb01cab11 100644 --- a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll +++ b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll @@ -21,34 +21,34 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } !9 = !{ !"UAV", i32 5, i32 1, i32 10, i32 5, i32 2 } ;CHECK-LABEL: Definition for 'main': -;CHECK-NEXT: Flags: 0x000001 -;CHECK-NEXT: Version: 2 -;CHECK-NEXT: RootParametersOffset: 24 -;CHECK-NEXT: NumParameters: 3 -;CHECK-NEXT: - Parameter Type: 1 -;CHECK-NEXT: Shader Visibility: 0 -;CHECK-NEXT: Register Space: 2 -;CHECK-NEXT: Shader Register: 1 -;CHECK-NEXT: Num 32 Bit Values: 3 -;CHECK-NEXT: - Parameter Type: 3 -;CHECK-NEXT: Shader Visibility: 1 -;CHECK-NEXT: Register Space: 5 -;CHECK-NEXT: Shader Register: 4 +;CHECK-NEXT: Flags: 0x000001 +;CHECK-NEXT: Version: 2 +;CHECK-NEXT: RootParametersOffset: 24 +;CHECK-NEXT: NumParameters: 3 +;CHECK-NEXT: - Parameter Type: Constants32Bit +;CHECK-NEXT: Shader Visibility: All +;CHECK-NEXT: Register Space: 2 +;CHECK-NEXT: Shader Register: 1 +;CHECK-NEXT: Num 32 Bit Values: 3 +;CHECK-NEXT: - Parameter Type: SRV +;CHECK-NEXT: Shader Visibility: Vertex +;CHECK-NEXT: Register Space: 5 +;CHECK-NEXT: Shader Register: 4 +;CHECK-NEXT: Flags: 4 +;CHECK-NEXT: - Parameter Type: DescriptorTable +;CHECK-NEXT: Shader Visibility: All +;CHECK-NEXT: NumRanges: 2 +;CHECK-NEXT: - Range Type: 0 +;CHECK-NEXT: Register Space: 0 +;CHECK-NEXT: Base Shader Register: 1 +;CHECK-NEXT: Num Descriptors: 1 +;CHECK-NEXT: Offset In Descriptors From Table Start: 4294967295 ;CHECK-NEXT: Flags: 4 -;CHECK-NEXT: - Parameter Type: 0 -;CHECK-NEXT: Shader Visibility: 0 -;CHECK-NEXT: NumRanges: 2 -;CHECK-NEXT: - Range Type: 0 -;CHECK-NEXT: Register Space: 0 -;CHECK-NEXT: Base Shader Register: 1 -;CHECK-NEXT: Num Descriptors: 1 -;CHECK-NEXT: Offset In Descriptors From Table Start: 4294967295 -;CHECK-NEXT: Flags: 4 -;CHECK-NEXT: - Range Type: 1 -;CHECK-NEXT: Register Space: 10 -;CHECK-NEXT: Base Shader Register: 1 -;CHECK-NEXT: Num Descriptors: 5 -;CHECK-NEXT: Offset In Descriptors From Table Start: 5 -;CHECK-NEXT: Flags: 2 -;CHECK-NEXT: NumStaticSamplers: 0 -;CHECK-NEXT: StaticSamplersOffset: 0 +;CHECK-NEXT: - Range Type: 1 +;CHECK-NEXT: Register Space: 10 +;CHECK-NEXT: Base Shader Register: 1 +;CHECK-NEXT: Num Descriptors: 5 +;CHECK-NEXT: Offset In Descriptors From Table Start: 5 +;CHECK-NEXT: Flags: 2 +;CHECK-NEXT: NumStaticSamplers: 0 +;CHECK-NEXT: StaticSamplersOffset: 0 From 1690a9c04dbdd4b04d272f0ab87eea97ff8b8f2d Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Mon, 18 Aug 2025 18:52:48 -0700 Subject: [PATCH 02/29] clean up --- llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp | 2 -- llvm/lib/Target/DirectX/DXILRootSignature.cpp | 1 - 2 files changed, 3 deletions(-) diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index 8b9c0d24c34f3..378f93359ddc4 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -12,11 +12,9 @@ //===----------------------------------------------------------------------===// #include "llvm/Frontend/HLSL/RootSignatureMetadata.h" -#include "llvm/BinaryFormat/DXContainer.h" #include "llvm/Frontend/HLSL/RootSignatureValidations.h" #include "llvm/IR/IRBuilder.h" #include "llvm/IR/Metadata.h" -#include "llvm/Support/Error.h" #include "llvm/Support/ScopedPrinter.h" using namespace llvm; diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp index b31f811d76bf9..3bc2e39544960 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp +++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp @@ -27,7 +27,6 @@ #include "llvm/Pass.h" #include "llvm/Support/Error.h" #include "llvm/Support/ErrorHandling.h" -#include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/raw_ostream.h" #include From f6f2e61d5d76c6b98ffc3c25edf964f61afa42a4 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Tue, 19 Aug 2025 10:34:02 -0700 Subject: [PATCH 03/29] removing root parameter header from MC --- .../llvm/MC/DXContainerRootSignature.h | 41 +++++++++---------- .../Frontend/HLSL/RootSignatureMetadata.cpp | 29 ++++++------- llvm/lib/MC/DXContainerRootSignature.cpp | 16 ++++---- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 27 ++++++------ .../DXILPostOptimizationValidation.cpp | 12 +++--- llvm/lib/Target/DirectX/DXILRootSignature.cpp | 14 +++---- .../RootSignature-InvalidType.yaml | 29 ------------- .../RootSignature-InvalidVisibility.yaml | 33 --------------- 8 files changed, 64 insertions(+), 137 deletions(-) delete mode 100644 llvm/test/ObjectYAML/DXContainer/RootSignature-InvalidType.yaml delete mode 100644 llvm/test/ObjectYAML/DXContainer/RootSignature-InvalidVisibility.yaml diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index 757ab8bc83129..980557a72ef84 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -11,7 +11,6 @@ #include "llvm/BinaryFormat/DXContainer.h" #include "llvm/Support/Compiler.h" -#include #include namespace llvm { @@ -26,13 +25,15 @@ struct RootParameterHeader { }; struct RootParameterInfo { - RootParameterHeader Header; + dxbc::RootParameterType Type; + dxbc::ShaderVisibility Visibility; size_t Location; RootParameterInfo() = default; - RootParameterInfo(RootParameterHeader Header, size_t Location) - : Header(Header), Location(Location) {} + RootParameterInfo(dxbc::RootParameterType Type, + dxbc::ShaderVisibility Visibility, size_t Location) + : Type(Type), Visibility(Visibility), Location(Location) {} }; struct DescriptorTable { @@ -52,38 +53,34 @@ struct RootParametersContainer { SmallVector Descriptors; SmallVector Tables; - void addInfo(RootParameterHeader Header, size_t Location) { - ParametersInfo.push_back(RootParameterInfo(Header, Location)); + void addInfo(dxbc::RootParameterType Type, dxbc::ShaderVisibility Visibility, + size_t Location) { + ParametersInfo.push_back(RootParameterInfo(Type, Visibility, Location)); } - void addParameter(RootParameterHeader Header, + void addParameter(dxbc::RootParameterType Type, + dxbc::ShaderVisibility Visibility, dxbc::RTS0::v1::RootConstants Constant) { - addInfo(Header, Constants.size()); + addInfo(Type, Visibility, Constants.size()); Constants.push_back(Constant); } - void addInvalidParameter(RootParameterHeader Header) { addInfo(Header, -1); } - - void addParameter(RootParameterHeader Header, + void addParameter(dxbc::RootParameterType Type, + dxbc::ShaderVisibility Visibility, dxbc::RTS0::v2::RootDescriptor Descriptor) { - addInfo(Header, Descriptors.size()); + addInfo(Type, Visibility, Descriptors.size()); Descriptors.push_back(Descriptor); } - void addParameter(RootParameterHeader Header, DescriptorTable Table) { - addInfo(Header, Tables.size()); + void addParameter(dxbc::RootParameterType Type, + dxbc::ShaderVisibility Visibility, DescriptorTable Table) { + addInfo(Type, Visibility, Tables.size()); Tables.push_back(Table); } - std::pair - getTypeAndLocForParameter(uint32_t Location) const { - const RootParameterInfo &Info = ParametersInfo[Location]; - return {Info.Header.ParameterType, Info.Location}; - } - - const RootParameterHeader &getHeader(size_t Location) const { + const RootParameterInfo &getInfo(uint32_t Location) const { const RootParameterInfo &Info = ParametersInfo[Location]; - return Info.Header; + return Info; } const dxbc::RTS0::v1::RootConstants &getConstant(size_t Index) const { diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index 378f93359ddc4..2d69369d08ebb 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -236,15 +236,11 @@ Error MetadataParser::parseRootConstants(mcdxbc::RootSignatureDesc &RSD, return make_error("RootConstants Element"); mcdxbc::RootParameterHeader Header; - // The parameter offset doesn't matter here - we recalculate it during - // serialization Header.ParameterOffset = 0; - Header.ParameterType = dxbc::RootParameterType::Constants32Bit; Expected VisibilityOrErr = extractShaderVisibility(RootConstantNode, 1); if (auto E = VisibilityOrErr.takeError()) return Error(std::move(E)); - Header.ShaderVisibility = *VisibilityOrErr; dxbc::RTS0::v1::RootConstants Constants; if (std::optional Val = extractMdIntValue(RootConstantNode, 2)) @@ -262,7 +258,10 @@ Error MetadataParser::parseRootConstants(mcdxbc::RootSignatureDesc &RSD, else return make_error("Num32BitValues"); - RSD.ParametersContainer.addParameter(Header, Constants); + // The parameter offset doesn't matter here - we recalculate it during + // serialization Header.ParameterOffset = 0; + RSD.ParametersContainer.addParameter(dxbc::RootParameterType::Constants32Bit, + *VisibilityOrErr, Constants); return Error::success(); } @@ -278,16 +277,16 @@ Error MetadataParser::parseRootDescriptors( if (RootDescriptorNode->getNumOperands() != 5) return make_error("Root Descriptor Element"); - mcdxbc::RootParameterHeader Header; + dxbc::RootParameterType Type; switch (ElementKind) { case RootSignatureElementKind::SRV: - Header.ParameterType = dxbc::RootParameterType::SRV; + Type = dxbc::RootParameterType::SRV; break; case RootSignatureElementKind::UAV: - Header.ParameterType = dxbc::RootParameterType::UAV; + Type = dxbc::RootParameterType::UAV; break; case RootSignatureElementKind::CBV: - Header.ParameterType = dxbc::RootParameterType::CBV; + Type = dxbc::RootParameterType::CBV; break; default: llvm_unreachable("invalid Root Descriptor kind"); @@ -298,7 +297,6 @@ Error MetadataParser::parseRootDescriptors( extractShaderVisibility(RootDescriptorNode, 1); if (auto E = VisibilityOrErr.takeError()) return Error(std::move(E)); - Header.ShaderVisibility = *VisibilityOrErr; dxbc::RTS0::v2::RootDescriptor Descriptor; if (std::optional Val = extractMdIntValue(RootDescriptorNode, 2)) @@ -312,7 +310,7 @@ Error MetadataParser::parseRootDescriptors( return make_error("RegisterSpace"); if (RSD.Version == 1) { - RSD.ParametersContainer.addParameter(Header, Descriptor); + RSD.ParametersContainer.addParameter(Type, *VisibilityOrErr, Descriptor); return Error::success(); } assert(RSD.Version > 1); @@ -322,7 +320,7 @@ Error MetadataParser::parseRootDescriptors( else return make_error("Root Descriptor Flags"); - RSD.ParametersContainer.addParameter(Header, Descriptor); + RSD.ParametersContainer.addParameter(Type, *VisibilityOrErr, Descriptor); return Error::success(); } @@ -394,10 +392,8 @@ Error MetadataParser::parseDescriptorTable(mcdxbc::RootSignatureDesc &RSD, extractShaderVisibility(DescriptorTableNode, 1); if (auto E = VisibilityOrErr.takeError()) return Error(std::move(E)); - Header.ShaderVisibility = *VisibilityOrErr; mcdxbc::DescriptorTable Table; - Header.ParameterType = dxbc::RootParameterType::DescriptorTable; for (unsigned int I = 2; I < NumOperands; I++) { MDNode *Element = dyn_cast(DescriptorTableNode->getOperand(I)); @@ -409,7 +405,8 @@ Error MetadataParser::parseDescriptorTable(mcdxbc::RootSignatureDesc &RSD, return Err; } - RSD.ParametersContainer.addParameter(Header, Table); + RSD.ParametersContainer.addParameter(dxbc::RootParameterType::DescriptorTable, + *VisibilityOrErr, Table); return Error::success(); } @@ -546,7 +543,7 @@ Error MetadataParser::validateRootSignature( for (const mcdxbc::RootParameterInfo &Info : RSD.ParametersContainer) { - switch (Info.Header.ParameterType) { + switch (Info.Type) { case dxbc::RootParameterType::Constants32Bit: break; diff --git a/llvm/lib/MC/DXContainerRootSignature.cpp b/llvm/lib/MC/DXContainerRootSignature.cpp index c7be78149a32b..45ecd9a8d5e01 100644 --- a/llvm/lib/MC/DXContainerRootSignature.cpp +++ b/llvm/lib/MC/DXContainerRootSignature.cpp @@ -9,6 +9,7 @@ #include "llvm/MC/DXContainerRootSignature.h" #include "llvm/ADT/SmallString.h" #include "llvm/Support/EndianStream.h" +#include using namespace llvm; using namespace llvm::mcdxbc; @@ -35,7 +36,7 @@ size_t RootSignatureDesc::getSize() const { StaticSamplers.size() * sizeof(dxbc::RTS0::v1::StaticSampler); for (const RootParameterInfo &I : ParametersContainer) { - switch (I.Header.ParameterType) { + switch (I.Type) { case dxbc::RootParameterType::Constants32Bit: Size += sizeof(dxbc::RTS0::v1::RootConstants); break; @@ -84,11 +85,9 @@ void RootSignatureDesc::write(raw_ostream &OS) const { support::endian::write(BOS, Flags, llvm::endianness::little); SmallVector ParamsOffsets; - for (const RootParameterInfo &P : ParametersContainer) { - support::endian::write(BOS, P.Header.ParameterType, - llvm::endianness::little); - support::endian::write(BOS, P.Header.ShaderVisibility, - llvm::endianness::little); + for (const RootParameterInfo &I : ParametersContainer) { + support::endian::write(BOS, I.Type, llvm::endianness::little); + support::endian::write(BOS, I.Visibility, llvm::endianness::little); ParamsOffsets.push_back(writePlaceholder(BOS)); } @@ -96,8 +95,9 @@ void RootSignatureDesc::write(raw_ostream &OS) const { assert(NumParameters == ParamsOffsets.size()); for (size_t I = 0; I < NumParameters; ++I) { rewriteOffsetToCurrentByte(BOS, ParamsOffsets[I]); - const auto &[Type, Loc] = ParametersContainer.getTypeAndLocForParameter(I); - switch (Type) { + const auto Info = ParametersContainer.getInfo(I); + const uint32_t &Loc = Info.Location; + switch (Info.Type) { case dxbc::RootParameterType::Constants32Bit: { const dxbc::RTS0::v1::RootConstants &Constants = ParametersContainer.getConstant(Loc); diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index 0eb73d4c0beb5..b112c6f21ee5a 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -276,20 +276,24 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { for (DXContainerYAML::RootParameterLocationYaml &L : P.RootSignature->Parameters.Locations) { - mcdxbc::RootParameterHeader Header{ - static_cast(L.Header.Type), - static_cast(L.Header.Visibility), - L.Header.Offset}; - - switch (Header.ParameterType) { + assert(dxbc::isValidParameterType(L.Header.Type) && + "invalid DXContainer YAML"); + assert(dxbc::isValidShaderVisibility(L.Header.Visibility) && + "invalid DXContainer YAML"); + dxbc::RootParameterType Type = dxbc::RootParameterType(L.Header.Type); + dxbc::ShaderVisibility Visibility = + dxbc::ShaderVisibility(L.Header.Visibility); + + switch (Type) { case dxbc::RootParameterType::Constants32Bit: { const DXContainerYAML::RootConstantsYaml &ConstantYaml = P.RootSignature->Parameters.getOrInsertConstants(L); dxbc::RTS0::v1::RootConstants Constants; + Constants.Num32BitValues = ConstantYaml.Num32BitValues; Constants.RegisterSpace = ConstantYaml.RegisterSpace; Constants.ShaderRegister = ConstantYaml.ShaderRegister; - RS.ParametersContainer.addParameter(Header, Constants); + RS.ParametersContainer.addParameter(Type, Visibility, Constants); break; } case dxbc::RootParameterType::CBV: @@ -303,7 +307,7 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { Descriptor.ShaderRegister = DescriptorYaml.ShaderRegister; if (RS.Version > 1) Descriptor.Flags = DescriptorYaml.getEncodedFlags(); - RS.ParametersContainer.addParameter(Header, Descriptor); + RS.ParametersContainer.addParameter(Type, Visibility, Descriptor); break; } case dxbc::RootParameterType::DescriptorTable: { @@ -323,14 +327,9 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { Range.Flags = R.getEncodedFlags(); Table.Ranges.push_back(Range); } - RS.ParametersContainer.addParameter(Header, Table); + RS.ParametersContainer.addParameter(Type, Visibility, Table); break; } - default: - // Handling invalid parameter type edge case. We intentionally let - // obj2yaml/yaml2obj parse and emit invalid dxcontainer data, in order - // for that to be used as a testing tool more effectively. - RS.ParametersContainer.addInvalidParameter(Header); } } diff --git a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp index be2c7d1ddff3f..8738e3071f824 100644 --- a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp +++ b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp @@ -164,12 +164,12 @@ static void validateRootSignature(Module &M, for (const mcdxbc::RootParameterInfo &ParamInfo : RSD.ParametersContainer) { dxbc::ShaderVisibility ParamVisibility = - static_cast(ParamInfo.Header.ShaderVisibility); + static_cast(ParamInfo.Visibility); if (ParamVisibility != dxbc::ShaderVisibility::All && ParamVisibility != Visibility) continue; dxbc::RootParameterType ParamType = - static_cast(ParamInfo.Header.ParameterType); + static_cast(ParamInfo.Type); switch (ParamType) { case dxbc::RootParameterType::Constants32Bit: { dxbc::RTS0::v1::RootConstants Const = @@ -185,10 +185,10 @@ static void validateRootSignature(Module &M, case dxbc::RootParameterType::CBV: { dxbc::RTS0::v2::RootDescriptor Desc = RSD.ParametersContainer.getRootDescriptor(ParamInfo.Location); - Builder.trackBinding(toResourceClass(static_cast( - ParamInfo.Header.ParameterType)), - Desc.RegisterSpace, Desc.ShaderRegister, - Desc.ShaderRegister, &ParamInfo); + Builder.trackBinding( + toResourceClass(static_cast(ParamInfo.Type)), + Desc.RegisterSpace, Desc.ShaderRegister, Desc.ShaderRegister, + &ParamInfo); break; } diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp index 3bc2e39544960..159cf7eda2482 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp +++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp @@ -171,19 +171,15 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M, << "RootParametersOffset: " << RS.RootParameterOffset << "\n" << "NumParameters: " << RS.ParametersContainer.size() << "\n"; for (size_t I = 0; I < RS.ParametersContainer.size(); I++) { - const auto &[Type, Loc] = - RS.ParametersContainer.getTypeAndLocForParameter(I); - const mcdxbc::RootParameterHeader Header = - RS.ParametersContainer.getHeader(I); + const auto &Info = RS.ParametersContainer.getInfo(I); OS << "- Parameter Type: " - << enumToStringRef(Type, dxbc::getRootParameterTypes()) << "\n" + << enumToStringRef(Info.Type, dxbc::getRootParameterTypes()) << "\n" << " Shader Visibility: " - << enumToStringRef(Header.ShaderVisibility, - dxbc::getShaderVisibility()) + << enumToStringRef(Info.Visibility, dxbc::getShaderVisibility()) << "\n"; - - switch (Type) { + const uint32_t &Loc = Info.Location; + switch (Info.Type) { case dxbc::RootParameterType::Constants32Bit: { const dxbc::RTS0::v1::RootConstants &Constants = RS.ParametersContainer.getConstant(Loc); diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-InvalidType.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-InvalidType.yaml deleted file mode 100644 index 091e70789d956..0000000000000 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-InvalidType.yaml +++ /dev/null @@ -1,29 +0,0 @@ -# RUN: yaml2obj %s -o %t -# RUN: not obj2yaml 2>&1 %t | FileCheck %s -DFILE=%t - -# CHECK: Error reading file: [[FILE]]: Invalid value for parameter type - - ---- !dxcontainer -Header: - Hash: [ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, - 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 ] - Version: - Major: 1 - Minor: 0 - PartCount: 1 - PartOffsets: [ 60 ] -Parts: - - Name: RTS0 - Size: 80 - RootSignature: - Version: 2 - NumRootParameters: 2 - RootParametersOffset: 24 - NumStaticSamplers: 0 - StaticSamplersOffset: 64 - Parameters: - - ParameterType: 255 # INVALID - ShaderVisibility: 2 # Hull - AllowInputAssemblerInputLayout: true - DenyGeometryShaderRootAccess: true diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-InvalidVisibility.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-InvalidVisibility.yaml deleted file mode 100644 index 1acaf6e4e08a4..0000000000000 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-InvalidVisibility.yaml +++ /dev/null @@ -1,33 +0,0 @@ -# RUN: yaml2obj %s -o %t -# RUN: not obj2yaml 2>&1 %t | FileCheck %s -DFILE=%t - -# CHECK: Error reading file: [[FILE]]: Invalid value for shader visibility - - ---- !dxcontainer -Header: - Hash: [ 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, - 0x0, 0x0, 0x0, 0x0, 0x0, 0x0 ] - Version: - Major: 1 - Minor: 0 - PartCount: 1 - PartOffsets: [ 60 ] -Parts: - - Name: RTS0 - Size: 80 - RootSignature: - Version: 2 - NumRootParameters: 2 - RootParametersOffset: 24 - NumStaticSamplers: 0 - StaticSamplersOffset: 64 - Parameters: - - ParameterType: 1 # Constants32Bit - ShaderVisibility: 255 # INVALID - Constants: - Num32BitValues: 21 - ShaderRegister: 22 - RegisterSpace: 23 - AllowInputAssemblerInputLayout: true - DenyGeometryShaderRootAccess: true From 6539364fa7b218bfe4f6743727f9ce21ec10e562 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Tue, 19 Aug 2025 10:45:49 -0700 Subject: [PATCH 04/29] clean up --- .../llvm/MC/DXContainerRootSignature.h | 1 + .../Frontend/HLSL/RootSignatureMetadata.cpp | 4 +- .../DXILPostOptimizationValidation.cpp | 12 ++-- .../ContainerData/RootSignature-Parameters.ll | 62 +++++++++---------- 4 files changed, 38 insertions(+), 41 deletions(-) diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index 980557a72ef84..149de9fbd8b47 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -11,6 +11,7 @@ #include "llvm/BinaryFormat/DXContainer.h" #include "llvm/Support/Compiler.h" +#include #include namespace llvm { diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index 2d69369d08ebb..4dbcf05fa5668 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -57,7 +57,7 @@ extractShaderVisibility(MDNode *Node, unsigned int OpId) { if (!dxbc::isValidShaderVisibility(*Val)) return make_error>( "ShaderVisibility", *Val); - return static_cast(*Val); + return dxbc::ShaderVisibility(*Val); } return make_error("ShaderVisibility"); } @@ -258,8 +258,6 @@ Error MetadataParser::parseRootConstants(mcdxbc::RootSignatureDesc &RSD, else return make_error("Num32BitValues"); - // The parameter offset doesn't matter here - we recalculate it during - // serialization Header.ParameterOffset = 0; RSD.ParametersContainer.addParameter(dxbc::RootParameterType::Constants32Bit, *VisibilityOrErr, Constants); diff --git a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp index 8738e3071f824..fc0afb9a0efdf 100644 --- a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp +++ b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp @@ -164,12 +164,11 @@ static void validateRootSignature(Module &M, for (const mcdxbc::RootParameterInfo &ParamInfo : RSD.ParametersContainer) { dxbc::ShaderVisibility ParamVisibility = - static_cast(ParamInfo.Visibility); + dxbc::ShaderVisibility(ParamInfo.Visibility); if (ParamVisibility != dxbc::ShaderVisibility::All && ParamVisibility != Visibility) continue; - dxbc::RootParameterType ParamType = - static_cast(ParamInfo.Type); + dxbc::RootParameterType ParamType = dxbc::RootParameterType(ParamInfo.Type); switch (ParamType) { case dxbc::RootParameterType::Constants32Bit: { dxbc::RTS0::v1::RootConstants Const = @@ -185,10 +184,9 @@ static void validateRootSignature(Module &M, case dxbc::RootParameterType::CBV: { dxbc::RTS0::v2::RootDescriptor Desc = RSD.ParametersContainer.getRootDescriptor(ParamInfo.Location); - Builder.trackBinding( - toResourceClass(static_cast(ParamInfo.Type)), - Desc.RegisterSpace, Desc.ShaderRegister, Desc.ShaderRegister, - &ParamInfo); + Builder.trackBinding(toResourceClass(ParamInfo.Type), Desc.RegisterSpace, + Desc.ShaderRegister, Desc.ShaderRegister, + &ParamInfo); break; } diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll index fd3dbb01cab11..b6cc7b456bdc4 100644 --- a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll +++ b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll @@ -21,34 +21,34 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } !9 = !{ !"UAV", i32 5, i32 1, i32 10, i32 5, i32 2 } ;CHECK-LABEL: Definition for 'main': -;CHECK-NEXT: Flags: 0x000001 -;CHECK-NEXT: Version: 2 -;CHECK-NEXT: RootParametersOffset: 24 -;CHECK-NEXT: NumParameters: 3 -;CHECK-NEXT: - Parameter Type: Constants32Bit -;CHECK-NEXT: Shader Visibility: All -;CHECK-NEXT: Register Space: 2 -;CHECK-NEXT: Shader Register: 1 -;CHECK-NEXT: Num 32 Bit Values: 3 -;CHECK-NEXT: - Parameter Type: SRV -;CHECK-NEXT: Shader Visibility: Vertex -;CHECK-NEXT: Register Space: 5 -;CHECK-NEXT: Shader Register: 4 -;CHECK-NEXT: Flags: 4 -;CHECK-NEXT: - Parameter Type: DescriptorTable -;CHECK-NEXT: Shader Visibility: All -;CHECK-NEXT: NumRanges: 2 -;CHECK-NEXT: - Range Type: 0 -;CHECK-NEXT: Register Space: 0 -;CHECK-NEXT: Base Shader Register: 1 -;CHECK-NEXT: Num Descriptors: 1 -;CHECK-NEXT: Offset In Descriptors From Table Start: 4294967295 -;CHECK-NEXT: Flags: 4 -;CHECK-NEXT: - Range Type: 1 -;CHECK-NEXT: Register Space: 10 -;CHECK-NEXT: Base Shader Register: 1 -;CHECK-NEXT: Num Descriptors: 5 -;CHECK-NEXT: Offset In Descriptors From Table Start: 5 -;CHECK-NEXT: Flags: 2 -;CHECK-NEXT: NumStaticSamplers: 0 -;CHECK-NEXT: StaticSamplersOffset: 0 +;CHECK-NEXT: Flags: 0x000001 +;CHECK-NEXT: Version: 2 +;CHECK-NEXT: RootParametersOffset: 24 +;CHECK-NEXT: NumParameters: 3 +;CHECK-NEXT: - Parameter Type: Constants32Bit +;CHECK-NEXT: Shader Visibility: All +;CHECK-NEXT: Register Space: 2 +;CHECK-NEXT: Shader Register: 1 +;CHECK-NEXT: Num 32 Bit Values: 3 +;CHECK-NEXT: - Parameter Type: SRV +;CHECK-NEXT: Shader Visibility: Vertex +;CHECK-NEXT: Register Space: 5 +;CHECK-NEXT: Shader Register: 4 +;CHECK-NEXT: Flags: 4 +;CHECK-NEXT: - Parameter Type: DescriptorTable +;CHECK-NEXT: Shader Visibility: All +;CHECK-NEXT: NumRanges: 2 +;CHECK-NEXT: - Range Type: 0 +;CHECK-NEXT: Register Space: 0 +;CHECK-NEXT: Base Shader Register: 1 +;CHECK-NEXT: Num Descriptors: 1 +;CHECK-NEXT: Offset In Descriptors From Table Start: 4294967295 +;CHECK-NEXT: Flags: 4 +;CHECK-NEXT: - Range Type: 1 +;CHECK-NEXT: Register Space: 10 +;CHECK-NEXT: Base Shader Register: 1 +;CHECK-NEXT: Num Descriptors: 5 +;CHECK-NEXT: Offset In Descriptors From Table Start: 5 +;CHECK-NEXT: Flags: 2 +;CHECK-NEXT: NumStaticSamplers: 0 +;CHECK-NEXT: StaticSamplersOffset: 0 From 1d29111c4f5a298572f50dd19f9838610a4a3778 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Tue, 19 Aug 2025 10:47:15 -0700 Subject: [PATCH 05/29] fix whitespace in test --- .../ContainerData/RootSignature-Parameters.ll | 50 +++++++++---------- 1 file changed, 25 insertions(+), 25 deletions(-) diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll index b6cc7b456bdc4..742fea14f5af6 100644 --- a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll +++ b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll @@ -25,30 +25,30 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } ;CHECK-NEXT: Version: 2 ;CHECK-NEXT: RootParametersOffset: 24 ;CHECK-NEXT: NumParameters: 3 -;CHECK-NEXT: - Parameter Type: Constants32Bit -;CHECK-NEXT: Shader Visibility: All -;CHECK-NEXT: Register Space: 2 -;CHECK-NEXT: Shader Register: 1 -;CHECK-NEXT: Num 32 Bit Values: 3 -;CHECK-NEXT: - Parameter Type: SRV -;CHECK-NEXT: Shader Visibility: Vertex -;CHECK-NEXT: Register Space: 5 -;CHECK-NEXT: Shader Register: 4 -;CHECK-NEXT: Flags: 4 -;CHECK-NEXT: - Parameter Type: DescriptorTable -;CHECK-NEXT: Shader Visibility: All -;CHECK-NEXT: NumRanges: 2 -;CHECK-NEXT: - Range Type: 0 -;CHECK-NEXT: Register Space: 0 -;CHECK-NEXT: Base Shader Register: 1 -;CHECK-NEXT: Num Descriptors: 1 -;CHECK-NEXT: Offset In Descriptors From Table Start: 4294967295 -;CHECK-NEXT: Flags: 4 -;CHECK-NEXT: - Range Type: 1 -;CHECK-NEXT: Register Space: 10 -;CHECK-NEXT: Base Shader Register: 1 -;CHECK-NEXT: Num Descriptors: 5 -;CHECK-NEXT: Offset In Descriptors From Table Start: 5 -;CHECK-NEXT: Flags: 2 +;CHECK-NEXT: - Parameter Type: Constants32Bit +;CHECK-NEXT: Shader Visibility: All +;CHECK-NEXT: Register Space: 2 +;CHECK-NEXT: Shader Register: 1 +;CHECK-NEXT: Num 32 Bit Values: 3 +;CHECK-NEXT: - Parameter Type: SRV +;CHECK-NEXT: Shader Visibility: Vertex +;CHECK-NEXT: Register Space: 5 +;CHECK-NEXT: Shader Register: 4 +;CHECK-NEXT: Flags: 4 +;CHECK-NEXT: - Parameter Type: DescriptorTable +;CHECK-NEXT: Shader Visibility: All +;CHECK-NEXT: NumRanges: 2 +;CHECK-NEXT: - Range Type: 0 +;CHECK-NEXT: Register Space: 0 +;CHECK-NEXT: Base Shader Register: 1 +;CHECK-NEXT: Num Descriptors: 1 +;CHECK-NEXT: Offset In Descriptors From Table Start: 4294967295 +;CHECK-NEXT: Flags: 4 +;CHECK-NEXT: - Range Type: 1 +;CHECK-NEXT: Register Space: 10 +;CHECK-NEXT: Base Shader Register: 1 +;CHECK-NEXT: Num Descriptors: 5 +;CHECK-NEXT: Offset In Descriptors From Table Start: 5 +;CHECK-NEXT: Flags: 2 ;CHECK-NEXT: NumStaticSamplers: 0 ;CHECK-NEXT: StaticSamplersOffset: 0 From 8eb82fdac3a0b7e632ffc644c369175aba9794c5 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Tue, 19 Aug 2025 10:56:17 -0700 Subject: [PATCH 06/29] adding missing import --- llvm/lib/Target/DirectX/DXILRootSignature.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp index 159cf7eda2482..2ca2ecff5a55f 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp +++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp @@ -27,6 +27,7 @@ #include "llvm/Pass.h" #include "llvm/Support/Error.h" #include "llvm/Support/ErrorHandling.h" +#include "llvm/Support/ScopedPrinter.h" #include "llvm/Support/raw_ostream.h" #include From d38c00d09a9fe8e9dbbb66dca57bc540516acdf0 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Tue, 19 Aug 2025 16:33:07 -0700 Subject: [PATCH 07/29] remove unused --- llvm/include/llvm/MC/DXContainerRootSignature.h | 6 ------ llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp | 2 -- 2 files changed, 8 deletions(-) diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index 149de9fbd8b47..6460d70943911 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -19,12 +19,6 @@ namespace llvm { class raw_ostream; namespace mcdxbc { -struct RootParameterHeader { - dxbc::RootParameterType ParameterType; - dxbc::ShaderVisibility ShaderVisibility; - uint32_t ParameterOffset; -}; - struct RootParameterInfo { dxbc::RootParameterType Type; dxbc::ShaderVisibility Visibility; diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index 4dbcf05fa5668..14001b7bd6428 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -235,8 +235,6 @@ Error MetadataParser::parseRootConstants(mcdxbc::RootSignatureDesc &RSD, if (RootConstantNode->getNumOperands() != 5) return make_error("RootConstants Element"); - mcdxbc::RootParameterHeader Header; - Expected VisibilityOrErr = extractShaderVisibility(RootConstantNode, 1); if (auto E = VisibilityOrErr.takeError()) From 3b25b34cd95d917b665ae53df5a53ec77dfeadd9 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Tue, 19 Aug 2025 16:35:05 -0700 Subject: [PATCH 08/29] save a copy --- llvm/include/llvm/MC/DXContainerRootSignature.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index 6460d70943911..304daaad9cd5f 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -50,7 +50,7 @@ struct RootParametersContainer { void addInfo(dxbc::RootParameterType Type, dxbc::ShaderVisibility Visibility, size_t Location) { - ParametersInfo.push_back(RootParameterInfo(Type, Visibility, Location)); + ParametersInfo.emplace_back(Type, Visibility, Location); } void addParameter(dxbc::RootParameterType Type, From 567a3d4efe867c88b49b6a2ecc614f205ffd1f1c Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Tue, 19 Aug 2025 16:35:55 -0700 Subject: [PATCH 09/29] remove default constructor --- llvm/include/llvm/MC/DXContainerRootSignature.h | 2 -- 1 file changed, 2 deletions(-) diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index 304daaad9cd5f..4db3f3458c808 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -24,8 +24,6 @@ struct RootParameterInfo { dxbc::ShaderVisibility Visibility; size_t Location; - RootParameterInfo() = default; - RootParameterInfo(dxbc::RootParameterType Type, dxbc::ShaderVisibility Visibility, size_t Location) : Type(Type), Visibility(Visibility), Location(Location) {} From fb248daeef03d261ee3baff56f181fba997b3ea0 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Tue, 19 Aug 2025 16:36:56 -0700 Subject: [PATCH 10/29] rename visibility --- .../Frontend/HLSL/RootSignatureMetadata.cpp | 22 +++++++++---------- 1 file changed, 10 insertions(+), 12 deletions(-) diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index 14001b7bd6428..610f889e8d7c6 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -235,9 +235,9 @@ Error MetadataParser::parseRootConstants(mcdxbc::RootSignatureDesc &RSD, if (RootConstantNode->getNumOperands() != 5) return make_error("RootConstants Element"); - Expected VisibilityOrErr = + Expected Visibility = extractShaderVisibility(RootConstantNode, 1); - if (auto E = VisibilityOrErr.takeError()) + if (auto E = Visibility.takeError()) return Error(std::move(E)); dxbc::RTS0::v1::RootConstants Constants; @@ -257,7 +257,7 @@ Error MetadataParser::parseRootConstants(mcdxbc::RootSignatureDesc &RSD, return make_error("Num32BitValues"); RSD.ParametersContainer.addParameter(dxbc::RootParameterType::Constants32Bit, - *VisibilityOrErr, Constants); + *Visibility, Constants); return Error::success(); } @@ -289,9 +289,9 @@ Error MetadataParser::parseRootDescriptors( break; } - Expected VisibilityOrErr = + Expected Visibility = extractShaderVisibility(RootDescriptorNode, 1); - if (auto E = VisibilityOrErr.takeError()) + if (auto E = Visibility.takeError()) return Error(std::move(E)); dxbc::RTS0::v2::RootDescriptor Descriptor; @@ -306,7 +306,7 @@ Error MetadataParser::parseRootDescriptors( return make_error("RegisterSpace"); if (RSD.Version == 1) { - RSD.ParametersContainer.addParameter(Type, *VisibilityOrErr, Descriptor); + RSD.ParametersContainer.addParameter(Type, *Visibility, Descriptor); return Error::success(); } assert(RSD.Version > 1); @@ -316,7 +316,7 @@ Error MetadataParser::parseRootDescriptors( else return make_error("Root Descriptor Flags"); - RSD.ParametersContainer.addParameter(Type, *VisibilityOrErr, Descriptor); + RSD.ParametersContainer.addParameter(Type, *Visibility, Descriptor); return Error::success(); } @@ -382,11 +382,9 @@ Error MetadataParser::parseDescriptorTable(mcdxbc::RootSignatureDesc &RSD, if (NumOperands < 2) return make_error("Descriptor Table"); - mcdxbc::RootParameterHeader Header; - - Expected VisibilityOrErr = + Expected Visibility = extractShaderVisibility(DescriptorTableNode, 1); - if (auto E = VisibilityOrErr.takeError()) + if (auto E = Visibility.takeError()) return Error(std::move(E)); mcdxbc::DescriptorTable Table; @@ -402,7 +400,7 @@ Error MetadataParser::parseDescriptorTable(mcdxbc::RootSignatureDesc &RSD, } RSD.ParametersContainer.addParameter(dxbc::RootParameterType::DescriptorTable, - *VisibilityOrErr, Table); + *Visibility, Table); return Error::success(); } From dc436d553be7e4b29530c9007f1c172ed72e7189 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Tue, 19 Aug 2025 16:37:45 -0700 Subject: [PATCH 11/29] remove cstdint --- llvm/lib/MC/DXContainerRootSignature.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/llvm/lib/MC/DXContainerRootSignature.cpp b/llvm/lib/MC/DXContainerRootSignature.cpp index 45ecd9a8d5e01..27e715f16a4a1 100644 --- a/llvm/lib/MC/DXContainerRootSignature.cpp +++ b/llvm/lib/MC/DXContainerRootSignature.cpp @@ -9,7 +9,6 @@ #include "llvm/MC/DXContainerRootSignature.h" #include "llvm/ADT/SmallString.h" #include "llvm/Support/EndianStream.h" -#include using namespace llvm; using namespace llvm::mcdxbc; From 8353fe0d0a6e5d8e1016c7d1b6b25a3b4b23f058 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Tue, 19 Aug 2025 16:38:47 -0700 Subject: [PATCH 12/29] remove Loc --- llvm/lib/MC/DXContainerRootSignature.cpp | 7 +++---- 1 file changed, 3 insertions(+), 4 deletions(-) diff --git a/llvm/lib/MC/DXContainerRootSignature.cpp b/llvm/lib/MC/DXContainerRootSignature.cpp index 27e715f16a4a1..14c9c8866bb24 100644 --- a/llvm/lib/MC/DXContainerRootSignature.cpp +++ b/llvm/lib/MC/DXContainerRootSignature.cpp @@ -95,11 +95,10 @@ void RootSignatureDesc::write(raw_ostream &OS) const { for (size_t I = 0; I < NumParameters; ++I) { rewriteOffsetToCurrentByte(BOS, ParamsOffsets[I]); const auto Info = ParametersContainer.getInfo(I); - const uint32_t &Loc = Info.Location; switch (Info.Type) { case dxbc::RootParameterType::Constants32Bit: { const dxbc::RTS0::v1::RootConstants &Constants = - ParametersContainer.getConstant(Loc); + ParametersContainer.getConstant(Info.Location); support::endian::write(BOS, Constants.ShaderRegister, llvm::endianness::little); support::endian::write(BOS, Constants.RegisterSpace, @@ -112,7 +111,7 @@ void RootSignatureDesc::write(raw_ostream &OS) const { case dxbc::RootParameterType::SRV: case dxbc::RootParameterType::UAV: { const dxbc::RTS0::v2::RootDescriptor &Descriptor = - ParametersContainer.getRootDescriptor(Loc); + ParametersContainer.getRootDescriptor(Info.Location); support::endian::write(BOS, Descriptor.ShaderRegister, llvm::endianness::little); @@ -124,7 +123,7 @@ void RootSignatureDesc::write(raw_ostream &OS) const { } case dxbc::RootParameterType::DescriptorTable: { const DescriptorTable &Table = - ParametersContainer.getDescriptorTable(Loc); + ParametersContainer.getDescriptorTable(Info.Location); support::endian::write(BOS, (uint32_t)Table.Ranges.size(), llvm::endianness::little); rewriteOffsetToCurrentByte(BOS, writePlaceholder(BOS)); From f3ecd8ae8c4af29d23d8c82c6a9104b615c24473 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Wed, 20 Aug 2025 10:15:37 -0700 Subject: [PATCH 13/29] removing dependency of Object --- .../llvm/MC/DXContainerRootSignature.h | 25 +++++++++++++------ .../Frontend/HLSL/RootSignatureMetadata.cpp | 6 ++--- llvm/lib/MC/DXContainerRootSignature.cpp | 4 +-- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 4 +-- .../DXILPostOptimizationValidation.cpp | 4 +-- llvm/lib/Target/DirectX/DXILRootSignature.cpp | 4 +-- 6 files changed, 29 insertions(+), 18 deletions(-) diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index 4db3f3458c808..85b45323cee08 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -19,6 +19,18 @@ namespace llvm { class raw_ostream; namespace mcdxbc { +struct RootConstants { + uint32_t ShaderRegister; + uint32_t RegisterSpace; + uint32_t Num32BitValues; +}; + +struct RootDescriptor { + uint32_t ShaderRegister; + uint32_t RegisterSpace; + uint32_t Flags; +}; + struct RootParameterInfo { dxbc::RootParameterType Type; dxbc::ShaderVisibility Visibility; @@ -42,8 +54,8 @@ struct DescriptorTable { struct RootParametersContainer { SmallVector ParametersInfo; - SmallVector Constants; - SmallVector Descriptors; + SmallVector Constants; + SmallVector Descriptors; SmallVector Tables; void addInfo(dxbc::RootParameterType Type, dxbc::ShaderVisibility Visibility, @@ -52,15 +64,14 @@ struct RootParametersContainer { } void addParameter(dxbc::RootParameterType Type, - dxbc::ShaderVisibility Visibility, - dxbc::RTS0::v1::RootConstants Constant) { + dxbc::ShaderVisibility Visibility, RootConstants Constant) { addInfo(Type, Visibility, Constants.size()); Constants.push_back(Constant); } void addParameter(dxbc::RootParameterType Type, dxbc::ShaderVisibility Visibility, - dxbc::RTS0::v2::RootDescriptor Descriptor) { + RootDescriptor Descriptor) { addInfo(Type, Visibility, Descriptors.size()); Descriptors.push_back(Descriptor); } @@ -76,11 +87,11 @@ struct RootParametersContainer { return Info; } - const dxbc::RTS0::v1::RootConstants &getConstant(size_t Index) const { + const RootConstants &getConstant(size_t Index) const { return Constants[Index]; } - const dxbc::RTS0::v2::RootDescriptor &getRootDescriptor(size_t Index) const { + const RootDescriptor &getRootDescriptor(size_t Index) const { return Descriptors[Index]; } diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index 610f889e8d7c6..770a6d1638e3c 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -240,7 +240,7 @@ Error MetadataParser::parseRootConstants(mcdxbc::RootSignatureDesc &RSD, if (auto E = Visibility.takeError()) return Error(std::move(E)); - dxbc::RTS0::v1::RootConstants Constants; + mcdxbc::RootConstants Constants; if (std::optional Val = extractMdIntValue(RootConstantNode, 2)) Constants.ShaderRegister = *Val; else @@ -294,7 +294,7 @@ Error MetadataParser::parseRootDescriptors( if (auto E = Visibility.takeError()) return Error(std::move(E)); - dxbc::RTS0::v2::RootDescriptor Descriptor; + mcdxbc::RootDescriptor Descriptor; if (std::optional Val = extractMdIntValue(RootDescriptorNode, 2)) Descriptor.ShaderRegister = *Val; else @@ -544,7 +544,7 @@ Error MetadataParser::validateRootSignature( case dxbc::RootParameterType::CBV: case dxbc::RootParameterType::UAV: case dxbc::RootParameterType::SRV: { - const dxbc::RTS0::v2::RootDescriptor &Descriptor = + const mcdxbc::RootDescriptor &Descriptor = RSD.ParametersContainer.getRootDescriptor(Info.Location); if (!hlsl::rootsig::verifyRegisterValue(Descriptor.ShaderRegister)) DeferredErrs = diff --git a/llvm/lib/MC/DXContainerRootSignature.cpp b/llvm/lib/MC/DXContainerRootSignature.cpp index 14c9c8866bb24..94119d8e89ec9 100644 --- a/llvm/lib/MC/DXContainerRootSignature.cpp +++ b/llvm/lib/MC/DXContainerRootSignature.cpp @@ -97,7 +97,7 @@ void RootSignatureDesc::write(raw_ostream &OS) const { const auto Info = ParametersContainer.getInfo(I); switch (Info.Type) { case dxbc::RootParameterType::Constants32Bit: { - const dxbc::RTS0::v1::RootConstants &Constants = + const mcdxbc::RootConstants &Constants = ParametersContainer.getConstant(Info.Location); support::endian::write(BOS, Constants.ShaderRegister, llvm::endianness::little); @@ -110,7 +110,7 @@ void RootSignatureDesc::write(raw_ostream &OS) const { case dxbc::RootParameterType::CBV: case dxbc::RootParameterType::SRV: case dxbc::RootParameterType::UAV: { - const dxbc::RTS0::v2::RootDescriptor &Descriptor = + const mcdxbc::RootDescriptor &Descriptor = ParametersContainer.getRootDescriptor(Info.Location); support::endian::write(BOS, Descriptor.ShaderRegister, diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index b112c6f21ee5a..a51821e196cb8 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -288,7 +288,7 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { case dxbc::RootParameterType::Constants32Bit: { const DXContainerYAML::RootConstantsYaml &ConstantYaml = P.RootSignature->Parameters.getOrInsertConstants(L); - dxbc::RTS0::v1::RootConstants Constants; + mcdxbc::RootConstants Constants; Constants.Num32BitValues = ConstantYaml.Num32BitValues; Constants.RegisterSpace = ConstantYaml.RegisterSpace; @@ -302,7 +302,7 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { const DXContainerYAML::RootDescriptorYaml &DescriptorYaml = P.RootSignature->Parameters.getOrInsertDescriptor(L); - dxbc::RTS0::v2::RootDescriptor Descriptor; + mcdxbc::RootDescriptor Descriptor; Descriptor.RegisterSpace = DescriptorYaml.RegisterSpace; Descriptor.ShaderRegister = DescriptorYaml.ShaderRegister; if (RS.Version > 1) diff --git a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp index fc0afb9a0efdf..5557443a3db93 100644 --- a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp +++ b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp @@ -171,7 +171,7 @@ static void validateRootSignature(Module &M, dxbc::RootParameterType ParamType = dxbc::RootParameterType(ParamInfo.Type); switch (ParamType) { case dxbc::RootParameterType::Constants32Bit: { - dxbc::RTS0::v1::RootConstants Const = + mcdxbc::RootConstants Const = RSD.ParametersContainer.getConstant(ParamInfo.Location); Builder.trackBinding(dxil::ResourceClass::CBuffer, Const.RegisterSpace, Const.ShaderRegister, Const.ShaderRegister, @@ -182,7 +182,7 @@ static void validateRootSignature(Module &M, case dxbc::RootParameterType::SRV: case dxbc::RootParameterType::UAV: case dxbc::RootParameterType::CBV: { - dxbc::RTS0::v2::RootDescriptor Desc = + mcdxbc::RootDescriptor Desc = RSD.ParametersContainer.getRootDescriptor(ParamInfo.Location); Builder.trackBinding(toResourceClass(ParamInfo.Type), Desc.RegisterSpace, Desc.ShaderRegister, Desc.ShaderRegister, diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp index 2ca2ecff5a55f..b05b8ee699ef6 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp +++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp @@ -182,7 +182,7 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M, const uint32_t &Loc = Info.Location; switch (Info.Type) { case dxbc::RootParameterType::Constants32Bit: { - const dxbc::RTS0::v1::RootConstants &Constants = + const mcdxbc::RootConstants &Constants = RS.ParametersContainer.getConstant(Loc); OS << " Register Space: " << Constants.RegisterSpace << "\n" << " Shader Register: " << Constants.ShaderRegister << "\n" @@ -192,7 +192,7 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M, case dxbc::RootParameterType::CBV: case dxbc::RootParameterType::UAV: case dxbc::RootParameterType::SRV: { - const dxbc::RTS0::v2::RootDescriptor &Descriptor = + const mcdxbc::RootDescriptor &Descriptor = RS.ParametersContainer.getRootDescriptor(Loc); OS << " Register Space: " << Descriptor.RegisterSpace << "\n" << " Shader Register: " << Descriptor.ShaderRegister << "\n"; From 8c143ba0ce00b198244ff9f598c4ce905e9f10cd Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Wed, 20 Aug 2025 11:55:38 -0700 Subject: [PATCH 14/29] removing binary format descriptor range dependency --- clang/lib/Sema/SemaHLSL.cpp | 31 ++++++++++++++++--- llvm/include/llvm/BinaryFormat/DXContainer.h | 10 ++++++ .../Frontend/HLSL/RootSignatureValidations.h | 3 +- .../llvm/MC/DXContainerRootSignature.h | 15 +++++++-- llvm/lib/BinaryFormat/DXContainer.cpp | 10 ++++++ .../Frontend/HLSL/RootSignatureMetadata.cpp | 25 +++++---------- .../HLSL/RootSignatureValidations.cpp | 5 ++- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 7 +++-- .../DXILPostOptimizationValidation.cpp | 2 +- llvm/lib/Target/DirectX/DXILRootSignature.cpp | 7 +++-- ...ature-DescriptorTable-Invalid-RangeType.ll | 20 ------------ .../ContainerData/RootSignature-Parameters.ll | 4 +-- 12 files changed, 82 insertions(+), 57 deletions(-) delete mode 100644 llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-Invalid-RangeType.ll diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp index 47a4874721db8..85dc5eb2b42f8 100644 --- a/clang/lib/Sema/SemaHLSL.cpp +++ b/clang/lib/Sema/SemaHLSL.cpp @@ -1268,11 +1268,34 @@ bool SemaHLSL::handleRootSignatureElements( // value ReportError(Loc, 1, 0xfffffffe); } + switch (Clause->Type) { - if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( - Version, llvm::to_underlying(Clause->Type), - llvm::to_underlying(Clause->Flags))) - ReportFlagError(Loc); + case llvm::dxil::ResourceClass::SRV: + if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( + Version, llvm::dxbc::DescriptorRangeType::SRV, + llvm::to_underlying(Clause->Flags))) + ReportFlagError(Loc); + break; + case llvm::dxil::ResourceClass::UAV: + if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( + Version, llvm::dxbc::DescriptorRangeType::UAV, + llvm::to_underlying(Clause->Flags))) + ReportFlagError(Loc); + break; + case llvm::dxil::ResourceClass::CBuffer: + if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( + Version, llvm::dxbc::DescriptorRangeType::CBV, + llvm::to_underlying(Clause->Flags))) + ReportFlagError(Loc); + break; + case llvm::dxil::ResourceClass::Sampler: + if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( + Version, llvm::dxbc::DescriptorRangeType::Sampler, + llvm::to_underlying(Clause->Flags))) + ReportFlagError(Loc); + break; + break; + } } } diff --git a/llvm/include/llvm/BinaryFormat/DXContainer.h b/llvm/include/llvm/BinaryFormat/DXContainer.h index f74c9775cb3f3..54747b46ccc6c 100644 --- a/llvm/include/llvm/BinaryFormat/DXContainer.h +++ b/llvm/include/llvm/BinaryFormat/DXContainer.h @@ -209,6 +209,16 @@ inline bool isValidParameterType(uint32_t V) { return false; } +#define DESCRIPTOR_RANGE(Val, Enum) \ + case Val: \ + return true; +inline bool isValidRangeType(uint32_t V) { + switch (V) { +#include "DXContainerConstants.def" + } + return false; +} + #define SHADER_VISIBILITY(Val, Enum) Enum = Val, enum class ShaderVisibility : uint32_t { #include "DXContainerConstants.def" diff --git a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h index fde32a1fff591..acb83e54b92ed 100644 --- a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h +++ b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h @@ -30,7 +30,8 @@ LLVM_ABI bool verifyRegisterValue(uint32_t RegisterValue); LLVM_ABI bool verifyRegisterSpace(uint32_t RegisterSpace); LLVM_ABI bool verifyRootDescriptorFlag(uint32_t Version, uint32_t FlagsVal); LLVM_ABI bool verifyRangeType(uint32_t Type); -LLVM_ABI bool verifyDescriptorRangeFlag(uint32_t Version, uint32_t Type, +LLVM_ABI bool verifyDescriptorRangeFlag(uint32_t Version, + dxbc::DescriptorRangeType Type, uint32_t FlagsVal); LLVM_ABI bool verifyNumDescriptors(uint32_t NumDescriptors); LLVM_ABI bool verifySamplerFilter(uint32_t Value); diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index 85b45323cee08..28664434f933c 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -31,6 +31,15 @@ struct RootDescriptor { uint32_t Flags; }; +struct DescriptorRange { + dxbc::DescriptorRangeType RangeType; + uint32_t NumDescriptors; + uint32_t BaseShaderRegister; + uint32_t RegisterSpace; + uint32_t Flags; + uint32_t OffsetInDescriptorsFromTableStart; +}; + struct RootParameterInfo { dxbc::RootParameterType Type; dxbc::ShaderVisibility Visibility; @@ -42,11 +51,11 @@ struct RootParameterInfo { }; struct DescriptorTable { - SmallVector Ranges; - SmallVector::const_iterator begin() const { + SmallVector Ranges; + SmallVector::const_iterator begin() const { return Ranges.begin(); } - SmallVector::const_iterator end() const { + SmallVector::const_iterator end() const { return Ranges.end(); } }; diff --git a/llvm/lib/BinaryFormat/DXContainer.cpp b/llvm/lib/BinaryFormat/DXContainer.cpp index 36d10d0b63078..f79db506962bc 100644 --- a/llvm/lib/BinaryFormat/DXContainer.cpp +++ b/llvm/lib/BinaryFormat/DXContainer.cpp @@ -149,6 +149,16 @@ ArrayRef> dxbc::getRootParameterTypes() { return ArrayRef(RootParameterTypes); } +#define DESCRIPTOR_RANGE(Val, Enum) {#Enum, DescriptorRangeType::Enum}, + +static const EnumEntry DescriptorRangeTypes[] = { +#include "llvm/BinaryFormat/DXContainerConstants.def" +}; + +ArrayRef> dxbc::getDescriptorRangeTypes() { + return ArrayRef(DescriptorRangeTypes); +} + #define SEMANTIC_KIND(Val, Enum) {#Enum, PSV::SemanticKind::Enum}, static const EnumEntry SemanticKindNames[] = { diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index 770a6d1638e3c..a5e66e73a5dc1 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -325,7 +325,7 @@ Error MetadataParser::parseDescriptorRange(mcdxbc::DescriptorTable &Table, if (RangeDescriptorNode->getNumOperands() != 6) return make_error("Descriptor Range"); - dxbc::RTS0::v2::DescriptorRange Range; + mcdxbc::DescriptorRange Range; std::optional ElementText = extractMdStringValue(RangeDescriptorNode, 0); @@ -333,17 +333,11 @@ Error MetadataParser::parseDescriptorRange(mcdxbc::DescriptorTable &Table, if (!ElementText.has_value()) return make_error("Descriptor Range"); - Range.RangeType = - StringSwitch(*ElementText) - .Case("CBV", to_underlying(dxbc::DescriptorRangeType::CBV)) - .Case("SRV", to_underlying(dxbc::DescriptorRangeType::SRV)) - .Case("UAV", to_underlying(dxbc::DescriptorRangeType::UAV)) - .Case("Sampler", to_underlying(dxbc::DescriptorRangeType::Sampler)) - .Default(~0U); - - if (Range.RangeType == ~0U) - return make_error("Invalid Descriptor Range type.", - RangeDescriptorNode); + Range.RangeType = StringSwitch(*ElementText) + .Case("CBV", dxbc::DescriptorRangeType::CBV) + .Case("SRV", dxbc::DescriptorRangeType::SRV) + .Case("UAV", dxbc::DescriptorRangeType::UAV) + .Case("Sampler", dxbc::DescriptorRangeType::Sampler); if (std::optional Val = extractMdIntValue(RangeDescriptorNode, 1)) Range.NumDescriptors = *Val; @@ -571,12 +565,7 @@ Error MetadataParser::validateRootSignature( case dxbc::RootParameterType::DescriptorTable: { const mcdxbc::DescriptorTable &Table = RSD.ParametersContainer.getDescriptorTable(Info.Location); - for (const dxbc::RTS0::v2::DescriptorRange &Range : Table) { - if (!hlsl::rootsig::verifyRangeType(Range.RangeType)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "RangeType", Range.RangeType)); + for (const mcdxbc::DescriptorRange &Range : Table) { if (!hlsl::rootsig::verifyRegisterSpace(Range.RegisterSpace)) DeferredErrs = diff --git a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp index 72308a3de5fd4..5dbeede778b04 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp @@ -63,13 +63,12 @@ bool verifyRangeType(uint32_t Type) { return false; } -bool verifyDescriptorRangeFlag(uint32_t Version, uint32_t Type, +bool verifyDescriptorRangeFlag(uint32_t Version, dxbc::DescriptorRangeType Type, uint32_t FlagsVal) { using FlagT = dxbc::DescriptorRangeFlags; FlagT Flags = FlagT(FlagsVal); - const bool IsSampler = - (Type == llvm::to_underlying(dxbc::DescriptorRangeType::Sampler)); + const bool IsSampler = (Type == dxbc::DescriptorRangeType::Sampler); if (Version == 1) { // Since the metadata is unversioned, we expect to explicitly see the values diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index a51821e196cb8..a749f47792453 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -315,9 +315,10 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { P.RootSignature->Parameters.getOrInsertTable(L); mcdxbc::DescriptorTable Table; for (const auto &R : TableYaml.Ranges) { - - dxbc::RTS0::v2::DescriptorRange Range; - Range.RangeType = R.RangeType; + assert(dxbc::isValidRangeType(R.RangeType) && + "Invalid Descriptor Range Type"); + mcdxbc::DescriptorRange Range; + Range.RangeType = dxbc::DescriptorRangeType(R.RangeType); Range.NumDescriptors = R.NumDescriptors; Range.BaseShaderRegister = R.BaseShaderRegister; Range.RegisterSpace = R.RegisterSpace; diff --git a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp index 5557443a3db93..c6f79621c39de 100644 --- a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp +++ b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp @@ -194,7 +194,7 @@ static void validateRootSignature(Module &M, const mcdxbc::DescriptorTable &Table = RSD.ParametersContainer.getDescriptorTable(ParamInfo.Location); - for (const dxbc::RTS0::v2::DescriptorRange &Range : Table.Ranges) { + for (const mcdxbc::DescriptorRange &Range : Table.Ranges) { uint32_t UpperBound = Range.NumDescriptors == ~0U ? Range.BaseShaderRegister diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp index b05b8ee699ef6..296e11f3ad5e9 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp +++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp @@ -205,8 +205,11 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M, RS.ParametersContainer.getDescriptorTable(Loc); OS << " NumRanges: " << Table.Ranges.size() << "\n"; - for (const dxbc::RTS0::v2::DescriptorRange Range : Table) { - OS << " - Range Type: " << Range.RangeType << "\n" + for (const mcdxbc::DescriptorRange Range : Table) { + OS << " - Range Type: " + << enumToStringRef(Range.RangeType, + dxbc::getDescriptorRangeTypes()) + << "\n" << " Register Space: " << Range.RegisterSpace << "\n" << " Base Shader Register: " << Range.BaseShaderRegister << "\n" << " Num Descriptors: " << Range.NumDescriptors << "\n" diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-Invalid-RangeType.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-Invalid-RangeType.ll deleted file mode 100644 index 4a65a53f9f727..0000000000000 --- a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-Invalid-RangeType.ll +++ /dev/null @@ -1,20 +0,0 @@ -; RUN: not opt -passes='print' %s -S -o - 2>&1 | FileCheck %s - -target triple = "dxil-unknown-shadermodel6.0-compute" - -; CHECK: error: Invalid Descriptor Range type -; CHECK-NOT: Root Signature Definitions - -define void @main() #0 { -entry: - ret void -} -attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } - - -!dx.rootsignatures = !{!2} ; list of function/root signature pairs -!2 = !{ ptr @main, !3, i32 2 } ; function, root signature -!3 = !{ !5 } ; list of root signature elements -!5 = !{ !"DescriptorTable", i32 0, !6, !7 } -!6 = !{ !"Invalid", i32 1, i32 0, i32 -1, i32 -1, i32 4 } -!7 = !{ !"UAV", i32 5, i32 1, i32 10, i32 5, i32 2 } diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll index 742fea14f5af6..6c6739d6ed390 100644 --- a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll +++ b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll @@ -38,13 +38,13 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } ;CHECK-NEXT: - Parameter Type: DescriptorTable ;CHECK-NEXT: Shader Visibility: All ;CHECK-NEXT: NumRanges: 2 -;CHECK-NEXT: - Range Type: 0 +;CHECK-NEXT: - Range Type: SRV ;CHECK-NEXT: Register Space: 0 ;CHECK-NEXT: Base Shader Register: 1 ;CHECK-NEXT: Num Descriptors: 1 ;CHECK-NEXT: Offset In Descriptors From Table Start: 4294967295 ;CHECK-NEXT: Flags: 4 -;CHECK-NEXT: - Range Type: 1 +;CHECK-NEXT: - Range Type: UAV ;CHECK-NEXT: Register Space: 10 ;CHECK-NEXT: Base Shader Register: 1 ;CHECK-NEXT: Num Descriptors: 5 From e57236c70a240ed2ad33d21bd6f79d708003d826 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Wed, 20 Aug 2025 14:41:14 -0700 Subject: [PATCH 15/29] removing binaryformat dependency on mc --- llvm/include/llvm/BinaryFormat/DXContainer.h | 40 +++++ .../Frontend/HLSL/RootSignatureValidations.h | 4 - .../llvm/MC/DXContainerRootSignature.h | 18 ++- .../Frontend/HLSL/RootSignatureMetadata.cpp | 140 ++++++++---------- .../HLSL/RootSignatureValidations.cpp | 41 ----- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 26 +++- .../DXILPostOptimizationValidation.cpp | 2 +- .../RootSignature-StaticSamplers.yaml | 4 +- .../ObjectYAML/DXContainerYAMLTest.cpp | 4 +- 9 files changed, 140 insertions(+), 139 deletions(-) diff --git a/llvm/include/llvm/BinaryFormat/DXContainer.h b/llvm/include/llvm/BinaryFormat/DXContainer.h index 54747b46ccc6c..20b05bff21f94 100644 --- a/llvm/include/llvm/BinaryFormat/DXContainer.h +++ b/llvm/include/llvm/BinaryFormat/DXContainer.h @@ -241,6 +241,16 @@ enum class SamplerFilter : uint32_t { #include "DXContainerConstants.def" }; +#define FILTER(Val, Enum) \ + case Val: \ + return true; +inline bool isValidSamplerFilter(uint32_t V) { + switch (V) { +#include "DXContainerConstants.def" + } + return false; +} + LLVM_ABI ArrayRef> getSamplerFilters(); #define TEXTURE_ADDRESS_MODE(Val, Enum) Enum = Val, @@ -250,6 +260,16 @@ enum class TextureAddressMode : uint32_t { LLVM_ABI ArrayRef> getTextureAddressModes(); +#define TEXTURE_ADDRESS_MODE(Val, Enum) \ + case Val: \ + return true; +inline bool isValidAddress(uint32_t V) { + switch (V) { +#include "DXContainerConstants.def" + } + return false; +} + #define COMPARISON_FUNC(Val, Enum) Enum = Val, enum class ComparisonFunc : uint32_t { #include "DXContainerConstants.def" @@ -257,11 +277,31 @@ enum class ComparisonFunc : uint32_t { LLVM_ABI ArrayRef> getComparisonFuncs(); +#define COMPARISON_FUNC(Val, Enum) \ + case Val: \ + return true; +inline bool isValidComparisonFunc(uint32_t V) { + switch (V) { +#include "DXContainerConstants.def" + } + return false; +} + #define STATIC_BORDER_COLOR(Val, Enum) Enum = Val, enum class StaticBorderColor : uint32_t { #include "DXContainerConstants.def" }; +#define STATIC_BORDER_COLOR(Val, Enum) \ + case Val: \ + return true; +inline bool isValidBorderColor(uint32_t V) { + switch (V) { +#include "DXContainerConstants.def" + } + return false; +} + LLVM_ABI ArrayRef> getStaticBorderColors(); LLVM_ABI PartType parsePartType(StringRef S); diff --git a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h index acb83e54b92ed..177bf404a900e 100644 --- a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h +++ b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h @@ -34,12 +34,8 @@ LLVM_ABI bool verifyDescriptorRangeFlag(uint32_t Version, dxbc::DescriptorRangeType Type, uint32_t FlagsVal); LLVM_ABI bool verifyNumDescriptors(uint32_t NumDescriptors); -LLVM_ABI bool verifySamplerFilter(uint32_t Value); -LLVM_ABI bool verifyAddress(uint32_t Address); LLVM_ABI bool verifyMipLODBias(float MipLODBias); LLVM_ABI bool verifyMaxAnisotropy(uint32_t MaxAnisotropy); -LLVM_ABI bool verifyComparisonFunc(uint32_t ComparisonFunc); -LLVM_ABI bool verifyBorderColor(uint32_t BorderColor); LLVM_ABI bool verifyLOD(float LOD); } // namespace rootsig diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index 28664434f933c..03de716c004eb 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -60,6 +60,22 @@ struct DescriptorTable { } }; +struct StaticSampler { + dxbc::SamplerFilter Filter; + dxbc::TextureAddressMode AddressU; + dxbc::TextureAddressMode AddressV; + dxbc::TextureAddressMode AddressW; + float MipLODBias; + uint32_t MaxAnisotropy; + dxbc::ComparisonFunc ComparisonFunc; + dxbc::StaticBorderColor BorderColor; + float MinLOD; + float MaxLOD; + uint32_t ShaderRegister; + uint32_t RegisterSpace; + dxbc::ShaderVisibility ShaderVisibility; +}; + struct RootParametersContainer { SmallVector ParametersInfo; @@ -125,7 +141,7 @@ struct RootSignatureDesc { uint32_t StaticSamplersOffset = 0u; uint32_t NumStaticSamplers = 0u; mcdxbc::RootParametersContainer ParametersContainer; - SmallVector StaticSamplers; + SmallVector StaticSamplers; LLVM_ABI void write(raw_ostream &OS) const; diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index a5e66e73a5dc1..c7a96dcbd9f87 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -51,13 +51,13 @@ static std::optional extractMdStringValue(MDNode *Node, return NodeText->getString(); } -static Expected -extractShaderVisibility(MDNode *Node, unsigned int OpId) { +template , int> = 0> +Expected extractEnumValue(MDNode *Node, unsigned int OpId, StringRef ErrText, + llvm::function_ref VerifyFn) { if (std::optional Val = extractMdIntValue(Node, OpId)) { - if (!dxbc::isValidShaderVisibility(*Val)) - return make_error>( - "ShaderVisibility", *Val); - return dxbc::ShaderVisibility(*Val); + if (!VerifyFn(*Val)) + return make_error>(ErrText, *Val); + return static_cast(*Val); } return make_error("ShaderVisibility"); } @@ -236,7 +236,9 @@ Error MetadataParser::parseRootConstants(mcdxbc::RootSignatureDesc &RSD, return make_error("RootConstants Element"); Expected Visibility = - extractShaderVisibility(RootConstantNode, 1); + extractEnumValue(RootConstantNode, 1, + "ShaderVisibility", + dxbc::isValidShaderVisibility); if (auto E = Visibility.takeError()) return Error(std::move(E)); @@ -290,7 +292,9 @@ Error MetadataParser::parseRootDescriptors( } Expected Visibility = - extractShaderVisibility(RootDescriptorNode, 1); + extractEnumValue(RootDescriptorNode, 1, + "ShaderVisibility", + dxbc::isValidShaderVisibility); if (auto E = Visibility.takeError()) return Error(std::move(E)); @@ -377,7 +381,9 @@ Error MetadataParser::parseDescriptorTable(mcdxbc::RootSignatureDesc &RSD, return make_error("Descriptor Table"); Expected Visibility = - extractShaderVisibility(DescriptorTableNode, 1); + extractEnumValue(DescriptorTableNode, 1, + "ShaderVisibility", + dxbc::isValidShaderVisibility); if (auto E = Visibility.takeError()) return Error(std::move(E)); @@ -403,26 +409,34 @@ Error MetadataParser::parseStaticSampler(mcdxbc::RootSignatureDesc &RSD, if (StaticSamplerNode->getNumOperands() != 14) return make_error("Static Sampler"); - dxbc::RTS0::v1::StaticSampler Sampler; - if (std::optional Val = extractMdIntValue(StaticSamplerNode, 1)) - Sampler.Filter = *Val; - else - return make_error("Filter"); + mcdxbc::StaticSampler Sampler; - if (std::optional Val = extractMdIntValue(StaticSamplerNode, 2)) - Sampler.AddressU = *Val; - else - return make_error("AddressU"); + Expected Filter = extractEnumValue( + StaticSamplerNode, 1, "Filter", dxbc::isValidSamplerFilter); + if (auto E = Filter.takeError()) + return Error(std::move(E)); + Sampler.Filter = *Filter; - if (std::optional Val = extractMdIntValue(StaticSamplerNode, 3)) - Sampler.AddressV = *Val; - else - return make_error("AddressV"); + Expected AddressU = + extractEnumValue( + StaticSamplerNode, 2, "AddressU", dxbc::isValidAddress); + if (auto E = AddressU.takeError()) + return Error(std::move(E)); + Sampler.AddressU = *AddressU; - if (std::optional Val = extractMdIntValue(StaticSamplerNode, 4)) - Sampler.AddressW = *Val; - else - return make_error("AddressW"); + Expected AddressV = + extractEnumValue( + StaticSamplerNode, 3, "AddressV", dxbc::isValidAddress); + if (auto E = AddressV.takeError()) + return Error(std::move(E)); + Sampler.AddressV = *AddressV; + + Expected AddressW = + extractEnumValue( + StaticSamplerNode, 4, "AddressW", dxbc::isValidAddress); + if (auto E = AddressW.takeError()) + return Error(std::move(E)); + Sampler.AddressW = *AddressW; if (std::optional Val = extractMdFloatValue(StaticSamplerNode, 5)) Sampler.MipLODBias = *Val; @@ -434,15 +448,19 @@ Error MetadataParser::parseStaticSampler(mcdxbc::RootSignatureDesc &RSD, else return make_error("MaxAnisotropy"); - if (std::optional Val = extractMdIntValue(StaticSamplerNode, 7)) - Sampler.ComparisonFunc = *Val; - else - return make_error("ComparisonFunc"); + Expected ComparisonFunc = + extractEnumValue( + StaticSamplerNode, 7, "ComparisonFunc", dxbc::isValidComparisonFunc); + if (auto E = ComparisonFunc.takeError()) + return Error(std::move(E)); + Sampler.ComparisonFunc = *ComparisonFunc; - if (std::optional Val = extractMdIntValue(StaticSamplerNode, 8)) - Sampler.BorderColor = *Val; - else - return make_error("ComparisonFunc"); + Expected BorderColor = + extractEnumValue( + StaticSamplerNode, 8, "BorderColor", dxbc::isValidBorderColor); + if (auto E = BorderColor.takeError()) + return Error(std::move(E)); + Sampler.BorderColor = *BorderColor; if (std::optional Val = extractMdFloatValue(StaticSamplerNode, 9)) Sampler.MinLOD = *Val; @@ -464,10 +482,13 @@ Error MetadataParser::parseStaticSampler(mcdxbc::RootSignatureDesc &RSD, else return make_error("RegisterSpace"); - if (std::optional Val = extractMdIntValue(StaticSamplerNode, 13)) - Sampler.ShaderVisibility = *Val; - else - return make_error("ShaderVisibility"); + Expected Visibility = + extractEnumValue(StaticSamplerNode, 13, + "ShaderVisibility", + dxbc::isValidShaderVisibility); + if (auto E = Visibility.takeError()) + return Error(std::move(E)); + Sampler.ShaderVisibility = *Visibility; RSD.StaticSamplers.push_back(Sampler); return Error::success(); @@ -591,30 +612,7 @@ Error MetadataParser::validateRootSignature( } } - for (const dxbc::RTS0::v1::StaticSampler &Sampler : RSD.StaticSamplers) { - if (!hlsl::rootsig::verifySamplerFilter(Sampler.Filter)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "Filter", Sampler.Filter)); - - if (!hlsl::rootsig::verifyAddress(Sampler.AddressU)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "AddressU", Sampler.AddressU)); - - if (!hlsl::rootsig::verifyAddress(Sampler.AddressV)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "AddressV", Sampler.AddressV)); - - if (!hlsl::rootsig::verifyAddress(Sampler.AddressW)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "AddressW", Sampler.AddressW)); + for (const mcdxbc::StaticSampler &Sampler : RSD.StaticSamplers) { if (!hlsl::rootsig::verifyMipLODBias(Sampler.MipLODBias)) DeferredErrs = joinErrors(std::move(DeferredErrs), @@ -627,18 +625,6 @@ Error MetadataParser::validateRootSignature( make_error>( "MaxAnisotropy", Sampler.MaxAnisotropy)); - if (!hlsl::rootsig::verifyComparisonFunc(Sampler.ComparisonFunc)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "ComparisonFunc", Sampler.ComparisonFunc)); - - if (!hlsl::rootsig::verifyBorderColor(Sampler.BorderColor)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "BorderColor", Sampler.BorderColor)); - if (!hlsl::rootsig::verifyLOD(Sampler.MinLOD)) DeferredErrs = joinErrors(std::move(DeferredErrs), make_error>( @@ -660,12 +646,6 @@ Error MetadataParser::validateRootSignature( joinErrors(std::move(DeferredErrs), make_error>( "RegisterSpace", Sampler.RegisterSpace)); - - if (!dxbc::isValidShaderVisibility(Sampler.ShaderVisibility)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "ShaderVisibility", Sampler.ShaderVisibility)); } return DeferredErrs; diff --git a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp index 5dbeede778b04..d2d451a4274a4 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp @@ -128,27 +128,6 @@ bool verifyNumDescriptors(uint32_t NumDescriptors) { return NumDescriptors > 0; } -bool verifySamplerFilter(uint32_t Value) { - switch (Value) { -#define FILTER(Num, Val) case llvm::to_underlying(dxbc::SamplerFilter::Val): -#include "llvm/BinaryFormat/DXContainerConstants.def" - return true; - } - return false; -} - -// Values allowed here: -// https://learn.microsoft.com/en-us/windows/win32/api/d3d12/ne-d3d12-d3d12_texture_address_mode#syntax -bool verifyAddress(uint32_t Address) { - switch (Address) { -#define TEXTURE_ADDRESS_MODE(Num, Val) \ - case llvm::to_underlying(dxbc::TextureAddressMode::Val): -#include "llvm/BinaryFormat/DXContainerConstants.def" - return true; - } - return false; -} - bool verifyMipLODBias(float MipLODBias) { return MipLODBias >= -16.f && MipLODBias <= 15.99f; } @@ -157,26 +136,6 @@ bool verifyMaxAnisotropy(uint32_t MaxAnisotropy) { return MaxAnisotropy <= 16u; } -bool verifyComparisonFunc(uint32_t ComparisonFunc) { - switch (ComparisonFunc) { -#define COMPARISON_FUNC(Num, Val) \ - case llvm::to_underlying(dxbc::ComparisonFunc::Val): -#include "llvm/BinaryFormat/DXContainerConstants.def" - return true; - } - return false; -} - -bool verifyBorderColor(uint32_t BorderColor) { - switch (BorderColor) { -#define STATIC_BORDER_COLOR(Num, Val) \ - case llvm::to_underlying(dxbc::StaticBorderColor::Val): -#include "llvm/BinaryFormat/DXContainerConstants.def" - return true; - } - return false; -} - bool verifyLOD(float LOD) { return !std::isnan(LOD); } } // namespace rootsig diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index a749f47792453..5a479461b8714 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -335,20 +335,30 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { } for (const auto &Param : P.RootSignature->samplers()) { - dxbc::RTS0::v1::StaticSampler NewSampler; - NewSampler.Filter = Param.Filter; - NewSampler.AddressU = Param.AddressU; - NewSampler.AddressV = Param.AddressV; - NewSampler.AddressW = Param.AddressW; + assert(dxbc::isValidSamplerFilter(Param.Filter) && + dxbc::isValidAddress(Param.AddressU) && + dxbc::isValidAddress(Param.AddressV) && + dxbc::isValidAddress(Param.AddressW) && + dxbc::isValidComparisonFunc(Param.ComparisonFunc) && + dxbc::isValidBorderColor(Param.BorderColor) && + dxbc::isValidShaderVisibility(Param.ShaderVisibility) && + "Invalid enum value in static sampler"); + + mcdxbc::StaticSampler NewSampler; + NewSampler.Filter = dxbc::SamplerFilter(Param.Filter); + NewSampler.AddressU = dxbc::TextureAddressMode(Param.AddressU); + NewSampler.AddressV = dxbc::TextureAddressMode(Param.AddressV); + NewSampler.AddressW = dxbc::TextureAddressMode(Param.AddressW); NewSampler.MipLODBias = Param.MipLODBias; NewSampler.MaxAnisotropy = Param.MaxAnisotropy; - NewSampler.ComparisonFunc = Param.ComparisonFunc; - NewSampler.BorderColor = Param.BorderColor; + NewSampler.ComparisonFunc = dxbc::ComparisonFunc(Param.ComparisonFunc); + NewSampler.BorderColor = dxbc::StaticBorderColor(Param.BorderColor); NewSampler.MinLOD = Param.MinLOD; NewSampler.MaxLOD = Param.MaxLOD; NewSampler.ShaderRegister = Param.ShaderRegister; NewSampler.RegisterSpace = Param.RegisterSpace; - NewSampler.ShaderVisibility = Param.ShaderVisibility; + NewSampler.ShaderVisibility = + dxbc::ShaderVisibility(Param.ShaderVisibility); RS.StaticSamplers.push_back(NewSampler); } diff --git a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp index c6f79621c39de..920a905f62304 100644 --- a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp +++ b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp @@ -210,7 +210,7 @@ static void validateRootSignature(Module &M, } } - for (const dxbc::RTS0::v1::StaticSampler &S : RSD.StaticSamplers) + for (const mcdxbc::StaticSampler &S : RSD.StaticSamplers) Builder.trackBinding(dxil::ResourceClass::Sampler, S.RegisterSpace, S.ShaderRegister, S.ShaderRegister, &S); diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplers.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplers.yaml index 8f8083e091253..175b8ea101c87 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplers.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplers.yaml @@ -20,7 +20,7 @@ Parts: StaticSamplersOffset: 24 Parameters: [] Samplers: - - Filter: 10 + - Filter: 16 AddressU: 1 AddressV: 2 AddressW: 5 @@ -46,7 +46,7 @@ Parts: #CHECK-NEXT: StaticSamplersOffset: 24 #CHECK-NEXT: Parameters: [] #CHECK-NEXT: Samplers: -#CHECK-NEXT: - Filter: 10 +#CHECK-NEXT: - Filter: 16 #CHECK-NEXT: AddressU: 1 #CHECK-NEXT: AddressV: 2 #CHECK-NEXT: AddressW: 5 diff --git a/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp b/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp index 9e6f7cc4f7dbd..37000259dc400 100644 --- a/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp +++ b/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp @@ -492,7 +492,7 @@ TEST(RootSignature, ParseStaticSamplers) { StaticSamplersOffset: 24 Parameters: [] Samplers: - - Filter: 10 + - Filter: 16 AddressU: 1 AddressV: 2 AddressW: 5 @@ -517,7 +517,7 @@ TEST(RootSignature, ParseStaticSamplers) { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x52, 0x54, 0x53, 0x30, 0x4c, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, - 0x18, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00, + 0x18, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0xa4, 0x70, 0x9d, 0x3f, 0x14, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x85, 0xeb, 0x91, 0x40, 0x66, 0x66, 0x0e, 0x41, From a4d77d734011cdd651dd23a67ef5be75b649a59a Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Wed, 20 Aug 2025 14:48:32 -0700 Subject: [PATCH 16/29] Revert "removing binary format descriptor range dependency" This reverts commit 8c143ba0ce00b198244ff9f598c4ce905e9f10cd. --- clang/lib/Sema/SemaHLSL.cpp | 31 +++---------------- llvm/include/llvm/BinaryFormat/DXContainer.h | 10 ------ .../Frontend/HLSL/RootSignatureValidations.h | 3 +- .../llvm/MC/DXContainerRootSignature.h | 15 ++------- llvm/lib/BinaryFormat/DXContainer.cpp | 10 ------ .../Frontend/HLSL/RootSignatureMetadata.cpp | 25 ++++++++++----- .../HLSL/RootSignatureValidations.cpp | 5 +-- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 7 ++--- .../DXILPostOptimizationValidation.cpp | 2 +- llvm/lib/Target/DirectX/DXILRootSignature.cpp | 7 ++--- ...ature-DescriptorTable-Invalid-RangeType.ll | 20 ++++++++++++ .../ContainerData/RootSignature-Parameters.ll | 4 +-- 12 files changed, 57 insertions(+), 82 deletions(-) create mode 100644 llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-Invalid-RangeType.ll diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp index 85dc5eb2b42f8..47a4874721db8 100644 --- a/clang/lib/Sema/SemaHLSL.cpp +++ b/clang/lib/Sema/SemaHLSL.cpp @@ -1268,34 +1268,11 @@ bool SemaHLSL::handleRootSignatureElements( // value ReportError(Loc, 1, 0xfffffffe); } - switch (Clause->Type) { - case llvm::dxil::ResourceClass::SRV: - if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( - Version, llvm::dxbc::DescriptorRangeType::SRV, - llvm::to_underlying(Clause->Flags))) - ReportFlagError(Loc); - break; - case llvm::dxil::ResourceClass::UAV: - if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( - Version, llvm::dxbc::DescriptorRangeType::UAV, - llvm::to_underlying(Clause->Flags))) - ReportFlagError(Loc); - break; - case llvm::dxil::ResourceClass::CBuffer: - if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( - Version, llvm::dxbc::DescriptorRangeType::CBV, - llvm::to_underlying(Clause->Flags))) - ReportFlagError(Loc); - break; - case llvm::dxil::ResourceClass::Sampler: - if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( - Version, llvm::dxbc::DescriptorRangeType::Sampler, - llvm::to_underlying(Clause->Flags))) - ReportFlagError(Loc); - break; - break; - } + if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( + Version, llvm::to_underlying(Clause->Type), + llvm::to_underlying(Clause->Flags))) + ReportFlagError(Loc); } } diff --git a/llvm/include/llvm/BinaryFormat/DXContainer.h b/llvm/include/llvm/BinaryFormat/DXContainer.h index 54747b46ccc6c..f74c9775cb3f3 100644 --- a/llvm/include/llvm/BinaryFormat/DXContainer.h +++ b/llvm/include/llvm/BinaryFormat/DXContainer.h @@ -209,16 +209,6 @@ inline bool isValidParameterType(uint32_t V) { return false; } -#define DESCRIPTOR_RANGE(Val, Enum) \ - case Val: \ - return true; -inline bool isValidRangeType(uint32_t V) { - switch (V) { -#include "DXContainerConstants.def" - } - return false; -} - #define SHADER_VISIBILITY(Val, Enum) Enum = Val, enum class ShaderVisibility : uint32_t { #include "DXContainerConstants.def" diff --git a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h index acb83e54b92ed..fde32a1fff591 100644 --- a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h +++ b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h @@ -30,8 +30,7 @@ LLVM_ABI bool verifyRegisterValue(uint32_t RegisterValue); LLVM_ABI bool verifyRegisterSpace(uint32_t RegisterSpace); LLVM_ABI bool verifyRootDescriptorFlag(uint32_t Version, uint32_t FlagsVal); LLVM_ABI bool verifyRangeType(uint32_t Type); -LLVM_ABI bool verifyDescriptorRangeFlag(uint32_t Version, - dxbc::DescriptorRangeType Type, +LLVM_ABI bool verifyDescriptorRangeFlag(uint32_t Version, uint32_t Type, uint32_t FlagsVal); LLVM_ABI bool verifyNumDescriptors(uint32_t NumDescriptors); LLVM_ABI bool verifySamplerFilter(uint32_t Value); diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index 28664434f933c..85b45323cee08 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -31,15 +31,6 @@ struct RootDescriptor { uint32_t Flags; }; -struct DescriptorRange { - dxbc::DescriptorRangeType RangeType; - uint32_t NumDescriptors; - uint32_t BaseShaderRegister; - uint32_t RegisterSpace; - uint32_t Flags; - uint32_t OffsetInDescriptorsFromTableStart; -}; - struct RootParameterInfo { dxbc::RootParameterType Type; dxbc::ShaderVisibility Visibility; @@ -51,11 +42,11 @@ struct RootParameterInfo { }; struct DescriptorTable { - SmallVector Ranges; - SmallVector::const_iterator begin() const { + SmallVector Ranges; + SmallVector::const_iterator begin() const { return Ranges.begin(); } - SmallVector::const_iterator end() const { + SmallVector::const_iterator end() const { return Ranges.end(); } }; diff --git a/llvm/lib/BinaryFormat/DXContainer.cpp b/llvm/lib/BinaryFormat/DXContainer.cpp index f79db506962bc..36d10d0b63078 100644 --- a/llvm/lib/BinaryFormat/DXContainer.cpp +++ b/llvm/lib/BinaryFormat/DXContainer.cpp @@ -149,16 +149,6 @@ ArrayRef> dxbc::getRootParameterTypes() { return ArrayRef(RootParameterTypes); } -#define DESCRIPTOR_RANGE(Val, Enum) {#Enum, DescriptorRangeType::Enum}, - -static const EnumEntry DescriptorRangeTypes[] = { -#include "llvm/BinaryFormat/DXContainerConstants.def" -}; - -ArrayRef> dxbc::getDescriptorRangeTypes() { - return ArrayRef(DescriptorRangeTypes); -} - #define SEMANTIC_KIND(Val, Enum) {#Enum, PSV::SemanticKind::Enum}, static const EnumEntry SemanticKindNames[] = { diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index a5e66e73a5dc1..770a6d1638e3c 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -325,7 +325,7 @@ Error MetadataParser::parseDescriptorRange(mcdxbc::DescriptorTable &Table, if (RangeDescriptorNode->getNumOperands() != 6) return make_error("Descriptor Range"); - mcdxbc::DescriptorRange Range; + dxbc::RTS0::v2::DescriptorRange Range; std::optional ElementText = extractMdStringValue(RangeDescriptorNode, 0); @@ -333,11 +333,17 @@ Error MetadataParser::parseDescriptorRange(mcdxbc::DescriptorTable &Table, if (!ElementText.has_value()) return make_error("Descriptor Range"); - Range.RangeType = StringSwitch(*ElementText) - .Case("CBV", dxbc::DescriptorRangeType::CBV) - .Case("SRV", dxbc::DescriptorRangeType::SRV) - .Case("UAV", dxbc::DescriptorRangeType::UAV) - .Case("Sampler", dxbc::DescriptorRangeType::Sampler); + Range.RangeType = + StringSwitch(*ElementText) + .Case("CBV", to_underlying(dxbc::DescriptorRangeType::CBV)) + .Case("SRV", to_underlying(dxbc::DescriptorRangeType::SRV)) + .Case("UAV", to_underlying(dxbc::DescriptorRangeType::UAV)) + .Case("Sampler", to_underlying(dxbc::DescriptorRangeType::Sampler)) + .Default(~0U); + + if (Range.RangeType == ~0U) + return make_error("Invalid Descriptor Range type.", + RangeDescriptorNode); if (std::optional Val = extractMdIntValue(RangeDescriptorNode, 1)) Range.NumDescriptors = *Val; @@ -565,7 +571,12 @@ Error MetadataParser::validateRootSignature( case dxbc::RootParameterType::DescriptorTable: { const mcdxbc::DescriptorTable &Table = RSD.ParametersContainer.getDescriptorTable(Info.Location); - for (const mcdxbc::DescriptorRange &Range : Table) { + for (const dxbc::RTS0::v2::DescriptorRange &Range : Table) { + if (!hlsl::rootsig::verifyRangeType(Range.RangeType)) + DeferredErrs = + joinErrors(std::move(DeferredErrs), + make_error>( + "RangeType", Range.RangeType)); if (!hlsl::rootsig::verifyRegisterSpace(Range.RegisterSpace)) DeferredErrs = diff --git a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp index 5dbeede778b04..72308a3de5fd4 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp @@ -63,12 +63,13 @@ bool verifyRangeType(uint32_t Type) { return false; } -bool verifyDescriptorRangeFlag(uint32_t Version, dxbc::DescriptorRangeType Type, +bool verifyDescriptorRangeFlag(uint32_t Version, uint32_t Type, uint32_t FlagsVal) { using FlagT = dxbc::DescriptorRangeFlags; FlagT Flags = FlagT(FlagsVal); - const bool IsSampler = (Type == dxbc::DescriptorRangeType::Sampler); + const bool IsSampler = + (Type == llvm::to_underlying(dxbc::DescriptorRangeType::Sampler)); if (Version == 1) { // Since the metadata is unversioned, we expect to explicitly see the values diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index a749f47792453..a51821e196cb8 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -315,10 +315,9 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { P.RootSignature->Parameters.getOrInsertTable(L); mcdxbc::DescriptorTable Table; for (const auto &R : TableYaml.Ranges) { - assert(dxbc::isValidRangeType(R.RangeType) && - "Invalid Descriptor Range Type"); - mcdxbc::DescriptorRange Range; - Range.RangeType = dxbc::DescriptorRangeType(R.RangeType); + + dxbc::RTS0::v2::DescriptorRange Range; + Range.RangeType = R.RangeType; Range.NumDescriptors = R.NumDescriptors; Range.BaseShaderRegister = R.BaseShaderRegister; Range.RegisterSpace = R.RegisterSpace; diff --git a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp index c6f79621c39de..5557443a3db93 100644 --- a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp +++ b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp @@ -194,7 +194,7 @@ static void validateRootSignature(Module &M, const mcdxbc::DescriptorTable &Table = RSD.ParametersContainer.getDescriptorTable(ParamInfo.Location); - for (const mcdxbc::DescriptorRange &Range : Table.Ranges) { + for (const dxbc::RTS0::v2::DescriptorRange &Range : Table.Ranges) { uint32_t UpperBound = Range.NumDescriptors == ~0U ? Range.BaseShaderRegister diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp index 296e11f3ad5e9..b05b8ee699ef6 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp +++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp @@ -205,11 +205,8 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M, RS.ParametersContainer.getDescriptorTable(Loc); OS << " NumRanges: " << Table.Ranges.size() << "\n"; - for (const mcdxbc::DescriptorRange Range : Table) { - OS << " - Range Type: " - << enumToStringRef(Range.RangeType, - dxbc::getDescriptorRangeTypes()) - << "\n" + for (const dxbc::RTS0::v2::DescriptorRange Range : Table) { + OS << " - Range Type: " << Range.RangeType << "\n" << " Register Space: " << Range.RegisterSpace << "\n" << " Base Shader Register: " << Range.BaseShaderRegister << "\n" << " Num Descriptors: " << Range.NumDescriptors << "\n" diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-Invalid-RangeType.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-Invalid-RangeType.ll new file mode 100644 index 0000000000000..4a65a53f9f727 --- /dev/null +++ b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-Invalid-RangeType.ll @@ -0,0 +1,20 @@ +; RUN: not opt -passes='print' %s -S -o - 2>&1 | FileCheck %s + +target triple = "dxil-unknown-shadermodel6.0-compute" + +; CHECK: error: Invalid Descriptor Range type +; CHECK-NOT: Root Signature Definitions + +define void @main() #0 { +entry: + ret void +} +attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } + + +!dx.rootsignatures = !{!2} ; list of function/root signature pairs +!2 = !{ ptr @main, !3, i32 2 } ; function, root signature +!3 = !{ !5 } ; list of root signature elements +!5 = !{ !"DescriptorTable", i32 0, !6, !7 } +!6 = !{ !"Invalid", i32 1, i32 0, i32 -1, i32 -1, i32 4 } +!7 = !{ !"UAV", i32 5, i32 1, i32 10, i32 5, i32 2 } diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll index 6c6739d6ed390..742fea14f5af6 100644 --- a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll +++ b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll @@ -38,13 +38,13 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } ;CHECK-NEXT: - Parameter Type: DescriptorTable ;CHECK-NEXT: Shader Visibility: All ;CHECK-NEXT: NumRanges: 2 -;CHECK-NEXT: - Range Type: SRV +;CHECK-NEXT: - Range Type: 0 ;CHECK-NEXT: Register Space: 0 ;CHECK-NEXT: Base Shader Register: 1 ;CHECK-NEXT: Num Descriptors: 1 ;CHECK-NEXT: Offset In Descriptors From Table Start: 4294967295 ;CHECK-NEXT: Flags: 4 -;CHECK-NEXT: - Range Type: UAV +;CHECK-NEXT: - Range Type: 1 ;CHECK-NEXT: Register Space: 10 ;CHECK-NEXT: Base Shader Register: 1 ;CHECK-NEXT: Num Descriptors: 5 From 4b9991d7df65ec18ce66ece53ad420b528a363da Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Wed, 20 Aug 2025 18:56:53 -0700 Subject: [PATCH 17/29] updating object to yaml to account for enums --- .../include/llvm/ObjectYAML/DXContainerYAML.h | 22 ++++--- llvm/lib/ObjectYAML/DXContainerYAML.cpp | 57 ++++++++++++++----- 2 files changed, 52 insertions(+), 27 deletions(-) diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h index 7e0a4c6b07039..70a1a3e096574 100644 --- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h +++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h @@ -92,7 +92,7 @@ struct RootDescriptorYaml { }; struct DescriptorRangeYaml { - uint32_t RangeType; + dxbc::DescriptorRangeType RangeType; uint32_t NumDescriptors; uint32_t BaseShaderRegister; uint32_t RegisterSpace; @@ -111,12 +111,12 @@ struct DescriptorTableYaml { }; struct RootParameterHeaderYaml { - uint32_t Type; - uint32_t Visibility; + dxbc::RootParameterType Type; + dxbc::ShaderVisibility Visibility; uint32_t Offset; RootParameterHeaderYaml(){}; - RootParameterHeaderYaml(uint32_t T) : Type(T) {} + RootParameterHeaderYaml(dxbc::RootParameterType T) : Type(T) {} }; struct RootParameterLocationYaml { @@ -165,16 +165,14 @@ struct RootParameterYamlDesc { }; struct StaticSamplerYamlDesc { - uint32_t Filter = llvm::to_underlying(dxbc::SamplerFilter::Anisotropic); - uint32_t AddressU = llvm::to_underlying(dxbc::TextureAddressMode::Wrap); - uint32_t AddressV = llvm::to_underlying(dxbc::TextureAddressMode::Wrap); - uint32_t AddressW = llvm::to_underlying(dxbc::TextureAddressMode::Wrap); + dxbc::SamplerFilter Filter = dxbc::SamplerFilter::Anisotropic; + dxbc::TextureAddressMode AddressU = dxbc::TextureAddressMode::Wrap; + dxbc::TextureAddressMode AddressV = dxbc::TextureAddressMode::Wrap; + dxbc::TextureAddressMode AddressW = dxbc::TextureAddressMode::Wrap; float MipLODBias = 0.f; uint32_t MaxAnisotropy = 16u; - uint32_t ComparisonFunc = - llvm::to_underlying(dxbc::ComparisonFunc::LessEqual); - uint32_t BorderColor = - llvm::to_underlying(dxbc::StaticBorderColor::OpaqueWhite); + dxbc::ComparisonFunc ComparisonFunc = dxbc::ComparisonFunc::LessEqual; + dxbc::StaticBorderColor BorderColor = dxbc::StaticBorderColor::OpaqueWhite; float MinLOD = 0.f; float MaxLOD = std::numeric_limits::max(); uint32_t ShaderRegister; diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index 263f7bdf37bca..e6564ad3ff28b 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -60,7 +60,10 @@ readDescriptorRanges(DXContainerYAML::RootParameterHeaderYaml &Header, NewR.NumDescriptors = R.NumDescriptors; NewR.BaseShaderRegister = R.BaseShaderRegister; NewR.RegisterSpace = R.RegisterSpace; - NewR.RangeType = R.RangeType; + if (!dxbc::isValidRangeType(R.RangeType)) + return createStringError(std::errc::invalid_argument, + "Invalid value for descriptor range type"); + NewR.RangeType = dxbc::DescriptorRangeType(R.RangeType); if constexpr (std::is_same_v) { // Set all flag fields for v2 #define DESCRIPTOR_RANGE_FLAG(Num, Enum, Flag) \ @@ -94,15 +97,14 @@ DXContainerYAML::RootSignatureYamlDesc::create( return createStringError(std::errc::invalid_argument, "Invalid value for parameter type"); - RootParameterHeaderYaml Header(PH.ParameterType); + RootParameterHeaderYaml Header(dxbc::RootParameterType(PH.ParameterType)); Header.Offset = PH.ParameterOffset; - Header.Type = PH.ParameterType; if (!dxbc::isValidShaderVisibility(PH.ShaderVisibility)) return createStringError(std::errc::invalid_argument, "Invalid value for shader visibility"); - Header.Visibility = PH.ShaderVisibility; + Header.Visibility = dxbc::ShaderVisibility(PH.ShaderVisibility); llvm::Expected ParamViewOrErr = Data.getParameter(PH); @@ -162,15 +164,40 @@ DXContainerYAML::RootSignatureYamlDesc::create( } for (const auto &S : Data.samplers()) { + if (!dxbc::isValidSamplerFilter(S.Filter)) + return createStringError(std::errc::invalid_argument, + "Invalid value for static sampler filter"); + + if (!dxbc::isValidAddress(S.AddressU)) + return createStringError(std::errc::invalid_argument, + "Invalid value for static sampler AddressU"); + + if (!dxbc::isValidAddress(S.AddressV)) + return createStringError(std::errc::invalid_argument, + "Invalid value for static sampler AddressV"); + + if (!dxbc::isValidAddress(S.AddressW)) + return createStringError(std::errc::invalid_argument, + "Invalid value for static sampler AddressW"); + + if (!dxbc::isValidComparisonFunc(S.ComparisonFunc)) + return createStringError( + std::errc::invalid_argument, + "Invalid value for static sampler ComparisonFunc"); + + if (!dxbc::isValidBorderColor(S.BorderColor)) + return createStringError(std::errc::invalid_argument, + "Invalid value for static sampler BorderColor"); + StaticSamplerYamlDesc NewS; - NewS.Filter = S.Filter; - NewS.AddressU = S.AddressU; - NewS.AddressV = S.AddressV; - NewS.AddressW = S.AddressW; + NewS.Filter = dxbc::SamplerFilter(S.Filter); + NewS.AddressU = dxbc::TextureAddressMode(S.AddressU); + NewS.AddressV = dxbc::TextureAddressMode(S.AddressV); + NewS.AddressW = dxbc::TextureAddressMode(S.AddressW); NewS.MipLODBias = S.MipLODBias; NewS.MaxAnisotropy = S.MaxAnisotropy; - NewS.ComparisonFunc = S.ComparisonFunc; - NewS.BorderColor = S.BorderColor; + NewS.ComparisonFunc = dxbc::ComparisonFunc(S.ComparisonFunc); + NewS.BorderColor = dxbc::StaticBorderColor(S.BorderColor); NewS.MinLOD = S.MinLOD; NewS.MaxLOD = S.MaxLOD; NewS.ShaderRegister = S.ShaderRegister; @@ -425,21 +452,21 @@ void MappingContextTraits Date: Thu, 21 Aug 2025 12:17:04 -0700 Subject: [PATCH 18/29] updating tests --- .../include/llvm/ObjectYAML/DXContainerYAML.h | 9 +++- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 15 ------ llvm/lib/ObjectYAML/DXContainerYAML.cpp | 49 ++++++++++++++++++- ...escriptorTable-AllValidFlagCombinations.ll | 32 ++++++------ ...criptorTable-AllValidFlagCombinationsV1.ll | 8 +-- .../RootSignature-DescriptorTable.ll | 12 ++--- .../RootSignature-RootConstants.ll | 8 +-- .../RootSignature-RootDescriptor.ll | 8 +-- .../RootSignature-RootDescriptor_V1.ll | 8 +-- .../RootSignature-StaticSamplers.ll | 14 +++--- .../RootSignature-Descriptor1.0.yaml | 8 +-- .../RootSignature-Descriptor1.1.yaml | 8 +-- .../RootSignature-DescriptorTable1.0.yaml | 12 ++--- .../RootSignature-DescriptorTable1.1.yaml | 12 ++--- .../RootSignature-MultipleParameters.yaml | 36 +++++++------- ...RootSignature-StaticSamplers-Defaults.yaml | 16 +++--- .../RootSignature-StaticSamplers.yaml | 28 +++++------ .../ObjectYAML/DXContainerYAMLTest.cpp | 42 ++++++++-------- 18 files changed, 182 insertions(+), 143 deletions(-) diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h index 70a1a3e096574..add9937717e25 100644 --- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h +++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h @@ -177,7 +177,7 @@ struct StaticSamplerYamlDesc { float MaxLOD = std::numeric_limits::max(); uint32_t ShaderRegister; uint32_t RegisterSpace; - uint32_t ShaderVisibility; + dxbc::ShaderVisibility ShaderVisibility; }; struct RootSignatureYamlDesc { @@ -319,6 +319,13 @@ LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::PSV::ResourceKind) LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::D3DSystemValue) LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::SigComponentType) LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::SigMinPrecision) +LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::RootParameterType) +LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::DescriptorRangeType) +LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::SamplerFilter) +LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::StaticBorderColor) +LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::TextureAddressMode) +LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::ShaderVisibility) +LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::ComparisonFunc) namespace llvm { diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index 5a479461b8714..28a21e762c616 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -276,10 +276,6 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { for (DXContainerYAML::RootParameterLocationYaml &L : P.RootSignature->Parameters.Locations) { - assert(dxbc::isValidParameterType(L.Header.Type) && - "invalid DXContainer YAML"); - assert(dxbc::isValidShaderVisibility(L.Header.Visibility) && - "invalid DXContainer YAML"); dxbc::RootParameterType Type = dxbc::RootParameterType(L.Header.Type); dxbc::ShaderVisibility Visibility = dxbc::ShaderVisibility(L.Header.Visibility); @@ -315,8 +311,6 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { P.RootSignature->Parameters.getOrInsertTable(L); mcdxbc::DescriptorTable Table; for (const auto &R : TableYaml.Ranges) { - assert(dxbc::isValidRangeType(R.RangeType) && - "Invalid Descriptor Range Type"); mcdxbc::DescriptorRange Range; Range.RangeType = dxbc::DescriptorRangeType(R.RangeType); Range.NumDescriptors = R.NumDescriptors; @@ -335,15 +329,6 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { } for (const auto &Param : P.RootSignature->samplers()) { - assert(dxbc::isValidSamplerFilter(Param.Filter) && - dxbc::isValidAddress(Param.AddressU) && - dxbc::isValidAddress(Param.AddressV) && - dxbc::isValidAddress(Param.AddressW) && - dxbc::isValidComparisonFunc(Param.ComparisonFunc) && - dxbc::isValidBorderColor(Param.BorderColor) && - dxbc::isValidShaderVisibility(Param.ShaderVisibility) && - "Invalid enum value in static sampler"); - mcdxbc::StaticSampler NewSampler; NewSampler.Filter = dxbc::SamplerFilter(Param.Filter); NewSampler.AddressU = dxbc::TextureAddressMode(Param.AddressU); diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index e6564ad3ff28b..e703e34320044 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -189,6 +189,11 @@ DXContainerYAML::RootSignatureYamlDesc::create( return createStringError(std::errc::invalid_argument, "Invalid value for static sampler BorderColor"); + if (!dxbc::isValidShaderVisibility(S.ShaderVisibility)) + return createStringError( + std::errc::invalid_argument, + "Invalid value for static sampler ShaderVisibility"); + StaticSamplerYamlDesc NewS; NewS.Filter = dxbc::SamplerFilter(S.Filter); NewS.AddressU = dxbc::TextureAddressMode(S.AddressU); @@ -202,7 +207,7 @@ DXContainerYAML::RootSignatureYamlDesc::create( NewS.MaxLOD = S.MaxLOD; NewS.ShaderRegister = S.ShaderRegister; NewS.RegisterSpace = S.RegisterSpace; - NewS.ShaderVisibility = S.ShaderVisibility; + NewS.ShaderVisibility = dxbc::ShaderVisibility(S.ShaderVisibility); RootSigDesc.StaticSamplers.push_back(NewS); } @@ -612,6 +617,48 @@ void ScalarEnumerationTraits::enumeration( IO.enumCase(Value, E.Name.str().c_str(), E.Value); } +void ScalarEnumerationTraits::enumeration( + IO &IO, dxbc::RootParameterType &Value) { + for (const auto &E : dxbc::getRootParameterTypes()) + IO.enumCase(Value, E.Name.str().c_str(), E.Value); +} + +void ScalarEnumerationTraits::enumeration( + IO &IO, dxbc::DescriptorRangeType &Value) { + for (const auto &E : dxbc::getDescriptorRangeTypes()) + IO.enumCase(Value, E.Name.str().c_str(), E.Value); +} + +void ScalarEnumerationTraits::enumeration( + IO &IO, dxbc::SamplerFilter &Value) { + for (const auto &E : dxbc::getSamplerFilters()) + IO.enumCase(Value, E.Name.str().c_str(), E.Value); +} + +void ScalarEnumerationTraits::enumeration( + IO &IO, dxbc::StaticBorderColor &Value) { + for (const auto &E : dxbc::getStaticBorderColors()) + IO.enumCase(Value, E.Name.str().c_str(), E.Value); +} + +void ScalarEnumerationTraits::enumeration( + IO &IO, dxbc::TextureAddressMode &Value) { + for (const auto &E : dxbc::getTextureAddressModes()) + IO.enumCase(Value, E.Name.str().c_str(), E.Value); +} + +void ScalarEnumerationTraits::enumeration( + IO &IO, dxbc::ShaderVisibility &Value) { + for (const auto &E : dxbc::getShaderVisibility()) + IO.enumCase(Value, E.Name.str().c_str(), E.Value); +} + +void ScalarEnumerationTraits::enumeration( + IO &IO, dxbc::ComparisonFunc &Value) { + for (const auto &E : dxbc::getComparisonFuncs()) + IO.enumCase(Value, E.Name.str().c_str(), E.Value); +} + } // namespace yaml void DXContainerYAML::PSVInfo::mapInfoForVersion(yaml::IO &IO) { diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-AllValidFlagCombinations.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-AllValidFlagCombinations.ll index 8eb7f90c6b757..09bab575bac5b 100644 --- a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-AllValidFlagCombinations.ll +++ b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-AllValidFlagCombinations.ll @@ -61,94 +61,94 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } ;DXC-NEXT: NumStaticSamplers: 0 ;DXC-NEXT: StaticSamplersOffset: 0 ;DXC-NEXT: Parameters: -;DXC-NEXT: - ParameterType: 0 -;DXC-NEXT: ShaderVisibility: 0 +;DXC-NEXT: - ParameterType: DescriptorTable +;DXC-NEXT: ShaderVisibility: All ;DXC-NEXT: Table: ;DXC-NEXT: NumRanges: 14 ;DXC-NEXT: RangesOffset: 44 ;DXC-NEXT: Ranges: -;DXC-NEXT: - RangeType: 3 +;DXC-NEXT: - RangeType: Sampler ;DXC-NEXT: NumDescriptors: 1 ;DXC-NEXT: BaseShaderRegister: 0 ;DXC-NEXT: RegisterSpace: 1 ;DXC-NEXT: OffsetInDescriptorsFromTableStart: 4294967295 -;DXC-NEXT: - RangeType: 3 +;DXC-NEXT: - RangeType: Sampler ;DXC-NEXT: NumDescriptors: 1 ;DXC-NEXT: BaseShaderRegister: 0 ;DXC-NEXT: RegisterSpace: 3 ;DXC-NEXT: OffsetInDescriptorsFromTableStart: 4294967295 ;DXC-NEXT: DESCRIPTORS_VOLATILE: true -;DXC-NEXT: - RangeType: 3 +;DXC-NEXT: - RangeType: Sampler ;DXC-NEXT: NumDescriptors: 1 ;DXC-NEXT: BaseShaderRegister: 0 ;DXC-NEXT: RegisterSpace: 4 ;DXC-NEXT: OffsetInDescriptorsFromTableStart: 4294967295 ;DXC-NEXT: DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS: true -;DXC-NEXT: - RangeType: 0 +;DXC-NEXT: - RangeType: SRV ;DXC-NEXT: NumDescriptors: 1 ;DXC-NEXT: BaseShaderRegister: 0 ;DXC-NEXT: RegisterSpace: 5 ;DXC-NEXT: OffsetInDescriptorsFromTableStart: 4294967295 ;DXC-NEXT: DESCRIPTORS_VOLATILE: true -;DXC-NEXT: - RangeType: 1 +;DXC-NEXT: - RangeType: UAV ;DXC-NEXT: NumDescriptors: 5 ;DXC-NEXT: BaseShaderRegister: 1 ;DXC-NEXT: RegisterSpace: 6 ;DXC-NEXT: OffsetInDescriptorsFromTableStart: 5 ;DXC-NEXT: DESCRIPTORS_VOLATILE: true -;DXC-NEXT: - RangeType: 2 +;DXC-NEXT: - RangeType: CBV ;DXC-NEXT: NumDescriptors: 5 ;DXC-NEXT: BaseShaderRegister: 1 ;DXC-NEXT: RegisterSpace: 7 ;DXC-NEXT: OffsetInDescriptorsFromTableStart: 5 ;DXC-NEXT: DATA_VOLATILE: true -;DXC-NEXT: - RangeType: 0 +;DXC-NEXT: - RangeType: SRV ;DXC-NEXT: NumDescriptors: 5 ;DXC-NEXT: BaseShaderRegister: 1 ;DXC-NEXT: RegisterSpace: 8 ;DXC-NEXT: OffsetInDescriptorsFromTableStart: 5 ;DXC-NEXT: DATA_STATIC: true -;DXC-NEXT: - RangeType: 1 +;DXC-NEXT: - RangeType: UAV ;DXC-NEXT: NumDescriptors: 5 ;DXC-NEXT: BaseShaderRegister: 1 ;DXC-NEXT: RegisterSpace: 9 ;DXC-NEXT: OffsetInDescriptorsFromTableStart: 5 ;DXC-NEXT: DATA_STATIC_WHILE_SET_AT_EXECUTE: true -;DXC-NEXT: - RangeType: 2 +;DXC-NEXT: - RangeType: CBV ;DXC-NEXT: NumDescriptors: 5 ;DXC-NEXT: BaseShaderRegister: 1 ;DXC-NEXT: RegisterSpace: 10 ;DXC-NEXT: OffsetInDescriptorsFromTableStart: 5 ;DXC-NEXT: DESCRIPTORS_VOLATILE: true ;DXC-NEXT: DATA_VOLATILE: true -;DXC-NEXT: - RangeType: 0 +;DXC-NEXT: - RangeType: SRV ;DXC-NEXT: NumDescriptors: 5 ;DXC-NEXT: BaseShaderRegister: 1 ;DXC-NEXT: RegisterSpace: 11 ;DXC-NEXT: OffsetInDescriptorsFromTableStart: 5 ;DXC-NEXT: DESCRIPTORS_VOLATILE: true ;DXC-NEXT: DATA_STATIC_WHILE_SET_AT_EXECUTE: true -;DXC-NEXT: - RangeType: 1 +;DXC-NEXT: - RangeType: UAV ;DXC-NEXT: NumDescriptors: 5 ;DXC-NEXT: BaseShaderRegister: 1 ;DXC-NEXT: RegisterSpace: 12 ;DXC-NEXT: OffsetInDescriptorsFromTableStart: 5 ;DXC-NEXT: DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS: true -;DXC-NEXT: - RangeType: 2 +;DXC-NEXT: - RangeType: CBV ;DXC-NEXT: NumDescriptors: 5 ;DXC-NEXT: BaseShaderRegister: 1 ;DXC-NEXT: RegisterSpace: 13 ;DXC-NEXT: OffsetInDescriptorsFromTableStart: 5 ;DXC-NEXT: DATA_VOLATILE: true ;DXC-NEXT: DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS: true -;DXC-NEXT: - RangeType: 0 +;DXC-NEXT: - RangeType: SRV ;DXC-NEXT: NumDescriptors: 5 ;DXC-NEXT: BaseShaderRegister: 1 ;DXC-NEXT: RegisterSpace: 14 ;DXC-NEXT: OffsetInDescriptorsFromTableStart: 5 ;DXC-NEXT: DATA_STATIC: true ;DXC-NEXT: DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS: true -;DXC-NEXT: - RangeType: 1 +;DXC-NEXT: - RangeType: UAV ;DXC-NEXT: NumDescriptors: 5 ;DXC-NEXT: BaseShaderRegister: 1 ;DXC-NEXT: RegisterSpace: 15 diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-AllValidFlagCombinationsV1.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-AllValidFlagCombinationsV1.ll index 053721de1eb1f..bb8a95fb52ce8 100644 --- a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-AllValidFlagCombinationsV1.ll +++ b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-AllValidFlagCombinationsV1.ll @@ -26,18 +26,18 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } ; DXC-NEXT: NumStaticSamplers: 0 ; DXC-NEXT: StaticSamplersOffset: 0 ; DXC-NEXT: Parameters: -; DXC-NEXT: - ParameterType: 0 -; DXC-NEXT: ShaderVisibility: 0 +; DXC-NEXT: - ParameterType: DescriptorTable +; DXC-NEXT: ShaderVisibility: All ; DXC-NEXT: Table: ; DXC-NEXT: NumRanges: 2 ; DXC-NEXT: RangesOffset: 44 ; DXC-NEXT: Ranges: -; DXC-NEXT: - RangeType: 3 +; DXC-NEXT: - RangeType: Sampler ; DXC-NEXT: NumDescriptors: 1 ; DXC-NEXT: BaseShaderRegister: 1 ; DXC-NEXT: RegisterSpace: 0 ; DXC-NEXT: OffsetInDescriptorsFromTableStart: 4294967295 -; DXC-NEXT: - RangeType: 1 +; DXC-NEXT: - RangeType: UAV ; DXC-NEXT: NumDescriptors: 5 ; DXC-NEXT: BaseShaderRegister: 1 ; DXC-NEXT: RegisterSpace: 10 diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable.ll index 8e9b4b43b11a6..cbd4e4f7276da 100644 --- a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable.ll +++ b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable.ll @@ -23,24 +23,24 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } ; DXC-NEXT: Size: 92 ; DXC-NEXT: RootSignature: ; DXC-NEXT: Version: 2 -; DXC-NEXT: NumRootParameters: 1 -; DXC-NEXT: RootParametersOffset: 24 +; DXC-NEXT: NumRootParameters: 1 +; DXC-NEXT: RootParametersOffset: 24 ; DXC-NEXT: NumStaticSamplers: 0 ; DXC-NEXT: StaticSamplersOffset: 0 ; DXC-NEXT: Parameters: -; DXC-NEXT: - ParameterType: 0 -; DXC-NEXT: ShaderVisibility: 0 +; DXC-NEXT: - ParameterType: DescriptorTable +; DXC-NEXT: ShaderVisibility: All ; DXC-NEXT: Table: ; DXC-NEXT: NumRanges: 2 ; DXC-NEXT: RangesOffset: 44 ; DXC-NEXT: Ranges: -; DXC-NEXT: - RangeType: 0 +; DXC-NEXT: - RangeType: SRV ; DXC-NEXT: NumDescriptors: 1 ; DXC-NEXT: BaseShaderRegister: 1 ; DXC-NEXT: RegisterSpace: 0 ; DXC-NEXT: OffsetInDescriptorsFromTableStart: 4294967295 ; DXC-NEXT: DATA_STATIC_WHILE_SET_AT_EXECUTE: true -; DXC-NEXT: - RangeType: 1 +; DXC-NEXT: - RangeType: UAV ; DXC-NEXT: NumDescriptors: 5 ; DXC-NEXT: BaseShaderRegister: 1 ; DXC-NEXT: RegisterSpace: 10 diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-RootConstants.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-RootConstants.ll index 964554fe143ef..0980ee04f1a5c 100644 --- a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-RootConstants.ll +++ b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-RootConstants.ll @@ -21,13 +21,13 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } ; DXC-NEXT: Size: 48 ; DXC-NEXT: RootSignature: ; DXC-NEXT: Version: 2 -; DXC-NEXT: NumRootParameters: 1 -; DXC-NEXT: RootParametersOffset: 24 +; DXC-NEXT: NumRootParameters: 1 +; DXC-NEXT: RootParametersOffset: 24 ; DXC-NEXT: NumStaticSamplers: 0 ; DXC-NEXT: StaticSamplersOffset: 0 ; DXC-NEXT: Parameters: -; DXC-NEXT: - ParameterType: 1 -; DXC-NEXT: ShaderVisibility: 0 +; DXC-NEXT: - ParameterType: Constants32Bit +; DXC-NEXT: ShaderVisibility: All ; DXC-NEXT: Constants: ; DXC-NEXT: Num32BitValues: 3 ; DXC-NEXT: RegisterSpace: 2 diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-RootDescriptor.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-RootDescriptor.ll index f77bb96840bea..734eddb5edfe8 100644 --- a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-RootDescriptor.ll +++ b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-RootDescriptor.ll @@ -21,13 +21,13 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } ; DXC-NEXT: Size: 48 ; DXC-NEXT: RootSignature: ; DXC-NEXT: Version: 2 -; DXC-NEXT: NumRootParameters: 1 -; DXC-NEXT: RootParametersOffset: 24 +; DXC-NEXT: NumRootParameters: 1 +; DXC-NEXT: RootParametersOffset: 24 ; DXC-NEXT: NumStaticSamplers: 0 ; DXC-NEXT: StaticSamplersOffset: 0 ; DXC-NEXT: Parameters: -; DXC-NEXT: - ParameterType: 2 -; DXC-NEXT: ShaderVisibility: 0 +; DXC-NEXT: - ParameterType: CBV +; DXC-NEXT: ShaderVisibility: All ; DXC-NEXT: Descriptor: ; DXC-NEXT: RegisterSpace: 2 ; DXC-NEXT: ShaderRegister: 1 diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-RootDescriptor_V1.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-RootDescriptor_V1.ll index ddf556e7fe20a..922d9d3155e2a 100644 --- a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-RootDescriptor_V1.ll +++ b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-RootDescriptor_V1.ll @@ -21,13 +21,13 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } ; DXC-NEXT: Size: 44 ; DXC-NEXT: RootSignature: ; DXC-NEXT: Version: 1 -; DXC-NEXT: NumRootParameters: 1 -; DXC-NEXT: RootParametersOffset: 24 +; DXC-NEXT: NumRootParameters: 1 +; DXC-NEXT: RootParametersOffset: 24 ; DXC-NEXT: NumStaticSamplers: 0 ; DXC-NEXT: StaticSamplersOffset: 0 ; DXC-NEXT: Parameters: -; DXC-NEXT: - ParameterType: 2 -; DXC-NEXT: ShaderVisibility: 0 +; DXC-NEXT: - ParameterType: CBV +; DXC-NEXT: ShaderVisibility: All ; DXC-NEXT: Descriptor: ; DXC-NEXT: RegisterSpace: 2 ; DXC-NEXT: ShaderRegister: 1 diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-StaticSamplers.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-StaticSamplers.ll index d9ee39dbb7287..1dd470d7fb822 100644 --- a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-StaticSamplers.ll +++ b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-StaticSamplers.ll @@ -27,16 +27,16 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } ; DXC-NEXT: StaticSamplersOffset: 24 ; DXC-NEXT: Parameters: [] ; DXC-NEXT: Samplers: -; DXC-NEXT: - Filter: 4 -; DXC-NEXT: AddressU: 2 -; DXC-NEXT: AddressV: 3 -; DXC-NEXT: AddressW: 5 +; DXC-NEXT: - Filter: MinPointMagLinearMipPoint +; DXC-NEXT: AddressU: Mirror +; DXC-NEXT: AddressV: Clamp +; DXC-NEXT: AddressW: MirrorOnce ; DXC-NEXT: MipLODBias: 1.425 ; DXC-NEXT: MaxAnisotropy: 9 -; DXC-NEXT: ComparisonFunc: 3 -; DXC-NEXT: BorderColor: 2 +; DXC-NEXT: ComparisonFunc: Equal +; DXC-NEXT: BorderColor: OpaqueWhite ; DXC-NEXT: MinLOD: -128 ; DXC-NEXT: MaxLOD: 128 ; DXC-NEXT: ShaderRegister: 42 ; DXC-NEXT: RegisterSpace: 0 -; DXC-NEXT: ShaderVisibility: 0 +; DXC-NEXT: ShaderVisibility: All diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.0.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.0.yaml index 889eccf74001f..8d48420916ca6 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.0.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.0.yaml @@ -19,8 +19,8 @@ Parts: NumStaticSamplers: 0 StaticSamplersOffset: 60 Parameters: - - ParameterType: 2 # SRV - ShaderVisibility: 3 # Domain + - ParameterType: CBV + ShaderVisibility: Domain Descriptor: ShaderRegister: 31 RegisterSpace: 32 @@ -36,8 +36,8 @@ Parts: # CHECK-NEXT: NumStaticSamplers: 0 # CHECK-NEXT: StaticSamplersOffset: 60 # CHECK-NEXT: Parameters: -# CHECK-NEXT: - ParameterType: 2 -# CHECK-NEXT: ShaderVisibility: 3 +# CHECK-NEXT: - ParameterType: CBV +# CHECK-NEXT: ShaderVisibility: Domain # CHECK-NEXT: Descriptor: # CHECK-NEXT: RegisterSpace: 32 # CHECK-NEXT: ShaderRegister: 31 diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.1.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.1.yaml index 64e01c6836e32..7ad9c6cc8b20d 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.1.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.1.yaml @@ -19,8 +19,8 @@ Parts: NumStaticSamplers: 0 StaticSamplersOffset: 60 Parameters: - - ParameterType: 2 # SRV - ShaderVisibility: 3 # Domain + - ParameterType: CBV + ShaderVisibility: Domain Descriptor: ShaderRegister: 31 RegisterSpace: 32 @@ -37,8 +37,8 @@ Parts: # CHECK-NEXT: NumStaticSamplers: 0 # CHECK-NEXT: StaticSamplersOffset: 60 # CHECK-NEXT: Parameters: -# CHECK-NEXT: - ParameterType: 2 -# CHECK-NEXT: ShaderVisibility: 3 +# CHECK-NEXT: - ParameterType: CBV +# CHECK-NEXT: ShaderVisibility: Domain # CHECK-NEXT: Descriptor: # CHECK-NEXT: RegisterSpace: 32 # CHECK-NEXT: ShaderRegister: 31 diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.0.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.0.yaml index 0441bb7a256b1..93c2c0eff979c 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.0.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.0.yaml @@ -20,12 +20,12 @@ Parts: NumStaticSamplers: 0 StaticSamplersOffset: 60 Parameters: - - ParameterType: 0 # SRV - ShaderVisibility: 3 # Domain + - ParameterType: DescriptorTable + ShaderVisibility: Domain Table: NumRanges: 1 Ranges: - - RangeType: 0 + - RangeType: SRV NumDescriptors: -1 BaseShaderRegister: 42 RegisterSpace: 43 @@ -42,13 +42,13 @@ Parts: # CHECK-NEXT: NumStaticSamplers: 0 # CHECK-NEXT: StaticSamplersOffset: 60 # CHECK-NEXT: Parameters: -# CHECK-NEXT: - ParameterType: 0 -# CHECK-NEXT: ShaderVisibility: 3 +# CHECK-NEXT: - ParameterType: DescriptorTable +# CHECK-NEXT: ShaderVisibility: Domain # CHECK-NEXT: Table: # CHECK-NEXT: NumRanges: 1 # CHECK-NEXT: RangesOffset: 44 # CHECK-NEXT: Ranges: -# CHECK-NEXT: - RangeType: 0 +# CHECK-NEXT: - RangeType: SRV # CHECK-NEXT: NumDescriptors: -1 # CHECK-NEXT: BaseShaderRegister: 42 # CHECK-NEXT: RegisterSpace: 43 diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.1.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.1.yaml index d06be5e181418..4e6fa23438579 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.1.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.1.yaml @@ -20,12 +20,12 @@ Parts: NumStaticSamplers: 0 StaticSamplersOffset: 60 Parameters: - - ParameterType: 0 # SRV - ShaderVisibility: 3 # Domain + - ParameterType: DescriptorTable + ShaderVisibility: Domain Table: NumRanges: 1 Ranges: - - RangeType: 0 + - RangeType: SRV NumDescriptors: -1 BaseShaderRegister: 42 RegisterSpace: 43 @@ -43,13 +43,13 @@ Parts: # CHECK-NEXT: NumStaticSamplers: 0 # CHECK-NEXT: StaticSamplersOffset: 60 # CHECK-NEXT: Parameters: -# CHECK-NEXT: - ParameterType: 0 -# CHECK-NEXT: ShaderVisibility: 3 +# CHECK-NEXT: - ParameterType: DescriptorTable +# CHECK-NEXT: ShaderVisibility: Domain # CHECK-NEXT: Table: # CHECK-NEXT: NumRanges: 1 # CHECK-NEXT: RangesOffset: 44 # CHECK-NEXT: Ranges: -# CHECK-NEXT: - RangeType: 0 +# CHECK-NEXT: - RangeType: SRV # CHECK-NEXT: NumDescriptors: -1 # CHECK-NEXT: BaseShaderRegister: 42 # CHECK-NEXT: RegisterSpace: 43 diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml index 947fc096a9207..cf09ff79e8564 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml @@ -19,30 +19,30 @@ Parts: NumStaticSamplers: 0 StaticSamplersOffset: 60 Parameters: - - ParameterType: 1 # Constants32Bit - ShaderVisibility: 2 # Hull + - ParameterType: Constants32Bit + ShaderVisibility: Hull Constants: Num32BitValues: 16 ShaderRegister: 15 RegisterSpace: 14 - - ParameterType: 1 # Constants32Bit - ShaderVisibility: 4 # Geometry + - ParameterType: Constants32Bit + ShaderVisibility: Geometry Constants: Num32BitValues: 21 ShaderRegister: 22 RegisterSpace: 23 - - ParameterType: 2 # SRV - ShaderVisibility: 3 # Domain + - ParameterType: SRV + ShaderVisibility: Domain Descriptor: ShaderRegister: 31 RegisterSpace: 32 DATA_STATIC_WHILE_SET_AT_EXECUTE: true - - ParameterType: 0 # SRV - ShaderVisibility: 3 # Domain + - ParameterType: DescriptorTable + ShaderVisibility: Domain Table: NumRanges: 1 Ranges: - - RangeType: 0 + - RangeType: SRV NumDescriptors: -1 BaseShaderRegister: 42 RegisterSpace: 43 @@ -60,31 +60,31 @@ Parts: # CHECK-NEXT: NumStaticSamplers: 0 # CHECK-NEXT: StaticSamplersOffset: 60 # CHECK-NEXT: Parameters: -# CHECK-NEXT: - ParameterType: 1 -# CHECK-NEXT: ShaderVisibility: 2 +# CHECK-NEXT: - ParameterType: Constants32Bit +# CHECK-NEXT: ShaderVisibility: Hull # CHECK-NEXT: Constants: # CHECK-NEXT: Num32BitValues: 16 # CHECK-NEXT: RegisterSpace: 14 # CHECK-NEXT: ShaderRegister: 15 -# CHECK-NEXT: - ParameterType: 1 -# CHECK-NEXT: ShaderVisibility: 4 +# CHECK-NEXT: - ParameterType: Constants32Bit +# CHECK-NEXT: ShaderVisibility: Geometry # CHECK-NEXT: Constants: # CHECK-NEXT: Num32BitValues: 21 # CHECK-NEXT: RegisterSpace: 23 # CHECK-NEXT: ShaderRegister: 22 -# CHECK-NEXT: - ParameterType: 2 -# CHECK-NEXT: ShaderVisibility: 3 +# CHECK-NEXT: - ParameterType: SRV +# CHECK-NEXT: ShaderVisibility: Domain # CHECK-NEXT: Descriptor: # CHECK-NEXT: RegisterSpace: 32 # CHECK-NEXT: ShaderRegister: 31 # CHECK-NEXT: DATA_STATIC_WHILE_SET_AT_EXECUTE: true -# CHECK-NEXT: - ParameterType: 0 -# CHECK-NEXT: ShaderVisibility: 3 +# CHECK-NEXT: - ParameterType: DescriptorTable +# CHECK-NEXT: ShaderVisibility: Domain # CHECK-NEXT: Table: # CHECK-NEXT: NumRanges: 1 # CHECK-NEXT: RangesOffset: 116 # CHECK-NEXT: Ranges: -# CHECK-NEXT: - RangeType: 0 +# CHECK-NEXT: - RangeType: SRV # CHECK-NEXT: NumDescriptors: -1 # CHECK-NEXT: BaseShaderRegister: 42 # CHECK-NEXT: RegisterSpace: 43 diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplers-Defaults.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplers-Defaults.yaml index 2189753be0b74..c5499155b53ea 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplers-Defaults.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplers-Defaults.yaml @@ -22,7 +22,7 @@ Parts: Samplers: - ShaderRegister: 31 RegisterSpace: 32 - ShaderVisibility: 7 + ShaderVisibility: Mesh AllowInputAssemblerInputLayout: true DenyGeometryShaderRootAccess: true @@ -36,18 +36,18 @@ Parts: #CHECK-NEXT: StaticSamplersOffset: 24 #CHECK-NEXT: Parameters: [] #CHECK-NEXT: Samplers: -#CHECK-NEXT: - Filter: 85 -#CHECK-NEXT: AddressU: 1 -#CHECK-NEXT: AddressV: 1 -#CHECK-NEXT: AddressW: 1 +#CHECK-NEXT: - Filter: Anisotropic +#CHECK-NEXT: AddressU: Wrap +#CHECK-NEXT: AddressV: Wrap +#CHECK-NEXT: AddressW: Wrap #CHECK-NEXT: MipLODBias: 0 #CHECK-NEXT: MaxAnisotropy: 16 -#CHECK-NEXT: ComparisonFunc: 4 -#CHECK-NEXT: BorderColor: 2 +#CHECK-NEXT: ComparisonFunc: LessEqual +#CHECK-NEXT: BorderColor: OpaqueWhite #CHECK-NEXT: MinLOD: 0 #CHECK-NEXT: MaxLOD: 3.40282e+38 #CHECK-NEXT: ShaderRegister: 31 #CHECK-NEXT: RegisterSpace: 32 -#CHECK-NEXT: ShaderVisibility: 7 +#CHECK-NEXT: ShaderVisibility: Mesh #CHECK-NEXT: AllowInputAssemblerInputLayout: true #CHECK-NEXT: DenyGeometryShaderRootAccess: true diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplers.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplers.yaml index 175b8ea101c87..f0f095ba72835 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplers.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplers.yaml @@ -20,19 +20,19 @@ Parts: StaticSamplersOffset: 24 Parameters: [] Samplers: - - Filter: 16 - AddressU: 1 - AddressV: 2 - AddressW: 5 + - Filter: MinLinearMagMipPoint + AddressU: Wrap + AddressV: Mirror + AddressW: MirrorOnce MipLODBias: 1.23 MaxAnisotropy: 20 - ComparisonFunc: 4 - BorderColor: 0 + ComparisonFunc: LessEqual + BorderColor: TransparentBlack MinLOD: 4.56 MaxLOD: 8.90 ShaderRegister: 31 RegisterSpace: 32 - ShaderVisibility: 7 + ShaderVisibility: Mesh AllowInputAssemblerInputLayout: true DenyGeometryShaderRootAccess: true @@ -46,18 +46,18 @@ Parts: #CHECK-NEXT: StaticSamplersOffset: 24 #CHECK-NEXT: Parameters: [] #CHECK-NEXT: Samplers: -#CHECK-NEXT: - Filter: 16 -#CHECK-NEXT: AddressU: 1 -#CHECK-NEXT: AddressV: 2 -#CHECK-NEXT: AddressW: 5 +#CHECK-NEXT: - Filter: MinLinearMagMipPoint +#CHECK-NEXT: AddressU: Wrap +#CHECK-NEXT: AddressV: Mirror +#CHECK-NEXT: AddressW: MirrorOnce #CHECK-NEXT: MipLODBias: 1.23 #CHECK-NEXT: MaxAnisotropy: 20 -#CHECK-NEXT: ComparisonFunc: 4 -#CHECK-NEXT: BorderColor: 0 +#CHECK-NEXT: ComparisonFunc: LessEqual +#CHECK-NEXT: BorderColor: TransparentBlack #CHECK-NEXT: MinLOD: 4.56 #CHECK-NEXT: MaxLOD: 8.9 #CHECK-NEXT: ShaderRegister: 31 #CHECK-NEXT: RegisterSpace: 32 -#CHECK-NEXT: ShaderVisibility: 7 +#CHECK-NEXT: ShaderVisibility: Mesh #CHECK-NEXT: AllowInputAssemblerInputLayout: true #CHECK-NEXT: DenyGeometryShaderRootAccess: true diff --git a/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp b/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp index 37000259dc400..78fb8e97dc582 100644 --- a/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp +++ b/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp @@ -172,8 +172,8 @@ TEST(RootSignature, HeaderData) { NumStaticSamplers: 0 StaticSamplersOffset: 0 Parameters: - - ParameterType: 1 - ShaderVisibility: 2 + - ParameterType: Constants32Bit + ShaderVisibility: Hull Constants: Num32BitValues: 16 ShaderRegister: 15 @@ -224,8 +224,8 @@ TEST(RootSignature, ParseRootConstants) { NumStaticSamplers: 0 StaticSamplersOffset: 0 Parameters: - - ParameterType: 1 - ShaderVisibility: 2 + - ParameterType: Constants32Bit + ShaderVisibility: Hull Constants: Num32BitValues: 16 ShaderRegister: 15 @@ -276,8 +276,8 @@ TEST(RootSignature, ParseRootDescriptorsV10) { NumStaticSamplers: 0 StaticSamplersOffset: 60 Parameters: - - ParameterType: 2 # SRV - ShaderVisibility: 3 # Domain + - ParameterType: CBV + ShaderVisibility: Domain Descriptor: ShaderRegister: 31 RegisterSpace: 32 @@ -327,8 +327,8 @@ TEST(RootSignature, ParseRootDescriptorsV11) { NumStaticSamplers: 0 StaticSamplersOffset: 60 Parameters: - - ParameterType: 2 # SRV - ShaderVisibility: 3 # Domain + - ParameterType: CBV + ShaderVisibility: Domain Descriptor: ShaderRegister: 31 RegisterSpace: 32 @@ -379,12 +379,12 @@ TEST(RootSignature, ParseDescriptorTableV10) { NumStaticSamplers: 0 StaticSamplersOffset: 60 Parameters: - - ParameterType: 0 # SRV - ShaderVisibility: 3 # Domain + - ParameterType: DescriptorTable + ShaderVisibility: Domain Table: NumRanges: 1 Ranges: - - RangeType: 0 + - RangeType: SRV NumDescriptors: 41 BaseShaderRegister: 42 RegisterSpace: 43 @@ -435,12 +435,12 @@ TEST(RootSignature, ParseDescriptorTableV11) { NumStaticSamplers: 0 StaticSamplersOffset: 60 Parameters: - - ParameterType: 0 # Descriptor Table - ShaderVisibility: 3 # Domain + - ParameterType: DescriptorTable + ShaderVisibility: Domain Table: NumRanges: 1 Ranges: - - RangeType: 0 + - RangeType: SRV NumDescriptors: -1 BaseShaderRegister: 42 RegisterSpace: 43 @@ -492,19 +492,19 @@ TEST(RootSignature, ParseStaticSamplers) { StaticSamplersOffset: 24 Parameters: [] Samplers: - - Filter: 16 - AddressU: 1 - AddressV: 2 - AddressW: 5 + - Filter: MinLinearMagMipPoint + AddressU: Wrap + AddressV: Mirror + AddressW: MirrorOnce MipLODBias: 1.23 MaxAnisotropy: 20 - ComparisonFunc: 4 - BorderColor: 0 + ComparisonFunc: LessEqual + BorderColor: TransparentBlack MinLOD: 4.56 MaxLOD: 8.90 ShaderRegister: 31 RegisterSpace: 32 - ShaderVisibility: 7 + ShaderVisibility: Mesh AllowInputAssemblerInputLayout: true DenyGeometryShaderRootAccess: true )")); From 182c8173536010f797c2071380dc8bc678a38914 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Wed, 20 Aug 2025 11:55:38 -0700 Subject: [PATCH 19/29] removing binary format descriptor range dependency --- clang/lib/Sema/SemaHLSL.cpp | 31 ++++++++++++++++--- llvm/include/llvm/BinaryFormat/DXContainer.h | 10 ++++++ .../Frontend/HLSL/RootSignatureValidations.h | 3 +- .../llvm/MC/DXContainerRootSignature.h | 15 +++++++-- llvm/lib/BinaryFormat/DXContainer.cpp | 10 ++++++ .../Frontend/HLSL/RootSignatureMetadata.cpp | 25 +++++---------- .../HLSL/RootSignatureValidations.cpp | 5 ++- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 7 +++-- .../DXILPostOptimizationValidation.cpp | 2 +- llvm/lib/Target/DirectX/DXILRootSignature.cpp | 7 +++-- ...ature-DescriptorTable-Invalid-RangeType.ll | 20 ------------ .../ContainerData/RootSignature-Parameters.ll | 4 +-- 12 files changed, 82 insertions(+), 57 deletions(-) delete mode 100644 llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-Invalid-RangeType.ll diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp index 1e5ec952c1ecf..fd49feff5f496 100644 --- a/clang/lib/Sema/SemaHLSL.cpp +++ b/clang/lib/Sema/SemaHLSL.cpp @@ -1282,11 +1282,34 @@ bool SemaHLSL::handleRootSignatureElements( // value ReportError(Loc, 1, 0xfffffffe); } + switch (Clause->Type) { - if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( - Version, llvm::to_underlying(Clause->Type), - llvm::to_underlying(Clause->Flags))) - ReportFlagError(Loc); + case llvm::dxil::ResourceClass::SRV: + if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( + Version, llvm::dxbc::DescriptorRangeType::SRV, + llvm::to_underlying(Clause->Flags))) + ReportFlagError(Loc); + break; + case llvm::dxil::ResourceClass::UAV: + if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( + Version, llvm::dxbc::DescriptorRangeType::UAV, + llvm::to_underlying(Clause->Flags))) + ReportFlagError(Loc); + break; + case llvm::dxil::ResourceClass::CBuffer: + if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( + Version, llvm::dxbc::DescriptorRangeType::CBV, + llvm::to_underlying(Clause->Flags))) + ReportFlagError(Loc); + break; + case llvm::dxil::ResourceClass::Sampler: + if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( + Version, llvm::dxbc::DescriptorRangeType::Sampler, + llvm::to_underlying(Clause->Flags))) + ReportFlagError(Loc); + break; + break; + } } } diff --git a/llvm/include/llvm/BinaryFormat/DXContainer.h b/llvm/include/llvm/BinaryFormat/DXContainer.h index f74c9775cb3f3..54747b46ccc6c 100644 --- a/llvm/include/llvm/BinaryFormat/DXContainer.h +++ b/llvm/include/llvm/BinaryFormat/DXContainer.h @@ -209,6 +209,16 @@ inline bool isValidParameterType(uint32_t V) { return false; } +#define DESCRIPTOR_RANGE(Val, Enum) \ + case Val: \ + return true; +inline bool isValidRangeType(uint32_t V) { + switch (V) { +#include "DXContainerConstants.def" + } + return false; +} + #define SHADER_VISIBILITY(Val, Enum) Enum = Val, enum class ShaderVisibility : uint32_t { #include "DXContainerConstants.def" diff --git a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h index fde32a1fff591..acb83e54b92ed 100644 --- a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h +++ b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h @@ -30,7 +30,8 @@ LLVM_ABI bool verifyRegisterValue(uint32_t RegisterValue); LLVM_ABI bool verifyRegisterSpace(uint32_t RegisterSpace); LLVM_ABI bool verifyRootDescriptorFlag(uint32_t Version, uint32_t FlagsVal); LLVM_ABI bool verifyRangeType(uint32_t Type); -LLVM_ABI bool verifyDescriptorRangeFlag(uint32_t Version, uint32_t Type, +LLVM_ABI bool verifyDescriptorRangeFlag(uint32_t Version, + dxbc::DescriptorRangeType Type, uint32_t FlagsVal); LLVM_ABI bool verifyNumDescriptors(uint32_t NumDescriptors); LLVM_ABI bool verifySamplerFilter(uint32_t Value); diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index 14fcdfd764353..9aca67da328ba 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -31,6 +31,15 @@ struct RootDescriptor { uint32_t Flags; }; +struct DescriptorRange { + dxbc::DescriptorRangeType RangeType; + uint32_t NumDescriptors; + uint32_t BaseShaderRegister; + uint32_t RegisterSpace; + uint32_t Flags; + uint32_t OffsetInDescriptorsFromTableStart; +}; + struct RootParameterInfo { dxbc::RootParameterType Type; dxbc::ShaderVisibility Visibility; @@ -42,11 +51,11 @@ struct RootParameterInfo { }; struct DescriptorTable { - SmallVector Ranges; - SmallVector::const_iterator begin() const { + SmallVector Ranges; + SmallVector::const_iterator begin() const { return Ranges.begin(); } - SmallVector::const_iterator end() const { + SmallVector::const_iterator end() const { return Ranges.end(); } }; diff --git a/llvm/lib/BinaryFormat/DXContainer.cpp b/llvm/lib/BinaryFormat/DXContainer.cpp index 36d10d0b63078..f79db506962bc 100644 --- a/llvm/lib/BinaryFormat/DXContainer.cpp +++ b/llvm/lib/BinaryFormat/DXContainer.cpp @@ -149,6 +149,16 @@ ArrayRef> dxbc::getRootParameterTypes() { return ArrayRef(RootParameterTypes); } +#define DESCRIPTOR_RANGE(Val, Enum) {#Enum, DescriptorRangeType::Enum}, + +static const EnumEntry DescriptorRangeTypes[] = { +#include "llvm/BinaryFormat/DXContainerConstants.def" +}; + +ArrayRef> dxbc::getDescriptorRangeTypes() { + return ArrayRef(DescriptorRangeTypes); +} + #define SEMANTIC_KIND(Val, Enum) {#Enum, PSV::SemanticKind::Enum}, static const EnumEntry SemanticKindNames[] = { diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index a5a92cbd2d616..ee8384405e7fb 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -322,7 +322,7 @@ Error MetadataParser::parseDescriptorRange(mcdxbc::DescriptorTable &Table, if (RangeDescriptorNode->getNumOperands() != 6) return make_error("Descriptor Range"); - dxbc::RTS0::v2::DescriptorRange Range; + mcdxbc::DescriptorRange Range; std::optional ElementText = extractMdStringValue(RangeDescriptorNode, 0); @@ -330,17 +330,11 @@ Error MetadataParser::parseDescriptorRange(mcdxbc::DescriptorTable &Table, if (!ElementText.has_value()) return make_error("Descriptor Range"); - Range.RangeType = - StringSwitch(*ElementText) - .Case("CBV", to_underlying(dxbc::DescriptorRangeType::CBV)) - .Case("SRV", to_underlying(dxbc::DescriptorRangeType::SRV)) - .Case("UAV", to_underlying(dxbc::DescriptorRangeType::UAV)) - .Case("Sampler", to_underlying(dxbc::DescriptorRangeType::Sampler)) - .Default(~0U); - - if (Range.RangeType == ~0U) - return make_error("Invalid Descriptor Range type.", - RangeDescriptorNode); + Range.RangeType = StringSwitch(*ElementText) + .Case("CBV", dxbc::DescriptorRangeType::CBV) + .Case("SRV", dxbc::DescriptorRangeType::SRV) + .Case("UAV", dxbc::DescriptorRangeType::UAV) + .Case("Sampler", dxbc::DescriptorRangeType::Sampler); if (std::optional Val = extractMdIntValue(RangeDescriptorNode, 1)) Range.NumDescriptors = *Val; @@ -568,12 +562,7 @@ Error MetadataParser::validateRootSignature( case dxbc::RootParameterType::DescriptorTable: { const mcdxbc::DescriptorTable &Table = RSD.ParametersContainer.getDescriptorTable(Info.Location); - for (const dxbc::RTS0::v2::DescriptorRange &Range : Table) { - if (!hlsl::rootsig::verifyRangeType(Range.RangeType)) - DeferredErrs = - joinErrors(std::move(DeferredErrs), - make_error>( - "RangeType", Range.RangeType)); + for (const mcdxbc::DescriptorRange &Range : Table) { if (!hlsl::rootsig::verifyRegisterSpace(Range.RegisterSpace)) DeferredErrs = diff --git a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp index 72308a3de5fd4..5dbeede778b04 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp @@ -63,13 +63,12 @@ bool verifyRangeType(uint32_t Type) { return false; } -bool verifyDescriptorRangeFlag(uint32_t Version, uint32_t Type, +bool verifyDescriptorRangeFlag(uint32_t Version, dxbc::DescriptorRangeType Type, uint32_t FlagsVal) { using FlagT = dxbc::DescriptorRangeFlags; FlagT Flags = FlagT(FlagsVal); - const bool IsSampler = - (Type == llvm::to_underlying(dxbc::DescriptorRangeType::Sampler)); + const bool IsSampler = (Type == dxbc::DescriptorRangeType::Sampler); if (Version == 1) { // Since the metadata is unversioned, we expect to explicitly see the values diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index fa3abd274480a..b4c5c3f5c018e 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -313,9 +313,10 @@ Error DXContainerWriter::writeParts(raw_ostream &OS) { P.RootSignature->Parameters.getOrInsertTable(L); mcdxbc::DescriptorTable Table; for (const auto &R : TableYaml.Ranges) { - - dxbc::RTS0::v2::DescriptorRange Range; - Range.RangeType = R.RangeType; + assert(dxbc::isValidRangeType(R.RangeType) && + "Invalid Descriptor Range Type"); + mcdxbc::DescriptorRange Range; + Range.RangeType = dxbc::DescriptorRangeType(R.RangeType); Range.NumDescriptors = R.NumDescriptors; Range.BaseShaderRegister = R.BaseShaderRegister; Range.RegisterSpace = R.RegisterSpace; diff --git a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp index a139167685ece..51cd1b8e3a478 100644 --- a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp +++ b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp @@ -205,7 +205,7 @@ static void validateRootSignature(Module &M, const mcdxbc::DescriptorTable &Table = RSD.ParametersContainer.getDescriptorTable(ParamInfo.Location); - for (const dxbc::RTS0::v2::DescriptorRange &Range : Table.Ranges) { + for (const mcdxbc::DescriptorRange &Range : Table.Ranges) { uint32_t UpperBound = Range.NumDescriptors == ~0U ? Range.BaseShaderRegister diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp index 2436d3869464f..3af595645ee7a 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp +++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp @@ -205,8 +205,11 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M, RS.ParametersContainer.getDescriptorTable(Info.Location); OS << " NumRanges: " << Table.Ranges.size() << "\n"; - for (const dxbc::RTS0::v2::DescriptorRange Range : Table) { - OS << " - Range Type: " << Range.RangeType << "\n" + for (const mcdxbc::DescriptorRange Range : Table) { + OS << " - Range Type: " + << enumToStringRef(Range.RangeType, + dxbc::getDescriptorRangeTypes()) + << "\n" << " Register Space: " << Range.RegisterSpace << "\n" << " Base Shader Register: " << Range.BaseShaderRegister << "\n" << " Num Descriptors: " << Range.NumDescriptors << "\n" diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-Invalid-RangeType.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-Invalid-RangeType.ll deleted file mode 100644 index 4a65a53f9f727..0000000000000 --- a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-Invalid-RangeType.ll +++ /dev/null @@ -1,20 +0,0 @@ -; RUN: not opt -passes='print' %s -S -o - 2>&1 | FileCheck %s - -target triple = "dxil-unknown-shadermodel6.0-compute" - -; CHECK: error: Invalid Descriptor Range type -; CHECK-NOT: Root Signature Definitions - -define void @main() #0 { -entry: - ret void -} -attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } - - -!dx.rootsignatures = !{!2} ; list of function/root signature pairs -!2 = !{ ptr @main, !3, i32 2 } ; function, root signature -!3 = !{ !5 } ; list of root signature elements -!5 = !{ !"DescriptorTable", i32 0, !6, !7 } -!6 = !{ !"Invalid", i32 1, i32 0, i32 -1, i32 -1, i32 4 } -!7 = !{ !"UAV", i32 5, i32 1, i32 10, i32 5, i32 2 } diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll index 742fea14f5af6..6c6739d6ed390 100644 --- a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll +++ b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-Parameters.ll @@ -38,13 +38,13 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } ;CHECK-NEXT: - Parameter Type: DescriptorTable ;CHECK-NEXT: Shader Visibility: All ;CHECK-NEXT: NumRanges: 2 -;CHECK-NEXT: - Range Type: 0 +;CHECK-NEXT: - Range Type: SRV ;CHECK-NEXT: Register Space: 0 ;CHECK-NEXT: Base Shader Register: 1 ;CHECK-NEXT: Num Descriptors: 1 ;CHECK-NEXT: Offset In Descriptors From Table Start: 4294967295 ;CHECK-NEXT: Flags: 4 -;CHECK-NEXT: - Range Type: 1 +;CHECK-NEXT: - Range Type: UAV ;CHECK-NEXT: Register Space: 10 ;CHECK-NEXT: Base Shader Register: 1 ;CHECK-NEXT: Num Descriptors: 5 From f9d16d21b804948c6e3f5f7010f8fa16cdefbae1 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Fri, 29 Aug 2025 14:59:27 -0700 Subject: [PATCH 20/29] creating toDescriptorRange and change verifyDescriptorRangeFlag signature --- clang/lib/Sema/SemaHLSL.cpp | 46 ++++++++----------- .../Frontend/HLSL/RootSignatureValidations.h | 3 ++ .../HLSL/RootSignatureValidations.cpp | 11 ++++- 3 files changed, 30 insertions(+), 30 deletions(-) diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp index fd49feff5f496..3f625c903e39e 100644 --- a/clang/lib/Sema/SemaHLSL.cpp +++ b/clang/lib/Sema/SemaHLSL.cpp @@ -1241,6 +1241,21 @@ bool SemaHLSL::handleRootSignatureElements( << /*version minor*/ VersionEnum; }; + auto toDescriptorRangeType = [](llvm::dxil::ResourceClass Type) { + switch (Type) { + case llvm::dxil::ResourceClass::SRV: + return llvm::dxbc::DescriptorRangeType::SRV; + case llvm::dxil::ResourceClass::UAV: + return llvm::dxbc::DescriptorRangeType::UAV; + case llvm::dxil::ResourceClass::CBuffer: + return llvm::dxbc::DescriptorRangeType::CBV; + case llvm::dxil::ResourceClass::Sampler: + return llvm::dxbc::DescriptorRangeType::Sampler; + } + + llvm_unreachable("Unhandled Resource Class"); + }; + // Iterate through the elements and do basic validations for (const hlsl::RootSignatureElement &RootSigElem : Elements) { SourceLocation Loc = RootSigElem.getLocation(); @@ -1282,34 +1297,9 @@ bool SemaHLSL::handleRootSignatureElements( // value ReportError(Loc, 1, 0xfffffffe); } - switch (Clause->Type) { - - case llvm::dxil::ResourceClass::SRV: - if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( - Version, llvm::dxbc::DescriptorRangeType::SRV, - llvm::to_underlying(Clause->Flags))) - ReportFlagError(Loc); - break; - case llvm::dxil::ResourceClass::UAV: - if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( - Version, llvm::dxbc::DescriptorRangeType::UAV, - llvm::to_underlying(Clause->Flags))) - ReportFlagError(Loc); - break; - case llvm::dxil::ResourceClass::CBuffer: - if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( - Version, llvm::dxbc::DescriptorRangeType::CBV, - llvm::to_underlying(Clause->Flags))) - ReportFlagError(Loc); - break; - case llvm::dxil::ResourceClass::Sampler: - if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( - Version, llvm::dxbc::DescriptorRangeType::Sampler, - llvm::to_underlying(Clause->Flags))) - ReportFlagError(Loc); - break; - break; - } + if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( + Version, toDescriptorRangeType(Clause->Type), Clause->Flags)) + ReportFlagError(Loc); } } diff --git a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h index acb83e54b92ed..4571c40cb1322 100644 --- a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h +++ b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h @@ -30,6 +30,9 @@ LLVM_ABI bool verifyRegisterValue(uint32_t RegisterValue); LLVM_ABI bool verifyRegisterSpace(uint32_t RegisterSpace); LLVM_ABI bool verifyRootDescriptorFlag(uint32_t Version, uint32_t FlagsVal); LLVM_ABI bool verifyRangeType(uint32_t Type); +LLVM_ABI bool verifyDescriptorRangeFlag(uint32_t Version, + dxbc::DescriptorRangeType Type, + dxbc::DescriptorRangeFlags FlagsVal); LLVM_ABI bool verifyDescriptorRangeFlag(uint32_t Version, dxbc::DescriptorRangeType Type, uint32_t FlagsVal); diff --git a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp index 5dbeede778b04..d2c6e9175de2d 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp @@ -64,9 +64,8 @@ bool verifyRangeType(uint32_t Type) { } bool verifyDescriptorRangeFlag(uint32_t Version, dxbc::DescriptorRangeType Type, - uint32_t FlagsVal) { + dxbc::DescriptorRangeFlags Flags) { using FlagT = dxbc::DescriptorRangeFlags; - FlagT Flags = FlagT(FlagsVal); const bool IsSampler = (Type == dxbc::DescriptorRangeType::Sampler); @@ -124,6 +123,14 @@ bool verifyDescriptorRangeFlag(uint32_t Version, dxbc::DescriptorRangeType Type, return (Flags & ~Mask) == FlagT::None; } +// This is included to avoid including BinaryFormat/DXContainer to make the +// flags conversion, since this might cause compilation times to increase. +bool verifyDescriptorRangeFlag(uint32_t Version, dxbc::DescriptorRangeType Type, + uint32_t Flags) { + return verifyDescriptorRangeFlag(Version, Type, + dxbc::DescriptorRangeFlags(Flags)); +} + bool verifyNumDescriptors(uint32_t NumDescriptors) { return NumDescriptors > 0; } From 42f8f114310a0d30c9bef18a6cb731a008404833 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Fri, 29 Aug 2025 15:08:17 -0700 Subject: [PATCH 21/29] adding test and removing string switch --- .../Frontend/HLSL/RootSignatureMetadata.cpp | 16 ++++++++++----- ...ature-DescriptorTable-Invalid-RangeType.ll | 20 +++++++++++++++++++ 2 files changed, 31 insertions(+), 5 deletions(-) create mode 100644 llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-Invalid-RangeType.ll diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index ee8384405e7fb..1e77c4ad08050 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -330,11 +330,17 @@ Error MetadataParser::parseDescriptorRange(mcdxbc::DescriptorTable &Table, if (!ElementText.has_value()) return make_error("Descriptor Range"); - Range.RangeType = StringSwitch(*ElementText) - .Case("CBV", dxbc::DescriptorRangeType::CBV) - .Case("SRV", dxbc::DescriptorRangeType::SRV) - .Case("UAV", dxbc::DescriptorRangeType::UAV) - .Case("Sampler", dxbc::DescriptorRangeType::Sampler); + if (*ElementText == "CBV") + Range.RangeType = dxbc::DescriptorRangeType::CBV; + else if (*ElementText == "SRV") + Range.RangeType = dxbc::DescriptorRangeType::SRV; + else if (*ElementText == "UAV") + Range.RangeType = dxbc::DescriptorRangeType::UAV; + else if (*ElementText == "Sampler") + Range.RangeType = dxbc::DescriptorRangeType::Sampler; + else + return make_error("Invalid Descriptor Range type.", + RangeDescriptorNode); if (std::optional Val = extractMdIntValue(RangeDescriptorNode, 1)) Range.NumDescriptors = *Val; diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-Invalid-RangeType.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-Invalid-RangeType.ll new file mode 100644 index 0000000000000..4a65a53f9f727 --- /dev/null +++ b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-Invalid-RangeType.ll @@ -0,0 +1,20 @@ +; RUN: not opt -passes='print' %s -S -o - 2>&1 | FileCheck %s + +target triple = "dxil-unknown-shadermodel6.0-compute" + +; CHECK: error: Invalid Descriptor Range type +; CHECK-NOT: Root Signature Definitions + +define void @main() #0 { +entry: + ret void +} +attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } + + +!dx.rootsignatures = !{!2} ; list of function/root signature pairs +!2 = !{ ptr @main, !3, i32 2 } ; function, root signature +!3 = !{ !5 } ; list of root signature elements +!5 = !{ !"DescriptorTable", i32 0, !6, !7 } +!6 = !{ !"Invalid", i32 1, i32 0, i32 -1, i32 -1, i32 4 } +!7 = !{ !"UAV", i32 5, i32 1, i32 10, i32 5, i32 2 } From 7ada31b7073cb516100282e39ff44162f9b7df3a Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Fri, 29 Aug 2025 15:11:28 -0700 Subject: [PATCH 22/29] removing copy --- llvm/lib/Target/DirectX/DXILRootSignature.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp index 3af595645ee7a..a39da388cc5f7 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp +++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp @@ -205,7 +205,7 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M, RS.ParametersContainer.getDescriptorTable(Info.Location); OS << " NumRanges: " << Table.Ranges.size() << "\n"; - for (const mcdxbc::DescriptorRange Range : Table) { + for (const mcdxbc::DescriptorRange &Range : Table) { OS << " - Range Type: " << enumToStringRef(Range.RangeType, dxbc::getDescriptorRangeTypes()) From fa60959c0c1d980ed2e3368aaaee0f11f82efa2b Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Fri, 29 Aug 2025 18:19:42 -0700 Subject: [PATCH 23/29] clean up --- clang/lib/Sema/SemaHLSL.cpp | 2 +- llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp | 3 --- 2 files changed, 1 insertion(+), 4 deletions(-) diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp index 3f625c903e39e..176cee59122fb 100644 --- a/clang/lib/Sema/SemaHLSL.cpp +++ b/clang/lib/Sema/SemaHLSL.cpp @@ -1252,7 +1252,6 @@ bool SemaHLSL::handleRootSignatureElements( case llvm::dxil::ResourceClass::Sampler: return llvm::dxbc::DescriptorRangeType::Sampler; } - llvm_unreachable("Unhandled Resource Class"); }; @@ -1297,6 +1296,7 @@ bool SemaHLSL::handleRootSignatureElements( // value ReportError(Loc, 1, 0xfffffffe); } + if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( Version, toDescriptorRangeType(Clause->Type), Clause->Flags)) ReportFlagError(Loc); diff --git a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp index d2c6e9175de2d..ec411aaf82438 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp @@ -122,9 +122,6 @@ bool verifyDescriptorRangeFlag(uint32_t Version, dxbc::DescriptorRangeType Type, } return (Flags & ~Mask) == FlagT::None; } - -// This is included to avoid including BinaryFormat/DXContainer to make the -// flags conversion, since this might cause compilation times to increase. bool verifyDescriptorRangeFlag(uint32_t Version, dxbc::DescriptorRangeType Type, uint32_t Flags) { return verifyDescriptorRangeFlag(Version, Type, From e065a8237be25d4a80d8a4ec8b826cac2069595d Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Fri, 5 Sep 2025 19:50:54 -0700 Subject: [PATCH 24/29] removing function I thought I needed --- llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h | 3 --- llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp | 4 ++-- llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp | 5 ----- 3 files changed, 2 insertions(+), 10 deletions(-) diff --git a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h index 4571c40cb1322..803cd097e7220 100644 --- a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h +++ b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h @@ -33,9 +33,6 @@ LLVM_ABI bool verifyRangeType(uint32_t Type); LLVM_ABI bool verifyDescriptorRangeFlag(uint32_t Version, dxbc::DescriptorRangeType Type, dxbc::DescriptorRangeFlags FlagsVal); -LLVM_ABI bool verifyDescriptorRangeFlag(uint32_t Version, - dxbc::DescriptorRangeType Type, - uint32_t FlagsVal); LLVM_ABI bool verifyNumDescriptors(uint32_t NumDescriptors); LLVM_ABI bool verifySamplerFilter(uint32_t Value); LLVM_ABI bool verifyAddress(uint32_t Address); diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index 1e77c4ad08050..8dca39ea1db2b 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -569,7 +569,6 @@ Error MetadataParser::validateRootSignature( const mcdxbc::DescriptorTable &Table = RSD.ParametersContainer.getDescriptorTable(Info.Location); for (const mcdxbc::DescriptorRange &Range : Table) { - if (!hlsl::rootsig::verifyRegisterSpace(Range.RegisterSpace)) DeferredErrs = joinErrors(std::move(DeferredErrs), @@ -583,7 +582,8 @@ Error MetadataParser::validateRootSignature( "NumDescriptors", Range.NumDescriptors)); if (!hlsl::rootsig::verifyDescriptorRangeFlag( - RSD.Version, Range.RangeType, Range.Flags)) + RSD.Version, Range.RangeType, + dxbc::DescriptorRangeFlags(Range.Flags))) DeferredErrs = joinErrors(std::move(DeferredErrs), make_error>( diff --git a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp index ec411aaf82438..b2b9a1dc593e7 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp @@ -122,11 +122,6 @@ bool verifyDescriptorRangeFlag(uint32_t Version, dxbc::DescriptorRangeType Type, } return (Flags & ~Mask) == FlagT::None; } -bool verifyDescriptorRangeFlag(uint32_t Version, dxbc::DescriptorRangeType Type, - uint32_t Flags) { - return verifyDescriptorRangeFlag(Version, Type, - dxbc::DescriptorRangeFlags(Flags)); -} bool verifyNumDescriptors(uint32_t NumDescriptors) { return NumDescriptors > 0; From 17dbe9fe954c596832b38be58e600a650eb256d4 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Mon, 8 Sep 2025 12:18:24 -0700 Subject: [PATCH 25/29] refactoring to use dxil::ResourceClass for range type --- clang/lib/Sema/SemaHLSL.cpp | 18 ++------------- llvm/include/llvm/BinaryFormat/DXContainer.h | 8 +------ .../BinaryFormat/DXContainerConstants.def | 10 --------- .../Frontend/HLSL/RootSignatureValidations.h | 2 +- .../llvm/MC/DXContainerRootSignature.h | 2 +- llvm/lib/BinaryFormat/DXContainer.cpp | 10 --------- .../Frontend/HLSL/RootSignatureMetadata.cpp | 8 +++---- .../HLSL/RootSignatureValidations.cpp | 16 ++------------ llvm/lib/MC/DXContainerRootSignature.cpp | 3 ++- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 2 +- .../DXILPostOptimizationValidation.cpp | 22 ++----------------- llvm/lib/Target/DirectX/DXILRootSignature.cpp | 4 +--- 12 files changed, 17 insertions(+), 88 deletions(-) diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp index 176cee59122fb..240897d8cfb47 100644 --- a/clang/lib/Sema/SemaHLSL.cpp +++ b/clang/lib/Sema/SemaHLSL.cpp @@ -1241,20 +1241,6 @@ bool SemaHLSL::handleRootSignatureElements( << /*version minor*/ VersionEnum; }; - auto toDescriptorRangeType = [](llvm::dxil::ResourceClass Type) { - switch (Type) { - case llvm::dxil::ResourceClass::SRV: - return llvm::dxbc::DescriptorRangeType::SRV; - case llvm::dxil::ResourceClass::UAV: - return llvm::dxbc::DescriptorRangeType::UAV; - case llvm::dxil::ResourceClass::CBuffer: - return llvm::dxbc::DescriptorRangeType::CBV; - case llvm::dxil::ResourceClass::Sampler: - return llvm::dxbc::DescriptorRangeType::Sampler; - } - llvm_unreachable("Unhandled Resource Class"); - }; - // Iterate through the elements and do basic validations for (const hlsl::RootSignatureElement &RootSigElem : Elements) { SourceLocation Loc = RootSigElem.getLocation(); @@ -1297,8 +1283,8 @@ bool SemaHLSL::handleRootSignatureElements( ReportError(Loc, 1, 0xfffffffe); } - if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag( - Version, toDescriptorRangeType(Clause->Type), Clause->Flags)) + if (!llvm::hlsl::rootsig::verifyDescriptorRangeFlag(Version, Clause->Type, + Clause->Flags)) ReportFlagError(Loc); } } diff --git a/llvm/include/llvm/BinaryFormat/DXContainer.h b/llvm/include/llvm/BinaryFormat/DXContainer.h index 54747b46ccc6c..8942e8bb1f7cc 100644 --- a/llvm/include/llvm/BinaryFormat/DXContainer.h +++ b/llvm/include/llvm/BinaryFormat/DXContainer.h @@ -209,14 +209,8 @@ inline bool isValidParameterType(uint32_t V) { return false; } -#define DESCRIPTOR_RANGE(Val, Enum) \ - case Val: \ - return true; inline bool isValidRangeType(uint32_t V) { - switch (V) { -#include "DXContainerConstants.def" - } - return false; + return V <= llvm::to_underlying(dxil::ResourceClass::Sampler); } #define SHADER_VISIBILITY(Val, Enum) Enum = Val, diff --git a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def index 8730820dd8b06..889653611d79a 100644 --- a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def +++ b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def @@ -104,16 +104,6 @@ DESCRIPTOR_RANGE_FLAG(0x10000, DescriptorsStaticKeepingBufferBoundsChecks, DESCR #undef DESCRIPTOR_RANGE_FLAG #endif // DESCRIPTOR_RANGE_FLAG -// DESCRIPTOR_RANGE(value, name). -#ifdef DESCRIPTOR_RANGE - -DESCRIPTOR_RANGE(0, SRV) -DESCRIPTOR_RANGE(1, UAV) -DESCRIPTOR_RANGE(2, CBV) -DESCRIPTOR_RANGE(3, Sampler) -#undef DESCRIPTOR_RANGE -#endif // DESCRIPTOR_RANGE - #ifdef ROOT_PARAMETER ROOT_PARAMETER(0, DescriptorTable) diff --git a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h index 803cd097e7220..fff7236bdcc31 100644 --- a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h +++ b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h @@ -31,7 +31,7 @@ LLVM_ABI bool verifyRegisterSpace(uint32_t RegisterSpace); LLVM_ABI bool verifyRootDescriptorFlag(uint32_t Version, uint32_t FlagsVal); LLVM_ABI bool verifyRangeType(uint32_t Type); LLVM_ABI bool verifyDescriptorRangeFlag(uint32_t Version, - dxbc::DescriptorRangeType Type, + dxil::ResourceClass Type, dxbc::DescriptorRangeFlags FlagsVal); LLVM_ABI bool verifyNumDescriptors(uint32_t NumDescriptors); LLVM_ABI bool verifySamplerFilter(uint32_t Value); diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index 9aca67da328ba..f2722fd37a4f1 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -32,7 +32,7 @@ struct RootDescriptor { }; struct DescriptorRange { - dxbc::DescriptorRangeType RangeType; + dxil::ResourceClass RangeType; uint32_t NumDescriptors; uint32_t BaseShaderRegister; uint32_t RegisterSpace; diff --git a/llvm/lib/BinaryFormat/DXContainer.cpp b/llvm/lib/BinaryFormat/DXContainer.cpp index f79db506962bc..36d10d0b63078 100644 --- a/llvm/lib/BinaryFormat/DXContainer.cpp +++ b/llvm/lib/BinaryFormat/DXContainer.cpp @@ -149,16 +149,6 @@ ArrayRef> dxbc::getRootParameterTypes() { return ArrayRef(RootParameterTypes); } -#define DESCRIPTOR_RANGE(Val, Enum) {#Enum, DescriptorRangeType::Enum}, - -static const EnumEntry DescriptorRangeTypes[] = { -#include "llvm/BinaryFormat/DXContainerConstants.def" -}; - -ArrayRef> dxbc::getDescriptorRangeTypes() { - return ArrayRef(DescriptorRangeTypes); -} - #define SEMANTIC_KIND(Val, Enum) {#Enum, PSV::SemanticKind::Enum}, static const EnumEntry SemanticKindNames[] = { diff --git a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp index 8dca39ea1db2b..31605e3900341 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureMetadata.cpp @@ -331,13 +331,13 @@ Error MetadataParser::parseDescriptorRange(mcdxbc::DescriptorTable &Table, return make_error("Descriptor Range"); if (*ElementText == "CBV") - Range.RangeType = dxbc::DescriptorRangeType::CBV; + Range.RangeType = dxil::ResourceClass::CBuffer; else if (*ElementText == "SRV") - Range.RangeType = dxbc::DescriptorRangeType::SRV; + Range.RangeType = dxil::ResourceClass::SRV; else if (*ElementText == "UAV") - Range.RangeType = dxbc::DescriptorRangeType::UAV; + Range.RangeType = dxil::ResourceClass::UAV; else if (*ElementText == "Sampler") - Range.RangeType = dxbc::DescriptorRangeType::Sampler; + Range.RangeType = dxil::ResourceClass::Sampler; else return make_error("Invalid Descriptor Range type.", RangeDescriptorNode); diff --git a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp index b2b9a1dc593e7..96737ea340e77 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp @@ -51,23 +51,11 @@ bool verifyRootDescriptorFlag(uint32_t Version, uint32_t FlagsVal) { return (Flags | DataFlags) == DataFlags; } -bool verifyRangeType(uint32_t Type) { - switch (Type) { - case llvm::to_underlying(dxbc::DescriptorRangeType::CBV): - case llvm::to_underlying(dxbc::DescriptorRangeType::SRV): - case llvm::to_underlying(dxbc::DescriptorRangeType::UAV): - case llvm::to_underlying(dxbc::DescriptorRangeType::Sampler): - return true; - }; - - return false; -} - -bool verifyDescriptorRangeFlag(uint32_t Version, dxbc::DescriptorRangeType Type, +bool verifyDescriptorRangeFlag(uint32_t Version, dxil::ResourceClass Type, dxbc::DescriptorRangeFlags Flags) { using FlagT = dxbc::DescriptorRangeFlags; - const bool IsSampler = (Type == dxbc::DescriptorRangeType::Sampler); + const bool IsSampler = (Type == dxil::ResourceClass::Sampler); if (Version == 1) { // Since the metadata is unversioned, we expect to explicitly see the values diff --git a/llvm/lib/MC/DXContainerRootSignature.cpp b/llvm/lib/MC/DXContainerRootSignature.cpp index ce7d5c91bc7c6..393d886d35aa4 100644 --- a/llvm/lib/MC/DXContainerRootSignature.cpp +++ b/llvm/lib/MC/DXContainerRootSignature.cpp @@ -137,7 +137,8 @@ void RootSignatureDesc::write(raw_ostream &OS) const { llvm::endianness::little); rewriteOffsetToCurrentByte(BOS, writePlaceholder(BOS)); for (const auto &Range : Table) { - support::endian::write(BOS, Range.RangeType, llvm::endianness::little); + support::endian::write(BOS, (uint32_t)Range.RangeType, + llvm::endianness::little); support::endian::write(BOS, Range.NumDescriptors, llvm::endianness::little); support::endian::write(BOS, Range.BaseShaderRegister, diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index b4c5c3f5c018e..1078b1188bb66 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -316,7 +316,7 @@ Error DXContainerWriter::writeParts(raw_ostream &OS) { assert(dxbc::isValidRangeType(R.RangeType) && "Invalid Descriptor Range Type"); mcdxbc::DescriptorRange Range; - Range.RangeType = dxbc::DescriptorRangeType(R.RangeType); + Range.RangeType = dxil::ResourceClass(R.RangeType); Range.NumDescriptors = R.NumDescriptors; Range.BaseShaderRegister = R.BaseShaderRegister; Range.RegisterSpace = R.RegisterSpace; diff --git a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp index 51cd1b8e3a478..d02f4b9f7ebcd 100644 --- a/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp +++ b/llvm/lib/Target/DirectX/DXILPostOptimizationValidation.cpp @@ -25,21 +25,6 @@ using namespace llvm; using namespace llvm::dxil; -static ResourceClass toResourceClass(dxbc::DescriptorRangeType RangeType) { - using namespace dxbc; - switch (RangeType) { - case DescriptorRangeType::SRV: - return ResourceClass::SRV; - case DescriptorRangeType::UAV: - return ResourceClass::UAV; - case DescriptorRangeType::CBV: - return ResourceClass::CBuffer; - case DescriptorRangeType::Sampler: - return ResourceClass::Sampler; - } - llvm_unreachable("Unknown DescriptorRangeType"); -} - static ResourceClass toResourceClass(dxbc::RootParameterType Type) { using namespace dxbc; switch (Type) { @@ -210,11 +195,8 @@ static void validateRootSignature(Module &M, Range.NumDescriptors == ~0U ? Range.BaseShaderRegister : Range.BaseShaderRegister + Range.NumDescriptors - 1; - Builder.trackBinding( - toResourceClass( - static_cast(Range.RangeType)), - Range.RegisterSpace, Range.BaseShaderRegister, UpperBound, - &ParamInfo); + Builder.trackBinding(Range.RangeType, Range.RegisterSpace, + Range.BaseShaderRegister, UpperBound, &ParamInfo); } break; } diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp index a39da388cc5f7..819e7232ca10d 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp +++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp @@ -207,9 +207,7 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M, for (const mcdxbc::DescriptorRange &Range : Table) { OS << " - Range Type: " - << enumToStringRef(Range.RangeType, - dxbc::getDescriptorRangeTypes()) - << "\n" + << dxil::getResourceClassName(Range.RangeType) << "\n" << " Register Space: " << Range.RegisterSpace << "\n" << " Base Shader Register: " << Range.BaseShaderRegister << "\n" << " Num Descriptors: " << Range.NumDescriptors << "\n" From 5c23b7ed365d0ab6508bb411d5b03219dc0ef8fe Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Mon, 8 Sep 2025 12:39:59 -0700 Subject: [PATCH 26/29] adding assert --- llvm/include/llvm/BinaryFormat/DXContainer.h | 3 +++ 1 file changed, 3 insertions(+) diff --git a/llvm/include/llvm/BinaryFormat/DXContainer.h b/llvm/include/llvm/BinaryFormat/DXContainer.h index 8942e8bb1f7cc..111381a4c1955 100644 --- a/llvm/include/llvm/BinaryFormat/DXContainer.h +++ b/llvm/include/llvm/BinaryFormat/DXContainer.h @@ -210,6 +210,9 @@ inline bool isValidParameterType(uint32_t V) { } inline bool isValidRangeType(uint32_t V) { + static_assert(llvm::to_underlying(dxil::ResourceClass::Sampler) == 3, + "dxil::ResourceClass numeric values must match the Root " + "Signature values associated to each class."); return V <= llvm::to_underlying(dxil::ResourceClass::Sampler); } From 1c539f0ff62deba731c46ed3ea2decd317e995e6 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Mon, 8 Sep 2025 12:52:33 -0700 Subject: [PATCH 27/29] changing casting to use proper llvm-casting --- llvm/lib/MC/DXContainerRootSignature.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/lib/MC/DXContainerRootSignature.cpp b/llvm/lib/MC/DXContainerRootSignature.cpp index 393d886d35aa4..b9ebb7a9e789c 100644 --- a/llvm/lib/MC/DXContainerRootSignature.cpp +++ b/llvm/lib/MC/DXContainerRootSignature.cpp @@ -137,7 +137,7 @@ void RootSignatureDesc::write(raw_ostream &OS) const { llvm::endianness::little); rewriteOffsetToCurrentByte(BOS, writePlaceholder(BOS)); for (const auto &Range : Table) { - support::endian::write(BOS, (uint32_t)Range.RangeType, + support::endian::write(BOS, static_cast(Range.RangeType), llvm::endianness::little); support::endian::write(BOS, Range.NumDescriptors, llvm::endianness::little); From 44bfe7a16fdb0375ef19f4edc46c9bda5f100f49 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Mon, 8 Sep 2025 17:10:59 -0700 Subject: [PATCH 28/29] fixing tests --- llvm/include/llvm/ObjectYAML/DXContainerYAML.h | 4 ++-- llvm/include/llvm/Support/DXILABI.h | 1 + llvm/lib/ObjectYAML/DXContainerYAML.cpp | 15 +++++++++++---- ...re-DescriptorTable-AllValidFlagCombinations.ll | 6 +++--- ...ootSignature-Invalid-StaticSamplersOffset.yaml | 4 ++-- .../RootSignature-OptionalOffsets.yaml | 14 +++++++------- .../RootSignature-StaticSamplerOffset1.0.yaml | 14 +++++++------- .../RootSignature-StaticSamplerOffset1.1.yaml | 14 +++++++------- 8 files changed, 40 insertions(+), 32 deletions(-) diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h index 7fe3edcd2c057..62bfee7693db1 100644 --- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h +++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h @@ -92,7 +92,7 @@ struct RootDescriptorYaml { }; struct DescriptorRangeYaml { - dxbc::DescriptorRangeType RangeType; + dxil::ResourceClass RangeType; uint32_t NumDescriptors; uint32_t BaseShaderRegister; uint32_t RegisterSpace; @@ -320,7 +320,7 @@ LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::D3DSystemValue) LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::SigComponentType) LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::SigMinPrecision) LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::RootParameterType) -LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::DescriptorRangeType) +LLVM_YAML_DECLARE_ENUM_TRAITS(dxil::ResourceClass) LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::SamplerFilter) LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::StaticBorderColor) LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::TextureAddressMode) diff --git a/llvm/include/llvm/Support/DXILABI.h b/llvm/include/llvm/Support/DXILABI.h index b25b3632f6c3b..89d57075f1051 100644 --- a/llvm/include/llvm/Support/DXILABI.h +++ b/llvm/include/llvm/Support/DXILABI.h @@ -101,6 +101,7 @@ const unsigned MinWaveSize = 4; const unsigned MaxWaveSize = 128; LLVM_ABI StringRef getResourceClassName(ResourceClass RC); +LLVM_ABI StringRef getResourceClassNames(); } // namespace dxil } // namespace llvm diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index 3fe423e6159b9..22674b1ceb734 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -63,7 +63,7 @@ readDescriptorRanges(DXContainerYAML::RootParameterHeaderYaml &Header, if (!dxbc::isValidRangeType(R.RangeType)) return createStringError(std::errc::invalid_argument, "Invalid value for descriptor range type"); - NewR.RangeType = dxbc::DescriptorRangeType(R.RangeType); + NewR.RangeType = dxil::ResourceClass(R.RangeType); if constexpr (std::is_same_v) { // Set all flag fields for v2 #define DESCRIPTOR_RANGE_FLAG(Num, Enum, Flag) \ @@ -623,9 +623,16 @@ void ScalarEnumerationTraits::enumeration( IO.enumCase(Value, E.Name.str().c_str(), E.Value); } -void ScalarEnumerationTraits::enumeration( - IO &IO, dxbc::DescriptorRangeType &Value) { - for (const auto &E : dxbc::getDescriptorRangeTypes()) +void ScalarEnumerationTraits::enumeration( + IO &IO, dxil::ResourceClass &Value) { + const EnumEntry ResourceClasses[] = { + {"CBuffer", dxil::ResourceClass::CBuffer}, + {"SRV", dxil::ResourceClass::SRV}, + {"UAV", dxil::ResourceClass::UAV}, + {"Sampler", dxil::ResourceClass::Sampler}, + }; + + for (const auto &E : ResourceClasses) IO.enumCase(Value, E.Name.str().c_str(), E.Value); } diff --git a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-AllValidFlagCombinations.ll b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-AllValidFlagCombinations.ll index 5e89b765aad81..d6cb05b5d0dd9 100644 --- a/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-AllValidFlagCombinations.ll +++ b/llvm/test/CodeGen/DirectX/ContainerData/RootSignature-DescriptorTable-AllValidFlagCombinations.ll @@ -96,7 +96,7 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } ;DXC-NEXT: RegisterSpace: 6 ;DXC-NEXT: OffsetInDescriptorsFromTableStart: 5 ;DXC-NEXT: DESCRIPTORS_VOLATILE: true -;DXC-NEXT: - RangeType: CBV +;DXC-NEXT: - RangeType: CBuffer ;DXC-NEXT: NumDescriptors: 5 ;DXC-NEXT: BaseShaderRegister: 1 ;DXC-NEXT: RegisterSpace: 7 @@ -114,7 +114,7 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } ;DXC-NEXT: RegisterSpace: 9 ;DXC-NEXT: OffsetInDescriptorsFromTableStart: 5 ;DXC-NEXT: DATA_STATIC_WHILE_SET_AT_EXECUTE: true -;DXC-NEXT: - RangeType: CBV +;DXC-NEXT: - RangeType: CBuffer ;DXC-NEXT: NumDescriptors: 5 ;DXC-NEXT: BaseShaderRegister: 1 ;DXC-NEXT: RegisterSpace: 10 @@ -134,7 +134,7 @@ attributes #0 = { "hlsl.numthreads"="1,1,1" "hlsl.shader"="compute" } ;DXC-NEXT: RegisterSpace: 12 ;DXC-NEXT: OffsetInDescriptorsFromTableStart: 5 ;DXC-NEXT: DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS: true -;DXC-NEXT: - RangeType: CBV +;DXC-NEXT: - RangeType: CBuffer ;DXC-NEXT: NumDescriptors: 5 ;DXC-NEXT: BaseShaderRegister: 1 ;DXC-NEXT: RegisterSpace: 13 diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-Invalid-StaticSamplersOffset.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-Invalid-StaticSamplersOffset.yaml index e805526ea7c51..1322a4ef365ad 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-Invalid-StaticSamplersOffset.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-Invalid-StaticSamplersOffset.yaml @@ -21,8 +21,8 @@ Parts: NumStaticSamplers: 0 StaticSamplersOffset: 0 Parameters: - - ParameterType: 2 - ShaderVisibility: 3 + - ParameterType: SRV + ShaderVisibility: Domain Descriptor: ShaderRegister: 31 RegisterSpace: 32 diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-OptionalOffsets.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-OptionalOffsets.yaml index 88d7c632968be..00bc190c0903d 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-OptionalOffsets.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-OptionalOffsets.yaml @@ -31,24 +31,24 @@ Parts: NumRootParameters: 3 NumStaticSamplers: 0 Parameters: - - ParameterType: 1 # RootConstants - ShaderVisibility: 0 + - ParameterType: Constants32Bit + ShaderVisibility: All Constants: Num32BitValues: 16 ShaderRegister: 15 RegisterSpace: 14 - - ParameterType: 2 # SRV - ShaderVisibility: 0 + - ParameterType: SRV + ShaderVisibility: All Descriptor: ShaderRegister: 31 RegisterSpace: 32 DATA_STATIC_WHILE_SET_AT_EXECUTE: true - - ParameterType: 0 # Descriptor Table - ShaderVisibility: 0 + - ParameterType: DescriptorTable + ShaderVisibility: All Table: NumRanges: 1 Ranges: - - RangeType: 0 # CBV + - RangeType: CBuffer NumDescriptors: -1 BaseShaderRegister: 42 RegisterSpace: 43 diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplerOffset1.0.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplerOffset1.0.yaml index 347d8f3be1710..eb940865e7c66 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplerOffset1.0.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplerOffset1.0.yaml @@ -33,24 +33,24 @@ Parts: NumStaticSamplers: 0 StaticSamplersOffset: 108 Parameters: - - ParameterType: 1 # RootConstants - ShaderVisibility: 0 + - ParameterType: Constants32Bit + ShaderVisibility: All Constants: Num32BitValues: 16 ShaderRegister: 15 RegisterSpace: 14 - - ParameterType: 2 # SRV - ShaderVisibility: 0 + - ParameterType: CBV + ShaderVisibility: All Descriptor: ShaderRegister: 31 RegisterSpace: 32 DATA_STATIC_WHILE_SET_AT_EXECUTE: true - - ParameterType: 0 # Descriptor Table - ShaderVisibility: 0 + - ParameterType: DescriptorTable + ShaderVisibility: All Table: NumRanges: 1 Ranges: - - RangeType: 0 # CBV + - RangeType: CBuffer NumDescriptors: -1 BaseShaderRegister: 42 RegisterSpace: 43 diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplerOffset1.1.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplerOffset1.1.yaml index 8e03e1a8b29be..73e89c2dbe336 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplerOffset1.1.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-StaticSamplerOffset1.1.yaml @@ -33,24 +33,24 @@ Parts: NumStaticSamplers: 0 StaticSamplersOffset: 116 Parameters: - - ParameterType: 1 # RootConstants - ShaderVisibility: 0 + - ParameterType: Constants32Bit + ShaderVisibility: All Constants: Num32BitValues: 16 ShaderRegister: 15 RegisterSpace: 14 - - ParameterType: 2 # SRV - ShaderVisibility: 0 + - ParameterType: SRV + ShaderVisibility: All Descriptor: ShaderRegister: 31 RegisterSpace: 32 DATA_STATIC_WHILE_SET_AT_EXECUTE: true - - ParameterType: 0 # Descriptor Table - ShaderVisibility: 0 + - ParameterType: DescriptorTable + ShaderVisibility: All Table: NumRanges: 1 Ranges: - - RangeType: 0 # CBV + - RangeType: CBuffer NumDescriptors: -1 BaseShaderRegister: 42 RegisterSpace: 43 From 3ebaa2938ce7055b2958c178ffa986900d8da976 Mon Sep 17 00:00:00 2001 From: Joao Saffran Date: Thu, 11 Sep 2025 16:38:51 -0700 Subject: [PATCH 29/29] clean up --- llvm/include/llvm/Support/DXILABI.h | 2 -- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 20 +++++++++----------- 2 files changed, 9 insertions(+), 13 deletions(-) diff --git a/llvm/include/llvm/Support/DXILABI.h b/llvm/include/llvm/Support/DXILABI.h index f4320a2bb1abe..e6600c3406df5 100644 --- a/llvm/include/llvm/Support/DXILABI.h +++ b/llvm/include/llvm/Support/DXILABI.h @@ -102,8 +102,6 @@ const unsigned MinWaveSize = 4; const unsigned MaxWaveSize = 128; LLVM_ABI StringRef getResourceClassName(ResourceClass RC); -LLVM_ABI StringRef getResourceClassNames(); - } // namespace dxil } // namespace llvm diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index af7db8986133d..910383816f43b 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -274,9 +274,8 @@ Error DXContainerWriter::writeParts(raw_ostream &OS) { for (DXContainerYAML::RootParameterLocationYaml &L : P.RootSignature->Parameters.Locations) { - dxbc::RootParameterType Type = dxbc::RootParameterType(L.Header.Type); - dxbc::ShaderVisibility Visibility = - dxbc::ShaderVisibility(L.Header.Visibility); + const dxbc::RootParameterType Type = L.Header.Type; + const dxbc::ShaderVisibility Visibility = L.Header.Visibility; switch (Type) { case dxbc::RootParameterType::Constants32Bit: { @@ -330,20 +329,19 @@ Error DXContainerWriter::writeParts(raw_ostream &OS) { for (const auto &Param : P.RootSignature->samplers()) { mcdxbc::StaticSampler NewSampler; - NewSampler.Filter = dxbc::SamplerFilter(Param.Filter); - NewSampler.AddressU = dxbc::TextureAddressMode(Param.AddressU); - NewSampler.AddressV = dxbc::TextureAddressMode(Param.AddressV); - NewSampler.AddressW = dxbc::TextureAddressMode(Param.AddressW); + NewSampler.Filter = Param.Filter; + NewSampler.AddressU = Param.AddressU; + NewSampler.AddressV = Param.AddressV; + NewSampler.AddressW = Param.AddressW; NewSampler.MipLODBias = Param.MipLODBias; NewSampler.MaxAnisotropy = Param.MaxAnisotropy; - NewSampler.ComparisonFunc = dxbc::ComparisonFunc(Param.ComparisonFunc); - NewSampler.BorderColor = dxbc::StaticBorderColor(Param.BorderColor); + NewSampler.ComparisonFunc = Param.ComparisonFunc; + NewSampler.BorderColor = Param.BorderColor; NewSampler.MinLOD = Param.MinLOD; NewSampler.MaxLOD = Param.MaxLOD; NewSampler.ShaderRegister = Param.ShaderRegister; NewSampler.RegisterSpace = Param.RegisterSpace; - NewSampler.ShaderVisibility = - dxbc::ShaderVisibility(Param.ShaderVisibility); + NewSampler.ShaderVisibility = Param.ShaderVisibility; RS.StaticSamplers.push_back(NewSampler); }