From 0abacfcb1e5b0602cd5b535cd224768028337077 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Thu, 24 Apr 2025 21:54:56 +0000 Subject: [PATCH 01/31] adding support for Root Descriptors --- llvm/include/llvm/BinaryFormat/DXContainer.h | 28 ++++- .../BinaryFormat/DXContainerConstants.def | 15 +++ .../llvm/MC/DXContainerRootSignature.h | 4 +- llvm/include/llvm/Object/DXContainer.h | 47 +++++++- .../include/llvm/ObjectYAML/DXContainerYAML.h | 34 +++++- llvm/lib/MC/DXContainerRootSignature.cpp | 25 +++++ llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 17 +++ llvm/lib/ObjectYAML/DXContainerYAML.cpp | 53 ++++++++- .../RootSignature-Descriptor1.0.yaml | 45 ++++++++ .../RootSignature-Descriptor1.1.yaml | 47 ++++++++ .../RootSignature-MultipleParameters.yaml | 20 +++- llvm/unittests/Object/DXContainerTest.cpp | 91 ++++++++++++++++ .../ObjectYAML/DXContainerYAMLTest.cpp | 103 ++++++++++++++++++ 13 files changed, 514 insertions(+), 15 deletions(-) create mode 100644 llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.0.yaml create mode 100644 llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.1.yaml diff --git a/llvm/include/llvm/BinaryFormat/DXContainer.h b/llvm/include/llvm/BinaryFormat/DXContainer.h index 455657980bf40..439bf7b40f31b 100644 --- a/llvm/include/llvm/BinaryFormat/DXContainer.h +++ b/llvm/include/llvm/BinaryFormat/DXContainer.h @@ -158,6 +158,11 @@ enum class RootElementFlag : uint32_t { #include "DXContainerConstants.def" }; +#define ROOT_DESCRIPTOR_FLAG(Num, Val) Val = 1ull << Num, +enum class RootDescriptorFlag : uint32_t { +#include "DXContainerConstants.def" +}; + #define ROOT_PARAMETER(Val, Enum) Enum = Val, enum class RootParameterType : uint32_t { #include "DXContainerConstants.def" @@ -422,7 +427,6 @@ struct SignatureElement { static_assert(sizeof(SignatureElement) == 4 * sizeof(uint32_t), "PSV Signature elements must fit in 16 bytes."); - } // namespace v0 namespace v1 { @@ -463,7 +467,6 @@ struct RuntimeInfo : public v0::RuntimeInfo { sys::swapByteOrder(GeomData.MaxVertexCount); } }; - } // namespace v1 namespace v2 { @@ -580,7 +583,28 @@ struct ProgramSignatureElement { static_assert(sizeof(ProgramSignatureElement) == 32, "ProgramSignatureElement is misaligned"); +namespace RST0 { +namespace v0 { +struct RootDescriptor { + uint32_t ShaderRegister; + uint32_t RegisterSpace; + void swapBytes() { + sys::swapByteOrder(ShaderRegister); + sys::swapByteOrder(RegisterSpace); + } +}; +} // namespace v0 +namespace v1 { +struct RootDescriptor : public v0::RootDescriptor { + uint32_t Flags; + void swapBytes() { + v0::RootDescriptor::swapBytes(); + sys::swapByteOrder(Flags); + } +}; +} // namespace v1 +} // namespace RST0 // following dx12 naming // https://learn.microsoft.com/en-us/windows/win32/api/d3d12/ns-d3d12-d3d12_root_constants struct RootConstants { diff --git a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def index 590ded5e8c899..bd9bd760547dc 100644 --- a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def +++ b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def @@ -72,9 +72,24 @@ ROOT_ELEMENT_FLAG(11, SamplerHeapDirectlyIndexed) #undef ROOT_ELEMENT_FLAG #endif // ROOT_ELEMENT_FLAG + +// ROOT_ELEMENT_FLAG(bit offset for the flag, name). +#ifdef ROOT_DESCRIPTOR_FLAG + +ROOT_DESCRIPTOR_FLAG(0, NONE) +ROOT_DESCRIPTOR_FLAG(1, DATA_VOLATILE) +ROOT_DESCRIPTOR_FLAG(2, DATA_STATIC_WHILE_SET_AT_EXECUTE) +ROOT_DESCRIPTOR_FLAG(3, DATA_STATIC) +#undef ROOT_DESCRIPTOR_FLAG +#endif // ROOT_DESCRIPTOR_FLAG + + #ifdef ROOT_PARAMETER ROOT_PARAMETER(1, Constants32Bit) +ROOT_PARAMETER(2, CBV) +ROOT_PARAMETER(3, SRV) +ROOT_PARAMETER(4, UAV) #undef ROOT_PARAMETER #endif // ROOT_PARAMETER diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index fee799249b255..ac062a375818c 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -19,13 +19,15 @@ struct RootParameter { dxbc::RootParameterHeader Header; union { dxbc::RootConstants Constants; + dxbc::RST0::v0::RootDescriptor Descriptor_V10; + dxbc::RST0::v1::RootDescriptor Descriptor_V11; }; }; struct RootSignatureDesc { uint32_t Version = 2U; uint32_t Flags = 0U; - uint32_t RootParameterOffset = 0U; + uint32_t RootParameterOffset = 24U; uint32_t StaticSamplersOffset = 0u; uint32_t NumStaticSamplers = 0u; SmallVector Parameters; diff --git a/llvm/include/llvm/Object/DXContainer.h b/llvm/include/llvm/Object/DXContainer.h index e8287ce078365..ba261a9e42aea 100644 --- a/llvm/include/llvm/Object/DXContainer.h +++ b/llvm/include/llvm/Object/DXContainer.h @@ -120,9 +120,10 @@ template struct ViewArray { namespace DirectX { struct RootParameterView { const dxbc::RootParameterHeader &Header; + uint32_t Version; StringRef ParamData; - RootParameterView(const dxbc::RootParameterHeader &H, StringRef P) - : Header(H), ParamData(P) {} + RootParameterView(uint32_t V, const dxbc::RootParameterHeader &H, StringRef P) + : Header(H), Version(V), ParamData(P) {} template Expected readParameter() { T Struct; @@ -149,6 +150,38 @@ struct RootConstantView : RootParameterView { } }; +struct RootDescriptorView_V1_0 : RootParameterView { + static bool classof(const RootParameterView *V) { + return (V->Version == 1 && + (V->Header.ParameterType == + llvm::to_underlying(dxbc::RootParameterType::CBV) || + V->Header.ParameterType == + llvm::to_underlying(dxbc::RootParameterType::SRV) || + V->Header.ParameterType == + llvm::to_underlying(dxbc::RootParameterType::UAV))); + } + + llvm::Expected read() { + return readParameter(); + } +}; + +struct RootDescriptorView_V1_1 : RootParameterView { + static bool classof(const RootParameterView *V) { + return (V->Version == 2 && + (V->Header.ParameterType == + llvm::to_underlying(dxbc::RootParameterType::CBV) || + V->Header.ParameterType == + llvm::to_underlying(dxbc::RootParameterType::SRV) || + V->Header.ParameterType == + llvm::to_underlying(dxbc::RootParameterType::UAV))); + } + + llvm::Expected read() { + return readParameter(); + } +}; + static Error parseFailed(const Twine &Msg) { return make_error(Msg.str(), object_error::parse_failed); } @@ -192,6 +225,14 @@ class RootSignature { case dxbc::RootParameterType::Constants32Bit: DataSize = sizeof(dxbc::RootConstants); break; + case dxbc::RootParameterType::CBV: + case dxbc::RootParameterType::SRV: + case dxbc::RootParameterType::UAV: + if (Version == 1) + DataSize = sizeof(dxbc::RST0::v0::RootDescriptor); + else + DataSize = sizeof(dxbc::RST0::v1::RootDescriptor); + break; } size_t EndOfSectionByte = getNumStaticSamplers() == 0 ? PartData.size() @@ -201,7 +242,7 @@ class RootSignature { return parseFailed("Reading structure out of file bounds"); StringRef Buff = PartData.substr(Header.ParameterOffset, DataSize); - RootParameterView View = RootParameterView(Header, Buff); + RootParameterView View = RootParameterView(Version, Header, Buff); return View; } }; diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h index 393bba9c79bf8..e86a869da99bc 100644 --- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h +++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h @@ -73,24 +73,50 @@ struct ShaderHash { std::vector Digest; }; -#define ROOT_ELEMENT_FLAG(Num, Val) bool Val = false; - struct RootConstantsYaml { uint32_t ShaderRegister; uint32_t RegisterSpace; uint32_t Num32BitValues; }; +#define ROOT_DESCRIPTOR_FLAG(Num, Val) bool Val = false; +struct RootDescriptorYaml { + RootDescriptorYaml() = default; + + uint32_t ShaderRegister; + uint32_t RegisterSpace; + + uint32_t getEncodedFlags() const; + +#include "llvm/BinaryFormat/DXContainerConstants.def" +}; + struct RootParameterYamlDesc { uint32_t Type; uint32_t Visibility; uint32_t Offset; + RootParameterYamlDesc(){}; + RootParameterYamlDesc(uint32_t T) : Type(T) { + switch (T) { + + case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): + Constants = RootConstantsYaml(); + break; + case llvm::to_underlying(dxbc::RootParameterType::CBV): + case llvm::to_underlying(dxbc::RootParameterType::SRV): + case llvm::to_underlying(dxbc::RootParameterType::UAV): + Descriptor = RootDescriptorYaml(); + break; + } + } union { RootConstantsYaml Constants; + RootDescriptorYaml Descriptor; }; }; +#define ROOT_ELEMENT_FLAG(Num, Val) bool Val = false; struct RootSignatureYamlDesc { RootSignatureYamlDesc() = default; @@ -298,6 +324,10 @@ template <> struct MappingTraits { static void mapping(IO &IO, llvm::DXContainerYAML::RootConstantsYaml &C); }; +template <> struct MappingTraits { + static void mapping(IO &IO, llvm::DXContainerYAML::RootDescriptorYaml &D); +}; + } // namespace yaml } // namespace llvm diff --git a/llvm/lib/MC/DXContainerRootSignature.cpp b/llvm/lib/MC/DXContainerRootSignature.cpp index c2731d95c955e..a5210f4768f16 100644 --- a/llvm/lib/MC/DXContainerRootSignature.cpp +++ b/llvm/lib/MC/DXContainerRootSignature.cpp @@ -37,6 +37,15 @@ size_t RootSignatureDesc::getSize() const { case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): Size += sizeof(dxbc::RootConstants); break; + case llvm::to_underlying(dxbc::RootParameterType::CBV): + case llvm::to_underlying(dxbc::RootParameterType::SRV): + case llvm::to_underlying(dxbc::RootParameterType::UAV): + if (Version == 1) + Size += sizeof(dxbc::RST0::v0::RootDescriptor); + else + Size += sizeof(dxbc::RST0::v1::RootDescriptor); + + break; } } return Size; @@ -80,6 +89,22 @@ void RootSignatureDesc::write(raw_ostream &OS) const { support::endian::write(BOS, P.Constants.Num32BitValues, 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): + if (Version == 1) { + support::endian::write(BOS, P.Descriptor_V10.ShaderRegister, + llvm::endianness::little); + support::endian::write(BOS, P.Descriptor_V10.RegisterSpace, + llvm::endianness::little); + } else { + support::endian::write(BOS, P.Descriptor_V11.ShaderRegister, + llvm::endianness::little); + support::endian::write(BOS, P.Descriptor_V11.RegisterSpace, + llvm::endianness::little); + support::endian::write(BOS, P.Descriptor_V11.Flags, + llvm::endianness::little); + } } } assert(Storage.size() == getSize()); diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index 86e24eae4abc6..be0e52fef04f5 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -283,6 +283,23 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { NewParam.Constants.Num32BitValues = Param.Constants.Num32BitValues; NewParam.Constants.RegisterSpace = Param.Constants.RegisterSpace; NewParam.Constants.ShaderRegister = Param.Constants.ShaderRegister; + break; + case llvm::to_underlying(dxbc::RootParameterType::SRV): + case llvm::to_underlying(dxbc::RootParameterType::UAV): + case llvm::to_underlying(dxbc::RootParameterType::CBV): + if (RS.Version == 1) { + NewParam.Descriptor_V10.RegisterSpace = + Param.Descriptor.RegisterSpace; + NewParam.Descriptor_V10.ShaderRegister = + Param.Descriptor.ShaderRegister; + } else { + NewParam.Descriptor_V11.RegisterSpace = + Param.Descriptor.RegisterSpace; + NewParam.Descriptor_V11.ShaderRegister = + Param.Descriptor.ShaderRegister; + NewParam.Descriptor_V11.Flags = Param.Descriptor.getEncodedFlags(); + } + break; } diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index 59914fe30082d..ef86da85989e6 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -15,6 +15,7 @@ #include "llvm/ADT/STLForwardCompat.h" #include "llvm/ADT/ScopeExit.h" #include "llvm/BinaryFormat/DXContainer.h" +#include "llvm/Object/DXContainer.h" #include "llvm/Support/Error.h" #include "llvm/Support/ScopedPrinter.h" #include @@ -48,13 +49,12 @@ DXContainerYAML::RootSignatureYamlDesc::create( uint32_t Flags = Data.getFlags(); for (const dxbc::RootParameterHeader &PH : Data.param_headers()) { - RootParameterYamlDesc NewP; - NewP.Offset = PH.ParameterOffset; - if (!dxbc::isValidParameterType(PH.ParameterType)) return createStringError(std::errc::invalid_argument, "Invalid value for parameter type"); + RootParameterYamlDesc NewP(PH.ParameterType); + NewP.Offset = PH.ParameterOffset; NewP.Type = PH.ParameterType; if (!dxbc::isValidShaderVisibility(PH.ShaderVisibility)) @@ -79,7 +79,32 @@ DXContainerYAML::RootSignatureYamlDesc::create( NewP.Constants.Num32BitValues = Constants.Num32BitValues; NewP.Constants.ShaderRegister = Constants.ShaderRegister; NewP.Constants.RegisterSpace = Constants.RegisterSpace; + } else if (auto *RDV = dyn_cast( + &ParamView)) { + llvm::Expected DescriptorOrErr = + RDV->read(); + if (Error E = DescriptorOrErr.takeError()) + return std::move(E); + auto Descriptor = *DescriptorOrErr; + + NewP.Descriptor.ShaderRegister = Descriptor.ShaderRegister; + NewP.Descriptor.RegisterSpace = Descriptor.RegisterSpace; + } else if (auto *RDV = dyn_cast( + &ParamView)) { + llvm::Expected DescriptorOrErr = + RDV->read(); + if (Error E = DescriptorOrErr.takeError()) + return std::move(E); + auto Descriptor = *DescriptorOrErr; + NewP.Descriptor.ShaderRegister = Descriptor.ShaderRegister; + NewP.Descriptor.RegisterSpace = Descriptor.RegisterSpace; +#define ROOT_DESCRIPTOR_FLAG(Num, Val) \ + NewP.Descriptor.Val = \ + (Descriptor.Flags & \ + llvm::to_underlying(dxbc::RootDescriptorFlag::Val)) > 0; +#include "llvm/BinaryFormat/DXContainerConstants.def" } + RootSigDesc.Parameters.push_back(NewP); } #define ROOT_ELEMENT_FLAG(Num, Val) \ @@ -89,6 +114,15 @@ DXContainerYAML::RootSignatureYamlDesc::create( return RootSigDesc; } +uint32_t DXContainerYAML::RootDescriptorYaml::getEncodedFlags() const { + uint64_t Flag = 0; +#define ROOT_DESCRIPTOR_FLAG(Num, Val) \ + if (Val) \ + Flag |= (uint32_t)dxbc::RootDescriptorFlag::Val; +#include "llvm/BinaryFormat/DXContainerConstants.def" + return Flag; +} + uint32_t DXContainerYAML::RootSignatureYamlDesc::getEncodedFlags() { uint64_t Flag = 0; #define ROOT_ELEMENT_FLAG(Num, Val) \ @@ -276,6 +310,14 @@ void MappingTraits::mapping( IO.mapRequired("ShaderRegister", C.ShaderRegister); } +void MappingTraits::mapping( + IO &IO, llvm::DXContainerYAML::RootDescriptorYaml &D) { + IO.mapRequired("RegisterSpace", D.RegisterSpace); + IO.mapRequired("ShaderRegister", D.ShaderRegister); +#define ROOT_DESCRIPTOR_FLAG(Num, Val) IO.mapOptional(#Val, D.Val, false); +#include "llvm/BinaryFormat/DXContainerConstants.def" +} + void MappingTraits::mapping( IO &IO, llvm::DXContainerYAML::RootParameterYamlDesc &P) { IO.mapRequired("ParameterType", P.Type); @@ -285,6 +327,11 @@ void MappingTraits::mapping( case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): IO.mapRequired("Constants", P.Constants); break; + case llvm::to_underlying(dxbc::RootParameterType::CBV): + case llvm::to_underlying(dxbc::RootParameterType::SRV): + case llvm::to_underlying(dxbc::RootParameterType::UAV): + IO.mapRequired("Descriptor", P.Descriptor); + break; } } diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.0.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.0.yaml new file mode 100644 index 0000000000000..46cdf416ffcae --- /dev/null +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.0.yaml @@ -0,0 +1,45 @@ +# RUN: yaml2obj %s | obj2yaml | FileCheck %s + +--- !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: 96 + RootSignature: + Version: 1 + NumRootParameters: 1 + RootParametersOffset: 24 + NumStaticSamplers: 0 + StaticSamplersOffset: 60 + Parameters: + - ParameterType: 2 # SRV + ShaderVisibility: 3 # Domain + Descriptor: + ShaderRegister: 31 + RegisterSpace: 32 + AllowInputAssemblerInputLayout: true + DenyGeometryShaderRootAccess: true + +# CHECK: - Name: RTS0 +# CHECK-NEXT: Size: 96 +# CHECK-NEXT: RootSignature: +# CHECK-NEXT: Version: 1 +# CHECK-NEXT: NumRootParameters: 1 +# CHECK-NEXT: RootParametersOffset: 24 +# CHECK-NEXT: NumStaticSamplers: 0 +# CHECK-NEXT: StaticSamplersOffset: 60 +# CHECK-NEXT: Parameters: +# CHECK-NEXT: - ParameterType: 2 +# CHECK-NEXT: ShaderVisibility: 3 +# CHECK-NEXT: Descriptor: +# CHECK-NEXT: RegisterSpace: 32 +# CHECK-NEXT: ShaderRegister: 31 +# CHECK-NEXT: AllowInputAssemblerInputLayout: true +# CHECK-NEXT: DenyGeometryShaderRootAccess: true diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.1.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.1.yaml new file mode 100644 index 0000000000000..64e01c6836e32 --- /dev/null +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.1.yaml @@ -0,0 +1,47 @@ +# RUN: yaml2obj %s | obj2yaml | FileCheck %s + +--- !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: 89 + RootSignature: + Version: 2 + NumRootParameters: 1 + RootParametersOffset: 24 + NumStaticSamplers: 0 + StaticSamplersOffset: 60 + Parameters: + - ParameterType: 2 # SRV + ShaderVisibility: 3 # Domain + Descriptor: + ShaderRegister: 31 + RegisterSpace: 32 + DATA_STATIC_WHILE_SET_AT_EXECUTE: true + AllowInputAssemblerInputLayout: true + DenyGeometryShaderRootAccess: true + +# CHECK: - Name: RTS0 +# CHECK-NEXT: Size: 89 +# CHECK-NEXT: RootSignature: +# CHECK-NEXT: Version: 2 +# CHECK-NEXT: NumRootParameters: 1 +# CHECK-NEXT: RootParametersOffset: 24 +# CHECK-NEXT: NumStaticSamplers: 0 +# CHECK-NEXT: StaticSamplersOffset: 60 +# CHECK-NEXT: Parameters: +# CHECK-NEXT: - ParameterType: 2 +# CHECK-NEXT: ShaderVisibility: 3 +# CHECK-NEXT: Descriptor: +# CHECK-NEXT: RegisterSpace: 32 +# CHECK-NEXT: ShaderRegister: 31 +# CHECK-NEXT: DATA_STATIC_WHILE_SET_AT_EXECUTE: true +# CHECK-NEXT: AllowInputAssemblerInputLayout: true +# CHECK-NEXT: DenyGeometryShaderRootAccess: true diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml index f366d71714359..debb459c3944e 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml @@ -11,10 +11,10 @@ Header: PartOffsets: [ 60 ] Parts: - Name: RTS0 - Size: 80 + Size: 96 RootSignature: Version: 2 - NumRootParameters: 2 + NumRootParameters: 3 RootParametersOffset: 24 NumStaticSamplers: 0 StaticSamplersOffset: 60 @@ -31,14 +31,20 @@ Parts: Num32BitValues: 21 ShaderRegister: 22 RegisterSpace: 23 + - ParameterType: 2 # SRV + ShaderVisibility: 3 # Domain + Descriptor: + ShaderRegister: 31 + RegisterSpace: 32 + DATA_STATIC_WHILE_SET_AT_EXECUTE: true AllowInputAssemblerInputLayout: true DenyGeometryShaderRootAccess: true # CHECK: - Name: RTS0 -# CHECK-NEXT: Size: 80 +# CHECK-NEXT: Size: 96 # CHECK-NEXT: RootSignature: # CHECK-NEXT: Version: 2 -# CHECK-NEXT: NumRootParameters: 2 +# CHECK-NEXT: NumRootParameters: 3 # CHECK-NEXT: RootParametersOffset: 24 # CHECK-NEXT: NumStaticSamplers: 0 # CHECK-NEXT: StaticSamplersOffset: 60 @@ -55,5 +61,11 @@ Parts: # CHECK-NEXT: Num32BitValues: 21 # CHECK-NEXT: RegisterSpace: 23 # CHECK-NEXT: ShaderRegister: 22 +# CHECK-NEXT: - ParameterType: 2 +# CHECK-NEXT: ShaderVisibility: 3 +# CHECK-NEXT: Descriptor: +# CHECK-NEXT: RegisterSpace: 32 +# CHECK-NEXT: ShaderRegister: 31 +# CHECK-NEXT: DATA_STATIC_WHILE_SET_AT_EXECUTE: true # CHECK-NEXT: AllowInputAssemblerInputLayout: true # CHECK-NEXT: DenyGeometryShaderRootAccess: true diff --git a/llvm/unittests/Object/DXContainerTest.cpp b/llvm/unittests/Object/DXContainerTest.cpp index 62ef8e385373f..ed43f6deaa951 100644 --- a/llvm/unittests/Object/DXContainerTest.cpp +++ b/llvm/unittests/Object/DXContainerTest.cpp @@ -959,3 +959,94 @@ TEST(RootSignature, ParseRootConstant) { ASSERT_EQ(Constants->Num32BitValues, 16u); } } + +TEST(RootSignature, ParseRootDescriptor) { + { + uint8_t Buffer[] = { + 0x44, 0x58, 0x42, 0x43, 0x32, 0x9a, 0x53, 0xd8, 0xec, 0xbe, 0x35, 0x6f, + 0x05, 0x39, 0xe1, 0xfe, 0x31, 0x20, 0xf0, 0xc1, 0x01, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, + 0x52, 0x54, 0x53, 0x30, 0x59, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3c, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00}; + DXContainer C = + llvm::cantFail(DXContainer::create(getMemoryBuffer<133>(Buffer))); + + auto MaybeRS = C.getRootSignature(); + ASSERT_TRUE(MaybeRS.has_value()); + const auto &RS = MaybeRS.value(); + ASSERT_EQ(RS.getVersion(), 1u); + ASSERT_EQ(RS.getNumParameters(), 1u); + ASSERT_EQ(RS.getRootParametersOffset(), 24u); + ASSERT_EQ(RS.getNumStaticSamplers(), 0u); + ASSERT_EQ(RS.getStaticSamplersOffset(), 60u); + ASSERT_EQ(RS.getFlags(), 17u); + + auto RootParam = *RS.param_headers().begin(); + ASSERT_EQ((unsigned)RootParam.ParameterType, 2u); + ASSERT_EQ((unsigned)RootParam.ShaderVisibility, 3u); + auto ParamView = RS.getParameter(RootParam); + ASSERT_THAT_ERROR(ParamView.takeError(), Succeeded()); + + DirectX::RootDescriptorView_V1_0 *RootDescriptorView = + dyn_cast(&*ParamView); + ASSERT_TRUE(RootDescriptorView != nullptr); + auto Descriptor = RootDescriptorView->read(); + + ASSERT_THAT_ERROR(Descriptor.takeError(), Succeeded()); + + ASSERT_EQ(Descriptor->ShaderRegister, 31u); + ASSERT_EQ(Descriptor->RegisterSpace, 32u); + } + + { + uint8_t Buffer[] = { + 0x44, 0x58, 0x42, 0x43, 0x32, 0x9a, 0x53, 0xd8, 0xec, 0xbe, 0x35, 0x6f, + 0x05, 0x39, 0xe1, 0xfe, 0x31, 0x20, 0xf0, 0xc1, 0x01, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, + 0x52, 0x54, 0x53, 0x30, 0x59, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3c, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00}; + DXContainer C = + llvm::cantFail(DXContainer::create(getMemoryBuffer<133>(Buffer))); + + auto MaybeRS = C.getRootSignature(); + ASSERT_TRUE(MaybeRS.has_value()); + const auto &RS = MaybeRS.value(); + ASSERT_EQ(RS.getVersion(), 2u); + ASSERT_EQ(RS.getNumParameters(), 1u); + ASSERT_EQ(RS.getRootParametersOffset(), 24u); + ASSERT_EQ(RS.getNumStaticSamplers(), 0u); + ASSERT_EQ(RS.getStaticSamplersOffset(), 60u); + ASSERT_EQ(RS.getFlags(), 17u); + + auto RootParam = *RS.param_headers().begin(); + ASSERT_EQ((unsigned)RootParam.ParameterType, 2u); + ASSERT_EQ((unsigned)RootParam.ShaderVisibility, 3u); + auto ParamView = RS.getParameter(RootParam); + ASSERT_THAT_ERROR(ParamView.takeError(), Succeeded()); + + DirectX::RootDescriptorView_V1_1 *RootDescriptorView = + dyn_cast(&*ParamView); + ASSERT_TRUE(RootDescriptorView != nullptr); + auto Descriptor = RootDescriptorView->read(); + + ASSERT_THAT_ERROR(Descriptor.takeError(), Succeeded()); + + ASSERT_EQ(Descriptor->ShaderRegister, 31u); + ASSERT_EQ(Descriptor->RegisterSpace, 32u); + ASSERT_EQ(Descriptor->Flags, 4u); + } +} diff --git a/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp b/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp index 61390049bc0df..b6a5cee24b29d 100644 --- a/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp +++ b/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp @@ -251,3 +251,106 @@ TEST(RootSignature, ParseRootConstants) { EXPECT_EQ(Storage.size(), 133u); EXPECT_TRUE(memcmp(Buffer, Storage.data(), 133u) == 0); } + +TEST(RootSignature, ParseRootDescriptorsV10) { + SmallString<128> Storage; + + // First read a fully explicit yaml with all sizes and offsets provided + ASSERT_TRUE(convert(Storage, R"(--- !dxcontainer + Header: + Hash: [ 0x32, 0x9A, 0x53, 0xD8, 0xEC, 0xBE, 0x35, 0x6F, 0x5, + 0x39, 0xE1, 0xFE, 0x31, 0x20, 0xF0, 0xC1 ] + Version: + Major: 1 + Minor: 0 + FileSize: 133 + PartCount: 1 + PartOffsets: [ 36 ] + Parts: + - Name: RTS0 + Size: 89 + RootSignature: + Version: 1 + NumRootParameters: 1 + RootParametersOffset: 24 + NumStaticSamplers: 0 + StaticSamplersOffset: 60 + Parameters: + - ParameterType: 2 # SRV + ShaderVisibility: 3 # Domain + Descriptor: + ShaderRegister: 31 + RegisterSpace: 32 + AllowInputAssemblerInputLayout: true + DenyGeometryShaderRootAccess: true + )")); + + uint8_t Buffer[] = { + 0x44, 0x58, 0x42, 0x43, 0x32, 0x9a, 0x53, 0xd8, 0xec, 0xbe, 0x35, 0x6f, + 0x05, 0x39, 0xe1, 0xfe, 0x31, 0x20, 0xf0, 0xc1, 0x01, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, + 0x52, 0x54, 0x53, 0x30, 0x59, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3c, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00}; + + EXPECT_EQ(Storage.size(), 133u); + EXPECT_TRUE(memcmp(Buffer, Storage.data(), 133u) == 0); +} + +TEST(RootSignature, ParseRootDescriptorsV11) { + SmallString<128> Storage; + + // First read a fully explicit yaml with all sizes and offsets provided + ASSERT_TRUE(convert(Storage, R"(--- !dxcontainer + Header: + Hash: [ 0x32, 0x9A, 0x53, 0xD8, 0xEC, 0xBE, 0x35, 0x6F, 0x5, + 0x39, 0xE1, 0xFE, 0x31, 0x20, 0xF0, 0xC1 ] + Version: + Major: 1 + Minor: 0 + FileSize: 133 + PartCount: 1 + PartOffsets: [ 36 ] + Parts: + - Name: RTS0 + Size: 89 + RootSignature: + Version: 2 + NumRootParameters: 1 + RootParametersOffset: 24 + NumStaticSamplers: 0 + StaticSamplersOffset: 60 + Parameters: + - ParameterType: 2 # SRV + ShaderVisibility: 3 # Domain + Descriptor: + ShaderRegister: 31 + RegisterSpace: 32 + DATA_STATIC_WHILE_SET_AT_EXECUTE: true + AllowInputAssemblerInputLayout: true + DenyGeometryShaderRootAccess: true + )")); + + uint8_t Buffer[] = { + 0x44, 0x58, 0x42, 0x43, 0x32, 0x9a, 0x53, 0xd8, 0xec, 0xbe, 0x35, 0x6f, + 0x05, 0x39, 0xe1, 0xfe, 0x31, 0x20, 0xf0, 0xc1, 0x01, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, + 0x52, 0x54, 0x53, 0x30, 0x59, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3c, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x1f, 0x00, 0x00, 0x00, + 0x20, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00}; + + EXPECT_EQ(Storage.size(), 133u); + EXPECT_TRUE(memcmp(Buffer, Storage.data(), 133u) == 0); +} From 8b8c02a6107b2b01bbc9cc9d84504d71e2726523 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Thu, 24 Apr 2025 22:34:06 +0000 Subject: [PATCH 02/31] clean up --- llvm/include/llvm/BinaryFormat/DXContainer.h | 2 ++ llvm/include/llvm/MC/DXContainerRootSignature.h | 2 +- llvm/include/llvm/ObjectYAML/DXContainerYAML.h | 2 +- llvm/lib/ObjectYAML/DXContainerYAML.cpp | 1 - 4 files changed, 4 insertions(+), 3 deletions(-) diff --git a/llvm/include/llvm/BinaryFormat/DXContainer.h b/llvm/include/llvm/BinaryFormat/DXContainer.h index 439bf7b40f31b..3dbcfa82f3d7c 100644 --- a/llvm/include/llvm/BinaryFormat/DXContainer.h +++ b/llvm/include/llvm/BinaryFormat/DXContainer.h @@ -427,6 +427,7 @@ struct SignatureElement { static_assert(sizeof(SignatureElement) == 4 * sizeof(uint32_t), "PSV Signature elements must fit in 16 bytes."); + } // namespace v0 namespace v1 { @@ -467,6 +468,7 @@ struct RuntimeInfo : public v0::RuntimeInfo { sys::swapByteOrder(GeomData.MaxVertexCount); } }; + } // namespace v1 namespace v2 { diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index ac062a375818c..1f421d726bf38 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -27,7 +27,7 @@ struct RootSignatureDesc { uint32_t Version = 2U; uint32_t Flags = 0U; - uint32_t RootParameterOffset = 24U; + uint32_t RootParameterOffset = 0U; uint32_t StaticSamplersOffset = 0u; uint32_t NumStaticSamplers = 0u; SmallVector Parameters; diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h index e86a869da99bc..c54c995acd263 100644 --- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h +++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h @@ -95,7 +95,7 @@ struct RootParameterYamlDesc { uint32_t Type; uint32_t Visibility; uint32_t Offset; - RootParameterYamlDesc(){}; + RootParameterYamlDesc() {}; RootParameterYamlDesc(uint32_t T) : Type(T) { switch (T) { diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index ef86da85989e6..e49712852d612 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -15,7 +15,6 @@ #include "llvm/ADT/STLForwardCompat.h" #include "llvm/ADT/ScopeExit.h" #include "llvm/BinaryFormat/DXContainer.h" -#include "llvm/Object/DXContainer.h" #include "llvm/Support/Error.h" #include "llvm/Support/ScopedPrinter.h" #include From 7ac964196fc9195165dc1128d0f889f6ff1a93b4 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Fri, 25 Apr 2025 22:28:48 +0000 Subject: [PATCH 03/31] addressing comments --- llvm/include/llvm/Object/DXContainer.h | 50 +++++++------------ .../include/llvm/ObjectYAML/DXContainerYAML.h | 6 +-- llvm/lib/ObjectYAML/DXContainerYAML.cpp | 17 ++----- llvm/unittests/Object/DXContainerTest.cpp | 12 ++--- 4 files changed, 32 insertions(+), 53 deletions(-) diff --git a/llvm/include/llvm/Object/DXContainer.h b/llvm/include/llvm/Object/DXContainer.h index ba261a9e42aea..e359d85f08bec 100644 --- a/llvm/include/llvm/Object/DXContainer.h +++ b/llvm/include/llvm/Object/DXContainer.h @@ -120,18 +120,20 @@ template struct ViewArray { namespace DirectX { struct RootParameterView { const dxbc::RootParameterHeader &Header; - uint32_t Version; StringRef ParamData; RootParameterView(uint32_t V, const dxbc::RootParameterHeader &H, StringRef P) - : Header(H), Version(V), ParamData(P) {} + : Header(H), ParamData(P) {} - template Expected readParameter() { - T Struct; - if (sizeof(T) != ParamData.size()) + template Expected readParameter() { + assert(sizeof(VersionT) <= sizeof(T) && + "Parameter of higher version must inherit all previous version data " + "members"); + if (sizeof(VersionT) != ParamData.size()) return make_error( "Reading structure out of file bounds", object_error::parse_failed); - memcpy(&Struct, ParamData.data(), sizeof(T)); + T Struct; + memcpy(&Struct, ParamData.data(), sizeof(VersionT)); // DXContainer is always little endian if (sys::IsBigEndianHost) Struct.swapBytes(); @@ -150,34 +152,20 @@ struct RootConstantView : RootParameterView { } }; -struct RootDescriptorView_V1_0 : RootParameterView { - static bool classof(const RootParameterView *V) { - return (V->Version == 1 && - (V->Header.ParameterType == - llvm::to_underlying(dxbc::RootParameterType::CBV) || - V->Header.ParameterType == - llvm::to_underlying(dxbc::RootParameterType::SRV) || - V->Header.ParameterType == - llvm::to_underlying(dxbc::RootParameterType::UAV))); - } - - llvm::Expected read() { - return readParameter(); - } -}; - -struct RootDescriptorView_V1_1 : RootParameterView { +struct RootDescriptorView : RootParameterView { static bool classof(const RootParameterView *V) { - return (V->Version == 2 && - (V->Header.ParameterType == - llvm::to_underlying(dxbc::RootParameterType::CBV) || - V->Header.ParameterType == - llvm::to_underlying(dxbc::RootParameterType::SRV) || - V->Header.ParameterType == - llvm::to_underlying(dxbc::RootParameterType::UAV))); + return (V->Header.ParameterType == + llvm::to_underlying(dxbc::RootParameterType::CBV) || + V->Header.ParameterType == + llvm::to_underlying(dxbc::RootParameterType::SRV) || + V->Header.ParameterType == + llvm::to_underlying(dxbc::RootParameterType::UAV)); } - llvm::Expected read() { + llvm::Expected read(uint32_t Version) { + if (Version == 1) + return readParameter(); return readParameter(); } }; diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h index c54c995acd263..8bb9da7884bed 100644 --- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h +++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h @@ -79,7 +79,6 @@ struct RootConstantsYaml { uint32_t Num32BitValues; }; -#define ROOT_DESCRIPTOR_FLAG(Num, Val) bool Val = false; struct RootDescriptorYaml { RootDescriptorYaml() = default; @@ -88,6 +87,7 @@ struct RootDescriptorYaml { uint32_t getEncodedFlags() const; +#define ROOT_DESCRIPTOR_FLAG(Num, Val) bool Val = false; #include "llvm/BinaryFormat/DXContainerConstants.def" }; @@ -95,7 +95,7 @@ struct RootParameterYamlDesc { uint32_t Type; uint32_t Visibility; uint32_t Offset; - RootParameterYamlDesc() {}; + RootParameterYamlDesc(){}; RootParameterYamlDesc(uint32_t T) : Type(T) { switch (T) { @@ -116,7 +116,6 @@ struct RootParameterYamlDesc { }; }; -#define ROOT_ELEMENT_FLAG(Num, Val) bool Val = false; struct RootSignatureYamlDesc { RootSignatureYamlDesc() = default; @@ -137,6 +136,7 @@ struct RootSignatureYamlDesc { static llvm::Expected create(const object::DirectX::RootSignature &Data); +#define ROOT_ELEMENT_FLAG(Num, Val) bool Val = false; #include "llvm/BinaryFormat/DXContainerConstants.def" }; diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index e49712852d612..c9d2084226b7a 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -15,6 +15,7 @@ #include "llvm/ADT/STLForwardCompat.h" #include "llvm/ADT/ScopeExit.h" #include "llvm/BinaryFormat/DXContainer.h" +#include "llvm/Object/DXContainer.h" #include "llvm/Support/Error.h" #include "llvm/Support/ScopedPrinter.h" #include @@ -78,20 +79,10 @@ DXContainerYAML::RootSignatureYamlDesc::create( NewP.Constants.Num32BitValues = Constants.Num32BitValues; NewP.Constants.ShaderRegister = Constants.ShaderRegister; NewP.Constants.RegisterSpace = Constants.RegisterSpace; - } else if (auto *RDV = dyn_cast( - &ParamView)) { - llvm::Expected DescriptorOrErr = - RDV->read(); - if (Error E = DescriptorOrErr.takeError()) - return std::move(E); - auto Descriptor = *DescriptorOrErr; - - NewP.Descriptor.ShaderRegister = Descriptor.ShaderRegister; - NewP.Descriptor.RegisterSpace = Descriptor.RegisterSpace; - } else if (auto *RDV = dyn_cast( - &ParamView)) { + } else if (auto *RDV = + dyn_cast(&ParamView)) { llvm::Expected DescriptorOrErr = - RDV->read(); + RDV->read(Data.getVersion()); if (Error E = DescriptorOrErr.takeError()) return std::move(E); auto Descriptor = *DescriptorOrErr; diff --git a/llvm/unittests/Object/DXContainerTest.cpp b/llvm/unittests/Object/DXContainerTest.cpp index ed43f6deaa951..72f860a5039ff 100644 --- a/llvm/unittests/Object/DXContainerTest.cpp +++ b/llvm/unittests/Object/DXContainerTest.cpp @@ -994,10 +994,10 @@ TEST(RootSignature, ParseRootDescriptor) { auto ParamView = RS.getParameter(RootParam); ASSERT_THAT_ERROR(ParamView.takeError(), Succeeded()); - DirectX::RootDescriptorView_V1_0 *RootDescriptorView = - dyn_cast(&*ParamView); + DirectX::RootDescriptorView *RootDescriptorView = + dyn_cast(&*ParamView); ASSERT_TRUE(RootDescriptorView != nullptr); - auto Descriptor = RootDescriptorView->read(); + auto Descriptor = RootDescriptorView->read(RS.getVersion()); ASSERT_THAT_ERROR(Descriptor.takeError(), Succeeded()); @@ -1038,10 +1038,10 @@ TEST(RootSignature, ParseRootDescriptor) { auto ParamView = RS.getParameter(RootParam); ASSERT_THAT_ERROR(ParamView.takeError(), Succeeded()); - DirectX::RootDescriptorView_V1_1 *RootDescriptorView = - dyn_cast(&*ParamView); + DirectX::RootDescriptorView *RootDescriptorView = + dyn_cast(&*ParamView); ASSERT_TRUE(RootDescriptorView != nullptr); - auto Descriptor = RootDescriptorView->read(); + auto Descriptor = RootDescriptorView->read(RS.getVersion()); ASSERT_THAT_ERROR(Descriptor.takeError(), Succeeded()); From c1054581e1a9973408991e863a5e7eec51e74f04 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Sat, 26 Apr 2025 01:45:29 +0000 Subject: [PATCH 04/31] formating --- llvm/include/llvm/ObjectYAML/DXContainerYAML.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h index 8bb9da7884bed..d9d43b40db299 100644 --- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h +++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h @@ -95,7 +95,7 @@ struct RootParameterYamlDesc { uint32_t Type; uint32_t Visibility; uint32_t Offset; - RootParameterYamlDesc(){}; + RootParameterYamlDesc() {}; RootParameterYamlDesc(uint32_t T) : Type(T) { switch (T) { From efe76aafee2c07e5e1df69daa404d48682ed5434 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Sat, 26 Apr 2025 02:02:53 +0000 Subject: [PATCH 05/31] try fix test --- llvm/lib/ObjectYAML/DXContainerYAML.cpp | 7 +++++-- .../DXContainer/RootSignature-Descriptor1.0.yaml | 2 +- 2 files changed, 6 insertions(+), 3 deletions(-) diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index c9d2084226b7a..18c1299d4b867 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -39,8 +39,9 @@ DXContainerYAML::RootSignatureYamlDesc::create( const object::DirectX::RootSignature &Data) { RootSignatureYamlDesc RootSigDesc; + uint32_t Version = Data.getVersion(); - RootSigDesc.Version = Data.getVersion(); + RootSigDesc.Version = Version; RootSigDesc.NumStaticSamplers = Data.getNumStaticSamplers(); RootSigDesc.StaticSamplersOffset = Data.getStaticSamplersOffset(); RootSigDesc.NumRootParameters = Data.getNumRootParameters(); @@ -82,17 +83,19 @@ DXContainerYAML::RootSignatureYamlDesc::create( } else if (auto *RDV = dyn_cast(&ParamView)) { llvm::Expected DescriptorOrErr = - RDV->read(Data.getVersion()); + RDV->read(Version); if (Error E = DescriptorOrErr.takeError()) return std::move(E); auto Descriptor = *DescriptorOrErr; NewP.Descriptor.ShaderRegister = Descriptor.ShaderRegister; NewP.Descriptor.RegisterSpace = Descriptor.RegisterSpace; + if (Version > 1) { #define ROOT_DESCRIPTOR_FLAG(Num, Val) \ NewP.Descriptor.Val = \ (Descriptor.Flags & \ llvm::to_underlying(dxbc::RootDescriptorFlag::Val)) > 0; #include "llvm/BinaryFormat/DXContainerConstants.def" + } } RootSigDesc.Parameters.push_back(NewP); diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.0.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.0.yaml index 46cdf416ffcae..889eccf74001f 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.0.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-Descriptor1.0.yaml @@ -27,7 +27,7 @@ Parts: AllowInputAssemblerInputLayout: true DenyGeometryShaderRootAccess: true -# CHECK: - Name: RTS0 +# CHECK: - Name: RTS0 # CHECK-NEXT: Size: 96 # CHECK-NEXT: RootSignature: # CHECK-NEXT: Version: 1 From a928e9d9a12fd1114e2c1732094ad1f32ebc196c Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Sat, 26 Apr 2025 06:33:13 +0000 Subject: [PATCH 06/31] addressing comments --- .../include/llvm/MC/DXContainerRootSignature.h | 3 +-- llvm/include/llvm/ObjectYAML/DXContainerYAML.h | 2 +- llvm/lib/MC/DXContainerRootSignature.cpp | 18 ++++++------------ llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 17 ++++------------- 4 files changed, 12 insertions(+), 28 deletions(-) diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index 1f421d726bf38..44e26c81eedc1 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -19,8 +19,7 @@ struct RootParameter { dxbc::RootParameterHeader Header; union { dxbc::RootConstants Constants; - dxbc::RST0::v0::RootDescriptor Descriptor_V10; - dxbc::RST0::v1::RootDescriptor Descriptor_V11; + dxbc::RST0::v1::RootDescriptor Descriptor; }; }; struct RootSignatureDesc { diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h index d9d43b40db299..8bb9da7884bed 100644 --- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h +++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h @@ -95,7 +95,7 @@ struct RootParameterYamlDesc { uint32_t Type; uint32_t Visibility; uint32_t Offset; - RootParameterYamlDesc() {}; + RootParameterYamlDesc(){}; RootParameterYamlDesc(uint32_t T) : Type(T) { switch (T) { diff --git a/llvm/lib/MC/DXContainerRootSignature.cpp b/llvm/lib/MC/DXContainerRootSignature.cpp index a5210f4768f16..2693cb9943d5e 100644 --- a/llvm/lib/MC/DXContainerRootSignature.cpp +++ b/llvm/lib/MC/DXContainerRootSignature.cpp @@ -92,19 +92,13 @@ void RootSignatureDesc::write(raw_ostream &OS) const { case llvm::to_underlying(dxbc::RootParameterType::CBV): case llvm::to_underlying(dxbc::RootParameterType::SRV): case llvm::to_underlying(dxbc::RootParameterType::UAV): - if (Version == 1) { - support::endian::write(BOS, P.Descriptor_V10.ShaderRegister, - llvm::endianness::little); - support::endian::write(BOS, P.Descriptor_V10.RegisterSpace, - llvm::endianness::little); - } else { - support::endian::write(BOS, P.Descriptor_V11.ShaderRegister, - llvm::endianness::little); - support::endian::write(BOS, P.Descriptor_V11.RegisterSpace, - llvm::endianness::little); - support::endian::write(BOS, P.Descriptor_V11.Flags, + support::endian::write(BOS, P.Descriptor.ShaderRegister, + llvm::endianness::little); + support::endian::write(BOS, P.Descriptor.RegisterSpace, + llvm::endianness::little); + if (Version > 1) + support::endian::write(BOS, P.Descriptor.Flags, llvm::endianness::little); - } } } assert(Storage.size() == getSize()); diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index be0e52fef04f5..239ee9e3de9b1 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -287,19 +287,10 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { case llvm::to_underlying(dxbc::RootParameterType::SRV): case llvm::to_underlying(dxbc::RootParameterType::UAV): case llvm::to_underlying(dxbc::RootParameterType::CBV): - if (RS.Version == 1) { - NewParam.Descriptor_V10.RegisterSpace = - Param.Descriptor.RegisterSpace; - NewParam.Descriptor_V10.ShaderRegister = - Param.Descriptor.ShaderRegister; - } else { - NewParam.Descriptor_V11.RegisterSpace = - Param.Descriptor.RegisterSpace; - NewParam.Descriptor_V11.ShaderRegister = - Param.Descriptor.ShaderRegister; - NewParam.Descriptor_V11.Flags = Param.Descriptor.getEncodedFlags(); - } - + NewParam.Descriptor.RegisterSpace = Param.Descriptor.RegisterSpace; + NewParam.Descriptor.ShaderRegister = Param.Descriptor.ShaderRegister; + if (P.RootSignature->Version > 1) + NewParam.Descriptor.Flags = Param.Descriptor.getEncodedFlags(); break; } From a38f10b51ac930be4bb5a5718d204d9f2d0c0396 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Fri, 25 Apr 2025 05:09:08 +0000 Subject: [PATCH 07/31] refactoring mcdxbc struct to store root parameters out of order --- .../llvm/MC/DXContainerRootSignature.h | 137 +++++++++++++++++- llvm/lib/MC/DXContainerRootSignature.cpp | 68 ++++----- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 26 ++-- llvm/lib/Target/DirectX/DXILRootSignature.cpp | 45 +++--- 4 files changed, 201 insertions(+), 75 deletions(-) diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index 44e26c81eedc1..e1f4abbcebf8f 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -6,21 +6,146 @@ // //===----------------------------------------------------------------------===// +#include "llvm/ADT/STLForwardCompat.h" #include "llvm/BinaryFormat/DXContainer.h" +#include "llvm/Support/ErrorHandling.h" +#include #include -#include +#include namespace llvm { class raw_ostream; namespace mcdxbc { +struct RootParameterHeader : public dxbc::RootParameterHeader { + + size_t Location; + + RootParameterHeader() = default; + + RootParameterHeader(dxbc::RootParameterHeader H, size_t L) + : dxbc::RootParameterHeader(H), Location(L) {} +}; + +using RootDescriptor = std::variant; +using ParametersView = + std::variant; struct RootParameter { - dxbc::RootParameterHeader Header; - union { - dxbc::RootConstants Constants; - dxbc::RST0::v1::RootDescriptor Descriptor; + SmallVector Headers; + + SmallVector Constants; + SmallVector Descriptors; + + void addHeader(dxbc::RootParameterHeader H, size_t L) { + Headers.push_back(RootParameterHeader(H, L)); + } + + void addParameter(dxbc::RootParameterHeader H, dxbc::RootConstants C) { + addHeader(H, Constants.size()); + Constants.push_back(C); + } + + void addParameter(dxbc::RootParameterHeader H, + dxbc::RST0::v0::RootDescriptor D) { + addHeader(H, Descriptors.size()); + Descriptors.push_back(D); + } + + void addParameter(dxbc::RootParameterHeader H, + dxbc::RST0::v1::RootDescriptor D) { + addHeader(H, Descriptors.size()); + Descriptors.push_back(D); + } + + ParametersView get(const RootParameterHeader &H) const { + switch (H.ParameterType) { + case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): + return Constants[H.Location]; + case llvm::to_underlying(dxbc::RootParameterType::CBV): + case llvm::to_underlying(dxbc::RootParameterType::SRV): + case llvm::to_underlying(dxbc::RootParameterType::UAV): + RootDescriptor VersionedParam = Descriptors[H.Location]; + if (std::holds_alternative( + VersionedParam)) + return std::get(VersionedParam); + return std::get(VersionedParam); + } + + llvm_unreachable("Unimplemented parameter type"); + } + + struct iterator { + const RootParameter &Parameters; + SmallVector::const_iterator Current; + + // Changed parameter type to match member variable (removed const) + iterator(const RootParameter &P, + SmallVector::const_iterator C) + : Parameters(P), Current(C) {} + iterator(const iterator &) = default; + + ParametersView operator*() { + ParametersView Val; + switch (Current->ParameterType) { + case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): + Val = Parameters.Constants[Current->Location]; + break; + + case llvm::to_underlying(dxbc::RootParameterType::CBV): + case llvm::to_underlying(dxbc::RootParameterType::SRV): + case llvm::to_underlying(dxbc::RootParameterType::UAV): + RootDescriptor VersionedParam = + Parameters.Descriptors[Current->Location]; + if (std::holds_alternative( + VersionedParam)) + Val = std::get(VersionedParam); + else + Val = std::get(VersionedParam); + break; + } + return Val; + } + + iterator operator++() { + Current++; + return *this; + } + + iterator operator++(int) { + iterator Tmp = *this; + ++*this; + return Tmp; + } + + iterator operator--() { + Current--; + return *this; + } + + iterator operator--(int) { + iterator Tmp = *this; + --*this; + return Tmp; + } + + bool operator==(const iterator I) { return I.Current == Current; } + bool operator!=(const iterator I) { return !(*this == I); } }; + + iterator begin() const { return iterator(*this, Headers.begin()); } + + iterator end() const { return iterator(*this, Headers.end()); } + + size_t size() const { return Headers.size(); } + + bool isEmpty() const { return Headers.empty(); } + + llvm::iterator_range getAll() const { + return llvm::make_range(begin(), end()); + } }; struct RootSignatureDesc { @@ -29,7 +154,7 @@ struct RootSignatureDesc { uint32_t RootParameterOffset = 0U; uint32_t StaticSamplersOffset = 0u; uint32_t NumStaticSamplers = 0u; - SmallVector Parameters; + mcdxbc::RootParameter Parameters; void write(raw_ostream &OS) const; diff --git a/llvm/lib/MC/DXContainerRootSignature.cpp b/llvm/lib/MC/DXContainerRootSignature.cpp index 2693cb9943d5e..18242ccc1e935 100644 --- a/llvm/lib/MC/DXContainerRootSignature.cpp +++ b/llvm/lib/MC/DXContainerRootSignature.cpp @@ -8,7 +8,9 @@ #include "llvm/MC/DXContainerRootSignature.h" #include "llvm/ADT/SmallString.h" +#include "llvm/BinaryFormat/DXContainer.h" #include "llvm/Support/EndianStream.h" +#include using namespace llvm; using namespace llvm::mcdxbc; @@ -32,22 +34,15 @@ size_t RootSignatureDesc::getSize() const { size_t Size = sizeof(dxbc::RootSignatureHeader) + Parameters.size() * sizeof(dxbc::RootParameterHeader); - for (const mcdxbc::RootParameter &P : Parameters) { - switch (P.Header.ParameterType) { - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): - Size += sizeof(dxbc::RootConstants); - break; - case llvm::to_underlying(dxbc::RootParameterType::CBV): - case llvm::to_underlying(dxbc::RootParameterType::SRV): - case llvm::to_underlying(dxbc::RootParameterType::UAV): - if (Version == 1) - Size += sizeof(dxbc::RST0::v0::RootDescriptor); - else - Size += sizeof(dxbc::RST0::v1::RootDescriptor); - - break; - } + for (const auto &P : Parameters) { + std::visit( + [&Size](auto &Value) -> void { + using T = std::decay_t; + Size += sizeof(T); + }, + P); } + return Size; } @@ -66,39 +61,40 @@ void RootSignatureDesc::write(raw_ostream &OS) const { support::endian::write(BOS, Flags, llvm::endianness::little); SmallVector ParamsOffsets; - for (const mcdxbc::RootParameter &P : Parameters) { - support::endian::write(BOS, P.Header.ParameterType, - llvm::endianness::little); - support::endian::write(BOS, P.Header.ShaderVisibility, - llvm::endianness::little); + for (const auto &P : Parameters.Headers) { + support::endian::write(BOS, P.ParameterType, llvm::endianness::little); + support::endian::write(BOS, P.ShaderVisibility, llvm::endianness::little); ParamsOffsets.push_back(writePlaceholder(BOS)); } assert(NumParameters == ParamsOffsets.size()); - for (size_t I = 0; I < NumParameters; ++I) { + auto P = Parameters.begin(); + for (size_t I = 0; I < NumParameters; ++I, P++) { rewriteOffsetToCurrentByte(BOS, ParamsOffsets[I]); - const mcdxbc::RootParameter &P = Parameters[I]; - switch (P.Header.ParameterType) { - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): - support::endian::write(BOS, P.Constants.ShaderRegister, + if (std::holds_alternative(*P)) { + auto Constants = std::get(*P); + support::endian::write(BOS, Constants.ShaderRegister, llvm::endianness::little); - support::endian::write(BOS, P.Constants.RegisterSpace, + support::endian::write(BOS, Constants.RegisterSpace, llvm::endianness::little); - support::endian::write(BOS, P.Constants.Num32BitValues, + support::endian::write(BOS, Constants.Num32BitValues, 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): - support::endian::write(BOS, P.Descriptor.ShaderRegister, + } else if (std::holds_alternative(*P)) { + auto Descriptor = std::get(*P); + support::endian::write(BOS, Descriptor.ShaderRegister, + llvm::endianness::little); + support::endian::write(BOS, Descriptor.RegisterSpace, + llvm::endianness::little); + } else if (std::holds_alternative(*P)) { + auto Descriptor = std::get(*P); + + support::endian::write(BOS, Descriptor.ShaderRegister, llvm::endianness::little); - support::endian::write(BOS, P.Descriptor.RegisterSpace, + support::endian::write(BOS, Descriptor.RegisterSpace, llvm::endianness::little); - if (Version > 1) - support::endian::write(BOS, P.Descriptor.Flags, - llvm::endianness::little); + support::endian::write(BOS, Descriptor.Flags, llvm::endianness::little); } } assert(Storage.size() == getSize()); diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index 239ee9e3de9b1..3e58c2cd7497b 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -274,27 +274,31 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { RS.StaticSamplersOffset = P.RootSignature->StaticSamplersOffset; for (const auto &Param : P.RootSignature->Parameters) { - mcdxbc::RootParameter NewParam; - NewParam.Header = dxbc::RootParameterHeader{ - Param.Type, Param.Visibility, Param.Offset}; + auto Header = dxbc::RootParameterHeader{Param.Type, Param.Visibility, + Param.Offset}; switch (Param.Type) { case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): - NewParam.Constants.Num32BitValues = Param.Constants.Num32BitValues; - NewParam.Constants.RegisterSpace = Param.Constants.RegisterSpace; - NewParam.Constants.ShaderRegister = Param.Constants.ShaderRegister; + dxbc::RootConstants Constants; + Constants.Num32BitValues = Param.Constants.Num32BitValues; + Constants.RegisterSpace = Param.Constants.RegisterSpace; + Constants.ShaderRegister = Param.Constants.ShaderRegister; + RS.Parameters.addParameter(Header, Constants); break; case llvm::to_underlying(dxbc::RootParameterType::SRV): case llvm::to_underlying(dxbc::RootParameterType::UAV): case llvm::to_underlying(dxbc::RootParameterType::CBV): - NewParam.Descriptor.RegisterSpace = Param.Descriptor.RegisterSpace; - NewParam.Descriptor.ShaderRegister = Param.Descriptor.ShaderRegister; + dxbc::RST0::v1::RootDescriptor Descriptor; + Descriptor.RegisterSpace = Param.Descriptor.RegisterSpace; + Descriptor.ShaderRegister = Param.Descriptor.ShaderRegister; if (P.RootSignature->Version > 1) - NewParam.Descriptor.Flags = Param.Descriptor.getEncodedFlags(); + Descriptor.Flags = Param.Descriptor.getEncodedFlags(); + RS.Parameters.addParameter(Header, Descriptor); break; + default: + // Handling invalid parameter type edge case + RS.Parameters.addHeader(Header, -1); } - - RS.Parameters.push_back(NewParam); } RS.write(OS); diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp index ef299c17baf76..a2141aa1364ad 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp +++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp @@ -30,6 +30,7 @@ #include #include #include +#include using namespace llvm; using namespace llvm::dxil; @@ -75,31 +76,32 @@ static bool parseRootConstants(LLVMContext *Ctx, mcdxbc::RootSignatureDesc &RSD, if (RootConstantNode->getNumOperands() != 5) return reportError(Ctx, "Invalid format for RootConstants Element"); - mcdxbc::RootParameter NewParameter; - NewParameter.Header.ParameterType = + dxbc::RootParameterHeader Header; + Header.ParameterType = llvm::to_underlying(dxbc::RootParameterType::Constants32Bit); if (std::optional Val = extractMdIntValue(RootConstantNode, 1)) - NewParameter.Header.ShaderVisibility = *Val; + Header.ShaderVisibility = *Val; else return reportError(Ctx, "Invalid value for ShaderVisibility"); + dxbc::RootConstants Constants; if (std::optional Val = extractMdIntValue(RootConstantNode, 2)) - NewParameter.Constants.ShaderRegister = *Val; + Constants.ShaderRegister = *Val; else return reportError(Ctx, "Invalid value for ShaderRegister"); if (std::optional Val = extractMdIntValue(RootConstantNode, 3)) - NewParameter.Constants.RegisterSpace = *Val; + Constants.RegisterSpace = *Val; else return reportError(Ctx, "Invalid value for RegisterSpace"); if (std::optional Val = extractMdIntValue(RootConstantNode, 4)) - NewParameter.Constants.Num32BitValues = *Val; + Constants.Num32BitValues = *Val; else return reportError(Ctx, "Invalid value for Num32BitValues"); - RSD.Parameters.push_back(NewParameter); + RSD.Parameters.addParameter(Header, Constants); return false; } @@ -164,12 +166,11 @@ static bool validate(LLVMContext *Ctx, const mcdxbc::RootSignatureDesc &RSD) { return reportValueError(Ctx, "RootFlags", RSD.Flags); } - for (const mcdxbc::RootParameter &P : RSD.Parameters) { - if (!dxbc::isValidShaderVisibility(P.Header.ShaderVisibility)) - return reportValueError(Ctx, "ShaderVisibility", - P.Header.ShaderVisibility); + for (const mcdxbc::RootParameterHeader &Header : RSD.Parameters.Headers) { + if (!dxbc::isValidShaderVisibility(Header.ShaderVisibility)) + return reportValueError(Ctx, "ShaderVisibility", Header.ShaderVisibility); - assert(dxbc::isValidParameterType(P.Header.ParameterType) && + assert(dxbc::isValidParameterType(Header.ParameterType) && "Invalid value for ParameterType"); } @@ -289,20 +290,20 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M, << "\n"; OS << indent(Space) << "NumParameters: " << RS.Parameters.size() << "\n"; Space++; - for (auto const &P : RS.Parameters) { - OS << indent(Space) << "- Parameter Type: " << P.Header.ParameterType + for (auto const &Header : RS.Parameters.Headers) { + OS << indent(Space) << "- Parameter Type: " << Header.ParameterType << "\n"; OS << indent(Space + 2) - << "Shader Visibility: " << P.Header.ShaderVisibility << "\n"; - switch (P.Header.ParameterType) { - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): + << "Shader Visibility: " << Header.ShaderVisibility << "\n"; + mcdxbc::ParametersView P = RS.Parameters.get(Header); + if (std::holds_alternative(P)) { + auto Constants = std::get(P); + OS << indent(Space + 2) << "Register Space: " << Constants.RegisterSpace + << "\n"; OS << indent(Space + 2) - << "Register Space: " << P.Constants.RegisterSpace << "\n"; + << "Shader Register: " << Constants.ShaderRegister << "\n"; OS << indent(Space + 2) - << "Shader Register: " << P.Constants.ShaderRegister << "\n"; - OS << indent(Space + 2) - << "Num 32 Bit Values: " << P.Constants.Num32BitValues << "\n"; - break; + << "Num 32 Bit Values: " << Constants.Num32BitValues << "\n"; } } Space--; From 9a7c359fd5ce3621647e35f4656b0ae5e46abf2e Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Mon, 28 Apr 2025 18:12:28 +0000 Subject: [PATCH 08/31] changing name --- .../llvm/MC/DXContainerRootSignature.h | 111 +++++------------- llvm/lib/MC/DXContainerRootSignature.cpp | 27 +++-- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 19 +-- llvm/lib/Target/DirectX/DXILRootSignature.cpp | 29 +++-- 4 files changed, 74 insertions(+), 112 deletions(-) diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index e1f4abbcebf8f..2ac79f4c454d8 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -11,6 +11,7 @@ #include "llvm/Support/ErrorHandling.h" #include #include +#include #include namespace llvm { @@ -18,14 +19,14 @@ namespace llvm { class raw_ostream; namespace mcdxbc { -struct RootParameterHeader : public dxbc::RootParameterHeader { - +struct RootParameterInfo { + dxbc::RootParameterHeader Header; size_t Location; - RootParameterHeader() = default; + RootParameterInfo() = default; - RootParameterHeader(dxbc::RootParameterHeader H, size_t L) - : dxbc::RootParameterHeader(H), Location(L) {} + RootParameterInfo(dxbc::RootParameterHeader H, size_t L) + : Header(H), Location(L) {} }; using RootDescriptor = std::variant; -struct RootParameter { - SmallVector Headers; +struct RootParametersContainer { + SmallVector ParametersInfo; SmallVector Constants; SmallVector Descriptors; - void addHeader(dxbc::RootParameterHeader H, size_t L) { - Headers.push_back(RootParameterHeader(H, L)); + void addInfo(dxbc::RootParameterHeader H, size_t L) { + ParametersInfo.push_back(RootParameterInfo(H, L)); } void addParameter(dxbc::RootParameterHeader H, dxbc::RootConstants C) { - addHeader(H, Constants.size()); + addInfo(H, Constants.size()); Constants.push_back(C); } void addParameter(dxbc::RootParameterHeader H, dxbc::RST0::v0::RootDescriptor D) { - addHeader(H, Descriptors.size()); + addInfo(H, Descriptors.size()); Descriptors.push_back(D); } void addParameter(dxbc::RootParameterHeader H, dxbc::RST0::v1::RootDescriptor D) { - addHeader(H, Descriptors.size()); + addInfo(H, Descriptors.size()); Descriptors.push_back(D); } - ParametersView get(const RootParameterHeader &H) const { - switch (H.ParameterType) { + std::optional getParameter(const RootParameterInfo *H) const { + switch (H->Header.ParameterType) { case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): - return Constants[H.Location]; + return Constants[H->Location]; case llvm::to_underlying(dxbc::RootParameterType::CBV): case llvm::to_underlying(dxbc::RootParameterType::SRV): case llvm::to_underlying(dxbc::RootParameterType::UAV): - RootDescriptor VersionedParam = Descriptors[H.Location]; + RootDescriptor VersionedParam = Descriptors[H->Location]; if (std::holds_alternative( VersionedParam)) return std::get(VersionedParam); return std::get(VersionedParam); } - llvm_unreachable("Unimplemented parameter type"); + return std::nullopt; } - struct iterator { - const RootParameter &Parameters; - SmallVector::const_iterator Current; - - // Changed parameter type to match member variable (removed const) - iterator(const RootParameter &P, - SmallVector::const_iterator C) - : Parameters(P), Current(C) {} - iterator(const iterator &) = default; - - ParametersView operator*() { - ParametersView Val; - switch (Current->ParameterType) { - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): - Val = Parameters.Constants[Current->Location]; - break; - - case llvm::to_underlying(dxbc::RootParameterType::CBV): - case llvm::to_underlying(dxbc::RootParameterType::SRV): - case llvm::to_underlying(dxbc::RootParameterType::UAV): - RootDescriptor VersionedParam = - Parameters.Descriptors[Current->Location]; - if (std::holds_alternative( - VersionedParam)) - Val = std::get(VersionedParam); - else - Val = std::get(VersionedParam); - break; - } - return Val; - } - - iterator operator++() { - Current++; - return *this; - } - - iterator operator++(int) { - iterator Tmp = *this; - ++*this; - return Tmp; - } - - iterator operator--() { - Current--; - return *this; - } - - iterator operator--(int) { - iterator Tmp = *this; - --*this; - return Tmp; - } - - bool operator==(const iterator I) { return I.Current == Current; } - bool operator!=(const iterator I) { return !(*this == I); } - }; - - iterator begin() const { return iterator(*this, Headers.begin()); } + size_t size() const { return ParametersInfo.size(); } - iterator end() const { return iterator(*this, Headers.end()); } - - size_t size() const { return Headers.size(); } - - bool isEmpty() const { return Headers.empty(); } + SmallVector::const_iterator begin() const { + return ParametersInfo.begin(); + } + SmallVector::const_iterator end() const { + return ParametersInfo.end(); + } - llvm::iterator_range getAll() const { + llvm::iterator_range::const_iterator> + getInfo() const { return llvm::make_range(begin(), end()); } }; @@ -154,7 +99,7 @@ struct RootSignatureDesc { uint32_t RootParameterOffset = 0U; uint32_t StaticSamplersOffset = 0u; uint32_t NumStaticSamplers = 0u; - mcdxbc::RootParameter Parameters; + mcdxbc::RootParametersContainer ParametersContainer; void write(raw_ostream &OS) const; diff --git a/llvm/lib/MC/DXContainerRootSignature.cpp b/llvm/lib/MC/DXContainerRootSignature.cpp index 18242ccc1e935..6cc8a9167bf40 100644 --- a/llvm/lib/MC/DXContainerRootSignature.cpp +++ b/llvm/lib/MC/DXContainerRootSignature.cpp @@ -32,15 +32,18 @@ static void rewriteOffsetToCurrentByte(raw_svector_ostream &Stream, size_t RootSignatureDesc::getSize() const { size_t Size = sizeof(dxbc::RootSignatureHeader) + - Parameters.size() * sizeof(dxbc::RootParameterHeader); + ParametersContainer.size() * sizeof(dxbc::RootParameterHeader); - for (const auto &P : Parameters) { + for (const auto &I : ParametersContainer) { + std::optional P = ParametersContainer.getParameter(&I); + if (!P) + continue; std::visit( [&Size](auto &Value) -> void { using T = std::decay_t; Size += sizeof(T); }, - P); + *P); } return Size; @@ -51,7 +54,7 @@ void RootSignatureDesc::write(raw_ostream &OS) const { raw_svector_ostream BOS(Storage); BOS.reserveExtraSpace(getSize()); - const uint32_t NumParameters = Parameters.size(); + const uint32_t NumParameters = ParametersContainer.size(); support::endian::write(BOS, Version, llvm::endianness::little); support::endian::write(BOS, NumParameters, llvm::endianness::little); @@ -61,18 +64,22 @@ void RootSignatureDesc::write(raw_ostream &OS) const { support::endian::write(BOS, Flags, llvm::endianness::little); SmallVector ParamsOffsets; - for (const auto &P : Parameters.Headers) { - support::endian::write(BOS, P.ParameterType, llvm::endianness::little); - support::endian::write(BOS, P.ShaderVisibility, llvm::endianness::little); + for (const auto &P : ParametersContainer) { + support::endian::write(BOS, P.Header.ParameterType, + llvm::endianness::little); + support::endian::write(BOS, P.Header.ShaderVisibility, + llvm::endianness::little); ParamsOffsets.push_back(writePlaceholder(BOS)); } assert(NumParameters == ParamsOffsets.size()); - auto P = Parameters.begin(); - for (size_t I = 0; I < NumParameters; ++I, P++) { + const RootParameterInfo *H = ParametersContainer.begin(); + for (size_t I = 0; I < NumParameters; ++I, H++) { rewriteOffsetToCurrentByte(BOS, ParamsOffsets[I]); - + auto P = ParametersContainer.getParameter(H); + if (!P) + continue; if (std::holds_alternative(*P)) { auto Constants = std::get(*P); support::endian::write(BOS, Constants.ShaderRegister, diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index 3e58c2cd7497b..381fe41d8b01c 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -283,21 +283,26 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { Constants.Num32BitValues = Param.Constants.Num32BitValues; Constants.RegisterSpace = Param.Constants.RegisterSpace; Constants.ShaderRegister = Param.Constants.ShaderRegister; - RS.Parameters.addParameter(Header, Constants); + RS.ParametersContainer.addParameter(Header, Constants); break; case llvm::to_underlying(dxbc::RootParameterType::SRV): case llvm::to_underlying(dxbc::RootParameterType::UAV): case llvm::to_underlying(dxbc::RootParameterType::CBV): - dxbc::RST0::v1::RootDescriptor Descriptor; - Descriptor.RegisterSpace = Param.Descriptor.RegisterSpace; - Descriptor.ShaderRegister = Param.Descriptor.ShaderRegister; - if (P.RootSignature->Version > 1) + if (RS.Version == 1) { + dxbc::RST0::v0::RootDescriptor Descriptor; + Descriptor.RegisterSpace = Param.Descriptor.RegisterSpace; + Descriptor.ShaderRegister = Param.Descriptor.ShaderRegister; + RS.ParametersContainer.addParameter(Header, Descriptor); + } else { + dxbc::RST0::v1::RootDescriptor Descriptor; + Descriptor.RegisterSpace = Param.Descriptor.RegisterSpace; + Descriptor.ShaderRegister = Param.Descriptor.ShaderRegister; Descriptor.Flags = Param.Descriptor.getEncodedFlags(); - RS.Parameters.addParameter(Header, Descriptor); + RS.ParametersContainer.addParameter(Header, Descriptor); break; default: // Handling invalid parameter type edge case - RS.Parameters.addHeader(Header, -1); + RS.ParametersContainer.addInfo(Header, -1); } } diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp index a2141aa1364ad..40dcff3999b8f 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp +++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp @@ -101,7 +101,7 @@ static bool parseRootConstants(LLVMContext *Ctx, mcdxbc::RootSignatureDesc &RSD, else return reportError(Ctx, "Invalid value for Num32BitValues"); - RSD.Parameters.addParameter(Header, Constants); + RSD.ParametersContainer.addParameter(Header, Constants); return false; } @@ -166,11 +166,12 @@ static bool validate(LLVMContext *Ctx, const mcdxbc::RootSignatureDesc &RSD) { return reportValueError(Ctx, "RootFlags", RSD.Flags); } - for (const mcdxbc::RootParameterHeader &Header : RSD.Parameters.Headers) { - if (!dxbc::isValidShaderVisibility(Header.ShaderVisibility)) - return reportValueError(Ctx, "ShaderVisibility", Header.ShaderVisibility); + for (const llvm::mcdxbc::RootParameterInfo &Info : RSD.ParametersContainer) { + if (!dxbc::isValidShaderVisibility(Info.Header.ShaderVisibility)) + return reportValueError(Ctx, "ShaderVisibility", + Info.Header.ShaderVisibility); - assert(dxbc::isValidParameterType(Header.ParameterType) && + assert(dxbc::isValidParameterType(Info.Header.ParameterType) && "Invalid value for ParameterType"); } @@ -288,16 +289,20 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M, OS << indent(Space) << "Version: " << RS.Version << "\n"; OS << indent(Space) << "RootParametersOffset: " << RS.RootParameterOffset << "\n"; - OS << indent(Space) << "NumParameters: " << RS.Parameters.size() << "\n"; + OS << indent(Space) << "NumParameters: " << RS.ParametersContainer.size() + << "\n"; Space++; - for (auto const &Header : RS.Parameters.Headers) { - OS << indent(Space) << "- Parameter Type: " << Header.ParameterType + for (auto const &Info : RS.ParametersContainer) { + OS << indent(Space) << "- Parameter Type: " << Info.Header.ParameterType << "\n"; OS << indent(Space + 2) - << "Shader Visibility: " << Header.ShaderVisibility << "\n"; - mcdxbc::ParametersView P = RS.Parameters.get(Header); - if (std::holds_alternative(P)) { - auto Constants = std::get(P); + << "Shader Visibility: " << Info.Header.ShaderVisibility << "\n"; + std::optional P = + RS.ParametersContainer.getParameter(&Info); + if (!P) + continue; + if (std::holds_alternative(*P)) { + auto Constants = std::get(*P); OS << indent(Space + 2) << "Register Space: " << Constants.RegisterSpace << "\n"; OS << indent(Space + 2) From d6c2b5583d3c13dcc96a5d5b36a8ac5741d8f6ce Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Mon, 28 Apr 2025 22:29:53 +0000 Subject: [PATCH 09/31] changing variant to host pointers --- .../llvm/MC/DXContainerRootSignature.h | 22 +++++++------- llvm/lib/MC/DXContainerRootSignature.cpp | 30 +++++++++---------- llvm/lib/Target/DirectX/DXILRootSignature.cpp | 10 +++---- 3 files changed, 31 insertions(+), 31 deletions(-) diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index 2ac79f4c454d8..33680c90d595f 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -8,10 +8,10 @@ #include "llvm/ADT/STLForwardCompat.h" #include "llvm/BinaryFormat/DXContainer.h" -#include "llvm/Support/ErrorHandling.h" #include #include #include +#include #include namespace llvm { @@ -29,11 +29,11 @@ struct RootParameterInfo { : Header(H), Location(L) {} }; -using RootDescriptor = std::variant; +using RootDescriptor = std::variant; using ParametersView = - std::variant; + std::variant; struct RootParametersContainer { SmallVector ParametersInfo; @@ -52,27 +52,27 @@ struct RootParametersContainer { void addParameter(dxbc::RootParameterHeader H, dxbc::RST0::v0::RootDescriptor D) { addInfo(H, Descriptors.size()); - Descriptors.push_back(D); + Descriptors.push_back(std::move(&D)); } void addParameter(dxbc::RootParameterHeader H, dxbc::RST0::v1::RootDescriptor D) { addInfo(H, Descriptors.size()); - Descriptors.push_back(D); + Descriptors.push_back(std::move(&D)); } std::optional getParameter(const RootParameterInfo *H) const { switch (H->Header.ParameterType) { case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): - return Constants[H->Location]; + return &Constants[H->Location]; case llvm::to_underlying(dxbc::RootParameterType::CBV): case llvm::to_underlying(dxbc::RootParameterType::SRV): case llvm::to_underlying(dxbc::RootParameterType::UAV): RootDescriptor VersionedParam = Descriptors[H->Location]; - if (std::holds_alternative( + if (std::holds_alternative( VersionedParam)) - return std::get(VersionedParam); - return std::get(VersionedParam); + return std::get(VersionedParam); + return std::get(VersionedParam); } return std::nullopt; diff --git a/llvm/lib/MC/DXContainerRootSignature.cpp b/llvm/lib/MC/DXContainerRootSignature.cpp index 6cc8a9167bf40..c3a535592b78f 100644 --- a/llvm/lib/MC/DXContainerRootSignature.cpp +++ b/llvm/lib/MC/DXContainerRootSignature.cpp @@ -40,7 +40,7 @@ size_t RootSignatureDesc::getSize() const { continue; std::visit( [&Size](auto &Value) -> void { - using T = std::decay_t; + using T = std::decay_t; Size += sizeof(T); }, *P); @@ -80,28 +80,28 @@ void RootSignatureDesc::write(raw_ostream &OS) const { auto P = ParametersContainer.getParameter(H); if (!P) continue; - if (std::holds_alternative(*P)) { - auto Constants = std::get(*P); - support::endian::write(BOS, Constants.ShaderRegister, + if (std::holds_alternative(*P)) { + auto* Constants = std::get(*P); + support::endian::write(BOS, Constants->ShaderRegister, llvm::endianness::little); - support::endian::write(BOS, Constants.RegisterSpace, + support::endian::write(BOS, Constants->RegisterSpace, llvm::endianness::little); - support::endian::write(BOS, Constants.Num32BitValues, + support::endian::write(BOS, Constants->Num32BitValues, llvm::endianness::little); - } else if (std::holds_alternative(*P)) { - auto Descriptor = std::get(*P); - support::endian::write(BOS, Descriptor.ShaderRegister, + } else if (std::holds_alternative(*P)) { + auto* Descriptor = std::get(*P); + support::endian::write(BOS, Descriptor->ShaderRegister, llvm::endianness::little); - support::endian::write(BOS, Descriptor.RegisterSpace, + support::endian::write(BOS, Descriptor->RegisterSpace, llvm::endianness::little); - } else if (std::holds_alternative(*P)) { - auto Descriptor = std::get(*P); + } else if (std::holds_alternative(*P)) { + auto* Descriptor = std::get(*P); - support::endian::write(BOS, Descriptor.ShaderRegister, + support::endian::write(BOS, Descriptor->ShaderRegister, llvm::endianness::little); - support::endian::write(BOS, Descriptor.RegisterSpace, + support::endian::write(BOS, Descriptor->RegisterSpace, llvm::endianness::little); - support::endian::write(BOS, Descriptor.Flags, llvm::endianness::little); + support::endian::write(BOS, Descriptor->Flags, llvm::endianness::little); } } assert(Storage.size() == getSize()); diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp index 40dcff3999b8f..4e5d44f30e908 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp +++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp @@ -301,14 +301,14 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M, RS.ParametersContainer.getParameter(&Info); if (!P) continue; - if (std::holds_alternative(*P)) { - auto Constants = std::get(*P); - OS << indent(Space + 2) << "Register Space: " << Constants.RegisterSpace + if (std::holds_alternative(*P)) { + auto* Constants = std::get(*P); + OS << indent(Space + 2) << "Register Space: " << Constants->RegisterSpace << "\n"; OS << indent(Space + 2) - << "Shader Register: " << Constants.ShaderRegister << "\n"; + << "Shader Register: " << Constants->ShaderRegister << "\n"; OS << indent(Space + 2) - << "Num 32 Bit Values: " << Constants.Num32BitValues << "\n"; + << "Num 32 Bit Values: " << Constants->Num32BitValues << "\n"; } } Space--; From 93e4cf299ba6898be9178f1c039eba052a8c9255 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Mon, 28 Apr 2025 22:39:36 +0000 Subject: [PATCH 10/31] clean up --- .../llvm/MC/DXContainerRootSignature.h | 21 +++++++------------ llvm/lib/MC/DXContainerRootSignature.cpp | 14 +++++++------ llvm/lib/Target/DirectX/DXILRootSignature.cpp | 8 +++---- 3 files changed, 20 insertions(+), 23 deletions(-) diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index 33680c90d595f..507204d5b2ba4 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -29,11 +29,11 @@ struct RootParameterInfo { : Header(H), Location(L) {} }; -using RootDescriptor = std::variant; -using ParametersView = - std::variant; +using RootDescriptor = std::variant; +using ParametersView = std::variant; struct RootParametersContainer { SmallVector ParametersInfo; @@ -69,10 +69,10 @@ struct RootParametersContainer { case llvm::to_underlying(dxbc::RootParameterType::SRV): case llvm::to_underlying(dxbc::RootParameterType::UAV): RootDescriptor VersionedParam = Descriptors[H->Location]; - if (std::holds_alternative( + if (std::holds_alternative( VersionedParam)) - return std::get(VersionedParam); - return std::get(VersionedParam); + return std::get(VersionedParam); + return std::get(VersionedParam); } return std::nullopt; @@ -86,11 +86,6 @@ struct RootParametersContainer { SmallVector::const_iterator end() const { return ParametersInfo.end(); } - - llvm::iterator_range::const_iterator> - getInfo() const { - return llvm::make_range(begin(), end()); - } }; struct RootSignatureDesc { diff --git a/llvm/lib/MC/DXContainerRootSignature.cpp b/llvm/lib/MC/DXContainerRootSignature.cpp index c3a535592b78f..252f864f6f4bd 100644 --- a/llvm/lib/MC/DXContainerRootSignature.cpp +++ b/llvm/lib/MC/DXContainerRootSignature.cpp @@ -80,22 +80,24 @@ void RootSignatureDesc::write(raw_ostream &OS) const { auto P = ParametersContainer.getParameter(H); if (!P) continue; - if (std::holds_alternative(*P)) { - auto* Constants = std::get(*P); + if (std::holds_alternative(*P)) { + auto *Constants = std::get(*P); support::endian::write(BOS, Constants->ShaderRegister, llvm::endianness::little); support::endian::write(BOS, Constants->RegisterSpace, llvm::endianness::little); support::endian::write(BOS, Constants->Num32BitValues, llvm::endianness::little); - } else if (std::holds_alternative(*P)) { - auto* Descriptor = std::get(*P); + } else if (std::holds_alternative( + *P)) { + auto *Descriptor = std::get(*P); support::endian::write(BOS, Descriptor->ShaderRegister, llvm::endianness::little); support::endian::write(BOS, Descriptor->RegisterSpace, llvm::endianness::little); - } else if (std::holds_alternative(*P)) { - auto* Descriptor = std::get(*P); + } else if (std::holds_alternative( + *P)) { + auto *Descriptor = std::get(*P); support::endian::write(BOS, Descriptor->ShaderRegister, llvm::endianness::little); diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp index 4e5d44f30e908..30ca4d8f7c8ed 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp +++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp @@ -301,10 +301,10 @@ PreservedAnalyses RootSignatureAnalysisPrinter::run(Module &M, RS.ParametersContainer.getParameter(&Info); if (!P) continue; - if (std::holds_alternative(*P)) { - auto* Constants = std::get(*P); - OS << indent(Space + 2) << "Register Space: " << Constants->RegisterSpace - << "\n"; + if (std::holds_alternative(*P)) { + auto *Constants = std::get(*P); + OS << indent(Space + 2) + << "Register Space: " << Constants->RegisterSpace << "\n"; OS << indent(Space + 2) << "Shader Register: " << Constants->ShaderRegister << "\n"; OS << indent(Space + 2) From b45b1b611730589a9a378ea5a6b9e411fb959c84 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Mon, 28 Apr 2025 22:49:22 +0000 Subject: [PATCH 11/31] fix --- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 1 + 1 file changed, 1 insertion(+) diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index 381fe41d8b01c..5f2e71ac2495e 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -305,6 +305,7 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { RS.ParametersContainer.addInfo(Header, -1); } } + } RS.write(OS); break; From f804a23d7a3f29149b7b8c88c68fa24bbb1b23a0 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Mon, 28 Apr 2025 23:49:45 +0000 Subject: [PATCH 12/31] fix --- .../llvm/MC/DXContainerRootSignature.h | 19 ++++++++++--------- llvm/lib/MC/DXContainerRootSignature.cpp | 10 ++++++---- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 2 +- 3 files changed, 17 insertions(+), 14 deletions(-) diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index 507204d5b2ba4..c8af613a57094 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -29,8 +29,8 @@ struct RootParameterInfo { : Header(H), Location(L) {} }; -using RootDescriptor = std::variant; +using RootDescriptor = std::variant; using ParametersView = std::variant; @@ -52,13 +52,13 @@ struct RootParametersContainer { void addParameter(dxbc::RootParameterHeader H, dxbc::RST0::v0::RootDescriptor D) { addInfo(H, Descriptors.size()); - Descriptors.push_back(std::move(&D)); + Descriptors.push_back(D); } void addParameter(dxbc::RootParameterHeader H, dxbc::RST0::v1::RootDescriptor D) { addInfo(H, Descriptors.size()); - Descriptors.push_back(std::move(&D)); + Descriptors.push_back(D); } std::optional getParameter(const RootParameterInfo *H) const { @@ -68,11 +68,12 @@ struct RootParametersContainer { case llvm::to_underlying(dxbc::RootParameterType::CBV): case llvm::to_underlying(dxbc::RootParameterType::SRV): case llvm::to_underlying(dxbc::RootParameterType::UAV): - RootDescriptor VersionedParam = Descriptors[H->Location]; - if (std::holds_alternative( - VersionedParam)) - return std::get(VersionedParam); - return std::get(VersionedParam); + const RootDescriptor &VersionedParam = Descriptors[H->Location]; + if (std::holds_alternative( + VersionedParam)) { + return &std::get(VersionedParam); + } + return &std::get(VersionedParam); } return std::nullopt; diff --git a/llvm/lib/MC/DXContainerRootSignature.cpp b/llvm/lib/MC/DXContainerRootSignature.cpp index 252f864f6f4bd..641c2f5fa1b1b 100644 --- a/llvm/lib/MC/DXContainerRootSignature.cpp +++ b/llvm/lib/MC/DXContainerRootSignature.cpp @@ -80,8 +80,8 @@ void RootSignatureDesc::write(raw_ostream &OS) const { auto P = ParametersContainer.getParameter(H); if (!P) continue; - if (std::holds_alternative(*P)) { - auto *Constants = std::get(*P); + if (std::holds_alternative(P.value())) { + auto *Constants = std::get(P.value()); support::endian::write(BOS, Constants->ShaderRegister, llvm::endianness::little); support::endian::write(BOS, Constants->RegisterSpace, @@ -90,14 +90,16 @@ void RootSignatureDesc::write(raw_ostream &OS) const { llvm::endianness::little); } else if (std::holds_alternative( *P)) { - auto *Descriptor = std::get(*P); + auto *Descriptor = + std::get(P.value()); support::endian::write(BOS, Descriptor->ShaderRegister, llvm::endianness::little); support::endian::write(BOS, Descriptor->RegisterSpace, llvm::endianness::little); } else if (std::holds_alternative( *P)) { - auto *Descriptor = std::get(*P); + auto *Descriptor = + std::get(P.value()); support::endian::write(BOS, Descriptor->ShaderRegister, llvm::endianness::little); diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index 5f2e71ac2495e..b8ea1b048edfe 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -299,13 +299,13 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { Descriptor.ShaderRegister = Param.Descriptor.ShaderRegister; Descriptor.Flags = Param.Descriptor.getEncodedFlags(); RS.ParametersContainer.addParameter(Header, Descriptor); + } break; default: // Handling invalid parameter type edge case RS.ParametersContainer.addInfo(Header, -1); } } - } RS.write(OS); break; From 44bd13abd1038aa43d66f4942d831a3b1c752b8c Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Tue, 29 Apr 2025 23:57:47 +0000 Subject: [PATCH 13/31] making read work --- llvm/include/llvm/BinaryFormat/DXContainer.h | 35 +++++++ .../BinaryFormat/DXContainerConstants.def | 25 ++++- .../llvm/MC/DXContainerRootSignature.h | 32 +++++- .../include/llvm/ObjectYAML/DXContainerYAML.h | 98 +++++++++++++++++++ llvm/lib/MC/DXContainerRootSignature.cpp | 78 +++++++++++++-- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 27 +++++ llvm/lib/ObjectYAML/DXContainerYAML.cpp | 32 ++++++ .../RootSignature-MultipleParameters.yaml | 11 +++ 8 files changed, 326 insertions(+), 12 deletions(-) diff --git a/llvm/include/llvm/BinaryFormat/DXContainer.h b/llvm/include/llvm/BinaryFormat/DXContainer.h index 3dbcfa82f3d7c..a441fa3a36886 100644 --- a/llvm/include/llvm/BinaryFormat/DXContainer.h +++ b/llvm/include/llvm/BinaryFormat/DXContainer.h @@ -163,6 +163,11 @@ enum class RootDescriptorFlag : uint32_t { #include "DXContainerConstants.def" }; +#define DESCRIPTOR_RANGE_FLAG(Num, Val) Val = 1ull << Num, +enum class DescriptorRangeFlag : uint32_t { +#include "DXContainerConstants.def" +}; + #define ROOT_PARAMETER(Val, Enum) Enum = Val, enum class RootParameterType : uint32_t { #include "DXContainerConstants.def" @@ -170,6 +175,13 @@ enum class RootParameterType : uint32_t { ArrayRef> getRootParameterTypes(); +#define DESCRIPTOR_RANGE(Val, Enum) Enum = Val, +enum class DescriptorRangeType : uint32_t { +#include "DXContainerConstants.def" +}; + +ArrayRef> getDescriptorRangeTypes(); + #define ROOT_PARAMETER(Val, Enum) \ case Val: \ return true; @@ -595,6 +607,21 @@ struct RootDescriptor { sys::swapByteOrder(RegisterSpace); } }; + +struct DescriptorRange { + uint32_t RangeType; + uint32_t NumDescriptors; + uint32_t BaseShaderRegister; + uint32_t RegisterSpace; + int32_t OffsetInDescriptorsFromTableStart; + void swapBytes() { + sys::swapByteOrder(RangeType); + sys::swapByteOrder(NumDescriptors); + sys::swapByteOrder(BaseShaderRegister); + sys::swapByteOrder(RegisterSpace); + sys::swapByteOrder(OffsetInDescriptorsFromTableStart); + } +}; } // namespace v0 namespace v1 { @@ -605,6 +632,14 @@ struct RootDescriptor : public v0::RootDescriptor { sys::swapByteOrder(Flags); } }; + +struct DescriptorRange : public v0::DescriptorRange { + uint32_t Flags; + void swapBytes() { + v0::DescriptorRange::swapBytes(); + sys::swapByteOrder(Flags); + } +}; } // namespace v1 } // namespace RST0 // following dx12 naming diff --git a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def index bd9bd760547dc..5fe7e7c321a33 100644 --- a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def +++ b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def @@ -73,7 +73,7 @@ ROOT_ELEMENT_FLAG(11, SamplerHeapDirectlyIndexed) #endif // ROOT_ELEMENT_FLAG -// ROOT_ELEMENT_FLAG(bit offset for the flag, name). +// ROOT_DESCRIPTOR_FLAG(bit offset for the flag, name). #ifdef ROOT_DESCRIPTOR_FLAG ROOT_DESCRIPTOR_FLAG(0, NONE) @@ -84,8 +84,21 @@ ROOT_DESCRIPTOR_FLAG(3, DATA_STATIC) #endif // ROOT_DESCRIPTOR_FLAG +// DESCRIPTOR_RANGE_FLAG(bit offset for the flag, name). +#ifdef DESCRIPTOR_RANGE_FLAG + +DESCRIPTOR_RANGE_FLAG(0, NONE) +DESCRIPTOR_RANGE_FLAG(1, DESCRIPTORS_VOLATILE) +DESCRIPTOR_RANGE_FLAG(2, DATA_VOLATILE) +DESCRIPTOR_RANGE_FLAG(3, DATA_STATIC_WHILE_SET_AT_EXECUTE) +DESCRIPTOR_RANGE_FLAG(4, DATA_STATIC) +DESCRIPTOR_RANGE_FLAG(16, DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS) +#undef DESCRIPTOR_RANGE_FLAG +#endif // DESCRIPTOR_RANGE_FLAG + #ifdef ROOT_PARAMETER +ROOT_PARAMETER(0, DescriptorTable) ROOT_PARAMETER(1, Constants32Bit) ROOT_PARAMETER(2, CBV) ROOT_PARAMETER(3, SRV) @@ -93,6 +106,16 @@ ROOT_PARAMETER(4, UAV) #undef ROOT_PARAMETER #endif // ROOT_PARAMETER + +#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 SHADER_VISIBILITY SHADER_VISIBILITY(0, All) diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index c8af613a57094..3f5960a6de2f9 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -7,6 +7,7 @@ //===----------------------------------------------------------------------===// #include "llvm/ADT/STLForwardCompat.h" +#include "llvm/ADT/SmallVector.h" #include "llvm/BinaryFormat/DXContainer.h" #include #include @@ -28,17 +29,30 @@ struct RootParameterInfo { RootParameterInfo(dxbc::RootParameterHeader H, size_t L) : Header(H), Location(L) {} }; +using DescriptorRanges = std::variant; +struct DescriptorTable { + SmallVector Ranges; + + SmallVector::const_iterator begin() const { + return Ranges.begin(); + } + SmallVector::const_iterator end() const { + return Ranges.end(); + } +}; using RootDescriptor = std::variant; -using ParametersView = std::variant; + +using ParametersView = std::variant< + const dxbc::RootConstants *, const dxbc::RST0::v0::RootDescriptor *, + const dxbc::RST0::v1::RootDescriptor *, const DescriptorTable *>; struct RootParametersContainer { SmallVector ParametersInfo; - SmallVector Constants; SmallVector Descriptors; + SmallVector Tables; void addInfo(dxbc::RootParameterHeader H, size_t L) { ParametersInfo.push_back(RootParameterInfo(H, L)); @@ -61,13 +75,18 @@ struct RootParametersContainer { Descriptors.push_back(D); } + void addParameter(dxbc::RootParameterHeader H, DescriptorTable D) { + addInfo(H, Tables.size()); + Tables.push_back(D); + } + std::optional getParameter(const RootParameterInfo *H) const { switch (H->Header.ParameterType) { case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): return &Constants[H->Location]; case llvm::to_underlying(dxbc::RootParameterType::CBV): case llvm::to_underlying(dxbc::RootParameterType::SRV): - case llvm::to_underlying(dxbc::RootParameterType::UAV): + case llvm::to_underlying(dxbc::RootParameterType::UAV): { const RootDescriptor &VersionedParam = Descriptors[H->Location]; if (std::holds_alternative( VersionedParam)) { @@ -75,6 +94,9 @@ struct RootParametersContainer { } return &std::get(VersionedParam); } + case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): + return &Tables[H->Location]; + } return std::nullopt; } diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h index 8bb9da7884bed..738108cc3d1be 100644 --- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h +++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h @@ -15,6 +15,8 @@ #ifndef LLVM_OBJECTYAML_DXCONTAINERYAML_H #define LLVM_OBJECTYAML_DXCONTAINERYAML_H +#include "llvm/ADT/STLForwardCompat.h" +#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringRef.h" #include "llvm/BinaryFormat/DXContainer.h" #include "llvm/Object/DXContainer.h" @@ -91,6 +93,25 @@ struct RootDescriptorYaml { #include "llvm/BinaryFormat/DXContainerConstants.def" }; +struct DescriptorRangeYaml { + uint32_t RangeType; + uint32_t NumDescriptors; + uint32_t BaseShaderRegister; + uint32_t RegisterSpace; + int32_t OffsetInDescriptorsFromTableStart; + + uint32_t getEncodedFlags() const; + +#define DESCRIPTOR_RANGE_FLAG(Num, Val) bool Val = false; +#include "llvm/BinaryFormat/DXContainerConstants.def" +}; + +struct DescriptorTableYaml { + uint32_t NumRanges; + uint32_t RangesOffset; + SmallVector Ranges; +}; + struct RootParameterYamlDesc { uint32_t Type; uint32_t Visibility; @@ -107,12 +128,80 @@ struct RootParameterYamlDesc { case llvm::to_underlying(dxbc::RootParameterType::UAV): Descriptor = RootDescriptorYaml(); break; + case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): + Table = DescriptorTableYaml(); + break; + } + } + + ~RootParameterYamlDesc() { + switch (Type) { + + case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): + Constants.~RootConstantsYaml(); + break; + case llvm::to_underlying(dxbc::RootParameterType::CBV): + case llvm::to_underlying(dxbc::RootParameterType::SRV): + case llvm::to_underlying(dxbc::RootParameterType::UAV): + Descriptor.~RootDescriptorYaml(); + break; + case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): + Table.~DescriptorTableYaml(); + break; } } + RootParameterYamlDesc(const RootParameterYamlDesc &Other) + : Type(Other.Type), Visibility(Other.Visibility), Offset(Other.Offset) { + // Initialize the appropriate union member based on Type + switch (Type) { + case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): + // Placement new to construct the union member + new (&Constants) RootConstantsYaml(Other.Constants); + break; + case llvm::to_underlying(dxbc::RootParameterType::CBV): + case llvm::to_underlying(dxbc::RootParameterType::SRV): + case llvm::to_underlying(dxbc::RootParameterType::UAV): + new (&Descriptor) RootDescriptorYaml(Other.Descriptor); + break; + case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): + new (&Table) DescriptorTableYaml(Other.Table); + break; + } + } + + RootParameterYamlDesc &operator=(const RootParameterYamlDesc &other) { + if (this != &other) { + // First, destroy the current union member + this->~RootParameterYamlDesc(); + + // Copy the basic members + Type = other.Type; + Visibility = other.Visibility; + Offset = other.Offset; + + // Initialize the new union member based on the Type from 'other' + switch (Type) { + case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): + new (&Constants) RootConstantsYaml(other.Constants); + break; + case llvm::to_underlying(dxbc::RootParameterType::CBV): + case llvm::to_underlying(dxbc::RootParameterType::SRV): + case llvm::to_underlying(dxbc::RootParameterType::UAV): + new (&Descriptor) RootDescriptorYaml(other.Descriptor); + break; + case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): + new (&Table) DescriptorTableYaml(other.Table); + break; + } + } + return *this; + } + union { RootConstantsYaml Constants; RootDescriptorYaml Descriptor; + DescriptorTableYaml Table; }; }; @@ -244,6 +333,7 @@ LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::SignatureElement) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::PSVInfo::MaskVector) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::SignatureParameter) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::RootParameterYamlDesc) +LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::DescriptorRangeYaml) LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::PSV::SemanticKind) LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::PSV::ComponentType) LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::PSV::InterpolationMode) @@ -328,6 +418,14 @@ template <> struct MappingTraits { static void mapping(IO &IO, llvm::DXContainerYAML::RootDescriptorYaml &D); }; +template <> struct MappingTraits { + static void mapping(IO &IO, llvm::DXContainerYAML::DescriptorTableYaml &D); +}; + +template <> struct MappingTraits { + static void mapping(IO &IO, llvm::DXContainerYAML::DescriptorRangeYaml &D); +}; + } // namespace yaml } // namespace llvm diff --git a/llvm/lib/MC/DXContainerRootSignature.cpp b/llvm/lib/MC/DXContainerRootSignature.cpp index 641c2f5fa1b1b..4c725969e63cf 100644 --- a/llvm/lib/MC/DXContainerRootSignature.cpp +++ b/llvm/lib/MC/DXContainerRootSignature.cpp @@ -10,11 +10,43 @@ #include "llvm/ADT/SmallString.h" #include "llvm/BinaryFormat/DXContainer.h" #include "llvm/Support/EndianStream.h" +#include #include using namespace llvm; using namespace llvm::mcdxbc; +class SizeCalculatorVisitor { +public: + SizeCalculatorVisitor(uint32_t Version, size_t &SizeRef) + : Size(SizeRef), Version(Version) {} + + void operator()(const dxbc::RootConstants *Value) const { + Size += sizeof(dxbc::RootConstants); + } + + void operator()(const dxbc::RST0::v0::RootDescriptor *Value) const { + Size += sizeof(dxbc::RST0::v0::RootDescriptor); + } + + void operator()(const dxbc::RST0::v1::RootDescriptor *Value) const { + Size += sizeof(dxbc::RST0::v1::RootDescriptor); + } + + void operator()(const DescriptorTable *Value) const { + if (Version == 1) + Size += + sizeof(dxbc::RST0::v0::DescriptorRange) * Value->Ranges.size() + 8; + else + Size += + sizeof(dxbc::RST0::v1::DescriptorRange) * Value->Ranges.size() + 8; + } + +private: + size_t &Size; + uint32_t Version; +}; + static uint32_t writePlaceholder(raw_svector_ostream &Stream) { const uint32_t DummyValue = std::numeric_limits::max(); uint32_t Offset = Stream.tell(); @@ -38,12 +70,8 @@ size_t RootSignatureDesc::getSize() const { std::optional P = ParametersContainer.getParameter(&I); if (!P) continue; - std::visit( - [&Size](auto &Value) -> void { - using T = std::decay_t; - Size += sizeof(T); - }, - *P); + + std::visit(SizeCalculatorVisitor(Version, Size), *P); } return Size; @@ -106,6 +134,44 @@ void RootSignatureDesc::write(raw_ostream &OS) const { support::endian::write(BOS, Descriptor->RegisterSpace, llvm::endianness::little); support::endian::write(BOS, Descriptor->Flags, llvm::endianness::little); + } else if (std::holds_alternative(P.value())) { + auto *Table = std::get(P.value()); + + support::endian::write(BOS, (uint32_t)Table->Ranges.size(), + llvm::endianness::little); + rewriteOffsetToCurrentByte(BOS, writePlaceholder(BOS)); + for (const auto &R : *Table) { + if (std::holds_alternative(R)) { + auto Range = std::get(R); + + support::endian::write(BOS, Range.RangeType, + llvm::endianness::little); + support::endian::write(BOS, Range.NumDescriptors, + llvm::endianness::little); + support::endian::write(BOS, Range.BaseShaderRegister, + llvm::endianness::little); + support::endian::write(BOS, Range.RegisterSpace, + llvm::endianness::little); + support::endian::write(BOS, Range.OffsetInDescriptorsFromTableStart, + llvm::endianness::little); + } else { + if (std::holds_alternative(R)) { + auto Range = std::get(R); + + support::endian::write(BOS, Range.RangeType, + llvm::endianness::little); + support::endian::write(BOS, Range.NumDescriptors, + llvm::endianness::little); + support::endian::write(BOS, Range.BaseShaderRegister, + llvm::endianness::little); + support::endian::write(BOS, Range.RegisterSpace, + llvm::endianness::little); + support::endian::write(BOS, Range.OffsetInDescriptorsFromTableStart, + llvm::endianness::little); + support::endian::write(BOS, Range.Flags, llvm::endianness::little); + } + } + } } } assert(Storage.size() == getSize()); diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index b8ea1b048edfe..6336a42c8e4ae 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -11,6 +11,7 @@ /// //===----------------------------------------------------------------------===// +#include "llvm/ADT/STLForwardCompat.h" #include "llvm/BinaryFormat/DXContainer.h" #include "llvm/MC/DXContainerPSVInfo.h" #include "llvm/MC/DXContainerRootSignature.h" @@ -301,6 +302,32 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { RS.ParametersContainer.addParameter(Header, Descriptor); } break; + case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): { + mcdxbc::DescriptorTable Table; + for (const auto &R : Param.Table.Ranges) { + if (RS.Version == 1) { + dxbc::RST0::v0::DescriptorRange Range; + Range.RangeType = R.RangeType; + Range.NumDescriptors = R.NumDescriptors; + Range.BaseShaderRegister = R.BaseShaderRegister; + Range.RegisterSpace = R.RegisterSpace; + Range.OffsetInDescriptorsFromTableStart = + R.OffsetInDescriptorsFromTableStart; + Table.Ranges.push_back(Range); + } else { + dxbc::RST0::v1::DescriptorRange Range; + Range.RangeType = R.RangeType; + Range.NumDescriptors = R.NumDescriptors; + Range.BaseShaderRegister = R.BaseShaderRegister; + Range.RegisterSpace = R.RegisterSpace; + Range.OffsetInDescriptorsFromTableStart = + R.OffsetInDescriptorsFromTableStart; + Range.Flags = R.getEncodedFlags(); + Table.Ranges.push_back(Range); + } + } + RS.ParametersContainer.addParameter(Header, Table); + } break; default: // Handling invalid parameter type edge case RS.ParametersContainer.addInfo(Header, -1); diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index 18c1299d4b867..5ababda9bcdb5 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -125,6 +125,15 @@ uint32_t DXContainerYAML::RootSignatureYamlDesc::getEncodedFlags() { return Flag; } +uint32_t DXContainerYAML::DescriptorRangeYaml::getEncodedFlags() const { + uint64_t Flag = 0; +#define DESCRIPTOR_RANGE_FLAG(Num, Val) \ + if (Val) \ + Flag |= (uint32_t)dxbc::DescriptorRangeFlag::Val; +#include "llvm/BinaryFormat/DXContainerConstants.def" + return Flag; +} + uint64_t DXContainerYAML::ShaderFeatureFlags::getEncodedFlags() { uint64_t Flag = 0; #define SHADER_FEATURE_FLAG(Num, DxilModuleNum, Val, Str) \ @@ -311,6 +320,25 @@ void MappingTraits::mapping( #include "llvm/BinaryFormat/DXContainerConstants.def" } +void MappingTraits::mapping( + IO &IO, llvm::DXContainerYAML::DescriptorRangeYaml &R) { + IO.mapRequired("RangeType", R.RangeType); + IO.mapRequired("NumDescriptors", R.NumDescriptors); + IO.mapRequired("BaseShaderRegister", R.BaseShaderRegister); + IO.mapRequired("RegisterSpace", R.RegisterSpace); + IO.mapRequired("OffsetInDescriptorsFromTableStart", + R.OffsetInDescriptorsFromTableStart); +#define DESCRIPTOR_RANGE_FLAG(Num, Val) IO.mapOptional(#Val, R.Val, false); +#include "llvm/BinaryFormat/DXContainerConstants.def" +} + +void MappingTraits::mapping( + IO &IO, llvm::DXContainerYAML::DescriptorTableYaml &T) { + IO.mapRequired("NumRanges", T.NumRanges); + IO.mapOptional("RangesOffset", T.RangesOffset); + IO.mapRequired("Ranges", T.Ranges); +} + void MappingTraits::mapping( IO &IO, llvm::DXContainerYAML::RootParameterYamlDesc &P) { IO.mapRequired("ParameterType", P.Type); @@ -325,6 +353,10 @@ void MappingTraits::mapping( case llvm::to_underlying(dxbc::RootParameterType::UAV): IO.mapRequired("Descriptor", P.Descriptor); break; + case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): + IO.mapRequired("Table", P.Table); + break; + break; } } diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml index debb459c3944e..d680bf09ab730 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml @@ -37,6 +37,17 @@ Parts: ShaderRegister: 31 RegisterSpace: 32 DATA_STATIC_WHILE_SET_AT_EXECUTE: true + - ParameterType: 0 # SRV + ShaderVisibility: 3 # Domain + Table: + NumRanges: 1 + Ranges: + - RangeType: 0 + NumDescriptors: 41 + BaseShaderRegister: 42 + RegisterSpace: 43 + OffsetInDescriptorsFromTableStart: -1 + DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS: true AllowInputAssemblerInputLayout: true DenyGeometryShaderRootAccess: true From ac51bf60742f2d8880970c7f7f106c9a1b4d105e Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Fri, 2 May 2025 00:41:20 +0000 Subject: [PATCH 14/31] adding reading logic --- llvm/include/llvm/Object/DXContainer.h | 52 +++++++- llvm/lib/ObjectYAML/DXContainerYAML.cpp | 49 ++++++++ .../ObjectYAML/DXContainerYAMLTest.cpp | 113 ++++++++++++++++++ 3 files changed, 212 insertions(+), 2 deletions(-) diff --git a/llvm/include/llvm/Object/DXContainer.h b/llvm/include/llvm/Object/DXContainer.h index e359d85f08bec..b27312c5697bc 100644 --- a/llvm/include/llvm/Object/DXContainer.h +++ b/llvm/include/llvm/Object/DXContainer.h @@ -19,11 +19,10 @@ #include "llvm/ADT/StringRef.h" #include "llvm/BinaryFormat/DXContainer.h" #include "llvm/Object/Error.h" +#include "llvm/Support/Endian.h" #include "llvm/Support/Error.h" #include "llvm/Support/MemoryBufferRef.h" #include "llvm/TargetParser/Triple.h" -#include -#include #include namespace llvm { @@ -169,6 +168,43 @@ struct RootDescriptorView : RootParameterView { return readParameter(); } }; +template struct DescriptorTable { + uint32_t Version; + uint32_t NumRanges; + uint32_t RangesOffset; + ViewArray Ranges; + + typename ViewArray::iterator begin() const { return Ranges.begin(); } + +typename ViewArray::iterator end() const { return Ranges.end(); } +}; + +template struct DescriptorTableView : RootParameterView { + using TemplateType = T; + + static bool classof(const RootParameterView *V) { + return (V->Header.ParameterType == + llvm::to_underlying(dxbc::RootParameterType::DescriptorTable)); + } + + // Define a type alias to access the template parameter from inside classof + llvm::Expected> read() { + const char *Current = ParamData.begin(); + DescriptorTable Table; + + Table.NumRanges = + support::endian::read(Current); + Current += sizeof(uint32_t); + + Table.RangesOffset = + support::endian::read(Current); + Current += sizeof(uint32_t); + + Table.Ranges.Data = + ParamData.substr(2 * sizeof(uint32_t), Table.NumRanges * sizeof(T)); + return Table; + } +}; static Error parseFailed(const Twine &Msg) { return make_error(Msg.str(), object_error::parse_failed); @@ -221,6 +257,18 @@ class RootSignature { else DataSize = sizeof(dxbc::RST0::v1::RootDescriptor); break; + case dxbc::RootParameterType::DescriptorTable: + uint32_t NumRanges = + support::endian::read( + PartData.begin() + Header.ParameterOffset); + if (Version == 1) + DataSize = sizeof(dxbc::RST0::v0::DescriptorRange) * NumRanges + + 2 * sizeof(uint32_t); + else + DataSize = sizeof(dxbc::RST0::v1::DescriptorRange) * NumRanges + + 2 * sizeof(uint32_t); + break; + break; } size_t EndOfSectionByte = getNumStaticSamplers() == 0 ? PartData.size() diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index 5ababda9bcdb5..528fef59b46e4 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -96,6 +96,55 @@ DXContainerYAML::RootSignatureYamlDesc::create( llvm::to_underlying(dxbc::RootDescriptorFlag::Val)) > 0; #include "llvm/BinaryFormat/DXContainerConstants.def" } + } else if (auto *TDV = dyn_cast>(&ParamView)) { + llvm::Expected< + object::DirectX::DescriptorTable> + TableOrErr = TDV->read(); + if (Error E = TableOrErr.takeError()) + return std::move(E); + auto Table = *TableOrErr; + NewP.Table.NumRanges = Table.NumRanges; + NewP.Table.RangesOffset = Table.RangesOffset; + + for (const auto &R : Table) { + DescriptorRangeYaml NewR; + + NewR.OffsetInDescriptorsFromTableStart = + R.OffsetInDescriptorsFromTableStart; + NewR.NumDescriptors = R.NumDescriptors; + NewR.BaseShaderRegister = R.BaseShaderRegister; + NewR.RegisterSpace = R.RegisterSpace; + NewR.RangeType = R.RangeType; + + NewP.Table.Ranges.push_back(NewR); + } + } else if (auto *TDV = dyn_cast>(&ParamView)) { + llvm::Expected< + object::DirectX::DescriptorTable> + TableOrErr = TDV->read(); + if (Error E = TableOrErr.takeError()) + return std::move(E); + auto Table = *TableOrErr; + NewP.Table.NumRanges = Table.NumRanges; + NewP.Table.RangesOffset = Table.RangesOffset; + + for (const auto &R : Table) { + DescriptorRangeYaml NewR; + + NewR.OffsetInDescriptorsFromTableStart = + R.OffsetInDescriptorsFromTableStart; + NewR.NumDescriptors = R.NumDescriptors; + NewR.BaseShaderRegister = R.BaseShaderRegister; + NewR.RegisterSpace = R.RegisterSpace; + NewR.RangeType = R.RangeType; +#define DESCRIPTOR_RANGE_FLAG(Num, Val) \ + NewR.Val = \ + (R.Flags & llvm::to_underlying(dxbc::DescriptorRangeFlag::Val)) > 0; +#include "llvm/BinaryFormat/DXContainerConstants.def" + NewP.Table.Ranges.push_back(NewR); + } } RootSigDesc.Parameters.push_back(NewP); diff --git a/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp b/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp index b6a5cee24b29d..494a710af454a 100644 --- a/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp +++ b/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp @@ -354,3 +354,116 @@ TEST(RootSignature, ParseRootDescriptorsV11) { EXPECT_EQ(Storage.size(), 133u); EXPECT_TRUE(memcmp(Buffer, Storage.data(), 133u) == 0); } + +TEST(RootSignature, ParseDescriptorTableV10) { + SmallString<128> Storage; + + // First read a fully explicit yaml with all sizes and offsets provided + ASSERT_TRUE(convert(Storage, R"(--- !dxcontainer + Header: + Hash: [ 0x32, 0x9A, 0x53, 0xD8, 0xEC, 0xBE, 0x35, 0x6F, 0x5, + 0x39, 0xE1, 0xFE, 0x31, 0x20, 0xF0, 0xC1 ] + Version: + Major: 1 + Minor: 0 + FileSize: 133 + PartCount: 1 + PartOffsets: [ 36 ] + Parts: + - Name: RTS0 + Size: 89 + RootSignature: + Version: 1 + NumRootParameters: 1 + RootParametersOffset: 24 + NumStaticSamplers: 0 + StaticSamplersOffset: 60 + Parameters: + - ParameterType: 0 # SRV + ShaderVisibility: 3 # Domain + Table: + NumRanges: 1 + Ranges: + - RangeType: 0 + NumDescriptors: 41 + BaseShaderRegister: 42 + RegisterSpace: 43 + OffsetInDescriptorsFromTableStart: -1 + AllowInputAssemblerInputLayout: true + DenyGeometryShaderRootAccess: true + )")); + + uint8_t Buffer[] = { + 0x44, 0x58, 0x42, 0x43, 0x32, 0x9a, 0x53, 0xd8, 0xec, 0xbe, 0x35, 0x6f, + 0x05, 0x39, 0xe1, 0xfe, 0x31, 0x20, 0xf0, 0xc1, 0x01, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, + 0x52, 0x54, 0x53, 0x30, 0x59, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3c, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, + 0x2a, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00}; + + EXPECT_EQ(Storage.size(), 133u); + EXPECT_TRUE(memcmp(Buffer, Storage.data(), 133u) == 0); +} + +TEST(RootSignature, ParseDescriptorTableV11) { + SmallString<128> Storage; + + // First read a fully explicit yaml with all sizes and offsets provided + ASSERT_TRUE(convert(Storage, R"(--- !dxcontainer + Header: + Hash: [ 0x32, 0x9A, 0x53, 0xD8, 0xEC, 0xBE, 0x35, 0x6F, 0x5, + 0x39, 0xE1, 0xFE, 0x31, 0x20, 0xF0, 0xC1 ] + Version: + Major: 1 + Minor: 0 + FileSize: 133 + PartCount: 1 + PartOffsets: [ 36 ] + Parts: + - Name: RTS0 + Size: 89 + RootSignature: + Version: 2 + NumRootParameters: 1 + RootParametersOffset: 24 + NumStaticSamplers: 0 + StaticSamplersOffset: 60 + Parameters: + - ParameterType: 0 # SRV + ShaderVisibility: 3 # Domain + Table: + NumRanges: 1 + Ranges: + - RangeType: 0 + NumDescriptors: 41 + BaseShaderRegister: 42 + RegisterSpace: 43 + OffsetInDescriptorsFromTableStart: -1 + DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS: true + AllowInputAssemblerInputLayout: true + DenyGeometryShaderRootAccess: true + )")); + + uint8_t Buffer[] = { + 0x44, 0x58, 0x42, 0x43, 0x32, 0x9a, 0x53, 0xd8, 0xec, 0xbe, 0x35, 0x6f, + 0x05, 0x39, 0xe1, 0xfe, 0x31, 0x20, 0xf0, 0xc1, 0x01, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, + 0x52, 0x54, 0x53, 0x30, 0x59, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3c, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, + 0x2a, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00}; + + EXPECT_EQ(Storage.size(), 133u); + EXPECT_TRUE(memcmp(Buffer, Storage.data(), 133u) == 0); +} From 97fb0036bc183dadc122963f1ff6a890ff8cf68a Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Fri, 2 May 2025 01:40:34 +0000 Subject: [PATCH 15/31] test pass locally --- llvm/include/llvm/Object/DXContainer.h | 29 ++++++-- .../include/llvm/ObjectYAML/DXContainerYAML.h | 19 ++--- llvm/lib/ObjectYAML/DXContainerYAML.cpp | 18 ++--- .../RootSignature-MultipleParameters.yaml | 72 +++++++++++-------- 4 files changed, 86 insertions(+), 52 deletions(-) diff --git a/llvm/include/llvm/Object/DXContainer.h b/llvm/include/llvm/Object/DXContainer.h index b27312c5697bc..26764289631a3 100644 --- a/llvm/include/llvm/Object/DXContainer.h +++ b/llvm/include/llvm/Object/DXContainer.h @@ -19,6 +19,7 @@ #include "llvm/ADT/StringRef.h" #include "llvm/BinaryFormat/DXContainer.h" #include "llvm/Object/Error.h" +#include "llvm/Support/Casting.h" #include "llvm/Support/Endian.h" #include "llvm/Support/Error.h" #include "llvm/Support/MemoryBufferRef.h" @@ -38,6 +39,12 @@ template std::enable_if_t::value, void> swapBytes(T &value) { value.swapBytes(); } + +struct TypeIdGenerator { + static inline size_t nextId = 0; + + static size_t getNextId() { return nextId++; } +}; } // namespace detail // This class provides a view into the underlying resource array. The Resource @@ -120,8 +127,10 @@ namespace DirectX { struct RootParameterView { const dxbc::RootParameterHeader &Header; StringRef ParamData; + uint32_t Version; + RootParameterView(uint32_t V, const dxbc::RootParameterHeader &H, StringRef P) - : Header(H), ParamData(P) {} + : Header(H), ParamData(P), Version(V) {} template Expected readParameter() { assert(sizeof(VersionT) <= sizeof(T) && @@ -169,14 +178,25 @@ struct RootDescriptorView : RootParameterView { } }; template struct DescriptorTable { - uint32_t Version; uint32_t NumRanges; uint32_t RangesOffset; ViewArray Ranges; typename ViewArray::iterator begin() const { return Ranges.begin(); } -typename ViewArray::iterator end() const { return Ranges.end(); } + typename ViewArray::iterator end() const { return Ranges.end(); } +}; +template struct TemplateTypeToVersion { + // Default version + static constexpr uint32_t Value = -1; +}; + +template <> struct TemplateTypeToVersion { + static constexpr uint32_t Value = 1; +}; + +template <> struct TemplateTypeToVersion { + static constexpr uint32_t Value = 2; }; template struct DescriptorTableView : RootParameterView { @@ -184,7 +204,8 @@ template struct DescriptorTableView : RootParameterView { static bool classof(const RootParameterView *V) { return (V->Header.ParameterType == - llvm::to_underlying(dxbc::RootParameterType::DescriptorTable)); + llvm::to_underlying(dxbc::RootParameterType::DescriptorTable)) && + (V->Version == TemplateTypeToVersion::Value); } // Define a type alias to access the template parameter from inside classof diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h index 738108cc3d1be..9cf0f8df1debf 100644 --- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h +++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h @@ -170,39 +170,40 @@ struct RootParameterYamlDesc { } } - RootParameterYamlDesc &operator=(const RootParameterYamlDesc &other) { - if (this != &other) { + RootParameterYamlDesc &operator=(const RootParameterYamlDesc &Other) { + if (this != &Other) { // First, destroy the current union member this->~RootParameterYamlDesc(); // Copy the basic members - Type = other.Type; - Visibility = other.Visibility; - Offset = other.Offset; + Type = Other.Type; + Visibility = Other.Visibility; + Offset = Other.Offset; // Initialize the new union member based on the Type from 'other' switch (Type) { case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): - new (&Constants) RootConstantsYaml(other.Constants); + new (&Constants) RootConstantsYaml(Other.Constants); break; case llvm::to_underlying(dxbc::RootParameterType::CBV): case llvm::to_underlying(dxbc::RootParameterType::SRV): case llvm::to_underlying(dxbc::RootParameterType::UAV): - new (&Descriptor) RootDescriptorYaml(other.Descriptor); + new (&Descriptor) RootDescriptorYaml(Other.Descriptor); break; case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): - new (&Table) DescriptorTableYaml(other.Table); + new (&Table) DescriptorTableYaml(Other.Table); break; } } return *this; } + // ToDo: Fix this (Already have a follow up PR with it) union { RootConstantsYaml Constants; RootDescriptorYaml Descriptor; - DescriptorTableYaml Table; }; + DescriptorTableYaml Table; }; struct RootSignatureYamlDesc { diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index 528fef59b46e4..c0a90dd50925c 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -97,9 +97,9 @@ DXContainerYAML::RootSignatureYamlDesc::create( #include "llvm/BinaryFormat/DXContainerConstants.def" } } else if (auto *TDV = dyn_cast>(&ParamView)) { + dxbc::RST0::v1::DescriptorRange>>(&ParamView)) { llvm::Expected< - object::DirectX::DescriptorTable> + object::DirectX::DescriptorTable> TableOrErr = TDV->read(); if (Error E = TableOrErr.takeError()) return std::move(E); @@ -116,13 +116,16 @@ DXContainerYAML::RootSignatureYamlDesc::create( NewR.BaseShaderRegister = R.BaseShaderRegister; NewR.RegisterSpace = R.RegisterSpace; NewR.RangeType = R.RangeType; - +#define DESCRIPTOR_RANGE_FLAG(Num, Val) \ + NewR.Val = \ + (R.Flags & llvm::to_underlying(dxbc::DescriptorRangeFlag::Val)) > 0; +#include "llvm/BinaryFormat/DXContainerConstants.def" NewP.Table.Ranges.push_back(NewR); } } else if (auto *TDV = dyn_cast>(&ParamView)) { + dxbc::RST0::v0::DescriptorRange>>(&ParamView)) { llvm::Expected< - object::DirectX::DescriptorTable> + object::DirectX::DescriptorTable> TableOrErr = TDV->read(); if (Error E = TableOrErr.takeError()) return std::move(E); @@ -139,10 +142,7 @@ DXContainerYAML::RootSignatureYamlDesc::create( NewR.BaseShaderRegister = R.BaseShaderRegister; NewR.RegisterSpace = R.RegisterSpace; NewR.RangeType = R.RangeType; -#define DESCRIPTOR_RANGE_FLAG(Num, Val) \ - NewR.Val = \ - (R.Flags & llvm::to_underlying(dxbc::DescriptorRangeFlag::Val)) > 0; -#include "llvm/BinaryFormat/DXContainerConstants.def" + NewP.Table.Ranges.push_back(NewR); } } diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml index d680bf09ab730..50cf7950be8aa 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml @@ -11,7 +11,7 @@ Header: PartOffsets: [ 60 ] Parts: - Name: RTS0 - Size: 96 + Size: 200 RootSignature: Version: 2 NumRootParameters: 3 @@ -51,32 +51,44 @@ Parts: AllowInputAssemblerInputLayout: true DenyGeometryShaderRootAccess: true -# CHECK: - Name: RTS0 -# CHECK-NEXT: Size: 96 -# CHECK-NEXT: RootSignature: -# CHECK-NEXT: Version: 2 -# CHECK-NEXT: NumRootParameters: 3 -# CHECK-NEXT: RootParametersOffset: 24 -# CHECK-NEXT: NumStaticSamplers: 0 -# CHECK-NEXT: StaticSamplersOffset: 60 -# CHECK-NEXT: Parameters: -# CHECK-NEXT: - ParameterType: 1 -# CHECK-NEXT: ShaderVisibility: 2 -# 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: Constants: -# CHECK-NEXT: Num32BitValues: 21 -# CHECK-NEXT: RegisterSpace: 23 -# CHECK-NEXT: ShaderRegister: 22 -# CHECK-NEXT: - ParameterType: 2 -# CHECK-NEXT: ShaderVisibility: 3 -# CHECK-NEXT: Descriptor: -# CHECK-NEXT: RegisterSpace: 32 -# CHECK-NEXT: ShaderRegister: 31 -# CHECK-NEXT: DATA_STATIC_WHILE_SET_AT_EXECUTE: true -# CHECK-NEXT: AllowInputAssemblerInputLayout: true -# CHECK-NEXT: DenyGeometryShaderRootAccess: true +#CHECK: - Name: RTS0 +#CHECK-NEXT: Size: 200 +#CHECK-NEXT: RootSignature: +#CHECK-NEXT: Version: 2 +#CHECK-NEXT: NumRootParameters: 4 +#CHECK-NEXT: RootParametersOffset: 24 +#CHECK-NEXT: NumStaticSamplers: 0 +#CHECK-NEXT: StaticSamplersOffset: 60 +#CHECK-NEXT: Parameters: +#CHECK-NEXT: - ParameterType: 1 +#CHECK-NEXT: ShaderVisibility: 2 +#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: Constants: +#CHECK-NEXT: Num32BitValues: 21 +#CHECK-NEXT: RegisterSpace: 23 +#CHECK-NEXT: ShaderRegister: 22 +#CHECK-NEXT: - ParameterType: 2 +#CHECK-NEXT: ShaderVisibility: 3 +#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: Table: +#CHECK-NEXT: NumRanges: 1 +#CHECK-NEXT: RangesOffset: 116 +#CHECK-NEXT: Ranges: +#CHECK-NEXT: - RangeType: 0 +#CHECK-NEXT: NumDescriptors: 41 +#CHECK-NEXT: BaseShaderRegister: 42 +#CHECK-NEXT: RegisterSpace: 43 +#CHECK-NEXT: OffsetInDescriptorsFromTableStart: -1 +#CHECK-NEXT: DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS: true +#CHECK-NEXT: AllowInputAssemblerInputLayout: true +#CHECK-NEXT: DenyGeometryShaderRootAccess: true From 93e04bd0e8e072ad761bdb53b9afd08de7358102 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Fri, 2 May 2025 16:55:47 +0000 Subject: [PATCH 16/31] adding tests --- llvm/unittests/Object/DXContainerTest.cpp | 108 ++++++++++++++++++ .../ObjectYAML/DXContainerYAMLTest.cpp | 2 +- 2 files changed, 109 insertions(+), 1 deletion(-) diff --git a/llvm/unittests/Object/DXContainerTest.cpp b/llvm/unittests/Object/DXContainerTest.cpp index 72f860a5039ff..b01b8ad2bad44 100644 --- a/llvm/unittests/Object/DXContainerTest.cpp +++ b/llvm/unittests/Object/DXContainerTest.cpp @@ -8,6 +8,7 @@ #include "llvm/Object/DXContainer.h" #include "llvm/ADT/StringRef.h" +#include "llvm/BinaryFormat/DXContainer.h" #include "llvm/BinaryFormat/Magic.h" #include "llvm/ObjectYAML/DXContainerYAML.h" #include "llvm/ObjectYAML/yaml2obj.h" @@ -1050,3 +1051,110 @@ TEST(RootSignature, ParseRootDescriptor) { ASSERT_EQ(Descriptor->Flags, 4u); } } + +TEST(RootSignature, ParseDescriptorTable) { + { + uint8_t Buffer[] = { + 0x44, 0x58, 0x42, 0x43, 0x32, 0x9a, 0x53, 0xd8, 0xec, 0xbe, 0x35, 0x6f, + 0x05, 0x39, 0xe1, 0xfe, 0x31, 0x20, 0xf0, 0xc1, 0x01, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, + 0x52, 0x54, 0x53, 0x30, 0x59, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3c, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, + 0x2a, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00}; + DXContainer C = + llvm::cantFail(DXContainer::create(getMemoryBuffer<133>(Buffer))); + + auto MaybeRS = C.getRootSignature(); + ASSERT_TRUE(MaybeRS.has_value()); + const auto &RS = MaybeRS.value(); + ASSERT_EQ(RS.getVersion(), 2u); + ASSERT_EQ(RS.getNumParameters(), 1u); + ASSERT_EQ(RS.getRootParametersOffset(), 24u); + ASSERT_EQ(RS.getNumStaticSamplers(), 0u); + ASSERT_EQ(RS.getStaticSamplersOffset(), 60u); + ASSERT_EQ(RS.getFlags(), 17u); + + auto RootParam = *RS.param_headers().begin(); + ASSERT_EQ((unsigned)RootParam.ParameterType, 0u); + ASSERT_EQ((unsigned)RootParam.ShaderVisibility, 3u); + auto ParamView = RS.getParameter(RootParam); + ASSERT_THAT_ERROR(ParamView.takeError(), Succeeded()); + + auto *DescriptorTableView = + dyn_cast>( + &*ParamView); + ASSERT_TRUE(DescriptorTableView != nullptr); + auto Table = DescriptorTableView->read(); + + ASSERT_THAT_ERROR(Table.takeError(), Succeeded()); + + ASSERT_EQ(Table->NumRanges, 1u); + + auto Range = *Table->begin(); + + ASSERT_EQ(Range.RangeType, 0u); + ASSERT_EQ(Range.NumDescriptors, 41u); + ASSERT_EQ(Range.BaseShaderRegister, 42u); + ASSERT_EQ(Range.RegisterSpace, 43u); + ASSERT_EQ(Range.OffsetInDescriptorsFromTableStart, -1); + ASSERT_EQ(Range.Flags, 65536u); + } + + { + uint8_t Buffer[] = { + 0x44, 0x58, 0x42, 0x43, 0x32, 0x9a, 0x53, 0xd8, 0xec, 0xbe, 0x35, 0x6f, + 0x05, 0x39, 0xe1, 0xfe, 0x31, 0x20, 0xf0, 0xc1, 0x01, 0x00, 0x00, 0x00, + 0x85, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, + 0x52, 0x54, 0x53, 0x30, 0x59, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x01, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x3c, 0x00, 0x00, 0x00, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x03, 0x00, 0x00, 0x00, 0x24, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, + 0x2c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x00, 0x00, 0x00, + 0x2a, 0x00, 0x00, 0x00, 0x2b, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00}; + DXContainer C = + llvm::cantFail(DXContainer::create(getMemoryBuffer<133>(Buffer))); + + auto MaybeRS = C.getRootSignature(); + ASSERT_TRUE(MaybeRS.has_value()); + const auto &RS = MaybeRS.value(); + ASSERT_EQ(RS.getVersion(), 1u); + ASSERT_EQ(RS.getNumParameters(), 1u); + ASSERT_EQ(RS.getRootParametersOffset(), 24u); + ASSERT_EQ(RS.getNumStaticSamplers(), 0u); + ASSERT_EQ(RS.getStaticSamplersOffset(), 60u); + ASSERT_EQ(RS.getFlags(), 17u); + + auto RootParam = *RS.param_headers().begin(); + ASSERT_EQ((unsigned)RootParam.ParameterType, 0u); + ASSERT_EQ((unsigned)RootParam.ShaderVisibility, 3u); + auto ParamView = RS.getParameter(RootParam); + ASSERT_THAT_ERROR(ParamView.takeError(), Succeeded()); + + auto *DescriptorTableView = + dyn_cast>( + &*ParamView); + ASSERT_TRUE(DescriptorTableView != nullptr); + auto Table = DescriptorTableView->read(); + + ASSERT_THAT_ERROR(Table.takeError(), Succeeded()); + + ASSERT_EQ(Table->NumRanges, 1u); + + auto Range = *Table->begin(); + + ASSERT_EQ(Range.RangeType, 0u); + ASSERT_EQ(Range.NumDescriptors, 41u); + ASSERT_EQ(Range.BaseShaderRegister, 42u); + ASSERT_EQ(Range.RegisterSpace, 43u); + ASSERT_EQ(Range.OffsetInDescriptorsFromTableStart, -1); + } +} diff --git a/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp b/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp index 494a710af454a..fa3af7045a4fd 100644 --- a/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp +++ b/llvm/unittests/ObjectYAML/DXContainerYAMLTest.cpp @@ -435,7 +435,7 @@ TEST(RootSignature, ParseDescriptorTableV11) { NumStaticSamplers: 0 StaticSamplersOffset: 60 Parameters: - - ParameterType: 0 # SRV + - ParameterType: 0 # Descriptor Table ShaderVisibility: 3 # Domain Table: NumRanges: 1 From 2f6d579c9588338d7677a13f243896ffc972b944 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Fri, 2 May 2025 17:32:10 +0000 Subject: [PATCH 17/31] adding more tests --- .../RootSignature-DescriptorTable1.0.yaml | 57 ++++++++++++++++++ .../RootSignature-DescriptorTable1.1.yaml | 59 +++++++++++++++++++ 2 files changed, 116 insertions(+) create mode 100644 llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.0.yaml create mode 100644 llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.1.yaml diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.0.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.0.yaml new file mode 100644 index 0000000000000..f431afa3cd3d3 --- /dev/null +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.0.yaml @@ -0,0 +1,57 @@ +# RUN: yaml2obj %s | obj2yaml | FileCheck %s + +--- !dxcontainer +Header: + Hash: [ 0x32, 0x9A, 0x53, 0xD8, 0xEC, 0xBE, 0x35, 0x6F, 0x5, + 0x39, 0xE1, 0xFE, 0x31, 0x20, 0xF0, 0xC1 ] + Version: + Major: 1 + Minor: 0 + FileSize: 133 + PartCount: 1 + PartOffsets: [ 36 ] +Parts: +- Name: RTS0 + Size: 89 + RootSignature: + Version: 1 + NumRootParameters: 1 + RootParametersOffset: 24 + NumStaticSamplers: 0 + StaticSamplersOffset: 60 + Parameters: + - ParameterType: 0 # SRV + ShaderVisibility: 3 # Domain + Table: + NumRanges: 1 + Ranges: + - RangeType: 0 + NumDescriptors: 41 + BaseShaderRegister: 42 + RegisterSpace: 43 + OffsetInDescriptorsFromTableStart: -1 + AllowInputAssemblerInputLayout: true + DenyGeometryShaderRootAccess: true + +# CHECK: - Name: RTS0 +# CHECK-NEXT: Size: 89 +# CHECK-NEXT: RootSignature: +# CHECK-NEXT: Version: 1 +# CHECK-NEXT: NumRootParameters: 1 +# CHECK-NEXT: RootParametersOffset: 24 +# CHECK-NEXT: NumStaticSamplers: 0 +# CHECK-NEXT: StaticSamplersOffset: 60 +# CHECK-NEXT: Parameters: +# CHECK-NEXT: - ParameterType: 0 +# CHECK-NEXT: ShaderVisibility: 3 +# CHECK-NEXT: Table: +# CHECK-NEXT: NumRanges: 1 +# CHECK-NEXT: RangesOffset: 44 +# CHECK-NEXT: Ranges: +# CHECK-NEXT: - RangeType: 0 +# CHECK-NEXT: NumDescriptors: 41 +# CHECK-NEXT: BaseShaderRegister: 42 +# CHECK-NEXT: RegisterSpace: 43 +# CHECK-NEXT: OffsetInDescriptorsFromTableStart: -1 +# CHECK-NEXT: AllowInputAssemblerInputLayout: true +# CHECK-NEXT: DenyGeometryShaderRootAccess: true diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.1.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.1.yaml new file mode 100644 index 0000000000000..54899cae57bf9 --- /dev/null +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.1.yaml @@ -0,0 +1,59 @@ +# RUN: yaml2obj %s | obj2yaml | FileCheck %s + +--- !dxcontainer +Header: + Hash: [ 0x32, 0x9A, 0x53, 0xD8, 0xEC, 0xBE, 0x35, 0x6F, 0x5, + 0x39, 0xE1, 0xFE, 0x31, 0x20, 0xF0, 0xC1 ] + Version: + Major: 1 + Minor: 0 + FileSize: 133 + PartCount: 1 + PartOffsets: [ 36 ] +Parts: +- Name: RTS0 + Size: 89 + RootSignature: + Version: 2 + NumRootParameters: 1 + RootParametersOffset: 24 + NumStaticSamplers: 0 + StaticSamplersOffset: 60 + Parameters: + - ParameterType: 0 # SRV + ShaderVisibility: 3 # Domain + Table: + NumRanges: 1 + Ranges: + - RangeType: 0 + NumDescriptors: 41 + BaseShaderRegister: 42 + RegisterSpace: 43 + OffsetInDescriptorsFromTableStart: -1 + DATA_STATIC_WHILE_SET_AT_EXECUTE: true + AllowInputAssemblerInputLayout: true + DenyGeometryShaderRootAccess: true + +# CHECK: - Name: RTS0 +# CHECK-NEXT: Size: 89 +# CHECK-NEXT: RootSignature: +# CHECK-NEXT: Version: 2 +# CHECK-NEXT: NumRootParameters: 1 +# CHECK-NEXT: RootParametersOffset: 24 +# CHECK-NEXT: NumStaticSamplers: 0 +# CHECK-NEXT: StaticSamplersOffset: 60 +# CHECK-NEXT: Parameters: +# CHECK-NEXT: - ParameterType: 0 +# CHECK-NEXT: ShaderVisibility: 3 +# CHECK-NEXT: Table: +# CHECK-NEXT: NumRanges: 1 +# CHECK-NEXT: RangesOffset: 44 +# CHECK-NEXT: Ranges: +# CHECK-NEXT: - RangeType: 0 +# CHECK-NEXT: NumDescriptors: 41 +# CHECK-NEXT: BaseShaderRegister: 42 +# CHECK-NEXT: RegisterSpace: 43 +# CHECK-NEXT: OffsetInDescriptorsFromTableStart: -1 +# CHECK-NEXT: DATA_STATIC_WHILE_SET_AT_EXECUTE: true +# CHECK-NEXT: AllowInputAssemblerInputLayout: true +# CHECK-NEXT: DenyGeometryShaderRootAccess: true From 76b1b75856b109490616cf1c2df5bc02d67e8d02 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Fri, 2 May 2025 17:51:03 +0000 Subject: [PATCH 18/31] clean up --- llvm/include/llvm/Object/DXContainer.h | 6 ------ llvm/unittests/Object/DXContainerTest.cpp | 1 - 2 files changed, 7 deletions(-) diff --git a/llvm/include/llvm/Object/DXContainer.h b/llvm/include/llvm/Object/DXContainer.h index 26764289631a3..c6c22213d7de8 100644 --- a/llvm/include/llvm/Object/DXContainer.h +++ b/llvm/include/llvm/Object/DXContainer.h @@ -40,11 +40,6 @@ std::enable_if_t::value, void> swapBytes(T &value) { value.swapBytes(); } -struct TypeIdGenerator { - static inline size_t nextId = 0; - - static size_t getNextId() { return nextId++; } -}; } // namespace detail // This class provides a view into the underlying resource array. The Resource @@ -289,7 +284,6 @@ class RootSignature { DataSize = sizeof(dxbc::RST0::v1::DescriptorRange) * NumRanges + 2 * sizeof(uint32_t); break; - break; } size_t EndOfSectionByte = getNumStaticSamplers() == 0 ? PartData.size() diff --git a/llvm/unittests/Object/DXContainerTest.cpp b/llvm/unittests/Object/DXContainerTest.cpp index b01b8ad2bad44..955b832459879 100644 --- a/llvm/unittests/Object/DXContainerTest.cpp +++ b/llvm/unittests/Object/DXContainerTest.cpp @@ -8,7 +8,6 @@ #include "llvm/Object/DXContainer.h" #include "llvm/ADT/StringRef.h" -#include "llvm/BinaryFormat/DXContainer.h" #include "llvm/BinaryFormat/Magic.h" #include "llvm/ObjectYAML/DXContainerYAML.h" #include "llvm/ObjectYAML/yaml2obj.h" From b2bfb0257cfd424dafbc9a46542528ade42a17ad Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Fri, 2 May 2025 00:42:56 +0000 Subject: [PATCH 19/31] refactoring root signature dxcontainer yaml representation --- .../include/llvm/ObjectYAML/DXContainerYAML.h | 96 +++---------------- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 41 ++++---- llvm/lib/ObjectYAML/DXContainerYAML.cpp | 82 +++++++++------- .../RootSignature-MultipleParameters.yaml | 11 --- 4 files changed, 83 insertions(+), 147 deletions(-) diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h index 9cf0f8df1debf..d8d025fe4294b 100644 --- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h +++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h @@ -26,6 +26,7 @@ #include #include #include +#include #include namespace llvm { @@ -112,98 +113,23 @@ struct DescriptorTableYaml { SmallVector Ranges; }; + +using ParameterData = std::variant< +RootConstantsYaml, +RootDescriptorYaml, +DescriptorTableYaml +>; + struct RootParameterYamlDesc { uint32_t Type; uint32_t Visibility; uint32_t Offset; + ParameterData Data; + RootParameterYamlDesc(){}; RootParameterYamlDesc(uint32_t T) : Type(T) { - switch (T) { - - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): - Constants = RootConstantsYaml(); - break; - case llvm::to_underlying(dxbc::RootParameterType::CBV): - case llvm::to_underlying(dxbc::RootParameterType::SRV): - case llvm::to_underlying(dxbc::RootParameterType::UAV): - Descriptor = RootDescriptorYaml(); - break; - case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): - Table = DescriptorTableYaml(); - break; - } - } - - ~RootParameterYamlDesc() { - switch (Type) { - - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): - Constants.~RootConstantsYaml(); - break; - case llvm::to_underlying(dxbc::RootParameterType::CBV): - case llvm::to_underlying(dxbc::RootParameterType::SRV): - case llvm::to_underlying(dxbc::RootParameterType::UAV): - Descriptor.~RootDescriptorYaml(); - break; - case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): - Table.~DescriptorTableYaml(); - break; - } + } - - RootParameterYamlDesc(const RootParameterYamlDesc &Other) - : Type(Other.Type), Visibility(Other.Visibility), Offset(Other.Offset) { - // Initialize the appropriate union member based on Type - switch (Type) { - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): - // Placement new to construct the union member - new (&Constants) RootConstantsYaml(Other.Constants); - break; - case llvm::to_underlying(dxbc::RootParameterType::CBV): - case llvm::to_underlying(dxbc::RootParameterType::SRV): - case llvm::to_underlying(dxbc::RootParameterType::UAV): - new (&Descriptor) RootDescriptorYaml(Other.Descriptor); - break; - case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): - new (&Table) DescriptorTableYaml(Other.Table); - break; - } - } - - RootParameterYamlDesc &operator=(const RootParameterYamlDesc &Other) { - if (this != &Other) { - // First, destroy the current union member - this->~RootParameterYamlDesc(); - - // Copy the basic members - Type = Other.Type; - Visibility = Other.Visibility; - Offset = Other.Offset; - - // Initialize the new union member based on the Type from 'other' - switch (Type) { - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): - new (&Constants) RootConstantsYaml(Other.Constants); - break; - case llvm::to_underlying(dxbc::RootParameterType::CBV): - case llvm::to_underlying(dxbc::RootParameterType::SRV): - case llvm::to_underlying(dxbc::RootParameterType::UAV): - new (&Descriptor) RootDescriptorYaml(Other.Descriptor); - break; - case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): - new (&Table) DescriptorTableYaml(Other.Table); - break; - } - } - return *this; - } - - // ToDo: Fix this (Already have a follow up PR with it) - union { - RootConstantsYaml Constants; - RootDescriptorYaml Descriptor; - }; - DescriptorTableYaml Table; }; struct RootSignatureYamlDesc { diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index 6336a42c8e4ae..c2c0188a959b0 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -15,11 +15,13 @@ #include "llvm/BinaryFormat/DXContainer.h" #include "llvm/MC/DXContainerPSVInfo.h" #include "llvm/MC/DXContainerRootSignature.h" +#include "llvm/ObjectYAML/DXContainerYAML.h" #include "llvm/ObjectYAML/ObjectYAML.h" #include "llvm/ObjectYAML/yaml2obj.h" #include "llvm/Support/Errc.h" #include "llvm/Support/Error.h" #include "llvm/Support/raw_ostream.h" +#include using namespace llvm; @@ -278,33 +280,35 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { auto Header = dxbc::RootParameterHeader{Param.Type, Param.Visibility, Param.Offset}; - switch (Param.Type) { - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): + if(std::holds_alternative(Param.Data)){ + auto ConstantYaml = std::get(Param.Data); + dxbc::RootConstants Constants; - Constants.Num32BitValues = Param.Constants.Num32BitValues; - Constants.RegisterSpace = Param.Constants.RegisterSpace; - Constants.ShaderRegister = Param.Constants.ShaderRegister; + Constants.Num32BitValues = ConstantYaml.Num32BitValues; + Constants.RegisterSpace = ConstantYaml.RegisterSpace; + Constants.ShaderRegister = ConstantYaml.ShaderRegister; RS.ParametersContainer.addParameter(Header, Constants); - break; - case llvm::to_underlying(dxbc::RootParameterType::SRV): - case llvm::to_underlying(dxbc::RootParameterType::UAV): - case llvm::to_underlying(dxbc::RootParameterType::CBV): + } else if (std::holds_alternative(Param.Data)){ + auto DescriptorYaml = std::get(Param.Data); + if (RS.Version == 1) { dxbc::RST0::v0::RootDescriptor Descriptor; - Descriptor.RegisterSpace = Param.Descriptor.RegisterSpace; - Descriptor.ShaderRegister = Param.Descriptor.ShaderRegister; + auto DescriptorYaml = std::get(Param.Data); + Descriptor.RegisterSpace = DescriptorYaml.RegisterSpace; + Descriptor.ShaderRegister = DescriptorYaml.ShaderRegister; RS.ParametersContainer.addParameter(Header, Descriptor); } else { dxbc::RST0::v1::RootDescriptor Descriptor; - Descriptor.RegisterSpace = Param.Descriptor.RegisterSpace; - Descriptor.ShaderRegister = Param.Descriptor.ShaderRegister; - Descriptor.Flags = Param.Descriptor.getEncodedFlags(); + Descriptor.RegisterSpace = DescriptorYaml.RegisterSpace; + Descriptor.ShaderRegister = DescriptorYaml.ShaderRegister; + Descriptor.Flags = DescriptorYaml.getEncodedFlags(); RS.ParametersContainer.addParameter(Header, Descriptor); } - break; - case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): { + }else if (std::holds_alternative(Param.Data)) { mcdxbc::DescriptorTable Table; - for (const auto &R : Param.Table.Ranges) { + auto TableYaml = std::get(Param.Data); + + for (const auto &R : TableYaml.Ranges) { if (RS.Version == 1) { dxbc::RST0::v0::DescriptorRange Range; Range.RangeType = R.RangeType; @@ -327,8 +331,7 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { } } RS.ParametersContainer.addParameter(Header, Table); - } break; - default: + } else { // Handling invalid parameter type edge case RS.ParametersContainer.addInfo(Header, -1); } diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index c0a90dd50925c..3fea73c0da447 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -76,10 +76,11 @@ DXContainerYAML::RootSignatureYamlDesc::create( return std::move(E); auto Constants = *ConstantsOrErr; - - NewP.Constants.Num32BitValues = Constants.Num32BitValues; - NewP.Constants.ShaderRegister = Constants.ShaderRegister; - NewP.Constants.RegisterSpace = Constants.RegisterSpace; + RootConstantsYaml ConstantYaml; + ConstantYaml.Num32BitValues = Constants.Num32BitValues; + ConstantYaml.ShaderRegister = Constants.ShaderRegister; + ConstantYaml.RegisterSpace = Constants.RegisterSpace; + NewP.Data = ConstantYaml; } else if (auto *RDV = dyn_cast(&ParamView)) { llvm::Expected DescriptorOrErr = @@ -87,25 +88,28 @@ DXContainerYAML::RootSignatureYamlDesc::create( if (Error E = DescriptorOrErr.takeError()) return std::move(E); auto Descriptor = *DescriptorOrErr; - NewP.Descriptor.ShaderRegister = Descriptor.ShaderRegister; - NewP.Descriptor.RegisterSpace = Descriptor.RegisterSpace; + RootDescriptorYaml YamlDescriptor; + YamlDescriptor.ShaderRegister = Descriptor.ShaderRegister; + YamlDescriptor.RegisterSpace = Descriptor.RegisterSpace; if (Version > 1) { #define ROOT_DESCRIPTOR_FLAG(Num, Val) \ - NewP.Descriptor.Val = \ + YamlDescriptor.Val = \ (Descriptor.Flags & \ llvm::to_underlying(dxbc::RootDescriptorFlag::Val)) > 0; #include "llvm/BinaryFormat/DXContainerConstants.def" } + NewP.Data = YamlDescriptor; } else if (auto *TDV = dyn_cast>(&ParamView)) { + dxbc::RST0::v0::DescriptorRange>>(&ParamView)) { llvm::Expected< - object::DirectX::DescriptorTable> + object::DirectX::DescriptorTable> TableOrErr = TDV->read(); if (Error E = TableOrErr.takeError()) return std::move(E); auto Table = *TableOrErr; - NewP.Table.NumRanges = Table.NumRanges; - NewP.Table.RangesOffset = Table.RangesOffset; + DescriptorTableYaml YamlTable; + YamlTable.NumRanges = Table.NumRanges; + YamlTable.RangesOffset = Table.RangesOffset; for (const auto &R : Table) { DescriptorRangeYaml NewR; @@ -116,22 +120,21 @@ DXContainerYAML::RootSignatureYamlDesc::create( NewR.BaseShaderRegister = R.BaseShaderRegister; NewR.RegisterSpace = R.RegisterSpace; NewR.RangeType = R.RangeType; -#define DESCRIPTOR_RANGE_FLAG(Num, Val) \ - NewR.Val = \ - (R.Flags & llvm::to_underlying(dxbc::DescriptorRangeFlag::Val)) > 0; -#include "llvm/BinaryFormat/DXContainerConstants.def" - NewP.Table.Ranges.push_back(NewR); + + YamlTable.Ranges.push_back(NewR); } + NewP.Data = YamlTable; } else if (auto *TDV = dyn_cast>(&ParamView)) { + dxbc::RST0::v1::DescriptorRange>>(&ParamView)) { llvm::Expected< - object::DirectX::DescriptorTable> + object::DirectX::DescriptorTable> TableOrErr = TDV->read(); if (Error E = TableOrErr.takeError()) return std::move(E); auto Table = *TableOrErr; - NewP.Table.NumRanges = Table.NumRanges; - NewP.Table.RangesOffset = Table.RangesOffset; + DescriptorTableYaml YamlTable; + YamlTable.NumRanges = Table.NumRanges; + YamlTable.RangesOffset = Table.RangesOffset; for (const auto &R : Table) { DescriptorRangeYaml NewR; @@ -142,9 +145,13 @@ DXContainerYAML::RootSignatureYamlDesc::create( NewR.BaseShaderRegister = R.BaseShaderRegister; NewR.RegisterSpace = R.RegisterSpace; NewR.RangeType = R.RangeType; - - NewP.Table.Ranges.push_back(NewR); +#define DESCRIPTOR_RANGE_FLAG(Num, Val) \ + NewR.Val = \ + (R.Flags & llvm::to_underlying(dxbc::DescriptorRangeFlag::Val)) > 0; +#include "llvm/BinaryFormat/DXContainerConstants.def" + YamlTable.Ranges.push_back(NewR); } + NewP.Data = YamlTable; } RootSigDesc.Parameters.push_back(NewP); @@ -394,18 +401,29 @@ void MappingTraits::mapping( IO.mapRequired("ShaderVisibility", P.Visibility); switch (P.Type) { - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): - IO.mapRequired("Constants", P.Constants); - break; + case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): { + DXContainerYAML::RootConstantsYaml Constants; + if(IO.outputting()) + Constants = std::get(P.Data); + IO.mapRequired("Constants", Constants); + P.Data = Constants; + } break; case llvm::to_underlying(dxbc::RootParameterType::CBV): case llvm::to_underlying(dxbc::RootParameterType::SRV): - case llvm::to_underlying(dxbc::RootParameterType::UAV): - IO.mapRequired("Descriptor", P.Descriptor); - break; - case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): - IO.mapRequired("Table", P.Table); - break; - break; + case llvm::to_underlying(dxbc::RootParameterType::UAV):{ + DXContainerYAML::RootDescriptorYaml Descriptor; + if(IO.outputting()) + Descriptor = std::get(P.Data); + IO.mapRequired("Descriptor", Descriptor); + P.Data = Descriptor; + } break; + case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): { + DXContainerYAML::DescriptorTableYaml Table; + if(IO.outputting()) + Table = std::get(P.Data); + IO.mapRequired("Table", Table); + P.Data = Table; + } break; } } diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml index 50cf7950be8aa..756de8ff12578 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml @@ -37,17 +37,6 @@ Parts: ShaderRegister: 31 RegisterSpace: 32 DATA_STATIC_WHILE_SET_AT_EXECUTE: true - - ParameterType: 0 # SRV - ShaderVisibility: 3 # Domain - Table: - NumRanges: 1 - Ranges: - - RangeType: 0 - NumDescriptors: 41 - BaseShaderRegister: 42 - RegisterSpace: 43 - OffsetInDescriptorsFromTableStart: -1 - DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS: true AllowInputAssemblerInputLayout: true DenyGeometryShaderRootAccess: true From 9ee29646ab571e052b4f31294fd4e0eb45c05832 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Fri, 2 May 2025 18:41:39 +0000 Subject: [PATCH 20/31] clean up --- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index c2c0188a959b0..738012b40608a 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -293,7 +293,6 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { if (RS.Version == 1) { dxbc::RST0::v0::RootDescriptor Descriptor; - auto DescriptorYaml = std::get(Param.Data); Descriptor.RegisterSpace = DescriptorYaml.RegisterSpace; Descriptor.ShaderRegister = DescriptorYaml.ShaderRegister; RS.ParametersContainer.addParameter(Header, Descriptor); From 2527580a3f2722b3c5619d45cd1c4cc4aba64e6b Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Fri, 2 May 2025 22:10:47 +0000 Subject: [PATCH 21/31] fix test --- .../include/llvm/ObjectYAML/DXContainerYAML.h | 12 +++-------- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 20 ++++++++++++------- llvm/lib/ObjectYAML/DXContainerYAML.cpp | 12 +++++------ .../RootSignature-MultipleParameters.yaml | 14 ++++++++++++- 4 files changed, 35 insertions(+), 23 deletions(-) diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h index d8d025fe4294b..549cf0b791e28 100644 --- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h +++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h @@ -113,12 +113,8 @@ struct DescriptorTableYaml { SmallVector Ranges; }; - -using ParameterData = std::variant< -RootConstantsYaml, -RootDescriptorYaml, -DescriptorTableYaml ->; +using ParameterData = + std::variant; struct RootParameterYamlDesc { uint32_t Type; @@ -127,9 +123,7 @@ struct RootParameterYamlDesc { ParameterData Data; RootParameterYamlDesc(){}; - RootParameterYamlDesc(uint32_t T) : Type(T) { - - } + RootParameterYamlDesc(uint32_t T) : Type(T) {} }; struct RootSignatureYamlDesc { diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index 738012b40608a..9f31f4efdeab7 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -280,16 +280,20 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { auto Header = dxbc::RootParameterHeader{Param.Type, Param.Visibility, Param.Offset}; - if(std::holds_alternative(Param.Data)){ - auto ConstantYaml = std::get(Param.Data); + if (std::holds_alternative( + Param.Data)) { + auto ConstantYaml = + std::get(Param.Data); dxbc::RootConstants Constants; Constants.Num32BitValues = ConstantYaml.Num32BitValues; Constants.RegisterSpace = ConstantYaml.RegisterSpace; Constants.ShaderRegister = ConstantYaml.ShaderRegister; RS.ParametersContainer.addParameter(Header, Constants); - } else if (std::holds_alternative(Param.Data)){ - auto DescriptorYaml = std::get(Param.Data); + } else if (std::holds_alternative( + Param.Data)) { + auto DescriptorYaml = + std::get(Param.Data); if (RS.Version == 1) { dxbc::RST0::v0::RootDescriptor Descriptor; @@ -301,11 +305,13 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { Descriptor.RegisterSpace = DescriptorYaml.RegisterSpace; Descriptor.ShaderRegister = DescriptorYaml.ShaderRegister; Descriptor.Flags = DescriptorYaml.getEncodedFlags(); - RS.ParametersContainer.addParameter(Header, Descriptor); + RS.ParametersContainer.addParameter(Header, Descriptor); } - }else if (std::holds_alternative(Param.Data)) { + } else if (std::holds_alternative( + Param.Data)) { mcdxbc::DescriptorTable Table; - auto TableYaml = std::get(Param.Data); + auto TableYaml = + std::get(Param.Data); for (const auto &R : TableYaml.Ranges) { if (RS.Version == 1) { diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index 3fea73c0da447..8a578a838a249 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -93,7 +93,7 @@ DXContainerYAML::RootSignatureYamlDesc::create( YamlDescriptor.RegisterSpace = Descriptor.RegisterSpace; if (Version > 1) { #define ROOT_DESCRIPTOR_FLAG(Num, Val) \ - YamlDescriptor.Val = \ + YamlDescriptor.Val = \ (Descriptor.Flags & \ llvm::to_underlying(dxbc::RootDescriptorFlag::Val)) > 0; #include "llvm/BinaryFormat/DXContainerConstants.def" @@ -403,24 +403,24 @@ void MappingTraits::mapping( switch (P.Type) { case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): { DXContainerYAML::RootConstantsYaml Constants; - if(IO.outputting()) + if (IO.outputting()) Constants = std::get(P.Data); IO.mapRequired("Constants", Constants); P.Data = Constants; } break; case llvm::to_underlying(dxbc::RootParameterType::CBV): case llvm::to_underlying(dxbc::RootParameterType::SRV): - case llvm::to_underlying(dxbc::RootParameterType::UAV):{ + case llvm::to_underlying(dxbc::RootParameterType::UAV): { DXContainerYAML::RootDescriptorYaml Descriptor; - if(IO.outputting()) + if (IO.outputting()) Descriptor = std::get(P.Data); IO.mapRequired("Descriptor", Descriptor); P.Data = Descriptor; } break; case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): { DXContainerYAML::DescriptorTableYaml Table; - if(IO.outputting()) - Table = std::get(P.Data); + if (IO.outputting()) + Table = std::get(P.Data); IO.mapRequired("Table", Table); P.Data = Table; } break; diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml index 756de8ff12578..e7cd3096c1a3f 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml @@ -14,7 +14,7 @@ Parts: Size: 200 RootSignature: Version: 2 - NumRootParameters: 3 + NumRootParameters: 4 RootParametersOffset: 24 NumStaticSamplers: 0 StaticSamplersOffset: 60 @@ -37,6 +37,18 @@ Parts: ShaderRegister: 31 RegisterSpace: 32 DATA_STATIC_WHILE_SET_AT_EXECUTE: true + - ParameterType: 0 + ShaderVisibility: 3 + Table: + NumRanges: 1 + RangesOffset: 116 + Ranges: + - RangeType: 0 + NumDescriptors: 41 + BaseShaderRegister: 42 + RegisterSpace: 43 + OffsetInDescriptorsFromTableStart: -1 + DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS: true AllowInputAssemblerInputLayout: true DenyGeometryShaderRootAccess: true From c3a46da551382a5494f1ccd5bffa24886fe527a4 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Fri, 2 May 2025 22:18:20 +0000 Subject: [PATCH 22/31] copy test --- .../RootSignature-MultipleParameters.yaml | 15 +++++++-------- 1 file changed, 7 insertions(+), 8 deletions(-) diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml index e7cd3096c1a3f..50cf7950be8aa 100644 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml +++ b/llvm/test/ObjectYAML/DXContainer/RootSignature-MultipleParameters.yaml @@ -14,7 +14,7 @@ Parts: Size: 200 RootSignature: Version: 2 - NumRootParameters: 4 + NumRootParameters: 3 RootParametersOffset: 24 NumStaticSamplers: 0 StaticSamplersOffset: 60 @@ -37,16 +37,15 @@ Parts: ShaderRegister: 31 RegisterSpace: 32 DATA_STATIC_WHILE_SET_AT_EXECUTE: true - - ParameterType: 0 - ShaderVisibility: 3 + - ParameterType: 0 # SRV + ShaderVisibility: 3 # Domain Table: - NumRanges: 1 - RangesOffset: 116 + NumRanges: 1 Ranges: - - RangeType: 0 - NumDescriptors: 41 + - RangeType: 0 + NumDescriptors: 41 BaseShaderRegister: 42 - RegisterSpace: 43 + RegisterSpace: 43 OffsetInDescriptorsFromTableStart: -1 DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS: true AllowInputAssemblerInputLayout: true From 0136cfcc31a41a84d5d088b6a646fdaf78c23bb9 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Thu, 22 May 2025 19:12:14 +0000 Subject: [PATCH 23/31] fix testing issues --- .../BinaryFormat/DXContainerConstants.def | 1 - llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 46 +--------- llvm/lib/ObjectYAML/DXContainerYAML.cpp | 91 +------------------ .../RootSignature-DescriptorTable1.0.yaml | 57 ------------ .../RootSignature-DescriptorTable1.1.yaml | 59 ------------ 5 files changed, 6 insertions(+), 248 deletions(-) delete mode 100644 llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.0.yaml delete mode 100644 llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.1.yaml diff --git a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def index f617b82bd0d12..f7edfb1c92a67 100644 --- a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def +++ b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def @@ -88,7 +88,6 @@ ROOT_DESCRIPTOR_FLAG(3, DATA_STATIC) #ifdef ROOT_PARAMETER -ROOT_PARAMETER(0, DescriptorTable) ROOT_PARAMETER(1, Constants32Bit) ROOT_PARAMETER(2, CBV) ROOT_PARAMETER(3, SRV) diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index 9f31f4efdeab7..a1ed734cbdcd9 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -294,48 +294,12 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { Param.Data)) { auto DescriptorYaml = std::get(Param.Data); - - if (RS.Version == 1) { - dxbc::RST0::v0::RootDescriptor Descriptor; - Descriptor.RegisterSpace = DescriptorYaml.RegisterSpace; - Descriptor.ShaderRegister = DescriptorYaml.ShaderRegister; - RS.ParametersContainer.addParameter(Header, Descriptor); - } else { - dxbc::RST0::v1::RootDescriptor Descriptor; - Descriptor.RegisterSpace = DescriptorYaml.RegisterSpace; - Descriptor.ShaderRegister = DescriptorYaml.ShaderRegister; + dxbc::RTS0::v2::RootDescriptor Descriptor; + Descriptor.RegisterSpace = DescriptorYaml.RegisterSpace; + Descriptor.ShaderRegister = DescriptorYaml.ShaderRegister; + if (RS.Version > 1) Descriptor.Flags = DescriptorYaml.getEncodedFlags(); - RS.ParametersContainer.addParameter(Header, Descriptor); - } - } else if (std::holds_alternative( - Param.Data)) { - mcdxbc::DescriptorTable Table; - auto TableYaml = - std::get(Param.Data); - - for (const auto &R : TableYaml.Ranges) { - if (RS.Version == 1) { - dxbc::RST0::v0::DescriptorRange Range; - Range.RangeType = R.RangeType; - Range.NumDescriptors = R.NumDescriptors; - Range.BaseShaderRegister = R.BaseShaderRegister; - Range.RegisterSpace = R.RegisterSpace; - Range.OffsetInDescriptorsFromTableStart = - R.OffsetInDescriptorsFromTableStart; - Table.Ranges.push_back(Range); - } else { - dxbc::RST0::v1::DescriptorRange Range; - Range.RangeType = R.RangeType; - Range.NumDescriptors = R.NumDescriptors; - Range.BaseShaderRegister = R.BaseShaderRegister; - Range.RegisterSpace = R.RegisterSpace; - Range.OffsetInDescriptorsFromTableStart = - R.OffsetInDescriptorsFromTableStart; - Range.Flags = R.getEncodedFlags(); - Table.Ranges.push_back(Range); - } - } - RS.ParametersContainer.addParameter(Header, Table); + RS.ParametersContainer.addParameter(Header, Descriptor); } else { // Handling invalid parameter type edge case RS.ParametersContainer.addInfo(Header, -1); diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index 96c1936648192..cc17ad178ff28 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -40,7 +40,6 @@ DXContainerYAML::RootSignatureYamlDesc::create( RootSignatureYamlDesc RootSigDesc; uint32_t Version = Data.getVersion(); - uint32_t Version = Data.getVersion(); RootSigDesc.Version = Version; RootSigDesc.NumStaticSamplers = Data.getNumStaticSamplers(); @@ -84,7 +83,7 @@ DXContainerYAML::RootSignatureYamlDesc::create( NewP.Data = ConstantYaml; } else if (auto *RDV = dyn_cast(&ParamView)) { - llvm::Expected DescriptorOrErr = + llvm::Expected DescriptorOrErr = RDV->read(Version); if (Error E = DescriptorOrErr.takeError()) return std::move(E); @@ -100,59 +99,6 @@ DXContainerYAML::RootSignatureYamlDesc::create( #include "llvm/BinaryFormat/DXContainerConstants.def" } NewP.Data = YamlDescriptor; - } else if (auto *TDV = dyn_cast>(&ParamView)) { - llvm::Expected< - object::DirectX::DescriptorTable> - TableOrErr = TDV->read(); - if (Error E = TableOrErr.takeError()) - return std::move(E); - auto Table = *TableOrErr; - DescriptorTableYaml YamlTable; - YamlTable.NumRanges = Table.NumRanges; - YamlTable.RangesOffset = Table.RangesOffset; - - for (const auto &R : Table) { - DescriptorRangeYaml NewR; - - NewR.OffsetInDescriptorsFromTableStart = - R.OffsetInDescriptorsFromTableStart; - NewR.NumDescriptors = R.NumDescriptors; - NewR.BaseShaderRegister = R.BaseShaderRegister; - NewR.RegisterSpace = R.RegisterSpace; - NewR.RangeType = R.RangeType; - - YamlTable.Ranges.push_back(NewR); - } - NewP.Data = YamlTable; - } else if (auto *TDV = dyn_cast>(&ParamView)) { - llvm::Expected< - object::DirectX::DescriptorTable> - TableOrErr = TDV->read(); - if (Error E = TableOrErr.takeError()) - return std::move(E); - auto Table = *TableOrErr; - DescriptorTableYaml YamlTable; - YamlTable.NumRanges = Table.NumRanges; - YamlTable.RangesOffset = Table.RangesOffset; - - for (const auto &R : Table) { - DescriptorRangeYaml NewR; - - NewR.OffsetInDescriptorsFromTableStart = - R.OffsetInDescriptorsFromTableStart; - NewR.NumDescriptors = R.NumDescriptors; - NewR.BaseShaderRegister = R.BaseShaderRegister; - NewR.RegisterSpace = R.RegisterSpace; - NewR.RangeType = R.RangeType; -#define DESCRIPTOR_RANGE_FLAG(Num, Val) \ - NewR.Val = \ - (R.Flags & llvm::to_underlying(dxbc::DescriptorRangeFlag::Val)) > 0; -#include "llvm/BinaryFormat/DXContainerConstants.def" - YamlTable.Ranges.push_back(NewR); - } - NewP.Data = YamlTable; } RootSigDesc.Parameters.push_back(NewP); @@ -182,15 +128,6 @@ uint32_t DXContainerYAML::RootSignatureYamlDesc::getEncodedFlags() { return Flag; } -uint32_t DXContainerYAML::DescriptorRangeYaml::getEncodedFlags() const { - uint64_t Flag = 0; -#define DESCRIPTOR_RANGE_FLAG(Num, Val) \ - if (Val) \ - Flag |= (uint32_t)dxbc::DescriptorRangeFlag::Val; -#include "llvm/BinaryFormat/DXContainerConstants.def" - return Flag; -} - uint64_t DXContainerYAML::ShaderFeatureFlags::getEncodedFlags() { uint64_t Flag = 0; #define SHADER_FEATURE_FLAG(Num, DxilModuleNum, Val, Str) \ @@ -377,25 +314,6 @@ void MappingTraits::mapping( #include "llvm/BinaryFormat/DXContainerConstants.def" } -void MappingTraits::mapping( - IO &IO, llvm::DXContainerYAML::DescriptorRangeYaml &R) { - IO.mapRequired("RangeType", R.RangeType); - IO.mapRequired("NumDescriptors", R.NumDescriptors); - IO.mapRequired("BaseShaderRegister", R.BaseShaderRegister); - IO.mapRequired("RegisterSpace", R.RegisterSpace); - IO.mapRequired("OffsetInDescriptorsFromTableStart", - R.OffsetInDescriptorsFromTableStart); -#define DESCRIPTOR_RANGE_FLAG(Num, Val) IO.mapOptional(#Val, R.Val, false); -#include "llvm/BinaryFormat/DXContainerConstants.def" -} - -void MappingTraits::mapping( - IO &IO, llvm::DXContainerYAML::DescriptorTableYaml &T) { - IO.mapRequired("NumRanges", T.NumRanges); - IO.mapOptional("RangesOffset", T.RangesOffset); - IO.mapRequired("Ranges", T.Ranges); -} - void MappingTraits::mapping( IO &IO, llvm::DXContainerYAML::RootParameterYamlDesc &P) { IO.mapRequired("ParameterType", P.Type); @@ -418,13 +336,6 @@ void MappingTraits::mapping( IO.mapRequired("Descriptor", Descriptor); P.Data = Descriptor; } break; - case llvm::to_underlying(dxbc::RootParameterType::DescriptorTable): { - DXContainerYAML::DescriptorTableYaml Table; - if (IO.outputting()) - Table = std::get(P.Data); - IO.mapRequired("Table", Table); - P.Data = Table; - } break; } } diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.0.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.0.yaml deleted file mode 100644 index f431afa3cd3d3..0000000000000 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.0.yaml +++ /dev/null @@ -1,57 +0,0 @@ -# RUN: yaml2obj %s | obj2yaml | FileCheck %s - ---- !dxcontainer -Header: - Hash: [ 0x32, 0x9A, 0x53, 0xD8, 0xEC, 0xBE, 0x35, 0x6F, 0x5, - 0x39, 0xE1, 0xFE, 0x31, 0x20, 0xF0, 0xC1 ] - Version: - Major: 1 - Minor: 0 - FileSize: 133 - PartCount: 1 - PartOffsets: [ 36 ] -Parts: -- Name: RTS0 - Size: 89 - RootSignature: - Version: 1 - NumRootParameters: 1 - RootParametersOffset: 24 - NumStaticSamplers: 0 - StaticSamplersOffset: 60 - Parameters: - - ParameterType: 0 # SRV - ShaderVisibility: 3 # Domain - Table: - NumRanges: 1 - Ranges: - - RangeType: 0 - NumDescriptors: 41 - BaseShaderRegister: 42 - RegisterSpace: 43 - OffsetInDescriptorsFromTableStart: -1 - AllowInputAssemblerInputLayout: true - DenyGeometryShaderRootAccess: true - -# CHECK: - Name: RTS0 -# CHECK-NEXT: Size: 89 -# CHECK-NEXT: RootSignature: -# CHECK-NEXT: Version: 1 -# CHECK-NEXT: NumRootParameters: 1 -# CHECK-NEXT: RootParametersOffset: 24 -# CHECK-NEXT: NumStaticSamplers: 0 -# CHECK-NEXT: StaticSamplersOffset: 60 -# CHECK-NEXT: Parameters: -# CHECK-NEXT: - ParameterType: 0 -# CHECK-NEXT: ShaderVisibility: 3 -# CHECK-NEXT: Table: -# CHECK-NEXT: NumRanges: 1 -# CHECK-NEXT: RangesOffset: 44 -# CHECK-NEXT: Ranges: -# CHECK-NEXT: - RangeType: 0 -# CHECK-NEXT: NumDescriptors: 41 -# CHECK-NEXT: BaseShaderRegister: 42 -# CHECK-NEXT: RegisterSpace: 43 -# CHECK-NEXT: OffsetInDescriptorsFromTableStart: -1 -# CHECK-NEXT: AllowInputAssemblerInputLayout: true -# CHECK-NEXT: DenyGeometryShaderRootAccess: true diff --git a/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.1.yaml b/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.1.yaml deleted file mode 100644 index 54899cae57bf9..0000000000000 --- a/llvm/test/ObjectYAML/DXContainer/RootSignature-DescriptorTable1.1.yaml +++ /dev/null @@ -1,59 +0,0 @@ -# RUN: yaml2obj %s | obj2yaml | FileCheck %s - ---- !dxcontainer -Header: - Hash: [ 0x32, 0x9A, 0x53, 0xD8, 0xEC, 0xBE, 0x35, 0x6F, 0x5, - 0x39, 0xE1, 0xFE, 0x31, 0x20, 0xF0, 0xC1 ] - Version: - Major: 1 - Minor: 0 - FileSize: 133 - PartCount: 1 - PartOffsets: [ 36 ] -Parts: -- Name: RTS0 - Size: 89 - RootSignature: - Version: 2 - NumRootParameters: 1 - RootParametersOffset: 24 - NumStaticSamplers: 0 - StaticSamplersOffset: 60 - Parameters: - - ParameterType: 0 # SRV - ShaderVisibility: 3 # Domain - Table: - NumRanges: 1 - Ranges: - - RangeType: 0 - NumDescriptors: 41 - BaseShaderRegister: 42 - RegisterSpace: 43 - OffsetInDescriptorsFromTableStart: -1 - DATA_STATIC_WHILE_SET_AT_EXECUTE: true - AllowInputAssemblerInputLayout: true - DenyGeometryShaderRootAccess: true - -# CHECK: - Name: RTS0 -# CHECK-NEXT: Size: 89 -# CHECK-NEXT: RootSignature: -# CHECK-NEXT: Version: 2 -# CHECK-NEXT: NumRootParameters: 1 -# CHECK-NEXT: RootParametersOffset: 24 -# CHECK-NEXT: NumStaticSamplers: 0 -# CHECK-NEXT: StaticSamplersOffset: 60 -# CHECK-NEXT: Parameters: -# CHECK-NEXT: - ParameterType: 0 -# CHECK-NEXT: ShaderVisibility: 3 -# CHECK-NEXT: Table: -# CHECK-NEXT: NumRanges: 1 -# CHECK-NEXT: RangesOffset: 44 -# CHECK-NEXT: Ranges: -# CHECK-NEXT: - RangeType: 0 -# CHECK-NEXT: NumDescriptors: 41 -# CHECK-NEXT: BaseShaderRegister: 42 -# CHECK-NEXT: RegisterSpace: 43 -# CHECK-NEXT: OffsetInDescriptorsFromTableStart: -1 -# CHECK-NEXT: DATA_STATIC_WHILE_SET_AT_EXECUTE: true -# CHECK-NEXT: AllowInputAssemblerInputLayout: true -# CHECK-NEXT: DenyGeometryShaderRootAccess: true From b589d10985113239fba55d465856152d97090d48 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Thu, 22 May 2025 19:26:38 +0000 Subject: [PATCH 24/31] clean up --- llvm/include/llvm/BinaryFormat/DXContainer.h | 7 ------- .../llvm/BinaryFormat/DXContainerConstants.def | 9 --------- llvm/include/llvm/MC/DXContainerRootSignature.h | 7 +------ llvm/include/llvm/Object/DXContainer.h | 17 +++++++---------- llvm/include/llvm/ObjectYAML/DXContainerYAML.h | 4 ---- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 3 --- llvm/lib/ObjectYAML/DXContainerYAML.cpp | 1 - llvm/lib/Target/DirectX/DXILRootSignature.cpp | 1 - 8 files changed, 8 insertions(+), 41 deletions(-) diff --git a/llvm/include/llvm/BinaryFormat/DXContainer.h b/llvm/include/llvm/BinaryFormat/DXContainer.h index 9124320bc9b07..82890bf814935 100644 --- a/llvm/include/llvm/BinaryFormat/DXContainer.h +++ b/llvm/include/llvm/BinaryFormat/DXContainer.h @@ -170,13 +170,6 @@ enum class RootParameterType : uint32_t { ArrayRef> getRootParameterTypes(); -#define DESCRIPTOR_RANGE(Val, Enum) Enum = Val, -enum class DescriptorRangeType : uint32_t { -#include "DXContainerConstants.def" -}; - -ArrayRef> getDescriptorRangeTypes(); - #define ROOT_PARAMETER(Val, Enum) \ case Val: \ return true; diff --git a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def index f7edfb1c92a67..d1927419f8d27 100644 --- a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def +++ b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def @@ -96,15 +96,6 @@ ROOT_PARAMETER(4, UAV) #endif // ROOT_PARAMETER -#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 SHADER_VISIBILITY SHADER_VISIBILITY(0, All) diff --git a/llvm/include/llvm/MC/DXContainerRootSignature.h b/llvm/include/llvm/MC/DXContainerRootSignature.h index cb04572133477..3496b5fff398f 100644 --- a/llvm/include/llvm/MC/DXContainerRootSignature.h +++ b/llvm/include/llvm/MC/DXContainerRootSignature.h @@ -6,14 +6,9 @@ // //===----------------------------------------------------------------------===// -#include "llvm/ADT/STLForwardCompat.h" -#include "llvm/ADT/SmallVector.h" #include "llvm/BinaryFormat/DXContainer.h" -#include #include -#include -#include -#include +#include namespace llvm { diff --git a/llvm/include/llvm/Object/DXContainer.h b/llvm/include/llvm/Object/DXContainer.h index b7f0beedd49a0..61bfa9411cc57 100644 --- a/llvm/include/llvm/Object/DXContainer.h +++ b/llvm/include/llvm/Object/DXContainer.h @@ -20,11 +20,12 @@ #include "llvm/ADT/Twine.h" #include "llvm/BinaryFormat/DXContainer.h" #include "llvm/Object/Error.h" -#include "llvm/Support/Casting.h" -#include "llvm/Support/Endian.h" #include "llvm/Support/Error.h" #include "llvm/Support/MemoryBufferRef.h" #include "llvm/TargetParser/Triple.h" +#include +#include +#include #include namespace llvm { @@ -40,7 +41,6 @@ template std::enable_if_t::value, void> swapBytes(T &value) { value.swapBytes(); } - } // namespace detail // This class provides a view into the underlying resource array. The Resource @@ -127,16 +127,13 @@ struct RootParameterView { RootParameterView(const dxbc::RootParameterHeader &H, StringRef P) : Header(H), ParamData(P) {} - template Expected readParameter() { - assert(sizeof(VersionT) <= sizeof(T) && - "Parameter of higher version must inherit all previous version data " - "members"); - if (sizeof(VersionT) != ParamData.size()) + template Expected readParameter() { + T Struct; + if (sizeof(T) != ParamData.size()) return make_error( "Reading structure out of file bounds", object_error::parse_failed); - T Struct; - memcpy(&Struct, ParamData.data(), sizeof(VersionT)); + memcpy(&Struct, ParamData.data(), sizeof(T)); // DXContainer is always little endian if (sys::IsBigEndianHost) Struct.swapBytes(); diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h index e55b8eea08679..4f8176cbbb852 100644 --- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h +++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h @@ -15,18 +15,14 @@ #ifndef LLVM_OBJECTYAML_DXCONTAINERYAML_H #define LLVM_OBJECTYAML_DXCONTAINERYAML_H -#include "llvm/ADT/STLForwardCompat.h" -#include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringRef.h" #include "llvm/BinaryFormat/DXContainer.h" #include "llvm/Object/DXContainer.h" #include "llvm/ObjectYAML/YAML.h" #include "llvm/Support/YAMLTraits.h" #include -#include #include #include -#include #include namespace llvm { diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index a1ed734cbdcd9..0d2a9ea8dd1db 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -11,17 +11,14 @@ /// //===----------------------------------------------------------------------===// -#include "llvm/ADT/STLForwardCompat.h" #include "llvm/BinaryFormat/DXContainer.h" #include "llvm/MC/DXContainerPSVInfo.h" #include "llvm/MC/DXContainerRootSignature.h" -#include "llvm/ObjectYAML/DXContainerYAML.h" #include "llvm/ObjectYAML/ObjectYAML.h" #include "llvm/ObjectYAML/yaml2obj.h" #include "llvm/Support/Errc.h" #include "llvm/Support/Error.h" #include "llvm/Support/raw_ostream.h" -#include using namespace llvm; diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index cc17ad178ff28..ece4d79fc1255 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -15,7 +15,6 @@ #include "llvm/ADT/STLForwardCompat.h" #include "llvm/ADT/ScopeExit.h" #include "llvm/BinaryFormat/DXContainer.h" -#include "llvm/Object/DXContainer.h" #include "llvm/Support/Error.h" #include "llvm/Support/ScopedPrinter.h" #include diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp index 732ded7084902..43e06ee278b49 100644 --- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp +++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp @@ -30,7 +30,6 @@ #include #include #include -#include using namespace llvm; using namespace llvm::dxil; From c7042b27f7463484dee22bff9ad4463f983710e8 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Thu, 22 May 2025 19:27:17 +0000 Subject: [PATCH 25/31] clean up --- llvm/include/llvm/BinaryFormat/DXContainerConstants.def | 1 - 1 file changed, 1 deletion(-) diff --git a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def index d1927419f8d27..81d2c54b6e07c 100644 --- a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def +++ b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def @@ -95,7 +95,6 @@ ROOT_PARAMETER(4, UAV) #undef ROOT_PARAMETER #endif // ROOT_PARAMETER - #ifdef SHADER_VISIBILITY SHADER_VISIBILITY(0, All) From 70a9b7f44cb03c1264df85474291d37db3eac9a5 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Thu, 22 May 2025 19:32:36 +0000 Subject: [PATCH 26/31] addressing PR Comments --- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 32 ++++++++++------------ 1 file changed, 15 insertions(+), 17 deletions(-) diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index 0d2a9ea8dd1db..ace2eca5072bd 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -277,29 +277,27 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { auto Header = dxbc::RootParameterHeader{Param.Type, Param.Visibility, Param.Offset}; - if (std::holds_alternative( - Param.Data)) { - auto ConstantYaml = - std::get(Param.Data); - + if (auto *ConstantYaml = + std::get_if(&Param.Data)) { dxbc::RootConstants Constants; - Constants.Num32BitValues = ConstantYaml.Num32BitValues; - Constants.RegisterSpace = ConstantYaml.RegisterSpace; - Constants.ShaderRegister = ConstantYaml.ShaderRegister; + Constants.Num32BitValues = ConstantYaml->Num32BitValues; + Constants.RegisterSpace = ConstantYaml->RegisterSpace; + Constants.ShaderRegister = ConstantYaml->ShaderRegister; RS.ParametersContainer.addParameter(Header, Constants); - } else if (std::holds_alternative( - Param.Data)) { - auto DescriptorYaml = - std::get(Param.Data); + } else if (auto *DescriptorYaml = + std::get_if( + &Param.Data)) { dxbc::RTS0::v2::RootDescriptor Descriptor; - Descriptor.RegisterSpace = DescriptorYaml.RegisterSpace; - Descriptor.ShaderRegister = DescriptorYaml.ShaderRegister; + Descriptor.RegisterSpace = DescriptorYaml->RegisterSpace; + Descriptor.ShaderRegister = DescriptorYaml->ShaderRegister; if (RS.Version > 1) - Descriptor.Flags = DescriptorYaml.getEncodedFlags(); + Descriptor.Flags = DescriptorYaml->getEncodedFlags(); RS.ParametersContainer.addParameter(Header, Descriptor); } else { - // Handling invalid parameter type edge case - RS.ParametersContainer.addInfo(Header, -1); + // 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); } } From f1dd0ce3c0d00f9334d88b753c6c838b417749f7 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Thu, 22 May 2025 19:41:02 +0000 Subject: [PATCH 27/31] formating --- llvm/include/llvm/ObjectYAML/DXContainerYAML.h | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h index 4f8176cbbb852..6312d4cb305da 100644 --- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h +++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h @@ -90,8 +90,7 @@ struct RootDescriptorYaml { #include "llvm/BinaryFormat/DXContainerConstants.def" }; -using ParameterData = - std::variant; +using ParameterData = std::variant; struct RootParameterYamlDesc { uint32_t Type; @@ -99,7 +98,7 @@ struct RootParameterYamlDesc { uint32_t Offset; ParameterData Data; - RootParameterYamlDesc(){}; + RootParameterYamlDesc() {}; RootParameterYamlDesc(uint32_t T) : Type(T) {} }; From aabd424d665437bfa8285fcfe5af1e86a0630730 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Fri, 23 May 2025 00:43:45 +0000 Subject: [PATCH 28/31] addressing comments --- llvm/lib/ObjectYAML/DXContainerYAML.cpp | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index ece4d79fc1255..fdb039e75fdda 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -324,7 +324,8 @@ void MappingTraits::mapping( if (IO.outputting()) Constants = std::get(P.Data); IO.mapRequired("Constants", Constants); - P.Data = Constants; + if (!IO.outputting()) + P.Data = Constants; } break; case llvm::to_underlying(dxbc::RootParameterType::CBV): case llvm::to_underlying(dxbc::RootParameterType::SRV): @@ -333,7 +334,8 @@ void MappingTraits::mapping( if (IO.outputting()) Descriptor = std::get(P.Data); IO.mapRequired("Descriptor", Descriptor); - P.Data = Descriptor; + if (!IO.outputting()) + P.Data = Descriptor; } break; } } From e8ab8f7380a3e8a560b144a6f6c24c60265c8fad Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Sat, 24 May 2025 05:53:53 +0000 Subject: [PATCH 29/31] addressing commets --- .../include/llvm/ObjectYAML/DXContainerYAML.h | 61 ++++++++++++---- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 38 ++++++---- llvm/lib/ObjectYAML/DXContainerYAML.cpp | 71 +++++++++---------- 3 files changed, 103 insertions(+), 67 deletions(-) diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h index 6312d4cb305da..444613a92d363 100644 --- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h +++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h @@ -21,6 +21,7 @@ #include "llvm/ObjectYAML/YAML.h" #include "llvm/Support/YAMLTraits.h" #include +#include #include #include #include @@ -90,18 +91,54 @@ struct RootDescriptorYaml { #include "llvm/BinaryFormat/DXContainerConstants.def" }; -using ParameterData = std::variant; - -struct RootParameterYamlDesc { +struct RootParameterHeaderYaml { uint32_t Type; uint32_t Visibility; uint32_t Offset; - ParameterData Data; - RootParameterYamlDesc() {}; - RootParameterYamlDesc(uint32_t T) : Type(T) {} + RootParameterHeaderYaml() {}; + RootParameterHeaderYaml(uint32_t T) : Type(T) {} +}; + +struct RootParameterLocationYaml { + RootParameterHeaderYaml Header; + std::optional IndexInSignature; + + RootParameterLocationYaml() {}; + explicit RootParameterLocationYaml(RootParameterHeaderYaml Header) : Header(Header) {} }; +struct RootParameterYamlDesc { + SmallVector Locations; + + SmallVector Constants; + SmallVector Descriptors; + + + template + T &getOrInsertImpl(RootParameterLocationYaml &ParamDesc, + SmallVectorImpl &Container) { + if (!ParamDesc.IndexInSignature) { + ParamDesc.IndexInSignature = Container.size(); + Container.emplace_back(); + } + return Container[*ParamDesc.IndexInSignature]; + } + + RootConstantsYaml &getOrInsertConstants(RootParameterLocationYaml &ParamDesc) { + return getOrInsertImpl(ParamDesc, Constants); + } + + RootDescriptorYaml &getOrInsertDescriptor(RootParameterLocationYaml &ParamDesc) { + return getOrInsertImpl(ParamDesc, Descriptors); + } + + void addLocation(RootParameterLocationYaml &Location){ + Locations.push_back(Location); + } +}; + + struct RootSignatureYamlDesc { RootSignatureYamlDesc() = default; @@ -111,14 +148,10 @@ struct RootSignatureYamlDesc { uint32_t NumStaticSamplers; uint32_t StaticSamplersOffset; - SmallVector Parameters; + RootParameterYamlDesc Parameters; uint32_t getEncodedFlags(); - iterator_range params() { - return make_range(Parameters.begin(), Parameters.end()); - } - static llvm::Expected create(const object::DirectX::RootSignature &Data); @@ -229,7 +262,7 @@ LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::ResourceBindInfo) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::SignatureElement) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::PSVInfo::MaskVector) LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::SignatureParameter) -LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::RootParameterYamlDesc) +LLVM_YAML_IS_SEQUENCE_VECTOR(llvm::DXContainerYAML::RootParameterLocationYaml) LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::PSV::SemanticKind) LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::PSV::ComponentType) LLVM_YAML_DECLARE_ENUM_TRAITS(llvm::dxbc::PSV::InterpolationMode) @@ -302,8 +335,8 @@ template <> struct MappingTraits { DXContainerYAML::RootSignatureYamlDesc &RootSignature); }; -template <> struct MappingTraits { - static void mapping(IO &IO, llvm::DXContainerYAML::RootParameterYamlDesc &P); +template <> struct MappingContextTraits { + static void mapping(IO &IO, llvm::DXContainerYAML::RootParameterLocationYaml &L, DXContainerYAML::RootSignatureYamlDesc &S); }; template <> struct MappingTraits { diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index ace2eca5072bd..6526bc9627023 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -11,9 +11,11 @@ /// //===----------------------------------------------------------------------===// +#include "llvm/ADT/STLForwardCompat.h" #include "llvm/BinaryFormat/DXContainer.h" #include "llvm/MC/DXContainerPSVInfo.h" #include "llvm/MC/DXContainerRootSignature.h" +#include "llvm/ObjectYAML/DXContainerYAML.h" #include "llvm/ObjectYAML/ObjectYAML.h" #include "llvm/ObjectYAML/yaml2obj.h" #include "llvm/Support/Errc.h" @@ -273,27 +275,33 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { RS.NumStaticSamplers = P.RootSignature->NumStaticSamplers; RS.StaticSamplersOffset = P.RootSignature->StaticSamplersOffset; - for (const auto &Param : P.RootSignature->Parameters) { - auto Header = dxbc::RootParameterHeader{Param.Type, Param.Visibility, - Param.Offset}; + for (DXContainerYAML::RootParameterLocationYaml &L : P.RootSignature->Parameters.Locations) { + auto Header = dxbc::RootParameterHeader{L.Header.Type, L.Header.Visibility, + L.Header.Offset}; - if (auto *ConstantYaml = - std::get_if(&Param.Data)) { + switch(L.Header.Type) { + case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): { + DXContainerYAML::RootConstantsYaml ConstantYaml = P.RootSignature->Parameters.getOrInsertConstants(L); dxbc::RootConstants Constants; - Constants.Num32BitValues = ConstantYaml->Num32BitValues; - Constants.RegisterSpace = ConstantYaml->RegisterSpace; - Constants.ShaderRegister = ConstantYaml->ShaderRegister; + Constants.Num32BitValues = ConstantYaml.Num32BitValues; + Constants.RegisterSpace = ConstantYaml.RegisterSpace; + Constants.ShaderRegister = ConstantYaml.ShaderRegister; RS.ParametersContainer.addParameter(Header, Constants); - } else if (auto *DescriptorYaml = - std::get_if( - &Param.Data)) { + break; + } + case llvm::to_underlying(dxbc::RootParameterType::CBV): + case llvm::to_underlying(dxbc::RootParameterType::SRV): + case llvm::to_underlying(dxbc::RootParameterType::UAV): { + DXContainerYAML::RootDescriptorYaml DescriptorYaml = P.RootSignature->Parameters.getOrInsertDescriptor(L); + dxbc::RTS0::v2::RootDescriptor Descriptor; - Descriptor.RegisterSpace = DescriptorYaml->RegisterSpace; - Descriptor.ShaderRegister = DescriptorYaml->ShaderRegister; + Descriptor.RegisterSpace = DescriptorYaml.RegisterSpace; + Descriptor.ShaderRegister = DescriptorYaml.ShaderRegister; if (RS.Version > 1) - Descriptor.Flags = DescriptorYaml->getEncodedFlags(); + Descriptor.Flags = DescriptorYaml.getEncodedFlags(); RS.ParametersContainer.addParameter(Header, Descriptor); - } else { + 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. diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index fdb039e75fdda..427381fba50ed 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -53,15 +53,15 @@ DXContainerYAML::RootSignatureYamlDesc::create( return createStringError(std::errc::invalid_argument, "Invalid value for parameter type"); - RootParameterYamlDesc NewP(PH.ParameterType); - NewP.Offset = PH.ParameterOffset; - NewP.Type = PH.ParameterType; + RootParameterHeaderYaml Header(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"); - NewP.Visibility = PH.ShaderVisibility; + Header.Visibility = PH.ShaderVisibility; llvm::Expected ParamViewOrErr = Data.getParameter(PH); @@ -75,11 +75,13 @@ DXContainerYAML::RootSignatureYamlDesc::create( return std::move(E); auto Constants = *ConstantsOrErr; - RootConstantsYaml ConstantYaml; + RootParameterLocationYaml Location (Header); + RootConstantsYaml &ConstantYaml = RootSigDesc.Parameters.getOrInsertConstants(Location); + RootSigDesc.Parameters.addLocation(Location); ConstantYaml.Num32BitValues = Constants.Num32BitValues; ConstantYaml.ShaderRegister = Constants.ShaderRegister; ConstantYaml.RegisterSpace = Constants.RegisterSpace; - NewP.Data = ConstantYaml; + } else if (auto *RDV = dyn_cast(&ParamView)) { llvm::Expected DescriptorOrErr = @@ -87,7 +89,10 @@ DXContainerYAML::RootSignatureYamlDesc::create( if (Error E = DescriptorOrErr.takeError()) return std::move(E); auto Descriptor = *DescriptorOrErr; - RootDescriptorYaml YamlDescriptor; + RootParameterLocationYaml Location (Header); + RootDescriptorYaml &YamlDescriptor = RootSigDesc.Parameters.getOrInsertDescriptor(Location); + RootSigDesc.Parameters.addLocation(Location); + YamlDescriptor.ShaderRegister = Descriptor.ShaderRegister; YamlDescriptor.RegisterSpace = Descriptor.RegisterSpace; if (Version > 1) { @@ -97,10 +102,7 @@ DXContainerYAML::RootSignatureYamlDesc::create( llvm::to_underlying(dxbc::RootDescriptorFlag::Val)) > 0; #include "llvm/BinaryFormat/DXContainerConstants.def" } - NewP.Data = YamlDescriptor; } - - RootSigDesc.Parameters.push_back(NewP); } #define ROOT_ELEMENT_FLAG(Num, Val) \ RootSigDesc.Val = \ @@ -293,11 +295,31 @@ void MappingTraits::mapping( IO.mapRequired("RootParametersOffset", S.RootParametersOffset); IO.mapRequired("NumStaticSamplers", S.NumStaticSamplers); IO.mapRequired("StaticSamplersOffset", S.StaticSamplersOffset); - IO.mapRequired("Parameters", S.Parameters); + IO.mapRequired("Parameters", S.Parameters.Locations, S); #define ROOT_ELEMENT_FLAG(Num, Val) IO.mapOptional(#Val, S.Val, false); #include "llvm/BinaryFormat/DXContainerConstants.def" } +void MappingContextTraits::mapping(IO &IO, DXContainerYAML::RootParameterLocationYaml &L, DXContainerYAML::RootSignatureYamlDesc &S) { + IO.mapRequired("ParameterType", L.Header.Type); + IO.mapRequired("ShaderVisibility", L.Header.Visibility); + + switch (L.Header.Type) { + case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): { + DXContainerYAML::RootConstantsYaml &Constants = S.Parameters.getOrInsertConstants(L); + IO.mapRequired("Constants", Constants); + break; + } + case llvm::to_underlying(dxbc::RootParameterType::CBV): + case llvm::to_underlying(dxbc::RootParameterType::SRV): + case llvm::to_underlying(dxbc::RootParameterType::UAV):{ + DXContainerYAML::RootDescriptorYaml &Descriptor = S.Parameters.getOrInsertDescriptor(L); + IO.mapRequired("Descriptor", Descriptor); + break; + } + } + +} void MappingTraits::mapping( IO &IO, llvm::DXContainerYAML::RootConstantsYaml &C) { IO.mapRequired("Num32BitValues", C.Num32BitValues); @@ -313,33 +335,6 @@ void MappingTraits::mapping( #include "llvm/BinaryFormat/DXContainerConstants.def" } -void MappingTraits::mapping( - IO &IO, llvm::DXContainerYAML::RootParameterYamlDesc &P) { - IO.mapRequired("ParameterType", P.Type); - IO.mapRequired("ShaderVisibility", P.Visibility); - - switch (P.Type) { - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): { - DXContainerYAML::RootConstantsYaml Constants; - if (IO.outputting()) - Constants = std::get(P.Data); - IO.mapRequired("Constants", Constants); - if (!IO.outputting()) - P.Data = Constants; - } break; - case llvm::to_underlying(dxbc::RootParameterType::CBV): - case llvm::to_underlying(dxbc::RootParameterType::SRV): - case llvm::to_underlying(dxbc::RootParameterType::UAV): { - DXContainerYAML::RootDescriptorYaml Descriptor; - if (IO.outputting()) - Descriptor = std::get(P.Data); - IO.mapRequired("Descriptor", Descriptor); - if (!IO.outputting()) - P.Data = Descriptor; - } break; - } -} - void MappingTraits::mapping(IO &IO, DXContainerYAML::Part &P) { IO.mapRequired("Name", P.Name); From bf5e7d3deceddf9730ca9dbc4bba743cfd41332d Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Mon, 26 May 2025 18:21:28 +0000 Subject: [PATCH 30/31] clean up --- .../include/llvm/ObjectYAML/DXContainerYAML.h | 32 +++---- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 96 ++++++++++--------- llvm/lib/ObjectYAML/DXContainerYAML.cpp | 85 ++++++++-------- 3 files changed, 111 insertions(+), 102 deletions(-) diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h index 444613a92d363..4f678554f84f4 100644 --- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h +++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h @@ -21,7 +21,6 @@ #include "llvm/ObjectYAML/YAML.h" #include "llvm/Support/YAMLTraits.h" #include -#include #include #include #include @@ -96,7 +95,7 @@ struct RootParameterHeaderYaml { uint32_t Visibility; uint32_t Offset; - RootParameterHeaderYaml() {}; + RootParameterHeaderYaml(){}; RootParameterHeaderYaml(uint32_t T) : Type(T) {} }; @@ -104,7 +103,7 @@ struct RootParameterLocationYaml { RootParameterHeaderYaml Header; std::optional IndexInSignature; - RootParameterLocationYaml() {}; + RootParameterLocationYaml(){}; explicit RootParameterLocationYaml(RootParameterHeaderYaml Header) : Header(Header) {} }; @@ -114,16 +113,15 @@ struct RootParameterYamlDesc { SmallVector Constants; SmallVector Descriptors; - template - T &getOrInsertImpl(RootParameterLocationYaml &ParamDesc, - SmallVectorImpl &Container) { - if (!ParamDesc.IndexInSignature) { - ParamDesc.IndexInSignature = Container.size(); - Container.emplace_back(); + T &getOrInsertImpl(RootParameterLocationYaml &ParamDesc, + SmallVectorImpl &Container) { + if (!ParamDesc.IndexInSignature) { + ParamDesc.IndexInSignature = Container.size(); + Container.emplace_back(); + } + return Container[*ParamDesc.IndexInSignature]; } - return Container[*ParamDesc.IndexInSignature]; - } RootConstantsYaml &getOrInsertConstants(RootParameterLocationYaml &ParamDesc) { return getOrInsertImpl(ParamDesc, Constants); @@ -133,12 +131,12 @@ struct RootParameterYamlDesc { return getOrInsertImpl(ParamDesc, Descriptors); } - void addLocation(RootParameterLocationYaml &Location){ + void insertLocation + (RootParameterLocationYaml &Location) { Locations.push_back(Location); } }; - struct RootSignatureYamlDesc { RootSignatureYamlDesc() = default; @@ -335,9 +333,11 @@ template <> struct MappingTraits { DXContainerYAML::RootSignatureYamlDesc &RootSignature); }; -template <> struct MappingContextTraits { - static void mapping(IO &IO, llvm::DXContainerYAML::RootParameterLocationYaml &L, DXContainerYAML::RootSignatureYamlDesc &S); -}; + template <> + struct MappingContextTraits { + static void mapping(IO &IO, llvm::DXContainerYAML::RootParameterLocationYaml &L, DXContainerYAML::RootSignatureYamlDesc &S); + }; template <> struct MappingTraits { static void mapping(IO &IO, llvm::DXContainerYAML::RootConstantsYaml &C); diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index 6526bc9627023..eb92660afa6fc 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -11,11 +11,9 @@ /// //===----------------------------------------------------------------------===// -#include "llvm/ADT/STLForwardCompat.h" #include "llvm/BinaryFormat/DXContainer.h" #include "llvm/MC/DXContainerPSVInfo.h" #include "llvm/MC/DXContainerRootSignature.h" -#include "llvm/ObjectYAML/DXContainerYAML.h" #include "llvm/ObjectYAML/ObjectYAML.h" #include "llvm/ObjectYAML/yaml2obj.h" #include "llvm/Support/Errc.h" @@ -265,51 +263,55 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { case dxbc::PartType::Unknown: break; // Skip any handling for unrecognized parts. case dxbc::PartType::RTS0: - if (!P.RootSignature.has_value()) - continue; - - mcdxbc::RootSignatureDesc RS; - RS.Flags = P.RootSignature->getEncodedFlags(); - RS.Version = P.RootSignature->Version; - RS.RootParameterOffset = P.RootSignature->RootParametersOffset; - RS.NumStaticSamplers = P.RootSignature->NumStaticSamplers; - RS.StaticSamplersOffset = P.RootSignature->StaticSamplersOffset; - - for (DXContainerYAML::RootParameterLocationYaml &L : P.RootSignature->Parameters.Locations) { - auto Header = dxbc::RootParameterHeader{L.Header.Type, L.Header.Visibility, - L.Header.Offset}; - - switch(L.Header.Type) { - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): { - DXContainerYAML::RootConstantsYaml ConstantYaml = P.RootSignature->Parameters.getOrInsertConstants(L); - dxbc::RootConstants Constants; - Constants.Num32BitValues = ConstantYaml.Num32BitValues; - Constants.RegisterSpace = ConstantYaml.RegisterSpace; - Constants.ShaderRegister = ConstantYaml.ShaderRegister; - 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): { - DXContainerYAML::RootDescriptorYaml DescriptorYaml = P.RootSignature->Parameters.getOrInsertDescriptor(L); - - dxbc::RTS0::v2::RootDescriptor Descriptor; - Descriptor.RegisterSpace = DescriptorYaml.RegisterSpace; - Descriptor.ShaderRegister = DescriptorYaml.ShaderRegister; - if (RS.Version > 1) - Descriptor.Flags = DescriptorYaml.getEncodedFlags(); - RS.ParametersContainer.addParameter(Header, Descriptor); - 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); - } - } - - RS.write(OS); + if (!P.RootSignature.has_value()) + continue; + + mcdxbc::RootSignatureDesc RS; + RS.Flags = P.RootSignature->getEncodedFlags(); + RS.Version = P.RootSignature->Version; + RS.RootParameterOffset = P.RootSignature->RootParametersOffset; + RS.NumStaticSamplers = P.RootSignature->NumStaticSamplers; + RS.StaticSamplersOffset = P.RootSignature->StaticSamplersOffset; + + for (DXContainerYAML::RootParameterLocationYaml &L : + P.RootSignature->Parameters.Locations) { + auto Header = dxbc::RootParameterHeader{ + L.Header.Type, L.Header.Visibility, L.Header.Offset}; + + switch (L.Header.Type) { + case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): { + DXContainerYAML::RootConstantsYaml ConstantYaml = + P.RootSignature->Parameters.getOrInsertConstants(L); + dxbc::RootConstants Constants; + Constants.Num32BitValues = ConstantYaml.Num32BitValues; + Constants.RegisterSpace = ConstantYaml.RegisterSpace; + Constants.ShaderRegister = ConstantYaml.ShaderRegister; + 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): { + DXContainerYAML::RootDescriptorYaml DescriptorYaml = + P.RootSignature->Parameters.getOrInsertDescriptor(L); + + dxbc::RTS0::v2::RootDescriptor Descriptor; + Descriptor.RegisterSpace = DescriptorYaml.RegisterSpace; + Descriptor.ShaderRegister = DescriptorYaml.ShaderRegister; + if (RS.Version > 1) + Descriptor.Flags = DescriptorYaml.getEncodedFlags(); + RS.ParametersContainer.addParameter(Header, Descriptor); + 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); + } + } + + RS.write(OS); break; } uint64_t BytesWritten = OS.tell() - DataStart; diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index 427381fba50ed..ac40762e59492 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -75,13 +75,14 @@ DXContainerYAML::RootSignatureYamlDesc::create( return std::move(E); auto Constants = *ConstantsOrErr; - RootParameterLocationYaml Location (Header); - RootConstantsYaml &ConstantYaml = RootSigDesc.Parameters.getOrInsertConstants(Location); - RootSigDesc.Parameters.addLocation(Location); + RootParameterLocationYaml Location(Header); + RootConstantsYaml &ConstantYaml = + RootSigDesc.Parameters.getOrInsertConstants(Location); + RootSigDesc.Parameters.insertLocation(Location); ConstantYaml.Num32BitValues = Constants.Num32BitValues; ConstantYaml.ShaderRegister = Constants.ShaderRegister; ConstantYaml.RegisterSpace = Constants.RegisterSpace; - + } else if (auto *RDV = dyn_cast(&ParamView)) { llvm::Expected DescriptorOrErr = @@ -89,9 +90,10 @@ DXContainerYAML::RootSignatureYamlDesc::create( if (Error E = DescriptorOrErr.takeError()) return std::move(E); auto Descriptor = *DescriptorOrErr; - RootParameterLocationYaml Location (Header); - RootDescriptorYaml &YamlDescriptor = RootSigDesc.Parameters.getOrInsertDescriptor(Location); - RootSigDesc.Parameters.addLocation(Location); + RootParameterLocationYaml Location(Header); + RootDescriptorYaml &YamlDescriptor = + RootSigDesc.Parameters.getOrInsertDescriptor(Location); + RootSigDesc.Parameters.insertLocation(Location); YamlDescriptor.ShaderRegister = Descriptor.ShaderRegister; YamlDescriptor.RegisterSpace = Descriptor.RegisterSpace; @@ -288,52 +290,57 @@ void MappingTraits::mapping( IO.mapRequired("Parameters", S.Parameters); } -void MappingTraits::mapping( - IO &IO, DXContainerYAML::RootSignatureYamlDesc &S) { - IO.mapRequired("Version", S.Version); - IO.mapRequired("NumRootParameters", S.NumRootParameters); - IO.mapRequired("RootParametersOffset", S.RootParametersOffset); - IO.mapRequired("NumStaticSamplers", S.NumStaticSamplers); - IO.mapRequired("StaticSamplersOffset", S.StaticSamplersOffset); - IO.mapRequired("Parameters", S.Parameters.Locations, S); -#define ROOT_ELEMENT_FLAG(Num, Val) IO.mapOptional(#Val, S.Val, false); -#include "llvm/BinaryFormat/DXContainerConstants.def" -} + void MappingTraits::mapping( + IO &IO, DXContainerYAML::RootSignatureYamlDesc &S) { + IO.mapRequired("Version", S.Version); + IO.mapRequired("NumRootParameters", S.NumRootParameters); + IO.mapRequired("RootParametersOffset", S.RootParametersOffset); + IO.mapRequired("NumStaticSamplers", S.NumStaticSamplers); + IO.mapRequired("StaticSamplersOffset", S.StaticSamplersOffset); + IO.mapRequired("Parameters", S.Parameters.Locations, S); + #define ROOT_ELEMENT_FLAG(Num, Val) IO.mapOptional(#Val, S.Val, false); + #include "llvm/BinaryFormat/DXContainerConstants.def" + } -void MappingContextTraits::mapping(IO &IO, DXContainerYAML::RootParameterLocationYaml &L, DXContainerYAML::RootSignatureYamlDesc &S) { - IO.mapRequired("ParameterType", L.Header.Type); - IO.mapRequired("ShaderVisibility", L.Header.Visibility); + void MappingContextTraits:: + mapping(IO &IO, DXContainerYAML::RootParameterLocationYaml &L, + DXContainerYAML::RootSignatureYamlDesc &S) { + IO.mapRequired("ParameterType", L.Header.Type); + IO.mapRequired("ShaderVisibility", L.Header.Visibility); - switch (L.Header.Type) { + switch (L.Header.Type) { case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): { - DXContainerYAML::RootConstantsYaml &Constants = S.Parameters.getOrInsertConstants(L); + DXContainerYAML::RootConstantsYaml &Constants = + S.Parameters.getOrInsertConstants(L); IO.mapRequired("Constants", Constants); break; } case llvm::to_underlying(dxbc::RootParameterType::CBV): case llvm::to_underlying(dxbc::RootParameterType::SRV): - case llvm::to_underlying(dxbc::RootParameterType::UAV):{ - DXContainerYAML::RootDescriptorYaml &Descriptor = S.Parameters.getOrInsertDescriptor(L); + case llvm::to_underlying(dxbc::RootParameterType::UAV): { + DXContainerYAML::RootDescriptorYaml &Descriptor = + S.Parameters.getOrInsertDescriptor(L); IO.mapRequired("Descriptor", Descriptor); break; } + } } -} -void MappingTraits::mapping( - IO &IO, llvm::DXContainerYAML::RootConstantsYaml &C) { - IO.mapRequired("Num32BitValues", C.Num32BitValues); - IO.mapRequired("RegisterSpace", C.RegisterSpace); - IO.mapRequired("ShaderRegister", C.ShaderRegister); -} + void MappingTraits::mapping( + IO &IO, llvm::DXContainerYAML::RootConstantsYaml &C) { + IO.mapRequired("Num32BitValues", C.Num32BitValues); + IO.mapRequired("RegisterSpace", C.RegisterSpace); + IO.mapRequired("ShaderRegister", C.ShaderRegister); + } -void MappingTraits::mapping( - IO &IO, llvm::DXContainerYAML::RootDescriptorYaml &D) { - IO.mapRequired("RegisterSpace", D.RegisterSpace); - IO.mapRequired("ShaderRegister", D.ShaderRegister); -#define ROOT_DESCRIPTOR_FLAG(Num, Val) IO.mapOptional(#Val, D.Val, false); -#include "llvm/BinaryFormat/DXContainerConstants.def" -} + void MappingTraits::mapping( + IO &IO, llvm::DXContainerYAML::RootDescriptorYaml &D) { + IO.mapRequired("RegisterSpace", D.RegisterSpace); + IO.mapRequired("ShaderRegister", D.ShaderRegister); + #define ROOT_DESCRIPTOR_FLAG(Num, Val) IO.mapOptional(#Val, D.Val, false); + #include "llvm/BinaryFormat/DXContainerConstants.def" + } void MappingTraits::mapping(IO &IO, DXContainerYAML::Part &P) { From ea572537c6e7207f4d84e0e30bde7c710f3d84a3 Mon Sep 17 00:00:00 2001 From: joaosaffran Date: Tue, 27 May 2025 21:51:04 +0000 Subject: [PATCH 31/31] address pr comments --- .../include/llvm/ObjectYAML/DXContainerYAML.h | 40 ++++---- llvm/lib/ObjectYAML/DXContainerEmitter.cpp | 98 +++++++++---------- llvm/lib/ObjectYAML/DXContainerYAML.cpp | 96 +++++++++--------- 3 files changed, 119 insertions(+), 115 deletions(-) diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h index 4f678554f84f4..3af1da552cc7a 100644 --- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h +++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h @@ -104,7 +104,8 @@ struct RootParameterLocationYaml { std::optional IndexInSignature; RootParameterLocationYaml(){}; - explicit RootParameterLocationYaml(RootParameterHeaderYaml Header) : Header(Header) {} + explicit RootParameterLocationYaml(RootParameterHeaderYaml Header) + : Header(Header) {} }; struct RootParameterYamlDesc { @@ -113,26 +114,27 @@ struct RootParameterYamlDesc { SmallVector Constants; SmallVector Descriptors; - template - T &getOrInsertImpl(RootParameterLocationYaml &ParamDesc, - SmallVectorImpl &Container) { - if (!ParamDesc.IndexInSignature) { - ParamDesc.IndexInSignature = Container.size(); - Container.emplace_back(); - } - return Container[*ParamDesc.IndexInSignature]; + template + T &getOrInsertImpl(RootParameterLocationYaml &ParamDesc, + SmallVectorImpl &Container) { + if (!ParamDesc.IndexInSignature) { + ParamDesc.IndexInSignature = Container.size(); + Container.emplace_back(); } + return Container[*ParamDesc.IndexInSignature]; + } - RootConstantsYaml &getOrInsertConstants(RootParameterLocationYaml &ParamDesc) { + RootConstantsYaml & + getOrInsertConstants(RootParameterLocationYaml &ParamDesc) { return getOrInsertImpl(ParamDesc, Constants); } - RootDescriptorYaml &getOrInsertDescriptor(RootParameterLocationYaml &ParamDesc) { + RootDescriptorYaml & + getOrInsertDescriptor(RootParameterLocationYaml &ParamDesc) { return getOrInsertImpl(ParamDesc, Descriptors); } - void insertLocation - (RootParameterLocationYaml &Location) { + void insertLocation(RootParameterLocationYaml &Location) { Locations.push_back(Location); } }; @@ -333,11 +335,13 @@ template <> struct MappingTraits { DXContainerYAML::RootSignatureYamlDesc &RootSignature); }; - template <> - struct MappingContextTraits { - static void mapping(IO &IO, llvm::DXContainerYAML::RootParameterLocationYaml &L, DXContainerYAML::RootSignatureYamlDesc &S); - }; +template <> +struct MappingContextTraits { + static void mapping(IO &IO, + llvm::DXContainerYAML::RootParameterLocationYaml &L, + DXContainerYAML::RootSignatureYamlDesc &S); +}; template <> struct MappingTraits { static void mapping(IO &IO, llvm::DXContainerYAML::RootConstantsYaml &C); diff --git a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp index eb92660afa6fc..e5501d2d3c89a 100644 --- a/llvm/lib/ObjectYAML/DXContainerEmitter.cpp +++ b/llvm/lib/ObjectYAML/DXContainerEmitter.cpp @@ -263,55 +263,55 @@ void DXContainerWriter::writeParts(raw_ostream &OS) { case dxbc::PartType::Unknown: break; // Skip any handling for unrecognized parts. case dxbc::PartType::RTS0: - if (!P.RootSignature.has_value()) - continue; - - mcdxbc::RootSignatureDesc RS; - RS.Flags = P.RootSignature->getEncodedFlags(); - RS.Version = P.RootSignature->Version; - RS.RootParameterOffset = P.RootSignature->RootParametersOffset; - RS.NumStaticSamplers = P.RootSignature->NumStaticSamplers; - RS.StaticSamplersOffset = P.RootSignature->StaticSamplersOffset; - - for (DXContainerYAML::RootParameterLocationYaml &L : - P.RootSignature->Parameters.Locations) { - auto Header = dxbc::RootParameterHeader{ - L.Header.Type, L.Header.Visibility, L.Header.Offset}; - - switch (L.Header.Type) { - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): { - DXContainerYAML::RootConstantsYaml ConstantYaml = - P.RootSignature->Parameters.getOrInsertConstants(L); - dxbc::RootConstants Constants; - Constants.Num32BitValues = ConstantYaml.Num32BitValues; - Constants.RegisterSpace = ConstantYaml.RegisterSpace; - Constants.ShaderRegister = ConstantYaml.ShaderRegister; - 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): { - DXContainerYAML::RootDescriptorYaml DescriptorYaml = - P.RootSignature->Parameters.getOrInsertDescriptor(L); - - dxbc::RTS0::v2::RootDescriptor Descriptor; - Descriptor.RegisterSpace = DescriptorYaml.RegisterSpace; - Descriptor.ShaderRegister = DescriptorYaml.ShaderRegister; - if (RS.Version > 1) - Descriptor.Flags = DescriptorYaml.getEncodedFlags(); - RS.ParametersContainer.addParameter(Header, Descriptor); - 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); - } - } - - RS.write(OS); + if (!P.RootSignature.has_value()) + continue; + + mcdxbc::RootSignatureDesc RS; + RS.Flags = P.RootSignature->getEncodedFlags(); + RS.Version = P.RootSignature->Version; + RS.RootParameterOffset = P.RootSignature->RootParametersOffset; + RS.NumStaticSamplers = P.RootSignature->NumStaticSamplers; + RS.StaticSamplersOffset = P.RootSignature->StaticSamplersOffset; + + for (DXContainerYAML::RootParameterLocationYaml &L : + P.RootSignature->Parameters.Locations) { + dxbc::RootParameterHeader Header{L.Header.Type, L.Header.Visibility, + L.Header.Offset}; + + switch (L.Header.Type) { + case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): { + const DXContainerYAML::RootConstantsYaml &ConstantYaml = + P.RootSignature->Parameters.getOrInsertConstants(L); + dxbc::RootConstants Constants; + Constants.Num32BitValues = ConstantYaml.Num32BitValues; + Constants.RegisterSpace = ConstantYaml.RegisterSpace; + Constants.ShaderRegister = ConstantYaml.ShaderRegister; + 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): { + const DXContainerYAML::RootDescriptorYaml &DescriptorYaml = + P.RootSignature->Parameters.getOrInsertDescriptor(L); + + dxbc::RTS0::v2::RootDescriptor Descriptor; + Descriptor.RegisterSpace = DescriptorYaml.RegisterSpace; + Descriptor.ShaderRegister = DescriptorYaml.ShaderRegister; + if (RS.Version > 1) + Descriptor.Flags = DescriptorYaml.getEncodedFlags(); + RS.ParametersContainer.addParameter(Header, Descriptor); + 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); + } + } + + RS.write(OS); break; } uint64_t BytesWritten = OS.tell() - DataStart; diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp index ac40762e59492..5a2279e334f42 100644 --- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp +++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp @@ -290,57 +290,57 @@ void MappingTraits::mapping( IO.mapRequired("Parameters", S.Parameters); } - void MappingTraits::mapping( - IO &IO, DXContainerYAML::RootSignatureYamlDesc &S) { - IO.mapRequired("Version", S.Version); - IO.mapRequired("NumRootParameters", S.NumRootParameters); - IO.mapRequired("RootParametersOffset", S.RootParametersOffset); - IO.mapRequired("NumStaticSamplers", S.NumStaticSamplers); - IO.mapRequired("StaticSamplersOffset", S.StaticSamplersOffset); - IO.mapRequired("Parameters", S.Parameters.Locations, S); - #define ROOT_ELEMENT_FLAG(Num, Val) IO.mapOptional(#Val, S.Val, false); - #include "llvm/BinaryFormat/DXContainerConstants.def" - } +void MappingTraits::mapping( + IO &IO, DXContainerYAML::RootSignatureYamlDesc &S) { + IO.mapRequired("Version", S.Version); + IO.mapRequired("NumRootParameters", S.NumRootParameters); + IO.mapRequired("RootParametersOffset", S.RootParametersOffset); + IO.mapRequired("NumStaticSamplers", S.NumStaticSamplers); + IO.mapRequired("StaticSamplersOffset", S.StaticSamplersOffset); + IO.mapRequired("Parameters", S.Parameters.Locations, S); +#define ROOT_ELEMENT_FLAG(Num, Val) IO.mapOptional(#Val, S.Val, false); +#include "llvm/BinaryFormat/DXContainerConstants.def" +} - void MappingContextTraits:: - mapping(IO &IO, DXContainerYAML::RootParameterLocationYaml &L, - DXContainerYAML::RootSignatureYamlDesc &S) { - IO.mapRequired("ParameterType", L.Header.Type); - IO.mapRequired("ShaderVisibility", L.Header.Visibility); - - switch (L.Header.Type) { - case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): { - DXContainerYAML::RootConstantsYaml &Constants = - S.Parameters.getOrInsertConstants(L); - IO.mapRequired("Constants", Constants); - break; - } - case llvm::to_underlying(dxbc::RootParameterType::CBV): - case llvm::to_underlying(dxbc::RootParameterType::SRV): - case llvm::to_underlying(dxbc::RootParameterType::UAV): { - DXContainerYAML::RootDescriptorYaml &Descriptor = - S.Parameters.getOrInsertDescriptor(L); - IO.mapRequired("Descriptor", Descriptor); - break; - } - } - } +void MappingContextTraits:: + mapping(IO &IO, DXContainerYAML::RootParameterLocationYaml &L, + DXContainerYAML::RootSignatureYamlDesc &S) { + IO.mapRequired("ParameterType", L.Header.Type); + IO.mapRequired("ShaderVisibility", L.Header.Visibility); - void MappingTraits::mapping( - IO &IO, llvm::DXContainerYAML::RootConstantsYaml &C) { - IO.mapRequired("Num32BitValues", C.Num32BitValues); - IO.mapRequired("RegisterSpace", C.RegisterSpace); - IO.mapRequired("ShaderRegister", C.ShaderRegister); - } + switch (L.Header.Type) { + case llvm::to_underlying(dxbc::RootParameterType::Constants32Bit): { + DXContainerYAML::RootConstantsYaml &Constants = + S.Parameters.getOrInsertConstants(L); + IO.mapRequired("Constants", Constants); + break; + } + case llvm::to_underlying(dxbc::RootParameterType::CBV): + case llvm::to_underlying(dxbc::RootParameterType::SRV): + case llvm::to_underlying(dxbc::RootParameterType::UAV): { + DXContainerYAML::RootDescriptorYaml &Descriptor = + S.Parameters.getOrInsertDescriptor(L); + IO.mapRequired("Descriptor", Descriptor); + break; + } + } +} - void MappingTraits::mapping( - IO &IO, llvm::DXContainerYAML::RootDescriptorYaml &D) { - IO.mapRequired("RegisterSpace", D.RegisterSpace); - IO.mapRequired("ShaderRegister", D.ShaderRegister); - #define ROOT_DESCRIPTOR_FLAG(Num, Val) IO.mapOptional(#Val, D.Val, false); - #include "llvm/BinaryFormat/DXContainerConstants.def" - } +void MappingTraits::mapping( + IO &IO, llvm::DXContainerYAML::RootConstantsYaml &C) { + IO.mapRequired("Num32BitValues", C.Num32BitValues); + IO.mapRequired("RegisterSpace", C.RegisterSpace); + IO.mapRequired("ShaderRegister", C.ShaderRegister); +} + +void MappingTraits::mapping( + IO &IO, llvm::DXContainerYAML::RootDescriptorYaml &D) { + IO.mapRequired("RegisterSpace", D.RegisterSpace); + IO.mapRequired("ShaderRegister", D.ShaderRegister); +#define ROOT_DESCRIPTOR_FLAG(Num, Val) IO.mapOptional(#Val, D.Val, false); +#include "llvm/BinaryFormat/DXContainerConstants.def" +} void MappingTraits::mapping(IO &IO, DXContainerYAML::Part &P) {