1 //===--- ParseOpenMP.cpp - OpenMP directives parsing ----------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 /// \file 10 /// \brief This file implements parsing of all OpenMP directives and clauses. 11 /// 12 //===----------------------------------------------------------------------===// 13 14 #include "RAIIObjectsForParser.h" 15 #include "clang/AST/ASTConsumer.h" 16 #include "clang/AST/ASTContext.h" 17 #include "clang/AST/StmtOpenMP.h" 18 #include "clang/Parse/ParseDiagnostic.h" 19 #include "clang/Parse/Parser.h" 20 #include "clang/Sema/Scope.h" 21 #include "llvm/ADT/PointerIntPair.h" 22 23 using namespace clang; 24 25 //===----------------------------------------------------------------------===// 26 // OpenMP declarative directives. 27 //===----------------------------------------------------------------------===// 28 29 namespace { 30 enum OpenMPDirectiveKindEx { 31 OMPD_cancellation = OMPD_unknown + 1, 32 OMPD_data, 33 OMPD_declare, 34 OMPD_end, 35 OMPD_end_declare, 36 OMPD_enter, 37 OMPD_exit, 38 OMPD_point, 39 OMPD_reduction, 40 OMPD_target_enter, 41 OMPD_target_exit, 42 OMPD_update, 43 OMPD_distribute_parallel 44 }; 45 46 class ThreadprivateListParserHelper final { 47 SmallVector<Expr *, 4> Identifiers; 48 Parser *P; 49 50 public: 51 ThreadprivateListParserHelper(Parser *P) : P(P) {} 52 void operator()(CXXScopeSpec &SS, DeclarationNameInfo NameInfo) { 53 ExprResult Res = 54 P->getActions().ActOnOpenMPIdExpression(P->getCurScope(), SS, NameInfo); 55 if (Res.isUsable()) 56 Identifiers.push_back(Res.get()); 57 } 58 llvm::ArrayRef<Expr *> getIdentifiers() const { return Identifiers; } 59 }; 60 } // namespace 61 62 // Map token string to extended OMP token kind that are 63 // OpenMPDirectiveKind + OpenMPDirectiveKindEx. 64 static unsigned getOpenMPDirectiveKindEx(StringRef S) { 65 auto DKind = getOpenMPDirectiveKind(S); 66 if (DKind != OMPD_unknown) 67 return DKind; 68 69 return llvm::StringSwitch<unsigned>(S) 70 .Case("cancellation", OMPD_cancellation) 71 .Case("data", OMPD_data) 72 .Case("declare", OMPD_declare) 73 .Case("end", OMPD_end) 74 .Case("enter", OMPD_enter) 75 .Case("exit", OMPD_exit) 76 .Case("point", OMPD_point) 77 .Case("reduction", OMPD_reduction) 78 .Case("update", OMPD_update) 79 .Default(OMPD_unknown); 80 } 81 82 static OpenMPDirectiveKind ParseOpenMPDirectiveKind(Parser &P) { 83 // Array of foldings: F[i][0] F[i][1] ===> F[i][2]. 84 // E.g.: OMPD_for OMPD_simd ===> OMPD_for_simd 85 // TODO: add other combined directives in topological order. 86 static const unsigned F[][3] = { 87 { OMPD_cancellation, OMPD_point, OMPD_cancellation_point }, 88 { OMPD_declare, OMPD_reduction, OMPD_declare_reduction }, 89 { OMPD_declare, OMPD_simd, OMPD_declare_simd }, 90 { OMPD_declare, OMPD_target, OMPD_declare_target }, 91 { OMPD_distribute, OMPD_parallel, OMPD_distribute_parallel }, 92 { OMPD_distribute_parallel, OMPD_for, OMPD_distribute_parallel_for }, 93 { OMPD_distribute_parallel_for, OMPD_simd, 94 OMPD_distribute_parallel_for_simd }, 95 { OMPD_distribute, OMPD_simd, OMPD_distribute_simd }, 96 { OMPD_end, OMPD_declare, OMPD_end_declare }, 97 { OMPD_end_declare, OMPD_target, OMPD_end_declare_target }, 98 { OMPD_target, OMPD_data, OMPD_target_data }, 99 { OMPD_target, OMPD_enter, OMPD_target_enter }, 100 { OMPD_target, OMPD_exit, OMPD_target_exit }, 101 { OMPD_target, OMPD_update, OMPD_target_update }, 102 { OMPD_target_enter, OMPD_data, OMPD_target_enter_data }, 103 { OMPD_target_exit, OMPD_data, OMPD_target_exit_data }, 104 { OMPD_for, OMPD_simd, OMPD_for_simd }, 105 { OMPD_parallel, OMPD_for, OMPD_parallel_for }, 106 { OMPD_parallel_for, OMPD_simd, OMPD_parallel_for_simd }, 107 { OMPD_parallel, OMPD_sections, OMPD_parallel_sections }, 108 { OMPD_taskloop, OMPD_simd, OMPD_taskloop_simd }, 109 { OMPD_target, OMPD_parallel, OMPD_target_parallel }, 110 { OMPD_target_parallel, OMPD_for, OMPD_target_parallel_for }, 111 { OMPD_target_parallel_for, OMPD_simd, OMPD_target_parallel_for_simd } 112 }; 113 enum { CancellationPoint = 0, DeclareReduction = 1, TargetData = 2 }; 114 auto Tok = P.getCurToken(); 115 unsigned DKind = 116 Tok.isAnnotation() 117 ? static_cast<unsigned>(OMPD_unknown) 118 : getOpenMPDirectiveKindEx(P.getPreprocessor().getSpelling(Tok)); 119 if (DKind == OMPD_unknown) 120 return OMPD_unknown; 121 122 for (unsigned i = 0; i < llvm::array_lengthof(F); ++i) { 123 if (DKind != F[i][0]) 124 continue; 125 126 Tok = P.getPreprocessor().LookAhead(0); 127 unsigned SDKind = 128 Tok.isAnnotation() 129 ? static_cast<unsigned>(OMPD_unknown) 130 : getOpenMPDirectiveKindEx(P.getPreprocessor().getSpelling(Tok)); 131 if (SDKind == OMPD_unknown) 132 continue; 133 134 if (SDKind == F[i][1]) { 135 P.ConsumeToken(); 136 DKind = F[i][2]; 137 } 138 } 139 return DKind < OMPD_unknown ? static_cast<OpenMPDirectiveKind>(DKind) 140 : OMPD_unknown; 141 } 142 143 static DeclarationName parseOpenMPReductionId(Parser &P) { 144 Token Tok = P.getCurToken(); 145 Sema &Actions = P.getActions(); 146 OverloadedOperatorKind OOK = OO_None; 147 // Allow to use 'operator' keyword for C++ operators 148 bool WithOperator = false; 149 if (Tok.is(tok::kw_operator)) { 150 P.ConsumeToken(); 151 Tok = P.getCurToken(); 152 WithOperator = true; 153 } 154 switch (Tok.getKind()) { 155 case tok::plus: // '+' 156 OOK = OO_Plus; 157 break; 158 case tok::minus: // '-' 159 OOK = OO_Minus; 160 break; 161 case tok::star: // '*' 162 OOK = OO_Star; 163 break; 164 case tok::amp: // '&' 165 OOK = OO_Amp; 166 break; 167 case tok::pipe: // '|' 168 OOK = OO_Pipe; 169 break; 170 case tok::caret: // '^' 171 OOK = OO_Caret; 172 break; 173 case tok::ampamp: // '&&' 174 OOK = OO_AmpAmp; 175 break; 176 case tok::pipepipe: // '||' 177 OOK = OO_PipePipe; 178 break; 179 case tok::identifier: // identifier 180 if (!WithOperator) 181 break; 182 default: 183 P.Diag(Tok.getLocation(), diag::err_omp_expected_reduction_identifier); 184 P.SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end, 185 Parser::StopBeforeMatch); 186 return DeclarationName(); 187 } 188 P.ConsumeToken(); 189 auto &DeclNames = Actions.getASTContext().DeclarationNames; 190 return OOK == OO_None ? DeclNames.getIdentifier(Tok.getIdentifierInfo()) 191 : DeclNames.getCXXOperatorName(OOK); 192 } 193 194 /// \brief Parse 'omp declare reduction' construct. 195 /// 196 /// declare-reduction-directive: 197 /// annot_pragma_openmp 'declare' 'reduction' 198 /// '(' <reduction_id> ':' <type> {',' <type>} ':' <expression> ')' 199 /// ['initializer' '(' ('omp_priv' '=' <expression>)|<function_call> ')'] 200 /// annot_pragma_openmp_end 201 /// <reduction_id> is either a base language identifier or one of the following 202 /// operators: '+', '-', '*', '&', '|', '^', '&&' and '||'. 203 /// 204 Parser::DeclGroupPtrTy 205 Parser::ParseOpenMPDeclareReductionDirective(AccessSpecifier AS) { 206 // Parse '('. 207 BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); 208 if (T.expectAndConsume(diag::err_expected_lparen_after, 209 getOpenMPDirectiveName(OMPD_declare_reduction))) { 210 SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch); 211 return DeclGroupPtrTy(); 212 } 213 214 DeclarationName Name = parseOpenMPReductionId(*this); 215 if (Name.isEmpty() && Tok.is(tok::annot_pragma_openmp_end)) 216 return DeclGroupPtrTy(); 217 218 // Consume ':'. 219 bool IsCorrect = !ExpectAndConsume(tok::colon); 220 221 if (!IsCorrect && Tok.is(tok::annot_pragma_openmp_end)) 222 return DeclGroupPtrTy(); 223 224 IsCorrect = IsCorrect && !Name.isEmpty(); 225 226 if (Tok.is(tok::colon) || Tok.is(tok::annot_pragma_openmp_end)) { 227 Diag(Tok.getLocation(), diag::err_expected_type); 228 IsCorrect = false; 229 } 230 231 if (!IsCorrect && Tok.is(tok::annot_pragma_openmp_end)) 232 return DeclGroupPtrTy(); 233 234 SmallVector<std::pair<QualType, SourceLocation>, 8> ReductionTypes; 235 // Parse list of types until ':' token. 236 do { 237 ColonProtectionRAIIObject ColonRAII(*this); 238 SourceRange Range; 239 TypeResult TR = ParseTypeName(&Range, Declarator::PrototypeContext, AS); 240 if (TR.isUsable()) { 241 auto ReductionType = 242 Actions.ActOnOpenMPDeclareReductionType(Range.getBegin(), TR); 243 if (!ReductionType.isNull()) { 244 ReductionTypes.push_back( 245 std::make_pair(ReductionType, Range.getBegin())); 246 } 247 } else { 248 SkipUntil(tok::comma, tok::colon, tok::annot_pragma_openmp_end, 249 StopBeforeMatch); 250 } 251 252 if (Tok.is(tok::colon) || Tok.is(tok::annot_pragma_openmp_end)) 253 break; 254 255 // Consume ','. 256 if (ExpectAndConsume(tok::comma)) { 257 IsCorrect = false; 258 if (Tok.is(tok::annot_pragma_openmp_end)) { 259 Diag(Tok.getLocation(), diag::err_expected_type); 260 return DeclGroupPtrTy(); 261 } 262 } 263 } while (Tok.isNot(tok::annot_pragma_openmp_end)); 264 265 if (ReductionTypes.empty()) { 266 SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch); 267 return DeclGroupPtrTy(); 268 } 269 270 if (!IsCorrect && Tok.is(tok::annot_pragma_openmp_end)) 271 return DeclGroupPtrTy(); 272 273 // Consume ':'. 274 if (ExpectAndConsume(tok::colon)) 275 IsCorrect = false; 276 277 if (Tok.is(tok::annot_pragma_openmp_end)) { 278 Diag(Tok.getLocation(), diag::err_expected_expression); 279 return DeclGroupPtrTy(); 280 } 281 282 DeclGroupPtrTy DRD = Actions.ActOnOpenMPDeclareReductionDirectiveStart( 283 getCurScope(), Actions.getCurLexicalContext(), Name, ReductionTypes, AS); 284 285 // Parse <combiner> expression and then parse initializer if any for each 286 // correct type. 287 unsigned I = 0, E = ReductionTypes.size(); 288 for (auto *D : DRD.get()) { 289 TentativeParsingAction TPA(*this); 290 ParseScope OMPDRScope(this, Scope::FnScope | Scope::DeclScope | 291 Scope::OpenMPDirectiveScope); 292 // Parse <combiner> expression. 293 Actions.ActOnOpenMPDeclareReductionCombinerStart(getCurScope(), D); 294 ExprResult CombinerResult = 295 Actions.ActOnFinishFullExpr(ParseAssignmentExpression().get(), 296 D->getLocation(), /*DiscardedValue=*/true); 297 Actions.ActOnOpenMPDeclareReductionCombinerEnd(D, CombinerResult.get()); 298 299 if (CombinerResult.isInvalid() && Tok.isNot(tok::r_paren) && 300 Tok.isNot(tok::annot_pragma_openmp_end)) { 301 TPA.Commit(); 302 IsCorrect = false; 303 break; 304 } 305 IsCorrect = !T.consumeClose() && IsCorrect && CombinerResult.isUsable(); 306 ExprResult InitializerResult; 307 if (Tok.isNot(tok::annot_pragma_openmp_end)) { 308 // Parse <initializer> expression. 309 if (Tok.is(tok::identifier) && 310 Tok.getIdentifierInfo()->isStr("initializer")) 311 ConsumeToken(); 312 else { 313 Diag(Tok.getLocation(), diag::err_expected) << "'initializer'"; 314 TPA.Commit(); 315 IsCorrect = false; 316 break; 317 } 318 // Parse '('. 319 BalancedDelimiterTracker T(*this, tok::l_paren, 320 tok::annot_pragma_openmp_end); 321 IsCorrect = 322 !T.expectAndConsume(diag::err_expected_lparen_after, "initializer") && 323 IsCorrect; 324 if (Tok.isNot(tok::annot_pragma_openmp_end)) { 325 ParseScope OMPDRScope(this, Scope::FnScope | Scope::DeclScope | 326 Scope::OpenMPDirectiveScope); 327 // Parse expression. 328 Actions.ActOnOpenMPDeclareReductionInitializerStart(getCurScope(), D); 329 InitializerResult = Actions.ActOnFinishFullExpr( 330 ParseAssignmentExpression().get(), D->getLocation(), 331 /*DiscardedValue=*/true); 332 Actions.ActOnOpenMPDeclareReductionInitializerEnd( 333 D, InitializerResult.get()); 334 if (InitializerResult.isInvalid() && Tok.isNot(tok::r_paren) && 335 Tok.isNot(tok::annot_pragma_openmp_end)) { 336 TPA.Commit(); 337 IsCorrect = false; 338 break; 339 } 340 IsCorrect = 341 !T.consumeClose() && IsCorrect && !InitializerResult.isInvalid(); 342 } 343 } 344 345 ++I; 346 // Revert parsing if not the last type, otherwise accept it, we're done with 347 // parsing. 348 if (I != E) 349 TPA.Revert(); 350 else 351 TPA.Commit(); 352 } 353 return Actions.ActOnOpenMPDeclareReductionDirectiveEnd(getCurScope(), DRD, 354 IsCorrect); 355 } 356 357 namespace { 358 /// RAII that recreates function context for correct parsing of clauses of 359 /// 'declare simd' construct. 360 /// OpenMP, 2.8.2 declare simd Construct 361 /// The expressions appearing in the clauses of this directive are evaluated in 362 /// the scope of the arguments of the function declaration or definition. 363 class FNContextRAII final { 364 Parser &P; 365 Sema::CXXThisScopeRAII *ThisScope; 366 Parser::ParseScope *TempScope; 367 Parser::ParseScope *FnScope; 368 bool HasTemplateScope = false; 369 bool HasFunScope = false; 370 FNContextRAII() = delete; 371 FNContextRAII(const FNContextRAII &) = delete; 372 FNContextRAII &operator=(const FNContextRAII &) = delete; 373 374 public: 375 FNContextRAII(Parser &P, Parser::DeclGroupPtrTy Ptr) : P(P) { 376 Decl *D = *Ptr.get().begin(); 377 NamedDecl *ND = dyn_cast<NamedDecl>(D); 378 RecordDecl *RD = dyn_cast_or_null<RecordDecl>(D->getDeclContext()); 379 Sema &Actions = P.getActions(); 380 381 // Allow 'this' within late-parsed attributes. 382 ThisScope = new Sema::CXXThisScopeRAII(Actions, RD, /*TypeQuals=*/0, 383 ND && ND->isCXXInstanceMember()); 384 385 // If the Decl is templatized, add template parameters to scope. 386 HasTemplateScope = D->isTemplateDecl(); 387 TempScope = 388 new Parser::ParseScope(&P, Scope::TemplateParamScope, HasTemplateScope); 389 if (HasTemplateScope) 390 Actions.ActOnReenterTemplateScope(Actions.getCurScope(), D); 391 392 // If the Decl is on a function, add function parameters to the scope. 393 HasFunScope = D->isFunctionOrFunctionTemplate(); 394 FnScope = new Parser::ParseScope(&P, Scope::FnScope | Scope::DeclScope, 395 HasFunScope); 396 if (HasFunScope) 397 Actions.ActOnReenterFunctionContext(Actions.getCurScope(), D); 398 } 399 ~FNContextRAII() { 400 if (HasFunScope) { 401 P.getActions().ActOnExitFunctionContext(); 402 FnScope->Exit(); // Pop scope, and remove Decls from IdResolver 403 } 404 if (HasTemplateScope) 405 TempScope->Exit(); 406 delete FnScope; 407 delete TempScope; 408 delete ThisScope; 409 } 410 }; 411 } // namespace 412 413 /// Parses clauses for 'declare simd' directive. 414 /// clause: 415 /// 'inbranch' | 'notinbranch' 416 /// 'simdlen' '(' <expr> ')' 417 /// { 'uniform' '(' <argument_list> ')' } 418 /// { 'aligned '(' <argument_list> [ ':' <alignment> ] ')' } 419 /// { 'linear '(' <argument_list> [ ':' <step> ] ')' } 420 static bool parseDeclareSimdClauses( 421 Parser &P, OMPDeclareSimdDeclAttr::BranchStateTy &BS, ExprResult &SimdLen, 422 SmallVectorImpl<Expr *> &Uniforms, SmallVectorImpl<Expr *> &Aligneds, 423 SmallVectorImpl<Expr *> &Alignments, SmallVectorImpl<Expr *> &Linears, 424 SmallVectorImpl<unsigned> &LinModifiers, SmallVectorImpl<Expr *> &Steps) { 425 SourceRange BSRange; 426 const Token &Tok = P.getCurToken(); 427 bool IsError = false; 428 while (Tok.isNot(tok::annot_pragma_openmp_end)) { 429 if (Tok.isNot(tok::identifier)) 430 break; 431 OMPDeclareSimdDeclAttr::BranchStateTy Out; 432 IdentifierInfo *II = Tok.getIdentifierInfo(); 433 StringRef ClauseName = II->getName(); 434 // Parse 'inranch|notinbranch' clauses. 435 if (OMPDeclareSimdDeclAttr::ConvertStrToBranchStateTy(ClauseName, Out)) { 436 if (BS != OMPDeclareSimdDeclAttr::BS_Undefined && BS != Out) { 437 P.Diag(Tok, diag::err_omp_declare_simd_inbranch_notinbranch) 438 << ClauseName 439 << OMPDeclareSimdDeclAttr::ConvertBranchStateTyToStr(BS) << BSRange; 440 IsError = true; 441 } 442 BS = Out; 443 BSRange = SourceRange(Tok.getLocation(), Tok.getEndLoc()); 444 P.ConsumeToken(); 445 } else if (ClauseName.equals("simdlen")) { 446 if (SimdLen.isUsable()) { 447 P.Diag(Tok, diag::err_omp_more_one_clause) 448 << getOpenMPDirectiveName(OMPD_declare_simd) << ClauseName << 0; 449 IsError = true; 450 } 451 P.ConsumeToken(); 452 SourceLocation RLoc; 453 SimdLen = P.ParseOpenMPParensExpr(ClauseName, RLoc); 454 if (SimdLen.isInvalid()) 455 IsError = true; 456 } else { 457 OpenMPClauseKind CKind = getOpenMPClauseKind(ClauseName); 458 if (CKind == OMPC_uniform || CKind == OMPC_aligned || 459 CKind == OMPC_linear) { 460 Parser::OpenMPVarListDataTy Data; 461 auto *Vars = &Uniforms; 462 if (CKind == OMPC_aligned) 463 Vars = &Aligneds; 464 else if (CKind == OMPC_linear) 465 Vars = &Linears; 466 467 P.ConsumeToken(); 468 if (P.ParseOpenMPVarList(OMPD_declare_simd, 469 getOpenMPClauseKind(ClauseName), *Vars, Data)) 470 IsError = true; 471 if (CKind == OMPC_aligned) 472 Alignments.append(Aligneds.size() - Alignments.size(), Data.TailExpr); 473 else if (CKind == OMPC_linear) { 474 if (P.getActions().CheckOpenMPLinearModifier(Data.LinKind, 475 Data.DepLinMapLoc)) 476 Data.LinKind = OMPC_LINEAR_val; 477 LinModifiers.append(Linears.size() - LinModifiers.size(), 478 Data.LinKind); 479 Steps.append(Linears.size() - Steps.size(), Data.TailExpr); 480 } 481 } else 482 // TODO: add parsing of other clauses. 483 break; 484 } 485 // Skip ',' if any. 486 if (Tok.is(tok::comma)) 487 P.ConsumeToken(); 488 } 489 return IsError; 490 } 491 492 /// Parse clauses for '#pragma omp declare simd'. 493 Parser::DeclGroupPtrTy 494 Parser::ParseOMPDeclareSimdClauses(Parser::DeclGroupPtrTy Ptr, 495 CachedTokens &Toks, SourceLocation Loc) { 496 PP.EnterToken(Tok); 497 PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true); 498 // Consume the previously pushed token. 499 ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true); 500 501 FNContextRAII FnContext(*this, Ptr); 502 OMPDeclareSimdDeclAttr::BranchStateTy BS = 503 OMPDeclareSimdDeclAttr::BS_Undefined; 504 ExprResult Simdlen; 505 SmallVector<Expr *, 4> Uniforms; 506 SmallVector<Expr *, 4> Aligneds; 507 SmallVector<Expr *, 4> Alignments; 508 SmallVector<Expr *, 4> Linears; 509 SmallVector<unsigned, 4> LinModifiers; 510 SmallVector<Expr *, 4> Steps; 511 bool IsError = 512 parseDeclareSimdClauses(*this, BS, Simdlen, Uniforms, Aligneds, 513 Alignments, Linears, LinModifiers, Steps); 514 // Need to check for extra tokens. 515 if (Tok.isNot(tok::annot_pragma_openmp_end)) { 516 Diag(Tok, diag::warn_omp_extra_tokens_at_eol) 517 << getOpenMPDirectiveName(OMPD_declare_simd); 518 while (Tok.isNot(tok::annot_pragma_openmp_end)) 519 ConsumeAnyToken(); 520 } 521 // Skip the last annot_pragma_openmp_end. 522 SourceLocation EndLoc = ConsumeToken(); 523 if (!IsError) { 524 return Actions.ActOnOpenMPDeclareSimdDirective( 525 Ptr, BS, Simdlen.get(), Uniforms, Aligneds, Alignments, Linears, 526 LinModifiers, Steps, SourceRange(Loc, EndLoc)); 527 } 528 return Ptr; 529 } 530 531 /// \brief Parsing of declarative OpenMP directives. 532 /// 533 /// threadprivate-directive: 534 /// annot_pragma_openmp 'threadprivate' simple-variable-list 535 /// annot_pragma_openmp_end 536 /// 537 /// declare-reduction-directive: 538 /// annot_pragma_openmp 'declare' 'reduction' [...] 539 /// annot_pragma_openmp_end 540 /// 541 /// declare-simd-directive: 542 /// annot_pragma_openmp 'declare simd' {<clause> [,]} 543 /// annot_pragma_openmp_end 544 /// <function declaration/definition> 545 /// 546 Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirectiveWithExtDecl( 547 AccessSpecifier &AS, ParsedAttributesWithRange &Attrs, 548 DeclSpec::TST TagType, Decl *Tag) { 549 assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!"); 550 ParenBraceBracketBalancer BalancerRAIIObj(*this); 551 552 SourceLocation Loc = ConsumeToken(); 553 auto DKind = ParseOpenMPDirectiveKind(*this); 554 555 switch (DKind) { 556 case OMPD_threadprivate: { 557 ConsumeToken(); 558 ThreadprivateListParserHelper Helper(this); 559 if (!ParseOpenMPSimpleVarList(OMPD_threadprivate, Helper, true)) { 560 // The last seen token is annot_pragma_openmp_end - need to check for 561 // extra tokens. 562 if (Tok.isNot(tok::annot_pragma_openmp_end)) { 563 Diag(Tok, diag::warn_omp_extra_tokens_at_eol) 564 << getOpenMPDirectiveName(OMPD_threadprivate); 565 SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch); 566 } 567 // Skip the last annot_pragma_openmp_end. 568 ConsumeToken(); 569 return Actions.ActOnOpenMPThreadprivateDirective(Loc, 570 Helper.getIdentifiers()); 571 } 572 break; 573 } 574 case OMPD_declare_reduction: 575 ConsumeToken(); 576 if (auto Res = ParseOpenMPDeclareReductionDirective(AS)) { 577 // The last seen token is annot_pragma_openmp_end - need to check for 578 // extra tokens. 579 if (Tok.isNot(tok::annot_pragma_openmp_end)) { 580 Diag(Tok, diag::warn_omp_extra_tokens_at_eol) 581 << getOpenMPDirectiveName(OMPD_declare_reduction); 582 while (Tok.isNot(tok::annot_pragma_openmp_end)) 583 ConsumeAnyToken(); 584 } 585 // Skip the last annot_pragma_openmp_end. 586 ConsumeToken(); 587 return Res; 588 } 589 break; 590 case OMPD_declare_simd: { 591 // The syntax is: 592 // { #pragma omp declare simd } 593 // <function-declaration-or-definition> 594 // 595 ConsumeToken(); 596 CachedTokens Toks; 597 while(Tok.isNot(tok::annot_pragma_openmp_end)) { 598 Toks.push_back(Tok); 599 ConsumeAnyToken(); 600 } 601 Toks.push_back(Tok); 602 ConsumeAnyToken(); 603 604 DeclGroupPtrTy Ptr; 605 if (Tok.is(tok::annot_pragma_openmp)) 606 Ptr = ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, Attrs, TagType, Tag); 607 else if (Tok.isNot(tok::r_brace) && !isEofOrEom()) { 608 // Here we expect to see some function declaration. 609 if (AS == AS_none) { 610 assert(TagType == DeclSpec::TST_unspecified); 611 MaybeParseCXX11Attributes(Attrs); 612 MaybeParseMicrosoftAttributes(Attrs); 613 ParsingDeclSpec PDS(*this); 614 Ptr = ParseExternalDeclaration(Attrs, &PDS); 615 } else { 616 Ptr = 617 ParseCXXClassMemberDeclarationWithPragmas(AS, Attrs, TagType, Tag); 618 } 619 } 620 if (!Ptr) { 621 Diag(Loc, diag::err_omp_decl_in_declare_simd); 622 return DeclGroupPtrTy(); 623 } 624 return ParseOMPDeclareSimdClauses(Ptr, Toks, Loc); 625 } 626 case OMPD_declare_target: { 627 SourceLocation DTLoc = ConsumeAnyToken(); 628 if (Tok.isNot(tok::annot_pragma_openmp_end)) { 629 // OpenMP 4.5 syntax with list of entities. 630 llvm::SmallSetVector<const NamedDecl*, 16> SameDirectiveDecls; 631 while (Tok.isNot(tok::annot_pragma_openmp_end)) { 632 OMPDeclareTargetDeclAttr::MapTypeTy MT = 633 OMPDeclareTargetDeclAttr::MT_To; 634 if (Tok.is(tok::identifier)) { 635 IdentifierInfo *II = Tok.getIdentifierInfo(); 636 StringRef ClauseName = II->getName(); 637 // Parse 'to|link' clauses. 638 if (!OMPDeclareTargetDeclAttr::ConvertStrToMapTypeTy(ClauseName, 639 MT)) { 640 Diag(Tok, diag::err_omp_declare_target_unexpected_clause) 641 << ClauseName; 642 break; 643 } 644 ConsumeToken(); 645 } 646 auto Callback = [this, MT, &SameDirectiveDecls]( 647 CXXScopeSpec &SS, DeclarationNameInfo NameInfo) { 648 Actions.ActOnOpenMPDeclareTargetName(getCurScope(), SS, NameInfo, MT, 649 SameDirectiveDecls); 650 }; 651 if (ParseOpenMPSimpleVarList(OMPD_declare_target, Callback, true)) 652 break; 653 654 // Consume optional ','. 655 if (Tok.is(tok::comma)) 656 ConsumeToken(); 657 } 658 SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch); 659 ConsumeAnyToken(); 660 return DeclGroupPtrTy(); 661 } 662 663 // Skip the last annot_pragma_openmp_end. 664 ConsumeAnyToken(); 665 666 if (!Actions.ActOnStartOpenMPDeclareTargetDirective(DTLoc)) 667 return DeclGroupPtrTy(); 668 669 DKind = ParseOpenMPDirectiveKind(*this); 670 while (DKind != OMPD_end_declare_target && DKind != OMPD_declare_target && 671 Tok.isNot(tok::eof) && Tok.isNot(tok::r_brace)) { 672 ParsedAttributesWithRange attrs(AttrFactory); 673 MaybeParseCXX11Attributes(attrs); 674 MaybeParseMicrosoftAttributes(attrs); 675 ParseExternalDeclaration(attrs); 676 if (Tok.isAnnotation() && Tok.is(tok::annot_pragma_openmp)) { 677 TentativeParsingAction TPA(*this); 678 ConsumeToken(); 679 DKind = ParseOpenMPDirectiveKind(*this); 680 if (DKind != OMPD_end_declare_target) 681 TPA.Revert(); 682 else 683 TPA.Commit(); 684 } 685 } 686 687 if (DKind == OMPD_end_declare_target) { 688 ConsumeAnyToken(); 689 if (Tok.isNot(tok::annot_pragma_openmp_end)) { 690 Diag(Tok, diag::warn_omp_extra_tokens_at_eol) 691 << getOpenMPDirectiveName(OMPD_end_declare_target); 692 SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch); 693 } 694 // Skip the last annot_pragma_openmp_end. 695 ConsumeAnyToken(); 696 } else { 697 Diag(Tok, diag::err_expected_end_declare_target); 698 Diag(DTLoc, diag::note_matching) << "'#pragma omp declare target'"; 699 } 700 Actions.ActOnFinishOpenMPDeclareTargetDirective(); 701 return DeclGroupPtrTy(); 702 } 703 case OMPD_unknown: 704 Diag(Tok, diag::err_omp_unknown_directive); 705 break; 706 case OMPD_parallel: 707 case OMPD_simd: 708 case OMPD_task: 709 case OMPD_taskyield: 710 case OMPD_barrier: 711 case OMPD_taskwait: 712 case OMPD_taskgroup: 713 case OMPD_flush: 714 case OMPD_for: 715 case OMPD_for_simd: 716 case OMPD_sections: 717 case OMPD_section: 718 case OMPD_single: 719 case OMPD_master: 720 case OMPD_ordered: 721 case OMPD_critical: 722 case OMPD_parallel_for: 723 case OMPD_parallel_for_simd: 724 case OMPD_parallel_sections: 725 case OMPD_atomic: 726 case OMPD_target: 727 case OMPD_teams: 728 case OMPD_cancellation_point: 729 case OMPD_cancel: 730 case OMPD_target_data: 731 case OMPD_target_enter_data: 732 case OMPD_target_exit_data: 733 case OMPD_target_parallel: 734 case OMPD_target_parallel_for: 735 case OMPD_taskloop: 736 case OMPD_taskloop_simd: 737 case OMPD_distribute: 738 case OMPD_end_declare_target: 739 case OMPD_target_update: 740 case OMPD_distribute_parallel_for: 741 case OMPD_distribute_parallel_for_simd: 742 case OMPD_distribute_simd: 743 case OMPD_target_parallel_for_simd: 744 Diag(Tok, diag::err_omp_unexpected_directive) 745 << getOpenMPDirectiveName(DKind); 746 break; 747 } 748 while (Tok.isNot(tok::annot_pragma_openmp_end)) 749 ConsumeAnyToken(); 750 ConsumeAnyToken(); 751 return nullptr; 752 } 753 754 /// \brief Parsing of declarative or executable OpenMP directives. 755 /// 756 /// threadprivate-directive: 757 /// annot_pragma_openmp 'threadprivate' simple-variable-list 758 /// annot_pragma_openmp_end 759 /// 760 /// declare-reduction-directive: 761 /// annot_pragma_openmp 'declare' 'reduction' '(' <reduction_id> ':' 762 /// <type> {',' <type>} ':' <expression> ')' ['initializer' '(' 763 /// ('omp_priv' '=' <expression>|<function_call>) ')'] 764 /// annot_pragma_openmp_end 765 /// 766 /// executable-directive: 767 /// annot_pragma_openmp 'parallel' | 'simd' | 'for' | 'sections' | 768 /// 'section' | 'single' | 'master' | 'critical' [ '(' <name> ')' ] | 769 /// 'parallel for' | 'parallel sections' | 'task' | 'taskyield' | 770 /// 'barrier' | 'taskwait' | 'flush' | 'ordered' | 'atomic' | 771 /// 'for simd' | 'parallel for simd' | 'target' | 'target data' | 772 /// 'taskgroup' | 'teams' | 'taskloop' | 'taskloop simd' | 773 /// 'distribute' | 'target enter data' | 'target exit data' | 774 /// 'target parallel' | 'target parallel for' | 775 /// 'target update' | 'distribute parallel for' | 776 /// 'distribute paralle for simd' | 'distribute simd' | 777 /// 'target parallel for simd' {clause} 778 /// annot_pragma_openmp_end 779 /// 780 StmtResult Parser::ParseOpenMPDeclarativeOrExecutableDirective( 781 AllowedContsructsKind Allowed) { 782 assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!"); 783 ParenBraceBracketBalancer BalancerRAIIObj(*this); 784 SmallVector<OMPClause *, 5> Clauses; 785 SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>, OMPC_unknown + 1> 786 FirstClauses(OMPC_unknown + 1); 787 unsigned ScopeFlags = 788 Scope::FnScope | Scope::DeclScope | Scope::OpenMPDirectiveScope; 789 SourceLocation Loc = ConsumeToken(), EndLoc; 790 auto DKind = ParseOpenMPDirectiveKind(*this); 791 OpenMPDirectiveKind CancelRegion = OMPD_unknown; 792 // Name of critical directive. 793 DeclarationNameInfo DirName; 794 StmtResult Directive = StmtError(); 795 bool HasAssociatedStatement = true; 796 bool FlushHasClause = false; 797 798 switch (DKind) { 799 case OMPD_threadprivate: { 800 if (Allowed != ACK_Any) { 801 Diag(Tok, diag::err_omp_immediate_directive) 802 << getOpenMPDirectiveName(DKind) << 0; 803 } 804 ConsumeToken(); 805 ThreadprivateListParserHelper Helper(this); 806 if (!ParseOpenMPSimpleVarList(OMPD_threadprivate, Helper, false)) { 807 // The last seen token is annot_pragma_openmp_end - need to check for 808 // extra tokens. 809 if (Tok.isNot(tok::annot_pragma_openmp_end)) { 810 Diag(Tok, diag::warn_omp_extra_tokens_at_eol) 811 << getOpenMPDirectiveName(OMPD_threadprivate); 812 SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch); 813 } 814 DeclGroupPtrTy Res = Actions.ActOnOpenMPThreadprivateDirective( 815 Loc, Helper.getIdentifiers()); 816 Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation()); 817 } 818 SkipUntil(tok::annot_pragma_openmp_end); 819 break; 820 } 821 case OMPD_declare_reduction: 822 ConsumeToken(); 823 if (auto Res = ParseOpenMPDeclareReductionDirective(/*AS=*/AS_none)) { 824 // The last seen token is annot_pragma_openmp_end - need to check for 825 // extra tokens. 826 if (Tok.isNot(tok::annot_pragma_openmp_end)) { 827 Diag(Tok, diag::warn_omp_extra_tokens_at_eol) 828 << getOpenMPDirectiveName(OMPD_declare_reduction); 829 while (Tok.isNot(tok::annot_pragma_openmp_end)) 830 ConsumeAnyToken(); 831 } 832 ConsumeAnyToken(); 833 Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation()); 834 } else 835 SkipUntil(tok::annot_pragma_openmp_end); 836 break; 837 case OMPD_flush: 838 if (PP.LookAhead(0).is(tok::l_paren)) { 839 FlushHasClause = true; 840 // Push copy of the current token back to stream to properly parse 841 // pseudo-clause OMPFlushClause. 842 PP.EnterToken(Tok); 843 } 844 case OMPD_taskyield: 845 case OMPD_barrier: 846 case OMPD_taskwait: 847 case OMPD_cancellation_point: 848 case OMPD_cancel: 849 case OMPD_target_enter_data: 850 case OMPD_target_exit_data: 851 case OMPD_target_update: 852 if (Allowed == ACK_StatementsOpenMPNonStandalone) { 853 Diag(Tok, diag::err_omp_immediate_directive) 854 << getOpenMPDirectiveName(DKind) << 0; 855 } 856 HasAssociatedStatement = false; 857 // Fall through for further analysis. 858 case OMPD_parallel: 859 case OMPD_simd: 860 case OMPD_for: 861 case OMPD_for_simd: 862 case OMPD_sections: 863 case OMPD_single: 864 case OMPD_section: 865 case OMPD_master: 866 case OMPD_critical: 867 case OMPD_parallel_for: 868 case OMPD_parallel_for_simd: 869 case OMPD_parallel_sections: 870 case OMPD_task: 871 case OMPD_ordered: 872 case OMPD_atomic: 873 case OMPD_target: 874 case OMPD_teams: 875 case OMPD_taskgroup: 876 case OMPD_target_data: 877 case OMPD_target_parallel: 878 case OMPD_target_parallel_for: 879 case OMPD_taskloop: 880 case OMPD_taskloop_simd: 881 case OMPD_distribute: 882 case OMPD_distribute_parallel_for: 883 case OMPD_distribute_parallel_for_simd: 884 case OMPD_distribute_simd: 885 case OMPD_target_parallel_for_simd: { 886 ConsumeToken(); 887 // Parse directive name of the 'critical' directive if any. 888 if (DKind == OMPD_critical) { 889 BalancedDelimiterTracker T(*this, tok::l_paren, 890 tok::annot_pragma_openmp_end); 891 if (!T.consumeOpen()) { 892 if (Tok.isAnyIdentifier()) { 893 DirName = 894 DeclarationNameInfo(Tok.getIdentifierInfo(), Tok.getLocation()); 895 ConsumeAnyToken(); 896 } else { 897 Diag(Tok, diag::err_omp_expected_identifier_for_critical); 898 } 899 T.consumeClose(); 900 } 901 } else if (DKind == OMPD_cancellation_point || DKind == OMPD_cancel) { 902 CancelRegion = ParseOpenMPDirectiveKind(*this); 903 if (Tok.isNot(tok::annot_pragma_openmp_end)) 904 ConsumeToken(); 905 } 906 907 if (isOpenMPLoopDirective(DKind)) 908 ScopeFlags |= Scope::OpenMPLoopDirectiveScope; 909 if (isOpenMPSimdDirective(DKind)) 910 ScopeFlags |= Scope::OpenMPSimdDirectiveScope; 911 ParseScope OMPDirectiveScope(this, ScopeFlags); 912 Actions.StartOpenMPDSABlock(DKind, DirName, Actions.getCurScope(), Loc); 913 914 while (Tok.isNot(tok::annot_pragma_openmp_end)) { 915 OpenMPClauseKind CKind = 916 Tok.isAnnotation() 917 ? OMPC_unknown 918 : FlushHasClause ? OMPC_flush 919 : getOpenMPClauseKind(PP.getSpelling(Tok)); 920 Actions.StartOpenMPClause(CKind); 921 FlushHasClause = false; 922 OMPClause *Clause = 923 ParseOpenMPClause(DKind, CKind, !FirstClauses[CKind].getInt()); 924 FirstClauses[CKind].setInt(true); 925 if (Clause) { 926 FirstClauses[CKind].setPointer(Clause); 927 Clauses.push_back(Clause); 928 } 929 930 // Skip ',' if any. 931 if (Tok.is(tok::comma)) 932 ConsumeToken(); 933 Actions.EndOpenMPClause(); 934 } 935 // End location of the directive. 936 EndLoc = Tok.getLocation(); 937 // Consume final annot_pragma_openmp_end. 938 ConsumeToken(); 939 940 // OpenMP [2.13.8, ordered Construct, Syntax] 941 // If the depend clause is specified, the ordered construct is a stand-alone 942 // directive. 943 if (DKind == OMPD_ordered && FirstClauses[OMPC_depend].getInt()) { 944 if (Allowed == ACK_StatementsOpenMPNonStandalone) { 945 Diag(Loc, diag::err_omp_immediate_directive) 946 << getOpenMPDirectiveName(DKind) << 1 947 << getOpenMPClauseName(OMPC_depend); 948 } 949 HasAssociatedStatement = false; 950 } 951 952 StmtResult AssociatedStmt; 953 if (HasAssociatedStatement) { 954 // The body is a block scope like in Lambdas and Blocks. 955 Sema::CompoundScopeRAII CompoundScope(Actions); 956 Actions.ActOnOpenMPRegionStart(DKind, getCurScope()); 957 Actions.ActOnStartOfCompoundStmt(); 958 // Parse statement 959 AssociatedStmt = ParseStatement(); 960 Actions.ActOnFinishOfCompoundStmt(); 961 AssociatedStmt = Actions.ActOnOpenMPRegionEnd(AssociatedStmt, Clauses); 962 } 963 Directive = Actions.ActOnOpenMPExecutableDirective( 964 DKind, DirName, CancelRegion, Clauses, AssociatedStmt.get(), Loc, 965 EndLoc); 966 967 // Exit scope. 968 Actions.EndOpenMPDSABlock(Directive.get()); 969 OMPDirectiveScope.Exit(); 970 break; 971 } 972 case OMPD_declare_simd: 973 case OMPD_declare_target: 974 case OMPD_end_declare_target: 975 Diag(Tok, diag::err_omp_unexpected_directive) 976 << getOpenMPDirectiveName(DKind); 977 SkipUntil(tok::annot_pragma_openmp_end); 978 break; 979 case OMPD_unknown: 980 Diag(Tok, diag::err_omp_unknown_directive); 981 SkipUntil(tok::annot_pragma_openmp_end); 982 break; 983 } 984 return Directive; 985 } 986 987 // Parses simple list: 988 // simple-variable-list: 989 // '(' id-expression {, id-expression} ')' 990 // 991 bool Parser::ParseOpenMPSimpleVarList( 992 OpenMPDirectiveKind Kind, 993 const llvm::function_ref<void(CXXScopeSpec &, DeclarationNameInfo)> & 994 Callback, 995 bool AllowScopeSpecifier) { 996 // Parse '('. 997 BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); 998 if (T.expectAndConsume(diag::err_expected_lparen_after, 999 getOpenMPDirectiveName(Kind))) 1000 return true; 1001 bool IsCorrect = true; 1002 bool NoIdentIsFound = true; 1003 1004 // Read tokens while ')' or annot_pragma_openmp_end is not found. 1005 while (Tok.isNot(tok::r_paren) && Tok.isNot(tok::annot_pragma_openmp_end)) { 1006 CXXScopeSpec SS; 1007 SourceLocation TemplateKWLoc; 1008 UnqualifiedId Name; 1009 // Read var name. 1010 Token PrevTok = Tok; 1011 NoIdentIsFound = false; 1012 1013 if (AllowScopeSpecifier && getLangOpts().CPlusPlus && 1014 ParseOptionalCXXScopeSpecifier(SS, nullptr, false)) { 1015 IsCorrect = false; 1016 SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end, 1017 StopBeforeMatch); 1018 } else if (ParseUnqualifiedId(SS, false, false, false, nullptr, 1019 TemplateKWLoc, Name)) { 1020 IsCorrect = false; 1021 SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end, 1022 StopBeforeMatch); 1023 } else if (Tok.isNot(tok::comma) && Tok.isNot(tok::r_paren) && 1024 Tok.isNot(tok::annot_pragma_openmp_end)) { 1025 IsCorrect = false; 1026 SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end, 1027 StopBeforeMatch); 1028 Diag(PrevTok.getLocation(), diag::err_expected) 1029 << tok::identifier 1030 << SourceRange(PrevTok.getLocation(), PrevTokLocation); 1031 } else { 1032 Callback(SS, Actions.GetNameFromUnqualifiedId(Name)); 1033 } 1034 // Consume ','. 1035 if (Tok.is(tok::comma)) { 1036 ConsumeToken(); 1037 } 1038 } 1039 1040 if (NoIdentIsFound) { 1041 Diag(Tok, diag::err_expected) << tok::identifier; 1042 IsCorrect = false; 1043 } 1044 1045 // Parse ')'. 1046 IsCorrect = !T.consumeClose() && IsCorrect; 1047 1048 return !IsCorrect; 1049 } 1050 1051 /// \brief Parsing of OpenMP clauses. 1052 /// 1053 /// clause: 1054 /// if-clause | final-clause | num_threads-clause | safelen-clause | 1055 /// default-clause | private-clause | firstprivate-clause | shared-clause 1056 /// | linear-clause | aligned-clause | collapse-clause | 1057 /// lastprivate-clause | reduction-clause | proc_bind-clause | 1058 /// schedule-clause | copyin-clause | copyprivate-clause | untied-clause | 1059 /// mergeable-clause | flush-clause | read-clause | write-clause | 1060 /// update-clause | capture-clause | seq_cst-clause | device-clause | 1061 /// simdlen-clause | threads-clause | simd-clause | num_teams-clause | 1062 /// thread_limit-clause | priority-clause | grainsize-clause | 1063 /// nogroup-clause | num_tasks-clause | hint-clause | to-clause | 1064 /// from-clause | is_device_ptr-clause 1065 /// 1066 OMPClause *Parser::ParseOpenMPClause(OpenMPDirectiveKind DKind, 1067 OpenMPClauseKind CKind, bool FirstClause) { 1068 OMPClause *Clause = nullptr; 1069 bool ErrorFound = false; 1070 // Check if clause is allowed for the given directive. 1071 if (CKind != OMPC_unknown && !isAllowedClauseForDirective(DKind, CKind)) { 1072 Diag(Tok, diag::err_omp_unexpected_clause) << getOpenMPClauseName(CKind) 1073 << getOpenMPDirectiveName(DKind); 1074 ErrorFound = true; 1075 } 1076 1077 switch (CKind) { 1078 case OMPC_final: 1079 case OMPC_num_threads: 1080 case OMPC_safelen: 1081 case OMPC_simdlen: 1082 case OMPC_collapse: 1083 case OMPC_ordered: 1084 case OMPC_device: 1085 case OMPC_num_teams: 1086 case OMPC_thread_limit: 1087 case OMPC_priority: 1088 case OMPC_grainsize: 1089 case OMPC_num_tasks: 1090 case OMPC_hint: 1091 // OpenMP [2.5, Restrictions] 1092 // At most one num_threads clause can appear on the directive. 1093 // OpenMP [2.8.1, simd construct, Restrictions] 1094 // Only one safelen clause can appear on a simd directive. 1095 // Only one simdlen clause can appear on a simd directive. 1096 // Only one collapse clause can appear on a simd directive. 1097 // OpenMP [2.9.1, target data construct, Restrictions] 1098 // At most one device clause can appear on the directive. 1099 // OpenMP [2.11.1, task Construct, Restrictions] 1100 // At most one if clause can appear on the directive. 1101 // At most one final clause can appear on the directive. 1102 // OpenMP [teams Construct, Restrictions] 1103 // At most one num_teams clause can appear on the directive. 1104 // At most one thread_limit clause can appear on the directive. 1105 // OpenMP [2.9.1, task Construct, Restrictions] 1106 // At most one priority clause can appear on the directive. 1107 // OpenMP [2.9.2, taskloop Construct, Restrictions] 1108 // At most one grainsize clause can appear on the directive. 1109 // OpenMP [2.9.2, taskloop Construct, Restrictions] 1110 // At most one num_tasks clause can appear on the directive. 1111 if (!FirstClause) { 1112 Diag(Tok, diag::err_omp_more_one_clause) 1113 << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0; 1114 ErrorFound = true; 1115 } 1116 1117 if (CKind == OMPC_ordered && PP.LookAhead(/*N=*/0).isNot(tok::l_paren)) 1118 Clause = ParseOpenMPClause(CKind); 1119 else 1120 Clause = ParseOpenMPSingleExprClause(CKind); 1121 break; 1122 case OMPC_default: 1123 case OMPC_proc_bind: 1124 // OpenMP [2.14.3.1, Restrictions] 1125 // Only a single default clause may be specified on a parallel, task or 1126 // teams directive. 1127 // OpenMP [2.5, parallel Construct, Restrictions] 1128 // At most one proc_bind clause can appear on the directive. 1129 if (!FirstClause) { 1130 Diag(Tok, diag::err_omp_more_one_clause) 1131 << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0; 1132 ErrorFound = true; 1133 } 1134 1135 Clause = ParseOpenMPSimpleClause(CKind); 1136 break; 1137 case OMPC_schedule: 1138 case OMPC_dist_schedule: 1139 case OMPC_defaultmap: 1140 // OpenMP [2.7.1, Restrictions, p. 3] 1141 // Only one schedule clause can appear on a loop directive. 1142 // OpenMP [2.10.4, Restrictions, p. 106] 1143 // At most one defaultmap clause can appear on the directive. 1144 if (!FirstClause) { 1145 Diag(Tok, diag::err_omp_more_one_clause) 1146 << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0; 1147 ErrorFound = true; 1148 } 1149 1150 case OMPC_if: 1151 Clause = ParseOpenMPSingleExprWithArgClause(CKind); 1152 break; 1153 case OMPC_nowait: 1154 case OMPC_untied: 1155 case OMPC_mergeable: 1156 case OMPC_read: 1157 case OMPC_write: 1158 case OMPC_update: 1159 case OMPC_capture: 1160 case OMPC_seq_cst: 1161 case OMPC_threads: 1162 case OMPC_simd: 1163 case OMPC_nogroup: 1164 // OpenMP [2.7.1, Restrictions, p. 9] 1165 // Only one ordered clause can appear on a loop directive. 1166 // OpenMP [2.7.1, Restrictions, C/C++, p. 4] 1167 // Only one nowait clause can appear on a for directive. 1168 if (!FirstClause) { 1169 Diag(Tok, diag::err_omp_more_one_clause) 1170 << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0; 1171 ErrorFound = true; 1172 } 1173 1174 Clause = ParseOpenMPClause(CKind); 1175 break; 1176 case OMPC_private: 1177 case OMPC_firstprivate: 1178 case OMPC_lastprivate: 1179 case OMPC_shared: 1180 case OMPC_reduction: 1181 case OMPC_linear: 1182 case OMPC_aligned: 1183 case OMPC_copyin: 1184 case OMPC_copyprivate: 1185 case OMPC_flush: 1186 case OMPC_depend: 1187 case OMPC_map: 1188 case OMPC_to: 1189 case OMPC_from: 1190 case OMPC_use_device_ptr: 1191 case OMPC_is_device_ptr: 1192 Clause = ParseOpenMPVarListClause(DKind, CKind); 1193 break; 1194 case OMPC_unknown: 1195 Diag(Tok, diag::warn_omp_extra_tokens_at_eol) 1196 << getOpenMPDirectiveName(DKind); 1197 SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch); 1198 break; 1199 case OMPC_threadprivate: 1200 case OMPC_uniform: 1201 Diag(Tok, diag::err_omp_unexpected_clause) << getOpenMPClauseName(CKind) 1202 << getOpenMPDirectiveName(DKind); 1203 SkipUntil(tok::comma, tok::annot_pragma_openmp_end, StopBeforeMatch); 1204 break; 1205 } 1206 return ErrorFound ? nullptr : Clause; 1207 } 1208 1209 /// Parses simple expression in parens for single-expression clauses of OpenMP 1210 /// constructs. 1211 /// \param RLoc Returned location of right paren. 1212 ExprResult Parser::ParseOpenMPParensExpr(StringRef ClauseName, 1213 SourceLocation &RLoc) { 1214 BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); 1215 if (T.expectAndConsume(diag::err_expected_lparen_after, ClauseName.data())) 1216 return ExprError(); 1217 1218 SourceLocation ELoc = Tok.getLocation(); 1219 ExprResult LHS(ParseCastExpression( 1220 /*isUnaryExpression=*/false, /*isAddressOfOperand=*/false, NotTypeCast)); 1221 ExprResult Val(ParseRHSOfBinaryExpression(LHS, prec::Conditional)); 1222 Val = Actions.ActOnFinishFullExpr(Val.get(), ELoc); 1223 1224 // Parse ')'. 1225 T.consumeClose(); 1226 1227 RLoc = T.getCloseLocation(); 1228 return Val; 1229 } 1230 1231 /// \brief Parsing of OpenMP clauses with single expressions like 'final', 1232 /// 'collapse', 'safelen', 'num_threads', 'simdlen', 'num_teams', 1233 /// 'thread_limit', 'simdlen', 'priority', 'grainsize', 'num_tasks' or 'hint'. 1234 /// 1235 /// final-clause: 1236 /// 'final' '(' expression ')' 1237 /// 1238 /// num_threads-clause: 1239 /// 'num_threads' '(' expression ')' 1240 /// 1241 /// safelen-clause: 1242 /// 'safelen' '(' expression ')' 1243 /// 1244 /// simdlen-clause: 1245 /// 'simdlen' '(' expression ')' 1246 /// 1247 /// collapse-clause: 1248 /// 'collapse' '(' expression ')' 1249 /// 1250 /// priority-clause: 1251 /// 'priority' '(' expression ')' 1252 /// 1253 /// grainsize-clause: 1254 /// 'grainsize' '(' expression ')' 1255 /// 1256 /// num_tasks-clause: 1257 /// 'num_tasks' '(' expression ')' 1258 /// 1259 /// hint-clause: 1260 /// 'hint' '(' expression ')' 1261 /// 1262 OMPClause *Parser::ParseOpenMPSingleExprClause(OpenMPClauseKind Kind) { 1263 SourceLocation Loc = ConsumeToken(); 1264 SourceLocation LLoc = Tok.getLocation(); 1265 SourceLocation RLoc; 1266 1267 ExprResult Val = ParseOpenMPParensExpr(getOpenMPClauseName(Kind), RLoc); 1268 1269 if (Val.isInvalid()) 1270 return nullptr; 1271 1272 return Actions.ActOnOpenMPSingleExprClause(Kind, Val.get(), Loc, LLoc, RLoc); 1273 } 1274 1275 /// \brief Parsing of simple OpenMP clauses like 'default' or 'proc_bind'. 1276 /// 1277 /// default-clause: 1278 /// 'default' '(' 'none' | 'shared' ') 1279 /// 1280 /// proc_bind-clause: 1281 /// 'proc_bind' '(' 'master' | 'close' | 'spread' ') 1282 /// 1283 OMPClause *Parser::ParseOpenMPSimpleClause(OpenMPClauseKind Kind) { 1284 SourceLocation Loc = Tok.getLocation(); 1285 SourceLocation LOpen = ConsumeToken(); 1286 // Parse '('. 1287 BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); 1288 if (T.expectAndConsume(diag::err_expected_lparen_after, 1289 getOpenMPClauseName(Kind))) 1290 return nullptr; 1291 1292 unsigned Type = getOpenMPSimpleClauseType( 1293 Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok)); 1294 SourceLocation TypeLoc = Tok.getLocation(); 1295 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) && 1296 Tok.isNot(tok::annot_pragma_openmp_end)) 1297 ConsumeAnyToken(); 1298 1299 // Parse ')'. 1300 T.consumeClose(); 1301 1302 return Actions.ActOnOpenMPSimpleClause(Kind, Type, TypeLoc, LOpen, Loc, 1303 Tok.getLocation()); 1304 } 1305 1306 /// \brief Parsing of OpenMP clauses like 'ordered'. 1307 /// 1308 /// ordered-clause: 1309 /// 'ordered' 1310 /// 1311 /// nowait-clause: 1312 /// 'nowait' 1313 /// 1314 /// untied-clause: 1315 /// 'untied' 1316 /// 1317 /// mergeable-clause: 1318 /// 'mergeable' 1319 /// 1320 /// read-clause: 1321 /// 'read' 1322 /// 1323 /// threads-clause: 1324 /// 'threads' 1325 /// 1326 /// simd-clause: 1327 /// 'simd' 1328 /// 1329 /// nogroup-clause: 1330 /// 'nogroup' 1331 /// 1332 OMPClause *Parser::ParseOpenMPClause(OpenMPClauseKind Kind) { 1333 SourceLocation Loc = Tok.getLocation(); 1334 ConsumeAnyToken(); 1335 1336 return Actions.ActOnOpenMPClause(Kind, Loc, Tok.getLocation()); 1337 } 1338 1339 1340 /// \brief Parsing of OpenMP clauses with single expressions and some additional 1341 /// argument like 'schedule' or 'dist_schedule'. 1342 /// 1343 /// schedule-clause: 1344 /// 'schedule' '(' [ modifier [ ',' modifier ] ':' ] kind [',' expression ] 1345 /// ')' 1346 /// 1347 /// if-clause: 1348 /// 'if' '(' [ directive-name-modifier ':' ] expression ')' 1349 /// 1350 /// defaultmap: 1351 /// 'defaultmap' '(' modifier ':' kind ')' 1352 /// 1353 OMPClause *Parser::ParseOpenMPSingleExprWithArgClause(OpenMPClauseKind Kind) { 1354 SourceLocation Loc = ConsumeToken(); 1355 SourceLocation DelimLoc; 1356 // Parse '('. 1357 BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); 1358 if (T.expectAndConsume(diag::err_expected_lparen_after, 1359 getOpenMPClauseName(Kind))) 1360 return nullptr; 1361 1362 ExprResult Val; 1363 SmallVector<unsigned, 4> Arg; 1364 SmallVector<SourceLocation, 4> KLoc; 1365 if (Kind == OMPC_schedule) { 1366 enum { Modifier1, Modifier2, ScheduleKind, NumberOfElements }; 1367 Arg.resize(NumberOfElements); 1368 KLoc.resize(NumberOfElements); 1369 Arg[Modifier1] = OMPC_SCHEDULE_MODIFIER_unknown; 1370 Arg[Modifier2] = OMPC_SCHEDULE_MODIFIER_unknown; 1371 Arg[ScheduleKind] = OMPC_SCHEDULE_unknown; 1372 auto KindModifier = getOpenMPSimpleClauseType( 1373 Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok)); 1374 if (KindModifier > OMPC_SCHEDULE_unknown) { 1375 // Parse 'modifier' 1376 Arg[Modifier1] = KindModifier; 1377 KLoc[Modifier1] = Tok.getLocation(); 1378 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) && 1379 Tok.isNot(tok::annot_pragma_openmp_end)) 1380 ConsumeAnyToken(); 1381 if (Tok.is(tok::comma)) { 1382 // Parse ',' 'modifier' 1383 ConsumeAnyToken(); 1384 KindModifier = getOpenMPSimpleClauseType( 1385 Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok)); 1386 Arg[Modifier2] = KindModifier > OMPC_SCHEDULE_unknown 1387 ? KindModifier 1388 : (unsigned)OMPC_SCHEDULE_unknown; 1389 KLoc[Modifier2] = Tok.getLocation(); 1390 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) && 1391 Tok.isNot(tok::annot_pragma_openmp_end)) 1392 ConsumeAnyToken(); 1393 } 1394 // Parse ':' 1395 if (Tok.is(tok::colon)) 1396 ConsumeAnyToken(); 1397 else 1398 Diag(Tok, diag::warn_pragma_expected_colon) << "schedule modifier"; 1399 KindModifier = getOpenMPSimpleClauseType( 1400 Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok)); 1401 } 1402 Arg[ScheduleKind] = KindModifier; 1403 KLoc[ScheduleKind] = Tok.getLocation(); 1404 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) && 1405 Tok.isNot(tok::annot_pragma_openmp_end)) 1406 ConsumeAnyToken(); 1407 if ((Arg[ScheduleKind] == OMPC_SCHEDULE_static || 1408 Arg[ScheduleKind] == OMPC_SCHEDULE_dynamic || 1409 Arg[ScheduleKind] == OMPC_SCHEDULE_guided) && 1410 Tok.is(tok::comma)) 1411 DelimLoc = ConsumeAnyToken(); 1412 } else if (Kind == OMPC_dist_schedule) { 1413 Arg.push_back(getOpenMPSimpleClauseType( 1414 Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok))); 1415 KLoc.push_back(Tok.getLocation()); 1416 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) && 1417 Tok.isNot(tok::annot_pragma_openmp_end)) 1418 ConsumeAnyToken(); 1419 if (Arg.back() == OMPC_DIST_SCHEDULE_static && Tok.is(tok::comma)) 1420 DelimLoc = ConsumeAnyToken(); 1421 } else if (Kind == OMPC_defaultmap) { 1422 // Get a defaultmap modifier 1423 Arg.push_back(getOpenMPSimpleClauseType( 1424 Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok))); 1425 KLoc.push_back(Tok.getLocation()); 1426 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) && 1427 Tok.isNot(tok::annot_pragma_openmp_end)) 1428 ConsumeAnyToken(); 1429 // Parse ':' 1430 if (Tok.is(tok::colon)) 1431 ConsumeAnyToken(); 1432 else if (Arg.back() != OMPC_DEFAULTMAP_MODIFIER_unknown) 1433 Diag(Tok, diag::warn_pragma_expected_colon) << "defaultmap modifier"; 1434 // Get a defaultmap kind 1435 Arg.push_back(getOpenMPSimpleClauseType( 1436 Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok))); 1437 KLoc.push_back(Tok.getLocation()); 1438 if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) && 1439 Tok.isNot(tok::annot_pragma_openmp_end)) 1440 ConsumeAnyToken(); 1441 } else { 1442 assert(Kind == OMPC_if); 1443 KLoc.push_back(Tok.getLocation()); 1444 Arg.push_back(ParseOpenMPDirectiveKind(*this)); 1445 if (Arg.back() != OMPD_unknown) { 1446 ConsumeToken(); 1447 if (Tok.is(tok::colon)) 1448 DelimLoc = ConsumeToken(); 1449 else 1450 Diag(Tok, diag::warn_pragma_expected_colon) 1451 << "directive name modifier"; 1452 } 1453 } 1454 1455 bool NeedAnExpression = (Kind == OMPC_schedule && DelimLoc.isValid()) || 1456 (Kind == OMPC_dist_schedule && DelimLoc.isValid()) || 1457 Kind == OMPC_if; 1458 if (NeedAnExpression) { 1459 SourceLocation ELoc = Tok.getLocation(); 1460 ExprResult LHS(ParseCastExpression(false, false, NotTypeCast)); 1461 Val = ParseRHSOfBinaryExpression(LHS, prec::Conditional); 1462 Val = Actions.ActOnFinishFullExpr(Val.get(), ELoc); 1463 } 1464 1465 // Parse ')'. 1466 T.consumeClose(); 1467 1468 if (NeedAnExpression && Val.isInvalid()) 1469 return nullptr; 1470 1471 return Actions.ActOnOpenMPSingleExprWithArgClause( 1472 Kind, Arg, Val.get(), Loc, T.getOpenLocation(), KLoc, DelimLoc, 1473 T.getCloseLocation()); 1474 } 1475 1476 static bool ParseReductionId(Parser &P, CXXScopeSpec &ReductionIdScopeSpec, 1477 UnqualifiedId &ReductionId) { 1478 SourceLocation TemplateKWLoc; 1479 if (ReductionIdScopeSpec.isEmpty()) { 1480 auto OOK = OO_None; 1481 switch (P.getCurToken().getKind()) { 1482 case tok::plus: 1483 OOK = OO_Plus; 1484 break; 1485 case tok::minus: 1486 OOK = OO_Minus; 1487 break; 1488 case tok::star: 1489 OOK = OO_Star; 1490 break; 1491 case tok::amp: 1492 OOK = OO_Amp; 1493 break; 1494 case tok::pipe: 1495 OOK = OO_Pipe; 1496 break; 1497 case tok::caret: 1498 OOK = OO_Caret; 1499 break; 1500 case tok::ampamp: 1501 OOK = OO_AmpAmp; 1502 break; 1503 case tok::pipepipe: 1504 OOK = OO_PipePipe; 1505 break; 1506 default: 1507 break; 1508 } 1509 if (OOK != OO_None) { 1510 SourceLocation OpLoc = P.ConsumeToken(); 1511 SourceLocation SymbolLocations[] = {OpLoc, OpLoc, SourceLocation()}; 1512 ReductionId.setOperatorFunctionId(OpLoc, OOK, SymbolLocations); 1513 return false; 1514 } 1515 } 1516 return P.ParseUnqualifiedId(ReductionIdScopeSpec, /*EnteringContext*/ false, 1517 /*AllowDestructorName*/ false, 1518 /*AllowConstructorName*/ false, nullptr, 1519 TemplateKWLoc, ReductionId); 1520 } 1521 1522 /// Parses clauses with list. 1523 bool Parser::ParseOpenMPVarList(OpenMPDirectiveKind DKind, 1524 OpenMPClauseKind Kind, 1525 SmallVectorImpl<Expr *> &Vars, 1526 OpenMPVarListDataTy &Data) { 1527 UnqualifiedId UnqualifiedReductionId; 1528 bool InvalidReductionId = false; 1529 bool MapTypeModifierSpecified = false; 1530 1531 // Parse '('. 1532 BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end); 1533 if (T.expectAndConsume(diag::err_expected_lparen_after, 1534 getOpenMPClauseName(Kind))) 1535 return true; 1536 1537 bool NeedRParenForLinear = false; 1538 BalancedDelimiterTracker LinearT(*this, tok::l_paren, 1539 tok::annot_pragma_openmp_end); 1540 // Handle reduction-identifier for reduction clause. 1541 if (Kind == OMPC_reduction) { 1542 ColonProtectionRAIIObject ColonRAII(*this); 1543 if (getLangOpts().CPlusPlus) 1544 ParseOptionalCXXScopeSpecifier(Data.ReductionIdScopeSpec, 1545 /*ObjectType=*/nullptr, 1546 /*EnteringContext=*/false); 1547 InvalidReductionId = ParseReductionId(*this, Data.ReductionIdScopeSpec, 1548 UnqualifiedReductionId); 1549 if (InvalidReductionId) { 1550 SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end, 1551 StopBeforeMatch); 1552 } 1553 if (Tok.is(tok::colon)) 1554 Data.ColonLoc = ConsumeToken(); 1555 else 1556 Diag(Tok, diag::warn_pragma_expected_colon) << "reduction identifier"; 1557 if (!InvalidReductionId) 1558 Data.ReductionId = 1559 Actions.GetNameFromUnqualifiedId(UnqualifiedReductionId); 1560 } else if (Kind == OMPC_depend) { 1561 // Handle dependency type for depend clause. 1562 ColonProtectionRAIIObject ColonRAII(*this); 1563 Data.DepKind = 1564 static_cast<OpenMPDependClauseKind>(getOpenMPSimpleClauseType( 1565 Kind, Tok.is(tok::identifier) ? PP.getSpelling(Tok) : "")); 1566 Data.DepLinMapLoc = Tok.getLocation(); 1567 1568 if (Data.DepKind == OMPC_DEPEND_unknown) { 1569 SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end, 1570 StopBeforeMatch); 1571 } else { 1572 ConsumeToken(); 1573 // Special processing for depend(source) clause. 1574 if (DKind == OMPD_ordered && Data.DepKind == OMPC_DEPEND_source) { 1575 // Parse ')'. 1576 T.consumeClose(); 1577 return false; 1578 } 1579 } 1580 if (Tok.is(tok::colon)) 1581 Data.ColonLoc = ConsumeToken(); 1582 else { 1583 Diag(Tok, DKind == OMPD_ordered ? diag::warn_pragma_expected_colon_r_paren 1584 : diag::warn_pragma_expected_colon) 1585 << "dependency type"; 1586 } 1587 } else if (Kind == OMPC_linear) { 1588 // Try to parse modifier if any. 1589 if (Tok.is(tok::identifier) && PP.LookAhead(0).is(tok::l_paren)) { 1590 Data.LinKind = static_cast<OpenMPLinearClauseKind>( 1591 getOpenMPSimpleClauseType(Kind, PP.getSpelling(Tok))); 1592 Data.DepLinMapLoc = ConsumeToken(); 1593 LinearT.consumeOpen(); 1594 NeedRParenForLinear = true; 1595 } 1596 } else if (Kind == OMPC_map) { 1597 // Handle map type for map clause. 1598 ColonProtectionRAIIObject ColonRAII(*this); 1599 1600 /// The map clause modifier token can be either a identifier or the C++ 1601 /// delete keyword. 1602 auto &&IsMapClauseModifierToken = [](const Token &Tok) -> bool { 1603 return Tok.isOneOf(tok::identifier, tok::kw_delete); 1604 }; 1605 1606 // The first identifier may be a list item, a map-type or a 1607 // map-type-modifier. The map modifier can also be delete which has the same 1608 // spelling of the C++ delete keyword. 1609 Data.MapType = 1610 IsMapClauseModifierToken(Tok) 1611 ? static_cast<OpenMPMapClauseKind>( 1612 getOpenMPSimpleClauseType(Kind, PP.getSpelling(Tok))) 1613 : OMPC_MAP_unknown; 1614 Data.DepLinMapLoc = Tok.getLocation(); 1615 bool ColonExpected = false; 1616 1617 if (IsMapClauseModifierToken(Tok)) { 1618 if (PP.LookAhead(0).is(tok::colon)) { 1619 if (Data.MapType == OMPC_MAP_unknown) 1620 Diag(Tok, diag::err_omp_unknown_map_type); 1621 else if (Data.MapType == OMPC_MAP_always) 1622 Diag(Tok, diag::err_omp_map_type_missing); 1623 ConsumeToken(); 1624 } else if (PP.LookAhead(0).is(tok::comma)) { 1625 if (IsMapClauseModifierToken(PP.LookAhead(1)) && 1626 PP.LookAhead(2).is(tok::colon)) { 1627 Data.MapTypeModifier = Data.MapType; 1628 if (Data.MapTypeModifier != OMPC_MAP_always) { 1629 Diag(Tok, diag::err_omp_unknown_map_type_modifier); 1630 Data.MapTypeModifier = OMPC_MAP_unknown; 1631 } else 1632 MapTypeModifierSpecified = true; 1633 1634 ConsumeToken(); 1635 ConsumeToken(); 1636 1637 Data.MapType = 1638 IsMapClauseModifierToken(Tok) 1639 ? static_cast<OpenMPMapClauseKind>( 1640 getOpenMPSimpleClauseType(Kind, PP.getSpelling(Tok))) 1641 : OMPC_MAP_unknown; 1642 if (Data.MapType == OMPC_MAP_unknown || 1643 Data.MapType == OMPC_MAP_always) 1644 Diag(Tok, diag::err_omp_unknown_map_type); 1645 ConsumeToken(); 1646 } else { 1647 Data.MapType = OMPC_MAP_tofrom; 1648 Data.IsMapTypeImplicit = true; 1649 } 1650 } else { 1651 Data.MapType = OMPC_MAP_tofrom; 1652 Data.IsMapTypeImplicit = true; 1653 } 1654 } else { 1655 Data.MapType = OMPC_MAP_tofrom; 1656 Data.IsMapTypeImplicit = true; 1657 } 1658 1659 if (Tok.is(tok::colon)) 1660 Data.ColonLoc = ConsumeToken(); 1661 else if (ColonExpected) 1662 Diag(Tok, diag::warn_pragma_expected_colon) << "map type"; 1663 } 1664 1665 bool IsComma = 1666 (Kind != OMPC_reduction && Kind != OMPC_depend && Kind != OMPC_map) || 1667 (Kind == OMPC_reduction && !InvalidReductionId) || 1668 (Kind == OMPC_map && Data.MapType != OMPC_MAP_unknown && 1669 (!MapTypeModifierSpecified || 1670 Data.MapTypeModifier == OMPC_MAP_always)) || 1671 (Kind == OMPC_depend && Data.DepKind != OMPC_DEPEND_unknown); 1672 const bool MayHaveTail = (Kind == OMPC_linear || Kind == OMPC_aligned); 1673 while (IsComma || (Tok.isNot(tok::r_paren) && Tok.isNot(tok::colon) && 1674 Tok.isNot(tok::annot_pragma_openmp_end))) { 1675 ColonProtectionRAIIObject ColonRAII(*this, MayHaveTail); 1676 // Parse variable 1677 ExprResult VarExpr = 1678 Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression()); 1679 if (VarExpr.isUsable()) 1680 Vars.push_back(VarExpr.get()); 1681 else { 1682 SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end, 1683 StopBeforeMatch); 1684 } 1685 // Skip ',' if any 1686 IsComma = Tok.is(tok::comma); 1687 if (IsComma) 1688 ConsumeToken(); 1689 else if (Tok.isNot(tok::r_paren) && 1690 Tok.isNot(tok::annot_pragma_openmp_end) && 1691 (!MayHaveTail || Tok.isNot(tok::colon))) 1692 Diag(Tok, diag::err_omp_expected_punc) 1693 << ((Kind == OMPC_flush) ? getOpenMPDirectiveName(OMPD_flush) 1694 : getOpenMPClauseName(Kind)) 1695 << (Kind == OMPC_flush); 1696 } 1697 1698 // Parse ')' for linear clause with modifier. 1699 if (NeedRParenForLinear) 1700 LinearT.consumeClose(); 1701 1702 // Parse ':' linear-step (or ':' alignment). 1703 const bool MustHaveTail = MayHaveTail && Tok.is(tok::colon); 1704 if (MustHaveTail) { 1705 Data.ColonLoc = Tok.getLocation(); 1706 SourceLocation ELoc = ConsumeToken(); 1707 ExprResult Tail = ParseAssignmentExpression(); 1708 Tail = Actions.ActOnFinishFullExpr(Tail.get(), ELoc); 1709 if (Tail.isUsable()) 1710 Data.TailExpr = Tail.get(); 1711 else 1712 SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end, 1713 StopBeforeMatch); 1714 } 1715 1716 // Parse ')'. 1717 T.consumeClose(); 1718 if ((Kind == OMPC_depend && Data.DepKind != OMPC_DEPEND_unknown && 1719 Vars.empty()) || 1720 (Kind != OMPC_depend && Kind != OMPC_map && Vars.empty()) || 1721 (MustHaveTail && !Data.TailExpr) || InvalidReductionId) 1722 return true; 1723 return false; 1724 } 1725 1726 /// \brief Parsing of OpenMP clause 'private', 'firstprivate', 'lastprivate', 1727 /// 'shared', 'copyin', 'copyprivate', 'flush' or 'reduction'. 1728 /// 1729 /// private-clause: 1730 /// 'private' '(' list ')' 1731 /// firstprivate-clause: 1732 /// 'firstprivate' '(' list ')' 1733 /// lastprivate-clause: 1734 /// 'lastprivate' '(' list ')' 1735 /// shared-clause: 1736 /// 'shared' '(' list ')' 1737 /// linear-clause: 1738 /// 'linear' '(' linear-list [ ':' linear-step ] ')' 1739 /// aligned-clause: 1740 /// 'aligned' '(' list [ ':' alignment ] ')' 1741 /// reduction-clause: 1742 /// 'reduction' '(' reduction-identifier ':' list ')' 1743 /// copyprivate-clause: 1744 /// 'copyprivate' '(' list ')' 1745 /// flush-clause: 1746 /// 'flush' '(' list ')' 1747 /// depend-clause: 1748 /// 'depend' '(' in | out | inout : list | source ')' 1749 /// map-clause: 1750 /// 'map' '(' [ [ always , ] 1751 /// to | from | tofrom | alloc | release | delete ':' ] list ')'; 1752 /// to-clause: 1753 /// 'to' '(' list ')' 1754 /// from-clause: 1755 /// 'from' '(' list ')' 1756 /// use_device_ptr-clause: 1757 /// 'use_device_ptr' '(' list ')' 1758 /// is_device_ptr-clause: 1759 /// 'is_device_ptr' '(' list ')' 1760 /// 1761 /// For 'linear' clause linear-list may have the following forms: 1762 /// list 1763 /// modifier(list) 1764 /// where modifier is 'val' (C) or 'ref', 'val' or 'uval'(C++). 1765 OMPClause *Parser::ParseOpenMPVarListClause(OpenMPDirectiveKind DKind, 1766 OpenMPClauseKind Kind) { 1767 SourceLocation Loc = Tok.getLocation(); 1768 SourceLocation LOpen = ConsumeToken(); 1769 SmallVector<Expr *, 4> Vars; 1770 OpenMPVarListDataTy Data; 1771 1772 if (ParseOpenMPVarList(DKind, Kind, Vars, Data)) 1773 return nullptr; 1774 1775 return Actions.ActOnOpenMPVarListClause( 1776 Kind, Vars, Data.TailExpr, Loc, LOpen, Data.ColonLoc, Tok.getLocation(), 1777 Data.ReductionIdScopeSpec, Data.ReductionId, Data.DepKind, Data.LinKind, 1778 Data.MapTypeModifier, Data.MapType, Data.IsMapTypeImplicit, 1779 Data.DepLinMapLoc); 1780 } 1781 1782
