[llvm] 0ceb0c3 - [NFC][HLSL][DirectX] Let `HLSLRootSignature` reuse the `dxbc` defined enums (#145986)
via llvm-commits
llvm-commits at lists.llvm.org
Thu Jul 3 14:44:16 PDT 2025
Author: Finn Plummer
Date: 2025-07-03T14:44:11-07:00
New Revision: 0ceb0c377a3e67b70965c32e7f21fe8b33f555d2
URL: https://github.com/llvm/llvm-project/commit/0ceb0c377a3e67b70965c32e7f21fe8b33f555d2
DIFF: https://github.com/llvm/llvm-project/commit/0ceb0c377a3e67b70965c32e7f21fe8b33f555d2.diff
LOG: [NFC][HLSL][DirectX] Let `HLSLRootSignature` reuse the `dxbc` defined enums (#145986)
This pr removes the redundancy of having the same enums defined in both
the front-end and back-end of handling root signatures. Since there are
many more uses of the enum in the front-end of the code, we will adhere
to the naming conventions used in the front-end, to minimize the diff.
The macros in `DXContainerConstants.def` are also touched-up to be
consistent and to have each macro name follow its respective definition
in d3d12.h and searchable by name
[here](https://learn.microsoft.com/en-us/windows/win32/api/d3d12/).
Additionally, the many `getEnumNames` are moved to `DXContainer` from
`HLSLRootSignatureUtils` as they we will want them to be exposed
publicly anyways.
Changes for each enum follow the pattern of a commit that will make the
enum definition in `DXContainer` adhere to above listed naming
conventions, followed by a commit to actually use that enum in the
front-end.
Resolves https://github.com/llvm/llvm-project/issues/145815
Added:
Modified:
clang/include/clang/Parse/ParseHLSLRootSignature.h
clang/lib/Parse/ParseHLSLRootSignature.cpp
clang/lib/Sema/SemaHLSL.cpp
clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp
llvm/include/llvm/BinaryFormat/DXContainer.h
llvm/include/llvm/BinaryFormat/DXContainerConstants.def
llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h
llvm/include/llvm/Frontend/HLSL/HLSLRootSignatureUtils.h
llvm/include/llvm/ObjectYAML/DXContainerYAML.h
llvm/lib/BinaryFormat/DXContainer.cpp
llvm/lib/Frontend/HLSL/CMakeLists.txt
llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp
llvm/lib/ObjectYAML/DXContainerYAML.cpp
llvm/lib/Target/DirectX/DXILRootSignature.cpp
llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/Parse/ParseHLSLRootSignature.h b/clang/include/clang/Parse/ParseHLSLRootSignature.h
index afa2c4d8cfe50..18cd1f379e62c 100644
--- a/clang/include/clang/Parse/ParseHLSLRootSignature.h
+++ b/clang/include/clang/Parse/ParseHLSLRootSignature.h
@@ -71,7 +71,7 @@ class RootSignatureParser {
// expected, or, there is a lexing error
/// Root Element parse methods:
- std::optional<llvm::hlsl::rootsig::RootFlags> parseRootFlags();
+ std::optional<llvm::dxbc::RootFlags> parseRootFlags();
std::optional<llvm::hlsl::rootsig::RootConstants> parseRootConstants();
std::optional<llvm::hlsl::rootsig::RootDescriptor> parseRootDescriptor();
std::optional<llvm::hlsl::rootsig::DescriptorTable> parseDescriptorTable();
@@ -86,15 +86,15 @@ class RootSignatureParser {
std::optional<llvm::hlsl::rootsig::Register> Reg;
std::optional<uint32_t> Num32BitConstants;
std::optional<uint32_t> Space;
- std::optional<llvm::hlsl::rootsig::ShaderVisibility> Visibility;
+ std::optional<llvm::dxbc::ShaderVisibility> Visibility;
};
std::optional<ParsedConstantParams> parseRootConstantParams();
struct ParsedRootDescriptorParams {
std::optional<llvm::hlsl::rootsig::Register> Reg;
std::optional<uint32_t> Space;
- std::optional<llvm::hlsl::rootsig::ShaderVisibility> Visibility;
- std::optional<llvm::hlsl::rootsig::RootDescriptorFlags> Flags;
+ std::optional<llvm::dxbc::ShaderVisibility> Visibility;
+ std::optional<llvm::dxbc::RootDescriptorFlags> Flags;
};
std::optional<ParsedRootDescriptorParams>
parseRootDescriptorParams(RootSignatureToken::Kind RegType);
@@ -104,25 +104,25 @@ class RootSignatureParser {
std::optional<uint32_t> NumDescriptors;
std::optional<uint32_t> Space;
std::optional<uint32_t> Offset;
- std::optional<llvm::hlsl::rootsig::DescriptorRangeFlags> Flags;
+ std::optional<llvm::dxbc::DescriptorRangeFlags> Flags;
};
std::optional<ParsedClauseParams>
parseDescriptorTableClauseParams(RootSignatureToken::Kind RegType);
struct ParsedStaticSamplerParams {
std::optional<llvm::hlsl::rootsig::Register> Reg;
- std::optional<llvm::hlsl::rootsig::SamplerFilter> Filter;
- std::optional<llvm::hlsl::rootsig::TextureAddressMode> AddressU;
- std::optional<llvm::hlsl::rootsig::TextureAddressMode> AddressV;
- std::optional<llvm::hlsl::rootsig::TextureAddressMode> AddressW;
+ std::optional<llvm::dxbc::SamplerFilter> Filter;
+ std::optional<llvm::dxbc::TextureAddressMode> AddressU;
+ std::optional<llvm::dxbc::TextureAddressMode> AddressV;
+ std::optional<llvm::dxbc::TextureAddressMode> AddressW;
std::optional<float> MipLODBias;
std::optional<uint32_t> MaxAnisotropy;
- std::optional<llvm::hlsl::rootsig::ComparisonFunc> CompFunc;
- std::optional<llvm::hlsl::rootsig::StaticBorderColor> BorderColor;
+ std::optional<llvm::dxbc::ComparisonFunc> CompFunc;
+ std::optional<llvm::dxbc::StaticBorderColor> BorderColor;
std::optional<float> MinLOD;
std::optional<float> MaxLOD;
std::optional<uint32_t> Space;
- std::optional<llvm::hlsl::rootsig::ShaderVisibility> Visibility;
+ std::optional<llvm::dxbc::ShaderVisibility> Visibility;
};
std::optional<ParsedStaticSamplerParams> parseStaticSamplerParams();
@@ -132,17 +132,13 @@ class RootSignatureParser {
std::optional<float> parseFloatParam();
/// Parsing methods of various enums
- std::optional<llvm::hlsl::rootsig::ShaderVisibility> parseShaderVisibility();
- std::optional<llvm::hlsl::rootsig::SamplerFilter> parseSamplerFilter();
- std::optional<llvm::hlsl::rootsig::TextureAddressMode>
- parseTextureAddressMode();
- std::optional<llvm::hlsl::rootsig::ComparisonFunc> parseComparisonFunc();
- std::optional<llvm::hlsl::rootsig::StaticBorderColor>
- parseStaticBorderColor();
- std::optional<llvm::hlsl::rootsig::RootDescriptorFlags>
- parseRootDescriptorFlags();
- std::optional<llvm::hlsl::rootsig::DescriptorRangeFlags>
- parseDescriptorRangeFlags();
+ std::optional<llvm::dxbc::ShaderVisibility> parseShaderVisibility();
+ std::optional<llvm::dxbc::SamplerFilter> parseSamplerFilter();
+ std::optional<llvm::dxbc::TextureAddressMode> parseTextureAddressMode();
+ std::optional<llvm::dxbc::ComparisonFunc> parseComparisonFunc();
+ std::optional<llvm::dxbc::StaticBorderColor> parseStaticBorderColor();
+ std::optional<llvm::dxbc::RootDescriptorFlags> parseRootDescriptorFlags();
+ std::optional<llvm::dxbc::DescriptorRangeFlags> parseDescriptorRangeFlags();
/// Use NumericLiteralParser to convert CurToken.NumSpelling into a unsigned
/// 32-bit integer
diff --git a/clang/lib/Parse/ParseHLSLRootSignature.cpp b/clang/lib/Parse/ParseHLSLRootSignature.cpp
index e510302c3aae0..18d3644114eef 100644
--- a/clang/lib/Parse/ParseHLSLRootSignature.cpp
+++ b/clang/lib/Parse/ParseHLSLRootSignature.cpp
@@ -76,7 +76,7 @@ static FlagType maybeOrFlag(std::optional<FlagType> Flags, FlagType Flag) {
llvm::to_underlying(Flag));
}
-std::optional<RootFlags> RootSignatureParser::parseRootFlags() {
+std::optional<llvm::dxbc::RootFlags> RootSignatureParser::parseRootFlags() {
assert(CurToken.TokKind == TokenKind::kw_RootFlags &&
"Expects to only be invoked starting at given keyword");
@@ -84,7 +84,7 @@ std::optional<RootFlags> RootSignatureParser::parseRootFlags() {
CurToken.TokKind))
return std::nullopt;
- std::optional<RootFlags> Flags = RootFlags::None;
+ std::optional<llvm::dxbc::RootFlags> Flags = llvm::dxbc::RootFlags::None;
// Handle the edge-case of '0' to specify no flags set
if (tryConsumeExpectedToken(TokenKind::int_literal)) {
@@ -104,7 +104,8 @@ std::optional<RootFlags> RootSignatureParser::parseRootFlags() {
switch (CurToken.TokKind) {
#define ROOT_FLAG_ENUM(NAME, LIT) \
case TokenKind::en_##NAME: \
- Flags = maybeOrFlag<RootFlags>(Flags, RootFlags::NAME); \
+ Flags = maybeOrFlag<llvm::dxbc::RootFlags>(Flags, \
+ llvm::dxbc::RootFlags::NAME); \
break;
#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
default:
@@ -240,7 +241,7 @@ std::optional<DescriptorTable> RootSignatureParser::parseDescriptorTable() {
return std::nullopt;
DescriptorTable Table;
- std::optional<ShaderVisibility> Visibility;
+ std::optional<llvm::dxbc::ShaderVisibility> Visibility;
// Iterate as many Clauses as possible
do {
@@ -983,7 +984,7 @@ std::optional<float> RootSignatureParser::parseFloatParam() {
return std::nullopt;
}
-std::optional<llvm::hlsl::rootsig::ShaderVisibility>
+std::optional<llvm::dxbc::ShaderVisibility>
RootSignatureParser::parseShaderVisibility() {
assert(CurToken.TokKind == TokenKind::pu_equal &&
"Expects to only be invoked starting at given keyword");
@@ -999,7 +1000,7 @@ RootSignatureParser::parseShaderVisibility() {
switch (CurToken.TokKind) {
#define SHADER_VISIBILITY_ENUM(NAME, LIT) \
case TokenKind::en_##NAME: \
- return ShaderVisibility::NAME; \
+ return llvm::dxbc::ShaderVisibility::NAME; \
break;
#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
default:
@@ -1009,7 +1010,7 @@ RootSignatureParser::parseShaderVisibility() {
return std::nullopt;
}
-std::optional<llvm::hlsl::rootsig::SamplerFilter>
+std::optional<llvm::dxbc::SamplerFilter>
RootSignatureParser::parseSamplerFilter() {
assert(CurToken.TokKind == TokenKind::pu_equal &&
"Expects to only be invoked starting at given keyword");
@@ -1025,7 +1026,7 @@ RootSignatureParser::parseSamplerFilter() {
switch (CurToken.TokKind) {
#define FILTER_ENUM(NAME, LIT) \
case TokenKind::en_##NAME: \
- return SamplerFilter::NAME; \
+ return llvm::dxbc::SamplerFilter::NAME; \
break;
#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
default:
@@ -1035,7 +1036,7 @@ RootSignatureParser::parseSamplerFilter() {
return std::nullopt;
}
-std::optional<llvm::hlsl::rootsig::TextureAddressMode>
+std::optional<llvm::dxbc::TextureAddressMode>
RootSignatureParser::parseTextureAddressMode() {
assert(CurToken.TokKind == TokenKind::pu_equal &&
"Expects to only be invoked starting at given keyword");
@@ -1051,7 +1052,7 @@ RootSignatureParser::parseTextureAddressMode() {
switch (CurToken.TokKind) {
#define TEXTURE_ADDRESS_MODE_ENUM(NAME, LIT) \
case TokenKind::en_##NAME: \
- return TextureAddressMode::NAME; \
+ return llvm::dxbc::TextureAddressMode::NAME; \
break;
#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
default:
@@ -1061,7 +1062,7 @@ RootSignatureParser::parseTextureAddressMode() {
return std::nullopt;
}
-std::optional<llvm::hlsl::rootsig::ComparisonFunc>
+std::optional<llvm::dxbc::ComparisonFunc>
RootSignatureParser::parseComparisonFunc() {
assert(CurToken.TokKind == TokenKind::pu_equal &&
"Expects to only be invoked starting at given keyword");
@@ -1077,7 +1078,7 @@ RootSignatureParser::parseComparisonFunc() {
switch (CurToken.TokKind) {
#define COMPARISON_FUNC_ENUM(NAME, LIT) \
case TokenKind::en_##NAME: \
- return ComparisonFunc::NAME; \
+ return llvm::dxbc::ComparisonFunc::NAME; \
break;
#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
default:
@@ -1087,7 +1088,7 @@ RootSignatureParser::parseComparisonFunc() {
return std::nullopt;
}
-std::optional<llvm::hlsl::rootsig::StaticBorderColor>
+std::optional<llvm::dxbc::StaticBorderColor>
RootSignatureParser::parseStaticBorderColor() {
assert(CurToken.TokKind == TokenKind::pu_equal &&
"Expects to only be invoked starting at given keyword");
@@ -1103,7 +1104,7 @@ RootSignatureParser::parseStaticBorderColor() {
switch (CurToken.TokKind) {
#define STATIC_BORDER_COLOR_ENUM(NAME, LIT) \
case TokenKind::en_##NAME: \
- return StaticBorderColor::NAME; \
+ return llvm::dxbc::StaticBorderColor::NAME; \
break;
#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
default:
@@ -1113,7 +1114,7 @@ RootSignatureParser::parseStaticBorderColor() {
return std::nullopt;
}
-std::optional<llvm::hlsl::rootsig::RootDescriptorFlags>
+std::optional<llvm::dxbc::RootDescriptorFlags>
RootSignatureParser::parseRootDescriptorFlags() {
assert(CurToken.TokKind == TokenKind::pu_equal &&
"Expects to only be invoked starting at given keyword");
@@ -1124,7 +1125,7 @@ RootSignatureParser::parseRootDescriptorFlags() {
getDiags().Report(CurToken.TokLoc, diag::err_hlsl_rootsig_non_zero_flag);
return std::nullopt;
}
- return RootDescriptorFlags::None;
+ return llvm::dxbc::RootDescriptorFlags::None;
}
TokenKind Expected[] = {
@@ -1132,15 +1133,15 @@ RootSignatureParser::parseRootDescriptorFlags() {
#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
};
- std::optional<RootDescriptorFlags> Flags;
+ std::optional<llvm::dxbc::RootDescriptorFlags> Flags;
do {
if (tryConsumeExpectedToken(Expected)) {
switch (CurToken.TokKind) {
#define ROOT_DESCRIPTOR_FLAG_ENUM(NAME, LIT) \
case TokenKind::en_##NAME: \
- Flags = \
- maybeOrFlag<RootDescriptorFlags>(Flags, RootDescriptorFlags::NAME); \
+ Flags = maybeOrFlag<llvm::dxbc::RootDescriptorFlags>( \
+ Flags, llvm::dxbc::RootDescriptorFlags::NAME); \
break;
#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
default:
@@ -1152,7 +1153,7 @@ RootSignatureParser::parseRootDescriptorFlags() {
return Flags;
}
-std::optional<llvm::hlsl::rootsig::DescriptorRangeFlags>
+std::optional<llvm::dxbc::DescriptorRangeFlags>
RootSignatureParser::parseDescriptorRangeFlags() {
assert(CurToken.TokKind == TokenKind::pu_equal &&
"Expects to only be invoked starting at given keyword");
@@ -1163,7 +1164,7 @@ RootSignatureParser::parseDescriptorRangeFlags() {
getDiags().Report(CurToken.TokLoc, diag::err_hlsl_rootsig_non_zero_flag);
return std::nullopt;
}
- return DescriptorRangeFlags::None;
+ return llvm::dxbc::DescriptorRangeFlags::None;
}
TokenKind Expected[] = {
@@ -1171,15 +1172,15 @@ RootSignatureParser::parseDescriptorRangeFlags() {
#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
};
- std::optional<DescriptorRangeFlags> Flags;
+ std::optional<llvm::dxbc::DescriptorRangeFlags> Flags;
do {
if (tryConsumeExpectedToken(Expected)) {
switch (CurToken.TokKind) {
#define DESCRIPTOR_RANGE_FLAG_ENUM(NAME, LIT, ON) \
case TokenKind::en_##NAME: \
- Flags = \
- maybeOrFlag<DescriptorRangeFlags>(Flags, DescriptorRangeFlags::NAME); \
+ Flags = maybeOrFlag<llvm::dxbc::DescriptorRangeFlags>( \
+ Flags, llvm::dxbc::DescriptorRangeFlags::NAME); \
break;
#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
default:
diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp
index bad357b50929b..6061b0015a56b 100644
--- a/clang/lib/Sema/SemaHLSL.cpp
+++ b/clang/lib/Sema/SemaHLSL.cpp
@@ -1200,10 +1200,9 @@ bool SemaHLSL::handleRootSignatureDecl(HLSLRootSignatureDecl *D,
auto ReportOverlap = [this, Loc, &HadOverlap](const RangeInfo *Info,
const RangeInfo *OInfo) {
HadOverlap = true;
- auto CommonVis =
- Info->Visibility == llvm::hlsl::rootsig::ShaderVisibility::All
- ? OInfo->Visibility
- : Info->Visibility;
+ auto CommonVis = Info->Visibility == llvm::dxbc::ShaderVisibility::All
+ ? OInfo->Visibility
+ : Info->Visibility;
this->Diag(Loc, diag::err_hlsl_resource_range_overlap)
<< llvm::to_underlying(Info->Class) << Info->LowerBound
<< /*unbounded=*/(Info->UpperBound == RangeInfo::Unbounded)
@@ -1238,7 +1237,7 @@ bool SemaHLSL::handleRootSignatureDecl(HLSLRootSignatureDecl *D,
// ResourceRanges in the former case and it will be an ArrayRef to just the
// all visiblity ResourceRange in the latter case.
ArrayRef<ResourceRange> OverlapRanges =
- Info.Visibility == llvm::hlsl::rootsig::ShaderVisibility::All
+ Info.Visibility == llvm::dxbc::ShaderVisibility::All
? ArrayRef<ResourceRange>{Ranges}.drop_front()
: ArrayRef<ResourceRange>{Ranges}.take_front();
diff --git a/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp b/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp
index 1e46ee35d5d49..8831198e4b9c2 100644
--- a/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp
+++ b/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp
@@ -127,6 +127,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseEmptyTest) {
}
TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) {
+ using llvm::dxbc::DescriptorRangeFlags;
const llvm::StringLiteral Source = R"cc(
DescriptorTable(
CBV(b0),
@@ -205,20 +206,27 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) {
ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Space, 0u);
ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Offset,
DescriptorTableOffsetAppend);
+ auto ValidDescriptorRangeFlags =
+ DescriptorRangeFlags::DescriptorsVolatile |
+ DescriptorRangeFlags::DataVolatile |
+ DescriptorRangeFlags::DataStaticWhileSetAtExecute |
+ DescriptorRangeFlags::DataStatic |
+ DescriptorRangeFlags::DescriptorsStaticKeepingBufferBoundsChecks;
ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags,
- DescriptorRangeFlags::ValidFlags);
+ ValidDescriptorRangeFlags);
Elem = Elements[4];
ASSERT_TRUE(std::holds_alternative<DescriptorTable>(Elem));
ASSERT_EQ(std::get<DescriptorTable>(Elem).NumClauses, (uint32_t)4);
ASSERT_EQ(std::get<DescriptorTable>(Elem).Visibility,
- ShaderVisibility::Pixel);
+ llvm::dxbc::ShaderVisibility::Pixel);
// Empty Descriptor Table
Elem = Elements[5];
ASSERT_TRUE(std::holds_alternative<DescriptorTable>(Elem));
ASSERT_EQ(std::get<DescriptorTable>(Elem).NumClauses, 0u);
- ASSERT_EQ(std::get<DescriptorTable>(Elem).Visibility, ShaderVisibility::All);
+ ASSERT_EQ(std::get<DescriptorTable>(Elem).Visibility,
+ llvm::dxbc::ShaderVisibility::All);
ASSERT_TRUE(Consumer->isSatisfied());
}
@@ -258,19 +266,25 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseStaticSamplerTest) {
ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem));
ASSERT_EQ(std::get<StaticSampler>(Elem).Reg.ViewType, RegisterType::SReg);
ASSERT_EQ(std::get<StaticSampler>(Elem).Reg.Number, 0u);
- ASSERT_EQ(std::get<StaticSampler>(Elem).Filter, SamplerFilter::Anisotropic);
- ASSERT_EQ(std::get<StaticSampler>(Elem).AddressU, TextureAddressMode::Wrap);
- ASSERT_EQ(std::get<StaticSampler>(Elem).AddressV, TextureAddressMode::Wrap);
- ASSERT_EQ(std::get<StaticSampler>(Elem).AddressW, TextureAddressMode::Wrap);
+ ASSERT_EQ(std::get<StaticSampler>(Elem).Filter,
+ llvm::dxbc::SamplerFilter::Anisotropic);
+ ASSERT_EQ(std::get<StaticSampler>(Elem).AddressU,
+ llvm::dxbc::TextureAddressMode::Wrap);
+ ASSERT_EQ(std::get<StaticSampler>(Elem).AddressV,
+ llvm::dxbc::TextureAddressMode::Wrap);
+ ASSERT_EQ(std::get<StaticSampler>(Elem).AddressW,
+ llvm::dxbc::TextureAddressMode::Wrap);
ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 0.f);
ASSERT_EQ(std::get<StaticSampler>(Elem).MaxAnisotropy, 16u);
- ASSERT_EQ(std::get<StaticSampler>(Elem).CompFunc, ComparisonFunc::LessEqual);
+ ASSERT_EQ(std::get<StaticSampler>(Elem).CompFunc,
+ llvm::dxbc::ComparisonFunc::LessEqual);
ASSERT_EQ(std::get<StaticSampler>(Elem).BorderColor,
- StaticBorderColor::OpaqueWhite);
+ llvm::dxbc::StaticBorderColor::OpaqueWhite);
ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MinLOD, 0.f);
ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MaxLOD, 3.402823466e+38f);
ASSERT_EQ(std::get<StaticSampler>(Elem).Space, 0u);
- ASSERT_EQ(std::get<StaticSampler>(Elem).Visibility, ShaderVisibility::All);
+ ASSERT_EQ(std::get<StaticSampler>(Elem).Visibility,
+ llvm::dxbc::ShaderVisibility::All);
// Check values can be set as expected
Elem = Elements[1];
@@ -278,19 +292,24 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseStaticSamplerTest) {
ASSERT_EQ(std::get<StaticSampler>(Elem).Reg.ViewType, RegisterType::SReg);
ASSERT_EQ(std::get<StaticSampler>(Elem).Reg.Number, 0u);
ASSERT_EQ(std::get<StaticSampler>(Elem).Filter,
- SamplerFilter::MaximumMinPointMagLinearMipPoint);
- ASSERT_EQ(std::get<StaticSampler>(Elem).AddressU, TextureAddressMode::Mirror);
- ASSERT_EQ(std::get<StaticSampler>(Elem).AddressV, TextureAddressMode::Border);
- ASSERT_EQ(std::get<StaticSampler>(Elem).AddressW, TextureAddressMode::Clamp);
+ llvm::dxbc::SamplerFilter::MaximumMinPointMagLinearMipPoint);
+ ASSERT_EQ(std::get<StaticSampler>(Elem).AddressU,
+ llvm::dxbc::TextureAddressMode::Mirror);
+ ASSERT_EQ(std::get<StaticSampler>(Elem).AddressV,
+ llvm::dxbc::TextureAddressMode::Border);
+ ASSERT_EQ(std::get<StaticSampler>(Elem).AddressW,
+ llvm::dxbc::TextureAddressMode::Clamp);
ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 230.f);
ASSERT_EQ(std::get<StaticSampler>(Elem).MaxAnisotropy, 3u);
- ASSERT_EQ(std::get<StaticSampler>(Elem).CompFunc, ComparisonFunc::NotEqual);
+ ASSERT_EQ(std::get<StaticSampler>(Elem).CompFunc,
+ llvm::dxbc::ComparisonFunc::NotEqual);
ASSERT_EQ(std::get<StaticSampler>(Elem).BorderColor,
- StaticBorderColor::OpaqueBlackUint);
+ llvm::dxbc::StaticBorderColor::OpaqueBlackUint);
ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MinLOD, 4.2f);
ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MaxLOD, 9000.f);
ASSERT_EQ(std::get<StaticSampler>(Elem).Space, 4u);
- ASSERT_EQ(std::get<StaticSampler>(Elem).Visibility, ShaderVisibility::Domain);
+ ASSERT_EQ(std::get<StaticSampler>(Elem).Visibility,
+ llvm::dxbc::ShaderVisibility::Domain);
ASSERT_TRUE(Consumer->isSatisfied());
}
@@ -403,8 +422,9 @@ TEST_F(ParseHLSLRootSignatureTest, ValidSamplerFlagsTest) {
RootElement Elem = Elements[0];
ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem));
ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::Sampler);
- ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags,
- DescriptorRangeFlags::ValidSamplerFlags);
+ auto ValidSamplerFlags =
+ llvm::dxbc::DescriptorRangeFlags::DescriptorsVolatile;
+ ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, ValidSamplerFlags);
ASSERT_TRUE(Consumer->isSatisfied());
}
@@ -438,7 +458,8 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootConsantsTest) {
ASSERT_EQ(std::get<RootConstants>(Elem).Reg.ViewType, RegisterType::BReg);
ASSERT_EQ(std::get<RootConstants>(Elem).Reg.Number, 0u);
ASSERT_EQ(std::get<RootConstants>(Elem).Space, 0u);
- ASSERT_EQ(std::get<RootConstants>(Elem).Visibility, ShaderVisibility::All);
+ ASSERT_EQ(std::get<RootConstants>(Elem).Visibility,
+ llvm::dxbc::ShaderVisibility::All);
Elem = Elements[1];
ASSERT_TRUE(std::holds_alternative<RootConstants>(Elem));
@@ -446,12 +467,14 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootConsantsTest) {
ASSERT_EQ(std::get<RootConstants>(Elem).Reg.ViewType, RegisterType::BReg);
ASSERT_EQ(std::get<RootConstants>(Elem).Reg.Number, 42u);
ASSERT_EQ(std::get<RootConstants>(Elem).Space, 3u);
- ASSERT_EQ(std::get<RootConstants>(Elem).Visibility, ShaderVisibility::Hull);
+ ASSERT_EQ(std::get<RootConstants>(Elem).Visibility,
+ llvm::dxbc::ShaderVisibility::Hull);
ASSERT_TRUE(Consumer->isSatisfied());
}
TEST_F(ParseHLSLRootSignatureTest, ValidParseRootFlagsTest) {
+ using llvm::dxbc::RootFlags;
const llvm::StringLiteral Source = R"cc(
RootFlags(),
RootFlags(0),
@@ -496,12 +519,25 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootFlagsTest) {
Elem = Elements[2];
ASSERT_TRUE(std::holds_alternative<RootFlags>(Elem));
- ASSERT_EQ(std::get<RootFlags>(Elem), RootFlags::ValidFlags);
+ 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;
+ ASSERT_EQ(std::get<RootFlags>(Elem), ValidRootFlags);
ASSERT_TRUE(Consumer->isSatisfied());
}
TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) {
+ using llvm::dxbc::RootDescriptorFlags;
const llvm::StringLiteral Source = R"cc(
CBV(b0),
SRV(space = 4, t42, visibility = SHADER_VISIBILITY_GEOMETRY,
@@ -532,7 +568,8 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) {
ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.ViewType, RegisterType::BReg);
ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.Number, 0u);
ASSERT_EQ(std::get<RootDescriptor>(Elem).Space, 0u);
- ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility, ShaderVisibility::All);
+ ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility,
+ llvm::dxbc::ShaderVisibility::All);
ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags,
RootDescriptorFlags::DataStaticWhileSetAtExecute);
@@ -543,9 +580,12 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) {
ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.Number, 42u);
ASSERT_EQ(std::get<RootDescriptor>(Elem).Space, 4u);
ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility,
- ShaderVisibility::Geometry);
- ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags,
- RootDescriptorFlags::ValidFlags);
+ llvm::dxbc::ShaderVisibility::Geometry);
+ auto ValidRootDescriptorFlags =
+ RootDescriptorFlags::DataVolatile |
+ RootDescriptorFlags::DataStaticWhileSetAtExecute |
+ RootDescriptorFlags::DataStatic;
+ ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, ValidRootDescriptorFlags);
Elem = Elements[2];
ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem));
@@ -553,7 +593,8 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) {
ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.ViewType, RegisterType::UReg);
ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.Number, 34893247u);
ASSERT_EQ(std::get<RootDescriptor>(Elem).Space, 0u);
- ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility, ShaderVisibility::Hull);
+ ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility,
+ llvm::dxbc::ShaderVisibility::Hull);
ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags,
RootDescriptorFlags::DataVolatile);
ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags,
@@ -564,7 +605,8 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) {
ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.ViewType, RegisterType::BReg);
ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.Number, 0u);
ASSERT_EQ(std::get<RootDescriptor>(Elem).Space, 0u);
- ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility, ShaderVisibility::All);
+ ASSERT_EQ(std::get<RootDescriptor>(Elem).Visibility,
+ llvm::dxbc::ShaderVisibility::All);
ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, RootDescriptorFlags::None);
ASSERT_TRUE(Consumer->isSatisfied());
diff --git a/llvm/include/llvm/BinaryFormat/DXContainer.h b/llvm/include/llvm/BinaryFormat/DXContainer.h
index 45170f550faf1..89abca02efefa 100644
--- a/llvm/include/llvm/BinaryFormat/DXContainer.h
+++ b/llvm/include/llvm/BinaryFormat/DXContainer.h
@@ -157,23 +157,33 @@ enum class FeatureFlags : uint64_t {
static_assert((uint64_t)FeatureFlags::NextUnusedBit <= 1ull << 63,
"Shader flag bits exceed enum size.");
-#define ROOT_ELEMENT_FLAG(Num, Val) Val = Num,
-enum class RootElementFlag : uint32_t {
+#define ROOT_SIGNATURE_FLAG(Num, Val) Val = Num,
+enum class RootFlags : uint32_t {
#include "DXContainerConstants.def"
+
+ LLVM_MARK_AS_BITMASK_ENUM(SamplerHeapDirectlyIndexed)
};
-#define ROOT_DESCRIPTOR_FLAG(Num, Val) Val = Num,
-enum class RootDescriptorFlag : uint32_t {
+LLVM_ABI ArrayRef<EnumEntry<RootFlags>> getRootFlags();
+
+#define ROOT_DESCRIPTOR_FLAG(Num, Enum, Flag) Enum = Num,
+enum class RootDescriptorFlags : uint32_t {
#include "DXContainerConstants.def"
+
+ LLVM_MARK_AS_BITMASK_ENUM(DataStatic)
};
-#define DESCRIPTOR_RANGE_FLAG(Num, Val) Val = Num,
-enum class DescriptorRangeFlag : uint32_t {
+LLVM_ABI ArrayRef<EnumEntry<RootDescriptorFlags>> getRootDescriptorFlags();
+
+#define DESCRIPTOR_RANGE_FLAG(Num, Enum, Flag) Enum = Num,
+enum class DescriptorRangeFlags : uint32_t {
#include "DXContainerConstants.def"
- LLVM_MARK_AS_BITMASK_ENUM(DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS)
+ LLVM_MARK_AS_BITMASK_ENUM(DescriptorsStaticKeepingBufferBoundsChecks)
};
+LLVM_ABI ArrayRef<EnumEntry<DescriptorRangeFlags>> getDescriptorRangeFlags();
+
#define ROOT_PARAMETER(Val, Enum) Enum = Val,
enum class RootParameterType : uint32_t {
#include "DXContainerConstants.def"
@@ -215,26 +225,34 @@ inline bool isValidShaderVisibility(uint32_t V) {
return false;
}
-#define STATIC_SAMPLER_FILTER(Val, Enum) Enum = Val,
-enum class StaticSamplerFilter : uint32_t {
+#define FILTER(Val, Enum) Enum = Val,
+enum class SamplerFilter : uint32_t {
#include "DXContainerConstants.def"
};
+LLVM_ABI ArrayRef<EnumEntry<SamplerFilter>> getSamplerFilters();
+
#define TEXTURE_ADDRESS_MODE(Val, Enum) Enum = Val,
enum class TextureAddressMode : uint32_t {
#include "DXContainerConstants.def"
};
-#define COMPARISON_FUNCTION(Val, Enum) Enum = Val,
-enum class SamplersComparisonFunction : uint32_t {
+LLVM_ABI ArrayRef<EnumEntry<TextureAddressMode>> getTextureAddressModes();
+
+#define COMPARISON_FUNC(Val, Enum) Enum = Val,
+enum class ComparisonFunc : uint32_t {
#include "DXContainerConstants.def"
};
+LLVM_ABI ArrayRef<EnumEntry<ComparisonFunc>> getComparisonFuncs();
+
#define STATIC_BORDER_COLOR(Val, Enum) Enum = Val,
-enum class SamplersBorderColor : uint32_t {
+enum class StaticBorderColor : uint32_t {
#include "DXContainerConstants.def"
};
+LLVM_ABI ArrayRef<EnumEntry<StaticBorderColor>> getStaticBorderColors();
+
LLVM_ABI PartType parsePartType(StringRef S);
struct VertexPSVInfo {
diff --git a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def
index a281256a44ae0..8730820dd8b06 100644
--- a/llvm/include/llvm/BinaryFormat/DXContainerConstants.def
+++ b/llvm/include/llvm/BinaryFormat/DXContainerConstants.def
@@ -55,47 +55,52 @@ SHADER_FEATURE_FLAG(33, 39, NextUnusedBit, "Next reserved shader flag bit (not a
#undef SHADER_FEATURE_FLAG
#endif // SHADER_FEATURE_FLAG
-
-// ROOT_ELEMENT_FLAG(bit offset for the flag, name).
-#ifdef ROOT_ELEMENT_FLAG
-
-ROOT_ELEMENT_FLAG(0, NONE)
-ROOT_ELEMENT_FLAG(0x1, AllowInputAssemblerInputLayout)
-ROOT_ELEMENT_FLAG(0x2, DenyVertexShaderRootAccess)
-ROOT_ELEMENT_FLAG(0x4, DenyHullShaderRootAccess)
-ROOT_ELEMENT_FLAG(0x8, DenyDomainShaderRootAccess)
-ROOT_ELEMENT_FLAG(0x10, DenyGeometryShaderRootAccess)
-ROOT_ELEMENT_FLAG(0x20, DenyPixelShaderRootAccess)
-ROOT_ELEMENT_FLAG(0x40, AllowStreamOutput)
-ROOT_ELEMENT_FLAG(0x80, LocalRootSignature)
-ROOT_ELEMENT_FLAG(0x100, DenyAmplificationShaderRootAccess)
-ROOT_ELEMENT_FLAG(0x200, DenyMeshShaderRootAccess)
-ROOT_ELEMENT_FLAG(0x400, CBVSRVUAVHeapDirectlyIndexed)
-ROOT_ELEMENT_FLAG(0x800, SamplerHeapDirectlyIndexed)
-#undef ROOT_ELEMENT_FLAG
-#endif // ROOT_ELEMENT_FLAG
-
+// Below is the definition of root signature enumerations and flags. The
+// definitions of all values here correspond to their description in the
+// d3d12.h header and are carried over from their values in DXC. For reference:
+// https://learn.microsoft.com/en-us/windows/win32/api/d3d12/
+
+// ROOT_SIGNATURE_FLAG(flag value, name).
+#ifdef ROOT_SIGNATURE_FLAG
+
+ROOT_SIGNATURE_FLAG(0, None)
+ROOT_SIGNATURE_FLAG(0x1, AllowInputAssemblerInputLayout)
+ROOT_SIGNATURE_FLAG(0x2, DenyVertexShaderRootAccess)
+ROOT_SIGNATURE_FLAG(0x4, DenyHullShaderRootAccess)
+ROOT_SIGNATURE_FLAG(0x8, DenyDomainShaderRootAccess)
+ROOT_SIGNATURE_FLAG(0x10, DenyGeometryShaderRootAccess)
+ROOT_SIGNATURE_FLAG(0x20, DenyPixelShaderRootAccess)
+ROOT_SIGNATURE_FLAG(0x40, AllowStreamOutput)
+ROOT_SIGNATURE_FLAG(0x80, LocalRootSignature)
+ROOT_SIGNATURE_FLAG(0x100, DenyAmplificationShaderRootAccess)
+ROOT_SIGNATURE_FLAG(0x200, DenyMeshShaderRootAccess)
+ROOT_SIGNATURE_FLAG(0x400, CBVSRVUAVHeapDirectlyIndexed)
+ROOT_SIGNATURE_FLAG(0x800, SamplerHeapDirectlyIndexed)
+
+#undef ROOT_SIGNATURE_FLAG
+#endif // ROOT_SIGNATURE_FLAG
-// ROOT_DESCRIPTOR_FLAG(bit offset for the flag, name).
+// ROOT_DESCRIPTOR_FLAG(flag value, name, flag).
#ifdef ROOT_DESCRIPTOR_FLAG
-ROOT_DESCRIPTOR_FLAG(0, NONE)
-ROOT_DESCRIPTOR_FLAG(0x2, DATA_VOLATILE)
-ROOT_DESCRIPTOR_FLAG(0x4, DATA_STATIC_WHILE_SET_AT_EXECUTE)
-ROOT_DESCRIPTOR_FLAG(0x8, DATA_STATIC)
+ROOT_DESCRIPTOR_FLAG(0, None, NONE)
+ROOT_DESCRIPTOR_FLAG(0x2, DataVolatile, DATA_VOLATILE)
+ROOT_DESCRIPTOR_FLAG(0x4, DataStaticWhileSetAtExecute, DATA_STATIC_WHILE_SET_AT_EXECUTE)
+ROOT_DESCRIPTOR_FLAG(0x8, DataStatic, DATA_STATIC)
+
#undef ROOT_DESCRIPTOR_FLAG
#endif // ROOT_DESCRIPTOR_FLAG
-
-// DESCRIPTOR_RANGE_FLAG(bit offset for the flag, name).
+// DESCRIPTOR_RANGE_FLAG(flag value, name, flag).
#ifdef DESCRIPTOR_RANGE_FLAG
-DESCRIPTOR_RANGE_FLAG(0, NONE)
-DESCRIPTOR_RANGE_FLAG(0x1, DESCRIPTORS_VOLATILE)
-DESCRIPTOR_RANGE_FLAG(0x2, DATA_VOLATILE)
-DESCRIPTOR_RANGE_FLAG(0x4, DATA_STATIC_WHILE_SET_AT_EXECUTE)
-DESCRIPTOR_RANGE_FLAG(0x8, DATA_STATIC)
-DESCRIPTOR_RANGE_FLAG(0x10000, DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS)
+DESCRIPTOR_RANGE_FLAG(0, None, NONE)
+DESCRIPTOR_RANGE_FLAG(0x1, DescriptorsVolatile, DESCRIPTORS_VOLATILE)
+DESCRIPTOR_RANGE_FLAG(0x2, DataVolatile, DATA_VOLATILE)
+DESCRIPTOR_RANGE_FLAG(0x4, DataStaticWhileSetAtExecute, DATA_STATIC_WHILE_SET_AT_EXECUTE)
+DESCRIPTOR_RANGE_FLAG(0x8, DataStatic, DATA_STATIC)
+DESCRIPTOR_RANGE_FLAG(0x10000, DescriptorsStaticKeepingBufferBoundsChecks, DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS)
+
#undef DESCRIPTOR_RANGE_FLAG
#endif // DESCRIPTOR_RANGE_FLAG
@@ -119,6 +124,7 @@ ROOT_PARAMETER(4, UAV)
#undef ROOT_PARAMETER
#endif // ROOT_PARAMETER
+// SHADER_VISIBILITY(value, enum).
#ifdef SHADER_VISIBILITY
SHADER_VISIBILITY(0, All)
@@ -129,79 +135,89 @@ SHADER_VISIBILITY(4, Geometry)
SHADER_VISIBILITY(5, Pixel)
SHADER_VISIBILITY(6, Amplification)
SHADER_VISIBILITY(7, Mesh)
+
#undef SHADER_VISIBILITY
#endif // SHADER_VISIBILITY
-#ifdef STATIC_SAMPLER_FILTER
-
-STATIC_SAMPLER_FILTER(0, MIN_MAG_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x1, MIN_MAG_POINT_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x4, MIN_POINT_MAG_LINEAR_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x5, MIN_POINT_MAG_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x10, MIN_LINEAR_MAG_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x11, MIN_LINEAR_MAG_POINT_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x14, MIN_MAG_LINEAR_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x15, MIN_MAG_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x55, ANISOTROPIC)
-STATIC_SAMPLER_FILTER(0x80, COMPARISON_MIN_MAG_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x81, COMPARISON_MIN_MAG_POINT_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x84, COMPARISON_MIN_POINT_MAG_LINEAR_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x85, COMPARISON_MIN_POINT_MAG_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x90, COMPARISON_MIN_LINEAR_MAG_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x91, COMPARISON_MIN_LINEAR_MAG_POINT_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x94, COMPARISON_MIN_MAG_LINEAR_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x95, COMPARISON_MIN_MAG_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0xd5, COMPARISON_ANISOTROPIC)
-STATIC_SAMPLER_FILTER(0x100, MINIMUM_MIN_MAG_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x101, MINIMUM_MIN_MAG_POINT_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x104, MINIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x105, MINIMUM_MIN_POINT_MAG_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x110, MINIMUM_MIN_LINEAR_MAG_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x111, MINIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x114, MINIMUM_MIN_MAG_LINEAR_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x115, MINIMUM_MIN_MAG_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x155, MINIMUM_ANISOTROPIC)
-STATIC_SAMPLER_FILTER(0x180, MAXIMUM_MIN_MAG_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x181, MAXIMUM_MIN_MAG_POINT_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x184, MAXIMUM_MIN_POINT_MAG_LINEAR_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x185, MAXIMUM_MIN_POINT_MAG_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x190, MAXIMUM_MIN_LINEAR_MAG_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x191, MAXIMUM_MIN_LINEAR_MAG_POINT_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x194, MAXIMUM_MIN_MAG_LINEAR_MIP_POINT)
-STATIC_SAMPLER_FILTER(0x195, MAXIMUM_MIN_MAG_MIP_LINEAR)
-STATIC_SAMPLER_FILTER(0x1d5, MAXIMUM_ANISOTROPIC)
-#undef STATIC_SAMPLER_FILTER
-#endif // STATIC_SAMPLER_FILTER
-
+// FILTER(value, enum).
+#ifdef FILTER
+
+FILTER(0, MinMagMipPoint)
+FILTER(0x1, MinMagPointMipLinear)
+FILTER(0x4, MinPointMagLinearMipPoint)
+FILTER(0x5, MinPointMagMipLinear)
+FILTER(0x10, MinLinearMagMipPoint)
+FILTER(0x11, MinLinearMagPointMipLinear)
+FILTER(0x14, MinMagLinearMipPoint)
+FILTER(0x15, MinMagMipLinear)
+FILTER(0x55, Anisotropic)
+FILTER(0x80, ComparisonMinMagMipPoint)
+FILTER(0x81, ComparisonMinMagPointMipLinear)
+FILTER(0x84, ComparisonMinPointMagLinearMipPoint)
+FILTER(0x85, ComparisonMinPointMagMipLinear)
+FILTER(0x90, ComparisonMinLinearMagMipPoint)
+FILTER(0x91, ComparisonMinLinearMagPointMipLinear)
+FILTER(0x94, ComparisonMinMagLinearMipPoint)
+FILTER(0x95, ComparisonMinMagMipLinear)
+FILTER(0xd5, ComparisonAnisotropic)
+FILTER(0x100, MinimumMinMagMipPoint)
+FILTER(0x101, MinimumMinMagPointMipLinear)
+FILTER(0x104, MinimumMinPointMagLinearMipPoint)
+FILTER(0x105, MinimumMinPointMagMipLinear)
+FILTER(0x110, MinimumMinLinearMagMipPoint)
+FILTER(0x111, MinimumMinLinearMagPointMipLinear)
+FILTER(0x114, MinimumMinMagLinearMipPoint)
+FILTER(0x115, MinimumMinMagMipLinear)
+FILTER(0x155, MinimumAnisotropic)
+FILTER(0x180, MaximumMinMagMipPoint)
+FILTER(0x181, MaximumMinMagPointMipLinear)
+FILTER(0x184, MaximumMinPointMagLinearMipPoint)
+FILTER(0x185, MaximumMinPointMagMipLinear)
+FILTER(0x190, MaximumMinLinearMagMipPoint)
+FILTER(0x191, MaximumMinLinearMagPointMipLinear)
+FILTER(0x194, MaximumMinMagLinearMipPoint)
+FILTER(0x195, MaximumMinMagMipLinear)
+FILTER(0x1d5, MaximumAnisotropic)
+
+#undef FILTER
+#endif // FILTER
+
+// TEXTURE_ADDRESS_MODE(value, enum).
#ifdef TEXTURE_ADDRESS_MODE
-TEXTURE_ADDRESS_MODE( 1, Wrap)
-TEXTURE_ADDRESS_MODE( 2, Mirror)
-TEXTURE_ADDRESS_MODE( 3, Clamp)
-TEXTURE_ADDRESS_MODE( 4, Border)
-TEXTURE_ADDRESS_MODE( 5, MirrorOnce)
+TEXTURE_ADDRESS_MODE(1, Wrap)
+TEXTURE_ADDRESS_MODE(2, Mirror)
+TEXTURE_ADDRESS_MODE(3, Clamp)
+TEXTURE_ADDRESS_MODE(4, Border)
+TEXTURE_ADDRESS_MODE(5, MirrorOnce)
+
#undef TEXTURE_ADDRESS_MODE
#endif // TEXTURE_ADDRESS_MODE
-#ifdef COMPARISON_FUNCTION
+// COMPARISON_FUNC(value, enum).
+#ifdef COMPARISON_FUNC
+
+COMPARISON_FUNC(1, Never)
+COMPARISON_FUNC(2, Less)
+COMPARISON_FUNC(3, Equal)
+COMPARISON_FUNC(4, LessEqual)
+COMPARISON_FUNC(5, Greater)
+COMPARISON_FUNC(6, NotEqual)
+COMPARISON_FUNC(7, GreaterEqual)
+COMPARISON_FUNC(8, Always)
-COMPARISON_FUNCTION( 1, Never)
-COMPARISON_FUNCTION( 2, Less)
-COMPARISON_FUNCTION( 3, Equal)
-COMPARISON_FUNCTION( 4, LessEqual)
-COMPARISON_FUNCTION( 5, Greater)
-COMPARISON_FUNCTION( 6, NotEqual)
-COMPARISON_FUNCTION( 7, GreaterEqual)
-COMPARISON_FUNCTION( 8, Always)
-#undef COMPARISON_FUNCTION
-#endif // COMPARISON_FUNCTION
+#undef COMPARISON_FUNC
+#endif // COMPARISON_FUNC
+// STATIC_BORDER_COLOR(value, enum).
#ifdef STATIC_BORDER_COLOR
-STATIC_BORDER_COLOR( 0, TransparentBlack)
-STATIC_BORDER_COLOR( 1, OpaqueBlack)
-STATIC_BORDER_COLOR( 2, OpaqueWhite)
-STATIC_BORDER_COLOR( 3, OpaqueBlackUint)
-STATIC_BORDER_COLOR( 4, OpaqueWhiteUint)
+
+STATIC_BORDER_COLOR(0, TransparentBlack)
+STATIC_BORDER_COLOR(1, OpaqueBlack)
+STATIC_BORDER_COLOR(2, OpaqueWhite)
+STATIC_BORDER_COLOR(3, OpaqueBlackUint)
+STATIC_BORDER_COLOR(4, OpaqueWhiteUint)
+
#undef STATIC_BORDER_COLOR
#endif // STATIC_BORDER_COLOR
diff --git a/llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h b/llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h
index 9dfbd3cb68928..3e959829a20bf 100644
--- a/llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h
+++ b/llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h
@@ -14,6 +14,7 @@
#ifndef LLVM_FRONTEND_HLSL_HLSLROOTSIGNATURE_H
#define LLVM_FRONTEND_HLSL_HLSLROOTSIGNATURE_H
+#include "llvm/BinaryFormat/DXContainer.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/DXILABI.h"
#include <limits>
@@ -23,126 +24,6 @@ namespace llvm {
namespace hlsl {
namespace rootsig {
-// Definition of the various enumerations and flags. The definitions of all
-// values here correspond to their description in the d3d12.h header and are
-// carried over from their values in DXC. For reference:
-// https://learn.microsoft.com/en-us/windows/win32/api/d3d12/
-
-enum class RootFlags : uint32_t {
- None = 0,
- AllowInputAssemblerInputLayout = 0x1,
- DenyVertexShaderRootAccess = 0x2,
- DenyHullShaderRootAccess = 0x4,
- DenyDomainShaderRootAccess = 0x8,
- DenyGeometryShaderRootAccess = 0x10,
- DenyPixelShaderRootAccess = 0x20,
- AllowStreamOutput = 0x40,
- LocalRootSignature = 0x80,
- DenyAmplificationShaderRootAccess = 0x100,
- DenyMeshShaderRootAccess = 0x200,
- CBVSRVUAVHeapDirectlyIndexed = 0x400,
- SamplerHeapDirectlyIndexed = 0x800,
- ValidFlags = 0x00000fff
-};
-
-enum class RootDescriptorFlags : unsigned {
- None = 0,
- DataVolatile = 0x2,
- DataStaticWhileSetAtExecute = 0x4,
- DataStatic = 0x8,
- ValidFlags = 0xe,
-};
-
-enum class DescriptorRangeFlags : unsigned {
- None = 0,
- DescriptorsVolatile = 0x1,
- DataVolatile = 0x2,
- DataStaticWhileSetAtExecute = 0x4,
- DataStatic = 0x8,
- DescriptorsStaticKeepingBufferBoundsChecks = 0x10000,
- ValidFlags = 0x1000f,
- ValidSamplerFlags = DescriptorsVolatile,
-};
-
-enum class ShaderVisibility {
- All = 0,
- Vertex = 1,
- Hull = 2,
- Domain = 3,
- Geometry = 4,
- Pixel = 5,
- Amplification = 6,
- Mesh = 7,
-};
-
-// D3D12_FILTER enumeration:
-// https://learn.microsoft.com/en-us/windows/win32/api/d3d12/ne-d3d12-d3d12_filter
-enum class SamplerFilter {
- MinMagMipPoint = 0,
- MinMagPointMipLinear = 0x1,
- MinPointMagLinearMipPoint = 0x4,
- MinPointMagMipLinear = 0x5,
- MinLinearMagMipPoint = 0x10,
- MinLinearMagPointMipLinear = 0x11,
- MinMagLinearMipPoint = 0x14,
- MinMagMipLinear = 0x15,
- Anisotropic = 0x55,
- ComparisonMinMagMipPoint = 0x80,
- ComparisonMinMagPointMipLinear = 0x81,
- ComparisonMinPointMagLinearMipPoint = 0x84,
- ComparisonMinPointMagMipLinear = 0x85,
- ComparisonMinLinearMagMipPoint = 0x90,
- ComparisonMinLinearMagPointMipLinear = 0x91,
- ComparisonMinMagLinearMipPoint = 0x94,
- ComparisonMinMagMipLinear = 0x95,
- ComparisonAnisotropic = 0xd5,
- MinimumMinMagMipPoint = 0x100,
- MinimumMinMagPointMipLinear = 0x101,
- MinimumMinPointMagLinearMipPoint = 0x104,
- MinimumMinPointMagMipLinear = 0x105,
- MinimumMinLinearMagMipPoint = 0x110,
- MinimumMinLinearMagPointMipLinear = 0x111,
- MinimumMinMagLinearMipPoint = 0x114,
- MinimumMinMagMipLinear = 0x115,
- MinimumAnisotropic = 0x155,
- MaximumMinMagMipPoint = 0x180,
- MaximumMinMagPointMipLinear = 0x181,
- MaximumMinPointMagLinearMipPoint = 0x184,
- MaximumMinPointMagMipLinear = 0x185,
- MaximumMinLinearMagMipPoint = 0x190,
- MaximumMinLinearMagPointMipLinear = 0x191,
- MaximumMinMagLinearMipPoint = 0x194,
- MaximumMinMagMipLinear = 0x195,
- MaximumAnisotropic = 0x1d5
-};
-
-enum class TextureAddressMode {
- Wrap = 1,
- Mirror = 2,
- Clamp = 3,
- Border = 4,
- MirrorOnce = 5
-};
-
-enum class ComparisonFunc : unsigned {
- Never = 1,
- Less = 2,
- Equal = 3,
- LessEqual = 4,
- Greater = 5,
- NotEqual = 6,
- GreaterEqual = 7,
- Always = 8
-};
-
-enum class StaticBorderColor {
- TransparentBlack = 0,
- OpaqueBlack = 1,
- OpaqueWhite = 2,
- OpaqueBlackUint = 3,
- OpaqueWhiteUint = 4
-};
-
// Definitions of the in-memory data layout structures
// Models the
diff erent registers: bReg | tReg | uReg | sReg
@@ -157,7 +38,7 @@ struct RootConstants {
uint32_t Num32BitConstants;
Register Reg;
uint32_t Space = 0;
- ShaderVisibility Visibility = ShaderVisibility::All;
+ dxbc::ShaderVisibility Visibility = dxbc::ShaderVisibility::All;
};
enum class DescriptorType : uint8_t { SRV = 0, UAV, CBuffer };
@@ -166,17 +47,17 @@ struct RootDescriptor {
DescriptorType Type;
Register Reg;
uint32_t Space = 0;
- ShaderVisibility Visibility = ShaderVisibility::All;
- RootDescriptorFlags Flags;
+ dxbc::ShaderVisibility Visibility = dxbc::ShaderVisibility::All;
+ dxbc::RootDescriptorFlags Flags;
void setDefaultFlags() {
switch (Type) {
case DescriptorType::CBuffer:
case DescriptorType::SRV:
- Flags = RootDescriptorFlags::DataStaticWhileSetAtExecute;
+ Flags = dxbc::RootDescriptorFlags::DataStaticWhileSetAtExecute;
break;
case DescriptorType::UAV:
- Flags = RootDescriptorFlags::DataVolatile;
+ Flags = dxbc::RootDescriptorFlags::DataVolatile;
break;
}
}
@@ -184,7 +65,7 @@ struct RootDescriptor {
// Models the end of a descriptor table and stores its visibility
struct DescriptorTable {
- ShaderVisibility Visibility = ShaderVisibility::All;
+ dxbc::ShaderVisibility Visibility = dxbc::ShaderVisibility::All;
// Denotes that the previous NumClauses in the RootElement array
// are the clauses in the table.
uint32_t NumClauses = 0;
@@ -200,19 +81,19 @@ struct DescriptorTableClause {
uint32_t NumDescriptors = 1;
uint32_t Space = 0;
uint32_t Offset = DescriptorTableOffsetAppend;
- DescriptorRangeFlags Flags;
+ dxbc::DescriptorRangeFlags Flags;
void setDefaultFlags() {
switch (Type) {
case ClauseType::CBuffer:
case ClauseType::SRV:
- Flags = DescriptorRangeFlags::DataStaticWhileSetAtExecute;
+ Flags = dxbc::DescriptorRangeFlags::DataStaticWhileSetAtExecute;
break;
case ClauseType::UAV:
- Flags = DescriptorRangeFlags::DataVolatile;
+ Flags = dxbc::DescriptorRangeFlags::DataVolatile;
break;
case ClauseType::Sampler:
- Flags = DescriptorRangeFlags::None;
+ Flags = dxbc::DescriptorRangeFlags::None;
break;
}
}
@@ -220,18 +101,18 @@ struct DescriptorTableClause {
struct StaticSampler {
Register Reg;
- SamplerFilter Filter = SamplerFilter::Anisotropic;
- TextureAddressMode AddressU = TextureAddressMode::Wrap;
- TextureAddressMode AddressV = TextureAddressMode::Wrap;
- TextureAddressMode AddressW = TextureAddressMode::Wrap;
+ dxbc::SamplerFilter Filter = dxbc::SamplerFilter::Anisotropic;
+ dxbc::TextureAddressMode AddressU = dxbc::TextureAddressMode::Wrap;
+ dxbc::TextureAddressMode AddressV = dxbc::TextureAddressMode::Wrap;
+ dxbc::TextureAddressMode AddressW = dxbc::TextureAddressMode::Wrap;
float MipLODBias = 0.f;
uint32_t MaxAnisotropy = 16;
- ComparisonFunc CompFunc = ComparisonFunc::LessEqual;
- StaticBorderColor BorderColor = StaticBorderColor::OpaqueWhite;
+ dxbc::ComparisonFunc CompFunc = dxbc::ComparisonFunc::LessEqual;
+ dxbc::StaticBorderColor BorderColor = dxbc::StaticBorderColor::OpaqueWhite;
float MinLOD = 0.f;
float MaxLOD = std::numeric_limits<float>::max();
uint32_t Space = 0;
- ShaderVisibility Visibility = ShaderVisibility::All;
+ dxbc::ShaderVisibility Visibility = dxbc::ShaderVisibility::All;
};
/// Models RootElement : RootFlags | RootConstants | RootParam
@@ -251,8 +132,8 @@ struct StaticSampler {
/// RootElements in the array, and it holds a data member for the Visibility
/// parameter.
using RootElement =
- std::variant<RootFlags, RootConstants, RootDescriptor, DescriptorTable,
- DescriptorTableClause, StaticSampler>;
+ std::variant<dxbc::RootFlags, RootConstants, RootDescriptor,
+ DescriptorTable, DescriptorTableClause, StaticSampler>;
} // namespace rootsig
} // namespace hlsl
diff --git a/llvm/include/llvm/Frontend/HLSL/HLSLRootSignatureUtils.h b/llvm/include/llvm/Frontend/HLSL/HLSLRootSignatureUtils.h
index 43c8805ce06b6..ed6e5e5447a61 100644
--- a/llvm/include/llvm/Frontend/HLSL/HLSLRootSignatureUtils.h
+++ b/llvm/include/llvm/Frontend/HLSL/HLSLRootSignatureUtils.h
@@ -28,7 +28,7 @@ class Metadata;
namespace hlsl {
namespace rootsig {
-LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, const RootFlags &Flags);
+LLVM_ABI raw_ostream &operator<<(raw_ostream &OS, const dxbc::RootFlags &Flags);
LLVM_ABI raw_ostream &operator<<(raw_ostream &OS,
const RootConstants &Constants);
@@ -61,7 +61,7 @@ class MetadataBuilder {
private:
/// Define the various builders for the
diff erent metadata types
- MDNode *BuildRootFlags(const RootFlags &Flags);
+ MDNode *BuildRootFlags(const dxbc::RootFlags &Flags);
MDNode *BuildRootConstants(const RootConstants &Constants);
MDNode *BuildRootDescriptor(const RootDescriptor &Descriptor);
MDNode *BuildDescriptorTable(const DescriptorTable &Table);
@@ -83,7 +83,7 @@ struct RangeInfo {
// Information retained for diagnostics
llvm::dxil::ResourceClass Class;
uint32_t Space;
- ShaderVisibility Visibility;
+ dxbc::ShaderVisibility Visibility;
};
class ResourceRange {
diff --git a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h
index c235112dacf7c..7e0a4c6b07039 100644
--- a/llvm/include/llvm/ObjectYAML/DXContainerYAML.h
+++ b/llvm/include/llvm/ObjectYAML/DXContainerYAML.h
@@ -87,7 +87,7 @@ struct RootDescriptorYaml {
LLVM_ABI uint32_t getEncodedFlags() const;
-#define ROOT_DESCRIPTOR_FLAG(Num, Val) bool Val = false;
+#define ROOT_DESCRIPTOR_FLAG(Num, Enum, Flag) bool Enum = false;
#include "llvm/BinaryFormat/DXContainerConstants.def"
};
@@ -100,7 +100,7 @@ struct DescriptorRangeYaml {
LLVM_ABI uint32_t getEncodedFlags() const;
-#define DESCRIPTOR_RANGE_FLAG(Num, Val) bool Val = false;
+#define DESCRIPTOR_RANGE_FLAG(Num, Enum, Flag) bool Enum = false;
#include "llvm/BinaryFormat/DXContainerConstants.def"
};
@@ -165,16 +165,16 @@ struct RootParameterYamlDesc {
};
struct StaticSamplerYamlDesc {
- uint32_t Filter = llvm::to_underlying(dxbc::StaticSamplerFilter::ANISOTROPIC);
+ uint32_t Filter = llvm::to_underlying(dxbc::SamplerFilter::Anisotropic);
uint32_t AddressU = llvm::to_underlying(dxbc::TextureAddressMode::Wrap);
uint32_t AddressV = llvm::to_underlying(dxbc::TextureAddressMode::Wrap);
uint32_t AddressW = llvm::to_underlying(dxbc::TextureAddressMode::Wrap);
float MipLODBias = 0.f;
uint32_t MaxAnisotropy = 16u;
uint32_t ComparisonFunc =
- llvm::to_underlying(dxbc::SamplersComparisonFunction::LessEqual);
+ llvm::to_underlying(dxbc::ComparisonFunc::LessEqual);
uint32_t BorderColor =
- llvm::to_underlying(dxbc::SamplersBorderColor::OpaqueWhite);
+ llvm::to_underlying(dxbc::StaticBorderColor::OpaqueWhite);
float MinLOD = 0.f;
float MaxLOD = std::numeric_limits<float>::max();
uint32_t ShaderRegister;
@@ -203,7 +203,7 @@ struct RootSignatureYamlDesc {
LLVM_ABI static llvm::Expected<DXContainerYAML::RootSignatureYamlDesc>
create(const object::DirectX::RootSignature &Data);
-#define ROOT_ELEMENT_FLAG(Num, Val) bool Val = false;
+#define ROOT_SIGNATURE_FLAG(Num, Val) bool Val = false;
#include "llvm/BinaryFormat/DXContainerConstants.def"
};
diff --git a/llvm/lib/BinaryFormat/DXContainer.cpp b/llvm/lib/BinaryFormat/DXContainer.cpp
index 8e7b7d313706a..36d10d0b63078 100644
--- a/llvm/lib/BinaryFormat/DXContainer.cpp
+++ b/llvm/lib/BinaryFormat/DXContainer.cpp
@@ -60,6 +60,35 @@ ArrayRef<EnumEntry<SigComponentType>> dxbc::getSigComponentTypes() {
return ArrayRef(SigComponentTypes);
}
+static const EnumEntry<RootFlags> RootFlagNames[] = {
+#define ROOT_SIGNATURE_FLAG(Val, Enum) {#Enum, RootFlags::Enum},
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<RootFlags>> dxbc::getRootFlags() {
+ return ArrayRef(RootFlagNames);
+}
+
+static const EnumEntry<RootDescriptorFlags> RootDescriptorFlagNames[] = {
+#define ROOT_DESCRIPTOR_FLAG(Val, Enum, Flag) \
+ {#Enum, RootDescriptorFlags::Enum},
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<RootDescriptorFlags>> dxbc::getRootDescriptorFlags() {
+ return ArrayRef(RootDescriptorFlagNames);
+}
+
+static const EnumEntry<DescriptorRangeFlags> DescriptorRangeFlagNames[] = {
+#define DESCRIPTOR_RANGE_FLAG(Val, Enum, Flag) \
+ {#Enum, DescriptorRangeFlags::Enum},
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<DescriptorRangeFlags>> dxbc::getDescriptorRangeFlags() {
+ return ArrayRef(DescriptorRangeFlagNames);
+}
+
#define SHADER_VISIBILITY(Val, Enum) {#Enum, ShaderVisibility::Enum},
static const EnumEntry<ShaderVisibility> ShaderVisibilityValues[] = {
@@ -70,6 +99,46 @@ ArrayRef<EnumEntry<ShaderVisibility>> dxbc::getShaderVisibility() {
return ArrayRef(ShaderVisibilityValues);
}
+#define FILTER(Val, Enum) {#Enum, SamplerFilter::Enum},
+
+static const EnumEntry<SamplerFilter> SamplerFilterNames[] = {
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<SamplerFilter>> dxbc::getSamplerFilters() {
+ return ArrayRef(SamplerFilterNames);
+}
+
+#define TEXTURE_ADDRESS_MODE(Val, Enum) {#Enum, TextureAddressMode::Enum},
+
+static const EnumEntry<TextureAddressMode> TextureAddressModeNames[] = {
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<TextureAddressMode>> dxbc::getTextureAddressModes() {
+ return ArrayRef(TextureAddressModeNames);
+}
+
+#define COMPARISON_FUNC(Val, Enum) {#Enum, ComparisonFunc::Enum},
+
+static const EnumEntry<ComparisonFunc> ComparisonFuncNames[] = {
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<ComparisonFunc>> dxbc::getComparisonFuncs() {
+ return ArrayRef(ComparisonFuncNames);
+}
+
+#define STATIC_BORDER_COLOR(Val, Enum) {#Enum, StaticBorderColor::Enum},
+
+static const EnumEntry<StaticBorderColor> StaticBorderColorValues[] = {
+#include "llvm/BinaryFormat/DXContainerConstants.def"
+};
+
+ArrayRef<EnumEntry<StaticBorderColor>> dxbc::getStaticBorderColors() {
+ return ArrayRef(StaticBorderColorValues);
+}
+
#define ROOT_PARAMETER(Val, Enum) {#Enum, RootParameterType::Enum},
static const EnumEntry<RootParameterType> RootParameterTypes[] = {
diff --git a/llvm/lib/Frontend/HLSL/CMakeLists.txt b/llvm/lib/Frontend/HLSL/CMakeLists.txt
index dfebe354807bf..8928144730477 100644
--- a/llvm/lib/Frontend/HLSL/CMakeLists.txt
+++ b/llvm/lib/Frontend/HLSL/CMakeLists.txt
@@ -11,6 +11,7 @@ add_llvm_component_library(LLVMFrontendHLSL
intrinsics_gen
LINK_COMPONENTS
+ BinaryFormat
Core
Support
)
diff --git a/llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp b/llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp
index 22a761ba3b135..67f512008b069 100644
--- a/llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp
+++ b/llvm/lib/Frontend/HLSL/HLSLRootSignatureUtils.cpp
@@ -80,123 +80,37 @@ static raw_ostream &operator<<(raw_ostream &OS, const Register &Reg) {
return OS;
}
-static const EnumEntry<ShaderVisibility> VisibilityNames[] = {
- {"All", ShaderVisibility::All},
- {"Vertex", ShaderVisibility::Vertex},
- {"Hull", ShaderVisibility::Hull},
- {"Domain", ShaderVisibility::Domain},
- {"Geometry", ShaderVisibility::Geometry},
- {"Pixel", ShaderVisibility::Pixel},
- {"Amplification", ShaderVisibility::Amplification},
- {"Mesh", ShaderVisibility::Mesh},
-};
-
static raw_ostream &operator<<(raw_ostream &OS,
- const ShaderVisibility &Visibility) {
- printEnum(OS, Visibility, ArrayRef(VisibilityNames));
+ const llvm::dxbc::ShaderVisibility &Visibility) {
+ printEnum(OS, Visibility, dxbc::getShaderVisibility());
return OS;
}
-static const EnumEntry<SamplerFilter> 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));
+static raw_ostream &operator<<(raw_ostream &OS,
+ const llvm::dxbc::SamplerFilter &Filter) {
+ printEnum(OS, Filter, dxbc::getSamplerFilters());
return OS;
}
-static const EnumEntry<TextureAddressMode> 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));
+ const dxbc::TextureAddressMode &Address) {
+ printEnum(OS, Address, dxbc::getTextureAddressModes());
return OS;
}
-static const EnumEntry<ComparisonFunc> 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));
+ const dxbc::ComparisonFunc &CompFunc) {
+ printEnum(OS, CompFunc, dxbc::getComparisonFuncs());
return OS;
}
-static const EnumEntry<StaticBorderColor> 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));
+ const dxbc::StaticBorderColor &BorderColor) {
+ printEnum(OS, BorderColor, dxbc::getStaticBorderColors());
return OS;
}
@@ -215,57 +129,23 @@ static raw_ostream &operator<<(raw_ostream &OS, const ClauseType &Type) {
return OS;
}
-static const EnumEntry<RootDescriptorFlags> 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));
+ const dxbc::RootDescriptorFlags &Flags) {
+ printFlags(OS, Flags, dxbc::getRootDescriptorFlags());
return OS;
}
-static const EnumEntry<DescriptorRangeFlags> DescriptorRangeFlagNames[] = {
- {"DescriptorsVolatile", DescriptorRangeFlags::DescriptorsVolatile},
- {"DataVolatile", DescriptorRangeFlags::DataVolatile},
- {"DataStaticWhileSetAtExecute",
- DescriptorRangeFlags::DataStaticWhileSetAtExecute},
- {"DataStatic", DescriptorRangeFlags::DataStatic},
- {"DescriptorsStaticKeepingBufferBoundsChecks",
- DescriptorRangeFlags::DescriptorsStaticKeepingBufferBoundsChecks},
-};
-
static raw_ostream &operator<<(raw_ostream &OS,
- const DescriptorRangeFlags &Flags) {
- printFlags(OS, Flags, ArrayRef(DescriptorRangeFlagNames));
+ const llvm::dxbc::DescriptorRangeFlags &Flags) {
+ printFlags(OS, Flags, dxbc::getDescriptorRangeFlags());
return OS;
}
-static const EnumEntry<RootFlags> RootFlagNames[] = {
- {"AllowInputAssemblerInputLayout",
- RootFlags::AllowInputAssemblerInputLayout},
- {"DenyVertexShaderRootAccess", RootFlags::DenyVertexShaderRootAccess},
- {"DenyHullShaderRootAccess", RootFlags::DenyHullShaderRootAccess},
- {"DenyDomainShaderRootAccess", RootFlags::DenyDomainShaderRootAccess},
- {"DenyGeometryShaderRootAccess", RootFlags::DenyGeometryShaderRootAccess},
- {"DenyPixelShaderRootAccess", RootFlags::DenyPixelShaderRootAccess},
- {"AllowStreamOutput", RootFlags::AllowStreamOutput},
- {"LocalRootSignature", RootFlags::LocalRootSignature},
- {"DenyAmplificationShaderRootAccess",
- RootFlags::DenyAmplificationShaderRootAccess},
- {"DenyMeshShaderRootAccess", RootFlags::DenyMeshShaderRootAccess},
- {"CBVSRVUAVHeapDirectlyIndexed", RootFlags::CBVSRVUAVHeapDirectlyIndexed},
- {"SamplerHeapDirectlyIndexed", RootFlags::SamplerHeapDirectlyIndexed},
-};
-
-raw_ostream &operator<<(raw_ostream &OS, const RootFlags &Flags) {
+raw_ostream &operator<<(raw_ostream &OS, const dxbc::RootFlags &Flags) {
OS << "RootFlags(";
- printFlags(OS, Flags, ArrayRef(RootFlagNames));
+ printFlags(OS, Flags, dxbc::getRootFlags());
OS << ")";
return OS;
@@ -341,7 +221,7 @@ template <class... Ts> OverloadedVisit(Ts...) -> OverloadedVisit<Ts...>;
raw_ostream &operator<<(raw_ostream &OS, const RootElement &Element) {
const auto Visitor = OverloadedVisit{
- [&OS](const RootFlags &Flags) { OS << Flags; },
+ [&OS](const dxbc::RootFlags &Flags) { OS << Flags; },
[&OS](const RootConstants &Constants) { OS << Constants; },
[&OS](const RootDescriptor &Descriptor) { OS << Descriptor; },
[&OS](const DescriptorTableClause &Clause) { OS << Clause; },
@@ -366,7 +246,7 @@ void dumpRootElements(raw_ostream &OS, ArrayRef<RootElement> Elements) {
MDNode *MetadataBuilder::BuildRootSignature() {
const auto Visitor = OverloadedVisit{
- [this](const RootFlags &Flags) -> MDNode * {
+ [this](const dxbc::RootFlags &Flags) -> MDNode * {
return BuildRootFlags(Flags);
},
[this](const RootConstants &Constants) -> MDNode * {
@@ -396,7 +276,7 @@ MDNode *MetadataBuilder::BuildRootSignature() {
return MDNode::get(Ctx, GeneratedMetadata);
}
-MDNode *MetadataBuilder::BuildRootFlags(const RootFlags &Flags) {
+MDNode *MetadataBuilder::BuildRootFlags(const dxbc::RootFlags &Flags) {
IRBuilder<> Builder(Ctx);
Metadata *Operands[] = {
MDString::get(Ctx, "RootFlags"),
diff --git a/llvm/lib/ObjectYAML/DXContainerYAML.cpp b/llvm/lib/ObjectYAML/DXContainerYAML.cpp
index f6d0e5227e64a..263f7bdf37bca 100644
--- a/llvm/lib/ObjectYAML/DXContainerYAML.cpp
+++ b/llvm/lib/ObjectYAML/DXContainerYAML.cpp
@@ -63,9 +63,9 @@ readDescriptorRanges(DXContainerYAML::RootParameterHeaderYaml &Header,
NewR.RangeType = R.RangeType;
if constexpr (std::is_same_v<T, dxbc::RTS0::v2::DescriptorRange>) {
// Set all flag fields for v2
-#define DESCRIPTOR_RANGE_FLAG(Num, Val) \
- NewR.Val = \
- (R.Flags & llvm::to_underlying(dxbc::DescriptorRangeFlag::Val)) != 0;
+#define DESCRIPTOR_RANGE_FLAG(Num, Enum, Flag) \
+ NewR.Enum = \
+ (R.Flags & llvm::to_underlying(dxbc::DescriptorRangeFlags::Enum)) != 0;
#include "llvm/BinaryFormat/DXContainerConstants.def"
}
TableYaml.Ranges.push_back(NewR);
@@ -140,10 +140,10 @@ DXContainerYAML::RootSignatureYamlDesc::create(
YamlDescriptor.ShaderRegister = Descriptor.ShaderRegister;
YamlDescriptor.RegisterSpace = Descriptor.RegisterSpace;
if (Version > 1) {
-#define ROOT_DESCRIPTOR_FLAG(Num, Val) \
- YamlDescriptor.Val = \
+#define ROOT_DESCRIPTOR_FLAG(Num, Enum, Flag) \
+ YamlDescriptor.Enum = \
(Descriptor.Flags & \
- llvm::to_underlying(dxbc::RootDescriptorFlag::Val)) > 0;
+ llvm::to_underlying(dxbc::RootDescriptorFlags::Enum)) > 0;
#include "llvm/BinaryFormat/DXContainerConstants.def"
}
} else if (auto *DTV =
@@ -180,38 +180,37 @@ DXContainerYAML::RootSignatureYamlDesc::create(
RootSigDesc.StaticSamplers.push_back(NewS);
}
-#define ROOT_ELEMENT_FLAG(Num, Val) \
- RootSigDesc.Val = \
- (Flags & llvm::to_underlying(dxbc::RootElementFlag::Val)) > 0;
+#define ROOT_SIGNATURE_FLAG(Num, Val) \
+ RootSigDesc.Val = (Flags & llvm::to_underlying(dxbc::RootFlags::Val)) > 0;
#include "llvm/BinaryFormat/DXContainerConstants.def"
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;
+ uint64_t Flags = 0;
+#define ROOT_DESCRIPTOR_FLAG(Num, Enum, Flag) \
+ if (Enum) \
+ Flags |= (uint32_t)dxbc::RootDescriptorFlags::Enum;
#include "llvm/BinaryFormat/DXContainerConstants.def"
- return Flag;
+ return Flags;
}
uint32_t DXContainerYAML::RootSignatureYamlDesc::getEncodedFlags() {
uint64_t Flag = 0;
-#define ROOT_ELEMENT_FLAG(Num, Val) \
+#define ROOT_SIGNATURE_FLAG(Num, Val) \
if (Val) \
- Flag |= (uint32_t)dxbc::RootElementFlag::Val;
+ Flag |= (uint32_t)dxbc::RootFlags::Val;
#include "llvm/BinaryFormat/DXContainerConstants.def"
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;
+ uint64_t Flags = 0;
+#define DESCRIPTOR_RANGE_FLAG(Num, Enum, Flag) \
+ if (Enum) \
+ Flags |= (uint32_t)dxbc::DescriptorRangeFlags::Enum;
#include "llvm/BinaryFormat/DXContainerConstants.def"
- return Flag;
+ return Flags;
}
uint64_t DXContainerYAML::ShaderFeatureFlags::getEncodedFlags() {
@@ -382,7 +381,7 @@ void MappingTraits<DXContainerYAML::RootSignatureYamlDesc>::mapping(
IO.mapRequired("StaticSamplersOffset", S.StaticSamplersOffset);
IO.mapRequired("Parameters", S.Parameters.Locations, S);
IO.mapOptional("Samplers", S.StaticSamplers);
-#define ROOT_ELEMENT_FLAG(Num, Val) IO.mapOptional(#Val, S.Val, false);
+#define ROOT_SIGNATURE_FLAG(Num, Val) IO.mapOptional(#Val, S.Val, false);
#include "llvm/BinaryFormat/DXContainerConstants.def"
}
@@ -406,7 +405,8 @@ void MappingTraits<llvm::DXContainerYAML::DescriptorRangeYaml>::mapping(
IO.mapRequired("RegisterSpace", R.RegisterSpace);
IO.mapRequired("OffsetInDescriptorsFromTableStart",
R.OffsetInDescriptorsFromTableStart);
-#define DESCRIPTOR_RANGE_FLAG(Num, Val) IO.mapOptional(#Val, R.Val, false);
+#define DESCRIPTOR_RANGE_FLAG(Num, Enum, Flag) \
+ IO.mapOptional(#Flag, R.Enum, false);
#include "llvm/BinaryFormat/DXContainerConstants.def"
}
@@ -459,7 +459,8 @@ void MappingTraits<llvm::DXContainerYAML::RootDescriptorYaml>::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);
+#define ROOT_DESCRIPTOR_FLAG(Num, Enum, Flag) \
+ IO.mapOptional(#Flag, D.Enum, false);
#include "llvm/BinaryFormat/DXContainerConstants.def"
}
diff --git a/llvm/lib/Target/DirectX/DXILRootSignature.cpp b/llvm/lib/Target/DirectX/DXILRootSignature.cpp
index 2dccc0d5b2b3e..5e0975736f90d 100644
--- a/llvm/lib/Target/DirectX/DXILRootSignature.cpp
+++ b/llvm/lib/Target/DirectX/DXILRootSignature.cpp
@@ -431,7 +431,7 @@ static bool verifyRangeType(uint32_t Type) {
static bool verifyDescriptorRangeFlag(uint32_t Version, uint32_t Type,
uint32_t FlagsVal) {
- using FlagT = dxbc::DescriptorRangeFlag;
+ using FlagT = dxbc::DescriptorRangeFlags;
FlagT Flags = FlagT(FlagsVal);
const bool IsSampler =
@@ -441,61 +441,59 @@ static bool verifyDescriptorRangeFlag(uint32_t Version, uint32_t Type,
// Since the metadata is unversioned, we expect to explicitly see the values
// that map to the version 1 behaviour here.
if (IsSampler)
- return Flags == FlagT::DESCRIPTORS_VOLATILE;
- return Flags == (FlagT::DATA_VOLATILE | FlagT::DESCRIPTORS_VOLATILE);
+ return Flags == FlagT::DescriptorsVolatile;
+ return Flags == (FlagT::DataVolatile | FlagT::DescriptorsVolatile);
}
// The data-specific flags are mutually exclusive.
- FlagT DataFlags = FlagT::DATA_VOLATILE | FlagT::DATA_STATIC |
- FlagT::DATA_STATIC_WHILE_SET_AT_EXECUTE;
+ FlagT DataFlags = FlagT::DataVolatile | FlagT::DataStatic |
+ FlagT::DataStaticWhileSetAtExecute;
if (popcount(llvm::to_underlying(Flags & DataFlags)) > 1)
return false;
// The descriptor-specific flags are mutually exclusive.
- FlagT DescriptorFlags =
- FlagT::DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS |
- FlagT::DESCRIPTORS_VOLATILE;
+ FlagT DescriptorFlags = FlagT::DescriptorsStaticKeepingBufferBoundsChecks |
+ FlagT::DescriptorsVolatile;
if (popcount(llvm::to_underlying(Flags & DescriptorFlags)) > 1)
return false;
// For volatile descriptors, DATA_STATIC is never valid.
- if ((Flags & FlagT::DESCRIPTORS_VOLATILE) == FlagT::DESCRIPTORS_VOLATILE) {
- FlagT Mask = FlagT::DESCRIPTORS_VOLATILE;
+ if ((Flags & FlagT::DescriptorsVolatile) == FlagT::DescriptorsVolatile) {
+ FlagT Mask = FlagT::DescriptorsVolatile;
if (!IsSampler) {
- Mask |= FlagT::DATA_VOLATILE;
- Mask |= FlagT::DATA_STATIC_WHILE_SET_AT_EXECUTE;
+ Mask |= FlagT::DataVolatile;
+ Mask |= FlagT::DataStaticWhileSetAtExecute;
}
- return (Flags & ~Mask) == FlagT::NONE;
+ return (Flags & ~Mask) == FlagT::None;
}
// For "STATIC_KEEPING_BUFFER_BOUNDS_CHECKS" descriptors,
// the other data-specific flags may all be set.
- if ((Flags & FlagT::DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS) ==
- FlagT::DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS) {
- FlagT Mask = FlagT::DESCRIPTORS_STATIC_KEEPING_BUFFER_BOUNDS_CHECKS;
+ if ((Flags & FlagT::DescriptorsStaticKeepingBufferBoundsChecks) ==
+ FlagT::DescriptorsStaticKeepingBufferBoundsChecks) {
+ FlagT Mask = FlagT::DescriptorsStaticKeepingBufferBoundsChecks;
if (!IsSampler) {
- Mask |= FlagT::DATA_VOLATILE;
- Mask |= FlagT::DATA_STATIC;
- Mask |= FlagT::DATA_STATIC_WHILE_SET_AT_EXECUTE;
+ Mask |= FlagT::DataVolatile;
+ Mask |= FlagT::DataStatic;
+ Mask |= FlagT::DataStaticWhileSetAtExecute;
}
- return (Flags & ~Mask) == FlagT::NONE;
+ return (Flags & ~Mask) == FlagT::None;
}
// When no descriptor flag is set, any data flag is allowed.
- FlagT Mask = FlagT::NONE;
+ FlagT Mask = FlagT::None;
if (!IsSampler) {
- Mask |= FlagT::DATA_VOLATILE;
- Mask |= FlagT::DATA_STATIC;
- Mask |= FlagT::DATA_STATIC_WHILE_SET_AT_EXECUTE;
+ Mask |= FlagT::DataVolatile;
+ Mask |= FlagT::DataStaticWhileSetAtExecute;
+ Mask |= FlagT::DataStatic;
}
- return (Flags & ~Mask) == FlagT::NONE;
+ return (Flags & ~Mask) == FlagT::None;
}
static bool verifySamplerFilter(uint32_t Value) {
switch (Value) {
-#define STATIC_SAMPLER_FILTER(Num, Val) \
- case llvm::to_underlying(dxbc::StaticSamplerFilter::Val):
+#define FILTER(Num, Val) case llvm::to_underlying(dxbc::SamplerFilter::Val):
#include "llvm/BinaryFormat/DXContainerConstants.def"
return true;
}
@@ -524,8 +522,8 @@ static bool verifyMaxAnisotropy(uint32_t MaxAnisotropy) {
static bool verifyComparisonFunc(uint32_t ComparisonFunc) {
switch (ComparisonFunc) {
-#define COMPARISON_FUNCTION(Num, Val) \
- case llvm::to_underlying(dxbc::SamplersComparisonFunction::Val):
+#define COMPARISON_FUNC(Num, Val) \
+ case llvm::to_underlying(dxbc::ComparisonFunc::Val):
#include "llvm/BinaryFormat/DXContainerConstants.def"
return true;
}
@@ -535,7 +533,7 @@ static bool verifyComparisonFunc(uint32_t ComparisonFunc) {
static bool verifyBorderColor(uint32_t BorderColor) {
switch (BorderColor) {
#define STATIC_BORDER_COLOR(Num, Val) \
- case llvm::to_underlying(dxbc::SamplersBorderColor::Val):
+ case llvm::to_underlying(dxbc::StaticBorderColor::Val):
#include "llvm/BinaryFormat/DXContainerConstants.def"
return true;
}
diff --git a/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp b/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp
index dde82ac34ea28..ca2c296efc99b 100644
--- a/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp
+++ b/llvm/unittests/Frontend/HLSLRootSignatureDumpTest.cpp
@@ -37,7 +37,7 @@ TEST(HLSLRootSignatureTest, DescriptorSRVClauseDump) {
Clause.NumDescriptors = NumDescriptorsUnbounded;
Clause.Space = 42;
Clause.Offset = 3;
- Clause.Flags = DescriptorRangeFlags::None;
+ Clause.Flags = llvm::dxbc::DescriptorRangeFlags::None;
std::string Out;
llvm::raw_string_ostream OS(Out);
@@ -50,13 +50,20 @@ TEST(HLSLRootSignatureTest, DescriptorSRVClauseDump) {
}
TEST(HLSLRootSignatureTest, DescriptorUAVClauseDump) {
+ using llvm::dxbc::DescriptorRangeFlags;
DescriptorTableClause Clause;
Clause.Type = ClauseType::UAV;
Clause.Reg = {RegisterType::UReg, 92374};
Clause.NumDescriptors = 3298;
Clause.Space = 932847;
Clause.Offset = 1;
- Clause.Flags = DescriptorRangeFlags::ValidFlags;
+ auto ValidDescriptorRangeFlags =
+ DescriptorRangeFlags::DescriptorsVolatile |
+ DescriptorRangeFlags::DataVolatile |
+ DescriptorRangeFlags::DataStaticWhileSetAtExecute |
+ DescriptorRangeFlags::DataStatic |
+ DescriptorRangeFlags::DescriptorsStaticKeepingBufferBoundsChecks;
+ Clause.Flags = ValidDescriptorRangeFlags;
std::string Out;
llvm::raw_string_ostream OS(Out);
@@ -80,7 +87,7 @@ TEST(HLSLRootSignatureTest, DescriptorSamplerClauseDump) {
Clause.NumDescriptors = 2;
Clause.Space = 42;
Clause.Offset = DescriptorTableOffsetAppend;
- Clause.Flags = DescriptorRangeFlags::ValidSamplerFlags;
+ Clause.Flags = llvm::dxbc::DescriptorRangeFlags::DescriptorsVolatile;
std::string Out;
llvm::raw_string_ostream OS(Out);
@@ -96,7 +103,7 @@ TEST(HLSLRootSignatureTest, DescriptorSamplerClauseDump) {
TEST(HLSLRootSignatureTest, DescriptorTableDump) {
DescriptorTable Table;
Table.NumClauses = 4;
- Table.Visibility = ShaderVisibility::Geometry;
+ Table.Visibility = llvm::dxbc::ShaderVisibility::Geometry;
std::string Out;
llvm::raw_string_ostream OS(Out);
@@ -130,8 +137,8 @@ TEST(HLSLRootSignatureTest, RootSRVDump) {
Descriptor.Type = DescriptorType::SRV;
Descriptor.Reg = {RegisterType::TReg, 0};
Descriptor.Space = 42;
- Descriptor.Visibility = ShaderVisibility::Geometry;
- Descriptor.Flags = RootDescriptorFlags::None;
+ Descriptor.Visibility = llvm::dxbc::ShaderVisibility::Geometry;
+ Descriptor.Flags = llvm::dxbc::RootDescriptorFlags::None;
std::string Out;
llvm::raw_string_ostream OS(Out);
@@ -144,12 +151,17 @@ TEST(HLSLRootSignatureTest, RootSRVDump) {
}
TEST(HLSLRootSignatureTest, RootUAVDump) {
+ using llvm::dxbc::RootDescriptorFlags;
RootDescriptor Descriptor;
Descriptor.Type = DescriptorType::UAV;
Descriptor.Reg = {RegisterType::UReg, 92374};
Descriptor.Space = 932847;
- Descriptor.Visibility = ShaderVisibility::Hull;
- Descriptor.Flags = RootDescriptorFlags::ValidFlags;
+ 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);
@@ -194,18 +206,18 @@ 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.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 = ComparisonFunc::NotEqual;
- Sampler.BorderColor = StaticBorderColor::OpaqueBlack;
+ 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 = ShaderVisibility::Domain;
+ Sampler.Visibility = llvm::dxbc::ShaderVisibility::Domain;
std::string Out;
llvm::raw_string_ostream OS(Out);
@@ -249,7 +261,7 @@ TEST(HLSLRootSignatureTest, SetRootConstantsDump) {
Constants.Num32BitConstants = 983;
Constants.Reg = {RegisterType::BReg, 34593};
Constants.Space = 7;
- Constants.Visibility = ShaderVisibility::Pixel;
+ Constants.Visibility = llvm::dxbc::ShaderVisibility::Pixel;
std::string Out;
llvm::raw_string_ostream OS(Out);
@@ -262,7 +274,7 @@ TEST(HLSLRootSignatureTest, SetRootConstantsDump) {
}
TEST(HLSLRootSignatureTest, NoneRootFlagsDump) {
- RootFlags Flags = RootFlags::None;
+ llvm::dxbc::RootFlags Flags = llvm::dxbc::RootFlags::None;
std::string Out;
llvm::raw_string_ostream OS(Out);
@@ -274,11 +286,23 @@ TEST(HLSLRootSignatureTest, NoneRootFlagsDump) {
}
TEST(HLSLRootSignatureTest, AllRootFlagsDump) {
- RootFlags Flags = RootFlags::ValidFlags;
+ 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 << Flags;
+ OS << ValidRootFlags;
OS.flush();
std::string Expected = "RootFlags("
More information about the llvm-commits
mailing list