[OpenMP][NFC] Remove the need to include `OpenMPClause.h`
[lldb.git] / clang / lib / Parse / ParseOpenMP.cpp
1 //===--- ParseOpenMP.cpp - OpenMP directives parsing ----------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 /// \file
9 /// This file implements parsing of all OpenMP directives and clauses.
10 ///
11 //===----------------------------------------------------------------------===//
12
13 #include "clang/AST/ASTContext.h"
14 #include "clang/AST/OpenMPClause.h"
15 #include "clang/AST/StmtOpenMP.h"
16 #include "clang/Basic/OpenMPKinds.h"
17 #include "clang/Basic/TargetInfo.h"
18 #include "clang/Basic/TokenKinds.h"
19 #include "clang/Parse/ParseDiagnostic.h"
20 #include "clang/Parse/Parser.h"
21 #include "clang/Parse/RAIIObjectsForParser.h"
22 #include "clang/Sema/Scope.h"
23 #include "llvm/ADT/PointerIntPair.h"
24 #include "llvm/ADT/UniqueVector.h"
25 #include "llvm/Frontend/OpenMP/OMPContext.h"
26
27 using namespace clang;
28 using namespace llvm::omp;
29
30 //===----------------------------------------------------------------------===//
31 // OpenMP declarative directives.
32 //===----------------------------------------------------------------------===//
33
34 namespace {
35 enum OpenMPDirectiveKindEx {
36   OMPD_cancellation = unsigned(OMPD_unknown) + 1,
37   OMPD_data,
38   OMPD_declare,
39   OMPD_end,
40   OMPD_end_declare,
41   OMPD_enter,
42   OMPD_exit,
43   OMPD_point,
44   OMPD_reduction,
45   OMPD_target_enter,
46   OMPD_target_exit,
47   OMPD_update,
48   OMPD_distribute_parallel,
49   OMPD_teams_distribute_parallel,
50   OMPD_target_teams_distribute_parallel,
51   OMPD_mapper,
52   OMPD_variant,
53   OMPD_begin,
54   OMPD_begin_declare,
55 };
56
57 // Helper to unify the enum class OpenMPDirectiveKind with its extension
58 // the OpenMPDirectiveKindEx enum which allows to use them together as if they
59 // are unsigned values.
60 struct OpenMPDirectiveKindExWrapper {
61   OpenMPDirectiveKindExWrapper(unsigned Value) : Value(Value) {}
62   OpenMPDirectiveKindExWrapper(OpenMPDirectiveKind DK) : Value(unsigned(DK)) {}
63   bool operator==(OpenMPDirectiveKind V) const { return Value == unsigned(V); }
64   bool operator!=(OpenMPDirectiveKind V) const { return Value != unsigned(V); }
65   bool operator<(OpenMPDirectiveKind V) const { return Value < unsigned(V); }
66   operator unsigned() const { return Value; }
67   operator OpenMPDirectiveKind() const { return OpenMPDirectiveKind(Value); }
68   unsigned Value;
69 };
70
71 class DeclDirectiveListParserHelper final {
72   SmallVector<Expr *, 4> Identifiers;
73   Parser *P;
74   OpenMPDirectiveKind Kind;
75
76 public:
77   DeclDirectiveListParserHelper(Parser *P, OpenMPDirectiveKind Kind)
78       : P(P), Kind(Kind) {}
79   void operator()(CXXScopeSpec &SS, DeclarationNameInfo NameInfo) {
80     ExprResult Res = P->getActions().ActOnOpenMPIdExpression(
81         P->getCurScope(), SS, NameInfo, Kind);
82     if (Res.isUsable())
83       Identifiers.push_back(Res.get());
84   }
85   llvm::ArrayRef<Expr *> getIdentifiers() const { return Identifiers; }
86 };
87 } // namespace
88
89 // Map token string to extended OMP token kind that are
90 // OpenMPDirectiveKind + OpenMPDirectiveKindEx.
91 static unsigned getOpenMPDirectiveKindEx(StringRef S) {
92   OpenMPDirectiveKindExWrapper DKind = getOpenMPDirectiveKind(S);
93   if (DKind != OMPD_unknown)
94     return DKind;
95
96   return llvm::StringSwitch<OpenMPDirectiveKindExWrapper>(S)
97       .Case("cancellation", OMPD_cancellation)
98       .Case("data", OMPD_data)
99       .Case("declare", OMPD_declare)
100       .Case("end", OMPD_end)
101       .Case("enter", OMPD_enter)
102       .Case("exit", OMPD_exit)
103       .Case("point", OMPD_point)
104       .Case("reduction", OMPD_reduction)
105       .Case("update", OMPD_update)
106       .Case("mapper", OMPD_mapper)
107       .Case("variant", OMPD_variant)
108       .Case("begin", OMPD_begin)
109       .Default(OMPD_unknown);
110 }
111
112 static OpenMPDirectiveKindExWrapper parseOpenMPDirectiveKind(Parser &P) {
113   // Array of foldings: F[i][0] F[i][1] ===> F[i][2].
114   // E.g.: OMPD_for OMPD_simd ===> OMPD_for_simd
115   // TODO: add other combined directives in topological order.
116   static const OpenMPDirectiveKindExWrapper F[][3] = {
117       {OMPD_begin, OMPD_declare, OMPD_begin_declare},
118       {OMPD_end, OMPD_declare, OMPD_end_declare},
119       {OMPD_cancellation, OMPD_point, OMPD_cancellation_point},
120       {OMPD_declare, OMPD_reduction, OMPD_declare_reduction},
121       {OMPD_declare, OMPD_mapper, OMPD_declare_mapper},
122       {OMPD_declare, OMPD_simd, OMPD_declare_simd},
123       {OMPD_declare, OMPD_target, OMPD_declare_target},
124       {OMPD_declare, OMPD_variant, OMPD_declare_variant},
125       {OMPD_begin_declare, OMPD_variant, OMPD_begin_declare_variant},
126       {OMPD_end_declare, OMPD_variant, OMPD_end_declare_variant},
127       {OMPD_distribute, OMPD_parallel, OMPD_distribute_parallel},
128       {OMPD_distribute_parallel, OMPD_for, OMPD_distribute_parallel_for},
129       {OMPD_distribute_parallel_for, OMPD_simd,
130        OMPD_distribute_parallel_for_simd},
131       {OMPD_distribute, OMPD_simd, OMPD_distribute_simd},
132       {OMPD_end_declare, OMPD_target, OMPD_end_declare_target},
133       {OMPD_target, OMPD_data, OMPD_target_data},
134       {OMPD_target, OMPD_enter, OMPD_target_enter},
135       {OMPD_target, OMPD_exit, OMPD_target_exit},
136       {OMPD_target, OMPD_update, OMPD_target_update},
137       {OMPD_target_enter, OMPD_data, OMPD_target_enter_data},
138       {OMPD_target_exit, OMPD_data, OMPD_target_exit_data},
139       {OMPD_for, OMPD_simd, OMPD_for_simd},
140       {OMPD_parallel, OMPD_for, OMPD_parallel_for},
141       {OMPD_parallel_for, OMPD_simd, OMPD_parallel_for_simd},
142       {OMPD_parallel, OMPD_sections, OMPD_parallel_sections},
143       {OMPD_taskloop, OMPD_simd, OMPD_taskloop_simd},
144       {OMPD_target, OMPD_parallel, OMPD_target_parallel},
145       {OMPD_target, OMPD_simd, OMPD_target_simd},
146       {OMPD_target_parallel, OMPD_for, OMPD_target_parallel_for},
147       {OMPD_target_parallel_for, OMPD_simd, OMPD_target_parallel_for_simd},
148       {OMPD_teams, OMPD_distribute, OMPD_teams_distribute},
149       {OMPD_teams_distribute, OMPD_simd, OMPD_teams_distribute_simd},
150       {OMPD_teams_distribute, OMPD_parallel, OMPD_teams_distribute_parallel},
151       {OMPD_teams_distribute_parallel, OMPD_for,
152        OMPD_teams_distribute_parallel_for},
153       {OMPD_teams_distribute_parallel_for, OMPD_simd,
154        OMPD_teams_distribute_parallel_for_simd},
155       {OMPD_target, OMPD_teams, OMPD_target_teams},
156       {OMPD_target_teams, OMPD_distribute, OMPD_target_teams_distribute},
157       {OMPD_target_teams_distribute, OMPD_parallel,
158        OMPD_target_teams_distribute_parallel},
159       {OMPD_target_teams_distribute, OMPD_simd,
160        OMPD_target_teams_distribute_simd},
161       {OMPD_target_teams_distribute_parallel, OMPD_for,
162        OMPD_target_teams_distribute_parallel_for},
163       {OMPD_target_teams_distribute_parallel_for, OMPD_simd,
164        OMPD_target_teams_distribute_parallel_for_simd},
165       {OMPD_master, OMPD_taskloop, OMPD_master_taskloop},
166       {OMPD_master_taskloop, OMPD_simd, OMPD_master_taskloop_simd},
167       {OMPD_parallel, OMPD_master, OMPD_parallel_master},
168       {OMPD_parallel_master, OMPD_taskloop, OMPD_parallel_master_taskloop},
169       {OMPD_parallel_master_taskloop, OMPD_simd,
170        OMPD_parallel_master_taskloop_simd}};
171   enum { CancellationPoint = 0, DeclareReduction = 1, TargetData = 2 };
172   Token Tok = P.getCurToken();
173   OpenMPDirectiveKindExWrapper DKind =
174       Tok.isAnnotation()
175           ? static_cast<unsigned>(OMPD_unknown)
176           : getOpenMPDirectiveKindEx(P.getPreprocessor().getSpelling(Tok));
177   if (DKind == OMPD_unknown)
178     return OMPD_unknown;
179
180   for (unsigned I = 0; I < llvm::array_lengthof(F); ++I) {
181     if (DKind != F[I][0])
182       continue;
183
184     Tok = P.getPreprocessor().LookAhead(0);
185     OpenMPDirectiveKindExWrapper SDKind =
186         Tok.isAnnotation()
187             ? static_cast<unsigned>(OMPD_unknown)
188             : getOpenMPDirectiveKindEx(P.getPreprocessor().getSpelling(Tok));
189     if (SDKind == OMPD_unknown)
190       continue;
191
192     if (SDKind == F[I][1]) {
193       P.ConsumeToken();
194       DKind = F[I][2];
195     }
196   }
197   return DKind < OMPD_unknown ? static_cast<OpenMPDirectiveKind>(DKind)
198                               : OMPD_unknown;
199 }
200
201 static DeclarationName parseOpenMPReductionId(Parser &P) {
202   Token Tok = P.getCurToken();
203   Sema &Actions = P.getActions();
204   OverloadedOperatorKind OOK = OO_None;
205   // Allow to use 'operator' keyword for C++ operators
206   bool WithOperator = false;
207   if (Tok.is(tok::kw_operator)) {
208     P.ConsumeToken();
209     Tok = P.getCurToken();
210     WithOperator = true;
211   }
212   switch (Tok.getKind()) {
213   case tok::plus: // '+'
214     OOK = OO_Plus;
215     break;
216   case tok::minus: // '-'
217     OOK = OO_Minus;
218     break;
219   case tok::star: // '*'
220     OOK = OO_Star;
221     break;
222   case tok::amp: // '&'
223     OOK = OO_Amp;
224     break;
225   case tok::pipe: // '|'
226     OOK = OO_Pipe;
227     break;
228   case tok::caret: // '^'
229     OOK = OO_Caret;
230     break;
231   case tok::ampamp: // '&&'
232     OOK = OO_AmpAmp;
233     break;
234   case tok::pipepipe: // '||'
235     OOK = OO_PipePipe;
236     break;
237   case tok::identifier: // identifier
238     if (!WithOperator)
239       break;
240     LLVM_FALLTHROUGH;
241   default:
242     P.Diag(Tok.getLocation(), diag::err_omp_expected_reduction_identifier);
243     P.SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,
244                 Parser::StopBeforeMatch);
245     return DeclarationName();
246   }
247   P.ConsumeToken();
248   auto &DeclNames = Actions.getASTContext().DeclarationNames;
249   return OOK == OO_None ? DeclNames.getIdentifier(Tok.getIdentifierInfo())
250                         : DeclNames.getCXXOperatorName(OOK);
251 }
252
253 /// Parse 'omp declare reduction' construct.
254 ///
255 ///       declare-reduction-directive:
256 ///        annot_pragma_openmp 'declare' 'reduction'
257 ///        '(' <reduction_id> ':' <type> {',' <type>} ':' <expression> ')'
258 ///        ['initializer' '(' ('omp_priv' '=' <expression>)|<function_call> ')']
259 ///        annot_pragma_openmp_end
260 /// <reduction_id> is either a base language identifier or one of the following
261 /// operators: '+', '-', '*', '&', '|', '^', '&&' and '||'.
262 ///
263 Parser::DeclGroupPtrTy
264 Parser::ParseOpenMPDeclareReductionDirective(AccessSpecifier AS) {
265   // Parse '('.
266   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
267   if (T.expectAndConsume(
268           diag::err_expected_lparen_after,
269           getOpenMPDirectiveName(OMPD_declare_reduction).data())) {
270     SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
271     return DeclGroupPtrTy();
272   }
273
274   DeclarationName Name = parseOpenMPReductionId(*this);
275   if (Name.isEmpty() && Tok.is(tok::annot_pragma_openmp_end))
276     return DeclGroupPtrTy();
277
278   // Consume ':'.
279   bool IsCorrect = !ExpectAndConsume(tok::colon);
280
281   if (!IsCorrect && Tok.is(tok::annot_pragma_openmp_end))
282     return DeclGroupPtrTy();
283
284   IsCorrect = IsCorrect && !Name.isEmpty();
285
286   if (Tok.is(tok::colon) || Tok.is(tok::annot_pragma_openmp_end)) {
287     Diag(Tok.getLocation(), diag::err_expected_type);
288     IsCorrect = false;
289   }
290
291   if (!IsCorrect && Tok.is(tok::annot_pragma_openmp_end))
292     return DeclGroupPtrTy();
293
294   SmallVector<std::pair<QualType, SourceLocation>, 8> ReductionTypes;
295   // Parse list of types until ':' token.
296   do {
297     ColonProtectionRAIIObject ColonRAII(*this);
298     SourceRange Range;
299     TypeResult TR =
300         ParseTypeName(&Range, DeclaratorContext::PrototypeContext, AS);
301     if (TR.isUsable()) {
302       QualType ReductionType =
303           Actions.ActOnOpenMPDeclareReductionType(Range.getBegin(), TR);
304       if (!ReductionType.isNull()) {
305         ReductionTypes.push_back(
306             std::make_pair(ReductionType, Range.getBegin()));
307       }
308     } else {
309       SkipUntil(tok::comma, tok::colon, tok::annot_pragma_openmp_end,
310                 StopBeforeMatch);
311     }
312
313     if (Tok.is(tok::colon) || Tok.is(tok::annot_pragma_openmp_end))
314       break;
315
316     // Consume ','.
317     if (ExpectAndConsume(tok::comma)) {
318       IsCorrect = false;
319       if (Tok.is(tok::annot_pragma_openmp_end)) {
320         Diag(Tok.getLocation(), diag::err_expected_type);
321         return DeclGroupPtrTy();
322       }
323     }
324   } while (Tok.isNot(tok::annot_pragma_openmp_end));
325
326   if (ReductionTypes.empty()) {
327     SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
328     return DeclGroupPtrTy();
329   }
330
331   if (!IsCorrect && Tok.is(tok::annot_pragma_openmp_end))
332     return DeclGroupPtrTy();
333
334   // Consume ':'.
335   if (ExpectAndConsume(tok::colon))
336     IsCorrect = false;
337
338   if (Tok.is(tok::annot_pragma_openmp_end)) {
339     Diag(Tok.getLocation(), diag::err_expected_expression);
340     return DeclGroupPtrTy();
341   }
342
343   DeclGroupPtrTy DRD = Actions.ActOnOpenMPDeclareReductionDirectiveStart(
344       getCurScope(), Actions.getCurLexicalContext(), Name, ReductionTypes, AS);
345
346   // Parse <combiner> expression and then parse initializer if any for each
347   // correct type.
348   unsigned I = 0, E = ReductionTypes.size();
349   for (Decl *D : DRD.get()) {
350     TentativeParsingAction TPA(*this);
351     ParseScope OMPDRScope(this, Scope::FnScope | Scope::DeclScope |
352                                     Scope::CompoundStmtScope |
353                                     Scope::OpenMPDirectiveScope);
354     // Parse <combiner> expression.
355     Actions.ActOnOpenMPDeclareReductionCombinerStart(getCurScope(), D);
356     ExprResult CombinerResult = Actions.ActOnFinishFullExpr(
357         ParseExpression().get(), D->getLocation(), /*DiscardedValue*/ false);
358     Actions.ActOnOpenMPDeclareReductionCombinerEnd(D, CombinerResult.get());
359
360     if (CombinerResult.isInvalid() && Tok.isNot(tok::r_paren) &&
361         Tok.isNot(tok::annot_pragma_openmp_end)) {
362       TPA.Commit();
363       IsCorrect = false;
364       break;
365     }
366     IsCorrect = !T.consumeClose() && IsCorrect && CombinerResult.isUsable();
367     ExprResult InitializerResult;
368     if (Tok.isNot(tok::annot_pragma_openmp_end)) {
369       // Parse <initializer> expression.
370       if (Tok.is(tok::identifier) &&
371           Tok.getIdentifierInfo()->isStr("initializer")) {
372         ConsumeToken();
373       } else {
374         Diag(Tok.getLocation(), diag::err_expected) << "'initializer'";
375         TPA.Commit();
376         IsCorrect = false;
377         break;
378       }
379       // Parse '('.
380       BalancedDelimiterTracker T(*this, tok::l_paren,
381                                  tok::annot_pragma_openmp_end);
382       IsCorrect =
383           !T.expectAndConsume(diag::err_expected_lparen_after, "initializer") &&
384           IsCorrect;
385       if (Tok.isNot(tok::annot_pragma_openmp_end)) {
386         ParseScope OMPDRScope(this, Scope::FnScope | Scope::DeclScope |
387                                         Scope::CompoundStmtScope |
388                                         Scope::OpenMPDirectiveScope);
389         // Parse expression.
390         VarDecl *OmpPrivParm =
391             Actions.ActOnOpenMPDeclareReductionInitializerStart(getCurScope(),
392                                                                 D);
393         // Check if initializer is omp_priv <init_expr> or something else.
394         if (Tok.is(tok::identifier) &&
395             Tok.getIdentifierInfo()->isStr("omp_priv")) {
396           ConsumeToken();
397           ParseOpenMPReductionInitializerForDecl(OmpPrivParm);
398         } else {
399           InitializerResult = Actions.ActOnFinishFullExpr(
400               ParseAssignmentExpression().get(), D->getLocation(),
401               /*DiscardedValue*/ false);
402         }
403         Actions.ActOnOpenMPDeclareReductionInitializerEnd(
404             D, InitializerResult.get(), OmpPrivParm);
405         if (InitializerResult.isInvalid() && Tok.isNot(tok::r_paren) &&
406             Tok.isNot(tok::annot_pragma_openmp_end)) {
407           TPA.Commit();
408           IsCorrect = false;
409           break;
410         }
411         IsCorrect =
412             !T.consumeClose() && IsCorrect && !InitializerResult.isInvalid();
413       }
414     }
415
416     ++I;
417     // Revert parsing if not the last type, otherwise accept it, we're done with
418     // parsing.
419     if (I != E)
420       TPA.Revert();
421     else
422       TPA.Commit();
423   }
424   return Actions.ActOnOpenMPDeclareReductionDirectiveEnd(getCurScope(), DRD,
425                                                          IsCorrect);
426 }
427
428 void Parser::ParseOpenMPReductionInitializerForDecl(VarDecl *OmpPrivParm) {
429   // Parse declarator '=' initializer.
430   // If a '==' or '+=' is found, suggest a fixit to '='.
431   if (isTokenEqualOrEqualTypo()) {
432     ConsumeToken();
433
434     if (Tok.is(tok::code_completion)) {
435       Actions.CodeCompleteInitializer(getCurScope(), OmpPrivParm);
436       Actions.FinalizeDeclaration(OmpPrivParm);
437       cutOffParsing();
438       return;
439     }
440
441     PreferredType.enterVariableInit(Tok.getLocation(), OmpPrivParm);
442     ExprResult Init = ParseInitializer();
443
444     if (Init.isInvalid()) {
445       SkipUntil(tok::r_paren, tok::annot_pragma_openmp_end, StopBeforeMatch);
446       Actions.ActOnInitializerError(OmpPrivParm);
447     } else {
448       Actions.AddInitializerToDecl(OmpPrivParm, Init.get(),
449                                    /*DirectInit=*/false);
450     }
451   } else if (Tok.is(tok::l_paren)) {
452     // Parse C++ direct initializer: '(' expression-list ')'
453     BalancedDelimiterTracker T(*this, tok::l_paren);
454     T.consumeOpen();
455
456     ExprVector Exprs;
457     CommaLocsTy CommaLocs;
458
459     SourceLocation LParLoc = T.getOpenLocation();
460     auto RunSignatureHelp = [this, OmpPrivParm, LParLoc, &Exprs]() {
461       QualType PreferredType = Actions.ProduceConstructorSignatureHelp(
462           getCurScope(), OmpPrivParm->getType()->getCanonicalTypeInternal(),
463           OmpPrivParm->getLocation(), Exprs, LParLoc);
464       CalledSignatureHelp = true;
465       return PreferredType;
466     };
467     if (ParseExpressionList(Exprs, CommaLocs, [&] {
468           PreferredType.enterFunctionArgument(Tok.getLocation(),
469                                               RunSignatureHelp);
470         })) {
471       if (PP.isCodeCompletionReached() && !CalledSignatureHelp)
472         RunSignatureHelp();
473       Actions.ActOnInitializerError(OmpPrivParm);
474       SkipUntil(tok::r_paren, tok::annot_pragma_openmp_end, StopBeforeMatch);
475     } else {
476       // Match the ')'.
477       SourceLocation RLoc = Tok.getLocation();
478       if (!T.consumeClose())
479         RLoc = T.getCloseLocation();
480
481       assert(!Exprs.empty() && Exprs.size() - 1 == CommaLocs.size() &&
482              "Unexpected number of commas!");
483
484       ExprResult Initializer =
485           Actions.ActOnParenListExpr(T.getOpenLocation(), RLoc, Exprs);
486       Actions.AddInitializerToDecl(OmpPrivParm, Initializer.get(),
487                                    /*DirectInit=*/true);
488     }
489   } else if (getLangOpts().CPlusPlus11 && Tok.is(tok::l_brace)) {
490     // Parse C++0x braced-init-list.
491     Diag(Tok, diag::warn_cxx98_compat_generalized_initializer_lists);
492
493     ExprResult Init(ParseBraceInitializer());
494
495     if (Init.isInvalid()) {
496       Actions.ActOnInitializerError(OmpPrivParm);
497     } else {
498       Actions.AddInitializerToDecl(OmpPrivParm, Init.get(),
499                                    /*DirectInit=*/true);
500     }
501   } else {
502     Actions.ActOnUninitializedDecl(OmpPrivParm);
503   }
504 }
505
506 /// Parses 'omp declare mapper' directive.
507 ///
508 ///       declare-mapper-directive:
509 ///         annot_pragma_openmp 'declare' 'mapper' '(' [<mapper-identifier> ':']
510 ///         <type> <var> ')' [<clause>[[,] <clause>] ... ]
511 ///         annot_pragma_openmp_end
512 /// <mapper-identifier> and <var> are base language identifiers.
513 ///
514 Parser::DeclGroupPtrTy
515 Parser::ParseOpenMPDeclareMapperDirective(AccessSpecifier AS) {
516   bool IsCorrect = true;
517   // Parse '('
518   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
519   if (T.expectAndConsume(diag::err_expected_lparen_after,
520                          getOpenMPDirectiveName(OMPD_declare_mapper).data())) {
521     SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
522     return DeclGroupPtrTy();
523   }
524
525   // Parse <mapper-identifier>
526   auto &DeclNames = Actions.getASTContext().DeclarationNames;
527   DeclarationName MapperId;
528   if (PP.LookAhead(0).is(tok::colon)) {
529     if (Tok.isNot(tok::identifier) && Tok.isNot(tok::kw_default)) {
530       Diag(Tok.getLocation(), diag::err_omp_mapper_illegal_identifier);
531       IsCorrect = false;
532     } else {
533       MapperId = DeclNames.getIdentifier(Tok.getIdentifierInfo());
534     }
535     ConsumeToken();
536     // Consume ':'.
537     ExpectAndConsume(tok::colon);
538   } else {
539     // If no mapper identifier is provided, its name is "default" by default
540     MapperId =
541         DeclNames.getIdentifier(&Actions.getASTContext().Idents.get("default"));
542   }
543
544   if (!IsCorrect && Tok.is(tok::annot_pragma_openmp_end))
545     return DeclGroupPtrTy();
546
547   // Parse <type> <var>
548   DeclarationName VName;
549   QualType MapperType;
550   SourceRange Range;
551   TypeResult ParsedType = parseOpenMPDeclareMapperVarDecl(Range, VName, AS);
552   if (ParsedType.isUsable())
553     MapperType =
554         Actions.ActOnOpenMPDeclareMapperType(Range.getBegin(), ParsedType);
555   if (MapperType.isNull())
556     IsCorrect = false;
557   if (!IsCorrect) {
558     SkipUntil(tok::annot_pragma_openmp_end, Parser::StopBeforeMatch);
559     return DeclGroupPtrTy();
560   }
561
562   // Consume ')'.
563   IsCorrect &= !T.consumeClose();
564   if (!IsCorrect) {
565     SkipUntil(tok::annot_pragma_openmp_end, Parser::StopBeforeMatch);
566     return DeclGroupPtrTy();
567   }
568
569   // Enter scope.
570   OMPDeclareMapperDecl *DMD = Actions.ActOnOpenMPDeclareMapperDirectiveStart(
571       getCurScope(), Actions.getCurLexicalContext(), MapperId, MapperType,
572       Range.getBegin(), VName, AS);
573   DeclarationNameInfo DirName;
574   SourceLocation Loc = Tok.getLocation();
575   unsigned ScopeFlags = Scope::FnScope | Scope::DeclScope |
576                         Scope::CompoundStmtScope | Scope::OpenMPDirectiveScope;
577   ParseScope OMPDirectiveScope(this, ScopeFlags);
578   Actions.StartOpenMPDSABlock(OMPD_declare_mapper, DirName, getCurScope(), Loc);
579
580   // Add the mapper variable declaration.
581   Actions.ActOnOpenMPDeclareMapperDirectiveVarDecl(
582       DMD, getCurScope(), MapperType, Range.getBegin(), VName);
583
584   // Parse map clauses.
585   SmallVector<OMPClause *, 6> Clauses;
586   while (Tok.isNot(tok::annot_pragma_openmp_end)) {
587     OpenMPClauseKind CKind = Tok.isAnnotation()
588                                  ? OMPC_unknown
589                                  : getOpenMPClauseKind(PP.getSpelling(Tok));
590     Actions.StartOpenMPClause(CKind);
591     OMPClause *Clause =
592         ParseOpenMPClause(OMPD_declare_mapper, CKind, Clauses.size() == 0);
593     if (Clause)
594       Clauses.push_back(Clause);
595     else
596       IsCorrect = false;
597     // Skip ',' if any.
598     if (Tok.is(tok::comma))
599       ConsumeToken();
600     Actions.EndOpenMPClause();
601   }
602   if (Clauses.empty()) {
603     Diag(Tok, diag::err_omp_expected_clause)
604         << getOpenMPDirectiveName(OMPD_declare_mapper);
605     IsCorrect = false;
606   }
607
608   // Exit scope.
609   Actions.EndOpenMPDSABlock(nullptr);
610   OMPDirectiveScope.Exit();
611
612   DeclGroupPtrTy DGP =
613       Actions.ActOnOpenMPDeclareMapperDirectiveEnd(DMD, getCurScope(), Clauses);
614   if (!IsCorrect)
615     return DeclGroupPtrTy();
616   return DGP;
617 }
618
619 TypeResult Parser::parseOpenMPDeclareMapperVarDecl(SourceRange &Range,
620                                                    DeclarationName &Name,
621                                                    AccessSpecifier AS) {
622   // Parse the common declaration-specifiers piece.
623   Parser::DeclSpecContext DSC = Parser::DeclSpecContext::DSC_type_specifier;
624   DeclSpec DS(AttrFactory);
625   ParseSpecifierQualifierList(DS, AS, DSC);
626
627   // Parse the declarator.
628   DeclaratorContext Context = DeclaratorContext::PrototypeContext;
629   Declarator DeclaratorInfo(DS, Context);
630   ParseDeclarator(DeclaratorInfo);
631   Range = DeclaratorInfo.getSourceRange();
632   if (DeclaratorInfo.getIdentifier() == nullptr) {
633     Diag(Tok.getLocation(), diag::err_omp_mapper_expected_declarator);
634     return true;
635   }
636   Name = Actions.GetNameForDeclarator(DeclaratorInfo).getName();
637
638   return Actions.ActOnOpenMPDeclareMapperVarDecl(getCurScope(), DeclaratorInfo);
639 }
640
641 namespace {
642 /// RAII that recreates function context for correct parsing of clauses of
643 /// 'declare simd' construct.
644 /// OpenMP, 2.8.2 declare simd Construct
645 /// The expressions appearing in the clauses of this directive are evaluated in
646 /// the scope of the arguments of the function declaration or definition.
647 class FNContextRAII final {
648   Parser &P;
649   Sema::CXXThisScopeRAII *ThisScope;
650   Parser::ParseScope *TempScope;
651   Parser::ParseScope *FnScope;
652   bool HasTemplateScope = false;
653   bool HasFunScope = false;
654   FNContextRAII() = delete;
655   FNContextRAII(const FNContextRAII &) = delete;
656   FNContextRAII &operator=(const FNContextRAII &) = delete;
657
658 public:
659   FNContextRAII(Parser &P, Parser::DeclGroupPtrTy Ptr) : P(P) {
660     Decl *D = *Ptr.get().begin();
661     NamedDecl *ND = dyn_cast<NamedDecl>(D);
662     RecordDecl *RD = dyn_cast_or_null<RecordDecl>(D->getDeclContext());
663     Sema &Actions = P.getActions();
664
665     // Allow 'this' within late-parsed attributes.
666     ThisScope = new Sema::CXXThisScopeRAII(Actions, RD, Qualifiers(),
667                                            ND && ND->isCXXInstanceMember());
668
669     // If the Decl is templatized, add template parameters to scope.
670     HasTemplateScope = D->isTemplateDecl();
671     TempScope =
672         new Parser::ParseScope(&P, Scope::TemplateParamScope, HasTemplateScope);
673     if (HasTemplateScope)
674       Actions.ActOnReenterTemplateScope(Actions.getCurScope(), D);
675
676     // If the Decl is on a function, add function parameters to the scope.
677     HasFunScope = D->isFunctionOrFunctionTemplate();
678     FnScope = new Parser::ParseScope(
679         &P, Scope::FnScope | Scope::DeclScope | Scope::CompoundStmtScope,
680         HasFunScope);
681     if (HasFunScope)
682       Actions.ActOnReenterFunctionContext(Actions.getCurScope(), D);
683   }
684   ~FNContextRAII() {
685     if (HasFunScope) {
686       P.getActions().ActOnExitFunctionContext();
687       FnScope->Exit(); // Pop scope, and remove Decls from IdResolver
688     }
689     if (HasTemplateScope)
690       TempScope->Exit();
691     delete FnScope;
692     delete TempScope;
693     delete ThisScope;
694   }
695 };
696 } // namespace
697
698 /// Parses clauses for 'declare simd' directive.
699 ///    clause:
700 ///      'inbranch' | 'notinbranch'
701 ///      'simdlen' '(' <expr> ')'
702 ///      { 'uniform' '(' <argument_list> ')' }
703 ///      { 'aligned '(' <argument_list> [ ':' <alignment> ] ')' }
704 ///      { 'linear '(' <argument_list> [ ':' <step> ] ')' }
705 static bool parseDeclareSimdClauses(
706     Parser &P, OMPDeclareSimdDeclAttr::BranchStateTy &BS, ExprResult &SimdLen,
707     SmallVectorImpl<Expr *> &Uniforms, SmallVectorImpl<Expr *> &Aligneds,
708     SmallVectorImpl<Expr *> &Alignments, SmallVectorImpl<Expr *> &Linears,
709     SmallVectorImpl<unsigned> &LinModifiers, SmallVectorImpl<Expr *> &Steps) {
710   SourceRange BSRange;
711   const Token &Tok = P.getCurToken();
712   bool IsError = false;
713   while (Tok.isNot(tok::annot_pragma_openmp_end)) {
714     if (Tok.isNot(tok::identifier))
715       break;
716     OMPDeclareSimdDeclAttr::BranchStateTy Out;
717     IdentifierInfo *II = Tok.getIdentifierInfo();
718     StringRef ClauseName = II->getName();
719     // Parse 'inranch|notinbranch' clauses.
720     if (OMPDeclareSimdDeclAttr::ConvertStrToBranchStateTy(ClauseName, Out)) {
721       if (BS != OMPDeclareSimdDeclAttr::BS_Undefined && BS != Out) {
722         P.Diag(Tok, diag::err_omp_declare_simd_inbranch_notinbranch)
723             << ClauseName
724             << OMPDeclareSimdDeclAttr::ConvertBranchStateTyToStr(BS) << BSRange;
725         IsError = true;
726       }
727       BS = Out;
728       BSRange = SourceRange(Tok.getLocation(), Tok.getEndLoc());
729       P.ConsumeToken();
730     } else if (ClauseName.equals("simdlen")) {
731       if (SimdLen.isUsable()) {
732         P.Diag(Tok, diag::err_omp_more_one_clause)
733             << getOpenMPDirectiveName(OMPD_declare_simd) << ClauseName << 0;
734         IsError = true;
735       }
736       P.ConsumeToken();
737       SourceLocation RLoc;
738       SimdLen = P.ParseOpenMPParensExpr(ClauseName, RLoc);
739       if (SimdLen.isInvalid())
740         IsError = true;
741     } else {
742       OpenMPClauseKind CKind = getOpenMPClauseKind(ClauseName);
743       if (CKind == OMPC_uniform || CKind == OMPC_aligned ||
744           CKind == OMPC_linear) {
745         Parser::OpenMPVarListDataTy Data;
746         SmallVectorImpl<Expr *> *Vars = &Uniforms;
747         if (CKind == OMPC_aligned) {
748           Vars = &Aligneds;
749         } else if (CKind == OMPC_linear) {
750           Data.ExtraModifier = OMPC_LINEAR_val;
751           Vars = &Linears;
752         }
753
754         P.ConsumeToken();
755         if (P.ParseOpenMPVarList(OMPD_declare_simd,
756                                  getOpenMPClauseKind(ClauseName), *Vars, Data))
757           IsError = true;
758         if (CKind == OMPC_aligned) {
759           Alignments.append(Aligneds.size() - Alignments.size(),
760                             Data.DepModOrTailExpr);
761         } else if (CKind == OMPC_linear) {
762           assert(0 <= Data.ExtraModifier &&
763                  Data.ExtraModifier <= OMPC_LINEAR_unknown &&
764                  "Unexpected linear modifier.");
765           if (P.getActions().CheckOpenMPLinearModifier(
766                   static_cast<OpenMPLinearClauseKind>(Data.ExtraModifier),
767                   Data.ExtraModifierLoc))
768             Data.ExtraModifier = OMPC_LINEAR_val;
769           LinModifiers.append(Linears.size() - LinModifiers.size(),
770                               Data.ExtraModifier);
771           Steps.append(Linears.size() - Steps.size(), Data.DepModOrTailExpr);
772         }
773       } else
774         // TODO: add parsing of other clauses.
775         break;
776     }
777     // Skip ',' if any.
778     if (Tok.is(tok::comma))
779       P.ConsumeToken();
780   }
781   return IsError;
782 }
783
784 /// Parse clauses for '#pragma omp declare simd'.
785 Parser::DeclGroupPtrTy
786 Parser::ParseOMPDeclareSimdClauses(Parser::DeclGroupPtrTy Ptr,
787                                    CachedTokens &Toks, SourceLocation Loc) {
788   PP.EnterToken(Tok, /*IsReinject*/ true);
789   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
790                       /*IsReinject*/ true);
791   // Consume the previously pushed token.
792   ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
793   ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
794
795   FNContextRAII FnContext(*this, Ptr);
796   OMPDeclareSimdDeclAttr::BranchStateTy BS =
797       OMPDeclareSimdDeclAttr::BS_Undefined;
798   ExprResult Simdlen;
799   SmallVector<Expr *, 4> Uniforms;
800   SmallVector<Expr *, 4> Aligneds;
801   SmallVector<Expr *, 4> Alignments;
802   SmallVector<Expr *, 4> Linears;
803   SmallVector<unsigned, 4> LinModifiers;
804   SmallVector<Expr *, 4> Steps;
805   bool IsError =
806       parseDeclareSimdClauses(*this, BS, Simdlen, Uniforms, Aligneds,
807                               Alignments, Linears, LinModifiers, Steps);
808   skipUntilPragmaOpenMPEnd(OMPD_declare_simd);
809   // Skip the last annot_pragma_openmp_end.
810   SourceLocation EndLoc = ConsumeAnnotationToken();
811   if (IsError)
812     return Ptr;
813   return Actions.ActOnOpenMPDeclareSimdDirective(
814       Ptr, BS, Simdlen.get(), Uniforms, Aligneds, Alignments, Linears,
815       LinModifiers, Steps, SourceRange(Loc, EndLoc));
816 }
817
818 namespace {
819 /// Constant used in the diagnostics to distinguish the levels in an OpenMP
820 /// contexts: selector-set={selector(trait, ...), ...}, ....
821 enum OMPContextLvl {
822   CONTEXT_SELECTOR_SET_LVL = 0,
823   CONTEXT_SELECTOR_LVL = 1,
824   CONTEXT_TRAIT_LVL = 2,
825 };
826
827 static StringRef stringLiteralParser(Parser &P) {
828   ExprResult Res = P.ParseStringLiteralExpression(true);
829   return Res.isUsable() ? Res.getAs<StringLiteral>()->getString() : "";
830 }
831
832 static StringRef getNameFromIdOrString(Parser &P, Token &Tok,
833                                        OMPContextLvl Lvl) {
834   if (Tok.is(tok::identifier)) {
835     llvm::SmallString<16> Buffer;
836     StringRef Name = P.getPreprocessor().getSpelling(Tok, Buffer);
837     (void)P.ConsumeToken();
838     return Name;
839   }
840
841   if (tok::isStringLiteral(Tok.getKind()))
842     return stringLiteralParser(P);
843
844   P.Diag(Tok.getLocation(),
845          diag::warn_omp_declare_variant_string_literal_or_identifier)
846       << Lvl;
847   return "";
848 }
849
850 static bool checkForDuplicates(Parser &P, StringRef Name,
851                                SourceLocation NameLoc,
852                                llvm::StringMap<SourceLocation> &Seen,
853                                OMPContextLvl Lvl) {
854   auto Res = Seen.try_emplace(Name, NameLoc);
855   if (Res.second)
856     return false;
857
858   // Each trait-set-selector-name, trait-selector-name and trait-name can
859   // only be specified once.
860   P.Diag(NameLoc, diag::warn_omp_declare_variant_ctx_mutiple_use)
861       << Lvl << Name;
862   P.Diag(Res.first->getValue(), diag::note_omp_declare_variant_ctx_used_here)
863       << Lvl << Name;
864   return true;
865 }
866 } // namespace
867
868 void Parser::parseOMPTraitPropertyKind(
869     OMPTraitProperty &TIProperty, llvm::omp::TraitSet Set,
870     llvm::omp::TraitSelector Selector, llvm::StringMap<SourceLocation> &Seen) {
871   TIProperty.Kind = TraitProperty::invalid;
872
873   SourceLocation NameLoc = Tok.getLocation();
874   StringRef Name =
875       getNameFromIdOrString(*this, Tok, CONTEXT_TRAIT_LVL);
876   if (Name.empty()) {
877     Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_options)
878         << CONTEXT_TRAIT_LVL << listOpenMPContextTraitProperties(Set, Selector);
879     return;
880   }
881
882   TIProperty.Kind = getOpenMPContextTraitPropertyKind(Set, Name);
883   if (TIProperty.Kind != TraitProperty::invalid) {
884     if (checkForDuplicates(*this, Name, NameLoc, Seen, CONTEXT_TRAIT_LVL))
885       TIProperty.Kind = TraitProperty::invalid;
886     return;
887   }
888
889   // It follows diagnosis and helping notes.
890   // FIXME: We should move the diagnosis string generation into libFrontend.
891   Diag(NameLoc, diag::warn_omp_declare_variant_ctx_not_a_property)
892       << Name << getOpenMPContextTraitSelectorName(Selector)
893       << getOpenMPContextTraitSetName(Set);
894
895   TraitSet SetForName = getOpenMPContextTraitSetKind(Name);
896   if (SetForName != TraitSet::invalid) {
897     Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a)
898         << Name << CONTEXT_SELECTOR_SET_LVL << CONTEXT_TRAIT_LVL;
899     Diag(NameLoc, diag::note_omp_declare_variant_ctx_try)
900         << Name << "<selector-name>"
901         << "(<property-name>)";
902     return;
903   }
904   TraitSelector SelectorForName = getOpenMPContextTraitSelectorKind(Name);
905   if (SelectorForName != TraitSelector::invalid) {
906     Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a)
907         << Name << CONTEXT_SELECTOR_LVL << CONTEXT_TRAIT_LVL;
908     bool AllowsTraitScore = false;
909     bool RequiresProperty = false;
910     isValidTraitSelectorForTraitSet(
911         SelectorForName, getOpenMPContextTraitSetForSelector(SelectorForName),
912         AllowsTraitScore, RequiresProperty);
913     Diag(NameLoc, diag::note_omp_declare_variant_ctx_try)
914         << getOpenMPContextTraitSetName(
915                getOpenMPContextTraitSetForSelector(SelectorForName))
916         << Name << (RequiresProperty ? "(<property-name>)" : "");
917     return;
918   }
919   for (const auto &PotentialSet :
920        {TraitSet::construct, TraitSet::user, TraitSet::implementation,
921         TraitSet::device}) {
922     TraitProperty PropertyForName =
923         getOpenMPContextTraitPropertyKind(PotentialSet, Name);
924     if (PropertyForName == TraitProperty::invalid)
925       continue;
926     Diag(NameLoc, diag::note_omp_declare_variant_ctx_try)
927         << getOpenMPContextTraitSetName(
928                getOpenMPContextTraitSetForProperty(PropertyForName))
929         << getOpenMPContextTraitSelectorName(
930                getOpenMPContextTraitSelectorForProperty(PropertyForName))
931         << ("(" + Name + ")").str();
932     return;
933   }
934   Diag(NameLoc, diag::note_omp_declare_variant_ctx_options)
935       << CONTEXT_TRAIT_LVL << listOpenMPContextTraitProperties(Set, Selector);
936 }
937
938 void Parser::parseOMPContextProperty(OMPTraitSelector &TISelector,
939                                      llvm::omp::TraitSet Set,
940                                      llvm::StringMap<SourceLocation> &Seen) {
941   assert(TISelector.Kind != TraitSelector::user_condition &&
942          "User conditions are special properties not handled here!");
943
944   SourceLocation PropertyLoc = Tok.getLocation();
945   OMPTraitProperty TIProperty;
946   parseOMPTraitPropertyKind(TIProperty, Set, TISelector.Kind, Seen);
947
948   // If we have an invalid property here we already issued a warning.
949   if (TIProperty.Kind == TraitProperty::invalid) {
950     if (PropertyLoc != Tok.getLocation())
951       Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_continue_here)
952           << CONTEXT_TRAIT_LVL;
953     return;
954   }
955
956   if (isValidTraitPropertyForTraitSetAndSelector(TIProperty.Kind,
957                                                  TISelector.Kind, Set)) {
958     // If we make it here the property, selector, set, score, condition, ... are
959     // all valid (or have been corrected). Thus we can record the property.
960     TISelector.Properties.push_back(TIProperty);
961     return;
962   }
963
964   Diag(PropertyLoc, diag::warn_omp_ctx_incompatible_property_for_selector)
965       << getOpenMPContextTraitPropertyName(TIProperty.Kind)
966       << getOpenMPContextTraitSelectorName(TISelector.Kind)
967       << getOpenMPContextTraitSetName(Set);
968   Diag(PropertyLoc, diag::note_omp_ctx_compatible_set_and_selector_for_property)
969       << getOpenMPContextTraitPropertyName(TIProperty.Kind)
970       << getOpenMPContextTraitSelectorName(
971              getOpenMPContextTraitSelectorForProperty(TIProperty.Kind))
972       << getOpenMPContextTraitSetName(
973              getOpenMPContextTraitSetForProperty(TIProperty.Kind));
974   Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_continue_here)
975       << CONTEXT_TRAIT_LVL;
976 }
977
978 void Parser::parseOMPTraitSelectorKind(
979     OMPTraitSelector &TISelector, llvm::omp::TraitSet Set,
980     llvm::StringMap<SourceLocation> &Seen) {
981   TISelector.Kind = TraitSelector::invalid;
982
983   SourceLocation NameLoc = Tok.getLocation();
984   StringRef Name = getNameFromIdOrString(*this, Tok, CONTEXT_SELECTOR_LVL
985                     );
986   if (Name.empty()) {
987     Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_options)
988         << CONTEXT_SELECTOR_LVL << listOpenMPContextTraitSelectors(Set);
989     return;
990   }
991
992   TISelector.Kind = getOpenMPContextTraitSelectorKind(Name);
993   if (TISelector.Kind != TraitSelector::invalid) {
994     if (checkForDuplicates(*this, Name, NameLoc, Seen, CONTEXT_SELECTOR_LVL))
995       TISelector.Kind = TraitSelector::invalid;
996     return;
997   }
998
999   // It follows diagnosis and helping notes.
1000   Diag(NameLoc, diag::warn_omp_declare_variant_ctx_not_a_selector)
1001       << Name << getOpenMPContextTraitSetName(Set);
1002
1003   TraitSet SetForName = getOpenMPContextTraitSetKind(Name);
1004   if (SetForName != TraitSet::invalid) {
1005     Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a)
1006         << Name << CONTEXT_SELECTOR_SET_LVL << CONTEXT_SELECTOR_LVL;
1007     Diag(NameLoc, diag::note_omp_declare_variant_ctx_try)
1008         << Name << "<selector-name>"
1009         << "<property-name>";
1010     return;
1011   }
1012   for (const auto &PotentialSet :
1013        {TraitSet::construct, TraitSet::user, TraitSet::implementation,
1014         TraitSet::device}) {
1015     TraitProperty PropertyForName =
1016         getOpenMPContextTraitPropertyKind(PotentialSet, Name);
1017     if (PropertyForName == TraitProperty::invalid)
1018       continue;
1019     Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a)
1020         << Name << CONTEXT_TRAIT_LVL << CONTEXT_SELECTOR_LVL;
1021     Diag(NameLoc, diag::note_omp_declare_variant_ctx_try)
1022         << getOpenMPContextTraitSetName(
1023                getOpenMPContextTraitSetForProperty(PropertyForName))
1024         << getOpenMPContextTraitSelectorName(
1025                getOpenMPContextTraitSelectorForProperty(PropertyForName))
1026         << ("(" + Name + ")").str();
1027     return;
1028   }
1029   Diag(NameLoc, diag::note_omp_declare_variant_ctx_options)
1030       << CONTEXT_SELECTOR_LVL << listOpenMPContextTraitSelectors(Set);
1031 }
1032
1033 /// Parse optional 'score' '(' <expr> ')' ':'.
1034 static ExprResult parseContextScore(Parser &P) {
1035   ExprResult ScoreExpr;
1036   llvm::SmallString<16> Buffer;
1037   StringRef SelectorName =
1038       P.getPreprocessor().getSpelling(P.getCurToken(), Buffer);
1039   if (!SelectorName.equals("score"))
1040     return ScoreExpr;
1041   (void)P.ConsumeToken();
1042   SourceLocation RLoc;
1043   ScoreExpr = P.ParseOpenMPParensExpr(SelectorName, RLoc);
1044   // Parse ':'
1045   if (P.getCurToken().is(tok::colon))
1046     (void)P.ConsumeAnyToken();
1047   else
1048     P.Diag(P.getCurToken(), diag::warn_omp_declare_variant_expected)
1049         << "':'"
1050         << "score expression";
1051   return ScoreExpr;
1052 }
1053
1054 /// Parses an OpenMP context selector.
1055 ///
1056 /// <trait-selector-name> ['('[<trait-score>] <trait-property> [, <t-p>]* ')']
1057 void Parser::parseOMPContextSelector(
1058     OMPTraitSelector &TISelector, llvm::omp::TraitSet Set,
1059     llvm::StringMap<SourceLocation> &SeenSelectors) {
1060   unsigned short OuterPC = ParenCount;
1061
1062   // If anything went wrong we issue an error or warning and then skip the rest
1063   // of the selector. However, commas are ambiguous so we look for the nesting
1064   // of parentheses here as well.
1065   auto FinishSelector = [OuterPC, this]() -> void {
1066     bool Done = false;
1067     while (!Done) {
1068       while (!SkipUntil({tok::r_brace, tok::r_paren, tok::comma,
1069                          tok::annot_pragma_openmp_end},
1070                         StopBeforeMatch))
1071         ;
1072       if (Tok.is(tok::r_paren) && OuterPC > ParenCount)
1073         (void)ConsumeParen();
1074       if (OuterPC <= ParenCount) {
1075         Done = true;
1076         break;
1077       }
1078       if (!Tok.is(tok::comma) && !Tok.is(tok::r_paren)) {
1079         Done = true;
1080         break;
1081       }
1082       (void)ConsumeAnyToken();
1083     }
1084     Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_continue_here)
1085         << CONTEXT_SELECTOR_LVL;
1086   };
1087
1088   SourceLocation SelectorLoc = Tok.getLocation();
1089   parseOMPTraitSelectorKind(TISelector, Set, SeenSelectors);
1090   if (TISelector.Kind == TraitSelector::invalid)
1091     return FinishSelector();
1092
1093   bool AllowsTraitScore = false;
1094   bool RequiresProperty = false;
1095   if (!isValidTraitSelectorForTraitSet(TISelector.Kind, Set, AllowsTraitScore,
1096                                        RequiresProperty)) {
1097     Diag(SelectorLoc, diag::warn_omp_ctx_incompatible_selector_for_set)
1098         << getOpenMPContextTraitSelectorName(TISelector.Kind)
1099         << getOpenMPContextTraitSetName(Set);
1100     Diag(SelectorLoc, diag::note_omp_ctx_compatible_set_for_selector)
1101         << getOpenMPContextTraitSelectorName(TISelector.Kind)
1102         << getOpenMPContextTraitSetName(
1103                getOpenMPContextTraitSetForSelector(TISelector.Kind))
1104         << RequiresProperty;
1105     return FinishSelector();
1106   }
1107
1108   if (!RequiresProperty) {
1109     TISelector.Properties.push_back(
1110         {getOpenMPContextTraitPropertyForSelector(TISelector.Kind)});
1111     return;
1112   }
1113
1114   if (!Tok.is(tok::l_paren)) {
1115     Diag(SelectorLoc, diag::warn_omp_ctx_selector_without_properties)
1116         << getOpenMPContextTraitSelectorName(TISelector.Kind)
1117         << getOpenMPContextTraitSetName(Set);
1118     return FinishSelector();
1119   }
1120
1121   if (TISelector.Kind == TraitSelector::user_condition) {
1122     SourceLocation RLoc;
1123     ExprResult Condition = ParseOpenMPParensExpr("user condition", RLoc);
1124     if (!Condition.isUsable())
1125       return FinishSelector();
1126     TISelector.ScoreOrCondition = Condition.get();
1127     TISelector.Properties.push_back({TraitProperty::user_condition_unknown});
1128     return;
1129   }
1130
1131   BalancedDelimiterTracker BDT(*this, tok::l_paren,
1132                                tok::annot_pragma_openmp_end);
1133   // Parse '('.
1134   (void)BDT.consumeOpen();
1135
1136   SourceLocation ScoreLoc = Tok.getLocation();
1137   ExprResult Score = parseContextScore(*this);
1138
1139   if (!AllowsTraitScore && !Score.isUnset()) {
1140     if (Score.isUsable()) {
1141       Diag(ScoreLoc, diag::warn_omp_ctx_incompatible_score_for_property)
1142           << getOpenMPContextTraitSelectorName(TISelector.Kind)
1143           << getOpenMPContextTraitSetName(Set) << Score.get();
1144     } else {
1145       Diag(ScoreLoc, diag::warn_omp_ctx_incompatible_score_for_property)
1146           << getOpenMPContextTraitSelectorName(TISelector.Kind)
1147           << getOpenMPContextTraitSetName(Set) << "<invalid>";
1148     }
1149     Score = ExprResult();
1150   }
1151
1152   if (Score.isUsable())
1153     TISelector.ScoreOrCondition = Score.get();
1154
1155   llvm::StringMap<SourceLocation> SeenProperties;
1156   do {
1157     parseOMPContextProperty(TISelector, Set, SeenProperties);
1158   } while (TryConsumeToken(tok::comma));
1159
1160   // Parse ')'.
1161   BDT.consumeClose();
1162 }
1163
1164 void Parser::parseOMPTraitSetKind(OMPTraitSet &TISet,
1165                                   llvm::StringMap<SourceLocation> &Seen) {
1166   TISet.Kind = TraitSet::invalid;
1167
1168   SourceLocation NameLoc = Tok.getLocation();
1169   StringRef Name = getNameFromIdOrString(*this, Tok, CONTEXT_SELECTOR_SET_LVL
1170                    );
1171   if (Name.empty()) {
1172     Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_options)
1173         << CONTEXT_SELECTOR_SET_LVL << listOpenMPContextTraitSets();
1174     return;
1175   }
1176
1177   TISet.Kind = getOpenMPContextTraitSetKind(Name);
1178   if (TISet.Kind != TraitSet::invalid) {
1179     if (checkForDuplicates(*this, Name, NameLoc, Seen,
1180                            CONTEXT_SELECTOR_SET_LVL))
1181       TISet.Kind = TraitSet::invalid;
1182     return;
1183   }
1184
1185   // It follows diagnosis and helping notes.
1186   Diag(NameLoc, diag::warn_omp_declare_variant_ctx_not_a_set) << Name;
1187
1188   TraitSelector SelectorForName = getOpenMPContextTraitSelectorKind(Name);
1189   if (SelectorForName != TraitSelector::invalid) {
1190     Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a)
1191         << Name << CONTEXT_SELECTOR_LVL << CONTEXT_SELECTOR_SET_LVL;
1192     bool AllowsTraitScore = false;
1193     bool RequiresProperty = false;
1194     isValidTraitSelectorForTraitSet(
1195         SelectorForName, getOpenMPContextTraitSetForSelector(SelectorForName),
1196         AllowsTraitScore, RequiresProperty);
1197     Diag(NameLoc, diag::note_omp_declare_variant_ctx_try)
1198         << getOpenMPContextTraitSetName(
1199                getOpenMPContextTraitSetForSelector(SelectorForName))
1200         << Name << (RequiresProperty ? "(<property-name>)" : "");
1201     return;
1202   }
1203   for (const auto &PotentialSet :
1204        {TraitSet::construct, TraitSet::user, TraitSet::implementation,
1205         TraitSet::device}) {
1206     TraitProperty PropertyForName =
1207         getOpenMPContextTraitPropertyKind(PotentialSet, Name);
1208     if (PropertyForName == TraitProperty::invalid)
1209       continue;
1210     Diag(NameLoc, diag::note_omp_declare_variant_ctx_is_a)
1211         << Name << CONTEXT_TRAIT_LVL << CONTEXT_SELECTOR_SET_LVL;
1212     Diag(NameLoc, diag::note_omp_declare_variant_ctx_try)
1213         << getOpenMPContextTraitSetName(
1214                getOpenMPContextTraitSetForProperty(PropertyForName))
1215         << getOpenMPContextTraitSelectorName(
1216                getOpenMPContextTraitSelectorForProperty(PropertyForName))
1217         << ("(" + Name + ")").str();
1218     return;
1219   }
1220   Diag(NameLoc, diag::note_omp_declare_variant_ctx_options)
1221       << CONTEXT_SELECTOR_SET_LVL << listOpenMPContextTraitSets();
1222 }
1223
1224 /// Parses an OpenMP context selector set.
1225 ///
1226 /// <trait-set-selector-name> '=' '{' <trait-selector> [, <trait-selector>]* '}'
1227 void Parser::parseOMPContextSelectorSet(
1228     OMPTraitSet &TISet,
1229     llvm::StringMap<SourceLocation> &SeenSets) {
1230   auto OuterBC = BraceCount;
1231
1232   // If anything went wrong we issue an error or warning and then skip the rest
1233   // of the set. However, commas are ambiguous so we look for the nesting
1234   // of braces here as well.
1235   auto FinishSelectorSet = [this, OuterBC]() -> void {
1236     bool Done = false;
1237     while (!Done) {
1238       while (!SkipUntil({tok::comma, tok::r_brace, tok::r_paren,
1239                          tok::annot_pragma_openmp_end},
1240                         StopBeforeMatch))
1241         ;
1242       if (Tok.is(tok::r_brace) && OuterBC > BraceCount)
1243         (void)ConsumeBrace();
1244       if (OuterBC <= BraceCount) {
1245         Done = true;
1246         break;
1247       }
1248       if (!Tok.is(tok::comma) && !Tok.is(tok::r_brace)) {
1249         Done = true;
1250         break;
1251       }
1252       (void)ConsumeAnyToken();
1253     }
1254     Diag(Tok.getLocation(), diag::note_omp_declare_variant_ctx_continue_here)
1255         << CONTEXT_SELECTOR_SET_LVL;
1256   };
1257
1258   parseOMPTraitSetKind(TISet, SeenSets);
1259   if (TISet.Kind == TraitSet::invalid)
1260     return FinishSelectorSet();
1261
1262   // Parse '='.
1263   if (!TryConsumeToken(tok::equal))
1264     Diag(Tok.getLocation(), diag::warn_omp_declare_variant_expected)
1265         << "="
1266         << ("context set name \"" + getOpenMPContextTraitSetName(TISet.Kind) +
1267             "\"")
1268                .str();
1269
1270   // Parse '{'.
1271   if (Tok.is(tok::l_brace)) {
1272     (void)ConsumeBrace();
1273   } else {
1274     Diag(Tok.getLocation(), diag::warn_omp_declare_variant_expected)
1275         << "{"
1276         << ("'=' that follows the context set name \"" +
1277             getOpenMPContextTraitSetName(TISet.Kind) + "\"")
1278                .str();
1279   }
1280
1281   llvm::StringMap<SourceLocation> SeenSelectors;
1282   do {
1283     OMPTraitSelector TISelector;
1284     parseOMPContextSelector(TISelector, TISet.Kind, SeenSelectors);
1285     if (TISelector.Kind != TraitSelector::invalid &&
1286         !TISelector.Properties.empty())
1287       TISet.Selectors.push_back(TISelector);
1288   } while (TryConsumeToken(tok::comma));
1289
1290   // Parse '}'.
1291   if (Tok.is(tok::r_brace)) {
1292     (void)ConsumeBrace();
1293   } else {
1294     Diag(Tok.getLocation(), diag::warn_omp_declare_variant_expected)
1295         << "}"
1296         << ("context selectors for the context set \"" +
1297             getOpenMPContextTraitSetName(TISet.Kind) + "\"")
1298                .str();
1299   }
1300 }
1301
1302 /// Parse OpenMP context selectors:
1303 ///
1304 /// <trait-set-selector> [, <trait-set-selector>]*
1305 bool Parser::parseOMPContextSelectors(SourceLocation Loc, OMPTraitInfo& TI) {
1306   llvm::StringMap<SourceLocation> SeenSets;
1307   do {
1308     OMPTraitSet TISet;
1309     parseOMPContextSelectorSet(TISet, SeenSets);
1310     if (TISet.Kind != TraitSet::invalid && !TISet.Selectors.empty())
1311       TI.Sets.push_back(TISet);
1312   } while (TryConsumeToken(tok::comma));
1313
1314   return false;
1315 }
1316
1317 /// Parse clauses for '#pragma omp declare variant ( variant-func-id ) clause'.
1318 void Parser::ParseOMPDeclareVariantClauses(Parser::DeclGroupPtrTy Ptr,
1319                                            CachedTokens &Toks,
1320                                            SourceLocation Loc) {
1321   PP.EnterToken(Tok, /*IsReinject*/ true);
1322   PP.EnterTokenStream(Toks, /*DisableMacroExpansion=*/true,
1323                       /*IsReinject*/ true);
1324   // Consume the previously pushed token.
1325   ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
1326   ConsumeAnyToken(/*ConsumeCodeCompletionTok=*/true);
1327
1328   FNContextRAII FnContext(*this, Ptr);
1329   // Parse function declaration id.
1330   SourceLocation RLoc;
1331   // Parse with IsAddressOfOperand set to true to parse methods as DeclRefExprs
1332   // instead of MemberExprs.
1333   ExprResult AssociatedFunction;
1334   {
1335     // Do not mark function as is used to prevent its emission if this is the
1336     // only place where it is used.
1337     EnterExpressionEvaluationContext Unevaluated(
1338         Actions, Sema::ExpressionEvaluationContext::Unevaluated);
1339     AssociatedFunction = ParseOpenMPParensExpr(
1340         getOpenMPDirectiveName(OMPD_declare_variant), RLoc,
1341         /*IsAddressOfOperand=*/true);
1342   }
1343   if (!AssociatedFunction.isUsable()) {
1344     if (!Tok.is(tok::annot_pragma_openmp_end))
1345       while (!SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch))
1346         ;
1347     // Skip the last annot_pragma_openmp_end.
1348     (void)ConsumeAnnotationToken();
1349     return;
1350   }
1351
1352   OMPTraitInfo &TI = Actions.getASTContext().getNewOMPTraitInfo();
1353   if (parseOMPDeclareVariantMatchClause(Loc, TI))
1354     return;
1355
1356   Optional<std::pair<FunctionDecl *, Expr *>> DeclVarData =
1357       Actions.checkOpenMPDeclareVariantFunction(
1358           Ptr, AssociatedFunction.get(), TI,
1359           SourceRange(Loc, Tok.getLocation()));
1360
1361   // Skip last tokens.
1362   while (Tok.isNot(tok::annot_pragma_openmp_end))
1363     ConsumeAnyToken();
1364   if (DeclVarData && !TI.Sets.empty())
1365     Actions.ActOnOpenMPDeclareVariantDirective(
1366         DeclVarData->first, DeclVarData->second, TI,
1367         SourceRange(Loc, Tok.getLocation()));
1368
1369   // Skip the last annot_pragma_openmp_end.
1370   (void)ConsumeAnnotationToken();
1371 }
1372
1373 bool Parser::parseOMPDeclareVariantMatchClause(SourceLocation Loc,
1374                                                OMPTraitInfo &TI) {
1375   // Parse 'match'.
1376   OpenMPClauseKind CKind = Tok.isAnnotation()
1377                                ? OMPC_unknown
1378                                : getOpenMPClauseKind(PP.getSpelling(Tok));
1379   if (CKind != OMPC_match) {
1380     Diag(Tok.getLocation(), diag::err_omp_declare_variant_wrong_clause)
1381         << getOpenMPClauseName(OMPC_match);
1382     while (!SkipUntil(tok::annot_pragma_openmp_end, Parser::StopBeforeMatch))
1383       ;
1384     // Skip the last annot_pragma_openmp_end.
1385     (void)ConsumeAnnotationToken();
1386     return true;
1387   }
1388   (void)ConsumeToken();
1389   // Parse '('.
1390   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
1391   if (T.expectAndConsume(diag::err_expected_lparen_after,
1392                          getOpenMPClauseName(OMPC_match))) {
1393     while (!SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch))
1394       ;
1395     // Skip the last annot_pragma_openmp_end.
1396     (void)ConsumeAnnotationToken();
1397     return true;
1398   }
1399
1400   // Parse inner context selectors.
1401   parseOMPContextSelectors(Loc, TI);
1402
1403   // Parse ')'
1404   (void)T.consumeClose();
1405   return false;
1406 }
1407
1408 /// Parsing of simple OpenMP clauses like 'default' or 'proc_bind'.
1409 ///
1410 ///    default-clause:
1411 ///         'default' '(' 'none' | 'shared' ')
1412 ///
1413 ///    proc_bind-clause:
1414 ///         'proc_bind' '(' 'master' | 'close' | 'spread' ')
1415 ///
1416 ///    device_type-clause:
1417 ///         'device_type' '(' 'host' | 'nohost' | 'any' )'
1418 namespace {
1419   struct SimpleClauseData {
1420     unsigned Type;
1421     SourceLocation Loc;
1422     SourceLocation LOpen;
1423     SourceLocation TypeLoc;
1424     SourceLocation RLoc;
1425     SimpleClauseData(unsigned Type, SourceLocation Loc, SourceLocation LOpen,
1426                      SourceLocation TypeLoc, SourceLocation RLoc)
1427         : Type(Type), Loc(Loc), LOpen(LOpen), TypeLoc(TypeLoc), RLoc(RLoc) {}
1428   };
1429 } // anonymous namespace
1430
1431 static Optional<SimpleClauseData>
1432 parseOpenMPSimpleClause(Parser &P, OpenMPClauseKind Kind) {
1433   const Token &Tok = P.getCurToken();
1434   SourceLocation Loc = Tok.getLocation();
1435   SourceLocation LOpen = P.ConsumeToken();
1436   // Parse '('.
1437   BalancedDelimiterTracker T(P, tok::l_paren, tok::annot_pragma_openmp_end);
1438   if (T.expectAndConsume(diag::err_expected_lparen_after,
1439                          getOpenMPClauseName(Kind)))
1440     return llvm::None;
1441
1442   unsigned Type = getOpenMPSimpleClauseType(
1443       Kind, Tok.isAnnotation() ? "" : P.getPreprocessor().getSpelling(Tok));
1444   SourceLocation TypeLoc = Tok.getLocation();
1445   if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
1446       Tok.isNot(tok::annot_pragma_openmp_end))
1447     P.ConsumeAnyToken();
1448
1449   // Parse ')'.
1450   SourceLocation RLoc = Tok.getLocation();
1451   if (!T.consumeClose())
1452     RLoc = T.getCloseLocation();
1453
1454   return SimpleClauseData(Type, Loc, LOpen, TypeLoc, RLoc);
1455 }
1456
1457 Parser::DeclGroupPtrTy Parser::ParseOMPDeclareTargetClauses() {
1458   // OpenMP 4.5 syntax with list of entities.
1459   Sema::NamedDeclSetType SameDirectiveDecls;
1460   SmallVector<std::tuple<OMPDeclareTargetDeclAttr::MapTypeTy, SourceLocation,
1461                          NamedDecl *>,
1462               4>
1463       DeclareTargetDecls;
1464   OMPDeclareTargetDeclAttr::DevTypeTy DT = OMPDeclareTargetDeclAttr::DT_Any;
1465   SourceLocation DeviceTypeLoc;
1466   while (Tok.isNot(tok::annot_pragma_openmp_end)) {
1467     OMPDeclareTargetDeclAttr::MapTypeTy MT = OMPDeclareTargetDeclAttr::MT_To;
1468     if (Tok.is(tok::identifier)) {
1469       IdentifierInfo *II = Tok.getIdentifierInfo();
1470       StringRef ClauseName = II->getName();
1471       bool IsDeviceTypeClause =
1472           getLangOpts().OpenMP >= 50 &&
1473           getOpenMPClauseKind(ClauseName) == OMPC_device_type;
1474       // Parse 'to|link|device_type' clauses.
1475       if (!OMPDeclareTargetDeclAttr::ConvertStrToMapTypeTy(ClauseName, MT) &&
1476           !IsDeviceTypeClause) {
1477         Diag(Tok, diag::err_omp_declare_target_unexpected_clause)
1478             << ClauseName << (getLangOpts().OpenMP >= 50 ? 1 : 0);
1479         break;
1480       }
1481       // Parse 'device_type' clause and go to next clause if any.
1482       if (IsDeviceTypeClause) {
1483         Optional<SimpleClauseData> DevTypeData =
1484             parseOpenMPSimpleClause(*this, OMPC_device_type);
1485         if (DevTypeData.hasValue()) {
1486           if (DeviceTypeLoc.isValid()) {
1487             // We already saw another device_type clause, diagnose it.
1488             Diag(DevTypeData.getValue().Loc,
1489                  diag::warn_omp_more_one_device_type_clause);
1490           }
1491           switch(static_cast<OpenMPDeviceType>(DevTypeData.getValue().Type)) {
1492           case OMPC_DEVICE_TYPE_any:
1493             DT = OMPDeclareTargetDeclAttr::DT_Any;
1494             break;
1495           case OMPC_DEVICE_TYPE_host:
1496             DT = OMPDeclareTargetDeclAttr::DT_Host;
1497             break;
1498           case OMPC_DEVICE_TYPE_nohost:
1499             DT = OMPDeclareTargetDeclAttr::DT_NoHost;
1500             break;
1501           case OMPC_DEVICE_TYPE_unknown:
1502             llvm_unreachable("Unexpected device_type");
1503           }
1504           DeviceTypeLoc = DevTypeData.getValue().Loc;
1505         }
1506         continue;
1507       }
1508       ConsumeToken();
1509     }
1510     auto &&Callback = [this, MT, &DeclareTargetDecls, &SameDirectiveDecls](
1511                           CXXScopeSpec &SS, DeclarationNameInfo NameInfo) {
1512       NamedDecl *ND = Actions.lookupOpenMPDeclareTargetName(
1513           getCurScope(), SS, NameInfo, SameDirectiveDecls);
1514       if (ND)
1515         DeclareTargetDecls.emplace_back(MT, NameInfo.getLoc(), ND);
1516     };
1517     if (ParseOpenMPSimpleVarList(OMPD_declare_target, Callback,
1518                                  /*AllowScopeSpecifier=*/true))
1519       break;
1520
1521     // Consume optional ','.
1522     if (Tok.is(tok::comma))
1523       ConsumeToken();
1524   }
1525   SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
1526   ConsumeAnyToken();
1527   for (auto &MTLocDecl : DeclareTargetDecls) {
1528     OMPDeclareTargetDeclAttr::MapTypeTy MT;
1529     SourceLocation Loc;
1530     NamedDecl *ND;
1531     std::tie(MT, Loc, ND) = MTLocDecl;
1532     // device_type clause is applied only to functions.
1533     Actions.ActOnOpenMPDeclareTargetName(
1534         ND, Loc, MT, isa<VarDecl>(ND) ? OMPDeclareTargetDeclAttr::DT_Any : DT);
1535   }
1536   SmallVector<Decl *, 4> Decls(SameDirectiveDecls.begin(),
1537                                SameDirectiveDecls.end());
1538   if (Decls.empty())
1539     return DeclGroupPtrTy();
1540   return Actions.BuildDeclaratorGroup(Decls);
1541 }
1542
1543 void Parser::skipUntilPragmaOpenMPEnd(OpenMPDirectiveKind DKind) {
1544   // The last seen token is annot_pragma_openmp_end - need to check for
1545   // extra tokens.
1546   if (Tok.is(tok::annot_pragma_openmp_end))
1547     return;
1548
1549   Diag(Tok, diag::warn_omp_extra_tokens_at_eol)
1550       << getOpenMPDirectiveName(DKind);
1551   while (Tok.isNot(tok::annot_pragma_openmp_end))
1552     ConsumeAnyToken();
1553 }
1554
1555 void Parser::parseOMPEndDirective(OpenMPDirectiveKind BeginKind,
1556                                   OpenMPDirectiveKind ExpectedKind,
1557                                   OpenMPDirectiveKind FoundKind,
1558                                   SourceLocation BeginLoc,
1559                                   SourceLocation FoundLoc,
1560                                   bool SkipUntilOpenMPEnd) {
1561   int DiagSelection = ExpectedKind == OMPD_end_declare_target ? 0 : 1;
1562
1563   if (FoundKind == ExpectedKind) {
1564     ConsumeAnyToken();
1565     skipUntilPragmaOpenMPEnd(ExpectedKind);
1566     return;
1567   }
1568
1569   Diag(FoundLoc, diag::err_expected_end_declare_target_or_variant)
1570       << DiagSelection;
1571   Diag(BeginLoc, diag::note_matching)
1572       << ("'#pragma omp " + getOpenMPDirectiveName(BeginKind) + "'").str();
1573   if (SkipUntilOpenMPEnd)
1574     SkipUntil(tok::annot_pragma_openmp_end, StopBeforeMatch);
1575 }
1576
1577 void Parser::ParseOMPEndDeclareTargetDirective(OpenMPDirectiveKind DKind,
1578                                                SourceLocation DKLoc) {
1579   parseOMPEndDirective(OMPD_declare_target, OMPD_end_declare_target, DKind,
1580                        DKLoc, Tok.getLocation(),
1581                        /* SkipUntilOpenMPEnd */ false);
1582   // Skip the last annot_pragma_openmp_end.
1583   if (Tok.is(tok::annot_pragma_openmp_end))
1584     ConsumeAnnotationToken();
1585 }
1586
1587 /// Parsing of declarative OpenMP directives.
1588 ///
1589 ///       threadprivate-directive:
1590 ///         annot_pragma_openmp 'threadprivate' simple-variable-list
1591 ///         annot_pragma_openmp_end
1592 ///
1593 ///       allocate-directive:
1594 ///         annot_pragma_openmp 'allocate' simple-variable-list [<clause>]
1595 ///         annot_pragma_openmp_end
1596 ///
1597 ///       declare-reduction-directive:
1598 ///        annot_pragma_openmp 'declare' 'reduction' [...]
1599 ///        annot_pragma_openmp_end
1600 ///
1601 ///       declare-mapper-directive:
1602 ///         annot_pragma_openmp 'declare' 'mapper' '(' [<mapper-identifer> ':']
1603 ///         <type> <var> ')' [<clause>[[,] <clause>] ... ]
1604 ///         annot_pragma_openmp_end
1605 ///
1606 ///       declare-simd-directive:
1607 ///         annot_pragma_openmp 'declare simd' {<clause> [,]}
1608 ///         annot_pragma_openmp_end
1609 ///         <function declaration/definition>
1610 ///
1611 ///       requires directive:
1612 ///         annot_pragma_openmp 'requires' <clause> [[[,] <clause>] ... ]
1613 ///         annot_pragma_openmp_end
1614 ///
1615 Parser::DeclGroupPtrTy Parser::ParseOpenMPDeclarativeDirectiveWithExtDecl(
1616     AccessSpecifier &AS, ParsedAttributesWithRange &Attrs, bool Delayed,
1617     DeclSpec::TST TagType, Decl *Tag) {
1618   assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!");
1619   ParsingOpenMPDirectiveRAII DirScope(*this);
1620   ParenBraceBracketBalancer BalancerRAIIObj(*this);
1621
1622   SourceLocation Loc;
1623   OpenMPDirectiveKind DKind;
1624   if (Delayed) {
1625     TentativeParsingAction TPA(*this);
1626     Loc = ConsumeAnnotationToken();
1627     DKind = parseOpenMPDirectiveKind(*this);
1628     if (DKind == OMPD_declare_reduction || DKind == OMPD_declare_mapper) {
1629       // Need to delay parsing until completion of the parent class.
1630       TPA.Revert();
1631       CachedTokens Toks;
1632       unsigned Cnt = 1;
1633       Toks.push_back(Tok);
1634       while (Cnt && Tok.isNot(tok::eof)) {
1635         (void)ConsumeAnyToken();
1636         if (Tok.is(tok::annot_pragma_openmp))
1637           ++Cnt;
1638         else if (Tok.is(tok::annot_pragma_openmp_end))
1639           --Cnt;
1640         Toks.push_back(Tok);
1641       }
1642       // Skip last annot_pragma_openmp_end.
1643       if (Cnt == 0)
1644         (void)ConsumeAnyToken();
1645       auto *LP = new LateParsedPragma(this, AS);
1646       LP->takeToks(Toks);
1647       getCurrentClass().LateParsedDeclarations.push_back(LP);
1648       return nullptr;
1649     }
1650     TPA.Commit();
1651   } else {
1652     Loc = ConsumeAnnotationToken();
1653     DKind = parseOpenMPDirectiveKind(*this);
1654   }
1655
1656   switch (DKind) {
1657   case OMPD_threadprivate: {
1658     ConsumeToken();
1659     DeclDirectiveListParserHelper Helper(this, DKind);
1660     if (!ParseOpenMPSimpleVarList(DKind, Helper,
1661                                   /*AllowScopeSpecifier=*/true)) {
1662       skipUntilPragmaOpenMPEnd(DKind);
1663       // Skip the last annot_pragma_openmp_end.
1664       ConsumeAnnotationToken();
1665       return Actions.ActOnOpenMPThreadprivateDirective(Loc,
1666                                                        Helper.getIdentifiers());
1667     }
1668     break;
1669   }
1670   case OMPD_allocate: {
1671     ConsumeToken();
1672     DeclDirectiveListParserHelper Helper(this, DKind);
1673     if (!ParseOpenMPSimpleVarList(DKind, Helper,
1674                                   /*AllowScopeSpecifier=*/true)) {
1675       SmallVector<OMPClause *, 1> Clauses;
1676       if (Tok.isNot(tok::annot_pragma_openmp_end)) {
1677         SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>,
1678                     OMPC_unknown + 1>
1679             FirstClauses(OMPC_unknown + 1);
1680         while (Tok.isNot(tok::annot_pragma_openmp_end)) {
1681           OpenMPClauseKind CKind =
1682               Tok.isAnnotation() ? OMPC_unknown
1683                                  : getOpenMPClauseKind(PP.getSpelling(Tok));
1684           Actions.StartOpenMPClause(CKind);
1685           OMPClause *Clause = ParseOpenMPClause(OMPD_allocate, CKind,
1686                                                 !FirstClauses[CKind].getInt());
1687           SkipUntil(tok::comma, tok::identifier, tok::annot_pragma_openmp_end,
1688                     StopBeforeMatch);
1689           FirstClauses[CKind].setInt(true);
1690           if (Clause != nullptr)
1691             Clauses.push_back(Clause);
1692           if (Tok.is(tok::annot_pragma_openmp_end)) {
1693             Actions.EndOpenMPClause();
1694             break;
1695           }
1696           // Skip ',' if any.
1697           if (Tok.is(tok::comma))
1698             ConsumeToken();
1699           Actions.EndOpenMPClause();
1700         }
1701         skipUntilPragmaOpenMPEnd(DKind);
1702       }
1703       // Skip the last annot_pragma_openmp_end.
1704       ConsumeAnnotationToken();
1705       return Actions.ActOnOpenMPAllocateDirective(Loc, Helper.getIdentifiers(),
1706                                                   Clauses);
1707     }
1708     break;
1709   }
1710   case OMPD_requires: {
1711     SourceLocation StartLoc = ConsumeToken();
1712     SmallVector<OMPClause *, 5> Clauses;
1713     SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>, OMPC_unknown + 1>
1714     FirstClauses(OMPC_unknown + 1);
1715     if (Tok.is(tok::annot_pragma_openmp_end)) {
1716       Diag(Tok, diag::err_omp_expected_clause)
1717           << getOpenMPDirectiveName(OMPD_requires);
1718       break;
1719     }
1720     while (Tok.isNot(tok::annot_pragma_openmp_end)) {
1721       OpenMPClauseKind CKind = Tok.isAnnotation()
1722                                    ? OMPC_unknown
1723                                    : getOpenMPClauseKind(PP.getSpelling(Tok));
1724       Actions.StartOpenMPClause(CKind);
1725       OMPClause *Clause = ParseOpenMPClause(OMPD_requires, CKind,
1726                                             !FirstClauses[CKind].getInt());
1727       SkipUntil(tok::comma, tok::identifier, tok::annot_pragma_openmp_end,
1728                 StopBeforeMatch);
1729       FirstClauses[CKind].setInt(true);
1730       if (Clause != nullptr)
1731         Clauses.push_back(Clause);
1732       if (Tok.is(tok::annot_pragma_openmp_end)) {
1733         Actions.EndOpenMPClause();
1734         break;
1735       }
1736       // Skip ',' if any.
1737       if (Tok.is(tok::comma))
1738         ConsumeToken();
1739       Actions.EndOpenMPClause();
1740     }
1741     // Consume final annot_pragma_openmp_end
1742     if (Clauses.empty()) {
1743       Diag(Tok, diag::err_omp_expected_clause)
1744           << getOpenMPDirectiveName(OMPD_requires);
1745       ConsumeAnnotationToken();
1746       return nullptr;
1747     }
1748     ConsumeAnnotationToken();
1749     return Actions.ActOnOpenMPRequiresDirective(StartLoc, Clauses);
1750   }
1751   case OMPD_declare_reduction:
1752     ConsumeToken();
1753     if (DeclGroupPtrTy Res = ParseOpenMPDeclareReductionDirective(AS)) {
1754       skipUntilPragmaOpenMPEnd(OMPD_declare_reduction);
1755       // Skip the last annot_pragma_openmp_end.
1756       ConsumeAnnotationToken();
1757       return Res;
1758     }
1759     break;
1760   case OMPD_declare_mapper: {
1761     ConsumeToken();
1762     if (DeclGroupPtrTy Res = ParseOpenMPDeclareMapperDirective(AS)) {
1763       // Skip the last annot_pragma_openmp_end.
1764       ConsumeAnnotationToken();
1765       return Res;
1766     }
1767     break;
1768   }
1769   case OMPD_begin_declare_variant: {
1770     // The syntax is:
1771     // { #pragma omp begin declare variant clause }
1772     // <function-declaration-or-definition-sequence>
1773     // { #pragma omp end declare variant }
1774     //
1775     ConsumeToken();
1776     OMPTraitInfo &TI = Actions.getASTContext().getNewOMPTraitInfo();
1777     if (parseOMPDeclareVariantMatchClause(Loc, TI))
1778       break;
1779
1780     // Skip last tokens.
1781     skipUntilPragmaOpenMPEnd(OMPD_begin_declare_variant);
1782
1783     VariantMatchInfo VMI;
1784     ASTContext &ASTCtx = Actions.getASTContext();
1785     TI.getAsVariantMatchInfo(ASTCtx, VMI, /* DeviceSetOnly */ true);
1786     OMPContext OMPCtx(ASTCtx.getLangOpts().OpenMPIsDevice,
1787                       ASTCtx.getTargetInfo().getTriple());
1788
1789     if (isVariantApplicableInContext(VMI, OMPCtx)) {
1790       Actions.ActOnOpenMPBeginDeclareVariant(Loc, TI);
1791       break;
1792     }
1793
1794     // Elide all the code till the matching end declare variant was found.
1795     unsigned Nesting = 1;
1796     SourceLocation DKLoc;
1797     OpenMPDirectiveKind DK = OMPD_unknown;
1798     do {
1799       DKLoc = Tok.getLocation();
1800       DK = parseOpenMPDirectiveKind(*this);
1801       if (DK == OMPD_end_declare_variant)
1802         --Nesting;
1803       else if (DK == OMPD_begin_declare_variant)
1804         ++Nesting;
1805       if (!Nesting || isEofOrEom())
1806         break;
1807       ConsumeAnyToken();
1808     } while (true);
1809
1810     parseOMPEndDirective(OMPD_begin_declare_variant, OMPD_end_declare_variant,
1811                          DK, Loc, DKLoc, /* SkipUntilOpenMPEnd */ true);
1812     if (isEofOrEom())
1813       return nullptr;
1814     break;
1815   }
1816   case OMPD_end_declare_variant: {
1817     if (Actions.isInOpenMPDeclareVariantScope())
1818       Actions.ActOnOpenMPEndDeclareVariant();
1819     else
1820       Diag(Loc, diag::err_expected_begin_declare_variant);
1821     ConsumeToken();
1822     break;
1823   }
1824   case OMPD_declare_variant:
1825   case OMPD_declare_simd: {
1826     // The syntax is:
1827     // { #pragma omp declare {simd|variant} }
1828     // <function-declaration-or-definition>
1829     //
1830     CachedTokens Toks;
1831     Toks.push_back(Tok);
1832     ConsumeToken();
1833     while(Tok.isNot(tok::annot_pragma_openmp_end)) {
1834       Toks.push_back(Tok);
1835       ConsumeAnyToken();
1836     }
1837     Toks.push_back(Tok);
1838     ConsumeAnyToken();
1839
1840     DeclGroupPtrTy Ptr;
1841     if (Tok.is(tok::annot_pragma_openmp)) {
1842       Ptr = ParseOpenMPDeclarativeDirectiveWithExtDecl(AS, Attrs, Delayed,
1843                                                        TagType, Tag);
1844     } else if (Tok.isNot(tok::r_brace) && !isEofOrEom()) {
1845       // Here we expect to see some function declaration.
1846       if (AS == AS_none) {
1847         assert(TagType == DeclSpec::TST_unspecified);
1848         MaybeParseCXX11Attributes(Attrs);
1849         ParsingDeclSpec PDS(*this);
1850         Ptr = ParseExternalDeclaration(Attrs, &PDS);
1851       } else {
1852         Ptr =
1853             ParseCXXClassMemberDeclarationWithPragmas(AS, Attrs, TagType, Tag);
1854       }
1855     }
1856     if (!Ptr) {
1857       Diag(Loc, diag::err_omp_decl_in_declare_simd_variant)
1858           << (DKind == OMPD_declare_simd ? 0 : 1);
1859       return DeclGroupPtrTy();
1860     }
1861     if (DKind == OMPD_declare_simd)
1862       return ParseOMPDeclareSimdClauses(Ptr, Toks, Loc);
1863     assert(DKind == OMPD_declare_variant &&
1864            "Expected declare variant directive only");
1865     ParseOMPDeclareVariantClauses(Ptr, Toks, Loc);
1866     return Ptr;
1867   }
1868   case OMPD_declare_target: {
1869     SourceLocation DTLoc = ConsumeAnyToken();
1870     if (Tok.isNot(tok::annot_pragma_openmp_end)) {
1871       return ParseOMPDeclareTargetClauses();
1872     }
1873
1874     // Skip the last annot_pragma_openmp_end.
1875     ConsumeAnyToken();
1876
1877     if (!Actions.ActOnStartOpenMPDeclareTargetDirective(DTLoc))
1878       return DeclGroupPtrTy();
1879
1880     llvm::SmallVector<Decl *, 4>  Decls;
1881     DKind = parseOpenMPDirectiveKind(*this);
1882     while (DKind != OMPD_end_declare_target && Tok.isNot(tok::eof) &&
1883            Tok.isNot(tok::r_brace)) {
1884       DeclGroupPtrTy Ptr;
1885       // Here we expect to see some function declaration.
1886       if (AS == AS_none) {
1887         assert(TagType == DeclSpec::TST_unspecified);
1888         MaybeParseCXX11Attributes(Attrs);
1889         ParsingDeclSpec PDS(*this);
1890         Ptr = ParseExternalDeclaration(Attrs, &PDS);
1891       } else {
1892         Ptr =
1893             ParseCXXClassMemberDeclarationWithPragmas(AS, Attrs, TagType, Tag);
1894       }
1895       if (Ptr) {
1896         DeclGroupRef Ref = Ptr.get();
1897         Decls.append(Ref.begin(), Ref.end());
1898       }
1899       if (Tok.isAnnotation() && Tok.is(tok::annot_pragma_openmp)) {
1900         TentativeParsingAction TPA(*this);
1901         ConsumeAnnotationToken();
1902         DKind = parseOpenMPDirectiveKind(*this);
1903         if (DKind != OMPD_end_declare_target)
1904           TPA.Revert();
1905         else
1906           TPA.Commit();
1907       }
1908     }
1909
1910     ParseOMPEndDeclareTargetDirective(DKind, DTLoc);
1911     Actions.ActOnFinishOpenMPDeclareTargetDirective();
1912     return Actions.BuildDeclaratorGroup(Decls);
1913   }
1914   case OMPD_unknown:
1915     Diag(Tok, diag::err_omp_unknown_directive);
1916     break;
1917   case OMPD_parallel:
1918   case OMPD_simd:
1919   case OMPD_task:
1920   case OMPD_taskyield:
1921   case OMPD_barrier:
1922   case OMPD_taskwait:
1923   case OMPD_taskgroup:
1924   case OMPD_flush:
1925   case OMPD_depobj:
1926   case OMPD_scan:
1927   case OMPD_for:
1928   case OMPD_for_simd:
1929   case OMPD_sections:
1930   case OMPD_section:
1931   case OMPD_single:
1932   case OMPD_master:
1933   case OMPD_ordered:
1934   case OMPD_critical:
1935   case OMPD_parallel_for:
1936   case OMPD_parallel_for_simd:
1937   case OMPD_parallel_sections:
1938   case OMPD_parallel_master:
1939   case OMPD_atomic:
1940   case OMPD_target:
1941   case OMPD_teams:
1942   case OMPD_cancellation_point:
1943   case OMPD_cancel:
1944   case OMPD_target_data:
1945   case OMPD_target_enter_data:
1946   case OMPD_target_exit_data:
1947   case OMPD_target_parallel:
1948   case OMPD_target_parallel_for:
1949   case OMPD_taskloop:
1950   case OMPD_taskloop_simd:
1951   case OMPD_master_taskloop:
1952   case OMPD_master_taskloop_simd:
1953   case OMPD_parallel_master_taskloop:
1954   case OMPD_parallel_master_taskloop_simd:
1955   case OMPD_distribute:
1956   case OMPD_end_declare_target:
1957   case OMPD_target_update:
1958   case OMPD_distribute_parallel_for:
1959   case OMPD_distribute_parallel_for_simd:
1960   case OMPD_distribute_simd:
1961   case OMPD_target_parallel_for_simd:
1962   case OMPD_target_simd:
1963   case OMPD_teams_distribute:
1964   case OMPD_teams_distribute_simd:
1965   case OMPD_teams_distribute_parallel_for_simd:
1966   case OMPD_teams_distribute_parallel_for:
1967   case OMPD_target_teams:
1968   case OMPD_target_teams_distribute:
1969   case OMPD_target_teams_distribute_parallel_for:
1970   case OMPD_target_teams_distribute_parallel_for_simd:
1971   case OMPD_target_teams_distribute_simd:
1972     Diag(Tok, diag::err_omp_unexpected_directive)
1973         << 1 << getOpenMPDirectiveName(DKind);
1974     break;
1975   }
1976   while (Tok.isNot(tok::annot_pragma_openmp_end))
1977     ConsumeAnyToken();
1978   ConsumeAnyToken();
1979   return nullptr;
1980 }
1981
1982 /// Parsing of declarative or executable OpenMP directives.
1983 ///
1984 ///       threadprivate-directive:
1985 ///         annot_pragma_openmp 'threadprivate' simple-variable-list
1986 ///         annot_pragma_openmp_end
1987 ///
1988 ///       allocate-directive:
1989 ///         annot_pragma_openmp 'allocate' simple-variable-list
1990 ///         annot_pragma_openmp_end
1991 ///
1992 ///       declare-reduction-directive:
1993 ///         annot_pragma_openmp 'declare' 'reduction' '(' <reduction_id> ':'
1994 ///         <type> {',' <type>} ':' <expression> ')' ['initializer' '('
1995 ///         ('omp_priv' '=' <expression>|<function_call>) ')']
1996 ///         annot_pragma_openmp_end
1997 ///
1998 ///       declare-mapper-directive:
1999 ///         annot_pragma_openmp 'declare' 'mapper' '(' [<mapper-identifer> ':']
2000 ///         <type> <var> ')' [<clause>[[,] <clause>] ... ]
2001 ///         annot_pragma_openmp_end
2002 ///
2003 ///       executable-directive:
2004 ///         annot_pragma_openmp 'parallel' | 'simd' | 'for' | 'sections' |
2005 ///         'section' | 'single' | 'master' | 'critical' [ '(' <name> ')' ] |
2006 ///         'parallel for' | 'parallel sections' | 'parallel master' | 'task' |
2007 ///         'taskyield' | 'barrier' | 'taskwait' | 'flush' | 'ordered' |
2008 ///         'atomic' | 'for simd' | 'parallel for simd' | 'target' | 'target
2009 ///         data' | 'taskgroup' | 'teams' | 'taskloop' | 'taskloop simd' |
2010 ///         'master taskloop' | 'master taskloop simd' | 'parallel master
2011 ///         taskloop' | 'parallel master taskloop simd' | 'distribute' | 'target
2012 ///         enter data' | 'target exit data' | 'target parallel' | 'target
2013 ///         parallel for' | 'target update' | 'distribute parallel for' |
2014 ///         'distribute paralle for simd' | 'distribute simd' | 'target parallel
2015 ///         for simd' | 'target simd' | 'teams distribute' | 'teams distribute
2016 ///         simd' | 'teams distribute parallel for simd' | 'teams distribute
2017 ///         parallel for' | 'target teams' | 'target teams distribute' | 'target
2018 ///         teams distribute parallel for' | 'target teams distribute parallel
2019 ///         for simd' | 'target teams distribute simd' {clause}
2020 ///         annot_pragma_openmp_end
2021 ///
2022 StmtResult
2023 Parser::ParseOpenMPDeclarativeOrExecutableDirective(ParsedStmtContext StmtCtx) {
2024   assert(Tok.is(tok::annot_pragma_openmp) && "Not an OpenMP directive!");
2025   ParsingOpenMPDirectiveRAII DirScope(*this);
2026   ParenBraceBracketBalancer BalancerRAIIObj(*this);
2027   SmallVector<OMPClause *, 5> Clauses;
2028   SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>, OMPC_unknown + 1>
2029   FirstClauses(OMPC_unknown + 1);
2030   unsigned ScopeFlags = Scope::FnScope | Scope::DeclScope |
2031                         Scope::CompoundStmtScope | Scope::OpenMPDirectiveScope;
2032   SourceLocation Loc = ConsumeAnnotationToken(), EndLoc;
2033   OpenMPDirectiveKind DKind = parseOpenMPDirectiveKind(*this);
2034   OpenMPDirectiveKind CancelRegion = OMPD_unknown;
2035   // Name of critical directive.
2036   DeclarationNameInfo DirName;
2037   StmtResult Directive = StmtError();
2038   bool HasAssociatedStatement = true;
2039
2040   switch (DKind) {
2041   case OMPD_threadprivate: {
2042     // FIXME: Should this be permitted in C++?
2043     if ((StmtCtx & ParsedStmtContext::AllowDeclarationsInC) ==
2044         ParsedStmtContext()) {
2045       Diag(Tok, diag::err_omp_immediate_directive)
2046           << getOpenMPDirectiveName(DKind) << 0;
2047     }
2048     ConsumeToken();
2049     DeclDirectiveListParserHelper Helper(this, DKind);
2050     if (!ParseOpenMPSimpleVarList(DKind, Helper,
2051                                   /*AllowScopeSpecifier=*/false)) {
2052       skipUntilPragmaOpenMPEnd(DKind);
2053       DeclGroupPtrTy Res = Actions.ActOnOpenMPThreadprivateDirective(
2054           Loc, Helper.getIdentifiers());
2055       Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation());
2056     }
2057     SkipUntil(tok::annot_pragma_openmp_end);
2058     break;
2059   }
2060   case OMPD_allocate: {
2061     // FIXME: Should this be permitted in C++?
2062     if ((StmtCtx & ParsedStmtContext::AllowDeclarationsInC) ==
2063         ParsedStmtContext()) {
2064       Diag(Tok, diag::err_omp_immediate_directive)
2065           << getOpenMPDirectiveName(DKind) << 0;
2066     }
2067     ConsumeToken();
2068     DeclDirectiveListParserHelper Helper(this, DKind);
2069     if (!ParseOpenMPSimpleVarList(DKind, Helper,
2070                                   /*AllowScopeSpecifier=*/false)) {
2071       SmallVector<OMPClause *, 1> Clauses;
2072       if (Tok.isNot(tok::annot_pragma_openmp_end)) {
2073         SmallVector<llvm::PointerIntPair<OMPClause *, 1, bool>,
2074                     OMPC_unknown + 1>
2075             FirstClauses(OMPC_unknown + 1);
2076         while (Tok.isNot(tok::annot_pragma_openmp_end)) {
2077           OpenMPClauseKind CKind =
2078               Tok.isAnnotation() ? OMPC_unknown
2079                                  : getOpenMPClauseKind(PP.getSpelling(Tok));
2080           Actions.StartOpenMPClause(CKind);
2081           OMPClause *Clause = ParseOpenMPClause(OMPD_allocate, CKind,
2082                                                 !FirstClauses[CKind].getInt());
2083           SkipUntil(tok::comma, tok::identifier, tok::annot_pragma_openmp_end,
2084                     StopBeforeMatch);
2085           FirstClauses[CKind].setInt(true);
2086           if (Clause != nullptr)
2087             Clauses.push_back(Clause);
2088           if (Tok.is(tok::annot_pragma_openmp_end)) {
2089             Actions.EndOpenMPClause();
2090             break;
2091           }
2092           // Skip ',' if any.
2093           if (Tok.is(tok::comma))
2094             ConsumeToken();
2095           Actions.EndOpenMPClause();
2096         }
2097         skipUntilPragmaOpenMPEnd(DKind);
2098       }
2099       DeclGroupPtrTy Res = Actions.ActOnOpenMPAllocateDirective(
2100           Loc, Helper.getIdentifiers(), Clauses);
2101       Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation());
2102     }
2103     SkipUntil(tok::annot_pragma_openmp_end);
2104     break;
2105   }
2106   case OMPD_declare_reduction:
2107     ConsumeToken();
2108     if (DeclGroupPtrTy Res =
2109             ParseOpenMPDeclareReductionDirective(/*AS=*/AS_none)) {
2110       skipUntilPragmaOpenMPEnd(OMPD_declare_reduction);
2111       ConsumeAnyToken();
2112       Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation());
2113     } else {
2114       SkipUntil(tok::annot_pragma_openmp_end);
2115     }
2116     break;
2117   case OMPD_declare_mapper: {
2118     ConsumeToken();
2119     if (DeclGroupPtrTy Res =
2120             ParseOpenMPDeclareMapperDirective(/*AS=*/AS_none)) {
2121       // Skip the last annot_pragma_openmp_end.
2122       ConsumeAnnotationToken();
2123       Directive = Actions.ActOnDeclStmt(Res, Loc, Tok.getLocation());
2124     } else {
2125       SkipUntil(tok::annot_pragma_openmp_end);
2126     }
2127     break;
2128   }
2129   case OMPD_flush:
2130   case OMPD_depobj:
2131   case OMPD_scan:
2132   case OMPD_taskyield:
2133   case OMPD_barrier:
2134   case OMPD_taskwait:
2135   case OMPD_cancellation_point:
2136   case OMPD_cancel:
2137   case OMPD_target_enter_data:
2138   case OMPD_target_exit_data:
2139   case OMPD_target_update:
2140     if ((StmtCtx & ParsedStmtContext::AllowStandaloneOpenMPDirectives) ==
2141         ParsedStmtContext()) {
2142       Diag(Tok, diag::err_omp_immediate_directive)
2143           << getOpenMPDirectiveName(DKind) << 0;
2144     }
2145     HasAssociatedStatement = false;
2146     // Fall through for further analysis.
2147     LLVM_FALLTHROUGH;
2148   case OMPD_parallel:
2149   case OMPD_simd:
2150   case OMPD_for:
2151   case OMPD_for_simd:
2152   case OMPD_sections:
2153   case OMPD_single:
2154   case OMPD_section:
2155   case OMPD_master:
2156   case OMPD_critical:
2157   case OMPD_parallel_for:
2158   case OMPD_parallel_for_simd:
2159   case OMPD_parallel_sections:
2160   case OMPD_parallel_master:
2161   case OMPD_task:
2162   case OMPD_ordered:
2163   case OMPD_atomic:
2164   case OMPD_target:
2165   case OMPD_teams:
2166   case OMPD_taskgroup:
2167   case OMPD_target_data:
2168   case OMPD_target_parallel:
2169   case OMPD_target_parallel_for:
2170   case OMPD_taskloop:
2171   case OMPD_taskloop_simd:
2172   case OMPD_master_taskloop:
2173   case OMPD_master_taskloop_simd:
2174   case OMPD_parallel_master_taskloop:
2175   case OMPD_parallel_master_taskloop_simd:
2176   case OMPD_distribute:
2177   case OMPD_distribute_parallel_for:
2178   case OMPD_distribute_parallel_for_simd:
2179   case OMPD_distribute_simd:
2180   case OMPD_target_parallel_for_simd:
2181   case OMPD_target_simd:
2182   case OMPD_teams_distribute:
2183   case OMPD_teams_distribute_simd:
2184   case OMPD_teams_distribute_parallel_for_simd:
2185   case OMPD_teams_distribute_parallel_for:
2186   case OMPD_target_teams:
2187   case OMPD_target_teams_distribute:
2188   case OMPD_target_teams_distribute_parallel_for:
2189   case OMPD_target_teams_distribute_parallel_for_simd:
2190   case OMPD_target_teams_distribute_simd: {
2191     // Special processing for flush and depobj clauses.
2192     Token ImplicitTok;
2193     bool ImplicitClauseAllowed = false;
2194     if (DKind == OMPD_flush || DKind == OMPD_depobj) {
2195       ImplicitTok = Tok;
2196       ImplicitClauseAllowed = true;
2197     }
2198     ConsumeToken();
2199     // Parse directive name of the 'critical' directive if any.
2200     if (DKind == OMPD_critical) {
2201       BalancedDelimiterTracker T(*this, tok::l_paren,
2202                                  tok::annot_pragma_openmp_end);
2203       if (!T.consumeOpen()) {
2204         if (Tok.isAnyIdentifier()) {
2205           DirName =
2206               DeclarationNameInfo(Tok.getIdentifierInfo(), Tok.getLocation());
2207           ConsumeAnyToken();
2208         } else {
2209           Diag(Tok, diag::err_omp_expected_identifier_for_critical);
2210         }
2211         T.consumeClose();
2212       }
2213     } else if (DKind == OMPD_cancellation_point || DKind == OMPD_cancel) {
2214       CancelRegion = parseOpenMPDirectiveKind(*this);
2215       if (Tok.isNot(tok::annot_pragma_openmp_end))
2216         ConsumeToken();
2217     }
2218
2219     if (isOpenMPLoopDirective(DKind))
2220       ScopeFlags |= Scope::OpenMPLoopDirectiveScope;
2221     if (isOpenMPSimdDirective(DKind))
2222       ScopeFlags |= Scope::OpenMPSimdDirectiveScope;
2223     ParseScope OMPDirectiveScope(this, ScopeFlags);
2224     Actions.StartOpenMPDSABlock(DKind, DirName, Actions.getCurScope(), Loc);
2225
2226     while (Tok.isNot(tok::annot_pragma_openmp_end)) {
2227       bool HasImplicitClause = false;
2228       if (ImplicitClauseAllowed && Tok.is(tok::l_paren)) {
2229         HasImplicitClause = true;
2230         // Push copy of the current token back to stream to properly parse
2231         // pseudo-clause OMPFlushClause or OMPDepobjClause.
2232         PP.EnterToken(Tok, /*IsReinject*/ true);
2233         PP.EnterToken(ImplicitTok, /*IsReinject*/ true);
2234         ConsumeAnyToken();
2235       }
2236       OpenMPClauseKind CKind = Tok.isAnnotation()
2237                                    ? OMPC_unknown
2238                                    : getOpenMPClauseKind(PP.getSpelling(Tok));
2239       if (HasImplicitClause) {
2240         assert(CKind == OMPC_unknown && "Must be unknown implicit clause.");
2241         if (DKind == OMPD_flush) {
2242           CKind = OMPC_flush;
2243         } else {
2244           assert(DKind == OMPD_depobj &&
2245                  "Expected flush or depobj directives.");
2246           CKind = OMPC_depobj;
2247         }
2248       }
2249       // No more implicit clauses allowed.
2250       ImplicitClauseAllowed = false;
2251       Actions.StartOpenMPClause(CKind);
2252       HasImplicitClause = false;
2253       OMPClause *Clause =
2254           ParseOpenMPClause(DKind, CKind, !FirstClauses[CKind].getInt());
2255       FirstClauses[CKind].setInt(true);
2256       if (Clause) {
2257         FirstClauses[CKind].setPointer(Clause);
2258         Clauses.push_back(Clause);
2259       }
2260
2261       // Skip ',' if any.
2262       if (Tok.is(tok::comma))
2263         ConsumeToken();
2264       Actions.EndOpenMPClause();
2265     }
2266     // End location of the directive.
2267     EndLoc = Tok.getLocation();
2268     // Consume final annot_pragma_openmp_end.
2269     ConsumeAnnotationToken();
2270
2271     // OpenMP [2.13.8, ordered Construct, Syntax]
2272     // If the depend clause is specified, the ordered construct is a stand-alone
2273     // directive.
2274     if (DKind == OMPD_ordered && FirstClauses[OMPC_depend].getInt()) {
2275       if ((StmtCtx & ParsedStmtContext::AllowStandaloneOpenMPDirectives) ==
2276           ParsedStmtContext()) {
2277         Diag(Loc, diag::err_omp_immediate_directive)
2278             << getOpenMPDirectiveName(DKind) << 1
2279             << getOpenMPClauseName(OMPC_depend);
2280       }
2281       HasAssociatedStatement = false;
2282     }
2283
2284     StmtResult AssociatedStmt;
2285     if (HasAssociatedStatement) {
2286       // The body is a block scope like in Lambdas and Blocks.
2287       Actions.ActOnOpenMPRegionStart(DKind, getCurScope());
2288       // FIXME: We create a bogus CompoundStmt scope to hold the contents of
2289       // the captured region. Code elsewhere assumes that any FunctionScopeInfo
2290       // should have at least one compound statement scope within it.
2291       AssociatedStmt = (Sema::CompoundScopeRAII(Actions), ParseStatement());
2292       AssociatedStmt = Actions.ActOnOpenMPRegionEnd(AssociatedStmt, Clauses);
2293     } else if (DKind == OMPD_target_update || DKind == OMPD_target_enter_data ||
2294                DKind == OMPD_target_exit_data) {
2295       Actions.ActOnOpenMPRegionStart(DKind, getCurScope());
2296       AssociatedStmt = (Sema::CompoundScopeRAII(Actions),
2297                         Actions.ActOnCompoundStmt(Loc, Loc, llvm::None,
2298                                                   /*isStmtExpr=*/false));
2299       AssociatedStmt = Actions.ActOnOpenMPRegionEnd(AssociatedStmt, Clauses);
2300     }
2301     Directive = Actions.ActOnOpenMPExecutableDirective(
2302         DKind, DirName, CancelRegion, Clauses, AssociatedStmt.get(), Loc,
2303         EndLoc);
2304
2305     // Exit scope.
2306     Actions.EndOpenMPDSABlock(Directive.get());
2307     OMPDirectiveScope.Exit();
2308     break;
2309   }
2310   case OMPD_declare_simd:
2311   case OMPD_declare_target:
2312   case OMPD_end_declare_target:
2313   case OMPD_requires:
2314   case OMPD_begin_declare_variant:
2315   case OMPD_end_declare_variant:
2316   case OMPD_declare_variant:
2317     Diag(Tok, diag::err_omp_unexpected_directive)
2318         << 1 << getOpenMPDirectiveName(DKind);
2319     SkipUntil(tok::annot_pragma_openmp_end);
2320     break;
2321   case OMPD_unknown:
2322     Diag(Tok, diag::err_omp_unknown_directive);
2323     SkipUntil(tok::annot_pragma_openmp_end);
2324     break;
2325   }
2326   return Directive;
2327 }
2328
2329 // Parses simple list:
2330 //   simple-variable-list:
2331 //         '(' id-expression {, id-expression} ')'
2332 //
2333 bool Parser::ParseOpenMPSimpleVarList(
2334     OpenMPDirectiveKind Kind,
2335     const llvm::function_ref<void(CXXScopeSpec &, DeclarationNameInfo)> &
2336         Callback,
2337     bool AllowScopeSpecifier) {
2338   // Parse '('.
2339   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
2340   if (T.expectAndConsume(diag::err_expected_lparen_after,
2341                          getOpenMPDirectiveName(Kind).data()))
2342     return true;
2343   bool IsCorrect = true;
2344   bool NoIdentIsFound = true;
2345
2346   // Read tokens while ')' or annot_pragma_openmp_end is not found.
2347   while (Tok.isNot(tok::r_paren) && Tok.isNot(tok::annot_pragma_openmp_end)) {
2348     CXXScopeSpec SS;
2349     UnqualifiedId Name;
2350     // Read var name.
2351     Token PrevTok = Tok;
2352     NoIdentIsFound = false;
2353
2354     if (AllowScopeSpecifier && getLangOpts().CPlusPlus &&
2355         ParseOptionalCXXScopeSpecifier(SS, /*ObjectType=*/nullptr,
2356                                        /*ObjectHadErrors=*/false, false)) {
2357       IsCorrect = false;
2358       SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
2359                 StopBeforeMatch);
2360     } else if (ParseUnqualifiedId(SS, /*ObjectType=*/nullptr,
2361                                   /*ObjectHadErrors=*/false, false, false,
2362                                   false, false, nullptr, Name)) {
2363       IsCorrect = false;
2364       SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
2365                 StopBeforeMatch);
2366     } else if (Tok.isNot(tok::comma) && Tok.isNot(tok::r_paren) &&
2367                Tok.isNot(tok::annot_pragma_openmp_end)) {
2368       IsCorrect = false;
2369       SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
2370                 StopBeforeMatch);
2371       Diag(PrevTok.getLocation(), diag::err_expected)
2372           << tok::identifier
2373           << SourceRange(PrevTok.getLocation(), PrevTokLocation);
2374     } else {
2375       Callback(SS, Actions.GetNameFromUnqualifiedId(Name));
2376     }
2377     // Consume ','.
2378     if (Tok.is(tok::comma)) {
2379       ConsumeToken();
2380     }
2381   }
2382
2383   if (NoIdentIsFound) {
2384     Diag(Tok, diag::err_expected) << tok::identifier;
2385     IsCorrect = false;
2386   }
2387
2388   // Parse ')'.
2389   IsCorrect = !T.consumeClose() && IsCorrect;
2390
2391   return !IsCorrect;
2392 }
2393
2394 /// Parsing of OpenMP clauses.
2395 ///
2396 ///    clause:
2397 ///       if-clause | final-clause | num_threads-clause | safelen-clause |
2398 ///       default-clause | private-clause | firstprivate-clause | shared-clause
2399 ///       | linear-clause | aligned-clause | collapse-clause |
2400 ///       lastprivate-clause | reduction-clause | proc_bind-clause |
2401 ///       schedule-clause | copyin-clause | copyprivate-clause | untied-clause |
2402 ///       mergeable-clause | flush-clause | read-clause | write-clause |
2403 ///       update-clause | capture-clause | seq_cst-clause | device-clause |
2404 ///       simdlen-clause | threads-clause | simd-clause | num_teams-clause |
2405 ///       thread_limit-clause | priority-clause | grainsize-clause |
2406 ///       nogroup-clause | num_tasks-clause | hint-clause | to-clause |
2407 ///       from-clause | is_device_ptr-clause | task_reduction-clause |
2408 ///       in_reduction-clause | allocator-clause | allocate-clause |
2409 ///       acq_rel-clause | acquire-clause | release-clause | relaxed-clause |
2410 ///       depobj-clause | destroy-clause | detach-clause | inclusive-clause |
2411 ///       exclusive-clause
2412 ///
2413 OMPClause *Parser::ParseOpenMPClause(OpenMPDirectiveKind DKind,
2414                                      OpenMPClauseKind CKind, bool FirstClause) {
2415   OMPClause *Clause = nullptr;
2416   bool ErrorFound = false;
2417   bool WrongDirective = false;
2418   // Check if clause is allowed for the given directive.
2419   if (CKind != OMPC_unknown &&
2420       !isAllowedClauseForDirective(DKind, CKind, getLangOpts().OpenMP)) {
2421     Diag(Tok, diag::err_omp_unexpected_clause) << getOpenMPClauseName(CKind)
2422                                                << getOpenMPDirectiveName(DKind);
2423     ErrorFound = true;
2424     WrongDirective = true;
2425   }
2426
2427   switch (CKind) {
2428   case OMPC_final:
2429   case OMPC_num_threads:
2430   case OMPC_safelen:
2431   case OMPC_simdlen:
2432   case OMPC_collapse:
2433   case OMPC_ordered:
2434   case OMPC_num_teams:
2435   case OMPC_thread_limit:
2436   case OMPC_priority:
2437   case OMPC_grainsize:
2438   case OMPC_num_tasks:
2439   case OMPC_hint:
2440   case OMPC_allocator:
2441   case OMPC_depobj:
2442   case OMPC_detach:
2443     // OpenMP [2.5, Restrictions]
2444     //  At most one num_threads clause can appear on the directive.
2445     // OpenMP [2.8.1, simd construct, Restrictions]
2446     //  Only one safelen  clause can appear on a simd directive.
2447     //  Only one simdlen  clause can appear on a simd directive.
2448     //  Only one collapse clause can appear on a simd directive.
2449     // OpenMP [2.11.1, task Construct, Restrictions]
2450     //  At most one if clause can appear on the directive.
2451     //  At most one final clause can appear on the directive.
2452     // OpenMP [teams Construct, Restrictions]
2453     //  At most one num_teams clause can appear on the directive.
2454     //  At most one thread_limit clause can appear on the directive.
2455     // OpenMP [2.9.1, task Construct, Restrictions]
2456     // At most one priority clause can appear on the directive.
2457     // OpenMP [2.9.2, taskloop Construct, Restrictions]
2458     // At most one grainsize clause can appear on the directive.
2459     // OpenMP [2.9.2, taskloop Construct, Restrictions]
2460     // At most one num_tasks clause can appear on the directive.
2461     // OpenMP [2.11.3, allocate Directive, Restrictions]
2462     // At most one allocator clause can appear on the directive.
2463     // OpenMP 5.0, 2.10.1 task Construct, Restrictions.
2464     // At most one detach clause can appear on the directive.
2465     if (!FirstClause) {
2466       Diag(Tok, diag::err_omp_more_one_clause)
2467           << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;
2468       ErrorFound = true;
2469     }
2470
2471     if (CKind == OMPC_ordered && PP.LookAhead(/*N=*/0).isNot(tok::l_paren))
2472       Clause = ParseOpenMPClause(CKind, WrongDirective);
2473     else
2474       Clause = ParseOpenMPSingleExprClause(CKind, WrongDirective);
2475     break;
2476   case OMPC_default:
2477   case OMPC_proc_bind:
2478   case OMPC_atomic_default_mem_order:
2479   case OMPC_order:
2480     // OpenMP [2.14.3.1, Restrictions]
2481     //  Only a single default clause may be specified on a parallel, task or
2482     //  teams directive.
2483     // OpenMP [2.5, parallel Construct, Restrictions]
2484     //  At most one proc_bind clause can appear on the directive.
2485     // OpenMP [5.0, Requires directive, Restrictions]
2486     //  At most one atomic_default_mem_order clause can appear
2487     //  on the directive
2488     if (!FirstClause && CKind != OMPC_order) {
2489       Diag(Tok, diag::err_omp_more_one_clause)
2490           << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;
2491       ErrorFound = true;
2492     }
2493
2494     Clause = ParseOpenMPSimpleClause(CKind, WrongDirective);
2495     break;
2496   case OMPC_device:
2497   case OMPC_schedule:
2498   case OMPC_dist_schedule:
2499   case OMPC_defaultmap:
2500     // OpenMP [2.7.1, Restrictions, p. 3]
2501     //  Only one schedule clause can appear on a loop directive.
2502     // OpenMP 4.5 [2.10.4, Restrictions, p. 106]
2503     //  At most one defaultmap clause can appear on the directive.
2504     // OpenMP 5.0 [2.12.5, target construct, Restrictions]
2505     //  At most one device clause can appear on the directive.
2506     if ((getLangOpts().OpenMP < 50 || CKind != OMPC_defaultmap) &&
2507         !FirstClause) {
2508       Diag(Tok, diag::err_omp_more_one_clause)
2509           << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;
2510       ErrorFound = true;
2511     }
2512     LLVM_FALLTHROUGH;
2513   case OMPC_if:
2514     Clause = ParseOpenMPSingleExprWithArgClause(DKind, CKind, WrongDirective);
2515     break;
2516   case OMPC_nowait:
2517   case OMPC_untied:
2518   case OMPC_mergeable:
2519   case OMPC_read:
2520   case OMPC_write:
2521   case OMPC_capture:
2522   case OMPC_seq_cst:
2523   case OMPC_acq_rel:
2524   case OMPC_acquire:
2525   case OMPC_release:
2526   case OMPC_relaxed:
2527   case OMPC_threads:
2528   case OMPC_simd:
2529   case OMPC_nogroup:
2530   case OMPC_unified_address:
2531   case OMPC_unified_shared_memory:
2532   case OMPC_reverse_offload:
2533   case OMPC_dynamic_allocators:
2534   case OMPC_destroy:
2535     // OpenMP [2.7.1, Restrictions, p. 9]
2536     //  Only one ordered clause can appear on a loop directive.
2537     // OpenMP [2.7.1, Restrictions, C/C++, p. 4]
2538     //  Only one nowait clause can appear on a for directive.
2539     // OpenMP [5.0, Requires directive, Restrictions]
2540     //   Each of the requires clauses can appear at most once on the directive.
2541     if (!FirstClause) {
2542       Diag(Tok, diag::err_omp_more_one_clause)
2543           << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;
2544       ErrorFound = true;
2545     }
2546
2547     Clause = ParseOpenMPClause(CKind, WrongDirective);
2548     break;
2549   case OMPC_update:
2550     if (!FirstClause) {
2551       Diag(Tok, diag::err_omp_more_one_clause)
2552           << getOpenMPDirectiveName(DKind) << getOpenMPClauseName(CKind) << 0;
2553       ErrorFound = true;
2554     }
2555
2556     Clause = (DKind == OMPD_depobj)
2557                  ? ParseOpenMPSimpleClause(CKind, WrongDirective)
2558                  : ParseOpenMPClause(CKind, WrongDirective);
2559     break;
2560   case OMPC_private:
2561   case OMPC_firstprivate:
2562   case OMPC_lastprivate:
2563   case OMPC_shared:
2564   case OMPC_reduction:
2565   case OMPC_task_reduction:
2566   case OMPC_in_reduction:
2567   case OMPC_linear:
2568   case OMPC_aligned:
2569   case OMPC_copyin:
2570   case OMPC_copyprivate:
2571   case OMPC_flush:
2572   case OMPC_depend:
2573   case OMPC_map:
2574   case OMPC_to:
2575   case OMPC_from:
2576   case OMPC_use_device_ptr:
2577   case OMPC_is_device_ptr:
2578   case OMPC_allocate:
2579   case OMPC_nontemporal:
2580   case OMPC_inclusive:
2581   case OMPC_exclusive:
2582     Clause = ParseOpenMPVarListClause(DKind, CKind, WrongDirective);
2583     break;
2584   case OMPC_device_type:
2585   case OMPC_unknown:
2586     skipUntilPragmaOpenMPEnd(DKind);
2587     break;
2588   case OMPC_threadprivate:
2589   case OMPC_uniform:
2590   case OMPC_match:
2591     if (!WrongDirective)
2592       Diag(Tok, diag::err_omp_unexpected_clause)
2593           << getOpenMPClauseName(CKind) << getOpenMPDirectiveName(DKind);
2594     SkipUntil(tok::comma, tok::annot_pragma_openmp_end, StopBeforeMatch);
2595     break;
2596   }
2597   return ErrorFound ? nullptr : Clause;
2598 }
2599
2600 /// Parses simple expression in parens for single-expression clauses of OpenMP
2601 /// constructs.
2602 /// \param RLoc Returned location of right paren.
2603 ExprResult Parser::ParseOpenMPParensExpr(StringRef ClauseName,
2604                                          SourceLocation &RLoc,
2605                                          bool IsAddressOfOperand) {
2606   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
2607   if (T.expectAndConsume(diag::err_expected_lparen_after, ClauseName.data()))
2608     return ExprError();
2609
2610   SourceLocation ELoc = Tok.getLocation();
2611   ExprResult LHS(ParseCastExpression(AnyCastExpr, IsAddressOfOperand,
2612                                      NotTypeCast));
2613   ExprResult Val(ParseRHSOfBinaryExpression(LHS, prec::Conditional));
2614   Val = Actions.ActOnFinishFullExpr(Val.get(), ELoc, /*DiscardedValue*/ false);
2615
2616   // Parse ')'.
2617   RLoc = Tok.getLocation();
2618   if (!T.consumeClose())
2619     RLoc = T.getCloseLocation();
2620
2621   return Val;
2622 }
2623
2624 /// Parsing of OpenMP clauses with single expressions like 'final',
2625 /// 'collapse', 'safelen', 'num_threads', 'simdlen', 'num_teams',
2626 /// 'thread_limit', 'simdlen', 'priority', 'grainsize', 'num_tasks', 'hint' or
2627 /// 'detach'.
2628 ///
2629 ///    final-clause:
2630 ///      'final' '(' expression ')'
2631 ///
2632 ///    num_threads-clause:
2633 ///      'num_threads' '(' expression ')'
2634 ///
2635 ///    safelen-clause:
2636 ///      'safelen' '(' expression ')'
2637 ///
2638 ///    simdlen-clause:
2639 ///      'simdlen' '(' expression ')'
2640 ///
2641 ///    collapse-clause:
2642 ///      'collapse' '(' expression ')'
2643 ///
2644 ///    priority-clause:
2645 ///      'priority' '(' expression ')'
2646 ///
2647 ///    grainsize-clause:
2648 ///      'grainsize' '(' expression ')'
2649 ///
2650 ///    num_tasks-clause:
2651 ///      'num_tasks' '(' expression ')'
2652 ///
2653 ///    hint-clause:
2654 ///      'hint' '(' expression ')'
2655 ///
2656 ///    allocator-clause:
2657 ///      'allocator' '(' expression ')'
2658 ///
2659 ///    detach-clause:
2660 ///      'detach' '(' event-handler-expression ')'
2661 ///
2662 OMPClause *Parser::ParseOpenMPSingleExprClause(OpenMPClauseKind Kind,
2663                                                bool ParseOnly) {
2664   SourceLocation Loc = ConsumeToken();
2665   SourceLocation LLoc = Tok.getLocation();
2666   SourceLocation RLoc;
2667
2668   ExprResult Val = ParseOpenMPParensExpr(getOpenMPClauseName(Kind), RLoc);
2669
2670   if (Val.isInvalid())
2671     return nullptr;
2672
2673   if (ParseOnly)
2674     return nullptr;
2675   return Actions.ActOnOpenMPSingleExprClause(Kind, Val.get(), Loc, LLoc, RLoc);
2676 }
2677
2678 /// Parsing of simple OpenMP clauses like 'default' or 'proc_bind'.
2679 ///
2680 ///    default-clause:
2681 ///         'default' '(' 'none' | 'shared' ')'
2682 ///
2683 ///    proc_bind-clause:
2684 ///         'proc_bind' '(' 'master' | 'close' | 'spread' ')'
2685 ///
2686 ///    update-clause:
2687 ///         'update' '(' 'in' | 'out' | 'inout' | 'mutexinoutset' ')'
2688 ///
2689 OMPClause *Parser::ParseOpenMPSimpleClause(OpenMPClauseKind Kind,
2690                                            bool ParseOnly) {
2691   llvm::Optional<SimpleClauseData> Val = parseOpenMPSimpleClause(*this, Kind);
2692   if (!Val || ParseOnly)
2693     return nullptr;
2694   return Actions.ActOnOpenMPSimpleClause(
2695       Kind, Val.getValue().Type, Val.getValue().TypeLoc, Val.getValue().LOpen,
2696       Val.getValue().Loc, Val.getValue().RLoc);
2697 }
2698
2699 /// Parsing of OpenMP clauses like 'ordered'.
2700 ///
2701 ///    ordered-clause:
2702 ///         'ordered'
2703 ///
2704 ///    nowait-clause:
2705 ///         'nowait'
2706 ///
2707 ///    untied-clause:
2708 ///         'untied'
2709 ///
2710 ///    mergeable-clause:
2711 ///         'mergeable'
2712 ///
2713 ///    read-clause:
2714 ///         'read'
2715 ///
2716 ///    threads-clause:
2717 ///         'threads'
2718 ///
2719 ///    simd-clause:
2720 ///         'simd'
2721 ///
2722 ///    nogroup-clause:
2723 ///         'nogroup'
2724 ///
2725 OMPClause *Parser::ParseOpenMPClause(OpenMPClauseKind Kind, bool ParseOnly) {
2726   SourceLocation Loc = Tok.getLocation();
2727   ConsumeAnyToken();
2728
2729   if (ParseOnly)
2730     return nullptr;
2731   return Actions.ActOnOpenMPClause(Kind, Loc, Tok.getLocation());
2732 }
2733
2734
2735 /// Parsing of OpenMP clauses with single expressions and some additional
2736 /// argument like 'schedule' or 'dist_schedule'.
2737 ///
2738 ///    schedule-clause:
2739 ///      'schedule' '(' [ modifier [ ',' modifier ] ':' ] kind [',' expression ]
2740 ///      ')'
2741 ///
2742 ///    if-clause:
2743 ///      'if' '(' [ directive-name-modifier ':' ] expression ')'
2744 ///
2745 ///    defaultmap:
2746 ///      'defaultmap' '(' modifier ':' kind ')'
2747 ///
2748 ///    device-clause:
2749 ///      'device' '(' [ device-modifier ':' ] expression ')'
2750 ///
2751 OMPClause *Parser::ParseOpenMPSingleExprWithArgClause(OpenMPDirectiveKind DKind,
2752                                                       OpenMPClauseKind Kind,
2753                                                       bool ParseOnly) {
2754   SourceLocation Loc = ConsumeToken();
2755   SourceLocation DelimLoc;
2756   // Parse '('.
2757   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
2758   if (T.expectAndConsume(diag::err_expected_lparen_after,
2759                          getOpenMPClauseName(Kind)))
2760     return nullptr;
2761
2762   ExprResult Val;
2763   SmallVector<unsigned, 4> Arg;
2764   SmallVector<SourceLocation, 4> KLoc;
2765   if (Kind == OMPC_schedule) {
2766     enum { Modifier1, Modifier2, ScheduleKind, NumberOfElements };
2767     Arg.resize(NumberOfElements);
2768     KLoc.resize(NumberOfElements);
2769     Arg[Modifier1] = OMPC_SCHEDULE_MODIFIER_unknown;
2770     Arg[Modifier2] = OMPC_SCHEDULE_MODIFIER_unknown;
2771     Arg[ScheduleKind] = OMPC_SCHEDULE_unknown;
2772     unsigned KindModifier = getOpenMPSimpleClauseType(
2773         Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok));
2774     if (KindModifier > OMPC_SCHEDULE_unknown) {
2775       // Parse 'modifier'
2776       Arg[Modifier1] = KindModifier;
2777       KLoc[Modifier1] = Tok.getLocation();
2778       if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
2779           Tok.isNot(tok::annot_pragma_openmp_end))
2780         ConsumeAnyToken();
2781       if (Tok.is(tok::comma)) {
2782         // Parse ',' 'modifier'
2783         ConsumeAnyToken();
2784         KindModifier = getOpenMPSimpleClauseType(
2785             Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok));
2786         Arg[Modifier2] = KindModifier > OMPC_SCHEDULE_unknown
2787                              ? KindModifier
2788                              : (unsigned)OMPC_SCHEDULE_unknown;
2789         KLoc[Modifier2] = Tok.getLocation();
2790         if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
2791             Tok.isNot(tok::annot_pragma_openmp_end))
2792           ConsumeAnyToken();
2793       }
2794       // Parse ':'
2795       if (Tok.is(tok::colon))
2796         ConsumeAnyToken();
2797       else
2798         Diag(Tok, diag::warn_pragma_expected_colon) << "schedule modifier";
2799       KindModifier = getOpenMPSimpleClauseType(
2800           Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok));
2801     }
2802     Arg[ScheduleKind] = KindModifier;
2803     KLoc[ScheduleKind] = Tok.getLocation();
2804     if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
2805         Tok.isNot(tok::annot_pragma_openmp_end))
2806       ConsumeAnyToken();
2807     if ((Arg[ScheduleKind] == OMPC_SCHEDULE_static ||
2808          Arg[ScheduleKind] == OMPC_SCHEDULE_dynamic ||
2809          Arg[ScheduleKind] == OMPC_SCHEDULE_guided) &&
2810         Tok.is(tok::comma))
2811       DelimLoc = ConsumeAnyToken();
2812   } else if (Kind == OMPC_dist_schedule) {
2813     Arg.push_back(getOpenMPSimpleClauseType(
2814         Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok)));
2815     KLoc.push_back(Tok.getLocation());
2816     if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
2817         Tok.isNot(tok::annot_pragma_openmp_end))
2818       ConsumeAnyToken();
2819     if (Arg.back() == OMPC_DIST_SCHEDULE_static && Tok.is(tok::comma))
2820       DelimLoc = ConsumeAnyToken();
2821   } else if (Kind == OMPC_defaultmap) {
2822     // Get a defaultmap modifier
2823     unsigned Modifier = getOpenMPSimpleClauseType(
2824         Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok));
2825     // Set defaultmap modifier to unknown if it is either scalar, aggregate, or
2826     // pointer
2827     if (Modifier < OMPC_DEFAULTMAP_MODIFIER_unknown)
2828       Modifier = OMPC_DEFAULTMAP_MODIFIER_unknown;
2829     Arg.push_back(Modifier);
2830     KLoc.push_back(Tok.getLocation());
2831     if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
2832         Tok.isNot(tok::annot_pragma_openmp_end))
2833       ConsumeAnyToken();
2834     // Parse ':'
2835     if (Tok.is(tok::colon))
2836       ConsumeAnyToken();
2837     else if (Arg.back() != OMPC_DEFAULTMAP_MODIFIER_unknown)
2838       Diag(Tok, diag::warn_pragma_expected_colon) << "defaultmap modifier";
2839     // Get a defaultmap kind
2840     Arg.push_back(getOpenMPSimpleClauseType(
2841         Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok)));
2842     KLoc.push_back(Tok.getLocation());
2843     if (Tok.isNot(tok::r_paren) && Tok.isNot(tok::comma) &&
2844         Tok.isNot(tok::annot_pragma_openmp_end))
2845       ConsumeAnyToken();
2846   } else if (Kind == OMPC_device) {
2847     // Only target executable directives support extended device construct.
2848     if (isOpenMPTargetExecutionDirective(DKind) && getLangOpts().OpenMP >= 50 &&
2849         NextToken().is(tok::colon)) {
2850       // Parse optional <device modifier> ':'
2851       Arg.push_back(getOpenMPSimpleClauseType(
2852           Kind, Tok.isAnnotation() ? "" : PP.getSpelling(Tok)));
2853       KLoc.push_back(Tok.getLocation());
2854       ConsumeAnyToken();
2855       // Parse ':'
2856       ConsumeAnyToken();
2857     } else {
2858       Arg.push_back(OMPC_DEVICE_unknown);
2859       KLoc.emplace_back();
2860     }
2861   } else {
2862     assert(Kind == OMPC_if);
2863     KLoc.push_back(Tok.getLocation());
2864     TentativeParsingAction TPA(*this);
2865     auto DK = parseOpenMPDirectiveKind(*this);
2866     Arg.push_back(DK);
2867     if (DK != OMPD_unknown) {
2868       ConsumeToken();
2869       if (Tok.is(tok::colon) && getLangOpts().OpenMP > 40) {
2870         TPA.Commit();
2871         DelimLoc = ConsumeToken();
2872       } else {
2873         TPA.Revert();
2874         Arg.back() = unsigned(OMPD_unknown);
2875       }
2876     } else {
2877       TPA.Revert();
2878     }
2879   }
2880
2881   bool NeedAnExpression = (Kind == OMPC_schedule && DelimLoc.isValid()) ||
2882                           (Kind == OMPC_dist_schedule && DelimLoc.isValid()) ||
2883                           Kind == OMPC_if || Kind == OMPC_device;
2884   if (NeedAnExpression) {
2885     SourceLocation ELoc = Tok.getLocation();
2886     ExprResult LHS(ParseCastExpression(AnyCastExpr, false, NotTypeCast));
2887     Val = ParseRHSOfBinaryExpression(LHS, prec::Conditional);
2888     Val =
2889         Actions.ActOnFinishFullExpr(Val.get(), ELoc, /*DiscardedValue*/ false);
2890   }
2891
2892   // Parse ')'.
2893   SourceLocation RLoc = Tok.getLocation();
2894   if (!T.consumeClose())
2895     RLoc = T.getCloseLocation();
2896
2897   if (NeedAnExpression && Val.isInvalid())
2898     return nullptr;
2899
2900   if (ParseOnly)
2901     return nullptr;
2902   return Actions.ActOnOpenMPSingleExprWithArgClause(
2903       Kind, Arg, Val.get(), Loc, T.getOpenLocation(), KLoc, DelimLoc, RLoc);
2904 }
2905
2906 static bool ParseReductionId(Parser &P, CXXScopeSpec &ReductionIdScopeSpec,
2907                              UnqualifiedId &ReductionId) {
2908   if (ReductionIdScopeSpec.isEmpty()) {
2909     auto OOK = OO_None;
2910     switch (P.getCurToken().getKind()) {
2911     case tok::plus:
2912       OOK = OO_Plus;
2913       break;
2914     case tok::minus:
2915       OOK = OO_Minus;
2916       break;
2917     case tok::star:
2918       OOK = OO_Star;
2919       break;
2920     case tok::amp:
2921       OOK = OO_Amp;
2922       break;
2923     case tok::pipe:
2924       OOK = OO_Pipe;
2925       break;
2926     case tok::caret:
2927       OOK = OO_Caret;
2928       break;
2929     case tok::ampamp:
2930       OOK = OO_AmpAmp;
2931       break;
2932     case tok::pipepipe:
2933       OOK = OO_PipePipe;
2934       break;
2935     default:
2936       break;
2937     }
2938     if (OOK != OO_None) {
2939       SourceLocation OpLoc = P.ConsumeToken();
2940       SourceLocation SymbolLocations[] = {OpLoc, OpLoc, SourceLocation()};
2941       ReductionId.setOperatorFunctionId(OpLoc, OOK, SymbolLocations);
2942       return false;
2943     }
2944   }
2945   return P.ParseUnqualifiedId(
2946       ReductionIdScopeSpec, /*ObjectType=*/nullptr,
2947       /*ObjectHadErrors=*/false, /*EnteringContext*/ false,
2948       /*AllowDestructorName*/ false,
2949       /*AllowConstructorName*/ false,
2950       /*AllowDeductionGuide*/ false, nullptr, ReductionId);
2951 }
2952
2953 /// Checks if the token is a valid map-type-modifier.
2954 static OpenMPMapModifierKind isMapModifier(Parser &P) {
2955   Token Tok = P.getCurToken();
2956   if (!Tok.is(tok::identifier))
2957     return OMPC_MAP_MODIFIER_unknown;
2958
2959   Preprocessor &PP = P.getPreprocessor();
2960   OpenMPMapModifierKind TypeModifier = static_cast<OpenMPMapModifierKind>(
2961       getOpenMPSimpleClauseType(OMPC_map, PP.getSpelling(Tok)));
2962   return TypeModifier;
2963 }
2964
2965 /// Parse the mapper modifier in map, to, and from clauses.
2966 bool Parser::parseMapperModifier(OpenMPVarListDataTy &Data) {
2967   // Parse '('.
2968   BalancedDelimiterTracker T(*this, tok::l_paren, tok::colon);
2969   if (T.expectAndConsume(diag::err_expected_lparen_after, "mapper")) {
2970     SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,
2971               StopBeforeMatch);
2972     return true;
2973   }
2974   // Parse mapper-identifier
2975   if (getLangOpts().CPlusPlus)
2976     ParseOptionalCXXScopeSpecifier(Data.ReductionOrMapperIdScopeSpec,
2977                                    /*ObjectType=*/nullptr,
2978                                    /*ObjectHadErrors=*/false,
2979                                    /*EnteringContext=*/false);
2980   if (Tok.isNot(tok::identifier) && Tok.isNot(tok::kw_default)) {
2981     Diag(Tok.getLocation(), diag::err_omp_mapper_illegal_identifier);
2982     SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,
2983               StopBeforeMatch);
2984     return true;
2985   }
2986   auto &DeclNames = Actions.getASTContext().DeclarationNames;
2987   Data.ReductionOrMapperId = DeclarationNameInfo(
2988       DeclNames.getIdentifier(Tok.getIdentifierInfo()), Tok.getLocation());
2989   ConsumeToken();
2990   // Parse ')'.
2991   return T.consumeClose();
2992 }
2993
2994 /// Parse map-type-modifiers in map clause.
2995 /// map([ [map-type-modifier[,] [map-type-modifier[,] ...] map-type : ] list)
2996 /// where, map-type-modifier ::= always | close | mapper(mapper-identifier)
2997 bool Parser::parseMapTypeModifiers(OpenMPVarListDataTy &Data) {
2998   while (getCurToken().isNot(tok::colon)) {
2999     OpenMPMapModifierKind TypeModifier = isMapModifier(*this);
3000     if (TypeModifier == OMPC_MAP_MODIFIER_always ||
3001         TypeModifier == OMPC_MAP_MODIFIER_close) {
3002       Data.MapTypeModifiers.push_back(TypeModifier);
3003       Data.MapTypeModifiersLoc.push_back(Tok.getLocation());
3004       ConsumeToken();
3005     } else if (TypeModifier == OMPC_MAP_MODIFIER_mapper) {
3006       Data.MapTypeModifiers.push_back(TypeModifier);
3007       Data.MapTypeModifiersLoc.push_back(Tok.getLocation());
3008       ConsumeToken();
3009       if (parseMapperModifier(Data))
3010         return true;
3011     } else {
3012       // For the case of unknown map-type-modifier or a map-type.
3013       // Map-type is followed by a colon; the function returns when it
3014       // encounters a token followed by a colon.
3015       if (Tok.is(tok::comma)) {
3016         Diag(Tok, diag::err_omp_map_type_modifier_missing);
3017         ConsumeToken();
3018         continue;
3019       }
3020       // Potential map-type token as it is followed by a colon.
3021       if (PP.LookAhead(0).is(tok::colon))
3022         return false;
3023       Diag(Tok, diag::err_omp_unknown_map_type_modifier);
3024       ConsumeToken();
3025     }
3026     if (getCurToken().is(tok::comma))
3027       ConsumeToken();
3028   }
3029   return false;
3030 }
3031
3032 /// Checks if the token is a valid map-type.
3033 static OpenMPMapClauseKind isMapType(Parser &P) {
3034   Token Tok = P.getCurToken();
3035   // The map-type token can be either an identifier or the C++ delete keyword.
3036   if (!Tok.isOneOf(tok::identifier, tok::kw_delete))
3037     return OMPC_MAP_unknown;
3038   Preprocessor &PP = P.getPreprocessor();
3039   OpenMPMapClauseKind MapType = static_cast<OpenMPMapClauseKind>(
3040       getOpenMPSimpleClauseType(OMPC_map, PP.getSpelling(Tok)));
3041   return MapType;
3042 }
3043
3044 /// Parse map-type in map clause.
3045 /// map([ [map-type-modifier[,] [map-type-modifier[,] ...] map-type : ] list)
3046 /// where, map-type ::= to | from | tofrom | alloc | release | delete
3047 static void parseMapType(Parser &P, Parser::OpenMPVarListDataTy &Data) {
3048   Token Tok = P.getCurToken();
3049   if (Tok.is(tok::colon)) {
3050     P.Diag(Tok, diag::err_omp_map_type_missing);
3051     return;
3052   }
3053   Data.ExtraModifier = isMapType(P);
3054   if (Data.ExtraModifier == OMPC_MAP_unknown)
3055     P.Diag(Tok, diag::err_omp_unknown_map_type);
3056   P.ConsumeToken();
3057 }
3058
3059 /// Parses simple expression in parens for single-expression clauses of OpenMP
3060 /// constructs.
3061 /// \param RLoc Returned location of right paren.
3062 ExprResult Parser::ParseOpenMPIteratorsExpr() {
3063   assert(Tok.is(tok::identifier) && PP.getSpelling(Tok) == "iterator" &&
3064          "Expected 'iterator' token.");
3065   SourceLocation IteratorKwLoc = ConsumeToken();
3066
3067   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
3068   if (T.expectAndConsume(diag::err_expected_lparen_after, "iterator"))
3069     return ExprError();
3070
3071   SourceLocation LLoc = T.getOpenLocation();
3072   SmallVector<Sema::OMPIteratorData, 4> Data;
3073   while (Tok.isNot(tok::r_paren) && Tok.isNot(tok::annot_pragma_openmp_end)) {
3074     // Check if the type parsing is required.
3075     ParsedType IteratorType;
3076     if (Tok.isNot(tok::identifier) || NextToken().isNot(tok::equal)) {
3077       // identifier '=' is not found - parse type.
3078       TypeResult TR = ParseTypeName();
3079       if (TR.isInvalid()) {
3080         T.skipToEnd();
3081         return ExprError();
3082       }
3083       IteratorType = TR.get();
3084     }
3085
3086     // Parse identifier.
3087     IdentifierInfo *II = nullptr;
3088     SourceLocation IdLoc;
3089     if (Tok.is(tok::identifier)) {
3090       II = Tok.getIdentifierInfo();
3091       IdLoc = ConsumeToken();
3092     } else {
3093       Diag(Tok, diag::err_expected_unqualified_id) << 0;
3094     }
3095
3096     // Parse '='.
3097     SourceLocation AssignLoc;
3098     if (Tok.is(tok::equal))
3099       AssignLoc = ConsumeToken();
3100     else
3101       Diag(Tok, diag::err_omp_expected_equal_in_iterator);
3102
3103     // Parse range-specification - <begin> ':' <end> [ ':' <step> ]
3104     ColonProtectionRAIIObject ColonRAII(*this);
3105     // Parse <begin>
3106     SourceLocation Loc = Tok.getLocation();
3107     ExprResult LHS = ParseCastExpression(AnyCastExpr);
3108     ExprResult Begin = Actions.CorrectDelayedTyposInExpr(
3109         ParseRHSOfBinaryExpression(LHS, prec::Conditional));
3110     Begin = Actions.ActOnFinishFullExpr(Begin.get(), Loc,
3111                                         /*DiscardedValue=*/false);
3112     // Parse ':'.
3113     SourceLocation ColonLoc;
3114     if (Tok.is(tok::colon))
3115       ColonLoc = ConsumeToken();
3116
3117     // Parse <end>
3118     Loc = Tok.getLocation();
3119     LHS = ParseCastExpression(AnyCastExpr);
3120     ExprResult End = Actions.CorrectDelayedTyposInExpr(
3121         ParseRHSOfBinaryExpression(LHS, prec::Conditional));
3122     End = Actions.ActOnFinishFullExpr(End.get(), Loc,
3123                                       /*DiscardedValue=*/false);
3124
3125     SourceLocation SecColonLoc;
3126     ExprResult Step;
3127     // Parse optional step.
3128     if (Tok.is(tok::colon)) {
3129       // Parse ':'
3130       SecColonLoc = ConsumeToken();
3131       // Parse <step>
3132       Loc = Tok.getLocation();
3133       LHS = ParseCastExpression(AnyCastExpr);
3134       Step = Actions.CorrectDelayedTyposInExpr(
3135           ParseRHSOfBinaryExpression(LHS, prec::Conditional));
3136       Step = Actions.ActOnFinishFullExpr(Step.get(), Loc,
3137                                          /*DiscardedValue=*/false);
3138     }
3139
3140     // Parse ',' or ')'
3141     if (Tok.isNot(tok::comma) && Tok.isNot(tok::r_paren))
3142       Diag(Tok, diag::err_omp_expected_punc_after_iterator);
3143     if (Tok.is(tok::comma))
3144       ConsumeToken();
3145
3146     Sema::OMPIteratorData &D = Data.emplace_back();
3147     D.DeclIdent = II;
3148     D.DeclIdentLoc = IdLoc;
3149     D.Type = IteratorType;
3150     D.AssignLoc = AssignLoc;
3151     D.ColonLoc = ColonLoc;
3152     D.SecColonLoc = SecColonLoc;
3153     D.Range.Begin = Begin.get();
3154     D.Range.End = End.get();
3155     D.Range.Step = Step.get();
3156   }
3157
3158   // Parse ')'.
3159   SourceLocation RLoc = Tok.getLocation();
3160   if (!T.consumeClose())
3161     RLoc = T.getCloseLocation();
3162
3163   return Actions.ActOnOMPIteratorExpr(getCurScope(), IteratorKwLoc, LLoc, RLoc,
3164                                       Data);
3165 }
3166
3167 /// Parses clauses with list.
3168 bool Parser::ParseOpenMPVarList(OpenMPDirectiveKind DKind,
3169                                 OpenMPClauseKind Kind,
3170                                 SmallVectorImpl<Expr *> &Vars,
3171                                 OpenMPVarListDataTy &Data) {
3172   UnqualifiedId UnqualifiedReductionId;
3173   bool InvalidReductionId = false;
3174   bool IsInvalidMapperModifier = false;
3175
3176   // Parse '('.
3177   BalancedDelimiterTracker T(*this, tok::l_paren, tok::annot_pragma_openmp_end);
3178   if (T.expectAndConsume(diag::err_expected_lparen_after,
3179                          getOpenMPClauseName(Kind)))
3180     return true;
3181
3182   bool DependWithIterator = false;
3183   bool NeedRParenForLinear = false;
3184   BalancedDelimiterTracker LinearT(*this, tok::l_paren,
3185                                   tok::annot_pragma_openmp_end);
3186   // Handle reduction-identifier for reduction clause.
3187   if (Kind == OMPC_reduction || Kind == OMPC_task_reduction ||
3188       Kind == OMPC_in_reduction) {
3189     Data.ExtraModifier = OMPC_REDUCTION_unknown;
3190     if (Kind == OMPC_reduction && getLangOpts().OpenMP >= 50 &&
3191         (Tok.is(tok::identifier) || Tok.is(tok::kw_default)) &&
3192         NextToken().is(tok::comma)) {
3193       // Parse optional reduction modifier.
3194       Data.ExtraModifier = getOpenMPSimpleClauseType(Kind, PP.getSpelling(Tok));
3195       Data.ExtraModifierLoc = Tok.getLocation();
3196       ConsumeToken();
3197       assert(Tok.is(tok::comma) && "Expected comma.");
3198       (void)ConsumeToken();
3199     }
3200     ColonProtectionRAIIObject ColonRAII(*this);
3201     if (getLangOpts().CPlusPlus)
3202       ParseOptionalCXXScopeSpecifier(Data.ReductionOrMapperIdScopeSpec,
3203                                      /*ObjectType=*/nullptr,
3204                                      /*ObjectHadErrors=*/false,
3205                                      /*EnteringContext=*/false);
3206     InvalidReductionId = ParseReductionId(
3207         *this, Data.ReductionOrMapperIdScopeSpec, UnqualifiedReductionId);
3208     if (InvalidReductionId) {
3209       SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,
3210                 StopBeforeMatch);
3211     }
3212     if (Tok.is(tok::colon))
3213       Data.ColonLoc = ConsumeToken();
3214     else
3215       Diag(Tok, diag::warn_pragma_expected_colon) << "reduction identifier";
3216     if (!InvalidReductionId)
3217       Data.ReductionOrMapperId =
3218           Actions.GetNameFromUnqualifiedId(UnqualifiedReductionId);
3219   } else if (Kind == OMPC_depend) {
3220     if (getLangOpts().OpenMP >= 50) {
3221       if (Tok.is(tok::identifier) && PP.getSpelling(Tok) == "iterator") {
3222         // Handle optional dependence modifier.
3223         // iterator(iterators-definition)
3224         // where iterators-definition is iterator-specifier [,
3225         // iterators-definition ]
3226         // where iterator-specifier is [ iterator-type ] identifier =
3227         // range-specification
3228         DependWithIterator = true;
3229         EnterScope(Scope::OpenMPDirectiveScope | Scope::DeclScope);
3230         ExprResult IteratorRes = ParseOpenMPIteratorsExpr();
3231         Data.DepModOrTailExpr = IteratorRes.get();
3232         // Parse ','
3233         ExpectAndConsume(tok::comma);
3234       }
3235     }
3236     // Handle dependency type for depend clause.
3237     ColonProtectionRAIIObject ColonRAII(*this);
3238     Data.ExtraModifier = getOpenMPSimpleClauseType(
3239         Kind, Tok.is(tok::identifier) ? PP.getSpelling(Tok) : "");
3240     Data.ExtraModifierLoc = Tok.getLocation();
3241     if (Data.ExtraModifier == OMPC_DEPEND_unknown) {
3242       SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,
3243                 StopBeforeMatch);
3244     } else {
3245       ConsumeToken();
3246       // Special processing for depend(source) clause.
3247       if (DKind == OMPD_ordered && Data.ExtraModifier == OMPC_DEPEND_source) {
3248         // Parse ')'.
3249         T.consumeClose();
3250         return false;
3251       }
3252     }
3253     if (Tok.is(tok::colon)) {
3254       Data.ColonLoc = ConsumeToken();
3255     } else {
3256       Diag(Tok, DKind == OMPD_ordered ? diag::warn_pragma_expected_colon_r_paren
3257                                       : diag::warn_pragma_expected_colon)
3258           << "dependency type";
3259     }
3260   } else if (Kind == OMPC_linear) {
3261     // Try to parse modifier if any.
3262     Data.ExtraModifier = OMPC_LINEAR_val;
3263     if (Tok.is(tok::identifier) && PP.LookAhead(0).is(tok::l_paren)) {
3264       Data.ExtraModifier = getOpenMPSimpleClauseType(Kind, PP.getSpelling(Tok));
3265       Data.ExtraModifierLoc = ConsumeToken();
3266       LinearT.consumeOpen();
3267       NeedRParenForLinear = true;
3268     }
3269   } else if (Kind == OMPC_lastprivate) {
3270     // Try to parse modifier if any.
3271     Data.ExtraModifier = OMPC_LASTPRIVATE_unknown;
3272     // Conditional modifier allowed only in OpenMP 5.0 and not supported in
3273     // distribute and taskloop based directives.
3274     if ((getLangOpts().OpenMP >= 50 && !isOpenMPDistributeDirective(DKind) &&
3275          !isOpenMPTaskLoopDirective(DKind)) &&
3276         Tok.is(tok::identifier) && PP.LookAhead(0).is(tok::colon)) {
3277       Data.ExtraModifier = getOpenMPSimpleClauseType(Kind, PP.getSpelling(Tok));
3278       Data.ExtraModifierLoc = Tok.getLocation();
3279       ConsumeToken();
3280       assert(Tok.is(tok::colon) && "Expected colon.");
3281       Data.ColonLoc = ConsumeToken();
3282     }
3283   } else if (Kind == OMPC_map) {
3284     // Handle map type for map clause.
3285     ColonProtectionRAIIObject ColonRAII(*this);
3286
3287     // The first identifier may be a list item, a map-type or a
3288     // map-type-modifier. The map-type can also be delete which has the same
3289     // spelling of the C++ delete keyword.
3290     Data.ExtraModifier = OMPC_MAP_unknown;
3291     Data.ExtraModifierLoc = Tok.getLocation();
3292
3293     // Check for presence of a colon in the map clause.
3294     TentativeParsingAction TPA(*this);
3295     bool ColonPresent = false;
3296     if (SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,
3297         StopBeforeMatch)) {
3298       if (Tok.is(tok::colon))
3299         ColonPresent = true;
3300     }
3301     TPA.Revert();
3302     // Only parse map-type-modifier[s] and map-type if a colon is present in
3303     // the map clause.
3304     if (ColonPresent) {
3305       IsInvalidMapperModifier = parseMapTypeModifiers(Data);
3306       if (!IsInvalidMapperModifier)
3307         parseMapType(*this, Data);
3308       else
3309         SkipUntil(tok::colon, tok::annot_pragma_openmp_end, StopBeforeMatch);
3310     }
3311     if (Data.ExtraModifier == OMPC_MAP_unknown) {
3312       Data.ExtraModifier = OMPC_MAP_tofrom;
3313       Data.IsMapTypeImplicit = true;
3314     }
3315
3316     if (Tok.is(tok::colon))
3317       Data.ColonLoc = ConsumeToken();
3318   } else if (Kind == OMPC_to || Kind == OMPC_from) {
3319     if (Tok.is(tok::identifier)) {
3320       bool IsMapperModifier = false;
3321       if (Kind == OMPC_to) {
3322         auto Modifier = static_cast<OpenMPToModifierKind>(
3323             getOpenMPSimpleClauseType(Kind, PP.getSpelling(Tok)));
3324         if (Modifier == OMPC_TO_MODIFIER_mapper)
3325           IsMapperModifier = true;
3326       } else {
3327         auto Modifier = static_cast<OpenMPFromModifierKind>(
3328             getOpenMPSimpleClauseType(Kind, PP.getSpelling(Tok)));
3329         if (Modifier == OMPC_FROM_MODIFIER_mapper)
3330           IsMapperModifier = true;
3331       }
3332       if (IsMapperModifier) {
3333         // Parse the mapper modifier.
3334         ConsumeToken();
3335         IsInvalidMapperModifier = parseMapperModifier(Data);
3336         if (Tok.isNot(tok::colon)) {
3337           if (!IsInvalidMapperModifier)
3338             Diag(Tok, diag::warn_pragma_expected_colon) << ")";
3339           SkipUntil(tok::colon, tok::r_paren, tok::annot_pragma_openmp_end,
3340                     StopBeforeMatch);
3341         }
3342         // Consume ':'.
3343         if (Tok.is(tok::colon))
3344           ConsumeToken();
3345       }
3346     }
3347   } else if (Kind == OMPC_allocate) {
3348     // Handle optional allocator expression followed by colon delimiter.
3349     ColonProtectionRAIIObject ColonRAII(*this);
3350     TentativeParsingAction TPA(*this);
3351     ExprResult Tail =
3352         Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
3353     Tail = Actions.ActOnFinishFullExpr(Tail.get(), T.getOpenLocation(),
3354                                        /*DiscardedValue=*/false);
3355     if (Tail.isUsable()) {
3356       if (Tok.is(tok::colon)) {
3357         Data.DepModOrTailExpr = Tail.get();
3358         Data.ColonLoc = ConsumeToken();
3359         TPA.Commit();
3360       } else {
3361         // colon not found, no allocator specified, parse only list of
3362         // variables.
3363         TPA.Revert();
3364       }
3365     } else {
3366       // Parsing was unsuccessfull, revert and skip to the end of clause or
3367       // directive.
3368       TPA.Revert();
3369       SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
3370                 StopBeforeMatch);
3371     }
3372   }
3373
3374   bool IsComma =
3375       (Kind != OMPC_reduction && Kind != OMPC_task_reduction &&
3376        Kind != OMPC_in_reduction && Kind != OMPC_depend && Kind != OMPC_map) ||
3377       (Kind == OMPC_reduction && !InvalidReductionId) ||
3378       (Kind == OMPC_map && Data.ExtraModifier != OMPC_MAP_unknown) ||
3379       (Kind == OMPC_depend && Data.ExtraModifier != OMPC_DEPEND_unknown);
3380   const bool MayHaveTail = (Kind == OMPC_linear || Kind == OMPC_aligned);
3381   while (IsComma || (Tok.isNot(tok::r_paren) && Tok.isNot(tok::colon) &&
3382                      Tok.isNot(tok::annot_pragma_openmp_end))) {
3383     ParseScope OMPListScope(this, Scope::OpenMPDirectiveScope);
3384     ColonProtectionRAIIObject ColonRAII(*this, MayHaveTail);
3385     // Parse variable
3386     ExprResult VarExpr =
3387         Actions.CorrectDelayedTyposInExpr(ParseAssignmentExpression());
3388     if (VarExpr.isUsable()) {
3389       Vars.push_back(VarExpr.get());
3390     } else {
3391       SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
3392                 StopBeforeMatch);
3393     }
3394     // Skip ',' if any
3395     IsComma = Tok.is(tok::comma);
3396     if (IsComma)
3397       ConsumeToken();
3398     else if (Tok.isNot(tok::r_paren) &&
3399              Tok.isNot(tok::annot_pragma_openmp_end) &&
3400              (!MayHaveTail || Tok.isNot(tok::colon)))
3401       Diag(Tok, diag::err_omp_expected_punc)
3402           << ((Kind == OMPC_flush) ? getOpenMPDirectiveName(OMPD_flush)
3403                                    : getOpenMPClauseName(Kind))
3404           << (Kind == OMPC_flush);
3405   }
3406
3407   // Parse ')' for linear clause with modifier.
3408   if (NeedRParenForLinear)
3409     LinearT.consumeClose();
3410
3411   // Parse ':' linear-step (or ':' alignment).
3412   const bool MustHaveTail = MayHaveTail && Tok.is(tok::colon);
3413   if (MustHaveTail) {
3414     Data.ColonLoc = Tok.getLocation();
3415     SourceLocation ELoc = ConsumeToken();
3416     ExprResult Tail = ParseAssignmentExpression();
3417     Tail =
3418         Actions.ActOnFinishFullExpr(Tail.get(), ELoc, /*DiscardedValue*/ false);
3419     if (Tail.isUsable())
3420       Data.DepModOrTailExpr = Tail.get();
3421     else
3422       SkipUntil(tok::comma, tok::r_paren, tok::annot_pragma_openmp_end,
3423                 StopBeforeMatch);
3424   }
3425
3426   // Parse ')'.
3427   Data.RLoc = Tok.getLocation();
3428   if (!T.consumeClose())
3429     Data.RLoc = T.getCloseLocation();
3430   // Exit from scope when the iterator is used in depend clause.
3431   if (DependWithIterator)
3432     ExitScope();
3433   return (Kind != OMPC_depend && Kind != OMPC_map && Vars.empty()) ||
3434          (MustHaveTail && !Data.DepModOrTailExpr) || InvalidReductionId ||
3435          IsInvalidMapperModifier;
3436 }
3437
3438 /// Parsing of OpenMP clause 'private', 'firstprivate', 'lastprivate',
3439 /// 'shared', 'copyin', 'copyprivate', 'flush', 'reduction', 'task_reduction',
3440 /// 'in_reduction', 'nontemporal', 'exclusive' or 'inclusive'.
3441 ///
3442 ///    private-clause:
3443 ///       'private' '(' list ')'
3444 ///    firstprivate-clause:
3445 ///       'firstprivate' '(' list ')'
3446 ///    lastprivate-clause:
3447 ///       'lastprivate' '(' list ')'
3448 ///    shared-clause:
3449 ///       'shared' '(' list ')'
3450 ///    linear-clause:
3451 ///       'linear' '(' linear-list [ ':' linear-step ] ')'
3452 ///    aligned-clause:
3453 ///       'aligned' '(' list [ ':' alignment ] ')'
3454 ///    reduction-clause:
3455 ///       'reduction' '(' [ modifier ',' ] reduction-identifier ':' list ')'
3456 ///    task_reduction-clause:
3457 ///       'task_reduction' '(' reduction-identifier ':' list ')'
3458 ///    in_reduction-clause:
3459 ///       'in_reduction' '(' reduction-identifier ':' list ')'
3460 ///    copyprivate-clause:
3461 ///       'copyprivate' '(' list ')'
3462 ///    flush-clause:
3463 ///       'flush' '(' list ')'
3464 ///    depend-clause:
3465 ///       'depend' '(' in | out | inout : list | source ')'
3466 ///    map-clause:
3467 ///       'map' '(' [ [ always [,] ] [ close [,] ]
3468 ///          [ mapper '(' mapper-identifier ')' [,] ]
3469 ///          to | from | tofrom | alloc | release | delete ':' ] list ')';
3470 ///    to-clause:
3471 ///       'to' '(' [ mapper '(' mapper-identifier ')' ':' ] list ')'
3472 ///    from-clause:
3473 ///       'from' '(' [ mapper '(' mapper-identifier ')' ':' ] list ')'
3474 ///    use_device_ptr-clause:
3475 ///       'use_device_ptr' '(' list ')'
3476 ///    is_device_ptr-clause:
3477 ///       'is_device_ptr' '(' list ')'
3478 ///    allocate-clause:
3479 ///       'allocate' '(' [ allocator ':' ] list ')'
3480 ///    nontemporal-clause:
3481 ///       'nontemporal' '(' list ')'
3482 ///    inclusive-clause:
3483 ///       'inclusive' '(' list ')'
3484 ///    exclusive-clause:
3485 ///       'exclusive' '(' list ')'
3486 ///
3487 /// For 'linear' clause linear-list may have the following forms:
3488 ///  list
3489 ///  modifier(list)
3490 /// where modifier is 'val' (C) or 'ref', 'val' or 'uval'(C++).
3491 OMPClause *Parser::ParseOpenMPVarListClause(OpenMPDirectiveKind DKind,
3492                                             OpenMPClauseKind Kind,
3493                                             bool ParseOnly) {
3494   SourceLocation Loc = Tok.getLocation();
3495   SourceLocation LOpen = ConsumeToken();
3496   SmallVector<Expr *, 4> Vars;
3497   OpenMPVarListDataTy Data;
3498
3499   if (ParseOpenMPVarList(DKind, Kind, Vars, Data))
3500     return nullptr;
3501
3502   if (ParseOnly)
3503     return nullptr;
3504   OMPVarListLocTy Locs(Loc, LOpen, Data.RLoc);
3505   return Actions.ActOnOpenMPVarListClause(
3506       Kind, Vars, Data.DepModOrTailExpr, Locs, Data.ColonLoc,
3507       Data.ReductionOrMapperIdScopeSpec, Data.ReductionOrMapperId,
3508       Data.ExtraModifier, Data.MapTypeModifiers, Data.MapTypeModifiersLoc,
3509       Data.IsMapTypeImplicit, Data.ExtraModifierLoc);
3510 }
3511