1 //===--- ParseHLSL.cpp - HLSL-specific parsing support --------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 // 9 // This file implements the parsing logic for HLSL language features. 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "clang/AST/Attr.h" 14 #include "clang/Basic/AttributeCommonInfo.h" 15 #include "clang/Parse/ParseDiagnostic.h" 16 #include "clang/Parse/Parser.h" 17 #include "clang/Parse/RAIIObjectsForParser.h" 18 19 using namespace clang; 20 21 static bool validateDeclsInsideHLSLBuffer(Parser::DeclGroupPtrTy DG, 22 SourceLocation BufferLoc, 23 bool IsCBuffer, Parser &P) { 24 // The parse is failed, just return false. 25 if (!DG) 26 return false; 27 DeclGroupRef Decls = DG.get(); 28 bool IsValid = true; 29 // Only allow function, variable, record decls inside HLSLBuffer. 30 for (DeclGroupRef::iterator I = Decls.begin(), E = Decls.end(); I != E; ++I) { 31 Decl *D = *I; 32 if (isa<CXXRecordDecl, RecordDecl, FunctionDecl, VarDecl>(D)) 33 continue; 34 35 // FIXME: support nested HLSLBuffer and namespace inside HLSLBuffer. 36 if (isa<HLSLBufferDecl, NamespaceDecl>(D)) { 37 P.Diag(D->getLocation(), diag::err_invalid_declaration_in_hlsl_buffer) 38 << IsCBuffer; 39 IsValid = false; 40 continue; 41 } 42 43 IsValid = false; 44 P.Diag(D->getLocation(), diag::err_invalid_declaration_in_hlsl_buffer) 45 << IsCBuffer; 46 } 47 return IsValid; 48 } 49 50 Decl *Parser::ParseHLSLBuffer(SourceLocation &DeclEnd) { 51 assert((Tok.is(tok::kw_cbuffer) || Tok.is(tok::kw_tbuffer)) && 52 "Not a cbuffer or tbuffer!"); 53 bool IsCBuffer = Tok.is(tok::kw_cbuffer); 54 SourceLocation BufferLoc = ConsumeToken(); // Eat the 'cbuffer' or 'tbuffer'. 55 56 if (!Tok.is(tok::identifier)) { 57 Diag(Tok, diag::err_expected) << tok::identifier; 58 return nullptr; 59 } 60 61 IdentifierInfo *Identifier = Tok.getIdentifierInfo(); 62 SourceLocation IdentifierLoc = ConsumeToken(); 63 64 ParsedAttributes Attrs(AttrFactory); 65 MaybeParseHLSLSemantics(Attrs, nullptr); 66 67 ParseScope BufferScope(this, Scope::DeclScope); 68 BalancedDelimiterTracker T(*this, tok::l_brace); 69 if (T.consumeOpen()) { 70 Diag(Tok, diag::err_expected) << tok::l_brace; 71 return nullptr; 72 } 73 74 Decl *D = Actions.ActOnStartHLSLBuffer(getCurScope(), IsCBuffer, BufferLoc, 75 Identifier, IdentifierLoc, 76 T.getOpenLocation()); 77 78 while (Tok.isNot(tok::r_brace) && Tok.isNot(tok::eof)) { 79 // FIXME: support attribute on constants inside cbuffer/tbuffer. 80 ParsedAttributes DeclAttrs(AttrFactory); 81 ParsedAttributes EmptyDeclSpecAttrs(AttrFactory); 82 83 DeclGroupPtrTy Result = 84 ParseExternalDeclaration(DeclAttrs, EmptyDeclSpecAttrs); 85 if (!validateDeclsInsideHLSLBuffer(Result, IdentifierLoc, IsCBuffer, 86 *this)) { 87 T.skipToEnd(); 88 DeclEnd = T.getCloseLocation(); 89 BufferScope.Exit(); 90 Actions.ActOnFinishHLSLBuffer(D, DeclEnd); 91 return nullptr; 92 } 93 } 94 95 T.consumeClose(); 96 DeclEnd = T.getCloseLocation(); 97 BufferScope.Exit(); 98 Actions.ActOnFinishHLSLBuffer(D, DeclEnd); 99 100 Actions.ProcessDeclAttributeList(Actions.CurScope, D, Attrs); 101 return D; 102 } 103 104 static void fixSeparateAttrArgAndNumber(StringRef ArgStr, SourceLocation ArgLoc, 105 Token Tok, ArgsVector &ArgExprs, 106 Parser &P, ASTContext &Ctx, 107 Preprocessor &PP) { 108 StringRef Num = StringRef(Tok.getLiteralData(), Tok.getLength()); 109 SourceLocation EndNumLoc = Tok.getEndLoc(); 110 111 P.ConsumeToken(); // consume constant. 112 std::string FixedArg = ArgStr.str() + Num.str(); 113 P.Diag(ArgLoc, diag::err_hlsl_separate_attr_arg_and_number) 114 << FixedArg 115 << FixItHint::CreateReplacement(SourceRange(ArgLoc, EndNumLoc), FixedArg); 116 ArgsUnion &Slot = ArgExprs.back(); 117 Slot = IdentifierLoc::create(Ctx, ArgLoc, PP.getIdentifierInfo(FixedArg)); 118 } 119 120 void Parser::ParseHLSLSemantics(ParsedAttributes &Attrs, 121 SourceLocation *EndLoc) { 122 // FIXME: HLSLSemantic is shared for Semantic and resource binding which is 123 // confusing. Need a better name to avoid misunderstanding. Issue 124 // https://github.com/llvm/llvm-project/issues/57882 125 assert(Tok.is(tok::colon) && "Not a HLSL Semantic"); 126 ConsumeToken(); 127 128 IdentifierInfo *II = nullptr; 129 if (Tok.is(tok::kw_register)) 130 II = PP.getIdentifierInfo("register"); 131 else if (Tok.is(tok::identifier)) 132 II = Tok.getIdentifierInfo(); 133 134 if (!II) { 135 Diag(Tok.getLocation(), diag::err_expected_semantic_identifier); 136 return; 137 } 138 139 SourceLocation Loc = ConsumeToken(); 140 if (EndLoc) 141 *EndLoc = Tok.getLocation(); 142 ParsedAttr::Kind AttrKind = 143 ParsedAttr::getParsedKind(II, nullptr, ParsedAttr::AS_HLSLSemantic); 144 145 ArgsVector ArgExprs; 146 switch (AttrKind) { 147 case ParsedAttr::AT_HLSLResourceBinding: { 148 if (ExpectAndConsume(tok::l_paren, diag::err_expected_lparen_after)) { 149 SkipUntil(tok::r_paren, StopAtSemi); // skip through ) 150 return; 151 } 152 if (!Tok.is(tok::identifier)) { 153 Diag(Tok.getLocation(), diag::err_expected) << tok::identifier; 154 SkipUntil(tok::r_paren, StopAtSemi); // skip through ) 155 return; 156 } 157 StringRef SlotStr = Tok.getIdentifierInfo()->getName(); 158 SourceLocation SlotLoc = Tok.getLocation(); 159 ArgExprs.push_back(ParseIdentifierLoc()); 160 161 // Add numeric_constant for fix-it. 162 if (SlotStr.size() == 1 && Tok.is(tok::numeric_constant)) 163 fixSeparateAttrArgAndNumber(SlotStr, SlotLoc, Tok, ArgExprs, *this, 164 Actions.Context, PP); 165 166 if (Tok.is(tok::comma)) { 167 ConsumeToken(); // consume comma 168 if (!Tok.is(tok::identifier)) { 169 Diag(Tok.getLocation(), diag::err_expected) << tok::identifier; 170 SkipUntil(tok::r_paren, StopAtSemi); // skip through ) 171 return; 172 } 173 StringRef SpaceStr = Tok.getIdentifierInfo()->getName(); 174 SourceLocation SpaceLoc = Tok.getLocation(); 175 ArgExprs.push_back(ParseIdentifierLoc()); 176 177 // Add numeric_constant for fix-it. 178 if (SpaceStr.equals("space") && Tok.is(tok::numeric_constant)) 179 fixSeparateAttrArgAndNumber(SpaceStr, SpaceLoc, Tok, ArgExprs, *this, 180 Actions.Context, PP); 181 } 182 if (ExpectAndConsume(tok::r_paren, diag::err_expected)) { 183 SkipUntil(tok::r_paren, StopAtSemi); // skip through ) 184 return; 185 } 186 } break; 187 case ParsedAttr::UnknownAttribute: 188 Diag(Loc, diag::err_unknown_hlsl_semantic) << II; 189 return; 190 case ParsedAttr::AT_HLSLSV_GroupIndex: 191 case ParsedAttr::AT_HLSLSV_DispatchThreadID: 192 break; 193 default: 194 llvm_unreachable("invalid HLSL Semantic"); 195 break; 196 } 197 198 Attrs.addNew(II, Loc, nullptr, SourceLocation(), ArgExprs.data(), 199 ArgExprs.size(), ParsedAttr::AS_HLSLSemantic); 200 } 201