From 4a5cde3f77dc0c371d1f33b10be9507d3aeff3e3 Mon Sep 17 00:00:00 2001 From: Finn Plummer Date: Fri, 27 Jun 2025 18:36:38 +0000 Subject: [PATCH 1/8] nfc: introduce wrapper `RootSignatureElement` around `RootElement` to retain clang diag info --- .../clang/Parse/ParseHLSLRootSignature.h | 17 ++- clang/include/clang/Sema/SemaHLSL.h | 10 +- clang/lib/Parse/ParseDeclCXX.cpp | 2 +- clang/lib/Parse/ParseHLSLRootSignature.cpp | 21 ++-- clang/lib/Sema/SemaHLSL.cpp | 6 +- .../Parse/ParseHLSLRootSignatureTest.cpp | 115 +++++++++--------- 6 files changed, 99 insertions(+), 72 deletions(-) diff --git a/clang/include/clang/Parse/ParseHLSLRootSignature.h b/clang/include/clang/Parse/ParseHLSLRootSignature.h index b0ef617a13c28..53001d2ba461f 100644 --- a/clang/include/clang/Parse/ParseHLSLRootSignature.h +++ b/clang/include/clang/Parse/ParseHLSLRootSignature.h @@ -26,10 +26,22 @@ namespace clang { namespace hlsl { +// Introduce a wrapper struct around the underlying RootElement. This structure +// will retain extra clang diagnostic information that is not available in llvm. +struct RootSignatureElement { + RootSignatureElement(llvm::hlsl::rootsig::RootElement Element) + : Element(Element) {} + + const llvm::hlsl::rootsig::RootElement &getElement() const { return Element; } + +private: + llvm::hlsl::rootsig::RootElement Element; +}; + class RootSignatureParser { public: RootSignatureParser(llvm::dxbc::RootSignatureVersion Version, - SmallVector &Elements, + SmallVector &Elements, StringLiteral *Signature, Preprocessor &PP); /// Consumes tokens from the Lexer and constructs the in-memory @@ -196,7 +208,8 @@ class RootSignatureParser { private: llvm::dxbc::RootSignatureVersion Version; - SmallVector &Elements; + SmallVector &Elements; + clang::StringLiteral *Signature; RootSignatureLexer Lexer; clang::Preprocessor &PP; diff --git a/clang/include/clang/Sema/SemaHLSL.h b/clang/include/clang/Sema/SemaHLSL.h index 7d7eae4db532c..1af706da702c2 100644 --- a/clang/include/clang/Sema/SemaHLSL.h +++ b/clang/include/clang/Sema/SemaHLSL.h @@ -32,6 +32,10 @@ class ParsedAttr; class Scope; class VarDecl; +namespace hlsl { +struct RootSignatureElement; +} + using llvm::dxil::ResourceClass; // FIXME: This can be hidden (as static function in SemaHLSL.cpp) once we no @@ -130,9 +134,9 @@ class SemaHLSL : public SemaBase { /// Creates the Root Signature decl of the parsed Root Signature elements /// onto the AST and push it onto current Scope - void ActOnFinishRootSignatureDecl( - SourceLocation Loc, IdentifierInfo *DeclIdent, - SmallVector &Elements); + void + ActOnFinishRootSignatureDecl(SourceLocation Loc, IdentifierInfo *DeclIdent, + ArrayRef Elements); // Returns true when D is invalid and a diagnostic was produced bool handleRootSignatureDecl(HLSLRootSignatureDecl *D, SourceLocation Loc); diff --git a/clang/lib/Parse/ParseDeclCXX.cpp b/clang/lib/Parse/ParseDeclCXX.cpp index d3bc6f1e89832..d06bb6a25efa5 100644 --- a/clang/lib/Parse/ParseDeclCXX.cpp +++ b/clang/lib/Parse/ParseDeclCXX.cpp @@ -4951,7 +4951,7 @@ void Parser::ParseHLSLRootSignatureAttributeArgs(ParsedAttributes &Attrs) { // signature string and construct the in-memory elements if (!Found) { // Invoke the root signature parser to construct the in-memory constructs - SmallVector RootElements; + SmallVector RootElements; hlsl::RootSignatureParser Parser(getLangOpts().HLSLRootSigVer, RootElements, Signature, PP); if (Parser.parse()) { diff --git a/clang/lib/Parse/ParseHLSLRootSignature.cpp b/clang/lib/Parse/ParseHLSLRootSignature.cpp index ebaf7ba60fa17..76e50fb85c8d7 100644 --- a/clang/lib/Parse/ParseHLSLRootSignature.cpp +++ b/clang/lib/Parse/ParseHLSLRootSignature.cpp @@ -19,33 +19,34 @@ using TokenKind = RootSignatureToken::Kind; RootSignatureParser::RootSignatureParser( llvm::dxbc::RootSignatureVersion Version, - SmallVector &Elements, StringLiteral *Signature, + SmallVector &Elements, StringLiteral *Signature, Preprocessor &PP) : Version(Version), Elements(Elements), Signature(Signature), Lexer(Signature->getString()), PP(PP), CurToken(0) {} bool RootSignatureParser::parse() { - // Iterate as many RootElements as possible + // Iterate as many RootSignatureElements as possible do { + std::optional Element = std::nullopt; if (tryConsumeExpectedToken(TokenKind::kw_RootFlags)) { auto Flags = parseRootFlags(); if (!Flags.has_value()) return true; - Elements.push_back(*Flags); + Element = RootSignatureElement(*Flags); } if (tryConsumeExpectedToken(TokenKind::kw_RootConstants)) { auto Constants = parseRootConstants(); if (!Constants.has_value()) return true; - Elements.push_back(*Constants); + Element = RootSignatureElement(*Constants); } if (tryConsumeExpectedToken(TokenKind::kw_DescriptorTable)) { auto Table = parseDescriptorTable(); if (!Table.has_value()) return true; - Elements.push_back(*Table); + Element = RootSignatureElement(*Table); } if (tryConsumeExpectedToken( @@ -53,15 +54,19 @@ bool RootSignatureParser::parse() { auto Descriptor = parseRootDescriptor(); if (!Descriptor.has_value()) return true; - Elements.push_back(*Descriptor); + Element = RootSignatureElement(*Descriptor); } if (tryConsumeExpectedToken(TokenKind::kw_StaticSampler)) { auto Sampler = parseStaticSampler(); if (!Sampler.has_value()) return true; - Elements.push_back(*Sampler); + Element = RootSignatureElement(*Sampler); } + + if (Element.has_value()) + Elements.push_back(*Element); + } while (tryConsumeExpectedToken(TokenKind::pu_comma)); return consumeExpectedToken(TokenKind::end_of_stream, @@ -256,7 +261,7 @@ std::optional RootSignatureParser::parseDescriptorTable() { auto Clause = parseDescriptorTableClause(); if (!Clause.has_value()) return std::nullopt; - Elements.push_back(*Clause); + Elements.push_back(RootSignatureElement(*Clause)); Table.NumClauses++; } diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp index ba55f8263e475..6b4e1e292f9ac 100644 --- a/clang/lib/Sema/SemaHLSL.cpp +++ b/clang/lib/Sema/SemaHLSL.cpp @@ -1064,7 +1064,11 @@ SemaHLSL::ActOnStartRootSignatureDecl(StringRef Signature) { void SemaHLSL::ActOnFinishRootSignatureDecl( SourceLocation Loc, IdentifierInfo *DeclIdent, - SmallVector &Elements) { + ArrayRef RootElements) { + + SmallVector Elements; + for (auto &RootSigElement : RootElements) + Elements.push_back(RootSigElement.getElement()); auto *SignatureDecl = HLSLRootSignatureDecl::Create( SemaRef.getASTContext(), /*DeclContext=*/SemaRef.CurContext, Loc, diff --git a/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp b/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp index ff1697f1bbb9a..a9d0f12714e72 100644 --- a/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp +++ b/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp @@ -27,6 +27,7 @@ #include "gtest/gtest.h" using namespace clang; +using namespace clang::hlsl; using namespace llvm::hlsl::rootsig; namespace { @@ -135,7 +136,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseEmptyTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -171,7 +172,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -181,7 +182,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) { ASSERT_FALSE(Parser.parse()); // First Descriptor Table with 4 elements - RootElement Elem = Elements[0]; + RootElement Elem = Elements[0].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, ClauseType::CBuffer); ASSERT_EQ(std::get(Elem).Reg.ViewType, @@ -194,7 +195,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) { ASSERT_EQ(std::get(Elem).Flags, DescriptorRangeFlags::DataStaticWhileSetAtExecute); - Elem = Elements[1]; + Elem = Elements[1].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, ClauseType::SRV); ASSERT_EQ(std::get(Elem).Reg.ViewType, @@ -206,7 +207,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) { ASSERT_EQ(std::get(Elem).Flags, DescriptorRangeFlags::None); - Elem = Elements[2]; + Elem = Elements[2].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, ClauseType::Sampler); ASSERT_EQ(std::get(Elem).Reg.ViewType, @@ -219,7 +220,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) { ASSERT_EQ(std::get(Elem).Flags, DescriptorRangeFlags::None); - Elem = Elements[3]; + Elem = Elements[3].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, ClauseType::UAV); ASSERT_EQ(std::get(Elem).Reg.ViewType, @@ -239,14 +240,14 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) { ASSERT_EQ(std::get(Elem).Flags, ValidDescriptorRangeFlags); - Elem = Elements[4]; + Elem = Elements[4].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).NumClauses, (uint32_t)4); ASSERT_EQ(std::get(Elem).Visibility, llvm::dxbc::ShaderVisibility::Pixel); // Empty Descriptor Table - Elem = Elements[5]; + Elem = Elements[5].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).NumClauses, 0u); ASSERT_EQ(std::get(Elem).Visibility, @@ -276,7 +277,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseStaticSamplerTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -288,7 +289,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseStaticSamplerTest) { ASSERT_EQ(Elements.size(), 2u); // Check default values are as expected - RootElement Elem = Elements[0]; + RootElement Elem = Elements[0].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Reg.ViewType, RegisterType::SReg); ASSERT_EQ(std::get(Elem).Reg.Number, 0u); @@ -313,7 +314,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseStaticSamplerTest) { llvm::dxbc::ShaderVisibility::All); // Check values can be set as expected - Elem = Elements[1]; + Elem = Elements[1].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Reg.ViewType, RegisterType::SReg); ASSERT_EQ(std::get(Elem).Reg.Number, 0u); @@ -363,7 +364,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseFloatsTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -372,55 +373,55 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseFloatsTest) { ASSERT_FALSE(Parser.parse()); - RootElement Elem = Elements[0]; + RootElement Elem = Elements[0].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_FLOAT_EQ(std::get(Elem).MipLODBias, 0.f); - Elem = Elements[1]; + Elem = Elements[1].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_FLOAT_EQ(std::get(Elem).MipLODBias, 1.f); - Elem = Elements[2]; + Elem = Elements[2].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_FLOAT_EQ(std::get(Elem).MipLODBias, -1.f); - Elem = Elements[3]; + Elem = Elements[3].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_FLOAT_EQ(std::get(Elem).MipLODBias, 42.f); - Elem = Elements[4]; + Elem = Elements[4].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_FLOAT_EQ(std::get(Elem).MipLODBias, 4.2f); - Elem = Elements[5]; + Elem = Elements[5].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_FLOAT_EQ(std::get(Elem).MipLODBias, -.42f); - Elem = Elements[6]; + Elem = Elements[6].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_FLOAT_EQ(std::get(Elem).MipLODBias, 420.f); - Elem = Elements[7]; + Elem = Elements[7].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_FLOAT_EQ(std::get(Elem).MipLODBias, 0.000000000042f); - Elem = Elements[8]; + Elem = Elements[8].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_FLOAT_EQ(std::get(Elem).MipLODBias, 42.f); - Elem = Elements[9]; + Elem = Elements[9].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_FLOAT_EQ(std::get(Elem).MipLODBias, 4.2f); - Elem = Elements[10]; + Elem = Elements[10].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_FLOAT_EQ(std::get(Elem).MipLODBias, 420000000000.f); - Elem = Elements[11]; + Elem = Elements[11].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_FLOAT_EQ(std::get(Elem).MipLODBias, -2147483648.f); - Elem = Elements[12]; + Elem = Elements[12].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_FLOAT_EQ(std::get(Elem).MipLODBias, 2147483648.f); @@ -440,7 +441,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidSamplerFlagsTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -449,7 +450,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidSamplerFlagsTest) { ASSERT_FALSE(Parser.parse()); - RootElement Elem = Elements[0]; + RootElement Elem = Elements[0].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, ClauseType::Sampler); auto ValidSamplerFlags = @@ -473,7 +474,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootConsantsTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -484,7 +485,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootConsantsTest) { ASSERT_EQ(Elements.size(), 2u); - RootElement Elem = Elements[0]; + RootElement Elem = Elements[0].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Num32BitConstants, 1u); ASSERT_EQ(std::get(Elem).Reg.ViewType, RegisterType::BReg); @@ -493,7 +494,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootConsantsTest) { ASSERT_EQ(std::get(Elem).Visibility, llvm::dxbc::ShaderVisibility::All); - Elem = Elements[1]; + Elem = Elements[1].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Num32BitConstants, 4294967295u); ASSERT_EQ(std::get(Elem).Reg.ViewType, RegisterType::BReg); @@ -532,7 +533,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootFlagsTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -543,15 +544,15 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootFlagsTest) { ASSERT_EQ(Elements.size(), 3u); - RootElement Elem = Elements[0]; + RootElement Elem = Elements[0].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem), RootFlags::None); - Elem = Elements[1]; + Elem = Elements[1].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem), RootFlags::None); - Elem = Elements[2]; + Elem = Elements[2].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); auto ValidRootFlags = RootFlags::AllowInputAssemblerInputLayout | RootFlags::DenyVertexShaderRootAccess | @@ -587,7 +588,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -598,7 +599,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) { ASSERT_EQ(Elements.size(), 4u); - RootElement Elem = Elements[0]; + RootElement Elem = Elements[0].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, DescriptorType::CBuffer); ASSERT_EQ(std::get(Elem).Reg.ViewType, RegisterType::BReg); @@ -609,7 +610,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) { ASSERT_EQ(std::get(Elem).Flags, RootDescriptorFlags::DataStaticWhileSetAtExecute); - Elem = Elements[1]; + Elem = Elements[1].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, DescriptorType::SRV); ASSERT_EQ(std::get(Elem).Reg.ViewType, RegisterType::TReg); @@ -623,7 +624,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) { RootDescriptorFlags::DataStatic; ASSERT_EQ(std::get(Elem).Flags, ValidRootDescriptorFlags); - Elem = Elements[2]; + Elem = Elements[2].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, DescriptorType::UAV); ASSERT_EQ(std::get(Elem).Reg.ViewType, RegisterType::UReg); @@ -636,7 +637,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) { ASSERT_EQ(std::get(Elem).Flags, RootDescriptorFlags::DataVolatile); - Elem = Elements[3]; + Elem = Elements[3].getElement(); ASSERT_EQ(std::get(Elem).Type, DescriptorType::CBuffer); ASSERT_EQ(std::get(Elem).Reg.ViewType, RegisterType::BReg); ASSERT_EQ(std::get(Elem).Reg.Number, 0u); @@ -663,7 +664,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidTrailingCommaTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -837,7 +838,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidParseUnexpectedTokenTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -859,7 +860,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidParseInvalidTokenTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -881,7 +882,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidParseUnexpectedEndOfStreamTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -908,7 +909,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidMissingDTParameterTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -932,7 +933,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidMissingRDParameterTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -956,7 +957,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidMissingRCParameterTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -982,7 +983,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRepeatedMandatoryDTParameterTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -1006,7 +1007,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRepeatedMandatoryRCParameterTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -1032,7 +1033,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRepeatedOptionalDTParameterTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -1060,7 +1061,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRepeatedOptionalRCParameterTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -1085,7 +1086,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidLexOverflowedNumberTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -1109,7 +1110,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidParseOverflowedNegativeNumberTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -1132,7 +1133,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidLexOverflowedFloatTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -1155,7 +1156,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidLexNegOverflowedFloatTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -1178,7 +1179,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidLexOverflowedDoubleTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -1201,7 +1202,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidLexUnderflowFloatTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -1227,7 +1228,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidNonZeroFlagsTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); From f6d6d97c00ae3ec340f6f07db9b27dd8370631b0 Mon Sep 17 00:00:00 2001 From: Finn Plummer Date: Fri, 27 Jun 2025 18:53:10 +0000 Subject: [PATCH 2/8] let `RootSignatureElement` retain its source location --- .../clang/Parse/ParseHLSLRootSignature.h | 7 +++++-- clang/lib/Parse/ParseHLSLRootSignature.cpp | 18 ++++++++++++------ 2 files changed, 17 insertions(+), 8 deletions(-) diff --git a/clang/include/clang/Parse/ParseHLSLRootSignature.h b/clang/include/clang/Parse/ParseHLSLRootSignature.h index 53001d2ba461f..22540a409991e 100644 --- a/clang/include/clang/Parse/ParseHLSLRootSignature.h +++ b/clang/include/clang/Parse/ParseHLSLRootSignature.h @@ -29,12 +29,15 @@ namespace hlsl { // Introduce a wrapper struct around the underlying RootElement. This structure // will retain extra clang diagnostic information that is not available in llvm. struct RootSignatureElement { - RootSignatureElement(llvm::hlsl::rootsig::RootElement Element) - : Element(Element) {} + RootSignatureElement(SourceLocation Loc, + llvm::hlsl::rootsig::RootElement Element) + : Loc(Loc), Element(Element) {} const llvm::hlsl::rootsig::RootElement &getElement() const { return Element; } + const SourceLocation &getLocation() const { return Loc; } private: + SourceLocation Loc; llvm::hlsl::rootsig::RootElement Element; }; diff --git a/clang/lib/Parse/ParseHLSLRootSignature.cpp b/clang/lib/Parse/ParseHLSLRootSignature.cpp index 76e50fb85c8d7..86dd01c1a2841 100644 --- a/clang/lib/Parse/ParseHLSLRootSignature.cpp +++ b/clang/lib/Parse/ParseHLSLRootSignature.cpp @@ -29,39 +29,44 @@ bool RootSignatureParser::parse() { do { std::optional Element = std::nullopt; if (tryConsumeExpectedToken(TokenKind::kw_RootFlags)) { + SourceLocation ElementLoc = getTokenLocation(CurToken); auto Flags = parseRootFlags(); if (!Flags.has_value()) return true; - Element = RootSignatureElement(*Flags); + Element = RootSignatureElement(ElementLoc, *Flags); } if (tryConsumeExpectedToken(TokenKind::kw_RootConstants)) { + SourceLocation ElementLoc = getTokenLocation(CurToken); auto Constants = parseRootConstants(); if (!Constants.has_value()) return true; - Element = RootSignatureElement(*Constants); + Element = RootSignatureElement(ElementLoc, *Constants); } if (tryConsumeExpectedToken(TokenKind::kw_DescriptorTable)) { + SourceLocation ElementLoc = getTokenLocation(CurToken); auto Table = parseDescriptorTable(); if (!Table.has_value()) return true; - Element = RootSignatureElement(*Table); + Element = RootSignatureElement(ElementLoc, *Table); } if (tryConsumeExpectedToken( {TokenKind::kw_CBV, TokenKind::kw_SRV, TokenKind::kw_UAV})) { + SourceLocation ElementLoc = getTokenLocation(CurToken); auto Descriptor = parseRootDescriptor(); if (!Descriptor.has_value()) return true; - Element = RootSignatureElement(*Descriptor); + Element = RootSignatureElement(ElementLoc, *Descriptor); } if (tryConsumeExpectedToken(TokenKind::kw_StaticSampler)) { + SourceLocation ElementLoc = getTokenLocation(CurToken); auto Sampler = parseStaticSampler(); if (!Sampler.has_value()) return true; - Element = RootSignatureElement(*Sampler); + Element = RootSignatureElement(ElementLoc, *Sampler); } if (Element.has_value()) @@ -258,10 +263,11 @@ std::optional RootSignatureParser::parseDescriptorTable() { do { if (tryConsumeExpectedToken({TokenKind::kw_CBV, TokenKind::kw_SRV, TokenKind::kw_UAV, TokenKind::kw_Sampler})) { + SourceLocation ElementLoc = getTokenLocation(CurToken); auto Clause = parseDescriptorTableClause(); if (!Clause.has_value()) return std::nullopt; - Elements.push_back(RootSignatureElement(*Clause)); + Elements.push_back(RootSignatureElement(ElementLoc, *Clause)); Table.NumClauses++; } From 67eb6532ecd484a7d4c7221bfb9871f2a8c65f0e Mon Sep 17 00:00:00 2001 From: Finn Plummer Date: Fri, 27 Jun 2025 19:24:18 +0000 Subject: [PATCH 3/8] update resource range analysis to use retained source loc --- clang/include/clang/Sema/SemaHLSL.h | 4 +- clang/lib/Sema/SemaHLSL.cpp | 37 +++++++++++++++---- .../Frontend/HLSL/RootSignatureValidations.h | 3 ++ 3 files changed, 35 insertions(+), 9 deletions(-) diff --git a/clang/include/clang/Sema/SemaHLSL.h b/clang/include/clang/Sema/SemaHLSL.h index 1af706da702c2..5c944cbbd966b 100644 --- a/clang/include/clang/Sema/SemaHLSL.h +++ b/clang/include/clang/Sema/SemaHLSL.h @@ -139,7 +139,9 @@ class SemaHLSL : public SemaBase { ArrayRef Elements); // Returns true when D is invalid and a diagnostic was produced - bool handleRootSignatureDecl(HLSLRootSignatureDecl *D, SourceLocation Loc); + bool + handleRootSignatureElements(ArrayRef Elements, + SourceLocation Loc); void handleRootSignatureAttr(Decl *D, const ParsedAttr &AL); void handleNumThreadsAttr(Decl *D, const ParsedAttr &AL); void handleWaveSizeAttr(Decl *D, const ParsedAttr &AL); diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp index 6b4e1e292f9ac..b625d4d370b55 100644 --- a/clang/lib/Sema/SemaHLSL.cpp +++ b/clang/lib/Sema/SemaHLSL.cpp @@ -28,6 +28,7 @@ #include "clang/Basic/SourceLocation.h" #include "clang/Basic/Specifiers.h" #include "clang/Basic/TargetInfo.h" +#include "clang/Parse/ParseHLSLRootSignature.h" #include "clang/Sema/Initialization.h" #include "clang/Sema/Lookup.h" #include "clang/Sema/ParsedAttr.h" @@ -1066,6 +1067,9 @@ void SemaHLSL::ActOnFinishRootSignatureDecl( SourceLocation Loc, IdentifierInfo *DeclIdent, ArrayRef RootElements) { + if (handleRootSignatureElements(RootElements, Loc)) + return; + SmallVector Elements; for (auto &RootSigElement : RootElements) Elements.push_back(RootSigElement.getElement()); @@ -1074,15 +1078,12 @@ void SemaHLSL::ActOnFinishRootSignatureDecl( SemaRef.getASTContext(), /*DeclContext=*/SemaRef.CurContext, Loc, DeclIdent, SemaRef.getLangOpts().HLSLRootSigVer, Elements); - if (handleRootSignatureDecl(SignatureDecl, Loc)) - return; - SignatureDecl->setImplicit(); SemaRef.PushOnScopeChains(SignatureDecl, SemaRef.getCurScope()); } -bool SemaHLSL::handleRootSignatureDecl(HLSLRootSignatureDecl *D, - SourceLocation Loc) { +bool SemaHLSL::handleRootSignatureElements( + ArrayRef Elements, SourceLocation Loc) { // The following conducts analysis on resource ranges to detect and report // any overlaps in resource ranges. // @@ -1107,9 +1108,15 @@ bool SemaHLSL::handleRootSignatureDecl(HLSLRootSignatureDecl *D, using ResourceRange = llvm::hlsl::rootsig::ResourceRange; using GroupT = std::pair; + // Introduce a mapping from the collected RangeInfos back to the + // RootSignatureElement that will retain its diagnostics info + llvm::DenseMap InfoIndexMap; + size_t InfoIndex = 0; + // 1. Collect RangeInfos llvm::SmallVector Infos; - for (const llvm::hlsl::rootsig::RootElement &Elem : D->getRootElements()) { + for (const hlsl::RootSignatureElement &RootSigElem : Elements) { + const llvm::hlsl::rootsig::RootElement &Elem = RootSigElem.getElement(); if (const auto *Descriptor = std::get_if(&Elem)) { RangeInfo Info; @@ -1120,6 +1127,9 @@ bool SemaHLSL::handleRootSignatureDecl(HLSLRootSignatureDecl *D, llvm::dxil::ResourceClass(llvm::to_underlying(Descriptor->Type)); Info.Space = Descriptor->Space; Info.Visibility = Descriptor->Visibility; + + Info.Index = InfoIndex++; + InfoIndexMap[Info.Index] = &RootSigElem; Infos.push_back(Info); } else if (const auto *Constants = std::get_if(&Elem)) { @@ -1130,6 +1140,9 @@ bool SemaHLSL::handleRootSignatureDecl(HLSLRootSignatureDecl *D, Info.Class = llvm::dxil::ResourceClass::CBuffer; Info.Space = Constants->Space; Info.Visibility = Constants->Visibility; + + Info.Index = InfoIndex++; + InfoIndexMap[Info.Index] = &RootSigElem; Infos.push_back(Info); } else if (const auto *Sampler = std::get_if(&Elem)) { @@ -1140,6 +1153,9 @@ bool SemaHLSL::handleRootSignatureDecl(HLSLRootSignatureDecl *D, Info.Class = llvm::dxil::ResourceClass::Sampler; Info.Space = Sampler->Space; Info.Visibility = Sampler->Visibility; + + Info.Index = InfoIndex++; + InfoIndexMap[Info.Index] = &RootSigElem; Infos.push_back(Info); } else if (const auto *Clause = std::get_if( @@ -1154,7 +1170,10 @@ bool SemaHLSL::handleRootSignatureDecl(HLSLRootSignatureDecl *D, Info.Class = Clause->Type; Info.Space = Clause->Space; + // Note: Clause does not hold the visibility this will need to + Info.Index = InfoIndex++; + InfoIndexMap[Info.Index] = &RootSigElem; Infos.push_back(Info); } else if (const auto *Table = std::get_if(&Elem)) { @@ -1201,13 +1220,15 @@ bool SemaHLSL::handleRootSignatureDecl(HLSLRootSignatureDecl *D, }; // Helper to report diagnostics - auto ReportOverlap = [this, Loc, &HadOverlap](const RangeInfo *Info, + auto ReportOverlap = [this, InfoIndexMap, &HadOverlap](const RangeInfo *Info, const RangeInfo *OInfo) { HadOverlap = true; auto CommonVis = Info->Visibility == llvm::dxbc::ShaderVisibility::All ? OInfo->Visibility : Info->Visibility; - this->Diag(Loc, diag::err_hlsl_resource_range_overlap) + const hlsl::RootSignatureElement *Elem = InfoIndexMap.at(Info->Index); + SourceLocation InfoLoc = Elem->getLocation(); + this->Diag(InfoLoc, diag::err_hlsl_resource_range_overlap) << llvm::to_underlying(Info->Class) << Info->LowerBound << /*unbounded=*/(Info->UpperBound == RangeInfo::Unbounded) << Info->UpperBound << llvm::to_underlying(OInfo->Class) diff --git a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h index ee4e3cc90118d..6bb59027a4cac 100644 --- a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h +++ b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h @@ -32,6 +32,9 @@ struct RangeInfo { llvm::dxil::ResourceClass Class; uint32_t Space; llvm::dxbc::ShaderVisibility Visibility; + + // The index retains its original position before being sorted by group. + size_t Index; }; class ResourceRange { From 02e9ebdfe35f1a13ba0e2ee7b2708cbc0b97ff9a Mon Sep 17 00:00:00 2001 From: Finn Plummer Date: Fri, 27 Jun 2025 19:54:53 +0000 Subject: [PATCH 4/8] move wrapper definition to `SemaHLSL` - this struct needs to be accessible to both `Sema` and `Parse` and since `Parse` depends on `Sema` then we need to have it be included from there, so as to not introduce a circular dependency --- .../clang/Parse/ParseHLSLRootSignature.h | 16 +--------------- clang/include/clang/Sema/SemaHLSL.h | 19 +++++++++++++++++-- clang/lib/Sema/SemaHLSL.cpp | 1 - 3 files changed, 18 insertions(+), 18 deletions(-) diff --git a/clang/include/clang/Parse/ParseHLSLRootSignature.h b/clang/include/clang/Parse/ParseHLSLRootSignature.h index 22540a409991e..9ef5b64d7b4a5 100644 --- a/clang/include/clang/Parse/ParseHLSLRootSignature.h +++ b/clang/include/clang/Parse/ParseHLSLRootSignature.h @@ -17,6 +17,7 @@ #include "clang/Basic/DiagnosticParse.h" #include "clang/Lex/LexHLSLRootSignature.h" #include "clang/Lex/Preprocessor.h" +#include "clang/Sema/SemaHLSL.h" #include "llvm/ADT/SmallVector.h" #include "llvm/ADT/StringRef.h" @@ -26,21 +27,6 @@ namespace clang { namespace hlsl { -// Introduce a wrapper struct around the underlying RootElement. This structure -// will retain extra clang diagnostic information that is not available in llvm. -struct RootSignatureElement { - RootSignatureElement(SourceLocation Loc, - llvm::hlsl::rootsig::RootElement Element) - : Loc(Loc), Element(Element) {} - - const llvm::hlsl::rootsig::RootElement &getElement() const { return Element; } - const SourceLocation &getLocation() const { return Loc; } - -private: - SourceLocation Loc; - llvm::hlsl::rootsig::RootElement Element; -}; - class RootSignatureParser { public: RootSignatureParser(llvm::dxbc::RootSignatureVersion Version, diff --git a/clang/include/clang/Sema/SemaHLSL.h b/clang/include/clang/Sema/SemaHLSL.h index 5c944cbbd966b..910e0e640796b 100644 --- a/clang/include/clang/Sema/SemaHLSL.h +++ b/clang/include/clang/Sema/SemaHLSL.h @@ -33,8 +33,23 @@ class Scope; class VarDecl; namespace hlsl { -struct RootSignatureElement; -} + +// Introduce a wrapper struct around the underlying RootElement. This structure +// will retain extra clang diagnostic information that is not available in llvm. +struct RootSignatureElement { + RootSignatureElement(SourceLocation Loc, + llvm::hlsl::rootsig::RootElement Element) + : Loc(Loc), Element(Element) {} + + const llvm::hlsl::rootsig::RootElement &getElement() const { return Element; } + const SourceLocation &getLocation() const { return Loc; } + +private: + SourceLocation Loc; + llvm::hlsl::rootsig::RootElement Element; +}; + +} // namespace hlsl using llvm::dxil::ResourceClass; diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp index b625d4d370b55..50436573d49f2 100644 --- a/clang/lib/Sema/SemaHLSL.cpp +++ b/clang/lib/Sema/SemaHLSL.cpp @@ -28,7 +28,6 @@ #include "clang/Basic/SourceLocation.h" #include "clang/Basic/Specifiers.h" #include "clang/Basic/TargetInfo.h" -#include "clang/Parse/ParseHLSLRootSignature.h" #include "clang/Sema/Initialization.h" #include "clang/Sema/Lookup.h" #include "clang/Sema/ParsedAttr.h" From b9d40cb4b390fd4cfb33748000213485e7830ce1 Mon Sep 17 00:00:00 2001 From: Finn Plummer Date: Thu, 3 Jul 2025 16:52:39 +0000 Subject: [PATCH 5/8] add note to denote where the other overlapping range is --- clang/include/clang/Basic/DiagnosticSemaKinds.td | 1 + clang/lib/Sema/SemaHLSL.cpp | 4 ++++ .../RootSignature-resource-ranges-err.hlsl | 14 ++++++++++++++ 3 files changed, 19 insertions(+) diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index 968edd967e0c5..4fe0abb972a61 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -13079,6 +13079,7 @@ def err_hlsl_resource_range_overlap: Error< "resource ranges %sub{subst_hlsl_format_ranges}0,1,2,3 and %sub{subst_hlsl_format_ranges}4,5,6,7 " "overlap within space = %8 and visibility = " "%select{All|Vertex|Hull|Domain|Geometry|Pixel|Amplification|Mesh}9">; +def note_hlsl_resource_range_here: Note<"overlapping resource range here">; // Layout randomization diagnostics. def err_non_designated_init_used : Error< diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp index 50436573d49f2..49e0299fd92e1 100644 --- a/clang/lib/Sema/SemaHLSL.cpp +++ b/clang/lib/Sema/SemaHLSL.cpp @@ -1234,6 +1234,10 @@ bool SemaHLSL::handleRootSignatureElements( << OInfo->LowerBound << /*unbounded=*/(OInfo->UpperBound == RangeInfo::Unbounded) << OInfo->UpperBound << Info->Space << CommonVis; + + const hlsl::RootSignatureElement *OElem = InfoIndexMap.at(OInfo->Index); + SourceLocation OInfoLoc = OElem->getLocation(); + this->Diag(OInfoLoc, diag::note_hlsl_resource_range_here); }; // 3: Iterate through collected RangeInfos diff --git a/clang/test/SemaHLSL/RootSignature-resource-ranges-err.hlsl b/clang/test/SemaHLSL/RootSignature-resource-ranges-err.hlsl index 4b3579d51818a..b98238dd43f7e 100644 --- a/clang/test/SemaHLSL/RootSignature-resource-ranges-err.hlsl +++ b/clang/test/SemaHLSL/RootSignature-resource-ranges-err.hlsl @@ -1,49 +1,61 @@ // RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -o - %s -verify +// expected-note@+2 {{overlapping resource range here}} // expected-error@+1 {{resource ranges b[42;42] and b[42;42] overlap within space = 0 and visibility = All}} [RootSignature("CBV(b42), CBV(b42)")] void bad_root_signature_0() {} +// expected-note@+2 {{overlapping resource range here}} // expected-error@+1 {{resource ranges t[0;0] and t[0;0] overlap within space = 3 and visibility = All}} [RootSignature("SRV(t0, space = 3), SRV(t0, space = 3)")] void bad_root_signature_1() {} +// expected-note@+2 {{overlapping resource range here}} // expected-error@+1 {{resource ranges u[0;0] and u[0;0] overlap within space = 0 and visibility = Pixel}} [RootSignature("UAV(u0, visibility = SHADER_VISIBILITY_PIXEL), UAV(u0, visibility = SHADER_VISIBILITY_PIXEL)")] void bad_root_signature_2() {} +// expected-note@+2 {{overlapping resource range here}} // expected-error@+1 {{resource ranges u[0;0] and u[0;0] overlap within space = 0 and visibility = Pixel}} [RootSignature("UAV(u0, visibility = SHADER_VISIBILITY_ALL), UAV(u0, visibility = SHADER_VISIBILITY_PIXEL)")] void bad_root_signature_3() {} +// expected-note@+2 {{overlapping resource range here}} // expected-error@+1 {{resource ranges u[0;0] and u[0;0] overlap within space = 0 and visibility = Pixel}} [RootSignature("UAV(u0, visibility = SHADER_VISIBILITY_PIXEL), UAV(u0, visibility = SHADER_VISIBILITY_ALL)")] void bad_root_signature_4() {} +// expected-note@+2 {{overlapping resource range here}} // expected-error@+1 {{resource ranges b[0;0] and b[0;0] overlap within space = 0 and visibility = All}} [RootSignature("RootConstants(num32BitConstants=4, b0), RootConstants(num32BitConstants=2, b0)")] void bad_root_signature_5() {} +// expected-note@+2 {{overlapping resource range here}} // expected-error@+1 {{resource ranges s[3;3] and s[3;3] overlap within space = 0 and visibility = All}} [RootSignature("StaticSampler(s3), StaticSampler(s3)")] void bad_root_signature_6() {} +// expected-note@+2 {{overlapping resource range here}} // expected-error@+1 {{resource ranges t[2;5] and t[0;3] overlap within space = 0 and visibility = All}} [RootSignature("DescriptorTable(SRV(t0, numDescriptors=4), SRV(t2, numDescriptors=4))")] void bad_root_signature_7() {} +// expected-note@+2 {{overlapping resource range here}} // expected-error@+1 {{resource ranges u[2;5] and u[0;unbounded) overlap within space = 0 and visibility = Hull}} [RootSignature("DescriptorTable(UAV(u0, numDescriptors=unbounded), visibility = SHADER_VISIBILITY_HULL), DescriptorTable(UAV(u2, numDescriptors=4))")] void bad_root_signature_8() {} +// expected-note@+2 {{overlapping resource range here}} // expected-error@+1 {{resource ranges b[0;2] and b[2;2] overlap within space = 0 and visibility = All}} [RootSignature("RootConstants(num32BitConstants=4, b2), DescriptorTable(CBV(b0, numDescriptors=3))")] void bad_root_signature_9() {} +// expected-note@+2 {{overlapping resource range here}} // expected-error@+1 {{resource ranges s[4;unbounded) and s[17;17] overlap within space = 0 and visibility = All}} [RootSignature("StaticSampler(s17), DescriptorTable(Sampler(s0, numDescriptors=3),Sampler(s4, numDescriptors=unbounded))")] void bad_root_signature_10() {} +// expected-note@+2 {{overlapping resource range here}} // expected-error@+1 {{resource ranges b[45;45] and b[4;unbounded) overlap within space = 0 and visibility = Geometry}} [RootSignature("DescriptorTable(CBV(b4, numDescriptors=unbounded)), CBV(b45, visibility = SHADER_VISIBILITY_GEOMETRY)")] void bad_root_signature_11() {} @@ -55,10 +67,12 @@ void bad_root_signature_11() {} " CBV(b0, numDescriptors = 8), " \ ")" +// expected-note@+2 {{overlapping resource range here}} // expected-error@+1 {{resource ranges b[0;7] and b[1;2] overlap within space = 0 and visibility = All}} [RootSignature(ReportFirstOverlap)] void bad_root_signature_12() {} +// expected-note@+2 {{overlapping resource range here}} // expected-error@+1 {{resource ranges s[2;2] and s[2;2] overlap within space = 0 and visibility = Vertex}} [RootSignature("StaticSampler(s2, visibility=SHADER_VISIBILITY_ALL), DescriptorTable(Sampler(s2), visibility=SHADER_VISIBILITY_VERTEX)")] void valid_root_signature_13() {} From e1289c12efbf178adb36fc11bb2e4ba59e5406b8 Mon Sep 17 00:00:00 2001 From: Finn Plummer Date: Fri, 4 Jul 2025 17:04:39 +0000 Subject: [PATCH 6/8] add testcase to demonstrate source location --- .../RootSignature-resource-ranges-err.hlsl | 27 +++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/clang/test/SemaHLSL/RootSignature-resource-ranges-err.hlsl b/clang/test/SemaHLSL/RootSignature-resource-ranges-err.hlsl index b98238dd43f7e..a021722aea2a4 100644 --- a/clang/test/SemaHLSL/RootSignature-resource-ranges-err.hlsl +++ b/clang/test/SemaHLSL/RootSignature-resource-ranges-err.hlsl @@ -1,4 +1,5 @@ // RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -o - %s -verify +// RUN: not %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -o - %s 2>&1 | FileCheck %s // expected-note@+2 {{overlapping resource range here}} // expected-error@+1 {{resource ranges b[42;42] and b[42;42] overlap within space = 0 and visibility = All}} @@ -76,3 +77,29 @@ void bad_root_signature_12() {} // expected-error@+1 {{resource ranges s[2;2] and s[2;2] overlap within space = 0 and visibility = Vertex}} [RootSignature("StaticSampler(s2, visibility=SHADER_VISIBILITY_ALL), DescriptorTable(Sampler(s2), visibility=SHADER_VISIBILITY_VERTEX)")] void valid_root_signature_13() {} + +#define DemoNoteSourceLocations \ + "DescriptorTable( " \ + " CBV(b4, numDescriptors = 4), " \ + " SRV(t22, numDescriptors = 1), " \ + " UAV(u42, numDescriptors = 2), " \ + " CBV(b9, numDescriptors = 8), " \ + " SRV(t12, numDescriptors = 3), " \ + " UAV(u3, numDescriptors = 16), " \ + " SRV(t9, numDescriptors = 1), " \ + " CBV(b1, numDescriptors = 2), " \ + " SRV(t17, numDescriptors = 7), " \ + " UAV(u0, numDescriptors = 3), " \ + ")" + +// CHECK: note: expanded from macro 'DemoNoteSourceLocations' +// CHECK-NEXT: [[@LINE-5]] | " SRV(t17, numDescriptors = 7), " \ +// CHECK-NEXT: | ^ +// CHECK: note: expanded from macro 'DemoNoteSourceLocations' +// CHECK-NEXT: [[@LINE-15]] | " SRV(t22, numDescriptors = 1), " +// CHECK-NEXT: | ^ + +// expected-note@+2 {{overlapping resource range here}} +// expected-error@+1 {{resource ranges t[17;23] and t[22;22] overlap within space = 0 and visibility = All}} +[RootSignature(DemoNoteSourceLocations)] +void bad_root_signature_14() {} From 74ee5ee870ac6a65dcdf70b3709edc072cbb1fb0 Mon Sep 17 00:00:00 2001 From: Finn Plummer Date: Fri, 4 Jul 2025 17:56:54 +0000 Subject: [PATCH 7/8] clang format --- clang/lib/Sema/SemaHLSL.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp index 49e0299fd92e1..f490f957f9667 100644 --- a/clang/lib/Sema/SemaHLSL.cpp +++ b/clang/lib/Sema/SemaHLSL.cpp @@ -1219,8 +1219,8 @@ bool SemaHLSL::handleRootSignatureElements( }; // Helper to report diagnostics - auto ReportOverlap = [this, InfoIndexMap, &HadOverlap](const RangeInfo *Info, - const RangeInfo *OInfo) { + auto ReportOverlap = [this, InfoIndexMap, &HadOverlap]( + const RangeInfo *Info, const RangeInfo *OInfo) { HadOverlap = true; auto CommonVis = Info->Visibility == llvm::dxbc::ShaderVisibility::All ? OInfo->Visibility From 72694b7e19956a5d28f26a91f48c9cfa49b2c35c Mon Sep 17 00:00:00 2001 From: Finn Plummer Date: Fri, 4 Jul 2025 18:03:28 +0000 Subject: [PATCH 8/8] rebase: clean-ups --- .../Parse/ParseHLSLRootSignatureTest.cpp | 32 +++++++++---------- 1 file changed, 16 insertions(+), 16 deletions(-) diff --git a/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp b/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp index a9d0f12714e72..f517619df2c2a 100644 --- a/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp +++ b/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp @@ -697,7 +697,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidVersion10Test) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_0, Elements, Signature, *PP); @@ -707,17 +707,17 @@ TEST_F(ParseHLSLRootSignatureTest, ValidVersion10Test) { ASSERT_FALSE(Parser.parse()); auto DefRootDescriptorFlag = llvm::dxbc::RootDescriptorFlags::DataVolatile; - RootElement Elem = Elements[0]; + RootElement Elem = Elements[0].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, DescriptorType::CBuffer); ASSERT_EQ(std::get(Elem).Flags, DefRootDescriptorFlag); - Elem = Elements[1]; + Elem = Elements[1].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, DescriptorType::SRV); ASSERT_EQ(std::get(Elem).Flags, DefRootDescriptorFlag); - Elem = Elements[2]; + Elem = Elements[2].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, DescriptorType::UAV); ASSERT_EQ(std::get(Elem).Flags, DefRootDescriptorFlag); @@ -725,22 +725,22 @@ TEST_F(ParseHLSLRootSignatureTest, ValidVersion10Test) { auto ValidNonSamplerFlags = llvm::dxbc::DescriptorRangeFlags::DescriptorsVolatile | llvm::dxbc::DescriptorRangeFlags::DataVolatile; - Elem = Elements[3]; + Elem = Elements[3].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, ClauseType::CBuffer); ASSERT_EQ(std::get(Elem).Flags, ValidNonSamplerFlags); - Elem = Elements[4]; + Elem = Elements[4].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, ClauseType::SRV); ASSERT_EQ(std::get(Elem).Flags, ValidNonSamplerFlags); - Elem = Elements[5]; + Elem = Elements[5].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, ClauseType::UAV); ASSERT_EQ(std::get(Elem).Flags, ValidNonSamplerFlags); - Elem = Elements[6]; + Elem = Elements[6].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, ClauseType::Sampler); ASSERT_EQ(std::get(Elem).Flags, @@ -770,7 +770,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidVersion11Test) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector Elements; + SmallVector Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -779,43 +779,43 @@ TEST_F(ParseHLSLRootSignatureTest, ValidVersion11Test) { ASSERT_FALSE(Parser.parse()); - RootElement Elem = Elements[0]; + RootElement Elem = Elements[0].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, DescriptorType::CBuffer); ASSERT_EQ(std::get(Elem).Flags, llvm::dxbc::RootDescriptorFlags::DataStaticWhileSetAtExecute); - Elem = Elements[1]; + Elem = Elements[1].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, DescriptorType::SRV); ASSERT_EQ(std::get(Elem).Flags, llvm::dxbc::RootDescriptorFlags::DataStaticWhileSetAtExecute); - Elem = Elements[2]; + Elem = Elements[2].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, DescriptorType::UAV); ASSERT_EQ(std::get(Elem).Flags, llvm::dxbc::RootDescriptorFlags::DataVolatile); - Elem = Elements[3]; + Elem = Elements[3].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, ClauseType::CBuffer); ASSERT_EQ(std::get(Elem).Flags, llvm::dxbc::DescriptorRangeFlags::DataStaticWhileSetAtExecute); - Elem = Elements[4]; + Elem = Elements[4].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, ClauseType::SRV); ASSERT_EQ(std::get(Elem).Flags, llvm::dxbc::DescriptorRangeFlags::DataStaticWhileSetAtExecute); - Elem = Elements[5]; + Elem = Elements[5].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, ClauseType::UAV); ASSERT_EQ(std::get(Elem).Flags, llvm::dxbc::DescriptorRangeFlags::DataVolatile); - Elem = Elements[6]; + Elem = Elements[6].getElement(); ASSERT_TRUE(std::holds_alternative(Elem)); ASSERT_EQ(std::get(Elem).Type, ClauseType::Sampler); ASSERT_EQ(std::get(Elem).Flags,