1 //===--- ParseOpenMP.cpp - OpenMP directives parsing ----------------------===// 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 /// \file 9 /// This file implements parsing of all OpenMP directives and clauses. 10 /// 11 //===----------------------------------------------------------------------===// 12 13 #include "clang/AST/ASTContext.h" 14 #include "clang/AST/OpenMPClause.h" 15 #include "clang/AST/StmtOpenMP.h" 16 #include "clang/Basic/OpenMPKinds.h" 17 #include "clang/Basic/TargetInfo.h" 18 #include "clang/Basic/TokenKinds.h" 19 #include "clang/Parse/ParseDiagnostic.h" 20 #include "clang/Parse/Parser.h" 21 #include "clang/Parse/RAIIObjectsForParser.h" 22 #include "clang/Sema/Scope.h" 23 #include "llvm/ADT/PointerIntPair.h" 24 #include "llvm/ADT/StringSwitch.h" 25 #include "llvm/ADT/UniqueVector.h" 26 #include "llvm/Frontend/OpenMP/OMPContext.h" 27 28 using namespace clang; 29 using namespace llvm::omp; 30 31 //===----------------------------------------------------------------------===// 32 // OpenMP declarative directives. 33 //===----------------------------------------------------------------------===// 34 35 namespace { 36 enum OpenMPDirectiveKindEx { 37 OMPD_cancellation = llvm::omp::Directive_enumSize + 1, 38 OMPD_data, 39 OMPD_declare, 40 OMPD_end, 41 OMPD_end_declare, 42 OMPD_enter, 43 OMPD_exit, 44 OMPD_point, 45 OMPD_reduction, 46 OMPD_target_enter, 47 OMPD_target_exit, 48 OMPD_update, 49 OMPD_distribute_parallel, 50 OMPD_teams_distribute_parallel, 51 OMPD_target_teams_distribute_parallel, 52 OMPD_mapper, 53 OMPD_variant, 54 OMPD_begin, 55 OMPD_begin_declare, 56 }; 57 58 // Helper to unify the enum class OpenMPDirectiveKind with its extension 59 // the OpenMPDirectiveKindEx enum which allows to use them together as if they 60 // are unsigned values. 61 struct OpenMPDirectiveKindExWrapper { 62 OpenMPDirectiveKindExWrapper(unsigned Value) : Value(Value) {} 63 OpenMPDirectiveKindExWrapper(OpenMPDirectiveKind DK) : Value(unsigned(DK)) {} 64 bool operator==(OpenMPDirectiveKindExWrapper V) const { 65 return Value == V.Value; 66 } 67 bool operator!=(OpenMPDirectiveKindExWrapper V) const { 68 return Value != V.Value; 69 } 70 bool operator==(OpenMPDirectiveKind V) const { return Value == unsigned(V); } 71 bool operator!=(OpenMPDirectiveKind V) const { return Value != unsigned(V); } 72 bool operator<(OpenMPDirectiveKind V) const { return Value < unsigned(V); } 73 operator unsigned() const { return Value; } 74 operator OpenMPDirectiveKind() const { return OpenMPDirectiveKind(Value); } 75 unsigned Value; 76 }; 77 78 class DeclDirectiveListParserHelper final { 79 SmallVector<Expr *, 4> Identifiers; 80 Parser *P; 81 OpenMPDirectiveKind Kind; 82 83 public: 84 DeclDirectiveListParserHelper(Parser *P, OpenMPDirectiveKind Kind) 85 : P(P), Kind(Kind) {} 86 void operator()(CXXScopeSpec &SS, DeclarationNameInfo NameInfo) { 87 ExprResult Res = P->getActions().ActOnOpenMPIdExpression( 88 P->getCurScope(), SS, NameInfo, Kind); 89 if (Res.isUsable()) 90 Identifiers.push_back(Res.get()); 91 } 92 llvm::ArrayRef<Expr *> getIdentifiers() const { return Identifiers; } 93 }; 94 } // namespace 95 96 // Map token string to extended OMP token kind that are 97 // OpenMPDirectiveKind + OpenMPDirectiveKindEx. 98 static unsigned getOpenMPDirectiveKindEx(StringRef S) { 99 OpenMPDirectiveKindExWrapper DKind = getOpenMPDirectiveKind(S); 100 if (DKind != OMPD_unknown) 101 return DKind; 102 103 return llvm::StringSwitch<OpenMPDirectiveKindExWrapper>(S) 104 .Case("cancellation", OMPD_cancellation) 105 .Case("data", OMPD_data) 106 .Case("declare", OMPD_declare) 107 .Case("end", OMPD_end) 108 .Case("enter", OMPD_enter) 109 .Case("exit", OMPD_exit) 110 .Case("point", OMPD_point) 111 .Case("reduction", OMPD_reduction) 112 .Case("update", OMPD_update) 113 .Case("mapper", OMPD_mapper) 114 .Case("variant", OMPD_variant) 115 .Case("begin", OMPD_begin) 116 .Default(OMPD_unknown); 117 } 118 119 static OpenMPDirectiveKindExWrapper parseOpenMPDirectiveKind(Parser &P) { 120 // Array of foldings: F[i][0] F[i][1] ===> F[i][2]. 121 // E.g.: OMPD_for OMPD_simd ===> OMPD_for_simd 122 // TODO: add other combined directives in topological order. 123 static const OpenMPDirectiveKindExWrapper F[][3] = { 124 {OMPD_begin, OMPD_declare, OMPD_begin_declare}, 125 {OMPD_begin, OMPD_assumes, OMPD_begin_assumes}, 126 {OMPD_end, OMPD_declare, OMPD_end_declare}, 127 {OMPD_end, OMPD_assumes, OMPD_end_assumes}, 128 {OMPD_cancellation, OMPD_point, OMPD_cancellation_point}, 129 {OMPD_declare, OMPD_reduction, OMPD_declare_reduction}, 130 {OMPD_declare, OMPD_mapper, OMPD_declare_mapper}, 131 {OMPD_declare, OMPD_simd, OMPD_declare_simd}, 132 {OMPD_declare, OMPD_target, OMPD_declare_target}, 133 {OMPD_declare, OMPD_variant, OMPD_declare_variant}, 134 {OMPD_begin_declare, OMPD_variant, OMPD_begin_declare_variant}, 135 {OMPD_end_declare, OMPD_variant, OMPD_end_declare_variant}, 136 {OMPD_distribute, OMPD_parallel, OMPD_distribute_parallel}, 137 {OMPD_distribute_parallel, OMPD_for, OMPD_distribute_parallel_for}, 138 {OMPD_distribute_parallel_for, OMPD_simd, 139 OMPD_distribute_parallel_for_simd}, 140 {OMPD_distribute, OMPD_simd, OMPD_distribute_simd}, 141 {OMPD_end_declare, OMPD_target, OMPD_end_declare_target}, 142 {OMPD_target, OMPD_data, OMPD_target_data}, 143 {OMPD_target, OMPD_enter, OMPD_target_enter}, 144 {OMPD_target, OMPD_exit, OMPD_target_exit}, 145 {OMPD_target, OMPD_update, OMPD_target_update}, 146 {OMPD_target_enter, OMPD_data, OMPD_target_enter_data}, 147 {OMPD_target_exit, OMPD_data, OMPD_target_exit_data}, 148 {OMPD_for, OMPD_simd, OMPD_for_simd}, 149 {OMPD_parallel, OMPD_for, OMPD_parallel_for}, 150 {OMPD_parallel_for, OMPD_simd, OMPD_parallel_for_simd}, 151 {OMPD_parallel, OMPD_sections, OMPD_parallel_sections}, 152 {OMPD_taskloop, OMPD_simd, OMPD_taskloop_simd}, 153 {OMPD_target, OMPD_parallel, OMPD_target_parallel}, 154 {OMPD_target, OMPD_simd, OMPD_target_simd}, 155 {OMPD_target_parallel, OMPD_for, OMPD_target_parallel_for}, 156 {OMPD_target_parallel_for, OMPD_simd, OMPD_target_parallel_for_simd}, 157 {OMPD_teams, OMPD_distribute, OMPD_teams_distribute}, 158 {OMPD_teams_distribute, OMPD_simd, OMPD_teams_distribute_simd}, 159 {OMPD_teams_distribute, OMPD_parallel, OMPD_teams_distribute_parallel}, 160 {OMPD_teams_distribute_parallel, OMPD_for, 161 OMPD_teams_distribute_parallel_for}, 162 {OMPD_teams_distribute_parallel_for, OMPD_simd, 163 OMPD_teams_distribute_parallel_for_simd}, 164 {OMPD_target, OMPD_teams, OMPD_target_teams}, 165 {OMPD_target_teams, OMPD_distribute, OMPD_target_teams_distribute}, 166 {OMPD_target_teams_distribute, OMPD_parallel, 167 OMPD_target_teams_distribute_parallel}, 168 {OMPD_target_teams_distribute, OMPD_simd, 169 OMPD_target_teams_distribute_simd}, 170 {OMPD_target_teams_distribute_parallel, OMPD_for, 171 OMPD_target_teams_distribute_parallel_for}, 172 {OMPD_target_teams_distribute_parallel_for, OMPD_simd, 173 OMPD_target_teams_distribute_parallel_for_simd}, 174 {OMPD_master, OMPD_taskloop, OMPD_master_taskloop}, 175 {OMPD_master_taskloop, OMPD_simd, OMPD_master_taskloop_simd}, 176 {OMPD_parallel, OMPD_master, OMPD_parallel_master}, 177 {OMPD_parallel_master, OMPD_taskloop, OMPD_parallel_master_taskloop}, 178 {OMPD_parallel_master_taskloop, OMPD_simd, 179 OMPD_parallel_master_taskloop_simd}}; 180 enum { CancellationPoint = 0, DeclareReduction = 1, TargetData = 2 }; 181 Token Tok = P.getCurToken(); 182 OpenMPDirectiveKindExWrapper DKind = 183 Tok.isAnnotation() 184 ? static_cast<unsigned>(OMPD_unknown) 185 : getOpenMPDirectiveKindEx(P.getPreprocessor().getSpelling(Tok)); 186 if (DKind == OMPD_unknown) 187 return OMPD_unknown; 188 189 for (unsigned I = 0; I < llvm::array_lengthof(F); ++I) { 190 if (DKind != F[I][0]) 191 continue; 192 193 Tok = P.getPreprocessor().LookAhead(0); 194 OpenMPDirectiveKindExWrapper SDKind = 195 Tok.isAnnotation() 196 ? static_cast<unsigned>(OMPD_unknown) 197 : getOpenMPDirectiveKindEx(P.getPreprocessor().getSpelling(Tok)); 198 if (SDKind == OMPD_unknown) 199 continue; 200 201 if (SDKind == F[I][1]) { 202 P.ConsumeToken(); 203 DKind = F[I][2]; 204 } 205 } 206 return unsigned(DKind) < llvm::omp::Directive_enumSize 207 ? static_cast<OpenMPDirectiveKind>(DKind) 208 : OMPD_unknown; 209 } 210 211 static DeclarationName parseOpenMPReductionId(Parser &P) { 212 Token Tok = P.getCurToken(); 213 Sema &Actions = P.getActions(); 214 OverloadedOperatorKind OOK = OO_None; 215 // Allow to use 'operator' keyword for C++ operators 216 bool WithOperator = false; 217 if (Tok.is(tok::kw_operator)) { 218 P.ConsumeToken(); 219 Tok = P.getCurToken(); 220 WithOperator = true; 221 } 222 switch (Tok.getKind()) { 223 case tok::plus: // '+' 224 OOK = OO_Plus; 225 break; 226 case tok::minus: // '-' 227 OOK = OO_Minus; 228 break; 229 case tok::star: // '*' 230 OOK = OO_Star; 231 break; 232 case tok::amp: // '&' 233 OOK = OO_Amp; 234 break; 235 case tok::pipe: // '|' 236 OOK = OO_Pipe; 237 break; 238 case tok::caret: // '^' 239 OOK = OO_Caret; 240 break; 241 case tok::ampamp: // '&&' 242 OOK = OO_AmpAmp; 243 break; 244 case tok::pipepipe: // '||' 245 OOK = OO_PipePipe; 246 break; 247 case tok::identifier: // identifier 248 if (!WithOperator) 249 break; 250 LLVM_FALLTHROUGH; 251 default: 252 P.Diag(Tok.getLocation(), diag::err_omp_expected_reduction_identifier); 253 P.SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end, 254 Parser::StopBeforeMatch); 255 return DeclarationName(); 256 } 257 P.ConsumeToken(); 258 auto &DeclNames = Actions.getASTContext().DeclarationNames; 259 return OOK == OO_None ? DeclNames.getIdentifier(Tok.getIdentifierInfo()) 260 : DeclNames.getCXXOperatorName(OOK); 261 } 262 263 /// Parse 'omp declare reduction' construct. 264 /// 265 /// declare-reduction-directive: 266 /// annot_pragma_openmp 'declare' 'reduction' 267 /// '(' <reduction_id> ':' <type> {',' <type>} ':' <expression> ')' 268 /// ['initializer' '(' ('omp_priv' '=' <expression>)|<function_call> ')'] 269 /// annot_pragma_openmp_end 270 /// <reduction_id> is either a base language identifier or one of the following 271 /// operators: '+', '-', '*', '&', '|', '^', '&&' and '||'. 272 /// 273 Parser::DeclGroupPtrTy 274 Parser::ParseOpenMPDeclareReductionDirective(AccessSpecifier AS) { 275 // Parse '('. 276 BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); 277 if (T.expectAndConsume( 278 diag::err_expected_lparen_after, 279 getOpenMPDirectiveName(OMPD_declare_reduction).data())) { 280 SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch); 281 return DeclGroupPtrTy(); 282 } 283 284 DeclarationName Name = parseOpenMPReductionId(*this); 285 if (Name.isEmpty() && Tok.is(tok::annot_pragma_openmp_end)) 286 return DeclGroupPtrTy(); 287 288 // Consume ':'. 289 bool IsCorrect = !ExpectAndConsume(tok::colon); 290 291 if (!IsCorrect && Tok.is(tok::annot_pragma_openmp_end)) 292 return DeclGroupPtrTy(); 293 294 IsCorrect = IsCorrect && !Name.isEmpty(); 295 296 if (Tok.is(tok::colon) || Tok.is(tok::annot_pragma_openmp_end)) { 297 Diag(Tok.getLocation(), diag::err_expected_type); 298 IsCorrect = false; 299 } 300 301 if (!IsCorrect && Tok.is(tok::annot_pragma_openmp_end)) 302 return DeclGroupPtrTy(); 303 304 SmallVector<std::pair<QualType, SourceLocation>, 8> ReductionTypes; 305 // Parse list of types until ':' token. 306 do { 307 ColonProtectionRAIIObject ColonRAII(*this); 308 SourceRange Range; 309 TypeResult TR = ParseTypeName(&Range, DeclaratorContext::Prototype, AS); 310 if (TR.isUsable()) { 311 QualType ReductionType = 312 Actions.ActOnOpenMPDeclareReductionType(Range.getBegin(), TR); 313 if (!ReductionType.isNull()) { 314 ReductionTypes.push_back( 315 std::make_pair(ReductionType, Range.getBegin())); 316 } 317 } else { 318 SkipUntil(tok::comma, tok::colon, tok::annot_pragma_openmp_end, 319 StopBeforeMatch); 320 } 321 322 if (Tok.is(tok::colon) || Tok.is(tok::annot_pragma_openmp_end)) 323 break; 324 325 // Consume ','. 326 if (ExpectAndConsume(tok::comma)) { 327 IsCorrect = false; 328 if (Tok.is(tok::annot_pragma_openmp_end)) { 329 Diag(Tok.getLocation(), diag::err_expected_type); 330 return DeclGroupPtrTy(); 331 } 332 } 333 } while (Tok.isNot(tok::annot_pragma_openmp_end)); 334 335 if (ReductionTypes.empty()) { 336 SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch); 337 return DeclGroupPtrTy(); 338 } 339 340 if (!IsCorrect && Tok.is(tok::annot_pragma_openmp_end)) 341 return DeclGroupPtrTy(); 342 343 // Consume ':'. 344 if (ExpectAndConsume(tok::colon)) 345 IsCorrect = false; 346 347 if (Tok.is(tok::annot_pragma_openmp_end)) { 348 Diag(Tok.getLocation(), diag::err_expected_expression); 349 return DeclGroupPtrTy(); 350 } 351 352 DeclGroupPtrTy DRD = Actions.ActOnOpenMPDeclareReductionDirectiveStart( 353 getCurScope(), Actions.getCurLexicalContext(), Name, ReductionTypes, AS); 354 355 // Parse <combiner> expression and then parse initializer if any for each 356 // correct type. 357 unsigned I = 0, E = ReductionTypes.size(); 358 for (Decl *D : DRD.get()) { 359 TentativeParsingAction TPA(*this); 360 ParseScope OMPDRScope(this, Scope::FnScope | Scope::DeclScope | 361 Scope::CompoundStmtScope | 362 Scope::OpenMPDirectiveScope); 363 // Parse <combiner> expression. 364 Actions.ActOnOpenMPDeclareReductionCombinerStart(getCurScope(), D); 365 ExprResult CombinerResult = Actions.ActOnFinishFullExpr( 366 ParseExpression().get(), D->getLocation(), /*DiscardedValue*/ false); 367 Actions.ActOnOpenMPDeclareReductionCombinerEnd(D, CombinerResult.get()); 368 369 if (CombinerResult.isInvalid() && Tok.isNot(tok::r_paren) && 370 Tok.isNot(tok::annot_pragma_openmp_end)) { 371 TPA.Commit(); 372 IsCorrect = false; 373 break; 374 } 375 IsCorrect = !T.consumeClose() && IsCorrect && CombinerResult.isUsable(); 376 ExprResult InitializerResult; 377 if (Tok.isNot(tok::annot_pragma_openmp_end)) { 378 // Parse <initializer> expression. 379 if (Tok.is(tok::identifier) && 380 Tok.getIdentifierInfo()->isStr("initializer")) { 381 ConsumeToken(); 382 } else { 383 Diag(Tok.getLocation(), diag::err_expected) << "'initializer'"; 384 TPA.Commit(); 385 IsCorrect = false; 386 break; 387 } 388 // Parse '('. 389 BalancedDelimiterTracker T(*this, tok::l_paren, 390 tok::annot_pragma_openmp_end); 391 IsCorrect = 392 !T.expectAndConsume(diag::err_expected_lparen_after, "initializer") && 393 IsCorrect; 394 if (Tok.isNot(tok::annot_pragma_openmp_end)) { 395 ParseScope OMPDRScope(this, Scope::FnScope | Scope::DeclScope | 396 Scope::CompoundStmtScope | 397 Scope::OpenMPDirectiveScope); 398 // Parse expression. 399 VarDecl *OmpPrivParm = 400 Actions.ActOnOpenMPDeclareReductionInitializerStart(getCurScope(), 401 D); 402 // Check if initializer is omp_priv <init_expr> or something else. 403 if (Tok.is(tok::identifier) && 404 Tok.getIdentifierInfo()->isStr("omp_priv")) { 405 ConsumeToken(); 406 ParseOpenMPReductionInitializerForDecl(OmpPrivParm); 407 } else { 408 InitializerResult = Actions.ActOnFinishFullExpr( 409 ParseAssignmentExpression().get(), D->getLocation(), 410 /*DiscardedValue*/ false); 411 } 412 Actions.ActOnOpenMPDeclareReductionInitializerEnd( 413 D, InitializerResult.get(), OmpPrivParm); 414 if (InitializerResult.isInvalid() && Tok.isNot(tok::r_paren) && 415 Tok.isNot(tok::annot_pragma_openmp_end)) { 416 TPA.Commit(); 417 IsCorrect = false; 418 break; 419 } 420 IsCorrect = 421 !T.consumeClose() && IsCorrect && !InitializerResult.isInvalid(); 422 } 423 } 424 425 ++I; 426 // Revert parsing if not the last type, otherwise accept it, we're done with 427 // parsing. 428 if (I != E) 429 TPA.Revert(); 430 else 431 TPA.Commit(); 432 } 433 return Actions.ActOnOpenMPDeclareReductionDirectiveEnd(getCurScope(), DRD, 434 IsCorrect); 435 } 436 437 void Parser::ParseOpenMPReductionInitializerForDecl(VarDecl *OmpPrivParm) { 438 // Parse declarator '=' initializer. 439 // If a '==' or '+=' is found, suggest a fixit to '='. 440 if (isTokenEqualOrEqualTypo()) { 441 ConsumeToken(); 442 443 if (Tok.is(tok::code_completion)) { 444 cutOffParsing(); 445 Actions.CodeCompleteInitializer(getCurScope(), OmpPrivParm); 446 Actions.FinalizeDeclaration(OmpPrivParm); 447 return; 448 } 449 450 PreferredType.enterVariableInit(Tok.getLocation(), OmpPrivParm); 451 ExprResult Init = ParseInitializer(); 452 453 if (Init.isInvalid()) { 454 SkipUntil(tok::r_paren, tok::annot_pragma_openmp_end, StopBeforeMatch); 455 Actions.ActOnInitializerError(OmpPrivParm); 456 } else { 457 Actions.AddInitializerToDecl(OmpPrivParm, Init.get(), 458 /*DirectInit=*/false); 459 } 460 } else if (Tok.is(tok::l_paren)) { 461 // Parse C++ direct initializer: '(' expression-list ')' 462 BalancedDelimiterTracker T(*this, tok::l_paren); 463 T.consumeOpen(); 464 465 ExprVector Exprs; 466 CommaLocsTy CommaLocs; 467 468 SourceLocation LParLoc = T.getOpenLocation(); 469 auto RunSignatureHelp = [this, OmpPrivParm, LParLoc, &Exprs]() { 470 QualType PreferredType = Actions.ProduceConstructorSignatureHelp( 471 getCurScope(), OmpPrivParm->getType()->getCanonicalTypeInternal(), 472 OmpPrivParm->getLocation(), Exprs, LParLoc); 473 CalledSignatureHelp = true; 474 return PreferredType; 475 }; 476 if (ParseExpressionList(Exprs, CommaLocs, [&] { 477 PreferredType.enterFunctionArgument(Tok.getLocation(), 478 RunSignatureHelp); 479 })) { 480 if (PP.isCodeCompletionReached() && !CalledSignatureHelp) 481 RunSignatureHelp(); 482 Actions.ActOnInitializerError(OmpPrivParm); 483 SkipUntil(tok::r_paren, tok::annot_pragma_openmp_end, StopBeforeMatch); 484 } else { 485 // Match the ')'. 486 SourceLocation RLoc = Tok.getLocation(); 487 if (!T.consumeClose()) 488 RLoc = T.getCloseLocation(); 489 490 assert(!Exprs.empty() && Exprs.size() - 1 == CommaLocs.size() && 491 "Unexpected number of commas!"); 492 493 ExprResult Initializer = 494 Actions.ActOnParenListExpr(T.getOpenLocation(), RLoc, Exprs); 495 Actions.AddInitializerToDecl(OmpPrivParm, Initializer.get(), 496 /*DirectInit=*/true); 497 } 498 } else if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) { 499 // Parse C++0x braced-init-list. 500 Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists); 501 502 ExprResult Init(ParseBraceInitializer()); 503 504 if (Init.isInvalid()) { 505 Actions.ActOnInitializerError(OmpPrivParm); 506 } else { 507 Actions.AddInitializerToDecl(OmpPrivParm, Init.get(), 508 /*DirectInit=*/true); 509 } 510 } else { 511 Actions.ActOnUninitializedDecl(OmpPrivParm); 512 } 513 } 514 515 /// Parses 'omp declare mapper' directive. 516 /// 517 /// declare-mapper-directive: 518 /// annot_pragma_openmp 'declare' 'mapper' '(' [<mapper-identifier> ':'] 519 /// <type> <var> ')' [<clause>[[,] <clause>] ... ] 520 /// annot_pragma_openmp_end 521 /// <mapper-identifier> and <var> are base language identifiers. 522 /// 523 Parser::DeclGroupPtrTy 524 Parser::ParseOpenMPDeclareMapperDirective(AccessSpecifier AS) { 525 bool IsCorrect = true; 526 // Parse '(' 527 BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); 528 if (T.expectAndConsume(diag::err_expected_lparen_after, 529 getOpenMPDirectiveName(OMPD_declare_mapper).data())) { 530 SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch); 531 return DeclGroupPtrTy(); 532 } 533 534 // Parse <mapper-identifier> 535 auto &DeclNames = Actions.getASTContext().DeclarationNames; 536 DeclarationName MapperId; 537 if (PP.LookAhead(0).is(tok::colon)) { 538 if (Tok.isNot(tok::identifier) && Tok.isNot(tok::kw_default)) { 539 Diag(Tok.getLocation(), diag::err_omp_mapper_illegal_identifier); 540 IsCorrect = false; 541 } else { 542 MapperId = DeclNames.getIdentifier(Tok.getIdentifierInfo()); 543 } 544 ConsumeToken(); 545 // Consume ':'. 546 ExpectAndConsume(tok::colon); 547 } else { 548 // If no mapper identifier is provided, its name is "default" by default 549 MapperId = 550 DeclNames.getIdentifier(&Actions.getASTContext().Idents.get("default")); 551 } 552 553 if (!IsCorrect && Tok.is(tok::annot_pragma_openmp_end)) 554 return DeclGroupPtrTy(); 555 556 // Parse <type> <var> 557 DeclarationName VName; 558 QualType MapperType; 559 SourceRange Range; 560 TypeResult ParsedType = parseOpenMPDeclareMapperVarDecl(Range, VName, AS); 561 if (ParsedType.isUsable()) 562 MapperType = 563 Actions.ActOnOpenMPDeclareMapperType(Range.getBegin(), ParsedType); 564 if (MapperType.isNull()) 565 IsCorrect = false; 566 if (!IsCorrect) { 567 SkipUntil(tok::annot_pragma_openmp_end, Parser::StopBeforeMatch); 568 return DeclGroupPtrTy(); 569 } 570 571 // Consume ')'. 572 IsCorrect &= !T.consumeClose(); 573 if (!IsCorrect) { 574 SkipUntil(tok::annot_pragma_openmp_end, Parser::StopBeforeMatch); 575 return DeclGroupPtrTy(); 576 } 577 578 // Enter scope. 579 DeclarationNameInfo DirName; 580 SourceLocation Loc = Tok.getLocation(); 581 unsigned ScopeFlags = Scope::FnScope | Scope::DeclScope | 582 Scope::CompoundStmtScope | Scope::OpenMPDirectiveScope; 583 ParseScope OMPDirectiveScope(this, ScopeFlags); 584 Actions.StartOpenMPDSABlock(OMPD_declare_mapper, DirName, getCurScope(), Loc); 585 586 // Add the mapper variable declaration. 587 ExprResult MapperVarRef = Actions.ActOnOpenMPDeclareMapperDirectiveVarDecl( 588 getCurScope(), MapperType, Range.getBegin(), VName); 589 590 // Parse map clauses. 591 SmallVector<OMPClause *, 6> Clauses; 592 while (Tok.isNot(tok::annot_pragma_openmp_end)) { 593 OpenMPClauseKind CKind = Tok.isAnnotation() 594 ? OMPC_unknown 595 : getOpenMPClauseKind(PP.getSpelling(Tok)); 596 Actions.StartOpenMPClause(CKind); 597 OMPClause *Clause = 598 ParseOpenMPClause(OMPD_declare_mapper, CKind, Clauses.empty()); 599 if (Clause) 600 Clauses.push_back(Clause); 601 else 602 IsCorrect = false; 603 // Skip ',' if any. 604 if (Tok.is(tok::comma)) 605 ConsumeToken(); 606 Actions.EndOpenMPClause(); 607 } 608 if (Clauses.empty()) { 609 Diag(Tok, diag::err_omp_expected_clause) 610 << getOpenMPDirectiveName(OMPD_declare_mapper); 611 IsCorrect = false; 612 } 613 614 // Exit scope. 615 Actions.EndOpenMPDSABlock(nullptr); 616 OMPDirectiveScope.Exit(); 617 DeclGroupPtrTy DG = Actions.ActOnOpenMPDeclareMapperDirective( 618 getCurScope(), Actions.getCurLexicalContext(), MapperId, MapperType, 619 Range.getBegin(), VName, AS, MapperVarRef.get(), Clauses); 620 if (!IsCorrect) 621 return DeclGroupPtrTy(); 622 623 return DG; 624 } 625 626 TypeResult Parser::parseOpenMPDeclareMapperVarDecl(SourceRange &Range, 627 DeclarationName &Name, 628 AccessSpecifier AS) { 629 // Parse the common declaration-specifiers piece. 630 Parser::DeclSpecContext DSC = Parser::DeclSpecContext::DSC_type_specifier; 631 DeclSpec DS(AttrFactory); 632 ParseSpecifierQualifierList(DS, AS, DSC); 633 634 // Parse the declarator. 635 DeclaratorContext Context = DeclaratorContext::Prototype; 636 Declarator DeclaratorInfo(DS, Context); 637 ParseDeclarator(DeclaratorInfo); 638 Range = DeclaratorInfo.getSourceRange(); 639 if (DeclaratorInfo.getIdentifier() == nullptr) { 640 Diag(Tok.getLocation(), diag::err_omp_mapper_expected_declarator); 641 return true; 642 } 643 Name = Actions.GetNameForDeclarator(DeclaratorInfo).getName(); 644 645 return Actions.ActOnOpenMPDeclareMapperVarDecl(getCurScope(), DeclaratorInfo); 646 } 647 648 namespace { 649 /// RAII that recreates function context for correct parsing of clauses of 650 /// 'declare simd' construct. 651 /// OpenMP, 2.8.2 declare simd Construct 652 /// The expressions appearing in the clauses of this directive are evaluated in 653 /// the scope of the arguments of the function declaration or definition. 654 class FNContextRAII final { 655 Parser &P; 656 Sema::CXXThisScopeRAII *ThisScope; 657 Parser::MultiParseScope Scopes; 658 bool HasFunScope = false; 659 FNContextRAII() = delete; 660 FNContextRAII(const FNContextRAII &) = delete; 661 FNContextRAII &operator=(const FNContextRAII &) = delete; 662 663 public: 664 FNContextRAII(Parser &P, Parser::DeclGroupPtrTy Ptr) : P(P), Scopes(P) { 665 Decl *D = *Ptr.get().begin(); 666 NamedDecl *ND = dyn_cast<NamedDecl>(D); 667 RecordDecl *RD = dyn_cast_or_null<RecordDecl>(D->getDeclContext()); 668 Sema &Actions = P.getActions(); 669 670 // Allow 'this' within late-parsed attributes. 671 ThisScope = new Sema::CXXThisScopeRAII(Actions, RD, Qualifiers(), 672 ND && ND->isCXXInstanceMember()); 673 674 // If the Decl is templatized, add template parameters to scope. 675 // FIXME: Track CurTemplateDepth? 676 P.ReenterTemplateScopes(Scopes, D); 677 678 // If the Decl is on a function, add function parameters to the scope. 679 if (D->isFunctionOrFunctionTemplate()) { 680 HasFunScope = true; 681 Scopes.Enter(Scope::FnScope | Scope::DeclScope | 682 Scope::CompoundStmtScope); 683 Actions.ActOnReenterFunctionContext(Actions.getCurScope(), D); 684 } 685 } 686 ~FNContextRAII() { 687 if (HasFunScope) 688 P.getActions().ActOnExitFunctionContext(); 689 delete ThisScope; 690 } 691 }; 692 } // namespace 693 694 /// Parses clauses for 'declare simd' directive. 695 /// clause: 696 /// 'inbranch' | 'notinbranch' 697 /// 'simdlen' '(' <expr> ')' 698 /// { 'uniform' '(' <argument_list> ')' } 699 /// { 'aligned '(' <argument_list> [ ':' <alignment> ] ')' } 700 /// { 'linear '(' <argument_list> [ ':' <step> ] ')' } 701 static bool parseDeclareSimdClauses( 702 Parser &P, OMPDeclareSimdDeclAttr::BranchStateTy &BS, ExprResult &SimdLen, 703 SmallVectorImpl<Expr *> &Uniforms, SmallVectorImpl<Expr *> &Aligneds, 704 SmallVectorImpl<Expr *> &Alignments, SmallVectorImpl<Expr *> &Linears, 705 SmallVectorImpl<unsigned> &LinModifiers, SmallVectorImpl<Expr *> &Steps) { 706 SourceRange BSRange; 707 const Token &Tok = P.getCurToken(); 708 bool IsError = false; 709 while (Tok.isNot(tok::annot_pragma_openmp_end)) { 710 if (Tok.isNot(tok::identifier)) 711 break; 712 OMPDeclareSimdDeclAttr::BranchStateTy Out; 713 IdentifierInfo *II = Tok.getIdentifierInfo(); 714 StringRef ClauseName = II->getName(); 715 // Parse 'inranch|notinbranch' clauses. 716 if (OMPDeclareSimdDeclAttr::ConvertStrToBranchStateTy(ClauseName, Out)) { 717 if (BS != OMPDeclareSimdDeclAttr::BS_Undefined && BS != Out) { 718 P.Diag(Tok, diag::err_omp_declare_simd_inbranch_notinbranch) 719 << ClauseName 720 << OMPDeclareSimdDeclAttr::ConvertBranchStateTyToStr(BS) << BSRange; 721 IsError = true; 722 } 723 BS = Out; 724 BSRange = SourceRange(Tok.getLocation(), Tok.getEndLoc()); 725 P.ConsumeToken(); 726 } else if (ClauseName.equals("simdlen")) { 727 if (SimdLen.isUsable()) { 728 P.Diag(Tok, diag::err_omp_more_one_clause) 729 << getOpenMPDirectiveName(OMPD_declare_simd) << ClauseName << 0; 730 IsError = true; 731 } 732 P.ConsumeToken(); 733 SourceLocation RLoc; 734 SimdLen = P.ParseOpenMPParensExpr(ClauseName, RLoc); 735 if (SimdLen.isInvalid()) 736 IsError = true; 737 } else { 738 OpenMPClauseKind CKind = getOpenMPClauseKind(ClauseName); 739 if (CKind == OMPC_uniform || CKind == OMPC_aligned || 740 CKind == OMPC_linear) { 741 Parser::OpenMPVarListDataTy Data; 742 SmallVectorImpl<Expr *> *Vars = &Uniforms; 743 if (CKind == OMPC_aligned) { 744 Vars = &Aligneds; 745 } else if (CKind == OMPC_linear) { 746 Data.ExtraModifier = OMPC_LINEAR_val; 747 Vars = &Linears; 748 } 749 750 P.ConsumeToken(); 751 if (P.ParseOpenMPVarList(OMPD_declare_simd, 752 getOpenMPClauseKind(ClauseName), *Vars, Data)) 753 IsError = true; 754 if (CKind == OMPC_aligned) { 755 Alignments.append(Aligneds.size() - Alignments.size(), 756 Data.DepModOrTailExpr); 757 } else if (CKind == OMPC_linear) { 758 assert(0 <= Data.ExtraModifier && 759 Data.ExtraModifier <= OMPC_LINEAR_unknown && 760 "Unexpected linear modifier."); 761 if (P.getActions().CheckOpenMPLinearModifier( 762 static_cast<OpenMPLinearClauseKind>(Data.ExtraModifier), 763 Data.ExtraModifierLoc)) 764 Data.ExtraModifier = OMPC_LINEAR_val; 765 LinModifiers.append(Linears.size() - LinModifiers.size(), 766 Data.ExtraModifier); 767 Steps.append(Linears.size() - Steps.size(), Data.DepModOrTailExpr); 768 } 769 } else 770 // TODO: add parsing of other clauses. 771 break; 772 } 773 // Skip ',' if any. 774 if (Tok.is(tok::comma)) 775 P.ConsumeToken(); 776 } 777 return IsError; 778 } 779 780 /// Parse clauses for '#pragma omp declare simd'. 781 Parser::DeclGroupPtrTy 782 Parser::ParseOMPDeclareSimdClauses(Parser::DeclGroupPtrTy Ptr, 783 CachedTokens &Toks, SourceLocation Loc) { 784 PP.EnterToken(Tok, /*IsReinject*/ true); 785 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true, 786 /*IsReinject*/ true); 787 // Consume the previously pushed token. 788 ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true); 789 ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true); 790 791 FNContextRAII FnContext(*this, Ptr); 792 OMPDeclareSimdDeclAttr::BranchStateTy BS = 793 OMPDeclareSimdDeclAttr::BS_Undefined; 794 ExprResult Simdlen; 795 SmallVector<Expr *, 4> Uniforms; 796 SmallVector<Expr *, 4> Aligneds; 797 SmallVector<Expr *, 4> Alignments; 798 SmallVector<Expr *, 4> Linears; 799 SmallVector<unsigned, 4> LinModifiers; 800 SmallVector<Expr *, 4> Steps; 801 bool IsError = 802 parseDeclareSimdClauses(*this, BS, Simdlen, Uniforms, Aligneds, 803 Alignments, Linears, LinModifiers, Steps); 804 skipUntilPragmaOpenMPEnd(OMPD_declare_simd); 805 // Skip the last annot_pragma_openmp_end. 806 SourceLocation EndLoc = ConsumeAnnotationToken(); 807 if (IsError) 808 return Ptr; 809 return Actions.ActOnOpenMPDeclareSimdDirective( 810 Ptr, BS, Simdlen.get(), Uniforms, Aligneds, Alignments, Linears, 811 LinModifiers, Steps, SourceRange(Loc, EndLoc)); 812 } 813 814 namespace { 815 /// Constant used in the diagnostics to distinguish the levels in an OpenMP 816 /// contexts: selector-set={selector(trait, ...), ...}, .... 817 enum OMPContextLvl { 818 CONTEXT_SELECTOR_SET_LVL = 0, 819 CONTEXT_SELECTOR_LVL = 1, 820 CONTEXT_TRAIT_LVL = 2, 821 }; 822 823 static StringRef stringLiteralParser(Parser &P) { 824 ExprResult Res = P.ParseStringLiteralExpression(true); 825 return Res.isUsable() ? Res.getAs<StringLiteral>()->getString() : ""; 826 } 827 828 static StringRef getNameFromIdOrString(Parser &P, Token &Tok, 829 OMPContextLvl Lvl) { 830 if (Tok.is(tok::identifier)) { 831 llvm::SmallString<16> Buffer; 832 StringRef Name = P.getPreprocessor().getSpelling(Tok, Buffer); 833 (void)P.ConsumeToken(); 834 return Name; 835 } 836 837 if (tok::isStringLiteral(Tok.getKind())) 838 return stringLiteralParser(P); 839 840 P.Diag(Tok.getLocation(), 841 diag::warn_omp_declare_variant_string_literal_or_identifier) 842 << Lvl; 843 return ""; 844 } 845 846 static bool checkForDuplicates(Parser &P, StringRef Name, 847 SourceLocation NameLoc, 848 llvm::StringMap<SourceLocation> &Seen, 849 OMPContextLvl Lvl) { 850 auto Res = Seen.try_emplace(Name, NameLoc); 851 if (Res.second) 852 return false; 853 854 // Each trait-set-selector-name, trait-selector-name and trait-name can 855 // only be specified once. 856 P.Diag(NameLoc, diag::warn_omp_declare_variant_ctx_mutiple_use) 857 << Lvl << Name; 858 P.Diag(Res.first->getValue(), diag::note_omp_declare_variant_ctx_used_here) 859 << Lvl << Name; 860 return true; 861 } 862 } // namespace 863 864 void Parser::parseOMPTraitPropertyKind(OMPTraitProperty &TIProperty, 865 llvm::omp::TraitSet Set, 866 llvm::omp::TraitSelector Selector, 867 llvm::StringMap<SourceLocation> &Seen) { 868 TIProperty.Kind = TraitProperty::invalid; 869 870 SourceLocation NameLoc = Tok.getLocation(); 871 StringRef Name = getNameFromIdOrString(*this, Tok, CONTEXT_TRAIT_LVL); 872 if (Name.empty()) { 873 Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_options) 874 << CONTEXT_TRAIT_LVL << listOpenMPContextTraitProperties(Set, Selector); 875 return; 876 } 877 878 TIProperty.RawString = Name; 879 TIProperty.Kind = getOpenMPContextTraitPropertyKind(Set, Selector, Name); 880 if (TIProperty.Kind != TraitProperty::invalid) { 881 if (checkForDuplicates(*this, Name, NameLoc, Seen, CONTEXT_TRAIT_LVL)) 882 TIProperty.Kind = TraitProperty::invalid; 883 return; 884 } 885 886 // It follows diagnosis and helping notes. 887 // FIXME: We should move the diagnosis string generation into libFrontend. 888 Diag(NameLoc, diag::warn_omp_declare_variant_ctx_not_a_property) 889 << Name << getOpenMPContextTraitSelectorName(Selector) 890 << getOpenMPContextTraitSetName(Set); 891 892 TraitSet SetForName = getOpenMPContextTraitSetKind(Name); 893 if (SetForName != TraitSet::invalid) { 894 Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a) 895 << Name << CONTEXT_SELECTOR_SET_LVL << CONTEXT_TRAIT_LVL; 896 Diag(NameLoc, diag::note_omp_declare_variant_ctx_try) 897 << Name << "<selector-name>" 898 << "(<property-name>)"; 899 return; 900 } 901 TraitSelector SelectorForName = getOpenMPContextTraitSelectorKind(Name); 902 if (SelectorForName != TraitSelector::invalid) { 903 Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a) 904 << Name << CONTEXT_SELECTOR_LVL << CONTEXT_TRAIT_LVL; 905 bool AllowsTraitScore = false; 906 bool RequiresProperty = false; 907 isValidTraitSelectorForTraitSet( 908 SelectorForName, getOpenMPContextTraitSetForSelector(SelectorForName), 909 AllowsTraitScore, RequiresProperty); 910 Diag(NameLoc, diag::note_omp_declare_variant_ctx_try) 911 << getOpenMPContextTraitSetName( 912 getOpenMPContextTraitSetForSelector(SelectorForName)) 913 << Name << (RequiresProperty ? "(<property-name>)" : ""); 914 return; 915 } 916 for (const auto &PotentialSet : 917 {TraitSet::construct, TraitSet::user, TraitSet::implementation, 918 TraitSet::device}) { 919 TraitProperty PropertyForName = 920 getOpenMPContextTraitPropertyKind(PotentialSet, Selector, Name); 921 if (PropertyForName == TraitProperty::invalid) 922 continue; 923 Diag(NameLoc, diag::note_omp_declare_variant_ctx_try) 924 << getOpenMPContextTraitSetName( 925 getOpenMPContextTraitSetForProperty(PropertyForName)) 926 << getOpenMPContextTraitSelectorName( 927 getOpenMPContextTraitSelectorForProperty(PropertyForName)) 928 << ("(" + Name + ")").str(); 929 return; 930 } 931 Diag(NameLoc, diag::note_omp_declare_variant_ctx_options) 932 << CONTEXT_TRAIT_LVL << listOpenMPContextTraitProperties(Set, Selector); 933 } 934 935 static bool checkExtensionProperty(Parser &P, SourceLocation Loc, 936 OMPTraitProperty &TIProperty, 937 OMPTraitSelector &TISelector, 938 llvm::StringMap<SourceLocation> &Seen) { 939 assert(TISelector.Kind == 940 llvm::omp::TraitSelector::implementation_extension && 941 "Only for extension properties, e.g., " 942 "`implementation={extension(PROPERTY)}`"); 943 if (TIProperty.Kind == TraitProperty::invalid) 944 return false; 945 946 if (TIProperty.Kind == 947 TraitProperty::implementation_extension_disable_implicit_base) 948 return true; 949 950 if (TIProperty.Kind == 951 TraitProperty::implementation_extension_allow_templates) 952 return true; 953 954 auto IsMatchExtension = [](OMPTraitProperty &TP) { 955 return (TP.Kind == 956 llvm::omp::TraitProperty::implementation_extension_match_all || 957 TP.Kind == 958 llvm::omp::TraitProperty::implementation_extension_match_any || 959 TP.Kind == 960 llvm::omp::TraitProperty::implementation_extension_match_none); 961 }; 962 963 if (IsMatchExtension(TIProperty)) { 964 for (OMPTraitProperty &SeenProp : TISelector.Properties) 965 if (IsMatchExtension(SeenProp)) { 966 P.Diag(Loc, diag::err_omp_variant_ctx_second_match_extension); 967 StringRef SeenName = llvm::omp::getOpenMPContextTraitPropertyName( 968 SeenProp.Kind, SeenProp.RawString); 969 SourceLocation SeenLoc = Seen[SeenName]; 970 P.Diag(SeenLoc, diag::note_omp_declare_variant_ctx_used_here) 971 << CONTEXT_TRAIT_LVL << SeenName; 972 return false; 973 } 974 return true; 975 } 976 977 llvm_unreachable("Unknown extension property!"); 978 } 979 980 void Parser::parseOMPContextProperty(OMPTraitSelector &TISelector, 981 llvm::omp::TraitSet Set, 982 llvm::StringMap<SourceLocation> &Seen) { 983 assert(TISelector.Kind != TraitSelector::user_condition && 984 "User conditions are special properties not handled here!"); 985 986 SourceLocation PropertyLoc = Tok.getLocation(); 987 OMPTraitProperty TIProperty; 988 parseOMPTraitPropertyKind(TIProperty, Set, TISelector.Kind, Seen); 989 990 if (TISelector.Kind == llvm::omp::TraitSelector::implementation_extension) 991 if (!checkExtensionProperty(*this, Tok.getLocation(), TIProperty, 992 TISelector, Seen)) 993 TIProperty.Kind = TraitProperty::invalid; 994 995 // If we have an invalid property here we already issued a warning. 996 if (TIProperty.Kind == TraitProperty::invalid) { 997 if (PropertyLoc != Tok.getLocation()) 998 Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_continue_here) 999 << CONTEXT_TRAIT_LVL; 1000 return; 1001 } 1002 1003 if (isValidTraitPropertyForTraitSetAndSelector(TIProperty.Kind, 1004 TISelector.Kind, Set)) { 1005 1006 // If we make it here the property, selector, set, score, condition, ... are 1007 // all valid (or have been corrected). Thus we can record the property. 1008 TISelector.Properties.push_back(TIProperty); 1009 return; 1010 } 1011 1012 Diag(PropertyLoc, diag::warn_omp_ctx_incompatible_property_for_selector) 1013 << getOpenMPContextTraitPropertyName(TIProperty.Kind, 1014 TIProperty.RawString) 1015 << getOpenMPContextTraitSelectorName(TISelector.Kind) 1016 << getOpenMPContextTraitSetName(Set); 1017 Diag(PropertyLoc, diag::note_omp_ctx_compatible_set_and_selector_for_property) 1018 << getOpenMPContextTraitPropertyName(TIProperty.Kind, 1019 TIProperty.RawString) 1020 << getOpenMPContextTraitSelectorName( 1021 getOpenMPContextTraitSelectorForProperty(TIProperty.Kind)) 1022 << getOpenMPContextTraitSetName( 1023 getOpenMPContextTraitSetForProperty(TIProperty.Kind)); 1024 Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_continue_here) 1025 << CONTEXT_TRAIT_LVL; 1026 } 1027 1028 void Parser::parseOMPTraitSelectorKind(OMPTraitSelector &TISelector, 1029 llvm::omp::TraitSet Set, 1030 llvm::StringMap<SourceLocation> &Seen) { 1031 TISelector.Kind = TraitSelector::invalid; 1032 1033 SourceLocation NameLoc = Tok.getLocation(); 1034 StringRef Name = getNameFromIdOrString(*this, Tok, CONTEXT_SELECTOR_LVL); 1035 if (Name.empty()) { 1036 Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_options) 1037 << CONTEXT_SELECTOR_LVL << listOpenMPContextTraitSelectors(Set); 1038 return; 1039 } 1040 1041 TISelector.Kind = getOpenMPContextTraitSelectorKind(Name); 1042 if (TISelector.Kind != TraitSelector::invalid) { 1043 if (checkForDuplicates(*this, Name, NameLoc, Seen, CONTEXT_SELECTOR_LVL)) 1044 TISelector.Kind = TraitSelector::invalid; 1045 return; 1046 } 1047 1048 // It follows diagnosis and helping notes. 1049 Diag(NameLoc, diag::warn_omp_declare_variant_ctx_not_a_selector) 1050 << Name << getOpenMPContextTraitSetName(Set); 1051 1052 TraitSet SetForName = getOpenMPContextTraitSetKind(Name); 1053 if (SetForName != TraitSet::invalid) { 1054 Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a) 1055 << Name << CONTEXT_SELECTOR_SET_LVL << CONTEXT_SELECTOR_LVL; 1056 Diag(NameLoc, diag::note_omp_declare_variant_ctx_try) 1057 << Name << "<selector-name>" 1058 << "<property-name>"; 1059 return; 1060 } 1061 for (const auto &PotentialSet : 1062 {TraitSet::construct, TraitSet::user, TraitSet::implementation, 1063 TraitSet::device}) { 1064 TraitProperty PropertyForName = getOpenMPContextTraitPropertyKind( 1065 PotentialSet, TraitSelector::invalid, Name); 1066 if (PropertyForName == TraitProperty::invalid) 1067 continue; 1068 Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a) 1069 << Name << CONTEXT_TRAIT_LVL << CONTEXT_SELECTOR_LVL; 1070 Diag(NameLoc, diag::note_omp_declare_variant_ctx_try) 1071 << getOpenMPContextTraitSetName( 1072 getOpenMPContextTraitSetForProperty(PropertyForName)) 1073 << getOpenMPContextTraitSelectorName( 1074 getOpenMPContextTraitSelectorForProperty(PropertyForName)) 1075 << ("(" + Name + ")").str(); 1076 return; 1077 } 1078 Diag(NameLoc, diag::note_omp_declare_variant_ctx_options) 1079 << CONTEXT_SELECTOR_LVL << listOpenMPContextTraitSelectors(Set); 1080 } 1081 1082 /// Parse optional 'score' '(' <expr> ')' ':'. 1083 static ExprResult parseContextScore(Parser &P) { 1084 ExprResult ScoreExpr; 1085 llvm::SmallString<16> Buffer; 1086 StringRef SelectorName = 1087 P.getPreprocessor().getSpelling(P.getCurToken(), Buffer); 1088 if (!SelectorName.equals("score")) 1089 return ScoreExpr; 1090 (void)P.ConsumeToken(); 1091 SourceLocation RLoc; 1092 ScoreExpr = P.ParseOpenMPParensExpr(SelectorName, RLoc); 1093 // Parse ':' 1094 if (P.getCurToken().is(tok::colon)) 1095 (void)P.ConsumeAnyToken(); 1096 else 1097 P.Diag(P.getCurToken(), diag::warn_omp_declare_variant_expected) 1098 << "':'" 1099 << "score expression"; 1100 return ScoreExpr; 1101 } 1102 1103 /// Parses an OpenMP context selector. 1104 /// 1105 /// <trait-selector-name> ['('[<trait-score>] <trait-property> [, <t-p>]* ')'] 1106 void Parser::parseOMPContextSelector( 1107 OMPTraitSelector &TISelector, llvm::omp::TraitSet Set, 1108 llvm::StringMap<SourceLocation> &SeenSelectors) { 1109 unsigned short OuterPC = ParenCount; 1110 1111 // If anything went wrong we issue an error or warning and then skip the rest 1112 // of the selector. However, commas are ambiguous so we look for the nesting 1113 // of parentheses here as well. 1114 auto FinishSelector = [OuterPC, this]() -> void { 1115 bool Done = false; 1116 while (!Done) { 1117 while (!SkipUntil({tok::r_brace, tok::r_paren, tok::comma, 1118 tok::annot_pragma_openmp_end}, 1119 StopBeforeMatch)) 1120 ; 1121 if (Tok.is(tok::r_paren) && OuterPC > ParenCount) 1122 (void)ConsumeParen(); 1123 if (OuterPC <= ParenCount) { 1124 Done = true; 1125 break; 1126 } 1127 if (!Tok.is(tok::comma) && !Tok.is(tok::r_paren)) { 1128 Done = true; 1129 break; 1130 } 1131 (void)ConsumeAnyToken(); 1132 } 1133 Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_continue_here) 1134 << CONTEXT_SELECTOR_LVL; 1135 }; 1136 1137 SourceLocation SelectorLoc = Tok.getLocation(); 1138 parseOMPTraitSelectorKind(TISelector, Set, SeenSelectors); 1139 if (TISelector.Kind == TraitSelector::invalid) 1140 return FinishSelector(); 1141 1142 bool AllowsTraitScore = false; 1143 bool RequiresProperty = false; 1144 if (!isValidTraitSelectorForTraitSet(TISelector.Kind, Set, AllowsTraitScore, 1145 RequiresProperty)) { 1146 Diag(SelectorLoc, diag::warn_omp_ctx_incompatible_selector_for_set) 1147 << getOpenMPContextTraitSelectorName(TISelector.Kind) 1148 << getOpenMPContextTraitSetName(Set); 1149 Diag(SelectorLoc, diag::note_omp_ctx_compatible_set_for_selector) 1150 << getOpenMPContextTraitSelectorName(TISelector.Kind) 1151 << getOpenMPContextTraitSetName( 1152 getOpenMPContextTraitSetForSelector(TISelector.Kind)) 1153 << RequiresProperty; 1154 return FinishSelector(); 1155 } 1156 1157 if (!RequiresProperty) { 1158 TISelector.Properties.push_back( 1159 {getOpenMPContextTraitPropertyForSelector(TISelector.Kind), 1160 getOpenMPContextTraitSelectorName(TISelector.Kind)}); 1161 return; 1162 } 1163 1164 if (!Tok.is(tok::l_paren)) { 1165 Diag(SelectorLoc, diag::warn_omp_ctx_selector_without_properties) 1166 << getOpenMPContextTraitSelectorName(TISelector.Kind) 1167 << getOpenMPContextTraitSetName(Set); 1168 return FinishSelector(); 1169 } 1170 1171 if (TISelector.Kind == TraitSelector::user_condition) { 1172 SourceLocation RLoc; 1173 ExprResult Condition = ParseOpenMPParensExpr("user condition", RLoc); 1174 if (!Condition.isUsable()) 1175 return FinishSelector(); 1176 TISelector.ScoreOrCondition = Condition.get(); 1177 TISelector.Properties.push_back( 1178 {TraitProperty::user_condition_unknown, "<condition>"}); 1179 return; 1180 } 1181 1182 BalancedDelimiterTracker BDT(*this, tok::l_paren, 1183 tok::annot_pragma_openmp_end); 1184 // Parse '('. 1185 (void)BDT.consumeOpen(); 1186 1187 SourceLocation ScoreLoc = Tok.getLocation(); 1188 ExprResult Score = parseContextScore(*this); 1189 1190 if (!AllowsTraitScore && !Score.isUnset()) { 1191 if (Score.isUsable()) { 1192 Diag(ScoreLoc, diag::warn_omp_ctx_incompatible_score_for_property) 1193 << getOpenMPContextTraitSelectorName(TISelector.Kind) 1194 << getOpenMPContextTraitSetName(Set) << Score.get(); 1195 } else { 1196 Diag(ScoreLoc, diag::warn_omp_ctx_incompatible_score_for_property) 1197 << getOpenMPContextTraitSelectorName(TISelector.Kind) 1198 << getOpenMPContextTraitSetName(Set) << "<invalid>"; 1199 } 1200 Score = ExprResult(); 1201 } 1202 1203 if (Score.isUsable()) 1204 TISelector.ScoreOrCondition = Score.get(); 1205 1206 llvm::StringMap<SourceLocation> SeenProperties; 1207 do { 1208 parseOMPContextProperty(TISelector, Set, SeenProperties); 1209 } while (TryConsumeToken(tok::comma)); 1210 1211 // Parse ')'. 1212 BDT.consumeClose(); 1213 } 1214 1215 void Parser::parseOMPTraitSetKind(OMPTraitSet &TISet, 1216 llvm::StringMap<SourceLocation> &Seen) { 1217 TISet.Kind = TraitSet::invalid; 1218 1219 SourceLocation NameLoc = Tok.getLocation(); 1220 StringRef Name = getNameFromIdOrString(*this, Tok, CONTEXT_SELECTOR_SET_LVL); 1221 if (Name.empty()) { 1222 Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_options) 1223 << CONTEXT_SELECTOR_SET_LVL << listOpenMPContextTraitSets(); 1224 return; 1225 } 1226 1227 TISet.Kind = getOpenMPContextTraitSetKind(Name); 1228 if (TISet.Kind != TraitSet::invalid) { 1229 if (checkForDuplicates(*this, Name, NameLoc, Seen, 1230 CONTEXT_SELECTOR_SET_LVL)) 1231 TISet.Kind = TraitSet::invalid; 1232 return; 1233 } 1234 1235 // It follows diagnosis and helping notes. 1236 Diag(NameLoc, diag::warn_omp_declare_variant_ctx_not_a_set) << Name; 1237 1238 TraitSelector SelectorForName = getOpenMPContextTraitSelectorKind(Name); 1239 if (SelectorForName != TraitSelector::invalid) { 1240 Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a) 1241 << Name << CONTEXT_SELECTOR_LVL << CONTEXT_SELECTOR_SET_LVL; 1242 bool AllowsTraitScore = false; 1243 bool RequiresProperty = false; 1244 isValidTraitSelectorForTraitSet( 1245 SelectorForName, getOpenMPContextTraitSetForSelector(SelectorForName), 1246 AllowsTraitScore, RequiresProperty); 1247 Diag(NameLoc, diag::note_omp_declare_variant_ctx_try) 1248 << getOpenMPContextTraitSetName( 1249 getOpenMPContextTraitSetForSelector(SelectorForName)) 1250 << Name << (RequiresProperty ? "(<property-name>)" : ""); 1251 return; 1252 } 1253 for (const auto &PotentialSet : 1254 {TraitSet::construct, TraitSet::user, TraitSet::implementation, 1255 TraitSet::device}) { 1256 TraitProperty PropertyForName = getOpenMPContextTraitPropertyKind( 1257 PotentialSet, TraitSelector::invalid, Name); 1258 if (PropertyForName == TraitProperty::invalid) 1259 continue; 1260 Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a) 1261 << Name << CONTEXT_TRAIT_LVL << CONTEXT_SELECTOR_SET_LVL; 1262 Diag(NameLoc, diag::note_omp_declare_variant_ctx_try) 1263 << getOpenMPContextTraitSetName( 1264 getOpenMPContextTraitSetForProperty(PropertyForName)) 1265 << getOpenMPContextTraitSelectorName( 1266 getOpenMPContextTraitSelectorForProperty(PropertyForName)) 1267 << ("(" + Name + ")").str(); 1268 return; 1269 } 1270 Diag(NameLoc, diag::note_omp_declare_variant_ctx_options) 1271 << CONTEXT_SELECTOR_SET_LVL << listOpenMPContextTraitSets(); 1272 } 1273 1274 /// Parses an OpenMP context selector set. 1275 /// 1276 /// <trait-set-selector-name> '=' '{' <trait-selector> [, <trait-selector>]* '}' 1277 void Parser::parseOMPContextSelectorSet( 1278 OMPTraitSet &TISet, llvm::StringMap<SourceLocation> &SeenSets) { 1279 auto OuterBC = BraceCount; 1280 1281 // If anything went wrong we issue an error or warning and then skip the rest 1282 // of the set. However, commas are ambiguous so we look for the nesting 1283 // of braces here as well. 1284 auto FinishSelectorSet = [this, OuterBC]() -> void { 1285 bool Done = false; 1286 while (!Done) { 1287 while (!SkipUntil({tok::comma, tok::r_brace, tok::r_paren, 1288 tok::annot_pragma_openmp_end}, 1289 StopBeforeMatch)) 1290 ; 1291 if (Tok.is(tok::r_brace) && OuterBC > BraceCount) 1292 (void)ConsumeBrace(); 1293 if (OuterBC <= BraceCount) { 1294 Done = true; 1295 break; 1296 } 1297 if (!Tok.is(tok::comma) && !Tok.is(tok::r_brace)) { 1298 Done = true; 1299 break; 1300 } 1301 (void)ConsumeAnyToken(); 1302 } 1303 Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_continue_here) 1304 << CONTEXT_SELECTOR_SET_LVL; 1305 }; 1306 1307 parseOMPTraitSetKind(TISet, SeenSets); 1308 if (TISet.Kind == TraitSet::invalid) 1309 return FinishSelectorSet(); 1310 1311 // Parse '='. 1312 if (!TryConsumeToken(tok::equal)) 1313 Diag(Tok.getLocation(), diag::warn_omp_declare_variant_expected) 1314 << "=" 1315 << ("context set name \"" + getOpenMPContextTraitSetName(TISet.Kind) + 1316 "\"") 1317 .str(); 1318 1319 // Parse '{'. 1320 if (Tok.is(tok::l_brace)) { 1321 (void)ConsumeBrace(); 1322 } else { 1323 Diag(Tok.getLocation(), diag::warn_omp_declare_variant_expected) 1324 << "{" 1325 << ("'=' that follows the context set name \"" + 1326 getOpenMPContextTraitSetName(TISet.Kind) + "\"") 1327 .str(); 1328 } 1329 1330 llvm::StringMap<SourceLocation> SeenSelectors; 1331 do { 1332 OMPTraitSelector TISelector; 1333 parseOMPContextSelector(TISelector, TISet.Kind, SeenSelectors); 1334 if (TISelector.Kind != TraitSelector::invalid && 1335 !TISelector.Properties.empty()) 1336 TISet.Selectors.push_back(TISelector); 1337 } while (TryConsumeToken(tok::comma)); 1338 1339 // Parse '}'. 1340 if (Tok.is(tok::r_brace)) { 1341 (void)ConsumeBrace(); 1342 } else { 1343 Diag(Tok.getLocation(), diag::warn_omp_declare_variant_expected) 1344 << "}" 1345 << ("context selectors for the context set \"" + 1346 getOpenMPContextTraitSetName(TISet.Kind) + "\"") 1347 .str(); 1348 } 1349 } 1350 1351 /// Parse OpenMP context selectors: 1352 /// 1353 /// <trait-set-selector> [, <trait-set-selector>]* 1354 bool Parser::parseOMPContextSelectors(SourceLocation Loc, OMPTraitInfo &TI) { 1355 llvm::StringMap<SourceLocation> SeenSets; 1356 do { 1357 OMPTraitSet TISet; 1358 parseOMPContextSelectorSet(TISet, SeenSets); 1359 if (TISet.Kind != TraitSet::invalid && !TISet.Selectors.empty()) 1360 TI.Sets.push_back(TISet); 1361 } while (TryConsumeToken(tok::comma)); 1362 1363 return false; 1364 } 1365 1366 /// Parse clauses for '#pragma omp declare variant ( variant-func-id ) clause'. 1367 void Parser::ParseOMPDeclareVariantClauses(Parser::DeclGroupPtrTy Ptr, 1368 CachedTokens &Toks, 1369 SourceLocation Loc) { 1370 PP.EnterToken(Tok, /*IsReinject*/ true); 1371 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true, 1372 /*IsReinject*/ true); 1373 // Consume the previously pushed token. 1374 ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true); 1375 ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true); 1376 1377 FNContextRAII FnContext(*this, Ptr); 1378 // Parse function declaration id. 1379 SourceLocation RLoc; 1380 // Parse with IsAddressOfOperand set to true to parse methods as DeclRefExprs 1381 // instead of MemberExprs. 1382 ExprResult AssociatedFunction; 1383 { 1384 // Do not mark function as is used to prevent its emission if this is the 1385 // only place where it is used. 1386 EnterExpressionEvaluationContext Unevaluated( 1387 Actions, Sema::ExpressionEvaluationContext::Unevaluated); 1388 AssociatedFunction = ParseOpenMPParensExpr( 1389 getOpenMPDirectiveName(OMPD_declare_variant), RLoc, 1390 /*IsAddressOfOperand=*/true); 1391 } 1392 if (!AssociatedFunction.isUsable()) { 1393 if (!Tok.is(tok::annot_pragma_openmp_end)) 1394 while (!SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch)) 1395 ; 1396 // Skip the last annot_pragma_openmp_end. 1397 (void)ConsumeAnnotationToken(); 1398 return; 1399 } 1400 1401 OMPTraitInfo *ParentTI = Actions.getOMPTraitInfoForSurroundingScope(); 1402 ASTContext &ASTCtx = Actions.getASTContext(); 1403 OMPTraitInfo &TI = ASTCtx.getNewOMPTraitInfo(); 1404 if (parseOMPDeclareVariantMatchClause(Loc, TI, ParentTI)) 1405 return; 1406 1407 Optional<std::pair<FunctionDecl *, Expr *>> DeclVarData = 1408 Actions.checkOpenMPDeclareVariantFunction( 1409 Ptr, AssociatedFunction.get(), TI, 1410 SourceRange(Loc, Tok.getLocation())); 1411 1412 // Skip last tokens. 1413 while (Tok.isNot(tok::annot_pragma_openmp_end)) 1414 ConsumeAnyToken(); 1415 if (DeclVarData && !TI.Sets.empty()) 1416 Actions.ActOnOpenMPDeclareVariantDirective( 1417 DeclVarData->first, DeclVarData->second, TI, 1418 SourceRange(Loc, Tok.getLocation())); 1419 1420 // Skip the last annot_pragma_openmp_end. 1421 (void)ConsumeAnnotationToken(); 1422 } 1423 1424 bool Parser::parseOMPDeclareVariantMatchClause(SourceLocation Loc, 1425 OMPTraitInfo &TI, 1426 OMPTraitInfo *ParentTI) { 1427 // Parse 'match'. 1428 OpenMPClauseKind CKind = Tok.isAnnotation() 1429 ? OMPC_unknown 1430 : getOpenMPClauseKind(PP.getSpelling(Tok)); 1431 if (CKind != OMPC_match) { 1432 Diag(Tok.getLocation(), diag::err_omp_declare_variant_wrong_clause) 1433 << getOpenMPClauseName(OMPC_match); 1434 while (!SkipUntil(tok::annot_pragma_openmp_end, Parser::StopBeforeMatch)) 1435 ; 1436 // Skip the last annot_pragma_openmp_end. 1437 (void)ConsumeAnnotationToken(); 1438 return true; 1439 } 1440 (void)ConsumeToken(); 1441 // Parse '('. 1442 BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); 1443 if (T.expectAndConsume(diag::err_expected_lparen_after, 1444 getOpenMPClauseName(OMPC_match).data())) { 1445 while (!SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch)) 1446 ; 1447 // Skip the last annot_pragma_openmp_end. 1448 (void)ConsumeAnnotationToken(); 1449 return true; 1450 } 1451 1452 // Parse inner context selectors. 1453 parseOMPContextSelectors(Loc, TI); 1454 1455 // Parse ')' 1456 (void)T.consumeClose(); 1457 1458 if (!ParentTI) 1459 return false; 1460 1461 // Merge the parent/outer trait info into the one we just parsed and diagnose 1462 // problems. 1463 // TODO: Keep some source location in the TI to provide better diagnostics. 1464 // TODO: Perform some kind of equivalence check on the condition and score 1465 // expressions. 1466 for (const OMPTraitSet &ParentSet : ParentTI->Sets) { 1467 bool MergedSet = false; 1468 for (OMPTraitSet &Set : TI.Sets) { 1469 if (Set.Kind != ParentSet.Kind) 1470 continue; 1471 MergedSet = true; 1472 for (const OMPTraitSelector &ParentSelector : ParentSet.Selectors) { 1473 bool MergedSelector = false; 1474 for (OMPTraitSelector &Selector : Set.Selectors) { 1475 if (Selector.Kind != ParentSelector.Kind) 1476 continue; 1477 MergedSelector = true; 1478 for (const OMPTraitProperty &ParentProperty : 1479 ParentSelector.Properties) { 1480 bool MergedProperty = false; 1481 for (OMPTraitProperty &Property : Selector.Properties) { 1482 // Ignore "equivalent" properties. 1483 if (Property.Kind != ParentProperty.Kind) 1484 continue; 1485 1486 // If the kind is the same but the raw string not, we don't want 1487 // to skip out on the property. 1488 MergedProperty |= Property.RawString == ParentProperty.RawString; 1489 1490 if (Property.RawString == ParentProperty.RawString && 1491 Selector.ScoreOrCondition == ParentSelector.ScoreOrCondition) 1492 continue; 1493 1494 if (Selector.Kind == llvm::omp::TraitSelector::user_condition) { 1495 Diag(Loc, diag::err_omp_declare_variant_nested_user_condition); 1496 } else if (Selector.ScoreOrCondition != 1497 ParentSelector.ScoreOrCondition) { 1498 Diag(Loc, diag::err_omp_declare_variant_duplicate_nested_trait) 1499 << getOpenMPContextTraitPropertyName( 1500 ParentProperty.Kind, ParentProperty.RawString) 1501 << getOpenMPContextTraitSelectorName(ParentSelector.Kind) 1502 << getOpenMPContextTraitSetName(ParentSet.Kind); 1503 } 1504 } 1505 if (!MergedProperty) 1506 Selector.Properties.push_back(ParentProperty); 1507 } 1508 } 1509 if (!MergedSelector) 1510 Set.Selectors.push_back(ParentSelector); 1511 } 1512 } 1513 if (!MergedSet) 1514 TI.Sets.push_back(ParentSet); 1515 } 1516 1517 return false; 1518 } 1519 1520 /// `omp assumes` or `omp begin/end assumes` <clause> [[,]<clause>]... 1521 /// where 1522 /// 1523 /// clause: 1524 /// 'ext_IMPL_DEFINED' 1525 /// 'absent' '(' directive-name [, directive-name]* ')' 1526 /// 'contains' '(' directive-name [, directive-name]* ')' 1527 /// 'holds' '(' scalar-expression ')' 1528 /// 'no_openmp' 1529 /// 'no_openmp_routines' 1530 /// 'no_parallelism' 1531 /// 1532 void Parser::ParseOpenMPAssumesDirective(OpenMPDirectiveKind DKind, 1533 SourceLocation Loc) { 1534 SmallVector<StringRef, 4> Assumptions; 1535 bool SkippedClauses = false; 1536 1537 auto SkipBraces = [&](llvm::StringRef Spelling, bool IssueNote) { 1538 BalancedDelimiterTracker T(*this, tok::l_paren, 1539 tok::annot_pragma_openmp_end); 1540 if (T.expectAndConsume(diag::err_expected_lparen_after, Spelling.data())) 1541 return; 1542 T.skipToEnd(); 1543 if (IssueNote && T.getCloseLocation().isValid()) 1544 Diag(T.getCloseLocation(), 1545 diag::note_omp_assumption_clause_continue_here); 1546 }; 1547 1548 /// Helper to determine which AssumptionClauseMapping (ACM) in the 1549 /// AssumptionClauseMappings table matches \p RawString. The return value is 1550 /// the index of the matching ACM into the table or -1 if there was no match. 1551 auto MatchACMClause = [&](StringRef RawString) { 1552 llvm::StringSwitch<int> SS(RawString); 1553 unsigned ACMIdx = 0; 1554 for (const AssumptionClauseMappingInfo &ACMI : AssumptionClauseMappings) { 1555 if (ACMI.StartsWith) 1556 SS.StartsWith(ACMI.Identifier, ACMIdx++); 1557 else 1558 SS.Case(ACMI.Identifier, ACMIdx++); 1559 } 1560 return SS.Default(-1); 1561 }; 1562 1563 while (Tok.isNot(tok::annot_pragma_openmp_end)) { 1564 IdentifierInfo *II = nullptr; 1565 SourceLocation StartLoc = Tok.getLocation(); 1566 int Idx = -1; 1567 if (Tok.isAnyIdentifier()) { 1568 II = Tok.getIdentifierInfo(); 1569 Idx = MatchACMClause(II->getName()); 1570 } 1571 ConsumeAnyToken(); 1572 1573 bool NextIsLPar = Tok.is(tok::l_paren); 1574 // Handle unknown clauses by skipping them. 1575 if (Idx == -1) { 1576 Diag(StartLoc, diag::warn_omp_unknown_assumption_clause_missing_id) 1577 << llvm::omp::getOpenMPDirectiveName(DKind) 1578 << llvm::omp::getAllAssumeClauseOptions() << NextIsLPar; 1579 if (NextIsLPar) 1580 SkipBraces(II ? II->getName() : "", /* IssueNote */ true); 1581 SkippedClauses = true; 1582 continue; 1583 } 1584 const AssumptionClauseMappingInfo &ACMI = AssumptionClauseMappings[Idx]; 1585 if (ACMI.HasDirectiveList || ACMI.HasExpression) { 1586 // TODO: We ignore absent, contains, and holds assumptions for now. We 1587 // also do not verify the content in the parenthesis at all. 1588 SkippedClauses = true; 1589 SkipBraces(II->getName(), /* IssueNote */ false); 1590 continue; 1591 } 1592 1593 if (NextIsLPar) { 1594 Diag(Tok.getLocation(), 1595 diag::warn_omp_unknown_assumption_clause_without_args) 1596 << II; 1597 SkipBraces(II->getName(), /* IssueNote */ true); 1598 } 1599 1600 assert(II && "Expected an identifier clause!"); 1601 StringRef Assumption = II->getName(); 1602 if (ACMI.StartsWith) 1603 Assumption = Assumption.substr(ACMI.Identifier.size()); 1604 Assumptions.push_back(Assumption); 1605 } 1606 1607 Actions.ActOnOpenMPAssumesDirective(Loc, DKind, Assumptions, SkippedClauses); 1608 } 1609 1610 void Parser::ParseOpenMPEndAssumesDirective(SourceLocation Loc) { 1611 if (Actions.isInOpenMPAssumeScope()) 1612 Actions.ActOnOpenMPEndAssumesDirective(); 1613 else 1614 Diag(Loc, diag::err_expected_begin_assumes); 1615 } 1616 1617 /// Parsing of simple OpenMP clauses like 'default' or 'proc_bind'. 1618 /// 1619 /// default-clause: 1620 /// 'default' '(' 'none' | 'shared' | 'firstprivate' ') 1621 /// 1622 /// proc_bind-clause: 1623 /// 'proc_bind' '(' 'master' | 'close' | 'spread' ') 1624 /// 1625 /// device_type-clause: 1626 /// 'device_type' '(' 'host' | 'nohost' | 'any' )' 1627 namespace { 1628 struct SimpleClauseData { 1629 unsigned Type; 1630 SourceLocation Loc; 1631 SourceLocation LOpen; 1632 SourceLocation TypeLoc; 1633 SourceLocation RLoc; 1634 SimpleClauseData(unsigned Type, SourceLocation Loc, SourceLocation LOpen, 1635 SourceLocation TypeLoc, SourceLocation RLoc) 1636 : Type(Type), Loc(Loc), LOpen(LOpen), TypeLoc(TypeLoc), RLoc(RLoc) {} 1637 }; 1638 } // anonymous namespace 1639 1640 static Optional<SimpleClauseData> 1641 parseOpenMPSimpleClause(Parser &P, OpenMPClauseKind Kind) { 1642 const Token &Tok = P.getCurToken(); 1643 SourceLocation Loc = Tok.getLocation(); 1644 SourceLocation LOpen = P.ConsumeToken(); 1645 // Parse '('. 1646 BalancedDelimiterTracker T(P, tok::l_paren, tok::annot_pragma_openmp_end); 1647 if (T.expectAndConsume(diag::err_expected_lparen_after, 1648 getOpenMPClauseName(Kind).data())) 1649 return llvm::None; 1650 1651 unsigned Type = getOpenMPSimpleClauseType( 1652 Kind, Tok.isAnnotation() ? "" : P.getPreprocessor().getSpelling(Tok), 1653 P.getLangOpts().OpenMP); 1654 SourceLocation TypeLoc = Tok.getLocation(); 1655 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) && 1656 Tok.isNot(tok::annot_pragma_openmp_end)) 1657 P.ConsumeAnyToken(); 1658 1659 // Parse ')'. 1660 SourceLocation RLoc = Tok.getLocation(); 1661 if (!T.consumeClose()) 1662 RLoc = T.getCloseLocation(); 1663 1664 return SimpleClauseData(Type, Loc, LOpen, TypeLoc, RLoc); 1665 } 1666 1667 Parser::DeclGroupPtrTy Parser::ParseOMPDeclareTargetClauses() { 1668 // OpenMP 4.5 syntax with list of entities. 1669 Sema::NamedDeclSetType SameDirectiveDecls; 1670 SmallVector<std::tuple<OMPDeclareTargetDeclAttr::MapTypeTy, SourceLocation, 1671 NamedDecl *>, 1672 4> 1673 DeclareTargetDecls; 1674 OMPDeclareTargetDeclAttr::DevTypeTy DT = OMPDeclareTargetDeclAttr::DT_Any; 1675 SourceLocation DeviceTypeLoc; 1676 while (Tok.isNot(tok::annot_pragma_openmp_end)) { 1677 OMPDeclareTargetDeclAttr::MapTypeTy MT = OMPDeclareTargetDeclAttr::MT_To; 1678 if (Tok.is(tok::identifier)) { 1679 IdentifierInfo *II = Tok.getIdentifierInfo(); 1680 StringRef ClauseName = II->getName(); 1681 bool IsDeviceTypeClause = 1682 getLangOpts().OpenMP >= 50 && 1683 getOpenMPClauseKind(ClauseName) == OMPC_device_type; 1684 // Parse 'to|link|device_type' clauses. 1685 if (!OMPDeclareTargetDeclAttr::ConvertStrToMapTypeTy(ClauseName, MT) && 1686 !IsDeviceTypeClause) { 1687 Diag(Tok, diag::err_omp_declare_target_unexpected_clause) 1688 << ClauseName << (getLangOpts().OpenMP >= 50 ? 1 : 0); 1689 break; 1690 } 1691 // Parse 'device_type' clause and go to next clause if any. 1692 if (IsDeviceTypeClause) { 1693 Optional<SimpleClauseData> DevTypeData = 1694 parseOpenMPSimpleClause(*this, OMPC_device_type); 1695 if (DevTypeData.hasValue()) { 1696 if (DeviceTypeLoc.isValid()) { 1697 // We already saw another device_type clause, diagnose it. 1698 Diag(DevTypeData.getValue().Loc, 1699 diag::warn_omp_more_one_device_type_clause); 1700 } 1701 switch (static_cast<OpenMPDeviceType>(DevTypeData.getValue().Type)) { 1702 case OMPC_DEVICE_TYPE_any: 1703 DT = OMPDeclareTargetDeclAttr::DT_Any; 1704 break; 1705 case OMPC_DEVICE_TYPE_host: 1706 DT = OMPDeclareTargetDeclAttr::DT_Host; 1707 break; 1708 case OMPC_DEVICE_TYPE_nohost: 1709 DT = OMPDeclareTargetDeclAttr::DT_NoHost; 1710 break; 1711 case OMPC_DEVICE_TYPE_unknown: 1712 llvm_unreachable("Unexpected device_type"); 1713 } 1714 DeviceTypeLoc = DevTypeData.getValue().Loc; 1715 } 1716 continue; 1717 } 1718 ConsumeToken(); 1719 } 1720 auto &&Callback = [this, MT, &DeclareTargetDecls, &SameDirectiveDecls]( 1721 CXXScopeSpec &SS, DeclarationNameInfo NameInfo) { 1722 NamedDecl *ND = Actions.lookupOpenMPDeclareTargetName( 1723 getCurScope(), SS, NameInfo, SameDirectiveDecls); 1724 if (ND) 1725 DeclareTargetDecls.emplace_back(MT, NameInfo.getLoc(), ND); 1726 }; 1727 if (ParseOpenMPSimpleVarList(OMPD_declare_target, Callback, 1728 /*AllowScopeSpecifier=*/true)) 1729 break; 1730 1731 // Consume optional ','. 1732 if (Tok.is(tok::comma)) 1733 ConsumeToken(); 1734 } 1735 SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch); 1736 ConsumeAnyToken(); 1737 for (auto &MTLocDecl : DeclareTargetDecls) { 1738 OMPDeclareTargetDeclAttr::MapTypeTy MT; 1739 SourceLocation Loc; 1740 NamedDecl *ND; 1741 std::tie(MT, Loc, ND) = MTLocDecl; 1742 // device_type clause is applied only to functions. 1743 Actions.ActOnOpenMPDeclareTargetName( 1744 ND, Loc, MT, isa<VarDecl>(ND) ? OMPDeclareTargetDeclAttr::DT_Any : DT); 1745 } 1746 SmallVector<Decl *, 4> Decls(SameDirectiveDecls.begin(), 1747 SameDirectiveDecls.end()); 1748 if (Decls.empty()) 1749 return DeclGroupPtrTy(); 1750 return Actions.BuildDeclaratorGroup(Decls); 1751 } 1752 1753 void Parser::skipUntilPragmaOpenMPEnd(OpenMPDirectiveKind DKind) { 1754 // The last seen token is annot_pragma_openmp_end - need to check for 1755 // extra tokens. 1756 if (Tok.is(tok::annot_pragma_openmp_end)) 1757 return; 1758 1759 Diag(Tok, diag::warn_omp_extra_tokens_at_eol) 1760 << getOpenMPDirectiveName(DKind); 1761 while (Tok.isNot(tok::annot_pragma_openmp_end)) 1762 ConsumeAnyToken(); 1763 } 1764 1765 void Parser::parseOMPEndDirective(OpenMPDirectiveKind BeginKind, 1766 OpenMPDirectiveKind ExpectedKind, 1767 OpenMPDirectiveKind FoundKind, 1768 SourceLocation BeginLoc, 1769 SourceLocation FoundLoc, 1770 bool SkipUntilOpenMPEnd) { 1771 int DiagSelection = ExpectedKind == OMPD_end_declare_target ? 0 : 1; 1772 1773 if (FoundKind == ExpectedKind) { 1774 ConsumeAnyToken(); 1775 skipUntilPragmaOpenMPEnd(ExpectedKind); 1776 return; 1777 } 1778 1779 Diag(FoundLoc, diag::err_expected_end_declare_target_or_variant) 1780 << DiagSelection; 1781 Diag(BeginLoc, diag::note_matching) 1782 << ("'#pragma omp " + getOpenMPDirectiveName(BeginKind) + "'").str(); 1783 if (SkipUntilOpenMPEnd) 1784 SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch); 1785 } 1786 1787 void Parser::ParseOMPEndDeclareTargetDirective(OpenMPDirectiveKind DKind, 1788 SourceLocation DKLoc) { 1789 parseOMPEndDirective(OMPD_declare_target, OMPD_end_declare_target, DKind, 1790 DKLoc, Tok.getLocation(), 1791 /* SkipUntilOpenMPEnd */ false); 1792 // Skip the last annot_pragma_openmp_end. 1793 if (Tok.is(tok::annot_pragma_openmp_end)) 1794 ConsumeAnnotationToken(); 1795 } 1796 1797 /// Parsing of declarative OpenMP directives. 1798 /// 1799 /// threadprivate-directive: 1800 /// annot_pragma_openmp 'threadprivate' simple-variable-list 1801 /// annot_pragma_openmp_end 1802 /// 1803 /// allocate-directive: 1804 /// annot_pragma_openmp 'allocate' simple-variable-list [<clause>] 1805 /// annot_pragma_openmp_end 1806 /// 1807 /// declare-reduction-directive: 1808 /// annot_pragma_openmp 'declare' 'reduction' [...] 1809 /// annot_pragma_openmp_end 1810 /// 1811 /// declare-mapper-directive: 1812 /// annot_pragma_openmp 'declare' 'mapper' '(' [<mapper-identifer> ':'] 1813 /// <type> <var> ')' [<clause>[[,] <clause>] ... ] 1814 /// annot_pragma_openmp_end 1815 /// 1816 /// declare-simd-directive: 1817 /// annot_pragma_openmp 'declare simd' {<clause> [,]} 1818 /// annot_pragma_openmp_end 1819 /// <function declaration/definition> 1820 /// 1821 /// requires directive: 1822 /// annot_pragma_openmp 'requires' <clause> [[[,] <clause>] ... ] 1823 /// annot_pragma_openmp_end 1824 /// 1825 /// assumes directive: 1826 /// annot_pragma_openmp 'assumes' <clause> [[[,] <clause>] ... ] 1827 /// annot_pragma_openmp_end 1828 /// or 1829 /// annot_pragma_openmp 'begin assumes' <clause> [[[,] <clause>] ... ] 1830 /// annot_pragma_openmp 'end assumes' 1831 /// annot_pragma_openmp_end 1832 /// 1833 Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirectiveWithExtDecl( 1834 AccessSpecifier &AS, ParsedAttributesWithRange &Attrs, bool Delayed, 1835 DeclSpec::TST TagType, Decl *Tag) { 1836 assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!"); 1837 ParsingOpenMPDirectiveRAII DirScope(*this); 1838 ParenBraceBracketBalancer BalancerRAIIObj(*this); 1839 1840 SourceLocation Loc; 1841 OpenMPDirectiveKind DKind; 1842 if (Delayed) { 1843 TentativeParsingAction TPA(*this); 1844 Loc = ConsumeAnnotationToken(); 1845 DKind = parseOpenMPDirectiveKind(*this); 1846 if (DKind == OMPD_declare_reduction || DKind == OMPD_declare_mapper) { 1847 // Need to delay parsing until completion of the parent class. 1848 TPA.Revert(); 1849 CachedTokens Toks; 1850 unsigned Cnt = 1; 1851 Toks.push_back(Tok); 1852 while (Cnt && Tok.isNot(tok::eof)) { 1853 (void)ConsumeAnyToken(); 1854 if (Tok.is(tok::annot_pragma_openmp)) 1855 ++Cnt; 1856 else if (Tok.is(tok::annot_pragma_openmp_end)) 1857 --Cnt; 1858 Toks.push_back(Tok); 1859 } 1860 // Skip last annot_pragma_openmp_end. 1861 if (Cnt == 0) 1862 (void)ConsumeAnyToken(); 1863 auto *LP = new LateParsedPragma(this, AS); 1864 LP->takeToks(Toks); 1865 getCurrentClass().LateParsedDeclarations.push_back(LP); 1866 return nullptr; 1867 } 1868 TPA.Commit(); 1869 } else { 1870 Loc = ConsumeAnnotationToken(); 1871 DKind = parseOpenMPDirectiveKind(*this); 1872 } 1873 1874 switch (DKind) { 1875 case OMPD_threadprivate: { 1876 ConsumeToken(); 1877 DeclDirectiveListParserHelper Helper(this, DKind); 1878 if (!ParseOpenMPSimpleVarList(DKind, Helper, 1879 /*AllowScopeSpecifier=*/true)) { 1880 skipUntilPragmaOpenMPEnd(DKind); 1881 // Skip the last annot_pragma_openmp_end. 1882 ConsumeAnnotationToken(); 1883 return Actions.ActOnOpenMPThreadprivateDirective(Loc, 1884 Helper.getIdentifiers()); 1885 } 1886 break; 1887 } 1888 case OMPD_allocate: { 1889 ConsumeToken(); 1890 DeclDirectiveListParserHelper Helper(this, DKind); 1891 if (!ParseOpenMPSimpleVarList(DKind, Helper, 1892 /*AllowScopeSpecifier=*/true)) { 1893 SmallVector<OMPClause *, 1> Clauses; 1894 if (Tok.isNot(tok::annot_pragma_openmp_end)) { 1895 SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>, 1896 llvm::omp::Clause_enumSize + 1> 1897 FirstClauses(llvm::omp::Clause_enumSize + 1); 1898 while (Tok.isNot(tok::annot_pragma_openmp_end)) { 1899 OpenMPClauseKind CKind = 1900 Tok.isAnnotation() ? OMPC_unknown 1901 : getOpenMPClauseKind(PP.getSpelling(Tok)); 1902 Actions.StartOpenMPClause(CKind); 1903 OMPClause *Clause = ParseOpenMPClause( 1904 OMPD_allocate, CKind, !FirstClauses[unsigned(CKind)].getInt()); 1905 SkipUntil(tok::comma, tok::identifier, tok::annot_pragma_openmp_end, 1906 StopBeforeMatch); 1907 FirstClauses[unsigned(CKind)].setInt(true); 1908 if (Clause != nullptr) 1909 Clauses.push_back(Clause); 1910 if (Tok.is(tok::annot_pragma_openmp_end)) { 1911 Actions.EndOpenMPClause(); 1912 break; 1913 } 1914 // Skip ',' if any. 1915 if (Tok.is(tok::comma)) 1916 ConsumeToken(); 1917 Actions.EndOpenMPClause(); 1918 } 1919 skipUntilPragmaOpenMPEnd(DKind); 1920 } 1921 // Skip the last annot_pragma_openmp_end. 1922 ConsumeAnnotationToken(); 1923 return Actions.ActOnOpenMPAllocateDirective(Loc, Helper.getIdentifiers(), 1924 Clauses); 1925 } 1926 break; 1927 } 1928 case OMPD_requires: { 1929 SourceLocation StartLoc = ConsumeToken(); 1930 SmallVector<OMPClause *, 5> Clauses; 1931 SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>, 1932 llvm::omp::Clause_enumSize + 1> 1933 FirstClauses(llvm::omp::Clause_enumSize + 1); 1934 if (Tok.is(tok::annot_pragma_openmp_end)) { 1935 Diag(Tok, diag::err_omp_expected_clause) 1936 << getOpenMPDirectiveName(OMPD_requires); 1937 break; 1938 } 1939 while (Tok.isNot(tok::annot_pragma_openmp_end)) { 1940 OpenMPClauseKind CKind = Tok.isAnnotation() 1941 ? OMPC_unknown 1942 : getOpenMPClauseKind(PP.getSpelling(Tok)); 1943 Actions.StartOpenMPClause(CKind); 1944 OMPClause *Clause = ParseOpenMPClause( 1945 OMPD_requires, CKind, !FirstClauses[unsigned(CKind)].getInt()); 1946 SkipUntil(tok::comma, tok::identifier, tok::annot_pragma_openmp_end, 1947 StopBeforeMatch); 1948 FirstClauses[unsigned(CKind)].setInt(true); 1949 if (Clause != nullptr) 1950 Clauses.push_back(Clause); 1951 if (Tok.is(tok::annot_pragma_openmp_end)) { 1952 Actions.EndOpenMPClause(); 1953 break; 1954 } 1955 // Skip ',' if any. 1956 if (Tok.is(tok::comma)) 1957 ConsumeToken(); 1958 Actions.EndOpenMPClause(); 1959 } 1960 // Consume final annot_pragma_openmp_end 1961 if (Clauses.empty()) { 1962 Diag(Tok, diag::err_omp_expected_clause) 1963 << getOpenMPDirectiveName(OMPD_requires); 1964 ConsumeAnnotationToken(); 1965 return nullptr; 1966 } 1967 ConsumeAnnotationToken(); 1968 return Actions.ActOnOpenMPRequiresDirective(StartLoc, Clauses); 1969 } 1970 case OMPD_assumes: 1971 case OMPD_begin_assumes: 1972 ParseOpenMPAssumesDirective(DKind, ConsumeToken()); 1973 break; 1974 case OMPD_end_assumes: 1975 ParseOpenMPEndAssumesDirective(ConsumeToken()); 1976 break; 1977 case OMPD_declare_reduction: 1978 ConsumeToken(); 1979 if (DeclGroupPtrTy Res = ParseOpenMPDeclareReductionDirective(AS)) { 1980 skipUntilPragmaOpenMPEnd(OMPD_declare_reduction); 1981 // Skip the last annot_pragma_openmp_end. 1982 ConsumeAnnotationToken(); 1983 return Res; 1984 } 1985 break; 1986 case OMPD_declare_mapper: { 1987 ConsumeToken(); 1988 if (DeclGroupPtrTy Res = ParseOpenMPDeclareMapperDirective(AS)) { 1989 // Skip the last annot_pragma_openmp_end. 1990 ConsumeAnnotationToken(); 1991 return Res; 1992 } 1993 break; 1994 } 1995 case OMPD_begin_declare_variant: { 1996 // The syntax is: 1997 // { #pragma omp begin declare variant clause } 1998 // <function-declaration-or-definition-sequence> 1999 // { #pragma omp end declare variant } 2000 // 2001 ConsumeToken(); 2002 OMPTraitInfo *ParentTI = Actions.getOMPTraitInfoForSurroundingScope(); 2003 ASTContext &ASTCtx = Actions.getASTContext(); 2004 OMPTraitInfo &TI = ASTCtx.getNewOMPTraitInfo(); 2005 if (parseOMPDeclareVariantMatchClause(Loc, TI, ParentTI)) 2006 break; 2007 2008 // Skip last tokens. 2009 skipUntilPragmaOpenMPEnd(OMPD_begin_declare_variant); 2010 2011 ParsingOpenMPDirectiveRAII NormalScope(*this, /*Value=*/false); 2012 2013 VariantMatchInfo VMI; 2014 TI.getAsVariantMatchInfo(ASTCtx, VMI); 2015 2016 std::function<void(StringRef)> DiagUnknownTrait = [this, Loc]( 2017 StringRef ISATrait) { 2018 // TODO Track the selector locations in a way that is accessible here to 2019 // improve the diagnostic location. 2020 Diag(Loc, diag::warn_unknown_begin_declare_variant_isa_trait) << ISATrait; 2021 }; 2022 TargetOMPContext OMPCtx(ASTCtx, std::move(DiagUnknownTrait), 2023 /* CurrentFunctionDecl */ nullptr); 2024 2025 if (isVariantApplicableInContext(VMI, OMPCtx, /* DeviceSetOnly */ true)) { 2026 Actions.ActOnOpenMPBeginDeclareVariant(Loc, TI); 2027 break; 2028 } 2029 2030 // Elide all the code till the matching end declare variant was found. 2031 unsigned Nesting = 1; 2032 SourceLocation DKLoc; 2033 OpenMPDirectiveKind DK = OMPD_unknown; 2034 do { 2035 DKLoc = Tok.getLocation(); 2036 DK = parseOpenMPDirectiveKind(*this); 2037 if (DK == OMPD_end_declare_variant) 2038 --Nesting; 2039 else if (DK == OMPD_begin_declare_variant) 2040 ++Nesting; 2041 if (!Nesting || isEofOrEom()) 2042 break; 2043 ConsumeAnyToken(); 2044 } while (true); 2045 2046 parseOMPEndDirective(OMPD_begin_declare_variant, OMPD_end_declare_variant, 2047 DK, Loc, DKLoc, /* SkipUntilOpenMPEnd */ true); 2048 if (isEofOrEom()) 2049 return nullptr; 2050 break; 2051 } 2052 case OMPD_end_declare_variant: { 2053 if (Actions.isInOpenMPDeclareVariantScope()) 2054 Actions.ActOnOpenMPEndDeclareVariant(); 2055 else 2056 Diag(Loc, diag::err_expected_begin_declare_variant); 2057 ConsumeToken(); 2058 break; 2059 } 2060 case OMPD_declare_variant: 2061 case OMPD_declare_simd: { 2062 // The syntax is: 2063 // { #pragma omp declare {simd|variant} } 2064 // <function-declaration-or-definition> 2065 // 2066 CachedTokens Toks; 2067 Toks.push_back(Tok); 2068 ConsumeToken(); 2069 while (Tok.isNot(tok::annot_pragma_openmp_end)) { 2070 Toks.push_back(Tok); 2071 ConsumeAnyToken(); 2072 } 2073 Toks.push_back(Tok); 2074 ConsumeAnyToken(); 2075 2076 DeclGroupPtrTy Ptr; 2077 if (Tok.is(tok::annot_pragma_openmp)) { 2078 Ptr = ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, Attrs, Delayed, 2079 TagType, Tag); 2080 } else if (Tok.isNot(tok::r_brace) && !isEofOrEom()) { 2081 // Here we expect to see some function declaration. 2082 if (AS == AS_none) { 2083 assert(TagType == DeclSpec::TST_unspecified); 2084 MaybeParseCXX11Attributes(Attrs); 2085 ParsingDeclSpec PDS(*this); 2086 Ptr = ParseExternalDeclaration(Attrs, &PDS); 2087 } else { 2088 Ptr = 2089 ParseCXXClassMemberDeclarationWithPragmas(AS, Attrs, TagType, Tag); 2090 } 2091 } 2092 if (!Ptr) { 2093 Diag(Loc, diag::err_omp_decl_in_declare_simd_variant) 2094 << (DKind == OMPD_declare_simd ? 0 : 1); 2095 return DeclGroupPtrTy(); 2096 } 2097 if (DKind == OMPD_declare_simd) 2098 return ParseOMPDeclareSimdClauses(Ptr, Toks, Loc); 2099 assert(DKind == OMPD_declare_variant && 2100 "Expected declare variant directive only"); 2101 ParseOMPDeclareVariantClauses(Ptr, Toks, Loc); 2102 return Ptr; 2103 } 2104 case OMPD_declare_target: { 2105 SourceLocation DTLoc = ConsumeAnyToken(); 2106 if (Tok.isNot(tok::annot_pragma_openmp_end)) { 2107 return ParseOMPDeclareTargetClauses(); 2108 } 2109 2110 // Skip the last annot_pragma_openmp_end. 2111 ConsumeAnyToken(); 2112 2113 if (!Actions.ActOnStartOpenMPDeclareTargetDirective(DTLoc)) 2114 return DeclGroupPtrTy(); 2115 2116 ParsingOpenMPDirectiveRAII NormalScope(*this, /*Value=*/false); 2117 llvm::SmallVector<Decl *, 4> Decls; 2118 while (Tok.isNot(tok::eof) && Tok.isNot(tok::r_brace)) { 2119 if (Tok.isAnnotation() && Tok.is(tok::annot_pragma_openmp)) { 2120 TentativeParsingAction TPA(*this); 2121 ConsumeAnnotationToken(); 2122 DKind = parseOpenMPDirectiveKind(*this); 2123 if (DKind != OMPD_end_declare_target) 2124 TPA.Revert(); 2125 else 2126 TPA.Commit(); 2127 } 2128 if (DKind == OMPD_end_declare_target) 2129 break; 2130 DeclGroupPtrTy Ptr; 2131 // Here we expect to see some function declaration. 2132 if (AS == AS_none) { 2133 assert(TagType == DeclSpec::TST_unspecified); 2134 MaybeParseCXX11Attributes(Attrs); 2135 ParsingDeclSpec PDS(*this); 2136 Ptr = ParseExternalDeclaration(Attrs, &PDS); 2137 } else { 2138 Ptr = 2139 ParseCXXClassMemberDeclarationWithPragmas(AS, Attrs, TagType, Tag); 2140 } 2141 if (Ptr) { 2142 DeclGroupRef Ref = Ptr.get(); 2143 Decls.append(Ref.begin(), Ref.end()); 2144 } 2145 } 2146 2147 ParseOMPEndDeclareTargetDirective(DKind, DTLoc); 2148 Actions.ActOnFinishOpenMPDeclareTargetDirective(); 2149 return Actions.BuildDeclaratorGroup(Decls); 2150 } 2151 case OMPD_unknown: 2152 Diag(Tok, diag::err_omp_unknown_directive); 2153 break; 2154 case OMPD_parallel: 2155 case OMPD_simd: 2156 case OMPD_tile: 2157 case OMPD_task: 2158 case OMPD_taskyield: 2159 case OMPD_barrier: 2160 case OMPD_taskwait: 2161 case OMPD_taskgroup: 2162 case OMPD_flush: 2163 case OMPD_depobj: 2164 case OMPD_scan: 2165 case OMPD_for: 2166 case OMPD_for_simd: 2167 case OMPD_sections: 2168 case OMPD_section: 2169 case OMPD_single: 2170 case OMPD_master: 2171 case OMPD_ordered: 2172 case OMPD_critical: 2173 case OMPD_parallel_for: 2174 case OMPD_parallel_for_simd: 2175 case OMPD_parallel_sections: 2176 case OMPD_parallel_master: 2177 case OMPD_atomic: 2178 case OMPD_target: 2179 case OMPD_teams: 2180 case OMPD_cancellation_point: 2181 case OMPD_cancel: 2182 case OMPD_target_data: 2183 case OMPD_target_enter_data: 2184 case OMPD_target_exit_data: 2185 case OMPD_target_parallel: 2186 case OMPD_target_parallel_for: 2187 case OMPD_taskloop: 2188 case OMPD_taskloop_simd: 2189 case OMPD_master_taskloop: 2190 case OMPD_master_taskloop_simd: 2191 case OMPD_parallel_master_taskloop: 2192 case OMPD_parallel_master_taskloop_simd: 2193 case OMPD_distribute: 2194 case OMPD_end_declare_target: 2195 case OMPD_target_update: 2196 case OMPD_distribute_parallel_for: 2197 case OMPD_distribute_parallel_for_simd: 2198 case OMPD_distribute_simd: 2199 case OMPD_target_parallel_for_simd: 2200 case OMPD_target_simd: 2201 case OMPD_teams_distribute: 2202 case OMPD_teams_distribute_simd: 2203 case OMPD_teams_distribute_parallel_for_simd: 2204 case OMPD_teams_distribute_parallel_for: 2205 case OMPD_target_teams: 2206 case OMPD_target_teams_distribute: 2207 case OMPD_target_teams_distribute_parallel_for: 2208 case OMPD_target_teams_distribute_parallel_for_simd: 2209 case OMPD_target_teams_distribute_simd: 2210 case OMPD_dispatch: 2211 case OMPD_masked: 2212 Diag(Tok, diag::err_omp_unexpected_directive) 2213 << 1 << getOpenMPDirectiveName(DKind); 2214 break; 2215 default: 2216 break; 2217 } 2218 while (Tok.isNot(tok::annot_pragma_openmp_end)) 2219 ConsumeAnyToken(); 2220 ConsumeAnyToken(); 2221 return nullptr; 2222 } 2223 2224 /// Parsing of declarative or executable OpenMP directives. 2225 /// 2226 /// threadprivate-directive: 2227 /// annot_pragma_openmp 'threadprivate' simple-variable-list 2228 /// annot_pragma_openmp_end 2229 /// 2230 /// allocate-directive: 2231 /// annot_pragma_openmp 'allocate' simple-variable-list 2232 /// annot_pragma_openmp_end 2233 /// 2234 /// declare-reduction-directive: 2235 /// annot_pragma_openmp 'declare' 'reduction' '(' <reduction_id> ':' 2236 /// <type> {',' <type>} ':' <expression> ')' ['initializer' '(' 2237 /// ('omp_priv' '=' <expression>|<function_call>) ')'] 2238 /// annot_pragma_openmp_end 2239 /// 2240 /// declare-mapper-directive: 2241 /// annot_pragma_openmp 'declare' 'mapper' '(' [<mapper-identifer> ':'] 2242 /// <type> <var> ')' [<clause>[[,] <clause>] ... ] 2243 /// annot_pragma_openmp_end 2244 /// 2245 /// executable-directive: 2246 /// annot_pragma_openmp 'parallel' | 'simd' | 'for' | 'sections' | 2247 /// 'section' | 'single' | 'master' | 'critical' [ '(' <name> ')' ] | 2248 /// 'parallel for' | 'parallel sections' | 'parallel master' | 'task' | 2249 /// 'taskyield' | 'barrier' | 'taskwait' | 'flush' | 'ordered' | 2250 /// 'atomic' | 'for simd' | 'parallel for simd' | 'target' | 'target 2251 /// data' | 'taskgroup' | 'teams' | 'taskloop' | 'taskloop simd' | 2252 /// 'master taskloop' | 'master taskloop simd' | 'parallel master 2253 /// taskloop' | 'parallel master taskloop simd' | 'distribute' | 'target 2254 /// enter data' | 'target exit data' | 'target parallel' | 'target 2255 /// parallel for' | 'target update' | 'distribute parallel for' | 2256 /// 'distribute paralle for simd' | 'distribute simd' | 'target parallel 2257 /// for simd' | 'target simd' | 'teams distribute' | 'teams distribute 2258 /// simd' | 'teams distribute parallel for simd' | 'teams distribute 2259 /// parallel for' | 'target teams' | 'target teams distribute' | 'target 2260 /// teams distribute parallel for' | 'target teams distribute parallel 2261 /// for simd' | 'target teams distribute simd' | 'masked' {clause} 2262 /// annot_pragma_openmp_end 2263 /// 2264 StmtResult 2265 Parser::ParseOpenMPDeclarativeOrExecutableDirective(ParsedStmtContext StmtCtx) { 2266 assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!"); 2267 ParsingOpenMPDirectiveRAII DirScope(*this); 2268 ParenBraceBracketBalancer BalancerRAIIObj(*this); 2269 SmallVector<OMPClause *, 5> Clauses; 2270 SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>, 2271 llvm::omp::Clause_enumSize + 1> 2272 FirstClauses(llvm::omp::Clause_enumSize + 1); 2273 unsigned ScopeFlags = Scope::FnScope | Scope::DeclScope | 2274 Scope::CompoundStmtScope | Scope::OpenMPDirectiveScope; 2275 SourceLocation Loc = ConsumeAnnotationToken(), EndLoc; 2276 OpenMPDirectiveKind DKind = parseOpenMPDirectiveKind(*this); 2277 OpenMPDirectiveKind CancelRegion = OMPD_unknown; 2278 // Name of critical directive. 2279 DeclarationNameInfo DirName; 2280 StmtResult Directive = StmtError(); 2281 bool HasAssociatedStatement = true; 2282 2283 switch (DKind) { 2284 case OMPD_threadprivate: { 2285 // FIXME: Should this be permitted in C++? 2286 if ((StmtCtx & ParsedStmtContext::AllowDeclarationsInC) == 2287 ParsedStmtContext()) { 2288 Diag(Tok, diag::err_omp_immediate_directive) 2289 << getOpenMPDirectiveName(DKind) << 0; 2290 } 2291 ConsumeToken(); 2292 DeclDirectiveListParserHelper Helper(this, DKind); 2293 if (!ParseOpenMPSimpleVarList(DKind, Helper, 2294 /*AllowScopeSpecifier=*/false)) { 2295 skipUntilPragmaOpenMPEnd(DKind); 2296 DeclGroupPtrTy Res = Actions.ActOnOpenMPThreadprivateDirective( 2297 Loc, Helper.getIdentifiers()); 2298 Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation()); 2299 } 2300 SkipUntil(tok::annot_pragma_openmp_end); 2301 break; 2302 } 2303 case OMPD_allocate: { 2304 // FIXME: Should this be permitted in C++? 2305 if ((StmtCtx & ParsedStmtContext::AllowDeclarationsInC) == 2306 ParsedStmtContext()) { 2307 Diag(Tok, diag::err_omp_immediate_directive) 2308 << getOpenMPDirectiveName(DKind) << 0; 2309 } 2310 ConsumeToken(); 2311 DeclDirectiveListParserHelper Helper(this, DKind); 2312 if (!ParseOpenMPSimpleVarList(DKind, Helper, 2313 /*AllowScopeSpecifier=*/false)) { 2314 SmallVector<OMPClause *, 1> Clauses; 2315 if (Tok.isNot(tok::annot_pragma_openmp_end)) { 2316 SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>, 2317 llvm::omp::Clause_enumSize + 1> 2318 FirstClauses(llvm::omp::Clause_enumSize + 1); 2319 while (Tok.isNot(tok::annot_pragma_openmp_end)) { 2320 OpenMPClauseKind CKind = 2321 Tok.isAnnotation() ? OMPC_unknown 2322 : getOpenMPClauseKind(PP.getSpelling(Tok)); 2323 Actions.StartOpenMPClause(CKind); 2324 OMPClause *Clause = ParseOpenMPClause( 2325 OMPD_allocate, CKind, !FirstClauses[unsigned(CKind)].getInt()); 2326 SkipUntil(tok::comma, tok::identifier, tok::annot_pragma_openmp_end, 2327 StopBeforeMatch); 2328 FirstClauses[unsigned(CKind)].setInt(true); 2329 if (Clause != nullptr) 2330 Clauses.push_back(Clause); 2331 if (Tok.is(tok::annot_pragma_openmp_end)) { 2332 Actions.EndOpenMPClause(); 2333 break; 2334 } 2335 // Skip ',' if any. 2336 if (Tok.is(tok::comma)) 2337 ConsumeToken(); 2338 Actions.EndOpenMPClause(); 2339 } 2340 skipUntilPragmaOpenMPEnd(DKind); 2341 } 2342 DeclGroupPtrTy Res = Actions.ActOnOpenMPAllocateDirective( 2343 Loc, Helper.getIdentifiers(), Clauses); 2344 Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation()); 2345 } 2346 SkipUntil(tok::annot_pragma_openmp_end); 2347 break; 2348 } 2349 case OMPD_declare_reduction: 2350 ConsumeToken(); 2351 if (DeclGroupPtrTy Res = 2352 ParseOpenMPDeclareReductionDirective(/*AS=*/AS_none)) { 2353 skipUntilPragmaOpenMPEnd(OMPD_declare_reduction); 2354 ConsumeAnyToken(); 2355 Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation()); 2356 } else { 2357 SkipUntil(tok::annot_pragma_openmp_end); 2358 } 2359 break; 2360 case OMPD_declare_mapper: { 2361 ConsumeToken(); 2362 if (DeclGroupPtrTy Res = 2363 ParseOpenMPDeclareMapperDirective(/*AS=*/AS_none)) { 2364 // Skip the last annot_pragma_openmp_end. 2365 ConsumeAnnotationToken(); 2366 Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation()); 2367 } else { 2368 SkipUntil(tok::annot_pragma_openmp_end); 2369 } 2370 break; 2371 } 2372 case OMPD_flush: 2373 case OMPD_depobj: 2374 case OMPD_scan: 2375 case OMPD_taskyield: 2376 case OMPD_barrier: 2377 case OMPD_taskwait: 2378 case OMPD_cancellation_point: 2379 case OMPD_cancel: 2380 case OMPD_target_enter_data: 2381 case OMPD_target_exit_data: 2382 case OMPD_target_update: 2383 case OMPD_interop: 2384 if ((StmtCtx & ParsedStmtContext::AllowStandaloneOpenMPDirectives) == 2385 ParsedStmtContext()) { 2386 Diag(Tok, diag::err_omp_immediate_directive) 2387 << getOpenMPDirectiveName(DKind) << 0; 2388 } 2389 HasAssociatedStatement = false; 2390 // Fall through for further analysis. 2391 LLVM_FALLTHROUGH; 2392 case OMPD_parallel: 2393 case OMPD_simd: 2394 case OMPD_tile: 2395 case OMPD_for: 2396 case OMPD_for_simd: 2397 case OMPD_sections: 2398 case OMPD_single: 2399 case OMPD_section: 2400 case OMPD_master: 2401 case OMPD_critical: 2402 case OMPD_parallel_for: 2403 case OMPD_parallel_for_simd: 2404 case OMPD_parallel_sections: 2405 case OMPD_parallel_master: 2406 case OMPD_task: 2407 case OMPD_ordered: 2408 case OMPD_atomic: 2409 case OMPD_target: 2410 case OMPD_teams: 2411 case OMPD_taskgroup: 2412 case OMPD_target_data: 2413 case OMPD_target_parallel: 2414 case OMPD_target_parallel_for: 2415 case OMPD_taskloop: 2416 case OMPD_taskloop_simd: 2417 case OMPD_master_taskloop: 2418 case OMPD_master_taskloop_simd: 2419 case OMPD_parallel_master_taskloop: 2420 case OMPD_parallel_master_taskloop_simd: 2421 case OMPD_distribute: 2422 case OMPD_distribute_parallel_for: 2423 case OMPD_distribute_parallel_for_simd: 2424 case OMPD_distribute_simd: 2425 case OMPD_target_parallel_for_simd: 2426 case OMPD_target_simd: 2427 case OMPD_teams_distribute: 2428 case OMPD_teams_distribute_simd: 2429 case OMPD_teams_distribute_parallel_for_simd: 2430 case OMPD_teams_distribute_parallel_for: 2431 case OMPD_target_teams: 2432 case OMPD_target_teams_distribute: 2433 case OMPD_target_teams_distribute_parallel_for: 2434 case OMPD_target_teams_distribute_parallel_for_simd: 2435 case OMPD_target_teams_distribute_simd: 2436 case OMPD_dispatch: 2437 case OMPD_masked: { 2438 // Special processing for flush and depobj clauses. 2439 Token ImplicitTok; 2440 bool ImplicitClauseAllowed = false; 2441 if (DKind == OMPD_flush || DKind == OMPD_depobj) { 2442 ImplicitTok = Tok; 2443 ImplicitClauseAllowed = true; 2444 } 2445 ConsumeToken(); 2446 // Parse directive name of the 'critical' directive if any. 2447 if (DKind == OMPD_critical) { 2448 BalancedDelimiterTracker T(*this, tok::l_paren, 2449 tok::annot_pragma_openmp_end); 2450 if (!T.consumeOpen()) { 2451 if (Tok.isAnyIdentifier()) { 2452 DirName = 2453 DeclarationNameInfo(Tok.getIdentifierInfo(), Tok.getLocation()); 2454 ConsumeAnyToken(); 2455 } else { 2456 Diag(Tok, diag::err_omp_expected_identifier_for_critical); 2457 } 2458 T.consumeClose(); 2459 } 2460 } else if (DKind == OMPD_cancellation_point || DKind == OMPD_cancel) { 2461 CancelRegion = parseOpenMPDirectiveKind(*this); 2462 if (Tok.isNot(tok::annot_pragma_openmp_end)) 2463 ConsumeToken(); 2464 } 2465 2466 if (isOpenMPLoopDirective(DKind)) 2467 ScopeFlags |= Scope::OpenMPLoopDirectiveScope; 2468 if (isOpenMPSimdDirective(DKind)) 2469 ScopeFlags |= Scope::OpenMPSimdDirectiveScope; 2470 ParseScope OMPDirectiveScope(this, ScopeFlags); 2471 Actions.StartOpenMPDSABlock(DKind, DirName, Actions.getCurScope(), Loc); 2472 2473 while (Tok.isNot(tok::annot_pragma_openmp_end)) { 2474 bool HasImplicitClause = false; 2475 if (ImplicitClauseAllowed && Tok.is(tok::l_paren)) { 2476 HasImplicitClause = true; 2477 // Push copy of the current token back to stream to properly parse 2478 // pseudo-clause OMPFlushClause or OMPDepobjClause. 2479 PP.EnterToken(Tok, /*IsReinject*/ true); 2480 PP.EnterToken(ImplicitTok, /*IsReinject*/ true); 2481 ConsumeAnyToken(); 2482 } 2483 OpenMPClauseKind CKind = Tok.isAnnotation() 2484 ? OMPC_unknown 2485 : getOpenMPClauseKind(PP.getSpelling(Tok)); 2486 if (HasImplicitClause) { 2487 assert(CKind == OMPC_unknown && "Must be unknown implicit clause."); 2488 if (DKind == OMPD_flush) { 2489 CKind = OMPC_flush; 2490 } else { 2491 assert(DKind == OMPD_depobj && 2492 "Expected flush or depobj directives."); 2493 CKind = OMPC_depobj; 2494 } 2495 } 2496 // No more implicit clauses allowed. 2497 ImplicitClauseAllowed = false; 2498 Actions.StartOpenMPClause(CKind); 2499 HasImplicitClause = false; 2500 OMPClause *Clause = ParseOpenMPClause( 2501 DKind, CKind, !FirstClauses[unsigned(CKind)].getInt()); 2502 FirstClauses[unsigned(CKind)].setInt(true); 2503 if (Clause) { 2504 FirstClauses[unsigned(CKind)].setPointer(Clause); 2505 Clauses.push_back(Clause); 2506 } 2507 2508 // Skip ',' if any. 2509 if (Tok.is(tok::comma)) 2510 ConsumeToken(); 2511 Actions.EndOpenMPClause(); 2512 } 2513 // End location of the directive. 2514 EndLoc = Tok.getLocation(); 2515 // Consume final annot_pragma_openmp_end. 2516 ConsumeAnnotationToken(); 2517 2518 // OpenMP [2.13.8, ordered Construct, Syntax] 2519 // If the depend clause is specified, the ordered construct is a stand-alone 2520 // directive. 2521 if (DKind == OMPD_ordered && FirstClauses[unsigned(OMPC_depend)].getInt()) { 2522 if ((StmtCtx & ParsedStmtContext::AllowStandaloneOpenMPDirectives) == 2523 ParsedStmtContext()) { 2524 Diag(Loc, diag::err_omp_immediate_directive) 2525 << getOpenMPDirectiveName(DKind) << 1 2526 << getOpenMPClauseName(OMPC_depend); 2527 } 2528 HasAssociatedStatement = false; 2529 } 2530 2531 if (DKind == OMPD_tile && !FirstClauses[unsigned(OMPC_sizes)].getInt()) { 2532 Diag(Loc, diag::err_omp_required_clause) 2533 << getOpenMPDirectiveName(OMPD_tile) << "sizes"; 2534 } 2535 2536 StmtResult AssociatedStmt; 2537 if (HasAssociatedStatement) { 2538 // The body is a block scope like in Lambdas and Blocks. 2539 Actions.ActOnOpenMPRegionStart(DKind, getCurScope()); 2540 // FIXME: We create a bogus CompoundStmt scope to hold the contents of 2541 // the captured region. Code elsewhere assumes that any FunctionScopeInfo 2542 // should have at least one compound statement scope within it. 2543 ParsingOpenMPDirectiveRAII NormalScope(*this, /*Value=*/false); 2544 { 2545 Sema::CompoundScopeRAII Scope(Actions); 2546 AssociatedStmt = ParseStatement(); 2547 2548 if (AssociatedStmt.isUsable() && isOpenMPLoopDirective(DKind) && 2549 getLangOpts().OpenMPIRBuilder) 2550 AssociatedStmt = 2551 Actions.ActOnOpenMPCanonicalLoop(AssociatedStmt.get()); 2552 } 2553 AssociatedStmt = Actions.ActOnOpenMPRegionEnd(AssociatedStmt, Clauses); 2554 } else if (DKind == OMPD_target_update || DKind == OMPD_target_enter_data || 2555 DKind == OMPD_target_exit_data) { 2556 Actions.ActOnOpenMPRegionStart(DKind, getCurScope()); 2557 AssociatedStmt = (Sema::CompoundScopeRAII(Actions), 2558 Actions.ActOnCompoundStmt(Loc, Loc, llvm::None, 2559 /*isStmtExpr=*/false)); 2560 AssociatedStmt = Actions.ActOnOpenMPRegionEnd(AssociatedStmt, Clauses); 2561 } 2562 Directive = Actions.ActOnOpenMPExecutableDirective( 2563 DKind, DirName, CancelRegion, Clauses, AssociatedStmt.get(), Loc, 2564 EndLoc); 2565 2566 // Exit scope. 2567 Actions.EndOpenMPDSABlock(Directive.get()); 2568 OMPDirectiveScope.Exit(); 2569 break; 2570 } 2571 case OMPD_declare_simd: 2572 case OMPD_declare_target: 2573 case OMPD_end_declare_target: 2574 case OMPD_requires: 2575 case OMPD_begin_declare_variant: 2576 case OMPD_end_declare_variant: 2577 case OMPD_declare_variant: 2578 Diag(Tok, diag::err_omp_unexpected_directive) 2579 << 1 << getOpenMPDirectiveName(DKind); 2580 SkipUntil(tok::annot_pragma_openmp_end); 2581 break; 2582 case OMPD_unknown: 2583 default: 2584 Diag(Tok, diag::err_omp_unknown_directive); 2585 SkipUntil(tok::annot_pragma_openmp_end); 2586 break; 2587 } 2588 return Directive; 2589 } 2590 2591 // Parses simple list: 2592 // simple-variable-list: 2593 // '(' id-expression {, id-expression} ')' 2594 // 2595 bool Parser::ParseOpenMPSimpleVarList( 2596 OpenMPDirectiveKind Kind, 2597 const llvm::function_ref<void(CXXScopeSpec &, DeclarationNameInfo)> 2598 &Callback, 2599 bool AllowScopeSpecifier) { 2600 // Parse '('. 2601 BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); 2602 if (T.expectAndConsume(diag::err_expected_lparen_after, 2603 getOpenMPDirectiveName(Kind).data())) 2604 return true; 2605 bool IsCorrect = true; 2606 bool NoIdentIsFound = true; 2607 2608 // Read tokens while ')' or annot_pragma_openmp_end is not found. 2609 while (Tok.isNot(tok::r_paren) && Tok.isNot(tok::annot_pragma_openmp_end)) { 2610 CXXScopeSpec SS; 2611 UnqualifiedId Name; 2612 // Read var name. 2613 Token PrevTok = Tok; 2614 NoIdentIsFound = false; 2615 2616 if (AllowScopeSpecifier && getLangOpts().CPlusPlus && 2617 ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr, 2618 /*ObjectHadErrors=*/false, false)) { 2619 IsCorrect = false; 2620 SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end, 2621 StopBeforeMatch); 2622 } else if (ParseUnqualifiedId(SS, /*ObjectType=*/nullptr, 2623 /*ObjectHadErrors=*/false, false, false, 2624 false, false, nullptr, Name)) { 2625 IsCorrect = false; 2626 SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end, 2627 StopBeforeMatch); 2628 } else if (Tok.isNot(tok::comma) && Tok.isNot(tok::r_paren) && 2629 Tok.isNot(tok::annot_pragma_openmp_end)) { 2630 IsCorrect = false; 2631 SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end, 2632 StopBeforeMatch); 2633 Diag(PrevTok.getLocation(), diag::err_expected) 2634 << tok::identifier 2635 << SourceRange(PrevTok.getLocation(), PrevTokLocation); 2636 } else { 2637 Callback(SS, Actions.GetNameFromUnqualifiedId(Name)); 2638 } 2639 // Consume ','. 2640 if (Tok.is(tok::comma)) { 2641 ConsumeToken(); 2642 } 2643 } 2644 2645 if (NoIdentIsFound) { 2646 Diag(Tok, diag::err_expected) << tok::identifier; 2647 IsCorrect = false; 2648 } 2649 2650 // Parse ')'. 2651 IsCorrect = !T.consumeClose() && IsCorrect; 2652 2653 return !IsCorrect; 2654 } 2655 2656 OMPClause *Parser::ParseOpenMPSizesClause() { 2657 SourceLocation ClauseNameLoc = ConsumeToken(); 2658 SmallVector<Expr *, 4> ValExprs; 2659 2660 BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); 2661 if (T.consumeOpen()) { 2662 Diag(Tok, diag::err_expected) << tok::l_paren; 2663 return nullptr; 2664 } 2665 2666 while (true) { 2667 ExprResult Val = ParseConstantExpression(); 2668 if (!Val.isUsable()) { 2669 T.skipToEnd(); 2670 return nullptr; 2671 } 2672 2673 ValExprs.push_back(Val.get()); 2674 2675 if (Tok.is(tok::r_paren) || Tok.is(tok::annot_pragma_openmp_end)) 2676 break; 2677 2678 ExpectAndConsume(tok::comma); 2679 } 2680 2681 T.consumeClose(); 2682 2683 return Actions.ActOnOpenMPSizesClause( 2684 ValExprs, ClauseNameLoc, T.getOpenLocation(), T.getCloseLocation()); 2685 } 2686 2687 OMPClause *Parser::ParseOpenMPUsesAllocatorClause(OpenMPDirectiveKind DKind) { 2688 SourceLocation Loc = Tok.getLocation(); 2689 ConsumeAnyToken(); 2690 2691 // Parse '('. 2692 BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); 2693 if (T.expectAndConsume(diag::err_expected_lparen_after, "uses_allocator")) 2694 return nullptr; 2695 SmallVector<Sema::UsesAllocatorsData, 4> Data; 2696 do { 2697 ExprResult Allocator = ParseCXXIdExpression(); 2698 if (Allocator.isInvalid()) { 2699 SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end, 2700 StopBeforeMatch); 2701 break; 2702 } 2703 Sema::UsesAllocatorsData &D = Data.emplace_back(); 2704 D.Allocator = Allocator.get(); 2705 if (Tok.is(tok::l_paren)) { 2706 BalancedDelimiterTracker T(*this, tok::l_paren, 2707 tok::annot_pragma_openmp_end); 2708 T.consumeOpen(); 2709 ExprResult AllocatorTraits = ParseCXXIdExpression(); 2710 T.consumeClose(); 2711 if (AllocatorTraits.isInvalid()) { 2712 SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end, 2713 StopBeforeMatch); 2714 break; 2715 } 2716 D.AllocatorTraits = AllocatorTraits.get(); 2717 D.LParenLoc = T.getOpenLocation(); 2718 D.RParenLoc = T.getCloseLocation(); 2719 } 2720 if (Tok.isNot(tok::comma) && Tok.isNot(tok::r_paren)) 2721 Diag(Tok, diag::err_omp_expected_punc) << "uses_allocators" << 0; 2722 // Parse ',' 2723 if (Tok.is(tok::comma)) 2724 ConsumeAnyToken(); 2725 } while (Tok.isNot(tok::r_paren) && Tok.isNot(tok::annot_pragma_openmp_end)); 2726 T.consumeClose(); 2727 return Actions.ActOnOpenMPUsesAllocatorClause(Loc, T.getOpenLocation(), 2728 T.getCloseLocation(), Data); 2729 } 2730 2731 /// Parsing of OpenMP clauses. 2732 /// 2733 /// clause: 2734 /// if-clause | final-clause | num_threads-clause | safelen-clause | 2735 /// default-clause | private-clause | firstprivate-clause | shared-clause 2736 /// | linear-clause | aligned-clause | collapse-clause | 2737 /// lastprivate-clause | reduction-clause | proc_bind-clause | 2738 /// schedule-clause | copyin-clause | copyprivate-clause | untied-clause | 2739 /// mergeable-clause | flush-clause | read-clause | write-clause | 2740 /// update-clause | capture-clause | seq_cst-clause | device-clause | 2741 /// simdlen-clause | threads-clause | simd-clause | num_teams-clause | 2742 /// thread_limit-clause | priority-clause | grainsize-clause | 2743 /// nogroup-clause | num_tasks-clause | hint-clause | to-clause | 2744 /// from-clause | is_device_ptr-clause | task_reduction-clause | 2745 /// in_reduction-clause | allocator-clause | allocate-clause | 2746 /// acq_rel-clause | acquire-clause | release-clause | relaxed-clause | 2747 /// depobj-clause | destroy-clause | detach-clause | inclusive-clause | 2748 /// exclusive-clause | uses_allocators-clause | use_device_addr-clause 2749 /// 2750 OMPClause *Parser::ParseOpenMPClause(OpenMPDirectiveKind DKind, 2751 OpenMPClauseKind CKind, bool FirstClause) { 2752 OMPClauseKind = CKind; 2753 OMPClause *Clause = nullptr; 2754 bool ErrorFound = false; 2755 bool WrongDirective = false; 2756 // Check if clause is allowed for the given directive. 2757 if (CKind != OMPC_unknown && 2758 !isAllowedClauseForDirective(DKind, CKind, getLangOpts().OpenMP)) { 2759 Diag(Tok, diag::err_omp_unexpected_clause) 2760 << getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind); 2761 ErrorFound = true; 2762 WrongDirective = true; 2763 } 2764 2765 switch (CKind) { 2766 case OMPC_final: 2767 case OMPC_num_threads: 2768 case OMPC_safelen: 2769 case OMPC_simdlen: 2770 case OMPC_collapse: 2771 case OMPC_ordered: 2772 case OMPC_num_teams: 2773 case OMPC_thread_limit: 2774 case OMPC_priority: 2775 case OMPC_grainsize: 2776 case OMPC_num_tasks: 2777 case OMPC_hint: 2778 case OMPC_allocator: 2779 case OMPC_depobj: 2780 case OMPC_detach: 2781 case OMPC_novariants: 2782 case OMPC_nocontext: 2783 case OMPC_filter: 2784 // OpenMP [2.5, Restrictions] 2785 // At most one num_threads clause can appear on the directive. 2786 // OpenMP [2.8.1, simd construct, Restrictions] 2787 // Only one safelen clause can appear on a simd directive. 2788 // Only one simdlen clause can appear on a simd directive. 2789 // Only one collapse clause can appear on a simd directive. 2790 // OpenMP [2.11.1, task Construct, Restrictions] 2791 // At most one if clause can appear on the directive. 2792 // At most one final clause can appear on the directive. 2793 // OpenMP [teams Construct, Restrictions] 2794 // At most one num_teams clause can appear on the directive. 2795 // At most one thread_limit clause can appear on the directive. 2796 // OpenMP [2.9.1, task Construct, Restrictions] 2797 // At most one priority clause can appear on the directive. 2798 // OpenMP [2.9.2, taskloop Construct, Restrictions] 2799 // At most one grainsize clause can appear on the directive. 2800 // OpenMP [2.9.2, taskloop Construct, Restrictions] 2801 // At most one num_tasks clause can appear on the directive. 2802 // OpenMP [2.11.3, allocate Directive, Restrictions] 2803 // At most one allocator clause can appear on the directive. 2804 // OpenMP 5.0, 2.10.1 task Construct, Restrictions. 2805 // At most one detach clause can appear on the directive. 2806 // OpenMP 5.1, 2.3.6 dispatch Construct, Restrictions. 2807 // At most one novariants clause can appear on a dispatch directive. 2808 // At most one nocontext clause can appear on a dispatch directive. 2809 if (!FirstClause) { 2810 Diag(Tok, diag::err_omp_more_one_clause) 2811 << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0; 2812 ErrorFound = true; 2813 } 2814 2815 if (CKind == OMPC_ordered && PP.LookAhead(/*N=*/0).isNot(tok::l_paren)) 2816 Clause = ParseOpenMPClause(CKind, WrongDirective); 2817 else 2818 Clause = ParseOpenMPSingleExprClause(CKind, WrongDirective); 2819 break; 2820 case OMPC_default: 2821 case OMPC_proc_bind: 2822 case OMPC_atomic_default_mem_order: 2823 case OMPC_order: 2824 // OpenMP [2.14.3.1, Restrictions] 2825 // Only a single default clause may be specified on a parallel, task or 2826 // teams directive. 2827 // OpenMP [2.5, parallel Construct, Restrictions] 2828 // At most one proc_bind clause can appear on the directive. 2829 // OpenMP [5.0, Requires directive, Restrictions] 2830 // At most one atomic_default_mem_order clause can appear 2831 // on the directive 2832 if (!FirstClause && CKind != OMPC_order) { 2833 Diag(Tok, diag::err_omp_more_one_clause) 2834 << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0; 2835 ErrorFound = true; 2836 } 2837 2838 Clause = ParseOpenMPSimpleClause(CKind, WrongDirective); 2839 break; 2840 case OMPC_device: 2841 case OMPC_schedule: 2842 case OMPC_dist_schedule: 2843 case OMPC_defaultmap: 2844 // OpenMP [2.7.1, Restrictions, p. 3] 2845 // Only one schedule clause can appear on a loop directive. 2846 // OpenMP 4.5 [2.10.4, Restrictions, p. 106] 2847 // At most one defaultmap clause can appear on the directive. 2848 // OpenMP 5.0 [2.12.5, target construct, Restrictions] 2849 // At most one device clause can appear on the directive. 2850 if ((getLangOpts().OpenMP < 50 || CKind != OMPC_defaultmap) && 2851 !FirstClause) { 2852 Diag(Tok, diag::err_omp_more_one_clause) 2853 << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0; 2854 ErrorFound = true; 2855 } 2856 LLVM_FALLTHROUGH; 2857 case OMPC_if: 2858 Clause = ParseOpenMPSingleExprWithArgClause(DKind, CKind, WrongDirective); 2859 break; 2860 case OMPC_nowait: 2861 case OMPC_untied: 2862 case OMPC_mergeable: 2863 case OMPC_read: 2864 case OMPC_write: 2865 case OMPC_capture: 2866 case OMPC_seq_cst: 2867 case OMPC_acq_rel: 2868 case OMPC_acquire: 2869 case OMPC_release: 2870 case OMPC_relaxed: 2871 case OMPC_threads: 2872 case OMPC_simd: 2873 case OMPC_nogroup: 2874 case OMPC_unified_address: 2875 case OMPC_unified_shared_memory: 2876 case OMPC_reverse_offload: 2877 case OMPC_dynamic_allocators: 2878 // OpenMP [2.7.1, Restrictions, p. 9] 2879 // Only one ordered clause can appear on a loop directive. 2880 // OpenMP [2.7.1, Restrictions, C/C++, p. 4] 2881 // Only one nowait clause can appear on a for directive. 2882 // OpenMP [5.0, Requires directive, Restrictions] 2883 // Each of the requires clauses can appear at most once on the directive. 2884 if (!FirstClause) { 2885 Diag(Tok, diag::err_omp_more_one_clause) 2886 << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0; 2887 ErrorFound = true; 2888 } 2889 2890 Clause = ParseOpenMPClause(CKind, WrongDirective); 2891 break; 2892 case OMPC_update: 2893 if (!FirstClause) { 2894 Diag(Tok, diag::err_omp_more_one_clause) 2895 << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0; 2896 ErrorFound = true; 2897 } 2898 2899 Clause = (DKind == OMPD_depobj) 2900 ? ParseOpenMPSimpleClause(CKind, WrongDirective) 2901 : ParseOpenMPClause(CKind, WrongDirective); 2902 break; 2903 case OMPC_private: 2904 case OMPC_firstprivate: 2905 case OMPC_lastprivate: 2906 case OMPC_shared: 2907 case OMPC_reduction: 2908 case OMPC_task_reduction: 2909 case OMPC_in_reduction: 2910 case OMPC_linear: 2911 case OMPC_aligned: 2912 case OMPC_copyin: 2913 case OMPC_copyprivate: 2914 case OMPC_flush: 2915 case OMPC_depend: 2916 case OMPC_map: 2917 case OMPC_to: 2918 case OMPC_from: 2919 case OMPC_use_device_ptr: 2920 case OMPC_use_device_addr: 2921 case OMPC_is_device_ptr: 2922 case OMPC_allocate: 2923 case OMPC_nontemporal: 2924 case OMPC_inclusive: 2925 case OMPC_exclusive: 2926 case OMPC_affinity: 2927 Clause = ParseOpenMPVarListClause(DKind, CKind, WrongDirective); 2928 break; 2929 case OMPC_sizes: 2930 if (!FirstClause) { 2931 Diag(Tok, diag::err_omp_more_one_clause) 2932 << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0; 2933 ErrorFound = true; 2934 } 2935 2936 Clause = ParseOpenMPSizesClause(); 2937 break; 2938 case OMPC_uses_allocators: 2939 Clause = ParseOpenMPUsesAllocatorClause(DKind); 2940 break; 2941 case OMPC_destroy: 2942 if (DKind != OMPD_interop) { 2943 if (!FirstClause) { 2944 Diag(Tok, diag::err_omp_more_one_clause) 2945 << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0; 2946 ErrorFound = true; 2947 } 2948 Clause = ParseOpenMPClause(CKind, WrongDirective); 2949 break; 2950 } 2951 LLVM_FALLTHROUGH; 2952 case OMPC_init: 2953 case OMPC_use: 2954 Clause = ParseOpenMPInteropClause(CKind, WrongDirective); 2955 break; 2956 case OMPC_device_type: 2957 case OMPC_unknown: 2958 skipUntilPragmaOpenMPEnd(DKind); 2959 break; 2960 case OMPC_threadprivate: 2961 case OMPC_uniform: 2962 case OMPC_match: 2963 if (!WrongDirective) 2964 Diag(Tok, diag::err_omp_unexpected_clause) 2965 << getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind); 2966 SkipUntil(tok::comma, tok::annot_pragma_openmp_end, StopBeforeMatch); 2967 break; 2968 default: 2969 break; 2970 } 2971 return ErrorFound ? nullptr : Clause; 2972 } 2973 2974 /// Parses simple expression in parens for single-expression clauses of OpenMP 2975 /// constructs. 2976 /// \param RLoc Returned location of right paren. 2977 ExprResult Parser::ParseOpenMPParensExpr(StringRef ClauseName, 2978 SourceLocation &RLoc, 2979 bool IsAddressOfOperand) { 2980 BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); 2981 if (T.expectAndConsume(diag::err_expected_lparen_after, ClauseName.data())) 2982 return ExprError(); 2983 2984 SourceLocation ELoc = Tok.getLocation(); 2985 ExprResult LHS( 2986 ParseCastExpression(AnyCastExpr, IsAddressOfOperand, NotTypeCast)); 2987 ExprResult Val(ParseRHSOfBinaryExpression(LHS, prec::Conditional)); 2988 Val = Actions.ActOnFinishFullExpr(Val.get(), ELoc, /*DiscardedValue*/ false); 2989 2990 // Parse ')'. 2991 RLoc = Tok.getLocation(); 2992 if (!T.consumeClose()) 2993 RLoc = T.getCloseLocation(); 2994 2995 return Val; 2996 } 2997 2998 /// Parsing of OpenMP clauses with single expressions like 'final', 2999 /// 'collapse', 'safelen', 'num_threads', 'simdlen', 'num_teams', 3000 /// 'thread_limit', 'simdlen', 'priority', 'grainsize', 'num_tasks', 'hint' or 3001 /// 'detach'. 3002 /// 3003 /// final-clause: 3004 /// 'final' '(' expression ')' 3005 /// 3006 /// num_threads-clause: 3007 /// 'num_threads' '(' expression ')' 3008 /// 3009 /// safelen-clause: 3010 /// 'safelen' '(' expression ')' 3011 /// 3012 /// simdlen-clause: 3013 /// 'simdlen' '(' expression ')' 3014 /// 3015 /// collapse-clause: 3016 /// 'collapse' '(' expression ')' 3017 /// 3018 /// priority-clause: 3019 /// 'priority' '(' expression ')' 3020 /// 3021 /// grainsize-clause: 3022 /// 'grainsize' '(' expression ')' 3023 /// 3024 /// num_tasks-clause: 3025 /// 'num_tasks' '(' expression ')' 3026 /// 3027 /// hint-clause: 3028 /// 'hint' '(' expression ')' 3029 /// 3030 /// allocator-clause: 3031 /// 'allocator' '(' expression ')' 3032 /// 3033 /// detach-clause: 3034 /// 'detach' '(' event-handler-expression ')' 3035 /// 3036 OMPClause *Parser::ParseOpenMPSingleExprClause(OpenMPClauseKind Kind, 3037 bool ParseOnly) { 3038 SourceLocation Loc = ConsumeToken(); 3039 SourceLocation LLoc = Tok.getLocation(); 3040 SourceLocation RLoc; 3041 3042 ExprResult Val = ParseOpenMPParensExpr(getOpenMPClauseName(Kind), RLoc); 3043 3044 if (Val.isInvalid()) 3045 return nullptr; 3046 3047 if (ParseOnly) 3048 return nullptr; 3049 return Actions.ActOnOpenMPSingleExprClause(Kind, Val.get(), Loc, LLoc, RLoc); 3050 } 3051 3052 /// Parsing of OpenMP clauses that use an interop-var. 3053 /// 3054 /// init-clause: 3055 /// init([interop-modifier, ]interop-type[[, interop-type] ... ]:interop-var) 3056 /// 3057 /// destroy-clause: 3058 /// destroy(interop-var) 3059 /// 3060 /// use-clause: 3061 /// use(interop-var) 3062 /// 3063 /// interop-modifier: 3064 /// prefer_type(preference-list) 3065 /// 3066 /// preference-list: 3067 /// foreign-runtime-id [, foreign-runtime-id]... 3068 /// 3069 /// foreign-runtime-id: 3070 /// <string-literal> | <constant-integral-expression> 3071 /// 3072 /// interop-type: 3073 /// target | targetsync 3074 /// 3075 OMPClause *Parser::ParseOpenMPInteropClause(OpenMPClauseKind Kind, 3076 bool ParseOnly) { 3077 SourceLocation Loc = ConsumeToken(); 3078 // Parse '('. 3079 BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); 3080 if (T.expectAndConsume(diag::err_expected_lparen_after, 3081 getOpenMPClauseName(Kind).data())) 3082 return nullptr; 3083 3084 bool IsTarget = false; 3085 bool IsTargetSync = false; 3086 SmallVector<Expr *, 4> Prefs; 3087 3088 if (Kind == OMPC_init) { 3089 3090 // Parse optional interop-modifier. 3091 if (Tok.is(tok::identifier) && PP.getSpelling(Tok) == "prefer_type") { 3092 ConsumeToken(); 3093 BalancedDelimiterTracker PT(*this, tok::l_paren, 3094 tok::annot_pragma_openmp_end); 3095 if (PT.expectAndConsume(diag::err_expected_lparen_after, "prefer_type")) 3096 return nullptr; 3097 3098 while (Tok.isNot(tok::r_paren)) { 3099 SourceLocation Loc = Tok.getLocation(); 3100 ExprResult LHS = ParseCastExpression(AnyCastExpr); 3101 ExprResult PTExpr = Actions.CorrectDelayedTyposInExpr( 3102 ParseRHSOfBinaryExpression(LHS, prec::Conditional)); 3103 PTExpr = Actions.ActOnFinishFullExpr(PTExpr.get(), Loc, 3104 /*DiscardedValue=*/false); 3105 if (PTExpr.isUsable()) 3106 Prefs.push_back(PTExpr.get()); 3107 else 3108 SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end, 3109 StopBeforeMatch); 3110 3111 if (Tok.is(tok::comma)) 3112 ConsumeToken(); 3113 } 3114 PT.consumeClose(); 3115 } 3116 3117 if (!Prefs.empty()) { 3118 if (Tok.is(tok::comma)) 3119 ConsumeToken(); 3120 else 3121 Diag(Tok, diag::err_omp_expected_punc_after_interop_mod); 3122 } 3123 3124 // Parse the interop-types. 3125 bool HasError = false; 3126 while (Tok.is(tok::identifier)) { 3127 if (PP.getSpelling(Tok) == "target") { 3128 // OpenMP 5.1 [2.15.1, interop Construct, Restrictions] 3129 // Each interop-type may be specified on an action-clause at most 3130 // once. 3131 if (IsTarget) 3132 Diag(Tok, diag::warn_omp_more_one_interop_type) << "target"; 3133 IsTarget = true; 3134 } else if (PP.getSpelling(Tok) == "targetsync") { 3135 if (IsTargetSync) 3136 Diag(Tok, diag::warn_omp_more_one_interop_type) << "targetsync"; 3137 IsTargetSync = true; 3138 } else { 3139 HasError = true; 3140 Diag(Tok, diag::err_omp_expected_interop_type); 3141 } 3142 ConsumeToken(); 3143 3144 if (!Tok.is(tok::comma)) 3145 break; 3146 ConsumeToken(); 3147 } 3148 if (!HasError && !IsTarget && !IsTargetSync) 3149 Diag(Tok, diag::err_omp_expected_interop_type); 3150 3151 if (Tok.is(tok::colon)) 3152 ConsumeToken(); 3153 else if (IsTarget || IsTargetSync) 3154 Diag(Tok, diag::warn_pragma_expected_colon) << "interop types"; 3155 } 3156 3157 // Parse the variable. 3158 SourceLocation VarLoc = Tok.getLocation(); 3159 ExprResult InteropVarExpr = 3160 Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression()); 3161 if (!InteropVarExpr.isUsable()) { 3162 SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end, 3163 StopBeforeMatch); 3164 } 3165 3166 // Parse ')'. 3167 SourceLocation RLoc = Tok.getLocation(); 3168 if (!T.consumeClose()) 3169 RLoc = T.getCloseLocation(); 3170 3171 if (ParseOnly || !InteropVarExpr.isUsable() || 3172 (Kind == OMPC_init && !IsTarget && !IsTargetSync)) 3173 return nullptr; 3174 3175 if (Kind == OMPC_init) 3176 return Actions.ActOnOpenMPInitClause(InteropVarExpr.get(), Prefs, IsTarget, 3177 IsTargetSync, Loc, T.getOpenLocation(), 3178 VarLoc, RLoc); 3179 if (Kind == OMPC_use) 3180 return Actions.ActOnOpenMPUseClause(InteropVarExpr.get(), Loc, 3181 T.getOpenLocation(), VarLoc, RLoc); 3182 3183 if (Kind == OMPC_destroy) 3184 return Actions.ActOnOpenMPDestroyClause(InteropVarExpr.get(), Loc, 3185 T.getOpenLocation(), VarLoc, RLoc); 3186 3187 llvm_unreachable("Unexpected interop variable clause."); 3188 } 3189 3190 /// Parsing of simple OpenMP clauses like 'default' or 'proc_bind'. 3191 /// 3192 /// default-clause: 3193 /// 'default' '(' 'none' | 'shared' | 'firstprivate' ')' 3194 /// 3195 /// proc_bind-clause: 3196 /// 'proc_bind' '(' 'master' | 'close' | 'spread' ')' 3197 /// 3198 /// update-clause: 3199 /// 'update' '(' 'in' | 'out' | 'inout' | 'mutexinoutset' ')' 3200 /// 3201 OMPClause *Parser::ParseOpenMPSimpleClause(OpenMPClauseKind Kind, 3202 bool ParseOnly) { 3203 llvm::Optional<SimpleClauseData> Val = parseOpenMPSimpleClause(*this, Kind); 3204 if (!Val || ParseOnly) 3205 return nullptr; 3206 if (getLangOpts().OpenMP < 51 && Kind == OMPC_default && 3207 static_cast<DefaultKind>(Val.getValue().Type) == 3208 OMP_DEFAULT_firstprivate) { 3209 Diag(Val.getValue().LOpen, diag::err_omp_invalid_dsa) 3210 << getOpenMPClauseName(OMPC_firstprivate) 3211 << getOpenMPClauseName(OMPC_default) << "5.1"; 3212 return nullptr; 3213 } 3214 return Actions.ActOnOpenMPSimpleClause( 3215 Kind, Val.getValue().Type, Val.getValue().TypeLoc, Val.getValue().LOpen, 3216 Val.getValue().Loc, Val.getValue().RLoc); 3217 } 3218 3219 /// Parsing of OpenMP clauses like 'ordered'. 3220 /// 3221 /// ordered-clause: 3222 /// 'ordered' 3223 /// 3224 /// nowait-clause: 3225 /// 'nowait' 3226 /// 3227 /// untied-clause: 3228 /// 'untied' 3229 /// 3230 /// mergeable-clause: 3231 /// 'mergeable' 3232 /// 3233 /// read-clause: 3234 /// 'read' 3235 /// 3236 /// threads-clause: 3237 /// 'threads' 3238 /// 3239 /// simd-clause: 3240 /// 'simd' 3241 /// 3242 /// nogroup-clause: 3243 /// 'nogroup' 3244 /// 3245 OMPClause *Parser::ParseOpenMPClause(OpenMPClauseKind Kind, bool ParseOnly) { 3246 SourceLocation Loc = Tok.getLocation(); 3247 ConsumeAnyToken(); 3248 3249 if (ParseOnly) 3250 return nullptr; 3251 return Actions.ActOnOpenMPClause(Kind, Loc, Tok.getLocation()); 3252 } 3253 3254 /// Parsing of OpenMP clauses with single expressions and some additional 3255 /// argument like 'schedule' or 'dist_schedule'. 3256 /// 3257 /// schedule-clause: 3258 /// 'schedule' '(' [ modifier [ ',' modifier ] ':' ] kind [',' expression ] 3259 /// ')' 3260 /// 3261 /// if-clause: 3262 /// 'if' '(' [ directive-name-modifier ':' ] expression ')' 3263 /// 3264 /// defaultmap: 3265 /// 'defaultmap' '(' modifier [ ':' kind ] ')' 3266 /// 3267 /// device-clause: 3268 /// 'device' '(' [ device-modifier ':' ] expression ')' 3269 /// 3270 OMPClause *Parser::ParseOpenMPSingleExprWithArgClause(OpenMPDirectiveKind DKind, 3271 OpenMPClauseKind Kind, 3272 bool ParseOnly) { 3273 SourceLocation Loc = ConsumeToken(); 3274 SourceLocation DelimLoc; 3275 // Parse '('. 3276 BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); 3277 if (T.expectAndConsume(diag::err_expected_lparen_after, 3278 getOpenMPClauseName(Kind).data())) 3279 return nullptr; 3280 3281 ExprResult Val; 3282 SmallVector<unsigned, 4> Arg; 3283 SmallVector<SourceLocation, 4> KLoc; 3284 if (Kind == OMPC_schedule) { 3285 enum { Modifier1, Modifier2, ScheduleKind, NumberOfElements }; 3286 Arg.resize(NumberOfElements); 3287 KLoc.resize(NumberOfElements); 3288 Arg[Modifier1] = OMPC_SCHEDULE_MODIFIER_unknown; 3289 Arg[Modifier2] = OMPC_SCHEDULE_MODIFIER_unknown; 3290 Arg[ScheduleKind] = OMPC_SCHEDULE_unknown; 3291 unsigned KindModifier = getOpenMPSimpleClauseType( 3292 Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok), 3293 getLangOpts().OpenMP); 3294 if (KindModifier > OMPC_SCHEDULE_unknown) { 3295 // Parse 'modifier' 3296 Arg[Modifier1] = KindModifier; 3297 KLoc[Modifier1] = Tok.getLocation(); 3298 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) && 3299 Tok.isNot(tok::annot_pragma_openmp_end)) 3300 ConsumeAnyToken(); 3301 if (Tok.is(tok::comma)) { 3302 // Parse ',' 'modifier' 3303 ConsumeAnyToken(); 3304 KindModifier = getOpenMPSimpleClauseType( 3305 Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok), 3306 getLangOpts().OpenMP); 3307 Arg[Modifier2] = KindModifier > OMPC_SCHEDULE_unknown 3308 ? KindModifier 3309 : (unsigned)OMPC_SCHEDULE_unknown; 3310 KLoc[Modifier2] = Tok.getLocation(); 3311 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) && 3312 Tok.isNot(tok::annot_pragma_openmp_end)) 3313 ConsumeAnyToken(); 3314 } 3315 // Parse ':' 3316 if (Tok.is(tok::colon)) 3317 ConsumeAnyToken(); 3318 else 3319 Diag(Tok, diag::warn_pragma_expected_colon) << "schedule modifier"; 3320 KindModifier = getOpenMPSimpleClauseType( 3321 Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok), 3322 getLangOpts().OpenMP); 3323 } 3324 Arg[ScheduleKind] = KindModifier; 3325 KLoc[ScheduleKind] = Tok.getLocation(); 3326 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) && 3327 Tok.isNot(tok::annot_pragma_openmp_end)) 3328 ConsumeAnyToken(); 3329 if ((Arg[ScheduleKind] == OMPC_SCHEDULE_static || 3330 Arg[ScheduleKind] == OMPC_SCHEDULE_dynamic || 3331 Arg[ScheduleKind] == OMPC_SCHEDULE_guided) && 3332 Tok.is(tok::comma)) 3333 DelimLoc = ConsumeAnyToken(); 3334 } else if (Kind == OMPC_dist_schedule) { 3335 Arg.push_back(getOpenMPSimpleClauseType( 3336 Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok), 3337 getLangOpts().OpenMP)); 3338 KLoc.push_back(Tok.getLocation()); 3339 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) && 3340 Tok.isNot(tok::annot_pragma_openmp_end)) 3341 ConsumeAnyToken(); 3342 if (Arg.back() == OMPC_DIST_SCHEDULE_static && Tok.is(tok::comma)) 3343 DelimLoc = ConsumeAnyToken(); 3344 } else if (Kind == OMPC_defaultmap) { 3345 // Get a defaultmap modifier 3346 unsigned Modifier = getOpenMPSimpleClauseType( 3347 Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok), 3348 getLangOpts().OpenMP); 3349 // Set defaultmap modifier to unknown if it is either scalar, aggregate, or 3350 // pointer 3351 if (Modifier < OMPC_DEFAULTMAP_MODIFIER_unknown) 3352 Modifier = OMPC_DEFAULTMAP_MODIFIER_unknown; 3353 Arg.push_back(Modifier); 3354 KLoc.push_back(Tok.getLocation()); 3355 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) && 3356 Tok.isNot(tok::annot_pragma_openmp_end)) 3357 ConsumeAnyToken(); 3358 // Parse ':' 3359 if (Tok.is(tok::colon) || getLangOpts().OpenMP < 50) { 3360 if (Tok.is(tok::colon)) 3361 ConsumeAnyToken(); 3362 else if (Arg.back() != OMPC_DEFAULTMAP_MODIFIER_unknown) 3363 Diag(Tok, diag::warn_pragma_expected_colon) << "defaultmap modifier"; 3364 // Get a defaultmap kind 3365 Arg.push_back(getOpenMPSimpleClauseType( 3366 Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok), 3367 getLangOpts().OpenMP)); 3368 KLoc.push_back(Tok.getLocation()); 3369 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) && 3370 Tok.isNot(tok::annot_pragma_openmp_end)) 3371 ConsumeAnyToken(); 3372 } else { 3373 Arg.push_back(OMPC_DEFAULTMAP_unknown); 3374 KLoc.push_back(SourceLocation()); 3375 } 3376 } else if (Kind == OMPC_device) { 3377 // Only target executable directives support extended device construct. 3378 if (isOpenMPTargetExecutionDirective(DKind) && getLangOpts().OpenMP >= 50 && 3379 NextToken().is(tok::colon)) { 3380 // Parse optional <device modifier> ':' 3381 Arg.push_back(getOpenMPSimpleClauseType( 3382 Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok), 3383 getLangOpts().OpenMP)); 3384 KLoc.push_back(Tok.getLocation()); 3385 ConsumeAnyToken(); 3386 // Parse ':' 3387 ConsumeAnyToken(); 3388 } else { 3389 Arg.push_back(OMPC_DEVICE_unknown); 3390 KLoc.emplace_back(); 3391 } 3392 } else { 3393 assert(Kind == OMPC_if); 3394 KLoc.push_back(Tok.getLocation()); 3395 TentativeParsingAction TPA(*this); 3396 auto DK = parseOpenMPDirectiveKind(*this); 3397 Arg.push_back(DK); 3398 if (DK != OMPD_unknown) { 3399 ConsumeToken(); 3400 if (Tok.is(tok::colon) && getLangOpts().OpenMP > 40) { 3401 TPA.Commit(); 3402 DelimLoc = ConsumeToken(); 3403 } else { 3404 TPA.Revert(); 3405 Arg.back() = unsigned(OMPD_unknown); 3406 } 3407 } else { 3408 TPA.Revert(); 3409 } 3410 } 3411 3412 bool NeedAnExpression = (Kind == OMPC_schedule && DelimLoc.isValid()) || 3413 (Kind == OMPC_dist_schedule && DelimLoc.isValid()) || 3414 Kind == OMPC_if || Kind == OMPC_device; 3415 if (NeedAnExpression) { 3416 SourceLocation ELoc = Tok.getLocation(); 3417 ExprResult LHS(ParseCastExpression(AnyCastExpr, false, NotTypeCast)); 3418 Val = ParseRHSOfBinaryExpression(LHS, prec::Conditional); 3419 Val = 3420 Actions.ActOnFinishFullExpr(Val.get(), ELoc, /*DiscardedValue*/ false); 3421 } 3422 3423 // Parse ')'. 3424 SourceLocation RLoc = Tok.getLocation(); 3425 if (!T.consumeClose()) 3426 RLoc = T.getCloseLocation(); 3427 3428 if (NeedAnExpression && Val.isInvalid()) 3429 return nullptr; 3430 3431 if (ParseOnly) 3432 return nullptr; 3433 return Actions.ActOnOpenMPSingleExprWithArgClause( 3434 Kind, Arg, Val.get(), Loc, T.getOpenLocation(), KLoc, DelimLoc, RLoc); 3435 } 3436 3437 static bool ParseReductionId(Parser &P, CXXScopeSpec &ReductionIdScopeSpec, 3438 UnqualifiedId &ReductionId) { 3439 if (ReductionIdScopeSpec.isEmpty()) { 3440 auto OOK = OO_None; 3441 switch (P.getCurToken().getKind()) { 3442 case tok::plus: 3443 OOK = OO_Plus; 3444 break; 3445 case tok::minus: 3446 OOK = OO_Minus; 3447 break; 3448 case tok::star: 3449 OOK = OO_Star; 3450 break; 3451 case tok::amp: 3452 OOK = OO_Amp; 3453 break; 3454 case tok::pipe: 3455 OOK = OO_Pipe; 3456 break; 3457 case tok::caret: 3458 OOK = OO_Caret; 3459 break; 3460 case tok::ampamp: 3461 OOK = OO_AmpAmp; 3462 break; 3463 case tok::pipepipe: 3464 OOK = OO_PipePipe; 3465 break; 3466 default: 3467 break; 3468 } 3469 if (OOK != OO_None) { 3470 SourceLocation OpLoc = P.ConsumeToken(); 3471 SourceLocation SymbolLocations[] = {OpLoc, OpLoc, SourceLocation()}; 3472 ReductionId.setOperatorFunctionId(OpLoc, OOK, SymbolLocations); 3473 return false; 3474 } 3475 } 3476 return P.ParseUnqualifiedId( 3477 ReductionIdScopeSpec, /*ObjectType=*/nullptr, 3478 /*ObjectHadErrors=*/false, /*EnteringContext*/ false, 3479 /*AllowDestructorName*/ false, 3480 /*AllowConstructorName*/ false, 3481 /*AllowDeductionGuide*/ false, nullptr, ReductionId); 3482 } 3483 3484 /// Checks if the token is a valid map-type-modifier. 3485 /// FIXME: It will return an OpenMPMapClauseKind if that's what it parses. 3486 static OpenMPMapModifierKind isMapModifier(Parser &P) { 3487 Token Tok = P.getCurToken(); 3488 if (!Tok.is(tok::identifier)) 3489 return OMPC_MAP_MODIFIER_unknown; 3490 3491 Preprocessor &PP = P.getPreprocessor(); 3492 OpenMPMapModifierKind TypeModifier = 3493 static_cast<OpenMPMapModifierKind>(getOpenMPSimpleClauseType( 3494 OMPC_map, PP.getSpelling(Tok), P.getLangOpts().OpenMP)); 3495 return TypeModifier; 3496 } 3497 3498 /// Parse the mapper modifier in map, to, and from clauses. 3499 bool Parser::parseMapperModifier(OpenMPVarListDataTy &Data) { 3500 // Parse '('. 3501 BalancedDelimiterTracker T(*this, tok::l_paren, tok::colon); 3502 if (T.expectAndConsume(diag::err_expected_lparen_after, "mapper")) { 3503 SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end, 3504 StopBeforeMatch); 3505 return true; 3506 } 3507 // Parse mapper-identifier 3508 if (getLangOpts().CPlusPlus) 3509 ParseOptionalCXXScopeSpecifier(Data.ReductionOrMapperIdScopeSpec, 3510 /*ObjectType=*/nullptr, 3511 /*ObjectHadErrors=*/false, 3512 /*EnteringContext=*/false); 3513 if (Tok.isNot(tok::identifier) && Tok.isNot(tok::kw_default)) { 3514 Diag(Tok.getLocation(), diag::err_omp_mapper_illegal_identifier); 3515 SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end, 3516 StopBeforeMatch); 3517 return true; 3518 } 3519 auto &DeclNames = Actions.getASTContext().DeclarationNames; 3520 Data.ReductionOrMapperId = DeclarationNameInfo( 3521 DeclNames.getIdentifier(Tok.getIdentifierInfo()), Tok.getLocation()); 3522 ConsumeToken(); 3523 // Parse ')'. 3524 return T.consumeClose(); 3525 } 3526 3527 /// Parse map-type-modifiers in map clause. 3528 /// map([ [map-type-modifier[,] [map-type-modifier[,] ...] map-type : ] list) 3529 /// where, map-type-modifier ::= always | close | mapper(mapper-identifier) | 3530 /// present 3531 bool Parser::parseMapTypeModifiers(OpenMPVarListDataTy &Data) { 3532 while (getCurToken().isNot(tok::colon)) { 3533 OpenMPMapModifierKind TypeModifier = isMapModifier(*this); 3534 if (TypeModifier == OMPC_MAP_MODIFIER_always || 3535 TypeModifier == OMPC_MAP_MODIFIER_close || 3536 TypeModifier == OMPC_MAP_MODIFIER_present) { 3537 Data.MapTypeModifiers.push_back(TypeModifier); 3538 Data.MapTypeModifiersLoc.push_back(Tok.getLocation()); 3539 ConsumeToken(); 3540 } else if (TypeModifier == OMPC_MAP_MODIFIER_mapper) { 3541 Data.MapTypeModifiers.push_back(TypeModifier); 3542 Data.MapTypeModifiersLoc.push_back(Tok.getLocation()); 3543 ConsumeToken(); 3544 if (parseMapperModifier(Data)) 3545 return true; 3546 } else { 3547 // For the case of unknown map-type-modifier or a map-type. 3548 // Map-type is followed by a colon; the function returns when it 3549 // encounters a token followed by a colon. 3550 if (Tok.is(tok::comma)) { 3551 Diag(Tok, diag::err_omp_map_type_modifier_missing); 3552 ConsumeToken(); 3553 continue; 3554 } 3555 // Potential map-type token as it is followed by a colon. 3556 if (PP.LookAhead(0).is(tok::colon)) 3557 return false; 3558 Diag(Tok, diag::err_omp_unknown_map_type_modifier) 3559 << (getLangOpts().OpenMP >= 51 ? 1 : 0); 3560 ConsumeToken(); 3561 } 3562 if (getCurToken().is(tok::comma)) 3563 ConsumeToken(); 3564 } 3565 return false; 3566 } 3567 3568 /// Checks if the token is a valid map-type. 3569 /// FIXME: It will return an OpenMPMapModifierKind if that's what it parses. 3570 static OpenMPMapClauseKind isMapType(Parser &P) { 3571 Token Tok = P.getCurToken(); 3572 // The map-type token can be either an identifier or the C++ delete keyword. 3573 if (!Tok.isOneOf(tok::identifier, tok::kw_delete)) 3574 return OMPC_MAP_unknown; 3575 Preprocessor &PP = P.getPreprocessor(); 3576 OpenMPMapClauseKind MapType = 3577 static_cast<OpenMPMapClauseKind>(getOpenMPSimpleClauseType( 3578 OMPC_map, PP.getSpelling(Tok), P.getLangOpts().OpenMP)); 3579 return MapType; 3580 } 3581 3582 /// Parse map-type in map clause. 3583 /// map([ [map-type-modifier[,] [map-type-modifier[,] ...] map-type : ] list) 3584 /// where, map-type ::= to | from | tofrom | alloc | release | delete 3585 static void parseMapType(Parser &P, Parser::OpenMPVarListDataTy &Data) { 3586 Token Tok = P.getCurToken(); 3587 if (Tok.is(tok::colon)) { 3588 P.Diag(Tok, diag::err_omp_map_type_missing); 3589 return; 3590 } 3591 Data.ExtraModifier = isMapType(P); 3592 if (Data.ExtraModifier == OMPC_MAP_unknown) 3593 P.Diag(Tok, diag::err_omp_unknown_map_type); 3594 P.ConsumeToken(); 3595 } 3596 3597 /// Parses simple expression in parens for single-expression clauses of OpenMP 3598 /// constructs. 3599 ExprResult Parser::ParseOpenMPIteratorsExpr() { 3600 assert(Tok.is(tok::identifier) && PP.getSpelling(Tok) == "iterator" && 3601 "Expected 'iterator' token."); 3602 SourceLocation IteratorKwLoc = ConsumeToken(); 3603 3604 BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); 3605 if (T.expectAndConsume(diag::err_expected_lparen_after, "iterator")) 3606 return ExprError(); 3607 3608 SourceLocation LLoc = T.getOpenLocation(); 3609 SmallVector<Sema::OMPIteratorData, 4> Data; 3610 while (Tok.isNot(tok::r_paren) && Tok.isNot(tok::annot_pragma_openmp_end)) { 3611 // Check if the type parsing is required. 3612 ParsedType IteratorType; 3613 if (Tok.isNot(tok::identifier) || NextToken().isNot(tok::equal)) { 3614 // identifier '=' is not found - parse type. 3615 TypeResult TR = ParseTypeName(); 3616 if (TR.isInvalid()) { 3617 T.skipToEnd(); 3618 return ExprError(); 3619 } 3620 IteratorType = TR.get(); 3621 } 3622 3623 // Parse identifier. 3624 IdentifierInfo *II = nullptr; 3625 SourceLocation IdLoc; 3626 if (Tok.is(tok::identifier)) { 3627 II = Tok.getIdentifierInfo(); 3628 IdLoc = ConsumeToken(); 3629 } else { 3630 Diag(Tok, diag::err_expected_unqualified_id) << 0; 3631 } 3632 3633 // Parse '='. 3634 SourceLocation AssignLoc; 3635 if (Tok.is(tok::equal)) 3636 AssignLoc = ConsumeToken(); 3637 else 3638 Diag(Tok, diag::err_omp_expected_equal_in_iterator); 3639 3640 // Parse range-specification - <begin> ':' <end> [ ':' <step> ] 3641 ColonProtectionRAIIObject ColonRAII(*this); 3642 // Parse <begin> 3643 SourceLocation Loc = Tok.getLocation(); 3644 ExprResult LHS = ParseCastExpression(AnyCastExpr); 3645 ExprResult Begin = Actions.CorrectDelayedTyposInExpr( 3646 ParseRHSOfBinaryExpression(LHS, prec::Conditional)); 3647 Begin = Actions.ActOnFinishFullExpr(Begin.get(), Loc, 3648 /*DiscardedValue=*/false); 3649 // Parse ':'. 3650 SourceLocation ColonLoc; 3651 if (Tok.is(tok::colon)) 3652 ColonLoc = ConsumeToken(); 3653 3654 // Parse <end> 3655 Loc = Tok.getLocation(); 3656 LHS = ParseCastExpression(AnyCastExpr); 3657 ExprResult End = Actions.CorrectDelayedTyposInExpr( 3658 ParseRHSOfBinaryExpression(LHS, prec::Conditional)); 3659 End = Actions.ActOnFinishFullExpr(End.get(), Loc, 3660 /*DiscardedValue=*/false); 3661 3662 SourceLocation SecColonLoc; 3663 ExprResult Step; 3664 // Parse optional step. 3665 if (Tok.is(tok::colon)) { 3666 // Parse ':' 3667 SecColonLoc = ConsumeToken(); 3668 // Parse <step> 3669 Loc = Tok.getLocation(); 3670 LHS = ParseCastExpression(AnyCastExpr); 3671 Step = Actions.CorrectDelayedTyposInExpr( 3672 ParseRHSOfBinaryExpression(LHS, prec::Conditional)); 3673 Step = Actions.ActOnFinishFullExpr(Step.get(), Loc, 3674 /*DiscardedValue=*/false); 3675 } 3676 3677 // Parse ',' or ')' 3678 if (Tok.isNot(tok::comma) && Tok.isNot(tok::r_paren)) 3679 Diag(Tok, diag::err_omp_expected_punc_after_iterator); 3680 if (Tok.is(tok::comma)) 3681 ConsumeToken(); 3682 3683 Sema::OMPIteratorData &D = Data.emplace_back(); 3684 D.DeclIdent = II; 3685 D.DeclIdentLoc = IdLoc; 3686 D.Type = IteratorType; 3687 D.AssignLoc = AssignLoc; 3688 D.ColonLoc = ColonLoc; 3689 D.SecColonLoc = SecColonLoc; 3690 D.Range.Begin = Begin.get(); 3691 D.Range.End = End.get(); 3692 D.Range.Step = Step.get(); 3693 } 3694 3695 // Parse ')'. 3696 SourceLocation RLoc = Tok.getLocation(); 3697 if (!T.consumeClose()) 3698 RLoc = T.getCloseLocation(); 3699 3700 return Actions.ActOnOMPIteratorExpr(getCurScope(), IteratorKwLoc, LLoc, RLoc, 3701 Data); 3702 } 3703 3704 /// Parses clauses with list. 3705 bool Parser::ParseOpenMPVarList(OpenMPDirectiveKind DKind, 3706 OpenMPClauseKind Kind, 3707 SmallVectorImpl<Expr *> &Vars, 3708 OpenMPVarListDataTy &Data) { 3709 UnqualifiedId UnqualifiedReductionId; 3710 bool InvalidReductionId = false; 3711 bool IsInvalidMapperModifier = false; 3712 3713 // Parse '('. 3714 BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); 3715 if (T.expectAndConsume(diag::err_expected_lparen_after, 3716 getOpenMPClauseName(Kind).data())) 3717 return true; 3718 3719 bool HasIterator = false; 3720 bool NeedRParenForLinear = false; 3721 BalancedDelimiterTracker LinearT(*this, tok::l_paren, 3722 tok::annot_pragma_openmp_end); 3723 // Handle reduction-identifier for reduction clause. 3724 if (Kind == OMPC_reduction || Kind == OMPC_task_reduction || 3725 Kind == OMPC_in_reduction) { 3726 Data.ExtraModifier = OMPC_REDUCTION_unknown; 3727 if (Kind == OMPC_reduction && getLangOpts().OpenMP >= 50 && 3728 (Tok.is(tok::identifier) || Tok.is(tok::kw_default)) && 3729 NextToken().is(tok::comma)) { 3730 // Parse optional reduction modifier. 3731 Data.ExtraModifier = getOpenMPSimpleClauseType(Kind, PP.getSpelling(Tok), 3732 getLangOpts().OpenMP); 3733 Data.ExtraModifierLoc = Tok.getLocation(); 3734 ConsumeToken(); 3735 assert(Tok.is(tok::comma) && "Expected comma."); 3736 (void)ConsumeToken(); 3737 } 3738 ColonProtectionRAIIObject ColonRAII(*this); 3739 if (getLangOpts().CPlusPlus) 3740 ParseOptionalCXXScopeSpecifier(Data.ReductionOrMapperIdScopeSpec, 3741 /*ObjectType=*/nullptr, 3742 /*ObjectHadErrors=*/false, 3743 /*EnteringContext=*/false); 3744 InvalidReductionId = ParseReductionId( 3745 *this, Data.ReductionOrMapperIdScopeSpec, UnqualifiedReductionId); 3746 if (InvalidReductionId) { 3747 SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end, 3748 StopBeforeMatch); 3749 } 3750 if (Tok.is(tok::colon)) 3751 Data.ColonLoc = ConsumeToken(); 3752 else 3753 Diag(Tok, diag::warn_pragma_expected_colon) << "reduction identifier"; 3754 if (!InvalidReductionId) 3755 Data.ReductionOrMapperId = 3756 Actions.GetNameFromUnqualifiedId(UnqualifiedReductionId); 3757 } else if (Kind == OMPC_depend) { 3758 if (getLangOpts().OpenMP >= 50) { 3759 if (Tok.is(tok::identifier) && PP.getSpelling(Tok) == "iterator") { 3760 // Handle optional dependence modifier. 3761 // iterator(iterators-definition) 3762 // where iterators-definition is iterator-specifier [, 3763 // iterators-definition ] 3764 // where iterator-specifier is [ iterator-type ] identifier = 3765 // range-specification 3766 HasIterator = true; 3767 EnterScope(Scope::OpenMPDirectiveScope | Scope::DeclScope); 3768 ExprResult IteratorRes = ParseOpenMPIteratorsExpr(); 3769 Data.DepModOrTailExpr = IteratorRes.get(); 3770 // Parse ',' 3771 ExpectAndConsume(tok::comma); 3772 } 3773 } 3774 // Handle dependency type for depend clause. 3775 ColonProtectionRAIIObject ColonRAII(*this); 3776 Data.ExtraModifier = getOpenMPSimpleClauseType( 3777 Kind, Tok.is(tok::identifier) ? PP.getSpelling(Tok) : "", 3778 getLangOpts().OpenMP); 3779 Data.ExtraModifierLoc = Tok.getLocation(); 3780 if (Data.ExtraModifier == OMPC_DEPEND_unknown) { 3781 SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end, 3782 StopBeforeMatch); 3783 } else { 3784 ConsumeToken(); 3785 // Special processing for depend(source) clause. 3786 if (DKind == OMPD_ordered && Data.ExtraModifier == OMPC_DEPEND_source) { 3787 // Parse ')'. 3788 T.consumeClose(); 3789 return false; 3790 } 3791 } 3792 if (Tok.is(tok::colon)) { 3793 Data.ColonLoc = ConsumeToken(); 3794 } else { 3795 Diag(Tok, DKind == OMPD_ordered ? diag::warn_pragma_expected_colon_r_paren 3796 : diag::warn_pragma_expected_colon) 3797 << "dependency type"; 3798 } 3799 } else if (Kind == OMPC_linear) { 3800 // Try to parse modifier if any. 3801 Data.ExtraModifier = OMPC_LINEAR_val; 3802 if (Tok.is(tok::identifier) && PP.LookAhead(0).is(tok::l_paren)) { 3803 Data.ExtraModifier = getOpenMPSimpleClauseType(Kind, PP.getSpelling(Tok), 3804 getLangOpts().OpenMP); 3805 Data.ExtraModifierLoc = ConsumeToken(); 3806 LinearT.consumeOpen(); 3807 NeedRParenForLinear = true; 3808 } 3809 } else if (Kind == OMPC_lastprivate) { 3810 // Try to parse modifier if any. 3811 Data.ExtraModifier = OMPC_LASTPRIVATE_unknown; 3812 // Conditional modifier allowed only in OpenMP 5.0 and not supported in 3813 // distribute and taskloop based directives. 3814 if ((getLangOpts().OpenMP >= 50 && !isOpenMPDistributeDirective(DKind) && 3815 !isOpenMPTaskLoopDirective(DKind)) && 3816 Tok.is(tok::identifier) && PP.LookAhead(0).is(tok::colon)) { 3817 Data.ExtraModifier = getOpenMPSimpleClauseType(Kind, PP.getSpelling(Tok), 3818 getLangOpts().OpenMP); 3819 Data.ExtraModifierLoc = Tok.getLocation(); 3820 ConsumeToken(); 3821 assert(Tok.is(tok::colon) && "Expected colon."); 3822 Data.ColonLoc = ConsumeToken(); 3823 } 3824 } else if (Kind == OMPC_map) { 3825 // Handle map type for map clause. 3826 ColonProtectionRAIIObject ColonRAII(*this); 3827 3828 // The first identifier may be a list item, a map-type or a 3829 // map-type-modifier. The map-type can also be delete which has the same 3830 // spelling of the C++ delete keyword. 3831 Data.ExtraModifier = OMPC_MAP_unknown; 3832 Data.ExtraModifierLoc = Tok.getLocation(); 3833 3834 // Check for presence of a colon in the map clause. 3835 TentativeParsingAction TPA(*this); 3836 bool ColonPresent = false; 3837 if (SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end, 3838 StopBeforeMatch)) { 3839 if (Tok.is(tok::colon)) 3840 ColonPresent = true; 3841 } 3842 TPA.Revert(); 3843 // Only parse map-type-modifier[s] and map-type if a colon is present in 3844 // the map clause. 3845 if (ColonPresent) { 3846 IsInvalidMapperModifier = parseMapTypeModifiers(Data); 3847 if (!IsInvalidMapperModifier) 3848 parseMapType(*this, Data); 3849 else 3850 SkipUntil(tok::colon, tok::annot_pragma_openmp_end, StopBeforeMatch); 3851 } 3852 if (Data.ExtraModifier == OMPC_MAP_unknown) { 3853 Data.ExtraModifier = OMPC_MAP_tofrom; 3854 Data.IsMapTypeImplicit = true; 3855 } 3856 3857 if (Tok.is(tok::colon)) 3858 Data.ColonLoc = ConsumeToken(); 3859 } else if (Kind == OMPC_to || Kind == OMPC_from) { 3860 while (Tok.is(tok::identifier)) { 3861 auto Modifier = 3862 static_cast<OpenMPMotionModifierKind>(getOpenMPSimpleClauseType( 3863 Kind, PP.getSpelling(Tok), getLangOpts().OpenMP)); 3864 if (Modifier == OMPC_MOTION_MODIFIER_unknown) 3865 break; 3866 Data.MotionModifiers.push_back(Modifier); 3867 Data.MotionModifiersLoc.push_back(Tok.getLocation()); 3868 ConsumeToken(); 3869 if (Modifier == OMPC_MOTION_MODIFIER_mapper) { 3870 IsInvalidMapperModifier = parseMapperModifier(Data); 3871 if (IsInvalidMapperModifier) 3872 break; 3873 } 3874 // OpenMP < 5.1 doesn't permit a ',' or additional modifiers. 3875 if (getLangOpts().OpenMP < 51) 3876 break; 3877 // OpenMP 5.1 accepts an optional ',' even if the next character is ':'. 3878 // TODO: Is that intentional? 3879 if (Tok.is(tok::comma)) 3880 ConsumeToken(); 3881 } 3882 if (!Data.MotionModifiers.empty() && Tok.isNot(tok::colon)) { 3883 if (!IsInvalidMapperModifier) { 3884 if (getLangOpts().OpenMP < 51) 3885 Diag(Tok, diag::warn_pragma_expected_colon) << ")"; 3886 else 3887 Diag(Tok, diag::warn_pragma_expected_colon) << "motion modifier"; 3888 } 3889 SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end, 3890 StopBeforeMatch); 3891 } 3892 // OpenMP 5.1 permits a ':' even without a preceding modifier. TODO: Is 3893 // that intentional? 3894 if ((!Data.MotionModifiers.empty() || getLangOpts().OpenMP >= 51) && 3895 Tok.is(tok::colon)) 3896 Data.ColonLoc = ConsumeToken(); 3897 } else if (Kind == OMPC_allocate || 3898 (Kind == OMPC_affinity && Tok.is(tok::identifier) && 3899 PP.getSpelling(Tok) == "iterator")) { 3900 // Handle optional allocator expression followed by colon delimiter. 3901 ColonProtectionRAIIObject ColonRAII(*this); 3902 TentativeParsingAction TPA(*this); 3903 // OpenMP 5.0, 2.10.1, task Construct. 3904 // where aff-modifier is one of the following: 3905 // iterator(iterators-definition) 3906 ExprResult Tail; 3907 if (Kind == OMPC_allocate) { 3908 Tail = ParseAssignmentExpression(); 3909 } else { 3910 HasIterator = true; 3911 EnterScope(Scope::OpenMPDirectiveScope | Scope::DeclScope); 3912 Tail = ParseOpenMPIteratorsExpr(); 3913 } 3914 Tail = Actions.CorrectDelayedTyposInExpr(Tail); 3915 Tail = Actions.ActOnFinishFullExpr(Tail.get(), T.getOpenLocation(), 3916 /*DiscardedValue=*/false); 3917 if (Tail.isUsable()) { 3918 if (Tok.is(tok::colon)) { 3919 Data.DepModOrTailExpr = Tail.get(); 3920 Data.ColonLoc = ConsumeToken(); 3921 TPA.Commit(); 3922 } else { 3923 // Colon not found, parse only list of variables. 3924 TPA.Revert(); 3925 } 3926 } else { 3927 // Parsing was unsuccessfull, revert and skip to the end of clause or 3928 // directive. 3929 TPA.Revert(); 3930 SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end, 3931 StopBeforeMatch); 3932 } 3933 } 3934 3935 bool IsComma = 3936 (Kind != OMPC_reduction && Kind != OMPC_task_reduction && 3937 Kind != OMPC_in_reduction && Kind != OMPC_depend && Kind != OMPC_map) || 3938 (Kind == OMPC_reduction && !InvalidReductionId) || 3939 (Kind == OMPC_map && Data.ExtraModifier != OMPC_MAP_unknown) || 3940 (Kind == OMPC_depend && Data.ExtraModifier != OMPC_DEPEND_unknown); 3941 const bool MayHaveTail = (Kind == OMPC_linear || Kind == OMPC_aligned); 3942 while (IsComma || (Tok.isNot(tok::r_paren) && Tok.isNot(tok::colon) && 3943 Tok.isNot(tok::annot_pragma_openmp_end))) { 3944 ParseScope OMPListScope(this, Scope::OpenMPDirectiveScope); 3945 ColonProtectionRAIIObject ColonRAII(*this, MayHaveTail); 3946 // Parse variable 3947 ExprResult VarExpr = 3948 Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression()); 3949 if (VarExpr.isUsable()) { 3950 Vars.push_back(VarExpr.get()); 3951 } else { 3952 SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end, 3953 StopBeforeMatch); 3954 } 3955 // Skip ',' if any 3956 IsComma = Tok.is(tok::comma); 3957 if (IsComma) 3958 ConsumeToken(); 3959 else if (Tok.isNot(tok::r_paren) && 3960 Tok.isNot(tok::annot_pragma_openmp_end) && 3961 (!MayHaveTail || Tok.isNot(tok::colon))) 3962 Diag(Tok, diag::err_omp_expected_punc) 3963 << ((Kind == OMPC_flush) ? getOpenMPDirectiveName(OMPD_flush) 3964 : getOpenMPClauseName(Kind)) 3965 << (Kind == OMPC_flush); 3966 } 3967 3968 // Parse ')' for linear clause with modifier. 3969 if (NeedRParenForLinear) 3970 LinearT.consumeClose(); 3971 3972 // Parse ':' linear-step (or ':' alignment). 3973 const bool MustHaveTail = MayHaveTail && Tok.is(tok::colon); 3974 if (MustHaveTail) { 3975 Data.ColonLoc = Tok.getLocation(); 3976 SourceLocation ELoc = ConsumeToken(); 3977 ExprResult Tail = ParseAssignmentExpression(); 3978 Tail = 3979 Actions.ActOnFinishFullExpr(Tail.get(), ELoc, /*DiscardedValue*/ false); 3980 if (Tail.isUsable()) 3981 Data.DepModOrTailExpr = Tail.get(); 3982 else 3983 SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end, 3984 StopBeforeMatch); 3985 } 3986 3987 // Parse ')'. 3988 Data.RLoc = Tok.getLocation(); 3989 if (!T.consumeClose()) 3990 Data.RLoc = T.getCloseLocation(); 3991 // Exit from scope when the iterator is used in depend clause. 3992 if (HasIterator) 3993 ExitScope(); 3994 return (Kind != OMPC_depend && Kind != OMPC_map && Vars.empty()) || 3995 (MustHaveTail && !Data.DepModOrTailExpr) || InvalidReductionId || 3996 IsInvalidMapperModifier; 3997 } 3998 3999 /// Parsing of OpenMP clause 'private', 'firstprivate', 'lastprivate', 4000 /// 'shared', 'copyin', 'copyprivate', 'flush', 'reduction', 'task_reduction', 4001 /// 'in_reduction', 'nontemporal', 'exclusive' or 'inclusive'. 4002 /// 4003 /// private-clause: 4004 /// 'private' '(' list ')' 4005 /// firstprivate-clause: 4006 /// 'firstprivate' '(' list ')' 4007 /// lastprivate-clause: 4008 /// 'lastprivate' '(' list ')' 4009 /// shared-clause: 4010 /// 'shared' '(' list ')' 4011 /// linear-clause: 4012 /// 'linear' '(' linear-list [ ':' linear-step ] ')' 4013 /// aligned-clause: 4014 /// 'aligned' '(' list [ ':' alignment ] ')' 4015 /// reduction-clause: 4016 /// 'reduction' '(' [ modifier ',' ] reduction-identifier ':' list ')' 4017 /// task_reduction-clause: 4018 /// 'task_reduction' '(' reduction-identifier ':' list ')' 4019 /// in_reduction-clause: 4020 /// 'in_reduction' '(' reduction-identifier ':' list ')' 4021 /// copyprivate-clause: 4022 /// 'copyprivate' '(' list ')' 4023 /// flush-clause: 4024 /// 'flush' '(' list ')' 4025 /// depend-clause: 4026 /// 'depend' '(' in | out | inout : list | source ')' 4027 /// map-clause: 4028 /// 'map' '(' [ [ always [,] ] [ close [,] ] 4029 /// [ mapper '(' mapper-identifier ')' [,] ] 4030 /// to | from | tofrom | alloc | release | delete ':' ] list ')'; 4031 /// to-clause: 4032 /// 'to' '(' [ mapper '(' mapper-identifier ')' ':' ] list ')' 4033 /// from-clause: 4034 /// 'from' '(' [ mapper '(' mapper-identifier ')' ':' ] list ')' 4035 /// use_device_ptr-clause: 4036 /// 'use_device_ptr' '(' list ')' 4037 /// use_device_addr-clause: 4038 /// 'use_device_addr' '(' list ')' 4039 /// is_device_ptr-clause: 4040 /// 'is_device_ptr' '(' list ')' 4041 /// allocate-clause: 4042 /// 'allocate' '(' [ allocator ':' ] list ')' 4043 /// nontemporal-clause: 4044 /// 'nontemporal' '(' list ')' 4045 /// inclusive-clause: 4046 /// 'inclusive' '(' list ')' 4047 /// exclusive-clause: 4048 /// 'exclusive' '(' list ')' 4049 /// 4050 /// For 'linear' clause linear-list may have the following forms: 4051 /// list 4052 /// modifier(list) 4053 /// where modifier is 'val' (C) or 'ref', 'val' or 'uval'(C++). 4054 OMPClause *Parser::ParseOpenMPVarListClause(OpenMPDirectiveKind DKind, 4055 OpenMPClauseKind Kind, 4056 bool ParseOnly) { 4057 SourceLocation Loc = Tok.getLocation(); 4058 SourceLocation LOpen = ConsumeToken(); 4059 SmallVector<Expr *, 4> Vars; 4060 OpenMPVarListDataTy Data; 4061 4062 if (ParseOpenMPVarList(DKind, Kind, Vars, Data)) 4063 return nullptr; 4064 4065 if (ParseOnly) 4066 return nullptr; 4067 OMPVarListLocTy Locs(Loc, LOpen, Data.RLoc); 4068 return Actions.ActOnOpenMPVarListClause( 4069 Kind, Vars, Data.DepModOrTailExpr, Locs, Data.ColonLoc, 4070 Data.ReductionOrMapperIdScopeSpec, Data.ReductionOrMapperId, 4071 Data.ExtraModifier, Data.MapTypeModifiers, Data.MapTypeModifiersLoc, 4072 Data.IsMapTypeImplicit, Data.ExtraModifierLoc, Data.MotionModifiers, 4073 Data.MotionModifiersLoc); 4074 } 4075