cc49f3b3e1
Remove: * DescriptorType enum - this almost exactly shadowed the ResourceClass enum * ClauseType aliased ResourceClass Although these were introduced to make the HLSL root signature handling code a bit cleaner, they were ultimately causing confusion as they appeared to be unique enums that needed to be converted between each other. Closes #153890
394 lines
13 KiB
C++
394 lines
13 KiB
C++
//===-------- HLSLRootSignatureDumpTest.cpp - RootSignature dump tests ----===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "llvm/Frontend/HLSL/HLSLRootSignature.h"
|
|
#include "gtest/gtest.h"
|
|
|
|
using namespace llvm::hlsl::rootsig;
|
|
using llvm::dxil::ResourceClass;
|
|
|
|
namespace {
|
|
|
|
TEST(HLSLRootSignatureTest, DescriptorCBVClauseDump) {
|
|
DescriptorTableClause Clause;
|
|
Clause.Type = ResourceClass::CBuffer;
|
|
Clause.Reg = {RegisterType::BReg, 0};
|
|
Clause.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_1);
|
|
|
|
std::string Out;
|
|
llvm::raw_string_ostream OS(Out);
|
|
OS << Clause;
|
|
OS.flush();
|
|
|
|
std::string Expected = "CBV(b0, numDescriptors = 1, space = 0, "
|
|
"offset = DescriptorTableOffsetAppend, "
|
|
"flags = DataStaticWhileSetAtExecute)";
|
|
EXPECT_EQ(Out, Expected);
|
|
}
|
|
|
|
TEST(HLSLRootSignatureTest, DescriptorSRVClauseDump) {
|
|
DescriptorTableClause Clause;
|
|
Clause.Type = ResourceClass::SRV;
|
|
Clause.Reg = {RegisterType::TReg, 0};
|
|
Clause.NumDescriptors = NumDescriptorsUnbounded;
|
|
Clause.Space = 42;
|
|
Clause.Offset = 3;
|
|
Clause.Flags = llvm::dxbc::DescriptorRangeFlags::None;
|
|
|
|
std::string Out;
|
|
llvm::raw_string_ostream OS(Out);
|
|
OS << Clause;
|
|
OS.flush();
|
|
|
|
std::string Expected = "SRV(t0, numDescriptors = unbounded, space = 42, "
|
|
"offset = 3, flags = None)";
|
|
EXPECT_EQ(Out, Expected);
|
|
}
|
|
|
|
TEST(HLSLRootSignatureTest, DescriptorUAVClauseDump) {
|
|
using llvm::dxbc::DescriptorRangeFlags;
|
|
DescriptorTableClause Clause;
|
|
Clause.Type = ResourceClass::UAV;
|
|
Clause.Reg = {RegisterType::UReg, 92374};
|
|
Clause.NumDescriptors = 3298;
|
|
Clause.Space = 932847;
|
|
Clause.Offset = 1;
|
|
auto ValidDescriptorRangeFlags =
|
|
DescriptorRangeFlags::DescriptorsVolatile |
|
|
DescriptorRangeFlags::DataVolatile |
|
|
DescriptorRangeFlags::DataStaticWhileSetAtExecute |
|
|
DescriptorRangeFlags::DataStatic |
|
|
DescriptorRangeFlags::DescriptorsStaticKeepingBufferBoundsChecks;
|
|
Clause.Flags = ValidDescriptorRangeFlags;
|
|
|
|
std::string Out;
|
|
llvm::raw_string_ostream OS(Out);
|
|
OS << Clause;
|
|
OS.flush();
|
|
|
|
std::string Expected =
|
|
"UAV(u92374, numDescriptors = 3298, space = 932847, offset = 1, flags = "
|
|
"DescriptorsVolatile | "
|
|
"DataVolatile | "
|
|
"DataStaticWhileSetAtExecute | "
|
|
"DataStatic | "
|
|
"DescriptorsStaticKeepingBufferBoundsChecks)";
|
|
EXPECT_EQ(Out, Expected);
|
|
}
|
|
|
|
TEST(HLSLRootSignatureTest, DescriptorSamplerClauseDump) {
|
|
DescriptorTableClause Clause;
|
|
Clause.Type = ResourceClass::Sampler;
|
|
Clause.Reg = {RegisterType::SReg, 0};
|
|
Clause.NumDescriptors = 2;
|
|
Clause.Space = 42;
|
|
Clause.Offset = DescriptorTableOffsetAppend;
|
|
Clause.Flags = llvm::dxbc::DescriptorRangeFlags::DescriptorsVolatile;
|
|
|
|
std::string Out;
|
|
llvm::raw_string_ostream OS(Out);
|
|
OS << Clause;
|
|
OS.flush();
|
|
|
|
std::string Expected = "Sampler(s0, numDescriptors = 2, space = 42, offset = "
|
|
"DescriptorTableOffsetAppend, "
|
|
"flags = DescriptorsVolatile)";
|
|
EXPECT_EQ(Out, Expected);
|
|
}
|
|
|
|
TEST(HLSLRootSignatureTest, DescriptorCBVV10ClauseDump) {
|
|
DescriptorTableClause Clause;
|
|
Clause.Type = ResourceClass::CBuffer;
|
|
Clause.Reg = {RegisterType::BReg, 0};
|
|
Clause.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_0);
|
|
|
|
std::string Out;
|
|
llvm::raw_string_ostream OS(Out);
|
|
OS << Clause;
|
|
OS.flush();
|
|
|
|
std::string Expected = "CBV(b0, numDescriptors = 1, space = 0, "
|
|
"offset = DescriptorTableOffsetAppend, "
|
|
"flags = DescriptorsVolatile | DataVolatile)";
|
|
EXPECT_EQ(Out, Expected);
|
|
}
|
|
|
|
TEST(HLSLRootSignatureTest, DescriptorSamplerV10ClauseDump) {
|
|
DescriptorTableClause Clause;
|
|
Clause.Type = ResourceClass::Sampler;
|
|
Clause.Reg = {RegisterType::SReg, 0};
|
|
Clause.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_0);
|
|
|
|
std::string Out;
|
|
llvm::raw_string_ostream OS(Out);
|
|
OS << Clause;
|
|
OS.flush();
|
|
|
|
std::string Expected = "Sampler(s0, numDescriptors = 1, space = 0, offset = "
|
|
"DescriptorTableOffsetAppend, "
|
|
"flags = DescriptorsVolatile)";
|
|
EXPECT_EQ(Out, Expected);
|
|
}
|
|
|
|
TEST(HLSLRootSignatureTest, DescriptorTableDump) {
|
|
DescriptorTable Table;
|
|
Table.NumClauses = 4;
|
|
Table.Visibility = llvm::dxbc::ShaderVisibility::Geometry;
|
|
|
|
std::string Out;
|
|
llvm::raw_string_ostream OS(Out);
|
|
OS << Table;
|
|
OS.flush();
|
|
|
|
std::string Expected =
|
|
"DescriptorTable(numClauses = 4, visibility = Geometry)";
|
|
EXPECT_EQ(Out, Expected);
|
|
}
|
|
|
|
TEST(HLSLRootSignatureTest, RootCBVDump) {
|
|
RootDescriptor Descriptor;
|
|
Descriptor.Type = ResourceClass::CBuffer;
|
|
Descriptor.Reg = {RegisterType::BReg, 0};
|
|
Descriptor.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_1);
|
|
|
|
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, RootSRV10Dump) {
|
|
RootDescriptor Descriptor;
|
|
Descriptor.Type = ResourceClass::SRV;
|
|
Descriptor.Reg = {RegisterType::TReg, 0};
|
|
Descriptor.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_0);
|
|
|
|
std::string Out;
|
|
llvm::raw_string_ostream OS(Out);
|
|
OS << Descriptor;
|
|
OS.flush();
|
|
|
|
std::string Expected = "RootSRV(t0, space = 0, "
|
|
"visibility = All, "
|
|
"flags = DataVolatile)";
|
|
EXPECT_EQ(Out, Expected);
|
|
}
|
|
|
|
TEST(HLSLRootSignatureTest, RootUAVV10Dump) {
|
|
RootDescriptor Descriptor;
|
|
Descriptor.Type = ResourceClass::UAV;
|
|
Descriptor.Reg = {RegisterType::UReg, 0};
|
|
Descriptor.setDefaultFlags(llvm::dxbc::RootSignatureVersion::V1_0);
|
|
|
|
std::string Out;
|
|
llvm::raw_string_ostream OS(Out);
|
|
OS << Descriptor;
|
|
OS.flush();
|
|
|
|
std::string Expected = "RootUAV(u0, space = 0, "
|
|
"visibility = All, "
|
|
"flags = DataVolatile)";
|
|
EXPECT_EQ(Out, Expected);
|
|
}
|
|
|
|
TEST(HLSLRootSignatureTest, RootSRVDump) {
|
|
RootDescriptor Descriptor;
|
|
Descriptor.Type = ResourceClass::SRV;
|
|
Descriptor.Reg = {RegisterType::TReg, 0};
|
|
Descriptor.Space = 42;
|
|
Descriptor.Visibility = llvm::dxbc::ShaderVisibility::Geometry;
|
|
Descriptor.Flags = llvm::dxbc::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) {
|
|
using llvm::dxbc::RootDescriptorFlags;
|
|
RootDescriptor Descriptor;
|
|
Descriptor.Type = ResourceClass::UAV;
|
|
Descriptor.Reg = {RegisterType::UReg, 92374};
|
|
Descriptor.Space = 932847;
|
|
Descriptor.Visibility = llvm::dxbc::ShaderVisibility::Hull;
|
|
auto ValidRootDescriptorFlags =
|
|
RootDescriptorFlags::DataVolatile |
|
|
RootDescriptorFlags::DataStaticWhileSetAtExecute |
|
|
RootDescriptorFlags::DataStatic;
|
|
Descriptor.Flags = ValidRootDescriptorFlags;
|
|
|
|
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 = llvm::dxbc::SamplerFilter::ComparisonMinMagLinearMipPoint;
|
|
Sampler.AddressU = llvm::dxbc::TextureAddressMode::Mirror;
|
|
Sampler.AddressV = llvm::dxbc::TextureAddressMode::Border;
|
|
Sampler.AddressW = llvm::dxbc::TextureAddressMode::Clamp;
|
|
Sampler.MipLODBias = 4.8f;
|
|
Sampler.MaxAnisotropy = 32;
|
|
Sampler.CompFunc = llvm::dxbc::ComparisonFunc::NotEqual;
|
|
Sampler.BorderColor = llvm::dxbc::StaticBorderColor::OpaqueBlack;
|
|
Sampler.MinLOD = 1.0f;
|
|
Sampler.MaxLOD = 32.0f;
|
|
Sampler.Space = 7;
|
|
Sampler.Visibility = llvm::dxbc::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;
|
|
Constants.Reg = {RegisterType::BReg, 3};
|
|
|
|
std::string Out;
|
|
llvm::raw_string_ostream OS(Out);
|
|
OS << Constants;
|
|
OS.flush();
|
|
|
|
std::string Expected = "RootConstants(num32BitConstants = 1, b3, space = 0, "
|
|
"visibility = All)";
|
|
EXPECT_EQ(Out, Expected);
|
|
}
|
|
|
|
TEST(HLSLRootSignatureTest, SetRootConstantsDump) {
|
|
RootConstants Constants;
|
|
Constants.Num32BitConstants = 983;
|
|
Constants.Reg = {RegisterType::BReg, 34593};
|
|
Constants.Space = 7;
|
|
Constants.Visibility = llvm::dxbc::ShaderVisibility::Pixel;
|
|
|
|
std::string Out;
|
|
llvm::raw_string_ostream OS(Out);
|
|
OS << Constants;
|
|
OS.flush();
|
|
|
|
std::string Expected = "RootConstants(num32BitConstants = 983, b34593, "
|
|
"space = 7, visibility = Pixel)";
|
|
EXPECT_EQ(Out, Expected);
|
|
}
|
|
|
|
TEST(HLSLRootSignatureTest, NoneRootFlagsDump) {
|
|
llvm::dxbc::RootFlags Flags = llvm::dxbc::RootFlags::None;
|
|
|
|
std::string Out;
|
|
llvm::raw_string_ostream OS(Out);
|
|
OS << Flags;
|
|
OS.flush();
|
|
|
|
std::string Expected = "RootFlags(None)";
|
|
EXPECT_EQ(Out, Expected);
|
|
}
|
|
|
|
TEST(HLSLRootSignatureTest, AllRootFlagsDump) {
|
|
using llvm::dxbc::RootFlags;
|
|
auto ValidRootFlags = RootFlags::AllowInputAssemblerInputLayout |
|
|
RootFlags::DenyVertexShaderRootAccess |
|
|
RootFlags::DenyHullShaderRootAccess |
|
|
RootFlags::DenyDomainShaderRootAccess |
|
|
RootFlags::DenyGeometryShaderRootAccess |
|
|
RootFlags::DenyPixelShaderRootAccess |
|
|
RootFlags::AllowStreamOutput |
|
|
RootFlags::LocalRootSignature |
|
|
RootFlags::DenyAmplificationShaderRootAccess |
|
|
RootFlags::DenyMeshShaderRootAccess |
|
|
RootFlags::CBVSRVUAVHeapDirectlyIndexed |
|
|
RootFlags::SamplerHeapDirectlyIndexed;
|
|
|
|
std::string Out;
|
|
llvm::raw_string_ostream OS(Out);
|
|
OS << ValidRootFlags;
|
|
OS.flush();
|
|
|
|
std::string Expected = "RootFlags("
|
|
"AllowInputAssemblerInputLayout | "
|
|
"DenyVertexShaderRootAccess | "
|
|
"DenyHullShaderRootAccess | "
|
|
"DenyDomainShaderRootAccess | "
|
|
"DenyGeometryShaderRootAccess | "
|
|
"DenyPixelShaderRootAccess | "
|
|
"AllowStreamOutput | "
|
|
"LocalRootSignature | "
|
|
"DenyAmplificationShaderRootAccess | "
|
|
"DenyMeshShaderRootAccess | "
|
|
"CBVSRVUAVHeapDirectlyIndexed | "
|
|
"SamplerHeapDirectlyIndexed)";
|
|
EXPECT_EQ(Out, Expected);
|
|
}
|
|
|
|
} // namespace
|