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