Skip to content

[HLSL][RootSignature] Add parsing of flags to RootDescriptor #140152

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
May 23, 2025
Merged

[HLSL][RootSignature] Add parsing of flags to RootDescriptor #140152

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
3daccf8
[HLSL][RootSignature] Add parsing of flags to RootParam
inbelic May 15, 2025
c3b4c86
review: update naming to RootDescriptor
inbelic May 21, 2025
710cc3e
self-review: touch-up
inbelic May 23, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
3 changes: 3 additions & 0 deletions clang/include/clang/Parse/ParseHLSLRootSignature.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -93,6 +93,7 @@ class RootSignatureParser {
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<ParsedRootDescriptorParams>
parseRootDescriptorParams(RootSignatureToken::Kind RegType);
Expand All @@ -113,6 +114,8 @@ class RootSignatureParser {

/// Parsing methods of various enums
std::optional<llvm::hlsl::rootsig::ShaderVisibility> parseShaderVisibility();
std::optional<llvm::hlsl::rootsig::RootDescriptorFlags>
parseRootDescriptorFlags();
std::optional<llvm::hlsl::rootsig::DescriptorRangeFlags>
parseDescriptorRangeFlags();

Expand Down
60 changes: 60 additions & 0 deletions clang/lib/Parse/ParseHLSLRootSignature.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -193,6 +193,7 @@ std::optional<RootDescriptor> RootSignatureParser::parseRootDescriptor() {
ExpectedReg = TokenKind::uReg;
break;
}
Descriptor.setDefaultFlags();

auto Params = parseRootDescriptorParams(ExpectedReg);
if (!Params.has_value())
Expand All @@ -214,6 +215,9 @@ std::optional<RootDescriptor> RootSignatureParser::parseRootDescriptor() {
if (Params->Visibility.has_value())
Descriptor.Visibility = Params->Visibility.value();

if (Params->Flags.has_value())
Descriptor.Flags = Params->Flags.value();

if (consumeExpectedToken(TokenKind::pu_r_paren,
diag::err_hlsl_unexpected_end_of_params,
/*param of=*/TokenKind::kw_RootConstants))
Expand Down Expand Up @@ -475,6 +479,23 @@ RootSignatureParser::parseRootDescriptorParams(TokenKind RegType) {
return std::nullopt;
Params.Visibility = Visibility;
}

// `flags` `=` ROOT_DESCRIPTOR_FLAGS
if (tryConsumeExpectedToken(TokenKind::kw_flags)) {
if (Params.Flags.has_value()) {
getDiags().Report(CurToken.TokLoc, diag::err_hlsl_rootsig_repeat_param)
<< CurToken.TokKind;
return std::nullopt;
}

if (consumeExpectedToken(TokenKind::pu_equal))
return std::nullopt;

auto Flags = parseRootDescriptorFlags();
if (!Flags.has_value())
return std::nullopt;
Params.Flags = Flags;
}
} while (tryConsumeExpectedToken(TokenKind::pu_comma));

return Params;
Expand Down Expand Up @@ -654,6 +675,45 @@ RootSignatureParser::parseShaderVisibility() {
return std::nullopt;
}

std::optional<llvm::hlsl::rootsig::RootDescriptorFlags>
RootSignatureParser::parseRootDescriptorFlags() {
assert(CurToken.TokKind == TokenKind::pu_equal &&
"Expects to only be invoked starting at given keyword");

// Handle the edge-case of '0' to specify no flags set
if (tryConsumeExpectedToken(TokenKind::int_literal)) {
if (!verifyZeroFlag()) {
getDiags().Report(CurToken.TokLoc, diag::err_hlsl_rootsig_non_zero_flag);
return std::nullopt;
}
return RootDescriptorFlags::None;
}

TokenKind Expected[] = {
#define ROOT_DESCRIPTOR_FLAG_ENUM(NAME, LIT) TokenKind::en_##NAME,
#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
};

std::optional<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); \
break;
#include "clang/Lex/HLSLRootSignatureTokenKinds.def"
default:
llvm_unreachable("Switch for consumed enum token was not provided");
}
}
} while (tryConsumeExpectedToken(TokenKind::pu_or));

return Flags;
}

std::optional<llvm::hlsl::rootsig::DescriptorRangeFlags>
RootSignatureParser::parseDescriptorRangeFlags() {
assert(CurToken.TokKind == TokenKind::pu_equal &&
Expand Down
25 changes: 22 additions & 3 deletions clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -347,8 +347,11 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootFlagsTest) {
TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) {
const llvm::StringLiteral Source = R"cc(
CBV(b0),
SRV(space = 4, t42, visibility = SHADER_VISIBILITY_GEOMETRY),
UAV(visibility = SHADER_VISIBILITY_HULL, u34893247)
SRV(space = 4, t42, visibility = SHADER_VISIBILITY_GEOMETRY,
flags = DATA_VOLATILE | DATA_STATIC | DATA_STATIC_WHILE_SET_AT_EXECUTE
),
UAV(visibility = SHADER_VISIBILITY_HULL, u34893247),
CBV(b0, flags = 0),
)cc";

TrivialModuleLoader ModLoader;
Expand All @@ -364,7 +367,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) {

ASSERT_FALSE(Parser.parse());

ASSERT_EQ(Elements.size(), 3u);
ASSERT_EQ(Elements.size(), 4u);

RootElement Elem = Elements[0];
ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem));
Expand All @@ -373,6 +376,8 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) {
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).Flags,
RootDescriptorFlags::DataStaticWhileSetAtExecute);

Elem = Elements[1];
ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem));
Expand All @@ -382,6 +387,8 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) {
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);

Elem = Elements[2];
ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem));
Expand All @@ -390,6 +397,18 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) {
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).Flags,
RootDescriptorFlags::DataVolatile);
ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags,
RootDescriptorFlags::DataVolatile);

Elem = Elements[3];
ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, DescriptorType::CBuffer);
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).Flags, RootDescriptorFlags::None);

ASSERT_TRUE(Consumer->isSatisfied());
}
Expand Down
23 changes: 22 additions & 1 deletion llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -46,6 +46,14 @@ enum class RootFlags : uint32_t {
ValidFlags = 0x00000fff
};

enum class RootDescriptorFlags : unsigned {
None = 0,
DataVolatile = 0x2,
DataStaticWhileSetAtExecute = 0x4,
DataStatic = 0x8,
ValidFlags = 0xe,
};

enum class DescriptorRangeFlags : unsigned {
None = 0,
DescriptorsVolatile = 0x1,
Expand Down Expand Up @@ -85,13 +93,26 @@ struct RootConstants {
ShaderVisibility Visibility = ShaderVisibility::All;
};

using DescriptorType = llvm::dxil::ResourceClass;
enum class DescriptorType : uint8_t { SRV = 0, UAV, CBuffer };
// Models RootDescriptor : CBV | SRV | UAV, by collecting like parameters
struct RootDescriptor {
DescriptorType Type;
Register Reg;
uint32_t Space = 0;
ShaderVisibility Visibility = ShaderVisibility::All;
RootDescriptorFlags Flags;

void setDefaultFlags() {
switch (Type) {
case DescriptorType::CBuffer:
case DescriptorType::SRV:
Flags = RootDescriptorFlags::DataStaticWhileSetAtExecute;
break;
case DescriptorType::UAV:
Flags = RootDescriptorFlags::DataVolatile;
break;
}
}
};

// Models the end of a descriptor table and stores its visibility
Expand Down
Loading