1 //===--- ParseOpenMP.cpp - OpenMP directives parsing ----------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 /// \file
10 /// \brief This file implements parsing of all OpenMP directives and clauses.
11 ///
12 //===----------------------------------------------------------------------===//
13 
14 #include "RAIIObjectsForParser.h"
15 #include "clang/AST/ASTConsumer.h"
16 #include "clang/AST/ASTContext.h"
17 #include "clang/AST/StmtOpenMP.h"
18 #include "clang/Parse/ParseDiagnostic.h"
19 #include "clang/Parse/Parser.h"
20 #include "clang/Sema/Scope.h"
21 #include "llvm/ADT/PointerIntPair.h"
22 using namespace clang;
23 
24 //===----------------------------------------------------------------------===//
25 // OpenMP declarative directives.
26 //===----------------------------------------------------------------------===//
27 
28 static OpenMPDirectiveKind ParseOpenMPDirectiveKind(Parser &P) {
29   // Array of foldings: F[i][0] F[i][1] ===> F[i][2].
30   // E.g.: OMPD_for OMPD_simd ===> OMPD_for_simd
31   // TODO: add other combined directives in topological order.
32   const OpenMPDirectiveKind F[][3] = {
33       {OMPD_unknown /*cancellation*/, OMPD_unknown /*point*/,
34        OMPD_cancellation_point},
35       {OMPD_for, OMPD_simd, OMPD_for_simd},
36       {OMPD_parallel, OMPD_for, OMPD_parallel_for},
37       {OMPD_parallel_for, OMPD_simd, OMPD_parallel_for_simd},
38       {OMPD_parallel, OMPD_sections, OMPD_parallel_sections}};
39   auto Tok = P.getCurToken();
40   auto DKind =
41       Tok.isAnnotation()
42           ? OMPD_unknown
43           : getOpenMPDirectiveKind(P.getPreprocessor().getSpelling(Tok));
44   bool TokenMatched = false;
45   for (unsigned i = 0; i < llvm::array_lengthof(F); ++i) {
46     if (!Tok.isAnnotation() && DKind == OMPD_unknown) {
47       TokenMatched =
48           (i == 0) &&
49           !P.getPreprocessor().getSpelling(Tok).compare("cancellation");
50     } else {
51       TokenMatched = DKind == F[i][0] && DKind != OMPD_unknown;
52     }
53     if (TokenMatched) {
54       Tok = P.getPreprocessor().LookAhead(0);
55       auto SDKind =
56           Tok.isAnnotation()
57               ? OMPD_unknown
58               : getOpenMPDirectiveKind(P.getPreprocessor().getSpelling(Tok));
59       if (!Tok.isAnnotation() && DKind == OMPD_unknown) {
60         TokenMatched =
61             (i == 0) && !P.getPreprocessor().getSpelling(Tok).compare("point");
62       } else {
63         TokenMatched = SDKind == F[i][1] && SDKind != OMPD_unknown;
64       }
65       if (TokenMatched) {
66         P.ConsumeToken();
67         DKind = F[i][2];
68       }
69     }
70   }
71   return DKind;
72 }
73 
74 /// \brief Parsing of declarative OpenMP directives.
75 ///
76 ///       threadprivate-directive:
77 ///         annot_pragma_openmp 'threadprivate' simple-variable-list
78 ///
79 Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirective() {
80   assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!");
81   ParenBraceBracketBalancer BalancerRAIIObj(*this);
82 
83   SourceLocation Loc = ConsumeToken();
84   SmallVector<Expr *, 5> Identifiers;
85   auto DKind = ParseOpenMPDirectiveKind(*this);
86 
87   switch (DKind) {
88   case OMPD_threadprivate:
89     ConsumeToken();
90     if (!ParseOpenMPSimpleVarList(OMPD_threadprivate, Identifiers, true)) {
91       // The last seen token is annot_pragma_openmp_end - need to check for
92       // extra tokens.
93       if (Tok.isNot(tok::annot_pragma_openmp_end)) {
94         Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
95             << getOpenMPDirectiveName(OMPD_threadprivate);
96         SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
97       }
98       // Skip the last annot_pragma_openmp_end.
99       ConsumeToken();
100       return Actions.ActOnOpenMPThreadprivateDirective(Loc, Identifiers);
101     }
102     break;
103   case OMPD_unknown:
104     Diag(Tok, diag::err_omp_unknown_directive);
105     break;
106   case OMPD_parallel:
107   case OMPD_simd:
108   case OMPD_task:
109   case OMPD_taskyield:
110   case OMPD_barrier:
111   case OMPD_taskwait:
112   case OMPD_taskgroup:
113   case OMPD_flush:
114   case OMPD_for:
115   case OMPD_for_simd:
116   case OMPD_sections:
117   case OMPD_section:
118   case OMPD_single:
119   case OMPD_master:
120   case OMPD_ordered:
121   case OMPD_critical:
122   case OMPD_parallel_for:
123   case OMPD_parallel_for_simd:
124   case OMPD_parallel_sections:
125   case OMPD_atomic:
126   case OMPD_target:
127   case OMPD_teams:
128   case OMPD_cancellation_point:
129   case OMPD_cancel:
130     Diag(Tok, diag::err_omp_unexpected_directive)
131         << getOpenMPDirectiveName(DKind);
132     break;
133   }
134   SkipUntil(tok::annot_pragma_openmp_end);
135   return DeclGroupPtrTy();
136 }
137 
138 /// \brief Parsing of declarative or executable OpenMP directives.
139 ///
140 ///       threadprivate-directive:
141 ///         annot_pragma_openmp 'threadprivate' simple-variable-list
142 ///         annot_pragma_openmp_end
143 ///
144 ///       executable-directive:
145 ///         annot_pragma_openmp 'parallel' | 'simd' | 'for' | 'sections' |
146 ///         'section' | 'single' | 'master' | 'critical' [ '(' <name> ')' ] |
147 ///         'parallel for' | 'parallel sections' | 'task' | 'taskyield' |
148 ///         'barrier' | 'taskwait' | 'flush' | 'ordered' | 'atomic' |
149 ///         'for simd' | 'parallel for simd' | 'target' | 'teams' | 'taskgroup'
150 ///         {clause}
151 ///         annot_pragma_openmp_end
152 ///
153 StmtResult
154 Parser::ParseOpenMPDeclarativeOrExecutableDirective(bool StandAloneAllowed) {
155   assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!");
156   ParenBraceBracketBalancer BalancerRAIIObj(*this);
157   SmallVector<Expr *, 5> Identifiers;
158   SmallVector<OMPClause *, 5> Clauses;
159   SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>, OMPC_unknown + 1>
160   FirstClauses(OMPC_unknown + 1);
161   unsigned ScopeFlags =
162       Scope::FnScope | Scope::DeclScope | Scope::OpenMPDirectiveScope;
163   SourceLocation Loc = ConsumeToken(), EndLoc;
164   auto DKind = ParseOpenMPDirectiveKind(*this);
165   OpenMPDirectiveKind CancelRegion = OMPD_unknown;
166   // Name of critical directive.
167   DeclarationNameInfo DirName;
168   StmtResult Directive = StmtError();
169   bool HasAssociatedStatement = true;
170   bool FlushHasClause = false;
171 
172   switch (DKind) {
173   case OMPD_threadprivate:
174     ConsumeToken();
175     if (!ParseOpenMPSimpleVarList(OMPD_threadprivate, Identifiers, false)) {
176       // The last seen token is annot_pragma_openmp_end - need to check for
177       // extra tokens.
178       if (Tok.isNot(tok::annot_pragma_openmp_end)) {
179         Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
180             << getOpenMPDirectiveName(OMPD_threadprivate);
181         SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
182       }
183       DeclGroupPtrTy Res =
184           Actions.ActOnOpenMPThreadprivateDirective(Loc, Identifiers);
185       Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation());
186     }
187     SkipUntil(tok::annot_pragma_openmp_end);
188     break;
189   case OMPD_flush:
190     if (PP.LookAhead(0).is(tok::l_paren)) {
191       FlushHasClause = true;
192       // Push copy of the current token back to stream to properly parse
193       // pseudo-clause OMPFlushClause.
194       PP.EnterToken(Tok);
195     }
196   case OMPD_taskyield:
197   case OMPD_barrier:
198   case OMPD_taskwait:
199   case OMPD_cancellation_point:
200   case OMPD_cancel:
201     if (!StandAloneAllowed) {
202       Diag(Tok, diag::err_omp_immediate_directive)
203           << getOpenMPDirectiveName(DKind);
204     }
205     HasAssociatedStatement = false;
206     // Fall through for further analysis.
207   case OMPD_parallel:
208   case OMPD_simd:
209   case OMPD_for:
210   case OMPD_for_simd:
211   case OMPD_sections:
212   case OMPD_single:
213   case OMPD_section:
214   case OMPD_master:
215   case OMPD_critical:
216   case OMPD_parallel_for:
217   case OMPD_parallel_for_simd:
218   case OMPD_parallel_sections:
219   case OMPD_task:
220   case OMPD_ordered:
221   case OMPD_atomic:
222   case OMPD_target:
223   case OMPD_teams:
224   case OMPD_taskgroup: {
225     ConsumeToken();
226     // Parse directive name of the 'critical' directive if any.
227     if (DKind == OMPD_critical) {
228       BalancedDelimiterTracker T(*this, tok::l_paren,
229                                  tok::annot_pragma_openmp_end);
230       if (!T.consumeOpen()) {
231         if (Tok.isAnyIdentifier()) {
232           DirName =
233               DeclarationNameInfo(Tok.getIdentifierInfo(), Tok.getLocation());
234           ConsumeAnyToken();
235         } else {
236           Diag(Tok, diag::err_omp_expected_identifier_for_critical);
237         }
238         T.consumeClose();
239       }
240     } else if (DKind == OMPD_cancellation_point || DKind == OMPD_cancel) {
241       CancelRegion = ParseOpenMPDirectiveKind(*this);
242       if (Tok.isNot(tok::annot_pragma_openmp_end))
243         ConsumeToken();
244     }
245 
246     if (isOpenMPLoopDirective(DKind))
247       ScopeFlags |= Scope::OpenMPLoopDirectiveScope;
248     if (isOpenMPSimdDirective(DKind))
249       ScopeFlags |= Scope::OpenMPSimdDirectiveScope;
250     ParseScope OMPDirectiveScope(this, ScopeFlags);
251     Actions.StartOpenMPDSABlock(DKind, DirName, Actions.getCurScope(), Loc);
252 
253     while (Tok.isNot(tok::annot_pragma_openmp_end)) {
254       OpenMPClauseKind CKind =
255           Tok.isAnnotation()
256               ? OMPC_unknown
257               : FlushHasClause ? OMPC_flush
258                                : getOpenMPClauseKind(PP.getSpelling(Tok));
259       Actions.StartOpenMPClause(CKind);
260       FlushHasClause = false;
261       OMPClause *Clause =
262           ParseOpenMPClause(DKind, CKind, !FirstClauses[CKind].getInt());
263       FirstClauses[CKind].setInt(true);
264       if (Clause) {
265         FirstClauses[CKind].setPointer(Clause);
266         Clauses.push_back(Clause);
267       }
268 
269       // Skip ',' if any.
270       if (Tok.is(tok::comma))
271         ConsumeToken();
272       Actions.EndOpenMPClause();
273     }
274     // End location of the directive.
275     EndLoc = Tok.getLocation();
276     // Consume final annot_pragma_openmp_end.
277     ConsumeToken();
278 
279     StmtResult AssociatedStmt;
280     bool CreateDirective = true;
281     if (HasAssociatedStatement) {
282       // The body is a block scope like in Lambdas and Blocks.
283       Sema::CompoundScopeRAII CompoundScope(Actions);
284       Actions.ActOnOpenMPRegionStart(DKind, getCurScope());
285       Actions.ActOnStartOfCompoundStmt();
286       // Parse statement
287       AssociatedStmt = ParseStatement();
288       Actions.ActOnFinishOfCompoundStmt();
289       AssociatedStmt = Actions.ActOnOpenMPRegionEnd(AssociatedStmt, Clauses);
290       CreateDirective = AssociatedStmt.isUsable();
291     }
292     if (CreateDirective)
293       Directive = Actions.ActOnOpenMPExecutableDirective(
294           DKind, DirName, CancelRegion, Clauses, AssociatedStmt.get(), Loc,
295           EndLoc);
296 
297     // Exit scope.
298     Actions.EndOpenMPDSABlock(Directive.get());
299     OMPDirectiveScope.Exit();
300     break;
301   }
302   case OMPD_unknown:
303     Diag(Tok, diag::err_omp_unknown_directive);
304     SkipUntil(tok::annot_pragma_openmp_end);
305     break;
306   }
307   return Directive;
308 }
309 
310 /// \brief Parses list of simple variables for '#pragma omp threadprivate'
311 /// directive.
312 ///
313 ///   simple-variable-list:
314 ///         '(' id-expression {, id-expression} ')'
315 ///
316 bool Parser::ParseOpenMPSimpleVarList(OpenMPDirectiveKind Kind,
317                                       SmallVectorImpl<Expr *> &VarList,
318                                       bool AllowScopeSpecifier) {
319   VarList.clear();
320   // Parse '('.
321   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
322   if (T.expectAndConsume(diag::err_expected_lparen_after,
323                          getOpenMPDirectiveName(Kind)))
324     return true;
325   bool IsCorrect = true;
326   bool NoIdentIsFound = true;
327 
328   // Read tokens while ')' or annot_pragma_openmp_end is not found.
329   while (Tok.isNot(tok::r_paren) && Tok.isNot(tok::annot_pragma_openmp_end)) {
330     CXXScopeSpec SS;
331     SourceLocation TemplateKWLoc;
332     UnqualifiedId Name;
333     // Read var name.
334     Token PrevTok = Tok;
335     NoIdentIsFound = false;
336 
337     if (AllowScopeSpecifier && getLangOpts().CPlusPlus &&
338         ParseOptionalCXXScopeSpecifier(SS, ParsedType(), false)) {
339       IsCorrect = false;
340       SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
341                 StopBeforeMatch);
342     } else if (ParseUnqualifiedId(SS, false, false, false, ParsedType(),
343                                   TemplateKWLoc, Name)) {
344       IsCorrect = false;
345       SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
346                 StopBeforeMatch);
347     } else if (Tok.isNot(tok::comma) && Tok.isNot(tok::r_paren) &&
348                Tok.isNot(tok::annot_pragma_openmp_end)) {
349       IsCorrect = false;
350       SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
351                 StopBeforeMatch);
352       Diag(PrevTok.getLocation(), diag::err_expected)
353           << tok::identifier
354           << SourceRange(PrevTok.getLocation(), PrevTokLocation);
355     } else {
356       DeclarationNameInfo NameInfo = Actions.GetNameFromUnqualifiedId(Name);
357       ExprResult Res =
358           Actions.ActOnOpenMPIdExpression(getCurScope(), SS, NameInfo);
359       if (Res.isUsable())
360         VarList.push_back(Res.get());
361     }
362     // Consume ','.
363     if (Tok.is(tok::comma)) {
364       ConsumeToken();
365     }
366   }
367 
368   if (NoIdentIsFound) {
369     Diag(Tok, diag::err_expected) << tok::identifier;
370     IsCorrect = false;
371   }
372 
373   // Parse ')'.
374   IsCorrect = !T.consumeClose() && IsCorrect;
375 
376   return !IsCorrect && VarList.empty();
377 }
378 
379 /// \brief Parsing of OpenMP clauses.
380 ///
381 ///    clause:
382 ///       if-clause | final-clause | num_threads-clause | safelen-clause |
383 ///       default-clause | private-clause | firstprivate-clause | shared-clause
384 ///       | linear-clause | aligned-clause | collapse-clause |
385 ///       lastprivate-clause | reduction-clause | proc_bind-clause |
386 ///       schedule-clause | copyin-clause | copyprivate-clause | untied-clause |
387 ///       mergeable-clause | flush-clause | read-clause | write-clause |
388 ///       update-clause | capture-clause | seq_cst-clause
389 ///
390 OMPClause *Parser::ParseOpenMPClause(OpenMPDirectiveKind DKind,
391                                      OpenMPClauseKind CKind, bool FirstClause) {
392   OMPClause *Clause = nullptr;
393   bool ErrorFound = false;
394   // Check if clause is allowed for the given directive.
395   if (CKind != OMPC_unknown && !isAllowedClauseForDirective(DKind, CKind)) {
396     Diag(Tok, diag::err_omp_unexpected_clause) << getOpenMPClauseName(CKind)
397                                                << getOpenMPDirectiveName(DKind);
398     ErrorFound = true;
399   }
400 
401   switch (CKind) {
402   case OMPC_if:
403   case OMPC_final:
404   case OMPC_num_threads:
405   case OMPC_safelen:
406   case OMPC_collapse:
407     // OpenMP [2.5, Restrictions]
408     //  At most one if clause can appear on the directive.
409     //  At most one num_threads clause can appear on the directive.
410     // OpenMP [2.8.1, simd construct, Restrictions]
411     //  Only one safelen  clause can appear on a simd directive.
412     //  Only one collapse clause can appear on a simd directive.
413     // OpenMP [2.11.1, task Construct, Restrictions]
414     //  At most one if clause can appear on the directive.
415     //  At most one final clause can appear on the directive.
416     if (!FirstClause) {
417       Diag(Tok, diag::err_omp_more_one_clause) << getOpenMPDirectiveName(DKind)
418                                                << getOpenMPClauseName(CKind);
419       ErrorFound = true;
420     }
421 
422     Clause = ParseOpenMPSingleExprClause(CKind);
423     break;
424   case OMPC_default:
425   case OMPC_proc_bind:
426     // OpenMP [2.14.3.1, Restrictions]
427     //  Only a single default clause may be specified on a parallel, task or
428     //  teams directive.
429     // OpenMP [2.5, parallel Construct, Restrictions]
430     //  At most one proc_bind clause can appear on the directive.
431     if (!FirstClause) {
432       Diag(Tok, diag::err_omp_more_one_clause) << getOpenMPDirectiveName(DKind)
433                                                << getOpenMPClauseName(CKind);
434       ErrorFound = true;
435     }
436 
437     Clause = ParseOpenMPSimpleClause(CKind);
438     break;
439   case OMPC_schedule:
440     // OpenMP [2.7.1, Restrictions, p. 3]
441     //  Only one schedule clause can appear on a loop directive.
442     if (!FirstClause) {
443       Diag(Tok, diag::err_omp_more_one_clause) << getOpenMPDirectiveName(DKind)
444                                                << getOpenMPClauseName(CKind);
445       ErrorFound = true;
446     }
447 
448     Clause = ParseOpenMPSingleExprWithArgClause(CKind);
449     break;
450   case OMPC_ordered:
451   case OMPC_nowait:
452   case OMPC_untied:
453   case OMPC_mergeable:
454   case OMPC_read:
455   case OMPC_write:
456   case OMPC_update:
457   case OMPC_capture:
458   case OMPC_seq_cst:
459     // OpenMP [2.7.1, Restrictions, p. 9]
460     //  Only one ordered clause can appear on a loop directive.
461     // OpenMP [2.7.1, Restrictions, C/C++, p. 4]
462     //  Only one nowait clause can appear on a for directive.
463     if (!FirstClause) {
464       Diag(Tok, diag::err_omp_more_one_clause) << getOpenMPDirectiveName(DKind)
465                                                << getOpenMPClauseName(CKind);
466       ErrorFound = true;
467     }
468 
469     Clause = ParseOpenMPClause(CKind);
470     break;
471   case OMPC_private:
472   case OMPC_firstprivate:
473   case OMPC_lastprivate:
474   case OMPC_shared:
475   case OMPC_reduction:
476   case OMPC_linear:
477   case OMPC_aligned:
478   case OMPC_copyin:
479   case OMPC_copyprivate:
480   case OMPC_flush:
481   case OMPC_depend:
482     Clause = ParseOpenMPVarListClause(CKind);
483     break;
484   case OMPC_unknown:
485     Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
486         << getOpenMPDirectiveName(DKind);
487     SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
488     break;
489   case OMPC_threadprivate:
490     Diag(Tok, diag::err_omp_unexpected_clause) << getOpenMPClauseName(CKind)
491                                                << getOpenMPDirectiveName(DKind);
492     SkipUntil(tok::comma, tok::annot_pragma_openmp_end, StopBeforeMatch);
493     break;
494   }
495   return ErrorFound ? nullptr : Clause;
496 }
497 
498 /// \brief Parsing of OpenMP clauses with single expressions like 'if',
499 /// 'final', 'collapse', 'safelen', 'num_threads', 'simdlen', 'num_teams' or
500 /// 'thread_limit'.
501 ///
502 ///    if-clause:
503 ///      'if' '(' expression ')'
504 ///
505 ///    final-clause:
506 ///      'final' '(' expression ')'
507 ///
508 ///    num_threads-clause:
509 ///      'num_threads' '(' expression ')'
510 ///
511 ///    safelen-clause:
512 ///      'safelen' '(' expression ')'
513 ///
514 ///    collapse-clause:
515 ///      'collapse' '(' expression ')'
516 ///
517 OMPClause *Parser::ParseOpenMPSingleExprClause(OpenMPClauseKind Kind) {
518   SourceLocation Loc = ConsumeToken();
519 
520   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
521   if (T.expectAndConsume(diag::err_expected_lparen_after,
522                          getOpenMPClauseName(Kind)))
523     return nullptr;
524 
525   ExprResult LHS(ParseCastExpression(false, false, NotTypeCast));
526   ExprResult Val(ParseRHSOfBinaryExpression(LHS, prec::Conditional));
527 
528   // Parse ')'.
529   T.consumeClose();
530 
531   if (Val.isInvalid())
532     return nullptr;
533 
534   return Actions.ActOnOpenMPSingleExprClause(
535       Kind, Val.get(), Loc, T.getOpenLocation(), T.getCloseLocation());
536 }
537 
538 /// \brief Parsing of simple OpenMP clauses like 'default' or 'proc_bind'.
539 ///
540 ///    default-clause:
541 ///         'default' '(' 'none' | 'shared' ')
542 ///
543 ///    proc_bind-clause:
544 ///         'proc_bind' '(' 'master' | 'close' | 'spread' ')
545 ///
546 OMPClause *Parser::ParseOpenMPSimpleClause(OpenMPClauseKind Kind) {
547   SourceLocation Loc = Tok.getLocation();
548   SourceLocation LOpen = ConsumeToken();
549   // Parse '('.
550   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
551   if (T.expectAndConsume(diag::err_expected_lparen_after,
552                          getOpenMPClauseName(Kind)))
553     return nullptr;
554 
555   unsigned Type = getOpenMPSimpleClauseType(
556       Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok));
557   SourceLocation TypeLoc = Tok.getLocation();
558   if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
559       Tok.isNot(tok::annot_pragma_openmp_end))
560     ConsumeAnyToken();
561 
562   // Parse ')'.
563   T.consumeClose();
564 
565   return Actions.ActOnOpenMPSimpleClause(Kind, Type, TypeLoc, LOpen, Loc,
566                                          Tok.getLocation());
567 }
568 
569 /// \brief Parsing of OpenMP clauses like 'ordered'.
570 ///
571 ///    ordered-clause:
572 ///         'ordered'
573 ///
574 ///    nowait-clause:
575 ///         'nowait'
576 ///
577 ///    untied-clause:
578 ///         'untied'
579 ///
580 ///    mergeable-clause:
581 ///         'mergeable'
582 ///
583 ///    read-clause:
584 ///         'read'
585 ///
586 OMPClause *Parser::ParseOpenMPClause(OpenMPClauseKind Kind) {
587   SourceLocation Loc = Tok.getLocation();
588   ConsumeAnyToken();
589 
590   return Actions.ActOnOpenMPClause(Kind, Loc, Tok.getLocation());
591 }
592 
593 
594 /// \brief Parsing of OpenMP clauses with single expressions and some additional
595 /// argument like 'schedule' or 'dist_schedule'.
596 ///
597 ///    schedule-clause:
598 ///      'schedule' '(' kind [',' expression ] ')'
599 ///
600 OMPClause *Parser::ParseOpenMPSingleExprWithArgClause(OpenMPClauseKind Kind) {
601   SourceLocation Loc = ConsumeToken();
602   SourceLocation CommaLoc;
603   // Parse '('.
604   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
605   if (T.expectAndConsume(diag::err_expected_lparen_after,
606                          getOpenMPClauseName(Kind)))
607     return nullptr;
608 
609   ExprResult Val;
610   unsigned Type = getOpenMPSimpleClauseType(
611       Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok));
612   SourceLocation KLoc = Tok.getLocation();
613   if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
614       Tok.isNot(tok::annot_pragma_openmp_end))
615     ConsumeAnyToken();
616 
617   if (Kind == OMPC_schedule &&
618       (Type == OMPC_SCHEDULE_static || Type == OMPC_SCHEDULE_dynamic ||
619        Type == OMPC_SCHEDULE_guided) &&
620       Tok.is(tok::comma)) {
621     CommaLoc = ConsumeAnyToken();
622     ExprResult LHS(ParseCastExpression(false, false, NotTypeCast));
623     Val = ParseRHSOfBinaryExpression(LHS, prec::Conditional);
624     if (Val.isInvalid())
625       return nullptr;
626   }
627 
628   // Parse ')'.
629   T.consumeClose();
630 
631   return Actions.ActOnOpenMPSingleExprWithArgClause(
632       Kind, Type, Val.get(), Loc, T.getOpenLocation(), KLoc, CommaLoc,
633       T.getCloseLocation());
634 }
635 
636 static bool ParseReductionId(Parser &P, CXXScopeSpec &ReductionIdScopeSpec,
637                              UnqualifiedId &ReductionId) {
638   SourceLocation TemplateKWLoc;
639   if (ReductionIdScopeSpec.isEmpty()) {
640     auto OOK = OO_None;
641     switch (P.getCurToken().getKind()) {
642     case tok::plus:
643       OOK = OO_Plus;
644       break;
645     case tok::minus:
646       OOK = OO_Minus;
647       break;
648     case tok::star:
649       OOK = OO_Star;
650       break;
651     case tok::amp:
652       OOK = OO_Amp;
653       break;
654     case tok::pipe:
655       OOK = OO_Pipe;
656       break;
657     case tok::caret:
658       OOK = OO_Caret;
659       break;
660     case tok::ampamp:
661       OOK = OO_AmpAmp;
662       break;
663     case tok::pipepipe:
664       OOK = OO_PipePipe;
665       break;
666     default:
667       break;
668     }
669     if (OOK != OO_None) {
670       SourceLocation OpLoc = P.ConsumeToken();
671       SourceLocation SymbolLocations[] = {OpLoc, OpLoc, SourceLocation()};
672       ReductionId.setOperatorFunctionId(OpLoc, OOK, SymbolLocations);
673       return false;
674     }
675   }
676   return P.ParseUnqualifiedId(ReductionIdScopeSpec, /*EnteringContext*/ false,
677                               /*AllowDestructorName*/ false,
678                               /*AllowConstructorName*/ false, ParsedType(),
679                               TemplateKWLoc, ReductionId);
680 }
681 
682 /// \brief Parsing of OpenMP clause 'private', 'firstprivate', 'lastprivate',
683 /// 'shared', 'copyin', 'copyprivate', 'flush' or 'reduction'.
684 ///
685 ///    private-clause:
686 ///       'private' '(' list ')'
687 ///    firstprivate-clause:
688 ///       'firstprivate' '(' list ')'
689 ///    lastprivate-clause:
690 ///       'lastprivate' '(' list ')'
691 ///    shared-clause:
692 ///       'shared' '(' list ')'
693 ///    linear-clause:
694 ///       'linear' '(' list [ ':' linear-step ] ')'
695 ///    aligned-clause:
696 ///       'aligned' '(' list [ ':' alignment ] ')'
697 ///    reduction-clause:
698 ///       'reduction' '(' reduction-identifier ':' list ')'
699 ///    copyprivate-clause:
700 ///       'copyprivate' '(' list ')'
701 ///    flush-clause:
702 ///       'flush' '(' list ')'
703 ///    depend-clause:
704 ///       'depend' '(' in | out | inout : list ')'
705 ///
706 OMPClause *Parser::ParseOpenMPVarListClause(OpenMPClauseKind Kind) {
707   SourceLocation Loc = Tok.getLocation();
708   SourceLocation LOpen = ConsumeToken();
709   SourceLocation ColonLoc = SourceLocation();
710   // Optional scope specifier and unqualified id for reduction identifier.
711   CXXScopeSpec ReductionIdScopeSpec;
712   UnqualifiedId ReductionId;
713   bool InvalidReductionId = false;
714   OpenMPDependClauseKind DepKind = OMPC_DEPEND_unknown;
715   SourceLocation DepLoc;
716 
717   // Parse '('.
718   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
719   if (T.expectAndConsume(diag::err_expected_lparen_after,
720                          getOpenMPClauseName(Kind)))
721     return nullptr;
722 
723   // Handle reduction-identifier for reduction clause.
724   if (Kind == OMPC_reduction) {
725     ColonProtectionRAIIObject ColonRAII(*this);
726     if (getLangOpts().CPlusPlus) {
727       ParseOptionalCXXScopeSpecifier(ReductionIdScopeSpec, ParsedType(), false);
728     }
729     InvalidReductionId =
730         ParseReductionId(*this, ReductionIdScopeSpec, ReductionId);
731     if (InvalidReductionId) {
732       SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,
733                 StopBeforeMatch);
734     }
735     if (Tok.is(tok::colon)) {
736       ColonLoc = ConsumeToken();
737     } else {
738       Diag(Tok, diag::warn_pragma_expected_colon) << "reduction identifier";
739     }
740   } else if (Kind == OMPC_depend) {
741   // Handle dependency type for depend clause.
742     ColonProtectionRAIIObject ColonRAII(*this);
743     DepKind = static_cast<OpenMPDependClauseKind>(getOpenMPSimpleClauseType(
744         Kind, Tok.is(tok::identifier) ? PP.getSpelling(Tok) : ""));
745     DepLoc = Tok.getLocation();
746 
747     if (DepKind == OMPC_DEPEND_unknown) {
748       SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,
749                 StopBeforeMatch);
750     } else {
751       ConsumeToken();
752     }
753     if (Tok.is(tok::colon)) {
754       ColonLoc = ConsumeToken();
755     } else {
756       Diag(Tok, diag::warn_pragma_expected_colon) << "dependency type";
757     }
758   }
759 
760   SmallVector<Expr *, 5> Vars;
761   bool IsComma = ((Kind != OMPC_reduction) && (Kind != OMPC_depend)) ||
762                  ((Kind == OMPC_reduction) && !InvalidReductionId) ||
763                  ((Kind == OMPC_depend) && DepKind != OMPC_DEPEND_unknown);
764   const bool MayHaveTail = (Kind == OMPC_linear || Kind == OMPC_aligned);
765   while (IsComma || (Tok.isNot(tok::r_paren) && Tok.isNot(tok::colon) &&
766                      Tok.isNot(tok::annot_pragma_openmp_end))) {
767     ColonProtectionRAIIObject ColonRAII(*this, MayHaveTail);
768     // Parse variable
769     ExprResult VarExpr =
770         Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
771     if (VarExpr.isUsable()) {
772       Vars.push_back(VarExpr.get());
773     } else {
774       SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
775                 StopBeforeMatch);
776     }
777     // Skip ',' if any
778     IsComma = Tok.is(tok::comma);
779     if (IsComma)
780       ConsumeToken();
781     else if (Tok.isNot(tok::r_paren) &&
782              Tok.isNot(tok::annot_pragma_openmp_end) &&
783              (!MayHaveTail || Tok.isNot(tok::colon)))
784       Diag(Tok, diag::err_omp_expected_punc)
785           << ((Kind == OMPC_flush) ? getOpenMPDirectiveName(OMPD_flush)
786                                    : getOpenMPClauseName(Kind))
787           << (Kind == OMPC_flush);
788   }
789 
790   // Parse ':' linear-step (or ':' alignment).
791   Expr *TailExpr = nullptr;
792   const bool MustHaveTail = MayHaveTail && Tok.is(tok::colon);
793   if (MustHaveTail) {
794     ColonLoc = Tok.getLocation();
795     ConsumeToken();
796     ExprResult Tail =
797         Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
798     if (Tail.isUsable())
799       TailExpr = Tail.get();
800     else
801       SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
802                 StopBeforeMatch);
803   }
804 
805   // Parse ')'.
806   T.consumeClose();
807   if ((Kind == OMPC_depend && DepKind != OMPC_DEPEND_unknown && Vars.empty()) ||
808       (Kind != OMPC_depend && Vars.empty()) || (MustHaveTail && !TailExpr) ||
809       InvalidReductionId)
810     return nullptr;
811 
812   return Actions.ActOnOpenMPVarListClause(
813       Kind, Vars, TailExpr, Loc, LOpen, ColonLoc, Tok.getLocation(),
814       ReductionIdScopeSpec,
815       ReductionId.isValid() ? Actions.GetNameFromUnqualifiedId(ReductionId)
816                             : DeclarationNameInfo(),
817       DepKind, DepLoc);
818 }
819 
820