Author: Finn Plummer Date: 2025-07-11T18:33:16-07:00 New Revision: 7ecb37b703b7c675d1be6c4194c50f6f8dd9ac9c
URL: https://github.com/llvm/llvm-project/commit/7ecb37b703b7c675d1be6c4194c50f6f8dd9ac9c DIFF: https://github.com/llvm/llvm-project/commit/7ecb37b703b7c675d1be6c4194c50f6f8dd9ac9c.diff LOG: [HLSL][RootSignature] Retain `SourceLocation` of `RootElement` for `SemaHLSL` diagnostics (#147115) At the moment, when we report diagnostics from `SemaHLSL` we only provide the source location of the root signature attr. This allows for significantly less helpful diagnostics (for eg. reporting resource range overlaps). This pr implements a way to retain the source location of a root element when it is parsed, so that we can output the `SourceLocation` of each root element that causes the overlap in the diagnostics during semantic analysis. This pr defines a wrapper struct `clang::hlsl::RootSignatureElement` in `SemaHLSL` that will contain the underlying `RootElement` and can hold any additional diagnostic information. This struct will be what is used in `HLSLRootSignatureParser` and in `SemaHLSL`. Then the diagnostic information will be stripped and the underlying element will be stored in the `RootSignatureDecl`. For the reporting of diagnostics, we can now use the retained `SourceLocation` of each `RootElement` when reporting the range overlap, and we can add a `note` diagnostic to highlight the other root element as well. - Defines `RootSignatureElement` in the `hlsl` namespace in `SemaHLSL` (defined in `SemaHLSL` because `Parse` has a dependency on `Sema`) - Updates parsing logic to construct `RootSignatureElement`s and retain the source loction in `ParseHLSLRootSignature` - Updates `SemaHLSL` when it constructs the `RootSignatureDecl` to take the new `RootSignatureElement` and store the underlying `RootElement` - Updates the current tests to ensure the new `note` diagnostic is produced and that the `SourceLocation` is seen - Slight update to the `RootSignatureValidations` api to ensure the caller sorts and owns the memory of the passed in `RangeInfo` - Adds a test to demonstrate the `SourceLocation` of both elements being correctly pointed out Resolves: https://github.com/llvm/llvm-project/issues/145819 Added: Modified: clang/include/clang/Basic/DiagnosticSemaKinds.td clang/include/clang/Parse/ParseHLSLRootSignature.h clang/include/clang/Sema/SemaHLSL.h clang/lib/Parse/ParseDeclCXX.cpp clang/lib/Parse/ParseHLSLRootSignature.cpp clang/lib/Sema/SemaHLSL.cpp clang/test/SemaHLSL/RootSignature-resource-ranges-err.hlsl clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp Removed: ################################################################################ diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td index 3b8f396e37c48..f1290738d46b2 100644 --- a/clang/include/clang/Basic/DiagnosticSemaKinds.td +++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td @@ -13098,6 +13098,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/include/clang/Parse/ParseHLSLRootSignature.h b/clang/include/clang/Parse/ParseHLSLRootSignature.h index 007c3f7ba1e9c..500e79a7ba574 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" @@ -29,7 +30,7 @@ namespace hlsl { class RootSignatureParser { public: RootSignatureParser(llvm::dxbc::RootSignatureVersion Version, - SmallVector<llvm::hlsl::rootsig::RootElement> &Elements, + SmallVector<RootSignatureElement> &Elements, StringLiteral *Signature, Preprocessor &PP); /// Consumes tokens from the Lexer and constructs the in-memory @@ -201,7 +202,7 @@ class RootSignatureParser { private: llvm::dxbc::RootSignatureVersion Version; - SmallVector<llvm::hlsl::rootsig::RootElement> &Elements; + SmallVector<RootSignatureElement> &Elements; StringLiteral *Signature; RootSignatureLexer Lexer; Preprocessor &PP; diff --git a/clang/include/clang/Sema/SemaHLSL.h b/clang/include/clang/Sema/SemaHLSL.h index 7d7eae4db532c..c0da80a70bb82 100644 --- a/clang/include/clang/Sema/SemaHLSL.h +++ b/clang/include/clang/Sema/SemaHLSL.h @@ -32,6 +32,25 @@ class ParsedAttr; class Scope; class VarDecl; +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; +}; + +} // namespace hlsl + using llvm::dxil::ResourceClass; // FIXME: This can be hidden (as static function in SemaHLSL.cpp) once we no @@ -130,12 +149,14 @@ 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<llvm::hlsl::rootsig::RootElement> &Elements); - - // Returns true when D is invalid and a diagnostic was produced - bool handleRootSignatureDecl(HLSLRootSignatureDecl *D, SourceLocation Loc); + void + ActOnFinishRootSignatureDecl(SourceLocation Loc, IdentifierInfo *DeclIdent, + ArrayRef<hlsl::RootSignatureElement> Elements); + + // Returns true if any RootSignatureElement is invalid and a diagnostic was + // produced + bool + handleRootSignatureElements(ArrayRef<hlsl::RootSignatureElement> Elements); 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/Parse/ParseDeclCXX.cpp b/clang/lib/Parse/ParseDeclCXX.cpp index 59e6e0af4b5b0..9fe18b0dbcedb 100644 --- a/clang/lib/Parse/ParseDeclCXX.cpp +++ b/clang/lib/Parse/ParseDeclCXX.cpp @@ -4948,7 +4948,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<llvm::hlsl::rootsig::RootElement> RootElements; + SmallVector<hlsl::RootSignatureElement> 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 dc5f6faefbab4..4f4bbb5ced13b 100644 --- a/clang/lib/Parse/ParseHLSLRootSignature.cpp +++ b/clang/lib/Parse/ParseHLSLRootSignature.cpp @@ -19,7 +19,7 @@ using TokenKind = RootSignatureToken::Kind; RootSignatureParser::RootSignatureParser( llvm::dxbc::RootSignatureVersion Version, - SmallVector<RootElement> &Elements, StringLiteral *Signature, + SmallVector<RootSignatureElement> &Elements, StringLiteral *Signature, Preprocessor &PP) : Version(Version), Elements(Elements), Signature(Signature), Lexer(Signature->getString()), PP(PP), CurToken(0) {} @@ -29,31 +29,36 @@ bool RootSignatureParser::parse() { // end of the stream while (!peekExpectedToken(TokenKind::end_of_stream)) { if (tryConsumeExpectedToken(TokenKind::kw_RootFlags)) { + SourceLocation ElementLoc = getTokenLocation(CurToken); auto Flags = parseRootFlags(); if (!Flags.has_value()) return true; - Elements.push_back(*Flags); + Elements.emplace_back(ElementLoc, *Flags); } else if (tryConsumeExpectedToken(TokenKind::kw_RootConstants)) { + SourceLocation ElementLoc = getTokenLocation(CurToken); auto Constants = parseRootConstants(); if (!Constants.has_value()) return true; - Elements.push_back(*Constants); + Elements.emplace_back(ElementLoc, *Constants); } else if (tryConsumeExpectedToken(TokenKind::kw_DescriptorTable)) { + SourceLocation ElementLoc = getTokenLocation(CurToken); auto Table = parseDescriptorTable(); if (!Table.has_value()) return true; - Elements.push_back(*Table); + Elements.emplace_back(ElementLoc, *Table); } else if (tryConsumeExpectedToken( {TokenKind::kw_CBV, TokenKind::kw_SRV, TokenKind::kw_UAV})) { + SourceLocation ElementLoc = getTokenLocation(CurToken); auto Descriptor = parseRootDescriptor(); if (!Descriptor.has_value()) return true; - Elements.push_back(*Descriptor); + Elements.emplace_back(ElementLoc, *Descriptor); } else if (tryConsumeExpectedToken(TokenKind::kw_StaticSampler)) { + SourceLocation ElementLoc = getTokenLocation(CurToken); auto Sampler = parseStaticSampler(); if (!Sampler.has_value()) return true; - Elements.push_back(*Sampler); + Elements.emplace_back(ElementLoc, *Sampler); } // ',' denotes another element, otherwise, expected to be at end of stream @@ -245,10 +250,11 @@ std::optional<DescriptorTable> RootSignatureParser::parseDescriptorTable() { if (tryConsumeExpectedToken({TokenKind::kw_CBV, TokenKind::kw_SRV, TokenKind::kw_UAV, TokenKind::kw_Sampler})) { // DescriptorTableClause - CBV, SRV, UAV, or Sampler + SourceLocation ElementLoc = getTokenLocation(CurToken); auto Clause = parseDescriptorTableClause(); if (!Clause.has_value()) return std::nullopt; - Elements.push_back(*Clause); + Elements.emplace_back(ElementLoc, *Clause); Table.NumClauses++; } else if (tryConsumeExpectedToken(TokenKind::kw_visibility)) { // visibility = SHADER_VISIBILITY diff --git a/clang/lib/Sema/SemaHLSL.cpp b/clang/lib/Sema/SemaHLSL.cpp index cc50d23e0b998..9af32138f9385 100644 --- a/clang/lib/Sema/SemaHLSL.cpp +++ b/clang/lib/Sema/SemaHLSL.cpp @@ -1064,27 +1064,33 @@ SemaHLSL::ActOnStartRootSignatureDecl(StringRef Signature) { void SemaHLSL::ActOnFinishRootSignatureDecl( SourceLocation Loc, IdentifierInfo *DeclIdent, - SmallVector<llvm::hlsl::rootsig::RootElement> &Elements) { + ArrayRef<hlsl::RootSignatureElement> RootElements) { + + if (handleRootSignatureElements(RootElements)) + return; + + SmallVector<llvm::hlsl::rootsig::RootElement> Elements; + for (auto &RootSigElement : RootElements) + Elements.push_back(RootSigElement.getElement()); auto *SignatureDecl = HLSLRootSignatureDecl::Create( 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<hlsl::RootSignatureElement> Elements) { using RangeInfo = llvm::hlsl::rootsig::RangeInfo; using OverlappingRanges = llvm::hlsl::rootsig::OverlappingRanges; + using InfoPairT = std::pair<RangeInfo, const hlsl::RootSignatureElement *>; // 1. Collect RangeInfos - llvm::SmallVector<RangeInfo> Infos; - for (const llvm::hlsl::rootsig::RootElement &Elem : D->getRootElements()) { + llvm::SmallVector<InfoPairT> InfoPairs; + for (const hlsl::RootSignatureElement &RootSigElem : Elements) { + const llvm::hlsl::rootsig::RootElement &Elem = RootSigElem.getElement(); if (const auto *Descriptor = std::get_if<llvm::hlsl::rootsig::RootDescriptor>(&Elem)) { RangeInfo Info; @@ -1095,7 +1101,8 @@ bool SemaHLSL::handleRootSignatureDecl(HLSLRootSignatureDecl *D, llvm::dxil::ResourceClass(llvm::to_underlying(Descriptor->Type)); Info.Space = Descriptor->Space; Info.Visibility = Descriptor->Visibility; - Infos.push_back(Info); + + InfoPairs.push_back({Info, &RootSigElem}); } else if (const auto *Constants = std::get_if<llvm::hlsl::rootsig::RootConstants>(&Elem)) { RangeInfo Info; @@ -1105,7 +1112,8 @@ bool SemaHLSL::handleRootSignatureDecl(HLSLRootSignatureDecl *D, Info.Class = llvm::dxil::ResourceClass::CBuffer; Info.Space = Constants->Space; Info.Visibility = Constants->Visibility; - Infos.push_back(Info); + + InfoPairs.push_back({Info, &RootSigElem}); } else if (const auto *Sampler = std::get_if<llvm::hlsl::rootsig::StaticSampler>(&Elem)) { RangeInfo Info; @@ -1115,7 +1123,8 @@ bool SemaHLSL::handleRootSignatureDecl(HLSLRootSignatureDecl *D, Info.Class = llvm::dxil::ResourceClass::Sampler; Info.Space = Sampler->Space; Info.Visibility = Sampler->Visibility; - Infos.push_back(Info); + + InfoPairs.push_back({Info, &RootSigElem}); } else if (const auto *Clause = std::get_if<llvm::hlsl::rootsig::DescriptorTableClause>( &Elem)) { @@ -1129,38 +1138,83 @@ bool SemaHLSL::handleRootSignatureDecl(HLSLRootSignatureDecl *D, Info.Class = Clause->Type; Info.Space = Clause->Space; + // Note: Clause does not hold the visibility this will need to - Infos.push_back(Info); + InfoPairs.push_back({Info, &RootSigElem}); } else if (const auto *Table = std::get_if<llvm::hlsl::rootsig::DescriptorTable>(&Elem)) { // Table holds the Visibility of all owned Clauses in Table, so iterate // owned Clauses and update their corresponding RangeInfo - assert(Table->NumClauses <= Infos.size() && "RootElement"); + assert(Table->NumClauses <= InfoPairs.size() && "RootElement"); // The last Table->NumClauses elements of Infos are the owned Clauses // generated RangeInfo auto TableInfos = - MutableArrayRef<RangeInfo>(Infos).take_back(Table->NumClauses); - for (RangeInfo &Info : TableInfos) - Info.Visibility = Table->Visibility; + MutableArrayRef<InfoPairT>(InfoPairs).take_back(Table->NumClauses); + for (InfoPairT &Pair : TableInfos) + Pair.first.Visibility = Table->Visibility; } } - // Helper to report diagnostics - auto ReportOverlap = [this, Loc](OverlappingRanges Overlap) { + // 2. Sort with the RangeInfo <operator to prepare it for findOverlapping + llvm::sort(InfoPairs, + [](InfoPairT A, InfoPairT B) { return A.first < B.first; }); + + llvm::SmallVector<RangeInfo> Infos; + for (const InfoPairT &Pair : InfoPairs) + Infos.push_back(Pair.first); + + // Helpers to report diagnostics + uint32_t DuplicateCounter = 0; + using ElemPair = std::pair<const hlsl::RootSignatureElement *, + const hlsl::RootSignatureElement *>; + auto GetElemPair = [&Infos, &InfoPairs, &DuplicateCounter]( + OverlappingRanges Overlap) -> ElemPair { + // Given we sorted the InfoPairs (and by implication) Infos, and, + // that Overlap.B is the item retrieved from the ResourceRange. Then it is + // guarenteed that Overlap.B <= Overlap.A. + // + // So we will find Overlap.B first and then continue to find Overlap.A + // after + auto InfoB = std::lower_bound(Infos.begin(), Infos.end(), *Overlap.B); + auto DistB = std::distance(Infos.begin(), InfoB); + auto PairB = InfoPairs.begin(); + std::advance(PairB, DistB); + + auto InfoA = std::lower_bound(InfoB, Infos.end(), *Overlap.A); + // Similarily, from the property that we have sorted the RangeInfos, + // all duplicates will be processed one after the other. So + // DuplicateCounter can be re-used for each set of duplicates we + // encounter as we handle incoming errors + DuplicateCounter = InfoA == InfoB ? DuplicateCounter + 1 : 0; + auto DistA = std::distance(InfoB, InfoA) + DuplicateCounter; + auto PairA = PairB; + std::advance(PairA, DistA); + + return {PairA->second, PairB->second}; + }; + + auto ReportOverlap = [this, &GetElemPair](OverlappingRanges Overlap) { + auto Pair = GetElemPair(Overlap); const RangeInfo *Info = Overlap.A; + const hlsl::RootSignatureElement *Elem = Pair.first; const RangeInfo *OInfo = Overlap.B; + auto CommonVis = Info->Visibility == llvm::dxbc::ShaderVisibility::All ? OInfo->Visibility : Info->Visibility; - this->Diag(Loc, diag::err_hlsl_resource_range_overlap) + this->Diag(Elem->getLocation(), 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) << OInfo->LowerBound << /*unbounded=*/(OInfo->UpperBound == RangeInfo::Unbounded) << OInfo->UpperBound << Info->Space << CommonVis; + + const hlsl::RootSignatureElement *OElem = Pair.second; + this->Diag(OElem->getLocation(), diag::note_hlsl_resource_range_here); }; + // 3. Invoke find overlapping ranges llvm::SmallVector<OverlappingRanges> Overlaps = llvm::hlsl::rootsig::findOverlappingRanges(Infos); for (OverlappingRanges Overlap : Overlaps) diff --git a/clang/test/SemaHLSL/RootSignature-resource-ranges-err.hlsl b/clang/test/SemaHLSL/RootSignature-resource-ranges-err.hlsl index 4b3579d51818a..47c06d3fd6381 100644 --- a/clang/test/SemaHLSL/RootSignature-resource-ranges-err.hlsl +++ b/clang/test/SemaHLSL/RootSignature-resource-ranges-err.hlsl @@ -1,50 +1,63 @@ -// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -o - %s -verify +// RUN: %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -fsyntax-only %s -verify +// RUN: not %clang_cc1 -triple dxil-pc-shadermodel6.3-library -x hlsl -fsyntax-only %s 2>&1 | FileCheck %s -// expected-error@+1 {{resource ranges b[42;42] and b[42;42] overlap within space = 0 and visibility = All}} +// expected-error@+2 {{resource ranges b[42;42] and b[42;42] overlap within space = 0 and visibility = All}} +// expected-note@+1 {{overlapping resource range here}} [RootSignature("CBV(b42), CBV(b42)")] void bad_root_signature_0() {} -// expected-error@+1 {{resource ranges t[0;0] and t[0;0] overlap within space = 3 and visibility = All}} +// expected-error@+2 {{resource ranges t[0;0] and t[0;0] overlap within space = 3 and visibility = All}} +// expected-note@+1 {{overlapping resource range here}} [RootSignature("SRV(t0, space = 3), SRV(t0, space = 3)")] void bad_root_signature_1() {} -// expected-error@+1 {{resource ranges u[0;0] and u[0;0] overlap within space = 0 and visibility = Pixel}} +// expected-error@+2 {{resource ranges u[0;0] and u[0;0] overlap within space = 0 and visibility = Pixel}} +// expected-note@+1 {{overlapping resource range here}} [RootSignature("UAV(u0, visibility = SHADER_VISIBILITY_PIXEL), UAV(u0, visibility = SHADER_VISIBILITY_PIXEL)")] void bad_root_signature_2() {} -// expected-error@+1 {{resource ranges u[0;0] and u[0;0] overlap within space = 0 and visibility = Pixel}} +// expected-error@+2 {{resource ranges u[0;0] and u[0;0] overlap within space = 0 and visibility = Pixel}} +// expected-note@+1 {{overlapping resource range here}} [RootSignature("UAV(u0, visibility = SHADER_VISIBILITY_ALL), UAV(u0, visibility = SHADER_VISIBILITY_PIXEL)")] void bad_root_signature_3() {} -// expected-error@+1 {{resource ranges u[0;0] and u[0;0] overlap within space = 0 and visibility = Pixel}} +// expected-error@+2 {{resource ranges u[0;0] and u[0;0] overlap within space = 0 and visibility = Pixel}} +// expected-note@+1 {{overlapping resource range here}} [RootSignature("UAV(u0, visibility = SHADER_VISIBILITY_PIXEL), UAV(u0, visibility = SHADER_VISIBILITY_ALL)")] void bad_root_signature_4() {} -// expected-error@+1 {{resource ranges b[0;0] and b[0;0] overlap within space = 0 and visibility = All}} +// expected-error@+2 {{resource ranges b[0;0] and b[0;0] overlap within space = 0 and visibility = All}} +// expected-note@+1 {{overlapping resource range here}} [RootSignature("RootConstants(num32BitConstants=4, b0), RootConstants(num32BitConstants=2, b0)")] void bad_root_signature_5() {} -// expected-error@+1 {{resource ranges s[3;3] and s[3;3] overlap within space = 0 and visibility = All}} +// expected-error@+2 {{resource ranges s[3;3] and s[3;3] overlap within space = 0 and visibility = All}} +// expected-note@+1 {{overlapping resource range here}} [RootSignature("StaticSampler(s3), StaticSampler(s3)")] void bad_root_signature_6() {} -// expected-error@+1 {{resource ranges t[2;5] and t[0;3] overlap within space = 0 and visibility = All}} +// expected-error@+2 {{resource ranges t[2;5] and t[0;3] overlap within space = 0 and visibility = All}} +// expected-note@+1 {{overlapping resource range here}} [RootSignature("DescriptorTable(SRV(t0, numDescriptors=4), SRV(t2, numDescriptors=4))")] void bad_root_signature_7() {} -// expected-error@+1 {{resource ranges u[2;5] and u[0;unbounded) overlap within space = 0 and visibility = Hull}} +// expected-error@+2 {{resource ranges u[2;5] and u[0;unbounded) overlap within space = 0 and visibility = Hull}} +// expected-note@+1 {{overlapping resource range here}} [RootSignature("DescriptorTable(UAV(u0, numDescriptors=unbounded), visibility = SHADER_VISIBILITY_HULL), DescriptorTable(UAV(u2, numDescriptors=4))")] void bad_root_signature_8() {} -// expected-error@+1 {{resource ranges b[0;2] and b[2;2] overlap within space = 0 and visibility = All}} +// expected-error@+2 {{resource ranges b[2;2] and b[0;2] overlap within space = 0 and visibility = All}} +// expected-note@+1 {{overlapping resource range here}} [RootSignature("RootConstants(num32BitConstants=4, b2), DescriptorTable(CBV(b0, numDescriptors=3))")] void bad_root_signature_9() {} -// expected-error@+1 {{resource ranges s[4;unbounded) and s[17;17] overlap within space = 0 and visibility = All}} +// expected-error@+2 {{resource ranges s[17;17] and s[4;unbounded) overlap within space = 0 and visibility = All}} +// expected-note@+1 {{overlapping resource range here}} [RootSignature("StaticSampler(s17), DescriptorTable(Sampler(s0, numDescriptors=3),Sampler(s4, numDescriptors=unbounded))")] void bad_root_signature_10() {} -// expected-error@+1 {{resource ranges b[45;45] and b[4;unbounded) overlap within space = 0 and visibility = Geometry}} +// expected-error@+2 {{resource ranges b[45;45] and b[4;unbounded) overlap within space = 0 and visibility = Geometry}} +// expected-note@+1 {{overlapping resource range here}} [RootSignature("DescriptorTable(CBV(b4, numDescriptors=unbounded)), CBV(b45, visibility = SHADER_VISIBILITY_GEOMETRY)")] void bad_root_signature_11() {} @@ -55,10 +68,71 @@ void bad_root_signature_11() {} " CBV(b0, numDescriptors = 8), " \ ")" -// expected-error@+1 {{resource ranges b[0;7] and b[1;2] overlap within space = 0 and visibility = All}} +// expected-error@+4 {{resource ranges b[4;7] and b[0;7] overlap within space = 0 and visibility = All}} +// expected-error@+3 {{resource ranges b[1;2] and b[0;7] overlap within space = 0 and visibility = All}} +// expected-note@+2 {{overlapping resource range here}} +// expected-note@+1 {{overlapping resource range here}} [RootSignature(ReportFirstOverlap)] void bad_root_signature_12() {} -// expected-error@+1 {{resource ranges s[2;2] and s[2;2] overlap within space = 0 and visibility = Vertex}} +// expected-error@+2 {{resource ranges s[2;2] and s[2;2] overlap within space = 0 and visibility = Vertex}} +// expected-note@+1 {{overlapping resource range here}} [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: [[@LINE-11]]:5: note: expanded from macro 'DemoNoteSourceLocations' +// CHECK-NEXT: [[@LINE-12]] | " SRV(t22, numDescriptors = 1), " +// CHECK-NEXT: | ^ +// CHECK: [[@LINE-7]]:5: note: expanded from macro 'DemoNoteSourceLocations' +// CHECK-NEXT: [[@LINE-8]] | " SRV(t17, numDescriptors = 7), " \ +// CHECK-NEXT: | ^ + +// expected-error@+2 {{resource ranges t[22;22] and t[17;23] overlap within space = 0 and visibility = All}} +// expected-note@+1 {{overlapping resource range here}} +[RootSignature(DemoNoteSourceLocations)] +void bad_root_signature_14() {} + +#define DuplicatesRootSignature \ + "CBV(b0), CBV(b0), CBV(b0), DescriptorTable(CBV(b0, numDescriptors = 2))" + +// CHECK: [[@LINE-2]]:13: note: expanded from macro 'DuplicatesRootSignature' +// CHECK-NEXT: [[@LINE-3]] | "CBV(b0), CBV(b0), CBV(b0), DescriptorTable(CBV(b0, numDescriptors = 2))" +// CHECK-NEXT: | ^ +// CHECK: [[@LINE-5]]:4: note: expanded from macro 'DuplicatesRootSignature' +// CHECK-NEXT: [[@LINE-6]] | "CBV(b0), CBV(b0), CBV(b0), DescriptorTable(CBV(b0, numDescriptors = 2))" +// CHECK-NEXT: | ^ +// CHECK: [[@LINE-8]]:22: note: expanded from macro 'DuplicatesRootSignature' +// CHECK-NEXT: [[@LINE-9]] | "CBV(b0), CBV(b0), CBV(b0), DescriptorTable(CBV(b0, numDescriptors = 2))" +// CHECK-NEXT: | ^ +// CHECK: [[@LINE-11]]:4: note: expanded from macro 'DuplicatesRootSignature' +// CHECK-NEXT: [[@LINE-12]] | "CBV(b0), CBV(b0), CBV(b0), DescriptorTable(CBV(b0, numDescriptors = 2))" +// CHECK-NEXT: | ^ +// CHECK: [[@LINE-14]]:47: note: expanded from macro 'DuplicatesRootSignature' +// CHECK-NEXT: [[@LINE-15]] | "CBV(b0), CBV(b0), CBV(b0), DescriptorTable(CBV(b0, numDescriptors = 2))" +// CHECK-NEXT: | ^ +// CHECK: [[@LINE-17]]:4: note: expanded from macro 'DuplicatesRootSignature' +// CHECK-NEXT: [[@LINE-18]] | "CBV(b0), CBV(b0), CBV(b0), DescriptorTable(CBV(b0, numDescriptors = 2))" +// CHECK-NEXT: | ^ + +// expected-error@+6 {{resource ranges b[0;0] and b[0;0] overlap within space = 0 and visibility = All}} +// expected-note@+5 {{overlapping resource range here}} +// expected-error@+4 {{resource ranges b[0;0] and b[0;0] overlap within space = 0 and visibility = All}} +// expected-note@+3 {{overlapping resource range here}} +// expected-error@+2 {{resource ranges b[0;1] and b[0;0] overlap within space = 0 and visibility = All}} +// expected-note@+1 {{overlapping resource range here}} +[RootSignature(DuplicatesRootSignature)] +void valid_root_signature_15() {} diff --git a/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp b/clang/unittests/Parse/ParseHLSLRootSignatureTest.cpp index e82dcadebba3f..5b1ab149f4497 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<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootElement> Elements; + SmallVector<RootSignatureElement> 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<DescriptorTableClause>(Elem)); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::CBuffer); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.ViewType, @@ -194,7 +195,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) { ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, DescriptorRangeFlags::DataStaticWhileSetAtExecute); - Elem = Elements[1]; + Elem = Elements[1].getElement(); ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::SRV); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.ViewType, @@ -206,7 +207,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) { ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, DescriptorRangeFlags::None); - Elem = Elements[2]; + Elem = Elements[2].getElement(); ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::Sampler); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.ViewType, @@ -219,7 +220,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) { ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, DescriptorRangeFlags::None); - Elem = Elements[3]; + Elem = Elements[3].getElement(); ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::UAV); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Reg.ViewType, @@ -239,14 +240,14 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseDTClausesTest) { ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, ValidDescriptorRangeFlags); - Elem = Elements[4]; + Elem = Elements[4].getElement(); ASSERT_TRUE(std::holds_alternative<DescriptorTable>(Elem)); ASSERT_EQ(std::get<DescriptorTable>(Elem).NumClauses, (uint32_t)4); ASSERT_EQ(std::get<DescriptorTable>(Elem).Visibility, llvm::dxbc::ShaderVisibility::Pixel); // Empty Descriptor Table - Elem = Elements[5]; + Elem = Elements[5].getElement(); ASSERT_TRUE(std::holds_alternative<DescriptorTable>(Elem)); ASSERT_EQ(std::get<DescriptorTable>(Elem).NumClauses, 0u); ASSERT_EQ(std::get<DescriptorTable>(Elem).Visibility, @@ -276,7 +277,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseStaticSamplerTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootElement> Elements; + SmallVector<RootSignatureElement> 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<StaticSampler>(Elem)); ASSERT_EQ(std::get<StaticSampler>(Elem).Reg.ViewType, RegisterType::SReg); ASSERT_EQ(std::get<StaticSampler>(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<StaticSampler>(Elem)); ASSERT_EQ(std::get<StaticSampler>(Elem).Reg.ViewType, RegisterType::SReg); ASSERT_EQ(std::get<StaticSampler>(Elem).Reg.Number, 0u); @@ -363,7 +364,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseFloatsTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootElement> Elements; + SmallVector<RootSignatureElement> 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<StaticSampler>(Elem)); ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 0.f); - Elem = Elements[1]; + Elem = Elements[1].getElement(); ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 1.f); - Elem = Elements[2]; + Elem = Elements[2].getElement(); ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, -1.f); - Elem = Elements[3]; + Elem = Elements[3].getElement(); ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 42.f); - Elem = Elements[4]; + Elem = Elements[4].getElement(); ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 4.2f); - Elem = Elements[5]; + Elem = Elements[5].getElement(); ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, -.42f); - Elem = Elements[6]; + Elem = Elements[6].getElement(); ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 420.f); - Elem = Elements[7]; + Elem = Elements[7].getElement(); ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 0.000000000042f); - Elem = Elements[8]; + Elem = Elements[8].getElement(); ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 42.f); - Elem = Elements[9]; + Elem = Elements[9].getElement(); ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 4.2f); - Elem = Elements[10]; + Elem = Elements[10].getElement(); ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 420000000000.f); - Elem = Elements[11]; + Elem = Elements[11].getElement(); ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, -2147483648.f); - Elem = Elements[12]; + Elem = Elements[12].getElement(); ASSERT_TRUE(std::holds_alternative<StaticSampler>(Elem)); ASSERT_FLOAT_EQ(std::get<StaticSampler>(Elem).MipLODBias, 2147483648.f); @@ -440,7 +441,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidSamplerFlagsTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootElement> Elements; + SmallVector<RootSignatureElement> 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<DescriptorTableClause>(Elem)); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::Sampler); auto ValidSamplerFlags = @@ -473,7 +474,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootConsantsTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootConstants>(Elem)); ASSERT_EQ(std::get<RootConstants>(Elem).Num32BitConstants, 1u); ASSERT_EQ(std::get<RootConstants>(Elem).Reg.ViewType, RegisterType::BReg); @@ -493,7 +494,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootConsantsTest) { ASSERT_EQ(std::get<RootConstants>(Elem).Visibility, llvm::dxbc::ShaderVisibility::All); - Elem = Elements[1]; + Elem = Elements[1].getElement(); ASSERT_TRUE(std::holds_alternative<RootConstants>(Elem)); ASSERT_EQ(std::get<RootConstants>(Elem).Num32BitConstants, 4294967295u); ASSERT_EQ(std::get<RootConstants>(Elem).Reg.ViewType, RegisterType::BReg); @@ -532,7 +533,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootFlagsTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootFlags>(Elem)); ASSERT_EQ(std::get<RootFlags>(Elem), RootFlags::None); - Elem = Elements[1]; + Elem = Elements[1].getElement(); ASSERT_TRUE(std::holds_alternative<RootFlags>(Elem)); ASSERT_EQ(std::get<RootFlags>(Elem), RootFlags::None); - Elem = Elements[2]; + Elem = Elements[2].getElement(); ASSERT_TRUE(std::holds_alternative<RootFlags>(Elem)); auto ValidRootFlags = RootFlags::AllowInputAssemblerInputLayout | RootFlags::DenyVertexShaderRootAccess | @@ -587,7 +588,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootDescriptor>(Elem)); ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, DescriptorType::CBuffer); ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.ViewType, RegisterType::BReg); @@ -609,7 +610,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) { ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, RootDescriptorFlags::DataStaticWhileSetAtExecute); - Elem = Elements[1]; + Elem = Elements[1].getElement(); ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem)); ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, DescriptorType::SRV); ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.ViewType, RegisterType::TReg); @@ -623,7 +624,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) { RootDescriptorFlags::DataStatic; ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, ValidRootDescriptorFlags); - Elem = Elements[2]; + Elem = Elements[2].getElement(); ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem)); ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, DescriptorType::UAV); ASSERT_EQ(std::get<RootDescriptor>(Elem).Reg.ViewType, RegisterType::UReg); @@ -636,7 +637,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidParseRootDescriptorsTest) { ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, RootDescriptorFlags::DataVolatile); - Elem = Elements[3]; + Elem = Elements[3].getElement(); 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); @@ -663,7 +664,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidTrailingCommaTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootElement> Elements; + SmallVector<RootSignatureElement> Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -696,7 +697,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidVersion10Test) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootElement> Elements; + SmallVector<RootSignatureElement> Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_0, Elements, Signature, *PP); @@ -706,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<RootDescriptor>(Elem)); ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, DescriptorType::CBuffer); ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, DefRootDescriptorFlag); - Elem = Elements[1]; + Elem = Elements[1].getElement(); ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem)); ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, DescriptorType::SRV); ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, DefRootDescriptorFlag); - Elem = Elements[2]; + Elem = Elements[2].getElement(); ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem)); ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, DescriptorType::UAV); ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, DefRootDescriptorFlag); @@ -724,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<DescriptorTableClause>(Elem)); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::CBuffer); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, ValidNonSamplerFlags); - Elem = Elements[4]; + Elem = Elements[4].getElement(); ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::SRV); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, ValidNonSamplerFlags); - Elem = Elements[5]; + Elem = Elements[5].getElement(); ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::UAV); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, ValidNonSamplerFlags); - Elem = Elements[6]; + Elem = Elements[6].getElement(); ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::Sampler); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, @@ -769,7 +770,7 @@ TEST_F(ParseHLSLRootSignatureTest, ValidVersion11Test) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootElement> Elements; + SmallVector<RootSignatureElement> Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -778,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<RootDescriptor>(Elem)); ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, DescriptorType::CBuffer); ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, llvm::dxbc::RootDescriptorFlags::DataStaticWhileSetAtExecute); - Elem = Elements[1]; + Elem = Elements[1].getElement(); ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem)); ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, DescriptorType::SRV); ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, llvm::dxbc::RootDescriptorFlags::DataStaticWhileSetAtExecute); - Elem = Elements[2]; + Elem = Elements[2].getElement(); ASSERT_TRUE(std::holds_alternative<RootDescriptor>(Elem)); ASSERT_EQ(std::get<RootDescriptor>(Elem).Type, DescriptorType::UAV); ASSERT_EQ(std::get<RootDescriptor>(Elem).Flags, llvm::dxbc::RootDescriptorFlags::DataVolatile); - Elem = Elements[3]; + Elem = Elements[3].getElement(); ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::CBuffer); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, llvm::dxbc::DescriptorRangeFlags::DataStaticWhileSetAtExecute); - Elem = Elements[4]; + Elem = Elements[4].getElement(); ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::SRV); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, llvm::dxbc::DescriptorRangeFlags::DataStaticWhileSetAtExecute); - Elem = Elements[5]; + Elem = Elements[5].getElement(); ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::UAV); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, llvm::dxbc::DescriptorRangeFlags::DataVolatile); - Elem = Elements[6]; + Elem = Elements[6].getElement(); ASSERT_TRUE(std::holds_alternative<DescriptorTableClause>(Elem)); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Type, ClauseType::Sampler); ASSERT_EQ(std::get<DescriptorTableClause>(Elem).Flags, @@ -837,7 +838,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidParseUnexpectedTokenTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootElement> Elements; + SmallVector<RootSignatureElement> 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<RootElement> Elements; + SmallVector<RootSignatureElement> Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -1252,7 +1253,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRootElementMissingCommaTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootElement> Elements; + SmallVector<RootSignatureElement> Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -1279,7 +1280,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidDescriptorTableMissingCommaTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootElement> Elements; + SmallVector<RootSignatureElement> Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -1306,7 +1307,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRootConstantParamsCommaTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootElement> Elements; + SmallVector<RootSignatureElement> Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -1333,7 +1334,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidRootDescriptorParamsCommaTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootElement> Elements; + SmallVector<RootSignatureElement> Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -1362,7 +1363,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidDescriptorClauseParamsCommaTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootElement> Elements; + SmallVector<RootSignatureElement> Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); @@ -1389,7 +1390,7 @@ TEST_F(ParseHLSLRootSignatureTest, InvalidStaticSamplerCommaTest) { TrivialModuleLoader ModLoader; auto PP = createPP(Source, ModLoader); - SmallVector<RootElement> Elements; + SmallVector<RootSignatureElement> Elements; hlsl::RootSignatureParser Parser(RootSignatureVersion::V1_1, Elements, Signature, *PP); diff --git a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h index ea63a253b6661..e9bdcee0d72df 100644 --- a/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h +++ b/llvm/include/llvm/Frontend/HLSL/RootSignatureValidations.h @@ -51,6 +51,18 @@ struct RangeInfo { llvm::dxil::ResourceClass Class; uint32_t Space; llvm::dxbc::ShaderVisibility Visibility; + + bool operator==(const RangeInfo &RHS) const { + return std::tie(LowerBound, UpperBound, Class, Space, Visibility) == + std::tie(RHS.LowerBound, RHS.UpperBound, RHS.Class, RHS.Space, + RHS.Visibility); + } + + bool operator<(const RangeInfo &RHS) const { + return std::tie(Class, Space, LowerBound, UpperBound, Visibility) < + std::tie(RHS.Class, RHS.Space, RHS.LowerBound, RHS.UpperBound, + RHS.Visibility); + } }; class ResourceRange { @@ -125,8 +137,8 @@ struct OverlappingRanges { /// - RangeInfo will retain the interval, ResourceClass, Space and Visibility /// - It will also contain an index so that it can be associated to /// additional diagnostic information -/// 2. Sort the RangeInfo's such that they are grouped together by -/// ResourceClass and Space +/// 2. The user is required to sort the RangeInfo's such that they are grouped +/// together by ResourceClass and Space /// 3. Iterate through the collected RangeInfos by their groups /// - For each group we will have a ResourceRange for each visibility /// - As we iterate through we will: @@ -134,7 +146,7 @@ struct OverlappingRanges { /// ResourceRange /// B: Check for overlap with any overlapping Visibility ResourceRange llvm::SmallVector<OverlappingRanges> -findOverlappingRanges(llvm::SmallVector<RangeInfo> &Infos); +findOverlappingRanges(ArrayRef<RangeInfo> Infos); } // namespace rootsig } // namespace hlsl diff --git a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp index 278c42e97667b..f11c7d2033bfb 100644 --- a/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp +++ b/llvm/lib/Frontend/HLSL/RootSignatureValidations.cpp @@ -244,17 +244,15 @@ std::optional<const RangeInfo *> ResourceRange::insert(const RangeInfo &Info) { } llvm::SmallVector<OverlappingRanges> -findOverlappingRanges(llvm::SmallVector<RangeInfo> &Infos) { - // 1. The user has provided the corresponding range information +findOverlappingRanges(ArrayRef<RangeInfo> Infos) { + // It is expected that Infos is filled with valid RangeInfos and that + // they are sorted with respect to the RangeInfo <operator + assert(llvm::is_sorted(Infos) && "Ranges must be sorted"); + llvm::SmallVector<OverlappingRanges> Overlaps; using GroupT = std::pair<dxil::ResourceClass, /*Space*/ uint32_t>; - // 2. Sort the RangeInfo's by their GroupT to form groupings - std::sort(Infos.begin(), Infos.end(), [](RangeInfo A, RangeInfo B) { - return std::tie(A.Class, A.Space) < std::tie(B.Class, B.Space); - }); - - // 3. First we will init our state to track: + // First we will init our state to track: if (Infos.size() == 0) return Overlaps; // No ranges to overlap GroupT CurGroup = {Infos[0].Class, Infos[0].Space}; @@ -278,7 +276,7 @@ findOverlappingRanges(llvm::SmallVector<RangeInfo> &Infos) { Range.clear(); }; - // 3: Iterate through collected RangeInfos + // Iterate through collected RangeInfos for (const RangeInfo &Info : Infos) { GroupT InfoGroup = {Info.Class, Info.Space}; // Reset our ResourceRanges when we enter a new group @@ -287,12 +285,12 @@ findOverlappingRanges(llvm::SmallVector<RangeInfo> &Infos) { CurGroup = InfoGroup; } - // 3A: Insert range info into corresponding Visibility ResourceRange + // Insert range info into corresponding Visibility ResourceRange ResourceRange &VisRange = Ranges[llvm::to_underlying(Info.Visibility)]; if (std::optional<const RangeInfo *> Overlapping = VisRange.insert(Info)) Overlaps.push_back(OverlappingRanges(&Info, Overlapping.value())); - // 3B: Check for overlap in all overlapping Visibility ResourceRanges + // Check for overlap in all overlapping Visibility ResourceRanges // // If the range that we are inserting has ShaderVisiblity::All it needs to // check for an overlap in all other visibility types as well. _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
