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