diff --git a/llvm/include/llvm/Frontend/HLSL/HLSLRootSignatureUtils.h b/llvm/include/llvm/Frontend/HLSL/HLSLRootSignatureUtils.h index 4d2cd183ebcbc..25c2a9f0cc808 100644 --- a/llvm/include/llvm/Frontend/HLSL/HLSLRootSignatureUtils.h +++ b/llvm/include/llvm/Frontend/HLSL/HLSLRootSignatureUtils.h @@ -38,6 +38,12 @@ LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, const DescriptorTable &Table); +LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, + const RootDescriptor &Descriptor); + +LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, + const StaticSampler &StaticSampler); + LLVM_ABI void dumpRootElements(raw_ostream &OS, ArrayRef Elements); class MetadataBuilder { diff --git a/llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp b/llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp index 1e198b639cfdc..a1ddb318055be 100644 --- a/llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp +++ b/llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp @@ -98,6 +98,109 @@ static raw_ostream &operator<<(raw_ostream &OS, return OS; } +static const EnumEntry SamplerFilterNames[] = { + {"MinMagMipPoint", SamplerFilter::MinMagMipPoint}, + {"MinMagPointMipLinear", SamplerFilter::MinMagPointMipLinear}, + {"MinPointMagLinearMipPoint", SamplerFilter::MinPointMagLinearMipPoint}, + {"MinPointMagMipLinear", SamplerFilter::MinPointMagMipLinear}, + {"MinLinearMagMipPoint", SamplerFilter::MinLinearMagMipPoint}, + {"MinLinearMagPointMipLinear", SamplerFilter::MinLinearMagPointMipLinear}, + {"MinMagLinearMipPoint", SamplerFilter::MinMagLinearMipPoint}, + {"MinMagMipLinear", SamplerFilter::MinMagMipLinear}, + {"Anisotropic", SamplerFilter::Anisotropic}, + {"ComparisonMinMagMipPoint", SamplerFilter::ComparisonMinMagMipPoint}, + {"ComparisonMinMagPointMipLinear", + SamplerFilter::ComparisonMinMagPointMipLinear}, + {"ComparisonMinPointMagLinearMipPoint", + SamplerFilter::ComparisonMinPointMagLinearMipPoint}, + {"ComparisonMinPointMagMipLinear", + SamplerFilter::ComparisonMinPointMagMipLinear}, + {"ComparisonMinLinearMagMipPoint", + SamplerFilter::ComparisonMinLinearMagMipPoint}, + {"ComparisonMinLinearMagPointMipLinear", + SamplerFilter::ComparisonMinLinearMagPointMipLinear}, + {"ComparisonMinMagLinearMipPoint", + SamplerFilter::ComparisonMinMagLinearMipPoint}, + {"ComparisonMinMagMipLinear", SamplerFilter::ComparisonMinMagMipLinear}, + {"ComparisonAnisotropic", SamplerFilter::ComparisonAnisotropic}, + {"MinimumMinMagMipPoint", SamplerFilter::MinimumMinMagMipPoint}, + {"MinimumMinMagPointMipLinear", SamplerFilter::MinimumMinMagPointMipLinear}, + {"MinimumMinPointMagLinearMipPoint", + SamplerFilter::MinimumMinPointMagLinearMipPoint}, + {"MinimumMinPointMagMipLinear", SamplerFilter::MinimumMinPointMagMipLinear}, + {"MinimumMinLinearMagMipPoint", SamplerFilter::MinimumMinLinearMagMipPoint}, + {"MinimumMinLinearMagPointMipLinear", + SamplerFilter::MinimumMinLinearMagPointMipLinear}, + {"MinimumMinMagLinearMipPoint", SamplerFilter::MinimumMinMagLinearMipPoint}, + {"MinimumMinMagMipLinear", SamplerFilter::MinimumMinMagMipLinear}, + {"MinimumAnisotropic", SamplerFilter::MinimumAnisotropic}, + {"MaximumMinMagMipPoint", SamplerFilter::MaximumMinMagMipPoint}, + {"MaximumMinMagPointMipLinear", SamplerFilter::MaximumMinMagPointMipLinear}, + {"MaximumMinPointMagLinearMipPoint", + SamplerFilter::MaximumMinPointMagLinearMipPoint}, + {"MaximumMinPointMagMipLinear", SamplerFilter::MaximumMinPointMagMipLinear}, + {"MaximumMinLinearMagMipPoint", SamplerFilter::MaximumMinLinearMagMipPoint}, + {"MaximumMinLinearMagPointMipLinear", + SamplerFilter::MaximumMinLinearMagPointMipLinear}, + {"MaximumMinMagLinearMipPoint", SamplerFilter::MaximumMinMagLinearMipPoint}, + {"MaximumMinMagMipLinear", SamplerFilter::MaximumMinMagMipLinear}, + {"MaximumAnisotropic", SamplerFilter::MaximumAnisotropic}, +}; + +static raw_ostream &operator<<(raw_ostream &OS, const SamplerFilter &Filter) { + printEnum(OS, Filter, ArrayRef(SamplerFilterNames)); + + return OS; +} + +static const EnumEntry TextureAddressModeNames[] = { + {"Wrap", TextureAddressMode::Wrap}, + {"Mirror", TextureAddressMode::Mirror}, + {"Clamp", TextureAddressMode::Clamp}, + {"Border", TextureAddressMode::Border}, + {"MirrorOnce", TextureAddressMode::MirrorOnce}, +}; + +static raw_ostream &operator<<(raw_ostream &OS, + const TextureAddressMode &Address) { + printEnum(OS, Address, ArrayRef(TextureAddressModeNames)); + + return OS; +} + +static const EnumEntry ComparisonFuncNames[] = { + {"Never", ComparisonFunc::Never}, + {"Less", ComparisonFunc::Less}, + {"Equal", ComparisonFunc::Equal}, + {"LessEqual", ComparisonFunc::LessEqual}, + {"Greater", ComparisonFunc::Greater}, + {"NotEqual", ComparisonFunc::NotEqual}, + {"GreaterEqual", ComparisonFunc::GreaterEqual}, + {"Always", ComparisonFunc::Always}, +}; + +static raw_ostream &operator<<(raw_ostream &OS, + const ComparisonFunc &CompFunc) { + printEnum(OS, CompFunc, ArrayRef(ComparisonFuncNames)); + + return OS; +} + +static const EnumEntry StaticBorderColorNames[] = { + {"TransparentBlack", StaticBorderColor::TransparentBlack}, + {"OpaqueBlack", StaticBorderColor::OpaqueBlack}, + {"OpaqueWhite", StaticBorderColor::OpaqueWhite}, + {"OpaqueBlackUint", StaticBorderColor::OpaqueBlackUint}, + {"OpaqueWhiteUint", StaticBorderColor::OpaqueWhiteUint}, +}; + +static raw_ostream &operator<<(raw_ostream &OS, + const StaticBorderColor &BorderColor) { + printEnum(OS, BorderColor, ArrayRef(StaticBorderColorNames)); + + return OS; +} + static const EnumEntry ResourceClassNames[] = { {"CBV", dxil::ResourceClass::CBuffer}, {"SRV", dxil::ResourceClass::SRV}, @@ -112,6 +215,20 @@ static raw_ostream &operator<<(raw_ostream &OS, const ClauseType &Type) { return OS; } +static const EnumEntry RootDescriptorFlagNames[] = { + {"DataVolatile", RootDescriptorFlags::DataVolatile}, + {"DataStaticWhileSetAtExecute", + RootDescriptorFlags::DataStaticWhileSetAtExecute}, + {"DataStatic", RootDescriptorFlags::DataStatic}, +}; + +static raw_ostream &operator<<(raw_ostream &OS, + const RootDescriptorFlags &Flags) { + printFlags(OS, Flags, ArrayRef(RootDescriptorFlagNames)); + + return OS; +} + static const EnumEntry DescriptorRangeFlagNames[] = { {"DescriptorsVolatile", DescriptorRangeFlags::DescriptorsVolatile}, {"DataVolatile", DescriptorRangeFlags::DataVolatile}, @@ -182,6 +299,31 @@ raw_ostream &operator<<(raw_ostream &OS, const DescriptorTableClause &Clause) { return OS; } +raw_ostream &operator<<(raw_ostream &OS, const RootDescriptor &Descriptor) { + ClauseType Type = ClauseType(llvm::to_underlying(Descriptor.Type)); + OS << "Root" << Type << "(" << Descriptor.Reg + << ", space = " << Descriptor.Space + << ", visibility = " << Descriptor.Visibility + << ", flags = " << Descriptor.Flags << ")"; + + return OS; +} + +raw_ostream &operator<<(raw_ostream &OS, const StaticSampler &Sampler) { + OS << "StaticSampler(" << Sampler.Reg << ", filter = " << Sampler.Filter + << ", addressU = " << Sampler.AddressU + << ", addressV = " << Sampler.AddressV + << ", addressW = " << Sampler.AddressW + << ", mipLODBias = " << Sampler.MipLODBias + << ", maxAnisotropy = " << Sampler.MaxAnisotropy + << ", comparisonFunc = " << Sampler.CompFunc + << ", borderColor = " << Sampler.BorderColor + << ", minLOD = " << Sampler.MinLOD << ", maxLOD = " << Sampler.MaxLOD + << ", space = " << Sampler.Space << ", visibility = " << Sampler.Visibility + << ")"; + return OS; +} + void dumpRootElements(raw_ostream &OS, ArrayRef Elements) { OS << "RootElements{"; bool First = true; diff --git a/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp b/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp index 1a0c8e2a16396..1c37ee709e098 100644 --- a/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp +++ b/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp @@ -108,6 +108,127 @@ TEST(HLSLRootSignatureTest, DescriptorTableDump) { EXPECT_EQ(Out, Expected); } +TEST(HLSLRootSignatureTest, RootCBVDump) { + RootDescriptor Descriptor; + Descriptor.Type = DescriptorType::CBuffer; + Descriptor.Reg = {RegisterType::BReg, 0}; + Descriptor.setDefaultFlags(); + + std::string Out; + llvm::raw_string_ostream OS(Out); + OS << Descriptor; + OS.flush(); + + std::string Expected = "RootCBV(b0, space = 0, " + "visibility = All, " + "flags = DataStaticWhileSetAtExecute)"; + EXPECT_EQ(Out, Expected); +} + +TEST(HLSLRootSignatureTest, RootSRVDump) { + RootDescriptor Descriptor; + Descriptor.Type = DescriptorType::SRV; + Descriptor.Reg = {RegisterType::TReg, 0}; + Descriptor.Space = 42; + Descriptor.Visibility = ShaderVisibility::Geometry; + Descriptor.Flags = RootDescriptorFlags::None; + + std::string Out; + llvm::raw_string_ostream OS(Out); + OS << Descriptor; + OS.flush(); + + std::string Expected = + "RootSRV(t0, space = 42, visibility = Geometry, flags = None)"; + EXPECT_EQ(Out, Expected); +} + +TEST(HLSLRootSignatureTest, RootUAVDump) { + RootDescriptor Descriptor; + Descriptor.Type = DescriptorType::UAV; + Descriptor.Reg = {RegisterType::UReg, 92374}; + Descriptor.Space = 932847; + Descriptor.Visibility = ShaderVisibility::Hull; + Descriptor.Flags = RootDescriptorFlags::ValidFlags; + + std::string Out; + llvm::raw_string_ostream OS(Out); + OS << Descriptor; + OS.flush(); + + std::string Expected = + "RootUAV(u92374, space = 932847, visibility = Hull, flags = " + "DataVolatile | " + "DataStaticWhileSetAtExecute | " + "DataStatic)"; + EXPECT_EQ(Out, Expected); +} + +TEST(HLSLRootSignatureTest, DefaultStaticSamplerDump) { + StaticSampler Sampler; + Sampler.Reg = {RegisterType::SReg, 0}; + + std::string Out; + llvm::raw_string_ostream OS(Out); + OS << Sampler; + OS.flush(); + + std::string Expected = "StaticSampler(s0, " + "filter = Anisotropic, " + "addressU = Wrap, " + "addressV = Wrap, " + "addressW = Wrap, " + "mipLODBias = 0.000000e+00, " + "maxAnisotropy = 16, " + "comparisonFunc = LessEqual, " + "borderColor = OpaqueWhite, " + "minLOD = 0.000000e+00, " + "maxLOD = 3.402823e+38, " + "space = 0, " + "visibility = All" + ")"; + EXPECT_EQ(Out, Expected); +} + +TEST(HLSLRootSignatureTest, DefinedStaticSamplerDump) { + StaticSampler Sampler; + Sampler.Reg = {RegisterType::SReg, 0}; + + Sampler.Filter = SamplerFilter::ComparisonMinMagLinearMipPoint; + Sampler.AddressU = TextureAddressMode::Mirror; + Sampler.AddressV = TextureAddressMode::Border; + Sampler.AddressW = TextureAddressMode::Clamp; + Sampler.MipLODBias = 4.8f; + Sampler.MaxAnisotropy = 32; + Sampler.CompFunc = ComparisonFunc::NotEqual; + Sampler.BorderColor = StaticBorderColor::OpaqueBlack; + Sampler.MinLOD = 1.0f; + Sampler.MaxLOD = 32.0f; + Sampler.Space = 7; + Sampler.Visibility = ShaderVisibility::Domain; + + std::string Out; + llvm::raw_string_ostream OS(Out); + OS << Sampler; + OS.flush(); + + std::string Expected = "StaticSampler(s0, " + "filter = ComparisonMinMagLinearMipPoint, " + "addressU = Mirror, " + "addressV = Border, " + "addressW = Clamp, " + "mipLODBias = 4.800000e+00, " + "maxAnisotropy = 32, " + "comparisonFunc = NotEqual, " + "borderColor = OpaqueBlack, " + "minLOD = 1.000000e+00, " + "maxLOD = 3.200000e+01, " + "space = 7, " + "visibility = Domain" + ")"; + EXPECT_EQ(Out, Expected); +} + TEST(HLSLRootSignatureTest, DefaultRootConstantsDump) { RootConstants Constants; Constants.Num32BitConstants = 1; @@ -173,7 +294,6 @@ TEST(HLSLRootSignatureTest, AllRootFlagsDump) { "DenyMeshShaderRootAccess | " "CBVSRVUAVHeapDirectlyIndexed | " "SamplerHeapDirectlyIndexed)"; - EXPECT_EQ(Out, Expected); }