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