Bug Summary

File:clang/lib/Parse/ParseOpenMP.cpp
Warning:line 2492, column 7
Value stored to 'HasImplicitClause' is never read

Annotated Source Code

Press '?' to see keyboard shortcuts

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