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