[HLSL][RootSignature] Add parsing for empty RootConstants

clang/include/clang/Lex/HLSLRootSignatureTokenKinds.def

@@ -74,6 +74,10 @@ PUNCTUATOR(minus,   '-')
 // RootElement Keywords:
 KEYWORD(RootSignature) // used only for diagnostic messaging
 KEYWORD(DescriptorTable)
+KEYWORD(RootConstants)
+
+// RootConstants Keywords:
+KEYWORD(num32BitConstants)
 
 // DescriptorTable Keywords:
 KEYWORD(CBV)

clang/include/clang/Parse/ParseHLSLRootSignature.h

@@ -71,6 +71,7 @@ class RootSignatureParser {
   // expected, or, there is a lexing error
 
   /// Root Element parse methods:
+  std::optional<llvm::hlsl::rootsig::RootConstants> parseRootConstants();
   std::optional<llvm::hlsl::rootsig::DescriptorTable> parseDescriptorTable();
   std::optional<llvm::hlsl::rootsig::DescriptorTableClause>
   parseDescriptorTableClause();

clang/lib/Parse/ParseHLSLRootSignature.cpp

@@ -27,6 +27,13 @@ RootSignatureParser::RootSignatureParser(SmallVector<RootElement> &Elements,
 bool RootSignatureParser::parse() {
   // Iterate as many RootElements as possible
   do {
+    if (tryConsumeExpectedToken(TokenKind::kw_RootConstants)) {
+      auto Constants = parseRootConstants();
+      if (!Constants.has_value())
+        return true;
+      Elements.push_back(*Constants);
+    }
+
     if (tryConsumeExpectedToken(TokenKind::kw_DescriptorTable)) {
       auto Table = parseDescriptorTable();
       if (!Table.has_value())
@@ -35,12 +42,27 @@ bool RootSignatureParser::parse() {
     }
   } while (tryConsumeExpectedToken(TokenKind::pu_comma));
 
-  if (consumeExpectedToken(TokenKind::end_of_stream,
+  return consumeExpectedToken(TokenKind::end_of_stream,
+                              diag::err_hlsl_unexpected_end_of_params,
+                              /*param of=*/TokenKind::kw_RootSignature);
+}
+
+std::optional<RootConstants> RootSignatureParser::parseRootConstants() {
+  assert(CurToken.TokKind == TokenKind::kw_RootConstants &&
+         "Expects to only be invoked starting at given keyword");
+
+  if (consumeExpectedToken(TokenKind::pu_l_paren, diag::err_expected_after,
+                           CurToken.TokKind))
+    return std::nullopt;
+
+  RootConstants Constants;
+
+  if (consumeExpectedToken(TokenKind::pu_r_paren,
                            diag::err_hlsl_unexpected_end_of_params,
-                           /*param of=*/TokenKind::kw_RootSignature))
-    return true;
+                           /*param of=*/TokenKind::kw_RootConstants))
+    return std::nullopt;
 
-  return false;
+  return Constants;
 }
 
 std::optional<DescriptorTable> RootSignatureParser::parseDescriptorTable() {

clang/unittests/Lex/LexHLSLRootSignatureTest.cpp

@@ -87,7 +87,9 @@ TEST_F(LexHLSLRootSignatureTest, ValidLexAllTokensTest) {
 
     RootSignature
 
-    DescriptorTable
+    DescriptorTable RootConstants
+
+    num32BitConstants
 
     CBV SRV UAV Sampler
     space visibility flags

clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp

@@ -252,6 +252,32 @@ TEST_F(ParseHLSLRootSignatureTest, ValidSamplerFlagsTest) {
   ASSERT_TRUE(Consumer->isSatisfied());
 }
 
+TEST_F(ParseHLSLRootSignatureTest, ValidParseRootConsantsTest) {
+  const llvm::StringLiteral Source = R"cc(
+    RootConstants()
+  )cc";
+
+  TrivialModuleLoader ModLoader;
+  auto PP = createPP(Source, ModLoader);
+  auto TokLoc = SourceLocation();
+
+  hlsl::RootSignatureLexer Lexer(Source, TokLoc);
+  SmallVector<RootElement> Elements;
+  hlsl::RootSignatureParser Parser(Elements, Lexer, *PP);
+
+  // Test no diagnostics produced
+  Consumer->setNoDiag();
+
+  ASSERT_FALSE(Parser.parse());
+
+  ASSERT_EQ(Elements.size(), 1u);
+
+  RootElement Elem = Elements[0];
+  ASSERT_TRUE(std::holds_alternative<RootConstants>(Elem));
+
+  ASSERT_TRUE(Consumer->isSatisfied());
+}
+
 TEST_F(ParseHLSLRootSignatureTest, ValidTrailingCommaTest) {
   // This test will checks we can handling trailing commas ','
   const llvm::StringLiteral Source = R"cc(

llvm/include/llvm/Frontend/HLSL/HLSLRootSignature.h

@@ -54,6 +54,9 @@ struct Register {
   uint32_t Number;
 };
 
+// Models the parameter values of root constants
+struct RootConstants {};
+
 // Models the end of a descriptor table and stores its visibility
 struct DescriptorTable {
   ShaderVisibility Visibility = ShaderVisibility::All;
@@ -88,8 +91,9 @@ struct DescriptorTableClause {
   }
 };
 
-// Models RootElement : DescriptorTable | DescriptorTableClause
-using RootElement = std::variant<DescriptorTable, DescriptorTableClause>;
+// Models RootElement : RootConstants | DescriptorTable | DescriptorTableClause
+using RootElement =
+    std::variant<RootConstants, DescriptorTable, DescriptorTableClause>;
 
 } // namespace rootsig
 } // namespace hlsl