Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
clang 20.0.0git
SemaOpenACCClause.cpp
Go to the documentation of this file.
1//===--- SemaOpenACCClause.cpp - Semantic Analysis for OpenACC clause -----===//
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 semantic analysis for OpenACC clauses.
10///
11//===----------------------------------------------------------------------===//
12
13#include "clang/AST/OpenACCClause.h"
14#include "clang/AST/DeclCXX.h"
15#include "clang/Basic/DiagnosticSema.h"
16#include "clang/Basic/OpenACCKinds.h"
17#include "clang/Sema/SemaOpenACC.h"
18
19using namespace clang;
20
21namespace {
22bool doesClauseApplyToDirective(OpenACCDirectiveKind DirectiveKind,
23 OpenACCClauseKind ClauseKind) {
24 switch (ClauseKind) {
25 // FIXME: For each clause as we implement them, we can add the
26 // 'legalization' list here.
27 case OpenACCClauseKind::Default:
28 switch (DirectiveKind) {
29 case OpenACCDirectiveKind::Parallel:
30 case OpenACCDirectiveKind::Serial:
31 case OpenACCDirectiveKind::Kernels:
32 case OpenACCDirectiveKind::ParallelLoop:
33 case OpenACCDirectiveKind::SerialLoop:
34 case OpenACCDirectiveKind::KernelsLoop:
35 case OpenACCDirectiveKind::Data:
36 return true;
37 default:
38 return false;
39 }
40 case OpenACCClauseKind::If:
41 switch (DirectiveKind) {
42 case OpenACCDirectiveKind::Parallel:
43 case OpenACCDirectiveKind::Serial:
44 case OpenACCDirectiveKind::Kernels:
45 case OpenACCDirectiveKind::Data:
46 case OpenACCDirectiveKind::EnterData:
47 case OpenACCDirectiveKind::ExitData:
48 case OpenACCDirectiveKind::HostData:
49 case OpenACCDirectiveKind::Init:
50 case OpenACCDirectiveKind::Shutdown:
51 case OpenACCDirectiveKind::Set:
52 case OpenACCDirectiveKind::Update:
53 case OpenACCDirectiveKind::Wait:
54 case OpenACCDirectiveKind::ParallelLoop:
55 case OpenACCDirectiveKind::SerialLoop:
56 case OpenACCDirectiveKind::KernelsLoop:
57 return true;
58 default:
59 return false;
60 }
61 case OpenACCClauseKind::Self:
62 switch (DirectiveKind) {
63 case OpenACCDirectiveKind::Parallel:
64 case OpenACCDirectiveKind::Serial:
65 case OpenACCDirectiveKind::Kernels:
66 case OpenACCDirectiveKind::Update:
67 case OpenACCDirectiveKind::ParallelLoop:
68 case OpenACCDirectiveKind::SerialLoop:
69 case OpenACCDirectiveKind::KernelsLoop:
70 return true;
71 default:
72 return false;
73 }
74 case OpenACCClauseKind::NumGangs:
75 case OpenACCClauseKind::NumWorkers:
76 case OpenACCClauseKind::VectorLength:
77 switch (DirectiveKind) {
78 case OpenACCDirectiveKind::Parallel:
79 case OpenACCDirectiveKind::Kernels:
80 case OpenACCDirectiveKind::ParallelLoop:
81 case OpenACCDirectiveKind::KernelsLoop:
82 return true;
83 default:
84 return false;
85 }
86 case OpenACCClauseKind::FirstPrivate:
87 switch (DirectiveKind) {
88 case OpenACCDirectiveKind::Parallel:
89 case OpenACCDirectiveKind::Serial:
90 case OpenACCDirectiveKind::ParallelLoop:
91 case OpenACCDirectiveKind::SerialLoop:
92 return true;
93 default:
94 return false;
95 }
96 case OpenACCClauseKind::Private:
97 switch (DirectiveKind) {
98 case OpenACCDirectiveKind::Parallel:
99 case OpenACCDirectiveKind::Serial:
100 case OpenACCDirectiveKind::Loop:
101 case OpenACCDirectiveKind::ParallelLoop:
102 case OpenACCDirectiveKind::SerialLoop:
103 case OpenACCDirectiveKind::KernelsLoop:
104 return true;
105 default:
106 return false;
107 }
108 case OpenACCClauseKind::NoCreate:
109 switch (DirectiveKind) {
110 case OpenACCDirectiveKind::Parallel:
111 case OpenACCDirectiveKind::Serial:
112 case OpenACCDirectiveKind::Kernels:
113 case OpenACCDirectiveKind::Data:
114 case OpenACCDirectiveKind::ParallelLoop:
115 case OpenACCDirectiveKind::SerialLoop:
116 case OpenACCDirectiveKind::KernelsLoop:
117 return true;
118 default:
119 return false;
120 }
121 case OpenACCClauseKind::Present:
122 switch (DirectiveKind) {
123 case OpenACCDirectiveKind::Parallel:
124 case OpenACCDirectiveKind::Serial:
125 case OpenACCDirectiveKind::Kernels:
126 case OpenACCDirectiveKind::Data:
127 case OpenACCDirectiveKind::Declare:
128 case OpenACCDirectiveKind::ParallelLoop:
129 case OpenACCDirectiveKind::SerialLoop:
130 case OpenACCDirectiveKind::KernelsLoop:
131 return true;
132 default:
133 return false;
134 }
135
136 case OpenACCClauseKind::Copy:
137 case OpenACCClauseKind::PCopy:
138 case OpenACCClauseKind::PresentOrCopy:
139 switch (DirectiveKind) {
140 case OpenACCDirectiveKind::Parallel:
141 case OpenACCDirectiveKind::Serial:
142 case OpenACCDirectiveKind::Kernels:
143 case OpenACCDirectiveKind::Data:
144 case OpenACCDirectiveKind::Declare:
145 case OpenACCDirectiveKind::ParallelLoop:
146 case OpenACCDirectiveKind::SerialLoop:
147 case OpenACCDirectiveKind::KernelsLoop:
148 return true;
149 default:
150 return false;
151 }
152 case OpenACCClauseKind::CopyIn:
153 case OpenACCClauseKind::PCopyIn:
154 case OpenACCClauseKind::PresentOrCopyIn:
155 switch (DirectiveKind) {
156 case OpenACCDirectiveKind::Parallel:
157 case OpenACCDirectiveKind::Serial:
158 case OpenACCDirectiveKind::Kernels:
159 case OpenACCDirectiveKind::Data:
160 case OpenACCDirectiveKind::EnterData:
161 case OpenACCDirectiveKind::Declare:
162 case OpenACCDirectiveKind::ParallelLoop:
163 case OpenACCDirectiveKind::SerialLoop:
164 case OpenACCDirectiveKind::KernelsLoop:
165 return true;
166 default:
167 return false;
168 }
169 case OpenACCClauseKind::CopyOut:
170 case OpenACCClauseKind::PCopyOut:
171 case OpenACCClauseKind::PresentOrCopyOut:
172 switch (DirectiveKind) {
173 case OpenACCDirectiveKind::Parallel:
174 case OpenACCDirectiveKind::Serial:
175 case OpenACCDirectiveKind::Kernels:
176 case OpenACCDirectiveKind::Data:
177 case OpenACCDirectiveKind::ExitData:
178 case OpenACCDirectiveKind::Declare:
179 case OpenACCDirectiveKind::ParallelLoop:
180 case OpenACCDirectiveKind::SerialLoop:
181 case OpenACCDirectiveKind::KernelsLoop:
182 return true;
183 default:
184 return false;
185 }
186 case OpenACCClauseKind::Create:
187 case OpenACCClauseKind::PCreate:
188 case OpenACCClauseKind::PresentOrCreate:
189 switch (DirectiveKind) {
190 case OpenACCDirectiveKind::Parallel:
191 case OpenACCDirectiveKind::Serial:
192 case OpenACCDirectiveKind::Kernels:
193 case OpenACCDirectiveKind::Data:
194 case OpenACCDirectiveKind::EnterData:
195 case OpenACCDirectiveKind::ParallelLoop:
196 case OpenACCDirectiveKind::SerialLoop:
197 case OpenACCDirectiveKind::KernelsLoop:
198 return true;
199 default:
200 return false;
201 }
202
203 case OpenACCClauseKind::Attach:
204 switch (DirectiveKind) {
205 case OpenACCDirectiveKind::Parallel:
206 case OpenACCDirectiveKind::Serial:
207 case OpenACCDirectiveKind::Kernels:
208 case OpenACCDirectiveKind::Data:
209 case OpenACCDirectiveKind::EnterData:
210 case OpenACCDirectiveKind::ParallelLoop:
211 case OpenACCDirectiveKind::SerialLoop:
212 case OpenACCDirectiveKind::KernelsLoop:
213 return true;
214 default:
215 return false;
216 }
217 case OpenACCClauseKind::DevicePtr:
218 switch (DirectiveKind) {
219 case OpenACCDirectiveKind::Parallel:
220 case OpenACCDirectiveKind::Serial:
221 case OpenACCDirectiveKind::Kernels:
222 case OpenACCDirectiveKind::Data:
223 case OpenACCDirectiveKind::Declare:
224 case OpenACCDirectiveKind::ParallelLoop:
225 case OpenACCDirectiveKind::SerialLoop:
226 case OpenACCDirectiveKind::KernelsLoop:
227 return true;
228 default:
229 return false;
230 }
231 case OpenACCClauseKind::Async:
232 switch (DirectiveKind) {
233 case OpenACCDirectiveKind::Parallel:
234 case OpenACCDirectiveKind::Serial:
235 case OpenACCDirectiveKind::Kernels:
236 case OpenACCDirectiveKind::Data:
237 case OpenACCDirectiveKind::EnterData:
238 case OpenACCDirectiveKind::ExitData:
239 case OpenACCDirectiveKind::Set:
240 case OpenACCDirectiveKind::Update:
241 case OpenACCDirectiveKind::Wait:
242 case OpenACCDirectiveKind::ParallelLoop:
243 case OpenACCDirectiveKind::SerialLoop:
244 case OpenACCDirectiveKind::KernelsLoop:
245 return true;
246 default:
247 return false;
248 }
249 case OpenACCClauseKind::Wait:
250 switch (DirectiveKind) {
251 case OpenACCDirectiveKind::Parallel:
252 case OpenACCDirectiveKind::Serial:
253 case OpenACCDirectiveKind::Kernels:
254 case OpenACCDirectiveKind::Data:
255 case OpenACCDirectiveKind::EnterData:
256 case OpenACCDirectiveKind::ExitData:
257 case OpenACCDirectiveKind::Update:
258 case OpenACCDirectiveKind::ParallelLoop:
259 case OpenACCDirectiveKind::SerialLoop:
260 case OpenACCDirectiveKind::KernelsLoop:
261 return true;
262 default:
263 return false;
264 }
265
266 case OpenACCClauseKind::Seq:
267 switch (DirectiveKind) {
268 case OpenACCDirectiveKind::Loop:
269 case OpenACCDirectiveKind::Routine:
270 case OpenACCDirectiveKind::ParallelLoop:
271 case OpenACCDirectiveKind::SerialLoop:
272 case OpenACCDirectiveKind::KernelsLoop:
273 return true;
274 default:
275 return false;
276 }
277
278 case OpenACCClauseKind::Independent:
279 case OpenACCClauseKind::Auto:
280 switch (DirectiveKind) {
281 case OpenACCDirectiveKind::Loop:
282 case OpenACCDirectiveKind::ParallelLoop:
283 case OpenACCDirectiveKind::SerialLoop:
284 case OpenACCDirectiveKind::KernelsLoop:
285 return true;
286 default:
287 return false;
288 }
289
290 case OpenACCClauseKind::Reduction:
291 switch (DirectiveKind) {
292 case OpenACCDirectiveKind::Parallel:
293 case OpenACCDirectiveKind::Serial:
294 case OpenACCDirectiveKind::Loop:
295 case OpenACCDirectiveKind::ParallelLoop:
296 case OpenACCDirectiveKind::SerialLoop:
297 case OpenACCDirectiveKind::KernelsLoop:
298 return true;
299 default:
300 return false;
301 }
302
303 case OpenACCClauseKind::DeviceType:
304 case OpenACCClauseKind::DType:
305 switch (DirectiveKind) {
306 case OpenACCDirectiveKind::Parallel:
307 case OpenACCDirectiveKind::Serial:
308 case OpenACCDirectiveKind::Kernels:
309 case OpenACCDirectiveKind::Data:
310 case OpenACCDirectiveKind::Init:
311 case OpenACCDirectiveKind::Shutdown:
312 case OpenACCDirectiveKind::Set:
313 case OpenACCDirectiveKind::Update:
314 case OpenACCDirectiveKind::Loop:
315 case OpenACCDirectiveKind::Routine:
316 case OpenACCDirectiveKind::ParallelLoop:
317 case OpenACCDirectiveKind::SerialLoop:
318 case OpenACCDirectiveKind::KernelsLoop:
319 return true;
320 default:
321 return false;
322 }
323
324 case OpenACCClauseKind::Collapse: {
325 switch (DirectiveKind) {
326 case OpenACCDirectiveKind::Loop:
327 case OpenACCDirectiveKind::ParallelLoop:
328 case OpenACCDirectiveKind::SerialLoop:
329 case OpenACCDirectiveKind::KernelsLoop:
330 return true;
331 default:
332 return false;
333 }
334 }
335 case OpenACCClauseKind::Tile: {
336 switch (DirectiveKind) {
337 case OpenACCDirectiveKind::Loop:
338 case OpenACCDirectiveKind::ParallelLoop:
339 case OpenACCDirectiveKind::SerialLoop:
340 case OpenACCDirectiveKind::KernelsLoop:
341 return true;
342 default:
343 return false;
344 }
345 }
346
347 case OpenACCClauseKind::Gang: {
348 switch (DirectiveKind) {
349 case OpenACCDirectiveKind::Loop:
350 case OpenACCDirectiveKind::ParallelLoop:
351 case OpenACCDirectiveKind::SerialLoop:
352 case OpenACCDirectiveKind::KernelsLoop:
353 case OpenACCDirectiveKind::Routine:
354 return true;
355 default:
356 return false;
357 }
358 case OpenACCClauseKind::Worker: {
359 switch (DirectiveKind) {
360 case OpenACCDirectiveKind::Loop:
361 case OpenACCDirectiveKind::ParallelLoop:
362 case OpenACCDirectiveKind::SerialLoop:
363 case OpenACCDirectiveKind::KernelsLoop:
364 case OpenACCDirectiveKind::Routine:
365 return true;
366 default:
367 return false;
368 }
369 }
370 case OpenACCClauseKind::Vector: {
371 switch (DirectiveKind) {
372 case OpenACCDirectiveKind::Loop:
373 case OpenACCDirectiveKind::ParallelLoop:
374 case OpenACCDirectiveKind::SerialLoop:
375 case OpenACCDirectiveKind::KernelsLoop:
376 case OpenACCDirectiveKind::Routine:
377 return true;
378 default:
379 return false;
380 }
381 }
382 case OpenACCClauseKind::Finalize: {
383 switch (DirectiveKind) {
384 case OpenACCDirectiveKind::ExitData:
385 return true;
386 default:
387 return false;
388 }
389 }
390 case OpenACCClauseKind::IfPresent: {
391 switch (DirectiveKind) {
392 case OpenACCDirectiveKind::HostData:
393 case OpenACCDirectiveKind::Update:
394 return true;
395 default:
396 return false;
397 }
398 }
399 case OpenACCClauseKind::Delete: {
400 switch (DirectiveKind) {
401 case OpenACCDirectiveKind::ExitData:
402 return true;
403 default:
404 return false;
405 }
406 }
407
408 case OpenACCClauseKind::Detach: {
409 switch (DirectiveKind) {
410 case OpenACCDirectiveKind::ExitData:
411 return true;
412 default:
413 return false;
414 }
415 }
416
417 case OpenACCClauseKind::DeviceNum: {
418 switch (DirectiveKind) {
419 case OpenACCDirectiveKind::Init:
420 case OpenACCDirectiveKind::Shutdown:
421 case OpenACCDirectiveKind::Set:
422 return true;
423 default:
424 return false;
425 }
426 }
427
428 case OpenACCClauseKind::UseDevice: {
429 switch (DirectiveKind) {
430 case OpenACCDirectiveKind::HostData:
431 return true;
432 default:
433 return false;
434 }
435 }
436 case OpenACCClauseKind::DefaultAsync: {
437 switch (DirectiveKind) {
438 case OpenACCDirectiveKind::Set:
439 return true;
440 default:
441 return false;
442 }
443 }
444 case OpenACCClauseKind::Device: {
445 switch (DirectiveKind) {
446 case OpenACCDirectiveKind::Update:
447 return true;
448 default:
449 return false;
450 }
451 }
452 case OpenACCClauseKind::Host: {
453 switch (DirectiveKind) {
454 case OpenACCDirectiveKind::Update:
455 return true;
456 default:
457 return false;
458 }
459 }
460 }
461
462 default:
463 // Do nothing so we can go to the 'unimplemented' diagnostic instead.
464 return true;
465 }
466 llvm_unreachable("Invalid clause kind");
467}
468
469bool checkAlreadyHasClauseOfKind(
470 SemaOpenACC &S, ArrayRef<const OpenACCClause *> ExistingClauses,
471 SemaOpenACC::OpenACCParsedClause &Clause) {
472 const auto *Itr = llvm::find_if(ExistingClauses, [&](const OpenACCClause *C) {
473 return C->getClauseKind() == Clause.getClauseKind();
474 });
475 if (Itr != ExistingClauses.end()) {
476 S.Diag(Clause.getBeginLoc(), diag::err_acc_duplicate_clause_disallowed)
477 << Clause.getDirectiveKind() << Clause.getClauseKind();
478 S.Diag((*Itr)->getBeginLoc(), diag::note_acc_previous_clause_here);
479 return true;
480 }
481 return false;
482}
483bool checkValidAfterDeviceType(
484 SemaOpenACC &S, const OpenACCDeviceTypeClause &DeviceTypeClause,
485 const SemaOpenACC::OpenACCParsedClause &NewClause) {
486 // This is implemented for everything but 'routine', so treat as 'fine' for
487 // that.
488 if (NewClause.getDirectiveKind() == OpenACCDirectiveKind::Routine)
489 return false;
490
491 // OpenACC3.3: Section 2.4: Clauses that precede any device_type clause are
492 // default clauses. Clauses that follow a device_type clause up to the end of
493 // the directive or up to the next device_type clause are device-specific
494 // clauses for the device types specified in the device_type argument.
495 //
496 // The above implies that despite what the individual text says, these are
497 // valid.
498 if (NewClause.getClauseKind() == OpenACCClauseKind::DType ||
499 NewClause.getClauseKind() == OpenACCClauseKind::DeviceType)
500 return false;
501
502 // Implement check from OpenACC3.3: section 2.5.4:
503 // Only the async, wait, num_gangs, num_workers, and vector_length clauses may
504 // follow a device_type clause.
505 if (isOpenACCComputeDirectiveKind(NewClause.getDirectiveKind())) {
506 switch (NewClause.getClauseKind()) {
507 case OpenACCClauseKind::Async:
508 case OpenACCClauseKind::Wait:
509 case OpenACCClauseKind::NumGangs:
510 case OpenACCClauseKind::NumWorkers:
511 case OpenACCClauseKind::VectorLength:
512 return false;
513 default:
514 break;
515 }
516 } else if (NewClause.getDirectiveKind() == OpenACCDirectiveKind::Loop) {
517 // Implement check from OpenACC3.3: section 2.9:
518 // Only the collapse, gang, worker, vector, seq, independent, auto, and tile
519 // clauses may follow a device_type clause.
520 switch (NewClause.getClauseKind()) {
521 case OpenACCClauseKind::Collapse:
522 case OpenACCClauseKind::Gang:
523 case OpenACCClauseKind::Worker:
524 case OpenACCClauseKind::Vector:
525 case OpenACCClauseKind::Seq:
526 case OpenACCClauseKind::Independent:
527 case OpenACCClauseKind::Auto:
528 case OpenACCClauseKind::Tile:
529 return false;
530 default:
531 break;
532 }
533 } else if (isOpenACCCombinedDirectiveKind(NewClause.getDirectiveKind())) {
534 // This seems like it should be the union of 2.9 and 2.5.4 from above.
535 switch (NewClause.getClauseKind()) {
536 case OpenACCClauseKind::Async:
537 case OpenACCClauseKind::Wait:
538 case OpenACCClauseKind::NumGangs:
539 case OpenACCClauseKind::NumWorkers:
540 case OpenACCClauseKind::VectorLength:
541 case OpenACCClauseKind::Collapse:
542 case OpenACCClauseKind::Gang:
543 case OpenACCClauseKind::Worker:
544 case OpenACCClauseKind::Vector:
545 case OpenACCClauseKind::Seq:
546 case OpenACCClauseKind::Independent:
547 case OpenACCClauseKind::Auto:
548 case OpenACCClauseKind::Tile:
549 return false;
550 default:
551 break;
552 }
553 } else if (NewClause.getDirectiveKind() == OpenACCDirectiveKind::Data) {
554 // OpenACC3.3 section 2.6.5: Only the async and wait clauses may follow a
555 // device_type clause.
556 switch (NewClause.getClauseKind()) {
557 case OpenACCClauseKind::Async:
558 case OpenACCClauseKind::Wait:
559 return false;
560 default:
561 break;
562 }
563 } else if (NewClause.getDirectiveKind() == OpenACCDirectiveKind::Set ||
564 NewClause.getDirectiveKind() == OpenACCDirectiveKind::Init ||
565 NewClause.getDirectiveKind() == OpenACCDirectiveKind::Shutdown) {
566 // There are no restrictions on 'set', 'init', or 'shutdown'.
567 return false;
568 } else if (NewClause.getDirectiveKind() == OpenACCDirectiveKind::Update) {
569 // OpenACC3.3 section 2.14.4: Only the async and wait clauses may follow a
570 // device_type clause.
571 switch (NewClause.getClauseKind()) {
572 case OpenACCClauseKind::Async:
573 case OpenACCClauseKind::Wait:
574 return false;
575 default:
576 break;
577 }
578 }
579 S.Diag(NewClause.getBeginLoc(), diag::err_acc_clause_after_device_type)
580 << NewClause.getClauseKind() << DeviceTypeClause.getClauseKind()
581 << NewClause.getDirectiveKind();
582 S.Diag(DeviceTypeClause.getBeginLoc(), diag::note_acc_previous_clause_here);
583 return true;
584}
585
586// A temporary function that helps implement the 'not implemented' check at the
587// top of each clause checking function. This should only be used in conjunction
588// with the one being currently implemented/only updated after the entire
589// construct has been implemented.
590bool isDirectiveKindImplemented(OpenACCDirectiveKind DK) {
591 return DK != OpenACCDirectiveKind::Declare &&
592 DK != OpenACCDirectiveKind::Atomic &&
593 DK != OpenACCDirectiveKind::Routine;
594}
595
596class SemaOpenACCClauseVisitor {
597 SemaOpenACC &SemaRef;
598 ASTContext &Ctx;
599 ArrayRef<const OpenACCClause *> ExistingClauses;
600 bool NotImplemented = false;
601
602 OpenACCClause *isNotImplemented() {
603 NotImplemented = true;
604 return nullptr;
605 }
606
607 // OpenACC 3.3 2.9:
608 // A 'gang', 'worker', or 'vector' clause may not appear if a 'seq' clause
609 // appears.
610 bool DiagIfSeqClause(SemaOpenACC::OpenACCParsedClause &Clause) {
611 const auto *Itr =
612 llvm::find_if(ExistingClauses, llvm::IsaPred<OpenACCSeqClause>);
613
614 if (Itr != ExistingClauses.end()) {
615 SemaRef.Diag(Clause.getBeginLoc(), diag::err_acc_clause_cannot_combine)
616 << Clause.getClauseKind() << (*Itr)->getClauseKind()
617 << Clause.getDirectiveKind();
618 SemaRef.Diag((*Itr)->getBeginLoc(), diag::note_acc_previous_clause_here);
619
620 return true;
621 }
622 return false;
623 }
624
625public:
626 SemaOpenACCClauseVisitor(SemaOpenACC &S,
627 ArrayRef<const OpenACCClause *> ExistingClauses)
628 : SemaRef(S), Ctx(S.getASTContext()), ExistingClauses(ExistingClauses) {}
629 // Once we've implemented everything, we shouldn't need this infrastructure.
630 // But in the meantime, we use this to help decide whether the clause was
631 // handled for this directive.
632 bool diagNotImplemented() { return NotImplemented; }
633
634 OpenACCClause *Visit(SemaOpenACC::OpenACCParsedClause &Clause) {
635 switch (Clause.getClauseKind()) {
636#define VISIT_CLAUSE(CLAUSE_NAME) \
637 case OpenACCClauseKind::CLAUSE_NAME: \
638 return Visit##CLAUSE_NAME##Clause(Clause);
639#define CLAUSE_ALIAS(ALIAS, CLAUSE_NAME, DEPRECATED) \
640 case OpenACCClauseKind::ALIAS: \
641 if (DEPRECATED) \
642 SemaRef.Diag(Clause.getBeginLoc(), diag::warn_acc_deprecated_alias_name) \
643 << Clause.getClauseKind() << OpenACCClauseKind::CLAUSE_NAME; \
644 return Visit##CLAUSE_NAME##Clause(Clause);
645#include "clang/Basic/OpenACCClauses.def"
646 default:
647 return isNotImplemented();
648 }
649 llvm_unreachable("Invalid clause kind");
650 }
651
652#define VISIT_CLAUSE(CLAUSE_NAME) \
653 OpenACCClause *Visit##CLAUSE_NAME##Clause( \
654 SemaOpenACC::OpenACCParsedClause &Clause);
655#include "clang/Basic/OpenACCClauses.def"
656};
657
658OpenACCClause *SemaOpenACCClauseVisitor::VisitDefaultClause(
659 SemaOpenACC::OpenACCParsedClause &Clause) {
660 // Don't add an invalid clause to the AST.
661 if (Clause.getDefaultClauseKind() == OpenACCDefaultClauseKind::Invalid)
662 return nullptr;
663
664 // OpenACC 3.3, Section 2.5.4:
665 // At most one 'default' clause may appear, and it must have a value of
666 // either 'none' or 'present'.
667 // Second half of the sentence is diagnosed during parsing.
668 if (checkAlreadyHasClauseOfKind(SemaRef, ExistingClauses, Clause))
669 return nullptr;
670
671 return OpenACCDefaultClause::Create(
672 Ctx, Clause.getDefaultClauseKind(), Clause.getBeginLoc(),
673 Clause.getLParenLoc(), Clause.getEndLoc());
674}
675
676OpenACCClause *SemaOpenACCClauseVisitor::VisitTileClause(
677 SemaOpenACC::OpenACCParsedClause &Clause) {
678
679 // Duplicates here are not really sensible. We could possible permit
680 // multiples if they all had the same value, but there isn't really a good
681 // reason to do so. Also, this simplifies the suppression of duplicates, in
682 // that we know if we 'find' one after instantiation, that it is the same
683 // clause, which simplifies instantiation/checking/etc.
684 if (checkAlreadyHasClauseOfKind(SemaRef, ExistingClauses, Clause))
685 return nullptr;
686
687 llvm::SmallVector<Expr *> NewSizeExprs;
688
689 // Make sure these are all positive constant expressions or *.
690 for (Expr *E : Clause.getIntExprs()) {
691 ExprResult Res = SemaRef.CheckTileSizeExpr(E);
692
693 if (!Res.isUsable())
694 return nullptr;
695
696 NewSizeExprs.push_back(Res.get());
697 }
698
699 return OpenACCTileClause::Create(Ctx, Clause.getBeginLoc(),
700 Clause.getLParenLoc(), NewSizeExprs,
701 Clause.getEndLoc());
702}
703
704OpenACCClause *SemaOpenACCClauseVisitor::VisitIfClause(
705 SemaOpenACC::OpenACCParsedClause &Clause) {
706 // There is no prose in the standard that says duplicates aren't allowed,
707 // but this diagnostic is present in other compilers, as well as makes
708 // sense. Prose DOES exist for 'data' and 'host_data', 'set', 'enter data' and
709 // 'exit data' both don't, but other implmementations do this. OpenACC issue
710 // 519 filed for the latter two. Prose also exists for 'update'.
711 // GCC allows this on init/shutdown, presumably for good reason, so we do too.
712 if (Clause.getDirectiveKind() != OpenACCDirectiveKind::Init &&
713 Clause.getDirectiveKind() != OpenACCDirectiveKind::Shutdown &&
714 checkAlreadyHasClauseOfKind(SemaRef, ExistingClauses, Clause))
715 return nullptr;
716
717 // The parser has ensured that we have a proper condition expr, so there
718 // isn't really much to do here.
719
720 // If the 'if' clause is true, it makes the 'self' clause have no effect,
721 // diagnose that here. This only applies on compute/combined constructs.
722 if (Clause.getDirectiveKind() != OpenACCDirectiveKind::Update) {
723 const auto *Itr =
724 llvm::find_if(ExistingClauses, llvm::IsaPred<OpenACCSelfClause>);
725 if (Itr != ExistingClauses.end()) {
726 SemaRef.Diag(Clause.getBeginLoc(), diag::warn_acc_if_self_conflict);
727 SemaRef.Diag((*Itr)->getBeginLoc(), diag::note_acc_previous_clause_here);
728 }
729 }
730
731 return OpenACCIfClause::Create(Ctx, Clause.getBeginLoc(),
732 Clause.getLParenLoc(),
733 Clause.getConditionExpr(), Clause.getEndLoc());
734}
735
736OpenACCClause *SemaOpenACCClauseVisitor::VisitSelfClause(
737 SemaOpenACC::OpenACCParsedClause &Clause) {
738 // There is no prose in the standard that says duplicates aren't allowed,
739 // but this diagnostic is present in other compilers, as well as makes
740 // sense.
741 if (checkAlreadyHasClauseOfKind(SemaRef, ExistingClauses, Clause))
742 return nullptr;
743
744 // If the 'if' clause is true, it makes the 'self' clause have no effect,
745 // diagnose that here. This only applies on compute/combined constructs.
746 if (Clause.getDirectiveKind() == OpenACCDirectiveKind::Update)
747 return OpenACCSelfClause::Create(Ctx, Clause.getBeginLoc(),
748 Clause.getLParenLoc(), Clause.getVarList(),
749 Clause.getEndLoc());
750
751 const auto *Itr =
752 llvm::find_if(ExistingClauses, llvm::IsaPred<OpenACCIfClause>);
753 if (Itr != ExistingClauses.end()) {
754 SemaRef.Diag(Clause.getBeginLoc(), diag::warn_acc_if_self_conflict);
755 SemaRef.Diag((*Itr)->getBeginLoc(), diag::note_acc_previous_clause_here);
756 }
757 return OpenACCSelfClause::Create(
758 Ctx, Clause.getBeginLoc(), Clause.getLParenLoc(),
759 Clause.getConditionExpr(), Clause.getEndLoc());
760}
761
762OpenACCClause *SemaOpenACCClauseVisitor::VisitNumGangsClause(
763 SemaOpenACC::OpenACCParsedClause &Clause) {
764 // There is no prose in the standard that says duplicates aren't allowed,
765 // but this diagnostic is present in other compilers, as well as makes
766 // sense.
767 if (checkAlreadyHasClauseOfKind(SemaRef, ExistingClauses, Clause))
768 return nullptr;
769
770 // num_gangs requires at least 1 int expr in all forms. Diagnose here, but
771 // allow us to continue, an empty clause might be useful for future
772 // diagnostics.
773 if (Clause.getIntExprs().empty())
774 SemaRef.Diag(Clause.getBeginLoc(), diag::err_acc_num_gangs_num_args)
775 << /*NoArgs=*/0;
776
777 unsigned MaxArgs =
778 (Clause.getDirectiveKind() == OpenACCDirectiveKind::Parallel ||
779 Clause.getDirectiveKind() == OpenACCDirectiveKind::ParallelLoop)
780 ? 3
781 : 1;
782 // The max number of args differs between parallel and other constructs.
783 // Again, allow us to continue for the purposes of future diagnostics.
784 if (Clause.getIntExprs().size() > MaxArgs)
785 SemaRef.Diag(Clause.getBeginLoc(), diag::err_acc_num_gangs_num_args)
786 << /*NoArgs=*/1 << Clause.getDirectiveKind() << MaxArgs
787 << Clause.getIntExprs().size();
788
789 // OpenACC 3.3 Section 2.9.11: A reduction clause may not appear on a loop
790 // directive that has a gang clause and is within a compute construct that has
791 // a num_gangs clause with more than one explicit argument.
792 if (Clause.getIntExprs().size() > 1 &&
793 isOpenACCCombinedDirectiveKind(Clause.getDirectiveKind())) {
794 auto *GangClauseItr =
795 llvm::find_if(ExistingClauses, llvm::IsaPred<OpenACCGangClause>);
796 auto *ReductionClauseItr =
797 llvm::find_if(ExistingClauses, llvm::IsaPred<OpenACCReductionClause>);
798
799 if (GangClauseItr != ExistingClauses.end() &&
800 ReductionClauseItr != ExistingClauses.end()) {
801 SemaRef.Diag(Clause.getBeginLoc(),
802 diag::err_acc_gang_reduction_numgangs_conflict)
803 << OpenACCClauseKind::Reduction << OpenACCClauseKind::Gang
804 << Clause.getDirectiveKind() << /*is on combined directive=*/1;
805 SemaRef.Diag((*ReductionClauseItr)->getBeginLoc(),
806 diag::note_acc_previous_clause_here);
807 SemaRef.Diag((*GangClauseItr)->getBeginLoc(),
808 diag::note_acc_previous_clause_here);
809 return nullptr;
810 }
811 }
812
813 // OpenACC 3.3 Section 2.5.4:
814 // A reduction clause may not appear on a parallel construct with a
815 // num_gangs clause that has more than one argument.
816 if ((Clause.getDirectiveKind() == OpenACCDirectiveKind::Parallel ||
817 Clause.getDirectiveKind() == OpenACCDirectiveKind::ParallelLoop) &&
818 Clause.getIntExprs().size() > 1) {
819 auto *Parallel =
820 llvm::find_if(ExistingClauses, llvm::IsaPred<OpenACCReductionClause>);
821
822 if (Parallel != ExistingClauses.end()) {
823 SemaRef.Diag(Clause.getBeginLoc(),
824 diag::err_acc_reduction_num_gangs_conflict)
825 << /*>1 arg in first loc=*/1 << Clause.getClauseKind()
826 << Clause.getDirectiveKind() << OpenACCClauseKind::Reduction;
827 SemaRef.Diag((*Parallel)->getBeginLoc(),
828 diag::note_acc_previous_clause_here);
829 return nullptr;
830 }
831 }
832
833 // OpenACC 3.3 Section 2.9.2:
834 // An argument with no keyword or with the 'num' keyword is allowed only when
835 // the 'num_gangs' does not appear on the 'kernel' construct.
836 if (Clause.getDirectiveKind() == OpenACCDirectiveKind::KernelsLoop) {
837 auto GangClauses = llvm::make_filter_range(
838 ExistingClauses, llvm::IsaPred<OpenACCGangClause>);
839
840 for (auto *GC : GangClauses) {
841 if (cast<OpenACCGangClause>(GC)->hasExprOfKind(OpenACCGangKind::Num)) {
842 SemaRef.Diag(Clause.getBeginLoc(),
843 diag::err_acc_num_arg_conflict_reverse)
844 << OpenACCClauseKind::NumGangs << OpenACCClauseKind::Gang
845 << /*Num argument*/ 1;
846 SemaRef.Diag(GC->getBeginLoc(), diag::note_acc_previous_clause_here);
847 return nullptr;
848 }
849 }
850 }
851
852 return OpenACCNumGangsClause::Create(
853 Ctx, Clause.getBeginLoc(), Clause.getLParenLoc(), Clause.getIntExprs(),
854 Clause.getEndLoc());
855}
856
857OpenACCClause *SemaOpenACCClauseVisitor::VisitNumWorkersClause(
858 SemaOpenACC::OpenACCParsedClause &Clause) {
859 // There is no prose in the standard that says duplicates aren't allowed,
860 // but this diagnostic is present in other compilers, as well as makes
861 // sense.
862 if (checkAlreadyHasClauseOfKind(SemaRef, ExistingClauses, Clause))
863 return nullptr;
864
865 // OpenACC 3.3 Section 2.9.2:
866 // An argument is allowed only when the 'num_workers' does not appear on the
867 // kernels construct.
868 if (Clause.getDirectiveKind() == OpenACCDirectiveKind::KernelsLoop) {
869 auto WorkerClauses = llvm::make_filter_range(
870 ExistingClauses, llvm::IsaPred<OpenACCWorkerClause>);
871
872 for (auto *WC : WorkerClauses) {
873 if (cast<OpenACCWorkerClause>(WC)->hasIntExpr()) {
874 SemaRef.Diag(Clause.getBeginLoc(),
875 diag::err_acc_num_arg_conflict_reverse)
876 << OpenACCClauseKind::NumWorkers << OpenACCClauseKind::Worker
877 << /*num argument*/ 0;
878 SemaRef.Diag(WC->getBeginLoc(), diag::note_acc_previous_clause_here);
879 return nullptr;
880 }
881 }
882 }
883
884 assert(Clause.getIntExprs().size() == 1 &&
885 "Invalid number of expressions for NumWorkers");
886 return OpenACCNumWorkersClause::Create(
887 Ctx, Clause.getBeginLoc(), Clause.getLParenLoc(), Clause.getIntExprs()[0],
888 Clause.getEndLoc());
889}
890
891OpenACCClause *SemaOpenACCClauseVisitor::VisitVectorLengthClause(
892 SemaOpenACC::OpenACCParsedClause &Clause) {
893 // There is no prose in the standard that says duplicates aren't allowed,
894 // but this diagnostic is present in other compilers, as well as makes
895 // sense.
896 if (checkAlreadyHasClauseOfKind(SemaRef, ExistingClauses, Clause))
897 return nullptr;
898
899 // OpenACC 3.3 Section 2.9.4:
900 // An argument is allowed only when the 'vector_length' does not appear on the
901 // 'kernels' construct.
902 if (Clause.getDirectiveKind() == OpenACCDirectiveKind::KernelsLoop) {
903 auto VectorClauses = llvm::make_filter_range(
904 ExistingClauses, llvm::IsaPred<OpenACCVectorClause>);
905
906 for (auto *VC : VectorClauses) {
907 if (cast<OpenACCVectorClause>(VC)->hasIntExpr()) {
908 SemaRef.Diag(Clause.getBeginLoc(),
909 diag::err_acc_num_arg_conflict_reverse)
910 << OpenACCClauseKind::VectorLength << OpenACCClauseKind::Vector
911 << /*num argument*/ 0;
912 SemaRef.Diag(VC->getBeginLoc(), diag::note_acc_previous_clause_here);
913 return nullptr;
914 }
915 }
916 }
917
918 assert(Clause.getIntExprs().size() == 1 &&
919 "Invalid number of expressions for NumWorkers");
920 return OpenACCVectorLengthClause::Create(
921 Ctx, Clause.getBeginLoc(), Clause.getLParenLoc(), Clause.getIntExprs()[0],
922 Clause.getEndLoc());
923}
924
925OpenACCClause *SemaOpenACCClauseVisitor::VisitAsyncClause(
926 SemaOpenACC::OpenACCParsedClause &Clause) {
927 // There is no prose in the standard that says duplicates aren't allowed,
928 // but this diagnostic is present in other compilers, as well as makes
929 // sense.
930 if (checkAlreadyHasClauseOfKind(SemaRef, ExistingClauses, Clause))
931 return nullptr;
932
933 assert(Clause.getNumIntExprs() < 2 &&
934 "Invalid number of expressions for Async");
935 return OpenACCAsyncClause::Create(
936 Ctx, Clause.getBeginLoc(), Clause.getLParenLoc(),
937 Clause.getNumIntExprs() != 0 ? Clause.getIntExprs()[0] : nullptr,
938 Clause.getEndLoc());
939}
940
941OpenACCClause *SemaOpenACCClauseVisitor::VisitDeviceNumClause(
942 SemaOpenACC::OpenACCParsedClause &Clause) {
943 // Restrictions only properly implemented on certain constructs, so skip/treat
944 // as unimplemented in those cases.
945 if (!isDirectiveKindImplemented(Clause.getDirectiveKind()))
946 return isNotImplemented();
947
948 // OpenACC 3.3 2.14.3: Two instances of the same clause may not appear on the
949 // same directive.
950 if (Clause.getDirectiveKind() == OpenACCDirectiveKind::Set &&
951 checkAlreadyHasClauseOfKind(SemaRef, ExistingClauses, Clause))
952 return nullptr;
953
954 assert(Clause.getNumIntExprs() == 1 &&
955 "Invalid number of expressions for device_num");
956 return OpenACCDeviceNumClause::Create(
957 Ctx, Clause.getBeginLoc(), Clause.getLParenLoc(), Clause.getIntExprs()[0],
958 Clause.getEndLoc());
959}
960
961OpenACCClause *SemaOpenACCClauseVisitor::VisitDefaultAsyncClause(
962 SemaOpenACC::OpenACCParsedClause &Clause) {
963 // OpenACC 3.3 2.14.3: Two instances of the same clause may not appear on the
964 // same directive.
965 if (checkAlreadyHasClauseOfKind(SemaRef, ExistingClauses, Clause))
966 return nullptr;
967
968 assert(Clause.getNumIntExprs() == 1 &&
969 "Invalid number of expressions for default_async");
970 return OpenACCDefaultAsyncClause::Create(
971 Ctx, Clause.getBeginLoc(), Clause.getLParenLoc(), Clause.getIntExprs()[0],
972 Clause.getEndLoc());
973}
974
975OpenACCClause *SemaOpenACCClauseVisitor::VisitPrivateClause(
976 SemaOpenACC::OpenACCParsedClause &Clause) {
977 // ActOnVar ensured that everything is a valid variable reference, so there
978 // really isn't anything to do here. GCC does some duplicate-finding, though
979 // it isn't apparent in the standard where this is justified.
980
981 return OpenACCPrivateClause::Create(Ctx, Clause.getBeginLoc(),
982 Clause.getLParenLoc(),
983 Clause.getVarList(), Clause.getEndLoc());
984}
985
986OpenACCClause *SemaOpenACCClauseVisitor::VisitFirstPrivateClause(
987 SemaOpenACC::OpenACCParsedClause &Clause) {
988 // ActOnVar ensured that everything is a valid variable reference, so there
989 // really isn't anything to do here. GCC does some duplicate-finding, though
990 // it isn't apparent in the standard where this is justified.
991
992 return OpenACCFirstPrivateClause::Create(
993 Ctx, Clause.getBeginLoc(), Clause.getLParenLoc(), Clause.getVarList(),
994 Clause.getEndLoc());
995}
996
997OpenACCClause *SemaOpenACCClauseVisitor::VisitNoCreateClause(
998 SemaOpenACC::OpenACCParsedClause &Clause) {
999 // ActOnVar ensured that everything is a valid variable reference, so there
1000 // really isn't anything to do here. GCC does some duplicate-finding, though
1001 // it isn't apparent in the standard where this is justified.
1002
1003 return OpenACCNoCreateClause::Create(Ctx, Clause.getBeginLoc(),
1004 Clause.getLParenLoc(),
1005 Clause.getVarList(), Clause.getEndLoc());
1006}
1007
1008OpenACCClause *SemaOpenACCClauseVisitor::VisitPresentClause(
1009 SemaOpenACC::OpenACCParsedClause &Clause) {
1010 // Restrictions only properly implemented on 'compute'/'combined'/'data'
1011 // constructs, and 'compute'/'combined'/'data' constructs are the only
1012 // construct that can do anything with this yet, so skip/treat as
1013 // unimplemented in this case.
1014 if (!isDirectiveKindImplemented(Clause.getDirectiveKind()))
1015 return isNotImplemented();
1016 // ActOnVar ensured that everything is a valid variable reference, so there
1017 // really isn't anything to do here. GCC does some duplicate-finding, though
1018 // it isn't apparent in the standard where this is justified.
1019
1020 return OpenACCPresentClause::Create(Ctx, Clause.getBeginLoc(),
1021 Clause.getLParenLoc(),
1022 Clause.getVarList(), Clause.getEndLoc());
1023}
1024
1025OpenACCClause *SemaOpenACCClauseVisitor::VisitHostClause(
1026 SemaOpenACC::OpenACCParsedClause &Clause) {
1027 // ActOnVar ensured that everything is a valid variable reference, so there
1028 // really isn't anything to do here. GCC does some duplicate-finding, though
1029 // it isn't apparent in the standard where this is justified.
1030
1031 return OpenACCHostClause::Create(Ctx, Clause.getBeginLoc(),
1032 Clause.getLParenLoc(), Clause.getVarList(),
1033 Clause.getEndLoc());
1034}
1035
1036OpenACCClause *SemaOpenACCClauseVisitor::VisitDeviceClause(
1037 SemaOpenACC::OpenACCParsedClause &Clause) {
1038 // ActOnVar ensured that everything is a valid variable reference, so there
1039 // really isn't anything to do here. GCC does some duplicate-finding, though
1040 // it isn't apparent in the standard where this is justified.
1041
1042 return OpenACCDeviceClause::Create(Ctx, Clause.getBeginLoc(),
1043 Clause.getLParenLoc(), Clause.getVarList(),
1044 Clause.getEndLoc());
1045}
1046
1047OpenACCClause *SemaOpenACCClauseVisitor::VisitCopyClause(
1048 SemaOpenACC::OpenACCParsedClause &Clause) {
1049 // Restrictions only properly implemented on 'compute'/'combined'/'data'
1050 // constructs, and 'compute'/'combined'/'data' constructs are the only
1051 // construct that can do anything with this yet, so skip/treat as
1052 // unimplemented in this case.
1053 if (!isDirectiveKindImplemented(Clause.getDirectiveKind()))
1054 return isNotImplemented();
1055 // ActOnVar ensured that everything is a valid variable reference, so there
1056 // really isn't anything to do here. GCC does some duplicate-finding, though
1057 // it isn't apparent in the standard where this is justified.
1058
1059 return OpenACCCopyClause::Create(
1060 Ctx, Clause.getClauseKind(), Clause.getBeginLoc(), Clause.getLParenLoc(),
1061 Clause.getVarList(), Clause.getEndLoc());
1062}
1063
1064OpenACCClause *SemaOpenACCClauseVisitor::VisitCopyInClause(
1065 SemaOpenACC::OpenACCParsedClause &Clause) {
1066 // Restrictions only properly implemented on 'compute'/'combined'/'data'
1067 // constructs, and 'compute'/'combined'/'data' constructs are the only
1068 // construct that can do anything with this yet, so skip/treat as
1069 // unimplemented in this case.
1070 if (!isDirectiveKindImplemented(Clause.getDirectiveKind()))
1071 return isNotImplemented();
1072 // ActOnVar ensured that everything is a valid variable reference, so there
1073 // really isn't anything to do here. GCC does some duplicate-finding, though
1074 // it isn't apparent in the standard where this is justified.
1075
1076 return OpenACCCopyInClause::Create(
1077 Ctx, Clause.getClauseKind(), Clause.getBeginLoc(), Clause.getLParenLoc(),
1078 Clause.isReadOnly(), Clause.getVarList(), Clause.getEndLoc());
1079}
1080
1081OpenACCClause *SemaOpenACCClauseVisitor::VisitCopyOutClause(
1082 SemaOpenACC::OpenACCParsedClause &Clause) {
1083 // Restrictions only properly implemented on 'compute'/'combined'/'data'
1084 // constructs, and 'compute'/'combined'/'data' constructs are the only
1085 // construct that can do anything with this yet, so skip/treat as
1086 // unimplemented in this case.
1087 if (!isDirectiveKindImplemented(Clause.getDirectiveKind()))
1088 return isNotImplemented();
1089 // ActOnVar ensured that everything is a valid variable reference, so there
1090 // really isn't anything to do here. GCC does some duplicate-finding, though
1091 // it isn't apparent in the standard where this is justified.
1092
1093 return OpenACCCopyOutClause::Create(
1094 Ctx, Clause.getClauseKind(), Clause.getBeginLoc(), Clause.getLParenLoc(),
1095 Clause.isZero(), Clause.getVarList(), Clause.getEndLoc());
1096}
1097
1098OpenACCClause *SemaOpenACCClauseVisitor::VisitCreateClause(
1099 SemaOpenACC::OpenACCParsedClause &Clause) {
1100 // ActOnVar ensured that everything is a valid variable reference, so there
1101 // really isn't anything to do here. GCC does some duplicate-finding, though
1102 // it isn't apparent in the standard where this is justified.
1103
1104 return OpenACCCreateClause::Create(
1105 Ctx, Clause.getClauseKind(), Clause.getBeginLoc(), Clause.getLParenLoc(),
1106 Clause.isZero(), Clause.getVarList(), Clause.getEndLoc());
1107}
1108
1109OpenACCClause *SemaOpenACCClauseVisitor::VisitAttachClause(
1110 SemaOpenACC::OpenACCParsedClause &Clause) {
1111 // ActOnVar ensured that everything is a valid variable reference, but we
1112 // still have to make sure it is a pointer type.
1113 llvm::SmallVector<Expr *> VarList{Clause.getVarList()};
1114 llvm::erase_if(VarList, [&](Expr *E) {
1115 return SemaRef.CheckVarIsPointerType(OpenACCClauseKind::Attach, E);
1116 });
1117 Clause.setVarListDetails(VarList,
1118 /*IsReadOnly=*/false, /*IsZero=*/false);
1119 return OpenACCAttachClause::Create(Ctx, Clause.getBeginLoc(),
1120 Clause.getLParenLoc(), Clause.getVarList(),
1121 Clause.getEndLoc());
1122}
1123
1124OpenACCClause *SemaOpenACCClauseVisitor::VisitDetachClause(
1125 SemaOpenACC::OpenACCParsedClause &Clause) {
1126 // ActOnVar ensured that everything is a valid variable reference, but we
1127 // still have to make sure it is a pointer type.
1128 llvm::SmallVector<Expr *> VarList{Clause.getVarList()};
1129 llvm::erase_if(VarList, [&](Expr *E) {
1130 return SemaRef.CheckVarIsPointerType(OpenACCClauseKind::Detach, E);
1131 });
1132 Clause.setVarListDetails(VarList,
1133 /*IsReadOnly=*/false, /*IsZero=*/false);
1134 return OpenACCDetachClause::Create(Ctx, Clause.getBeginLoc(),
1135 Clause.getLParenLoc(), Clause.getVarList(),
1136 Clause.getEndLoc());
1137}
1138
1139OpenACCClause *SemaOpenACCClauseVisitor::VisitDeleteClause(
1140 SemaOpenACC::OpenACCParsedClause &Clause) {
1141 // ActOnVar ensured that everything is a valid variable reference, so there
1142 // really isn't anything to do here. GCC does some duplicate-finding, though
1143 // it isn't apparent in the standard where this is justified.
1144 return OpenACCDeleteClause::Create(Ctx, Clause.getBeginLoc(),
1145 Clause.getLParenLoc(), Clause.getVarList(),
1146 Clause.getEndLoc());
1147}
1148
1149OpenACCClause *SemaOpenACCClauseVisitor::VisitUseDeviceClause(
1150 SemaOpenACC::OpenACCParsedClause &Clause) {
1151 // ActOnVar ensured that everything is a valid variable or array, so nothing
1152 // left to do here.
1153 return OpenACCUseDeviceClause::Create(
1154 Ctx, Clause.getBeginLoc(), Clause.getLParenLoc(), Clause.getVarList(),
1155 Clause.getEndLoc());
1156}
1157
1158OpenACCClause *SemaOpenACCClauseVisitor::VisitDevicePtrClause(
1159 SemaOpenACC::OpenACCParsedClause &Clause) {
1160 // Restrictions only properly implemented on 'compute'/'combined'/'data'
1161 // constructs, and 'compute'/'combined'/'data' constructs are the only
1162 // construct that can do anything with this yet, so skip/treat as
1163 // unimplemented in this case.
1164 if (!isDirectiveKindImplemented(Clause.getDirectiveKind()))
1165 return isNotImplemented();
1166
1167 // ActOnVar ensured that everything is a valid variable reference, but we
1168 // still have to make sure it is a pointer type.
1169 llvm::SmallVector<Expr *> VarList{Clause.getVarList()};
1170 llvm::erase_if(VarList, [&](Expr *E) {
1171 return SemaRef.CheckVarIsPointerType(OpenACCClauseKind::DevicePtr, E);
1172 });
1173 Clause.setVarListDetails(VarList,
1174 /*IsReadOnly=*/false, /*IsZero=*/false);
1175
1176 return OpenACCDevicePtrClause::Create(
1177 Ctx, Clause.getBeginLoc(), Clause.getLParenLoc(), Clause.getVarList(),
1178 Clause.getEndLoc());
1179}
1180
1181OpenACCClause *SemaOpenACCClauseVisitor::VisitWaitClause(
1182 SemaOpenACC::OpenACCParsedClause &Clause) {
1183 return OpenACCWaitClause::Create(
1184 Ctx, Clause.getBeginLoc(), Clause.getLParenLoc(), Clause.getDevNumExpr(),
1185 Clause.getQueuesLoc(), Clause.getQueueIdExprs(), Clause.getEndLoc());
1186}
1187
1188OpenACCClause *SemaOpenACCClauseVisitor::VisitDeviceTypeClause(
1189 SemaOpenACC::OpenACCParsedClause &Clause) {
1190 // Restrictions implemented properly on everything except 'routine'.
1191 if (Clause.getDirectiveKind() == OpenACCDirectiveKind::Routine)
1192 return isNotImplemented();
1193
1194 // OpenACC 3.3 2.14.3: Two instances of the same clause may not appear on the
1195 // same directive.
1196 if (Clause.getDirectiveKind() == OpenACCDirectiveKind::Set &&
1197 checkAlreadyHasClauseOfKind(SemaRef, ExistingClauses, Clause))
1198 return nullptr;
1199
1200 // TODO OpenACC: Once we get enough of the CodeGen implemented that we have
1201 // a source for the list of valid architectures, we need to warn on unknown
1202 // identifiers here.
1203
1204 return OpenACCDeviceTypeClause::Create(
1205 Ctx, Clause.getClauseKind(), Clause.getBeginLoc(), Clause.getLParenLoc(),
1206 Clause.getDeviceTypeArchitectures(), Clause.getEndLoc());
1207}
1208
1209OpenACCClause *SemaOpenACCClauseVisitor::VisitAutoClause(
1210 SemaOpenACC::OpenACCParsedClause &Clause) {
1211 // OpenACC 3.3 2.9:
1212 // Only one of the seq, independent, and auto clauses may appear.
1213 const auto *Itr =
1214 llvm::find_if(ExistingClauses,
1215 llvm::IsaPred<OpenACCIndependentClause, OpenACCSeqClause>);
1216 if (Itr != ExistingClauses.end()) {
1217 SemaRef.Diag(Clause.getBeginLoc(), diag::err_acc_loop_spec_conflict)
1218 << Clause.getClauseKind() << Clause.getDirectiveKind();
1219 SemaRef.Diag((*Itr)->getBeginLoc(), diag::note_acc_previous_clause_here);
1220 return nullptr;
1221 }
1222
1223 return OpenACCAutoClause::Create(Ctx, Clause.getBeginLoc(),
1224 Clause.getEndLoc());
1225}
1226
1227OpenACCClause *SemaOpenACCClauseVisitor::VisitIndependentClause(
1228 SemaOpenACC::OpenACCParsedClause &Clause) {
1229 // OpenACC 3.3 2.9:
1230 // Only one of the seq, independent, and auto clauses may appear.
1231 const auto *Itr = llvm::find_if(
1232 ExistingClauses, llvm::IsaPred<OpenACCAutoClause, OpenACCSeqClause>);
1233 if (Itr != ExistingClauses.end()) {
1234 SemaRef.Diag(Clause.getBeginLoc(), diag::err_acc_loop_spec_conflict)
1235 << Clause.getClauseKind() << Clause.getDirectiveKind();
1236 SemaRef.Diag((*Itr)->getBeginLoc(), diag::note_acc_previous_clause_here);
1237 return nullptr;
1238 }
1239
1240 return OpenACCIndependentClause::Create(Ctx, Clause.getBeginLoc(),
1241 Clause.getEndLoc());
1242}
1243
1244ExprResult CheckGangStaticExpr(SemaOpenACC &S, Expr *E) {
1245 if (isa<OpenACCAsteriskSizeExpr>(E))
1246 return E;
1247 return S.ActOnIntExpr(OpenACCDirectiveKind::Invalid, OpenACCClauseKind::Gang,
1248 E->getBeginLoc(), E);
1249}
1250
1251bool IsOrphanLoop(OpenACCDirectiveKind DK, OpenACCDirectiveKind AssocKind) {
1252 return DK == OpenACCDirectiveKind::Loop &&
1253 AssocKind == OpenACCDirectiveKind::Invalid;
1254}
1255
1256bool HasAssocKind(OpenACCDirectiveKind DK, OpenACCDirectiveKind AssocKind) {
1257 return DK == OpenACCDirectiveKind::Loop &&
1258 AssocKind != OpenACCDirectiveKind::Invalid;
1259}
1260
1261ExprResult DiagIntArgInvalid(SemaOpenACC &S, Expr *E, OpenACCGangKind GK,
1262 OpenACCClauseKind CK, OpenACCDirectiveKind DK,
1263 OpenACCDirectiveKind AssocKind) {
1264 S.Diag(E->getBeginLoc(), diag::err_acc_int_arg_invalid)
1265 << GK << CK << IsOrphanLoop(DK, AssocKind) << DK
1266 << HasAssocKind(DK, AssocKind) << AssocKind;
1267 return ExprError();
1268}
1269ExprResult DiagIntArgInvalid(SemaOpenACC &S, Expr *E, StringRef TagKind,
1270 OpenACCClauseKind CK, OpenACCDirectiveKind DK,
1271 OpenACCDirectiveKind AssocKind) {
1272 S.Diag(E->getBeginLoc(), diag::err_acc_int_arg_invalid)
1273 << TagKind << CK << IsOrphanLoop(DK, AssocKind) << DK
1274 << HasAssocKind(DK, AssocKind) << AssocKind;
1275 return ExprError();
1276}
1277
1278ExprResult CheckGangParallelExpr(SemaOpenACC &S, OpenACCDirectiveKind DK,
1279 OpenACCDirectiveKind AssocKind,
1280 OpenACCGangKind GK, Expr *E) {
1281 switch (GK) {
1282 case OpenACCGangKind::Static:
1283 return CheckGangStaticExpr(S, E);
1284 case OpenACCGangKind::Num:
1285 // OpenACC 3.3 2.9.2: When the parent compute construct is a parallel
1286 // construct, or an orphaned loop construct, the gang clause behaves as
1287 // follows. ... The num argument is not allowed.
1288 return DiagIntArgInvalid(S, E, GK, OpenACCClauseKind::Gang, DK, AssocKind);
1289 case OpenACCGangKind::Dim: {
1290 // OpenACC 3.3 2.9.2: When the parent compute construct is a parallel
1291 // construct, or an orphaned loop construct, the gang clause behaves as
1292 // follows. ... The dim argument must be a constant positive integer value
1293 // 1, 2, or 3.
1294 if (!E)
1295 return ExprError();
1296 ExprResult Res =
1297 S.ActOnIntExpr(OpenACCDirectiveKind::Invalid, OpenACCClauseKind::Gang,
1298 E->getBeginLoc(), E);
1299
1300 if (!Res.isUsable())
1301 return Res;
1302
1303 if (Res.get()->isInstantiationDependent())
1304 return Res;
1305
1306 std::optional<llvm::APSInt> ICE =
1307 Res.get()->getIntegerConstantExpr(S.getASTContext());
1308
1309 if (!ICE || *ICE <= 0 || ICE > 3) {
1310 S.Diag(Res.get()->getBeginLoc(), diag::err_acc_gang_dim_value)
1311 << ICE.has_value() << ICE.value_or(llvm::APSInt{}).getExtValue();
1312 return ExprError();
1313 }
1314
1315 return ExprResult{
1316 ConstantExpr::Create(S.getASTContext(), Res.get(), APValue{*ICE})};
1317 }
1318 }
1319 llvm_unreachable("Unknown gang kind in gang parallel check");
1320}
1321
1322ExprResult CheckGangKernelsExpr(SemaOpenACC &S,
1323 ArrayRef<const OpenACCClause *> ExistingClauses,
1324 OpenACCDirectiveKind DK,
1325 OpenACCDirectiveKind AssocKind,
1326 OpenACCGangKind GK, Expr *E) {
1327 switch (GK) {
1328 // OpenACC 3.3 2.9.2: When the parent compute construct is a kernels
1329 // construct, the gang clause behaves as follows. ... The dim argument is
1330 // not allowed.
1331 case OpenACCGangKind::Dim:
1332 return DiagIntArgInvalid(S, E, GK, OpenACCClauseKind::Gang, DK, AssocKind);
1333 case OpenACCGangKind::Num: {
1334 // OpenACC 3.3 2.9.2: When the parent compute construct is a kernels
1335 // construct, the gang clause behaves as follows. ... An argument with no
1336 // keyword or with num keyword is only allowed when num_gangs does not
1337 // appear on the kernels construct. ... The region of a loop with the gang
1338 // clause may not contain another loop with a gang clause unless within a
1339 // nested compute region.
1340
1341 // If this is a 'combined' construct, search the list of existing clauses.
1342 // Else we need to search the containing 'kernel'.
1343 auto Collection = isOpenACCCombinedDirectiveKind(DK)
1344 ? ExistingClauses
1345 : S.getActiveComputeConstructInfo().Clauses;
1346
1347 const auto *Itr =
1348 llvm::find_if(Collection, llvm::IsaPred<OpenACCNumGangsClause>);
1349
1350 if (Itr != Collection.end()) {
1351 S.Diag(E->getBeginLoc(), diag::err_acc_num_arg_conflict)
1352 << "num" << OpenACCClauseKind::Gang << DK
1353 << HasAssocKind(DK, AssocKind) << AssocKind
1354 << OpenACCClauseKind::NumGangs;
1355
1356 S.Diag((*Itr)->getBeginLoc(), diag::note_acc_previous_clause_here);
1357 return ExprError();
1358 }
1359 return ExprResult{E};
1360 }
1361 case OpenACCGangKind::Static:
1362 return CheckGangStaticExpr(S, E);
1363 }
1364 llvm_unreachable("Unknown gang kind in gang kernels check");
1365}
1366
1367ExprResult CheckGangSerialExpr(SemaOpenACC &S, OpenACCDirectiveKind DK,
1368 OpenACCDirectiveKind AssocKind,
1369 OpenACCGangKind GK, Expr *E) {
1370 switch (GK) {
1371 // 'dim' and 'num' don't really make sense on serial, and GCC rejects them
1372 // too, so we disallow them too.
1373 case OpenACCGangKind::Dim:
1374 case OpenACCGangKind::Num:
1375 return DiagIntArgInvalid(S, E, GK, OpenACCClauseKind::Gang, DK, AssocKind);
1376 case OpenACCGangKind::Static:
1377 return CheckGangStaticExpr(S, E);
1378 }
1379 llvm_unreachable("Unknown gang kind in gang serial check");
1380}
1381
1382OpenACCClause *SemaOpenACCClauseVisitor::VisitVectorClause(
1383 SemaOpenACC::OpenACCParsedClause &Clause) {
1384 if (DiagIfSeqClause(Clause))
1385 return nullptr;
1386
1387 // Restrictions only properly implemented on 'loop'/'combined' constructs, and
1388 // it is the only construct that can do anything with this, so skip/treat as
1389 // unimplemented for the routine constructs.
1390 if (!isDirectiveKindImplemented(Clause.getDirectiveKind()))
1391 return isNotImplemented();
1392
1393 Expr *IntExpr =
1394 Clause.getNumIntExprs() != 0 ? Clause.getIntExprs()[0] : nullptr;
1395 if (IntExpr) {
1396 if (!isOpenACCCombinedDirectiveKind(Clause.getDirectiveKind())) {
1397 switch (SemaRef.getActiveComputeConstructInfo().Kind) {
1398 case OpenACCDirectiveKind::Invalid:
1399 case OpenACCDirectiveKind::Parallel:
1400 // No restriction on when 'parallel' can contain an argument.
1401 break;
1402 case OpenACCDirectiveKind::Serial:
1403 // GCC disallows this, and there is no real good reason for us to permit
1404 // it, so disallow until we come up with a use case that makes sense.
1405 DiagIntArgInvalid(SemaRef, IntExpr, "length", OpenACCClauseKind::Vector,
1406 Clause.getDirectiveKind(),
1407 SemaRef.getActiveComputeConstructInfo().Kind);
1408 IntExpr = nullptr;
1409 break;
1410 case OpenACCDirectiveKind::Kernels: {
1411 const auto *Itr =
1412 llvm::find_if(SemaRef.getActiveComputeConstructInfo().Clauses,
1413 llvm::IsaPred<OpenACCVectorLengthClause>);
1414 if (Itr != SemaRef.getActiveComputeConstructInfo().Clauses.end()) {
1415 SemaRef.Diag(IntExpr->getBeginLoc(), diag::err_acc_num_arg_conflict)
1416 << "length" << OpenACCClauseKind::Vector
1417 << Clause.getDirectiveKind()
1418 << HasAssocKind(Clause.getDirectiveKind(),
1419 SemaRef.getActiveComputeConstructInfo().Kind)
1420 << SemaRef.getActiveComputeConstructInfo().Kind
1421 << OpenACCClauseKind::VectorLength;
1422 SemaRef.Diag((*Itr)->getBeginLoc(),
1423 diag::note_acc_previous_clause_here);
1424
1425 IntExpr = nullptr;
1426 }
1427 break;
1428 }
1429 default:
1430 llvm_unreachable("Non compute construct in active compute construct");
1431 }
1432 } else {
1433 if (Clause.getDirectiveKind() == OpenACCDirectiveKind::SerialLoop) {
1434 DiagIntArgInvalid(SemaRef, IntExpr, "length", OpenACCClauseKind::Vector,
1435 Clause.getDirectiveKind(),
1436 SemaRef.getActiveComputeConstructInfo().Kind);
1437 IntExpr = nullptr;
1438 } else if (Clause.getDirectiveKind() ==
1439 OpenACCDirectiveKind::KernelsLoop) {
1440 const auto *Itr = llvm::find_if(
1441 ExistingClauses, llvm::IsaPred<OpenACCVectorLengthClause>);
1442 if (Itr != ExistingClauses.end()) {
1443 SemaRef.Diag(IntExpr->getBeginLoc(), diag::err_acc_num_arg_conflict)
1444 << "length" << OpenACCClauseKind::Vector
1445 << Clause.getDirectiveKind()
1446 << HasAssocKind(Clause.getDirectiveKind(),
1447 SemaRef.getActiveComputeConstructInfo().Kind)
1448 << SemaRef.getActiveComputeConstructInfo().Kind
1449 << OpenACCClauseKind::VectorLength;
1450 SemaRef.Diag((*Itr)->getBeginLoc(),
1451 diag::note_acc_previous_clause_here);
1452
1453 IntExpr = nullptr;
1454 }
1455 }
1456 }
1457 }
1458
1459 if (!isOpenACCCombinedDirectiveKind(Clause.getDirectiveKind())) {
1460 // OpenACC 3.3 2.9.4: The region of a loop with a 'vector' clause may not
1461 // contain a loop with a gang, worker, or vector clause unless within a
1462 // nested compute region.
1463 if (SemaRef.LoopVectorClauseLoc.isValid()) {
1464 // This handles the 'inner loop' diagnostic, but we cannot set that we're
1465 // on one of these until we get to the end of the construct.
1466 SemaRef.Diag(Clause.getBeginLoc(), diag::err_acc_clause_in_clause_region)
1467 << OpenACCClauseKind::Vector << OpenACCClauseKind::Vector
1468 << /*skip kernels construct info*/ 0;
1469 SemaRef.Diag(SemaRef.LoopVectorClauseLoc,
1470 diag::note_acc_previous_clause_here);
1471 return nullptr;
1472 }
1473 }
1474
1475 return OpenACCVectorClause::Create(Ctx, Clause.getBeginLoc(),
1476 Clause.getLParenLoc(), IntExpr,
1477 Clause.getEndLoc());
1478}
1479
1480OpenACCClause *SemaOpenACCClauseVisitor::VisitWorkerClause(
1481 SemaOpenACC::OpenACCParsedClause &Clause) {
1482 if (DiagIfSeqClause(Clause))
1483 return nullptr;
1484
1485 // Restrictions only properly implemented on 'loop'/'combined' constructs, and
1486 // it is the only construct that can do anything with this, so skip/treat as
1487 // unimplemented for the routine constructs.
1488 if (!isDirectiveKindImplemented(Clause.getDirectiveKind()))
1489 return isNotImplemented();
1490
1491 Expr *IntExpr =
1492 Clause.getNumIntExprs() != 0 ? Clause.getIntExprs()[0] : nullptr;
1493
1494 if (IntExpr) {
1495 if (!isOpenACCCombinedDirectiveKind(Clause.getDirectiveKind())) {
1496 switch (SemaRef.getActiveComputeConstructInfo().Kind) {
1497 case OpenACCDirectiveKind::Invalid:
1498 case OpenACCDirectiveKind::ParallelLoop:
1499 case OpenACCDirectiveKind::SerialLoop:
1500 case OpenACCDirectiveKind::Parallel:
1501 case OpenACCDirectiveKind::Serial:
1502 DiagIntArgInvalid(SemaRef, IntExpr, OpenACCGangKind::Num,
1503 OpenACCClauseKind::Worker, Clause.getDirectiveKind(),
1504 SemaRef.getActiveComputeConstructInfo().Kind);
1505 IntExpr = nullptr;
1506 break;
1507 case OpenACCDirectiveKind::KernelsLoop:
1508 case OpenACCDirectiveKind::Kernels: {
1509 const auto *Itr =
1510 llvm::find_if(SemaRef.getActiveComputeConstructInfo().Clauses,
1511 llvm::IsaPred<OpenACCNumWorkersClause>);
1512 if (Itr != SemaRef.getActiveComputeConstructInfo().Clauses.end()) {
1513 SemaRef.Diag(IntExpr->getBeginLoc(), diag::err_acc_num_arg_conflict)
1514 << "num" << OpenACCClauseKind::Worker << Clause.getDirectiveKind()
1515 << HasAssocKind(Clause.getDirectiveKind(),
1516 SemaRef.getActiveComputeConstructInfo().Kind)
1517 << SemaRef.getActiveComputeConstructInfo().Kind
1518 << OpenACCClauseKind::NumWorkers;
1519 SemaRef.Diag((*Itr)->getBeginLoc(),
1520 diag::note_acc_previous_clause_here);
1521
1522 IntExpr = nullptr;
1523 }
1524 break;
1525 }
1526 default:
1527 llvm_unreachable("Non compute construct in active compute construct");
1528 }
1529 } else {
1530 if (Clause.getDirectiveKind() == OpenACCDirectiveKind::ParallelLoop ||
1531 Clause.getDirectiveKind() == OpenACCDirectiveKind::SerialLoop) {
1532 DiagIntArgInvalid(SemaRef, IntExpr, OpenACCGangKind::Num,
1533 OpenACCClauseKind::Worker, Clause.getDirectiveKind(),
1534 SemaRef.getActiveComputeConstructInfo().Kind);
1535 IntExpr = nullptr;
1536 } else {
1537 assert(Clause.getDirectiveKind() == OpenACCDirectiveKind::KernelsLoop &&
1538 "Unknown combined directive kind?");
1539 const auto *Itr = llvm::find_if(ExistingClauses,
1540 llvm::IsaPred<OpenACCNumWorkersClause>);
1541 if (Itr != ExistingClauses.end()) {
1542 SemaRef.Diag(IntExpr->getBeginLoc(), diag::err_acc_num_arg_conflict)
1543 << "num" << OpenACCClauseKind::Worker << Clause.getDirectiveKind()
1544 << HasAssocKind(Clause.getDirectiveKind(),
1545 SemaRef.getActiveComputeConstructInfo().Kind)
1546 << SemaRef.getActiveComputeConstructInfo().Kind
1547 << OpenACCClauseKind::NumWorkers;
1548 SemaRef.Diag((*Itr)->getBeginLoc(),
1549 diag::note_acc_previous_clause_here);
1550
1551 IntExpr = nullptr;
1552 }
1553 }
1554 }
1555 }
1556
1557 if (!isOpenACCCombinedDirectiveKind(Clause.getDirectiveKind())) {
1558 // OpenACC 3.3 2.9.3: The region of a loop with a 'worker' clause may not
1559 // contain a loop with a gang or worker clause unless within a nested
1560 // compute region.
1561 if (SemaRef.LoopWorkerClauseLoc.isValid()) {
1562 // This handles the 'inner loop' diagnostic, but we cannot set that we're
1563 // on one of these until we get to the end of the construct.
1564 SemaRef.Diag(Clause.getBeginLoc(), diag::err_acc_clause_in_clause_region)
1565 << OpenACCClauseKind::Worker << OpenACCClauseKind::Worker
1566 << /*skip kernels construct info*/ 0;
1567 SemaRef.Diag(SemaRef.LoopWorkerClauseLoc,
1568 diag::note_acc_previous_clause_here);
1569 return nullptr;
1570 }
1571
1572 // OpenACC 3.3 2.9.4: The region of a loop with a 'vector' clause may not
1573 // contain a loop with a gang, worker, or vector clause unless within a
1574 // nested compute region.
1575 if (SemaRef.LoopVectorClauseLoc.isValid()) {
1576 // This handles the 'inner loop' diagnostic, but we cannot set that we're
1577 // on one of these until we get to the end of the construct.
1578 SemaRef.Diag(Clause.getBeginLoc(), diag::err_acc_clause_in_clause_region)
1579 << OpenACCClauseKind::Worker << OpenACCClauseKind::Vector
1580 << /*skip kernels construct info*/ 0;
1581 SemaRef.Diag(SemaRef.LoopVectorClauseLoc,
1582 diag::note_acc_previous_clause_here);
1583 return nullptr;
1584 }
1585 }
1586
1587 return OpenACCWorkerClause::Create(Ctx, Clause.getBeginLoc(),
1588 Clause.getLParenLoc(), IntExpr,
1589 Clause.getEndLoc());
1590}
1591
1592OpenACCClause *SemaOpenACCClauseVisitor::VisitGangClause(
1593 SemaOpenACC::OpenACCParsedClause &Clause) {
1594 if (DiagIfSeqClause(Clause))
1595 return nullptr;
1596
1597 // Restrictions only properly implemented on 'loop' constructs, and it is
1598 // the only construct that can do anything with this, so skip/treat as
1599 // unimplemented for the combined constructs.
1600 if (!isDirectiveKindImplemented(Clause.getDirectiveKind()))
1601 return isNotImplemented();
1602
1603 // OpenACC 3.3 Section 2.9.11: A reduction clause may not appear on a loop
1604 // directive that has a gang clause and is within a compute construct that has
1605 // a num_gangs clause with more than one explicit argument.
1606 if ((Clause.getDirectiveKind() == OpenACCDirectiveKind::Loop &&
1607 SemaRef.getActiveComputeConstructInfo().Kind !=
1608 OpenACCDirectiveKind::Invalid) ||
1609 isOpenACCCombinedDirectiveKind(Clause.getDirectiveKind())) {
1610 // num_gangs clause on the active compute construct.
1611 auto ActiveComputeConstructContainer =
1612 isOpenACCCombinedDirectiveKind(Clause.getDirectiveKind())
1613 ? ExistingClauses
1614 : SemaRef.getActiveComputeConstructInfo().Clauses;
1615 auto *NumGangsClauseItr = llvm::find_if(
1616 ActiveComputeConstructContainer, llvm::IsaPred<OpenACCNumGangsClause>);
1617
1618 if (NumGangsClauseItr != ActiveComputeConstructContainer.end() &&
1619 cast<OpenACCNumGangsClause>(*NumGangsClauseItr)->getIntExprs().size() >
1620 1) {
1621 auto *ReductionClauseItr =
1622 llvm::find_if(ExistingClauses, llvm::IsaPred<OpenACCReductionClause>);
1623
1624 if (ReductionClauseItr != ExistingClauses.end()) {
1625 SemaRef.Diag(Clause.getBeginLoc(),
1626 diag::err_acc_gang_reduction_numgangs_conflict)
1627 << OpenACCClauseKind::Gang << OpenACCClauseKind::Reduction
1628 << Clause.getDirectiveKind()
1629 << isOpenACCCombinedDirectiveKind(Clause.getDirectiveKind());
1630 SemaRef.Diag((*ReductionClauseItr)->getBeginLoc(),
1631 diag::note_acc_previous_clause_here);
1632 SemaRef.Diag((*NumGangsClauseItr)->getBeginLoc(),
1633 diag::note_acc_previous_clause_here);
1634 return nullptr;
1635 }
1636 }
1637 }
1638
1639 llvm::SmallVector<OpenACCGangKind> GangKinds;
1640 llvm::SmallVector<Expr *> IntExprs;
1641
1642 // Store the existing locations, so we can do duplicate checking. Index is
1643 // the int-value of the OpenACCGangKind enum.
1644 SourceLocation ExistingElemLoc[3];
1645
1646 for (unsigned I = 0; I < Clause.getIntExprs().size(); ++I) {
1647 OpenACCGangKind GK = Clause.getGangKinds()[I];
1648 ExprResult ER =
1649 SemaRef.CheckGangExpr(ExistingClauses, Clause.getDirectiveKind(), GK,
1650 Clause.getIntExprs()[I]);
1651
1652 if (!ER.isUsable())
1653 continue;
1654
1655 // OpenACC 3.3 2.9: 'gang-arg-list' may have at most one num, one dim, and
1656 // one static argument.
1657 if (ExistingElemLoc[static_cast<unsigned>(GK)].isValid()) {
1658 SemaRef.Diag(ER.get()->getBeginLoc(), diag::err_acc_gang_multiple_elt)
1659 << static_cast<unsigned>(GK);
1660 SemaRef.Diag(ExistingElemLoc[static_cast<unsigned>(GK)],
1661 diag::note_acc_previous_expr_here);
1662 continue;
1663 }
1664
1665 ExistingElemLoc[static_cast<unsigned>(GK)] = ER.get()->getBeginLoc();
1666 GangKinds.push_back(GK);
1667 IntExprs.push_back(ER.get());
1668 }
1669
1670 if (!isOpenACCCombinedDirectiveKind(Clause.getDirectiveKind())) {
1671 // OpenACC 3.3 2.9.2: When the parent compute construct is a kernels
1672 // construct, the gang clause behaves as follows. ... The region of a loop
1673 // with a gang clause may not contain another loop with a gang clause unless
1674 // within a nested compute region.
1675 if (SemaRef.LoopGangClauseOnKernel.Loc.isValid()) {
1676 // This handles the 'inner loop' diagnostic, but we cannot set that we're
1677 // on one of these until we get to the end of the construct.
1678 SemaRef.Diag(Clause.getBeginLoc(), diag::err_acc_clause_in_clause_region)
1679 << OpenACCClauseKind::Gang << OpenACCClauseKind::Gang
1680 << /*kernels construct info*/ 1
1681 << SemaRef.LoopGangClauseOnKernel.DirKind;
1682 SemaRef.Diag(SemaRef.LoopGangClauseOnKernel.Loc,
1683 diag::note_acc_previous_clause_here);
1684 return nullptr;
1685 }
1686
1687 // OpenACC 3.3 2.9.3: The region of a loop with a 'worker' clause may not
1688 // contain a loop with a gang or worker clause unless within a nested
1689 // compute region.
1690 if (SemaRef.LoopWorkerClauseLoc.isValid()) {
1691 // This handles the 'inner loop' diagnostic, but we cannot set that we're
1692 // on one of these until we get to the end of the construct.
1693 SemaRef.Diag(Clause.getBeginLoc(), diag::err_acc_clause_in_clause_region)
1694 << OpenACCClauseKind::Gang << OpenACCClauseKind::Worker
1695 << /*!kernels construct info*/ 0;
1696 SemaRef.Diag(SemaRef.LoopWorkerClauseLoc,
1697 diag::note_acc_previous_clause_here);
1698 return nullptr;
1699 }
1700
1701 // OpenACC 3.3 2.9.4: The region of a loop with a 'vector' clause may not
1702 // contain a loop with a gang, worker, or vector clause unless within a
1703 // nested compute region.
1704 if (SemaRef.LoopVectorClauseLoc.isValid()) {
1705 // This handles the 'inner loop' diagnostic, but we cannot set that we're
1706 // on one of these until we get to the end of the construct.
1707 SemaRef.Diag(Clause.getBeginLoc(), diag::err_acc_clause_in_clause_region)
1708 << OpenACCClauseKind::Gang << OpenACCClauseKind::Vector
1709 << /*!kernels construct info*/ 0;
1710 SemaRef.Diag(SemaRef.LoopVectorClauseLoc,
1711 diag::note_acc_previous_clause_here);
1712 return nullptr;
1713 }
1714 }
1715
1716 return SemaRef.CheckGangClause(Clause.getDirectiveKind(), ExistingClauses,
1717 Clause.getBeginLoc(), Clause.getLParenLoc(),
1718 GangKinds, IntExprs, Clause.getEndLoc());
1719}
1720
1721OpenACCClause *SemaOpenACCClauseVisitor::VisitFinalizeClause(
1722 SemaOpenACC::OpenACCParsedClause &Clause) {
1723 // There isn't anything to do here, this is only valid on one construct, and
1724 // has no associated rules.
1725 return OpenACCFinalizeClause::Create(Ctx, Clause.getBeginLoc(),
1726 Clause.getEndLoc());
1727}
1728
1729OpenACCClause *SemaOpenACCClauseVisitor::VisitIfPresentClause(
1730 SemaOpenACC::OpenACCParsedClause &Clause) {
1731 // There isn't anything to do here, this is only valid on one construct, and
1732 // has no associated rules.
1733 return OpenACCIfPresentClause::Create(Ctx, Clause.getBeginLoc(),
1734 Clause.getEndLoc());
1735}
1736
1737OpenACCClause *SemaOpenACCClauseVisitor::VisitSeqClause(
1738 SemaOpenACC::OpenACCParsedClause &Clause) {
1739 // Restrictions only properly implemented on 'loop' constructs and combined ,
1740 // and it is the only construct that can do anything with this, so skip/treat
1741 // as unimplemented for the routine constructs.
1742 if (!isDirectiveKindImplemented(Clause.getDirectiveKind()))
1743 return isNotImplemented();
1744
1745 // OpenACC 3.3 2.9:
1746 // Only one of the seq, independent, and auto clauses may appear.
1747 const auto *Itr =
1748 llvm::find_if(ExistingClauses,
1749 llvm::IsaPred<OpenACCAutoClause, OpenACCIndependentClause>);
1750 if (Itr != ExistingClauses.end()) {
1751 SemaRef.Diag(Clause.getBeginLoc(), diag::err_acc_loop_spec_conflict)
1752 << Clause.getClauseKind() << Clause.getDirectiveKind();
1753 SemaRef.Diag((*Itr)->getBeginLoc(), diag::note_acc_previous_clause_here);
1754 return nullptr;
1755 }
1756
1757 // OpenACC 3.3 2.9:
1758 // A 'gang', 'worker', or 'vector' clause may not appear if a 'seq' clause
1759 // appears.
1760 Itr = llvm::find_if(ExistingClauses,
1761 llvm::IsaPred<OpenACCGangClause, OpenACCWorkerClause,
1762 OpenACCVectorClause>);
1763
1764 if (Itr != ExistingClauses.end()) {
1765 SemaRef.Diag(Clause.getBeginLoc(), diag::err_acc_clause_cannot_combine)
1766 << Clause.getClauseKind() << (*Itr)->getClauseKind()
1767 << Clause.getDirectiveKind();
1768 SemaRef.Diag((*Itr)->getBeginLoc(), diag::note_acc_previous_clause_here);
1769 return nullptr;
1770 }
1771
1772 return OpenACCSeqClause::Create(Ctx, Clause.getBeginLoc(),
1773 Clause.getEndLoc());
1774}
1775
1776OpenACCClause *SemaOpenACCClauseVisitor::VisitReductionClause(
1777 SemaOpenACC::OpenACCParsedClause &Clause) {
1778 // OpenACC 3.3 Section 2.9.11: A reduction clause may not appear on a loop
1779 // directive that has a gang clause and is within a compute construct that has
1780 // a num_gangs clause with more than one explicit argument.
1781 if ((Clause.getDirectiveKind() == OpenACCDirectiveKind::Loop &&
1782 SemaRef.getActiveComputeConstructInfo().Kind !=
1783 OpenACCDirectiveKind::Invalid) ||
1784 isOpenACCCombinedDirectiveKind(Clause.getDirectiveKind())) {
1785 // num_gangs clause on the active compute construct.
1786 auto ActiveComputeConstructContainer =
1787 isOpenACCCombinedDirectiveKind(Clause.getDirectiveKind())
1788 ? ExistingClauses
1789 : SemaRef.getActiveComputeConstructInfo().Clauses;
1790 auto *NumGangsClauseItr = llvm::find_if(
1791 ActiveComputeConstructContainer, llvm::IsaPred<OpenACCNumGangsClause>);
1792
1793 if (NumGangsClauseItr != ActiveComputeConstructContainer.end() &&
1794 cast<OpenACCNumGangsClause>(*NumGangsClauseItr)->getIntExprs().size() >
1795 1) {
1796 auto *GangClauseItr =
1797 llvm::find_if(ExistingClauses, llvm::IsaPred<OpenACCGangClause>);
1798
1799 if (GangClauseItr != ExistingClauses.end()) {
1800 SemaRef.Diag(Clause.getBeginLoc(),
1801 diag::err_acc_gang_reduction_numgangs_conflict)
1802 << OpenACCClauseKind::Reduction << OpenACCClauseKind::Gang
1803 << Clause.getDirectiveKind()
1804 << isOpenACCCombinedDirectiveKind(Clause.getDirectiveKind());
1805 SemaRef.Diag((*GangClauseItr)->getBeginLoc(),
1806 diag::note_acc_previous_clause_here);
1807 SemaRef.Diag((*NumGangsClauseItr)->getBeginLoc(),
1808 diag::note_acc_previous_clause_here);
1809 return nullptr;
1810 }
1811 }
1812 }
1813
1814 // OpenACC3.3 Section 2.9.11: If a variable is involved in a reduction that
1815 // spans multiple nested loops where two or more of those loops have
1816 // associated loop directives, a reduction clause containing that variable
1817 // must appear on each of those loop directives.
1818 //
1819 // This can't really be implemented in the CFE, as this requires a level of
1820 // rechability/useage analysis that we're not really wanting to get into.
1821 // Additionally, I'm alerted that this restriction is one that the middle-end
1822 // can just 'figure out' as an extension and isn't really necessary.
1823 //
1824 // OpenACC3.3 Section 2.9.11: Every 'var' in a reduction clause appearing on
1825 // an orphaned loop construct must be private.
1826 //
1827 // This again is something we cannot really diagnose, as it requires we see
1828 // all the uses/scopes of all variables referenced. The middle end/MLIR might
1829 // be able to diagnose this.
1830
1831 // OpenACC 3.3 Section 2.5.4:
1832 // A reduction clause may not appear on a parallel construct with a
1833 // num_gangs clause that has more than one argument.
1834 if (Clause.getDirectiveKind() == OpenACCDirectiveKind::Parallel ||
1835 Clause.getDirectiveKind() == OpenACCDirectiveKind::ParallelLoop) {
1836 auto NumGangsClauses = llvm::make_filter_range(
1837 ExistingClauses, llvm::IsaPred<OpenACCNumGangsClause>);
1838
1839 for (auto *NGC : NumGangsClauses) {
1840 unsigned NumExprs =
1841 cast<OpenACCNumGangsClause>(NGC)->getIntExprs().size();
1842
1843 if (NumExprs > 1) {
1844 SemaRef.Diag(Clause.getBeginLoc(),
1845 diag::err_acc_reduction_num_gangs_conflict)
1846 << /*>1 arg in first loc=*/0 << Clause.getClauseKind()
1847 << Clause.getDirectiveKind() << OpenACCClauseKind::NumGangs;
1848 SemaRef.Diag(NGC->getBeginLoc(), diag::note_acc_previous_clause_here);
1849 return nullptr;
1850 }
1851 }
1852 }
1853
1854 SmallVector<Expr *> ValidVars;
1855
1856 for (Expr *Var : Clause.getVarList()) {
1857 ExprResult Res = SemaRef.CheckReductionVar(Clause.getDirectiveKind(),
1858 Clause.getReductionOp(), Var);
1859
1860 if (Res.isUsable())
1861 ValidVars.push_back(Res.get());
1862 }
1863
1864 return SemaRef.CheckReductionClause(
1865 ExistingClauses, Clause.getDirectiveKind(), Clause.getBeginLoc(),
1866 Clause.getLParenLoc(), Clause.getReductionOp(), ValidVars,
1867 Clause.getEndLoc());
1868}
1869
1870OpenACCClause *SemaOpenACCClauseVisitor::VisitCollapseClause(
1871 SemaOpenACC::OpenACCParsedClause &Clause) {
1872 // Duplicates here are not really sensible. We could possible permit
1873 // multiples if they all had the same value, but there isn't really a good
1874 // reason to do so. Also, this simplifies the suppression of duplicates, in
1875 // that we know if we 'find' one after instantiation, that it is the same
1876 // clause, which simplifies instantiation/checking/etc.
1877 if (checkAlreadyHasClauseOfKind(SemaRef, ExistingClauses, Clause))
1878 return nullptr;
1879
1880 ExprResult LoopCount = SemaRef.CheckCollapseLoopCount(Clause.getLoopCount());
1881
1882 if (!LoopCount.isUsable())
1883 return nullptr;
1884
1885 return OpenACCCollapseClause::Create(Ctx, Clause.getBeginLoc(),
1886 Clause.getLParenLoc(), Clause.isForce(),
1887 LoopCount.get(), Clause.getEndLoc());
1888}
1889
1890// Return true if the two vars refer to the same variable, for the purposes of
1891// equality checking.
1892bool areVarsEqual(Expr *VarExpr1, Expr *VarExpr2) {
1893 if (VarExpr1->isInstantiationDependent() ||
1894 VarExpr2->isInstantiationDependent())
1895 return false;
1896
1897 VarExpr1 = VarExpr1->IgnoreParenCasts();
1898 VarExpr2 = VarExpr2->IgnoreParenCasts();
1899
1900 // Legal expressions can be: Scalar variable reference, sub-array, array
1901 // element, or composite variable member.
1902
1903 // Sub-array.
1904 if (isa<ArraySectionExpr>(VarExpr1)) {
1905 auto *Expr2AS = dyn_cast<ArraySectionExpr>(VarExpr2);
1906 if (!Expr2AS)
1907 return false;
1908
1909 auto *Expr1AS = cast<ArraySectionExpr>(VarExpr1);
1910
1911 if (!areVarsEqual(Expr1AS->getBase(), Expr2AS->getBase()))
1912 return false;
1913 // We could possibly check to see if the ranges aren't overlapping, but it
1914 // isn't clear that the rules allow this.
1915 return true;
1916 }
1917
1918 // Array-element.
1919 if (isa<ArraySubscriptExpr>(VarExpr1)) {
1920 auto *Expr2AS = dyn_cast<ArraySubscriptExpr>(VarExpr2);
1921 if (!Expr2AS)
1922 return false;
1923
1924 auto *Expr1AS = cast<ArraySubscriptExpr>(VarExpr1);
1925
1926 if (!areVarsEqual(Expr1AS->getBase(), Expr2AS->getBase()))
1927 return false;
1928
1929 // We could possibly check to see if the elements referenced aren't the
1930 // same, but it isn't clear by reading of the standard that this is allowed
1931 // (and that the 'var' refered to isn't the array).
1932 return true;
1933 }
1934
1935 // Scalar variable reference, or composite variable.
1936 if (isa<DeclRefExpr>(VarExpr1)) {
1937 auto *Expr2DRE = dyn_cast<DeclRefExpr>(VarExpr2);
1938 if (!Expr2DRE)
1939 return false;
1940
1941 auto *Expr1DRE = cast<DeclRefExpr>(VarExpr1);
1942
1943 return Expr1DRE->getDecl()->getMostRecentDecl() ==
1944 Expr2DRE->getDecl()->getMostRecentDecl();
1945 }
1946
1947 llvm_unreachable("Unknown variable type encountered");
1948}
1949} // namespace
1950
1951OpenACCClause *
1952SemaOpenACC::ActOnClause(ArrayRef<const OpenACCClause *> ExistingClauses,
1953 OpenACCParsedClause &Clause) {
1954 if (Clause.getClauseKind() == OpenACCClauseKind::Invalid)
1955 return nullptr;
1956
1957 // Diagnose that we don't support this clause on this directive.
1958 if (!doesClauseApplyToDirective(Clause.getDirectiveKind(),
1959 Clause.getClauseKind())) {
1960 Diag(Clause.getBeginLoc(), diag::err_acc_clause_appertainment)
1961 << Clause.getDirectiveKind() << Clause.getClauseKind();
1962 return nullptr;
1963 }
1964
1965 if (const auto *DevTypeClause =
1966 llvm::find_if(ExistingClauses,
1967 [&](const OpenACCClause *C) {
1968 return isa<OpenACCDeviceTypeClause>(C);
1969 });
1970 DevTypeClause != ExistingClauses.end()) {
1971 if (checkValidAfterDeviceType(
1972 *this, *cast<OpenACCDeviceTypeClause>(*DevTypeClause), Clause))
1973 return nullptr;
1974 }
1975
1976 SemaOpenACCClauseVisitor Visitor{*this, ExistingClauses};
1977 OpenACCClause *Result = Visitor.Visit(Clause);
1978 assert((!Result || Result->getClauseKind() == Clause.getClauseKind()) &&
1979 "Created wrong clause?");
1980
1981 if (Visitor.diagNotImplemented())
1982 Diag(Clause.getBeginLoc(), diag::warn_acc_clause_unimplemented)
1983 << Clause.getClauseKind();
1984
1985 return Result;
1986
1987}
1988
1989/// OpenACC 3.3 section 2.5.15:
1990/// At a mininmum, the supported data types include ... the numerical data types
1991/// in C, C++, and Fortran.
1992///
1993/// If the reduction var is a composite variable, each
1994/// member of the composite variable must be a supported datatype for the
1995/// reduction operation.
1996ExprResult SemaOpenACC::CheckReductionVar(OpenACCDirectiveKind DirectiveKind,
1997 OpenACCReductionOperator ReductionOp,
1998 Expr *VarExpr) {
1999 VarExpr = VarExpr->IgnoreParenCasts();
2000
2001 auto TypeIsValid = [](QualType Ty) {
2002 return Ty->isDependentType() || Ty->isScalarType();
2003 };
2004
2005 if (isa<ArraySectionExpr>(VarExpr)) {
2006 Expr *ASExpr = VarExpr;
2007 QualType BaseTy = ArraySectionExpr::getBaseOriginalType(ASExpr);
2008 QualType EltTy = getASTContext().getBaseElementType(BaseTy);
2009
2010 if (!TypeIsValid(EltTy)) {
2011 Diag(VarExpr->getExprLoc(), diag::err_acc_reduction_type)
2012 << EltTy << /*Sub array base type*/ 1;
2013 return ExprError();
2014 }
2015 } else if (auto *RD = VarExpr->getType()->getAsRecordDecl()) {
2016 if (!RD->isStruct() && !RD->isClass()) {
2017 Diag(VarExpr->getExprLoc(), diag::err_acc_reduction_composite_type)
2018 << /*not class or struct*/ 0 << VarExpr->getType();
2019 return ExprError();
2020 }
2021
2022 if (!RD->isCompleteDefinition()) {
2023 Diag(VarExpr->getExprLoc(), diag::err_acc_reduction_composite_type)
2024 << /*incomplete*/ 1 << VarExpr->getType();
2025 return ExprError();
2026 }
2027 if (const auto *CXXRD = dyn_cast<CXXRecordDecl>(RD);
2028 CXXRD && !CXXRD->isAggregate()) {
2029 Diag(VarExpr->getExprLoc(), diag::err_acc_reduction_composite_type)
2030 << /*aggregate*/ 2 << VarExpr->getType();
2031 return ExprError();
2032 }
2033
2034 for (FieldDecl *FD : RD->fields()) {
2035 if (!TypeIsValid(FD->getType())) {
2036 Diag(VarExpr->getExprLoc(),
2037 diag::err_acc_reduction_composite_member_type);
2038 Diag(FD->getLocation(), diag::note_acc_reduction_composite_member_loc);
2039 return ExprError();
2040 }
2041 }
2042 } else if (!TypeIsValid(VarExpr->getType())) {
2043 Diag(VarExpr->getExprLoc(), diag::err_acc_reduction_type)
2044 << VarExpr->getType() << /*Sub array base type*/ 0;
2045 return ExprError();
2046 }
2047
2048 // OpenACC3.3: 2.9.11: Reduction clauses on nested constructs for the same
2049 // reduction 'var' must have the same reduction operator.
2050 if (!VarExpr->isInstantiationDependent()) {
2051
2052 for (const OpenACCReductionClause *RClause : ActiveReductionClauses) {
2053 if (RClause->getReductionOp() == ReductionOp)
2054 break;
2055
2056 for (Expr *OldVarExpr : RClause->getVarList()) {
2057 if (OldVarExpr->isInstantiationDependent())
2058 continue;
2059
2060 if (areVarsEqual(VarExpr, OldVarExpr)) {
2061 Diag(VarExpr->getExprLoc(), diag::err_reduction_op_mismatch)
2062 << ReductionOp << RClause->getReductionOp();
2063 Diag(OldVarExpr->getExprLoc(), diag::note_acc_previous_clause_here);
2064 return ExprError();
2065 }
2066 }
2067 }
2068 }
2069
2070 return VarExpr;
2071}
2072
2073ExprResult SemaOpenACC::CheckTileSizeExpr(Expr *SizeExpr) {
2074 if (!SizeExpr)
2075 return ExprError();
2076
2077 assert((SizeExpr->isInstantiationDependent() ||
2078 SizeExpr->getType()->isIntegerType()) &&
2079 "size argument non integer?");
2080
2081 // If dependent, or an asterisk, the expression is fine.
2082 if (SizeExpr->isInstantiationDependent() ||
2083 isa<OpenACCAsteriskSizeExpr>(SizeExpr))
2084 return ExprResult{SizeExpr};
2085
2086 std::optional<llvm::APSInt> ICE =
2087 SizeExpr->getIntegerConstantExpr(getASTContext());
2088
2089 // OpenACC 3.3 2.9.8
2090 // where each tile size is a constant positive integer expression or asterisk.
2091 if (!ICE || *ICE <= 0) {
2092 Diag(SizeExpr->getBeginLoc(), diag::err_acc_size_expr_value)
2093 << ICE.has_value() << ICE.value_or(llvm::APSInt{}).getExtValue();
2094 return ExprError();
2095 }
2096
2097 return ExprResult{
2098 ConstantExpr::Create(getASTContext(), SizeExpr, APValue{*ICE})};
2099}
2100
2101ExprResult SemaOpenACC::CheckCollapseLoopCount(Expr *LoopCount) {
2102 if (!LoopCount)
2103 return ExprError();
2104
2105 assert((LoopCount->isInstantiationDependent() ||
2106 LoopCount->getType()->isIntegerType()) &&
2107 "Loop argument non integer?");
2108
2109 // If this is dependent, there really isn't anything we can check.
2110 if (LoopCount->isInstantiationDependent())
2111 return ExprResult{LoopCount};
2112
2113 std::optional<llvm::APSInt> ICE =
2114 LoopCount->getIntegerConstantExpr(getASTContext());
2115
2116 // OpenACC 3.3: 2.9.1
2117 // The argument to the collapse clause must be a constant positive integer
2118 // expression.
2119 if (!ICE || *ICE <= 0) {
2120 Diag(LoopCount->getBeginLoc(), diag::err_acc_collapse_loop_count)
2121 << ICE.has_value() << ICE.value_or(llvm::APSInt{}).getExtValue();
2122 return ExprError();
2123 }
2124
2125 return ExprResult{
2126 ConstantExpr::Create(getASTContext(), LoopCount, APValue{*ICE})};
2127}
2128
2129ExprResult
2130SemaOpenACC::CheckGangExpr(ArrayRef<const OpenACCClause *> ExistingClauses,
2131 OpenACCDirectiveKind DK, OpenACCGangKind GK,
2132 Expr *E) {
2133 // There are two cases for the enforcement here: the 'current' directive is a
2134 // 'loop', where we need to check the active compute construct kind, or the
2135 // current directive is a 'combined' construct, where we have to check the
2136 // current one.
2137 switch (DK) {
2138 case OpenACCDirectiveKind::ParallelLoop:
2139 return CheckGangParallelExpr(*this, DK, ActiveComputeConstructInfo.Kind, GK,
2140 E);
2141 case OpenACCDirectiveKind::SerialLoop:
2142 return CheckGangSerialExpr(*this, DK, ActiveComputeConstructInfo.Kind, GK,
2143 E);
2144 case OpenACCDirectiveKind::KernelsLoop:
2145 return CheckGangKernelsExpr(*this, ExistingClauses, DK,
2146 ActiveComputeConstructInfo.Kind, GK, E);
2147 case OpenACCDirectiveKind::Loop:
2148 switch (ActiveComputeConstructInfo.Kind) {
2149 case OpenACCDirectiveKind::Invalid:
2150 case OpenACCDirectiveKind::Parallel:
2151 case OpenACCDirectiveKind::ParallelLoop:
2152 return CheckGangParallelExpr(*this, DK, ActiveComputeConstructInfo.Kind,
2153 GK, E);
2154 case OpenACCDirectiveKind::SerialLoop:
2155 case OpenACCDirectiveKind::Serial:
2156 return CheckGangSerialExpr(*this, DK, ActiveComputeConstructInfo.Kind, GK,
2157 E);
2158 case OpenACCDirectiveKind::KernelsLoop:
2159 case OpenACCDirectiveKind::Kernels:
2160 return CheckGangKernelsExpr(*this, ExistingClauses, DK,
2161 ActiveComputeConstructInfo.Kind, GK, E);
2162 default:
2163 llvm_unreachable("Non compute construct in active compute construct?");
2164 }
2165 default:
2166 // TODO: OpenACC: when we implement this on 'routine', we'll have to
2167 // implement its checking here.
2168 llvm_unreachable("Invalid directive kind for a Gang clause");
2169 }
2170 llvm_unreachable("Compute construct directive not handled?");
2171}
2172
2173OpenACCClause *
2174SemaOpenACC::CheckGangClause(OpenACCDirectiveKind DirKind,
2175 ArrayRef<const OpenACCClause *> ExistingClauses,
2176 SourceLocation BeginLoc, SourceLocation LParenLoc,
2177 ArrayRef<OpenACCGangKind> GangKinds,
2178 ArrayRef<Expr *> IntExprs, SourceLocation EndLoc) {
2179 // OpenACC 3.3 2.9.11: A reduction clause may not appear on a loop directive
2180 // that has a gang clause with a dim: argument whose value is greater than 1.
2181
2182 const auto *ReductionItr =
2183 llvm::find_if(ExistingClauses, llvm::IsaPred<OpenACCReductionClause>);
2184
2185 if (ReductionItr != ExistingClauses.end()) {
2186 const auto GangZip = llvm::zip_equal(GangKinds, IntExprs);
2187 const auto GangItr = llvm::find_if(GangZip, [](const auto &Tuple) {
2188 return std::get<0>(Tuple) == OpenACCGangKind::Dim;
2189 });
2190
2191 if (GangItr != GangZip.end()) {
2192 const Expr *DimExpr = std::get<1>(*GangItr);
2193
2194 assert(
2195 (DimExpr->isInstantiationDependent() || isa<ConstantExpr>(DimExpr)) &&
2196 "Improperly formed gang argument");
2197 if (const auto *DimVal = dyn_cast<ConstantExpr>(DimExpr);
2198 DimVal && DimVal->getResultAsAPSInt() > 1) {
2199 Diag(DimVal->getBeginLoc(), diag::err_acc_gang_reduction_conflict)
2200 << /*gang/reduction=*/0 << DirKind;
2201 Diag((*ReductionItr)->getBeginLoc(),
2202 diag::note_acc_previous_clause_here);
2203 return nullptr;
2204 }
2205 }
2206 }
2207
2208 return OpenACCGangClause::Create(getASTContext(), BeginLoc, LParenLoc,
2209 GangKinds, IntExprs, EndLoc);
2210}
2211
2212OpenACCClause *SemaOpenACC::CheckReductionClause(
2213 ArrayRef<const OpenACCClause *> ExistingClauses,
2214 OpenACCDirectiveKind DirectiveKind, SourceLocation BeginLoc,
2215 SourceLocation LParenLoc, OpenACCReductionOperator ReductionOp,
2216 ArrayRef<Expr *> Vars, SourceLocation EndLoc) {
2217 if (DirectiveKind == OpenACCDirectiveKind::Loop ||
2218 isOpenACCCombinedDirectiveKind(DirectiveKind)) {
2219 // OpenACC 3.3 2.9.11: A reduction clause may not appear on a loop directive
2220 // that has a gang clause with a dim: argument whose value is greater
2221 // than 1.
2222 const auto GangClauses = llvm::make_filter_range(
2223 ExistingClauses, llvm::IsaPred<OpenACCGangClause>);
2224
2225 for (auto *GC : GangClauses) {
2226 const auto *GangClause = cast<OpenACCGangClause>(GC);
2227 for (unsigned I = 0; I < GangClause->getNumExprs(); ++I) {
2228 std::pair<OpenACCGangKind, const Expr *> EPair = GangClause->getExpr(I);
2229 if (EPair.first != OpenACCGangKind::Dim)
2230 continue;
2231
2232 if (const auto *DimVal = dyn_cast<ConstantExpr>(EPair.second);
2233 DimVal && DimVal->getResultAsAPSInt() > 1) {
2234 Diag(BeginLoc, diag::err_acc_gang_reduction_conflict)
2235 << /*reduction/gang=*/1 << DirectiveKind;
2236 Diag(GangClause->getBeginLoc(), diag::note_acc_previous_clause_here);
2237 return nullptr;
2238 }
2239 }
2240 }
2241 }
2242
2243 auto *Ret = OpenACCReductionClause::Create(
2244 getASTContext(), BeginLoc, LParenLoc, ReductionOp, Vars, EndLoc);
2245 return Ret;
2246}
E
Expr * E
Definition: CheckExprLifetime.cpp:210
DeclCXX.h
Defines the C++ Decl subclasses, other than those for templates (found in DeclTemplate....
OpenACCKinds.h
Defines some OpenACC-specific enums and functions.
SemaOpenACC.h
This file declares semantic analysis for OpenACC constructs and clauses.
clang::APValue
APValue - This class implements a discriminated union of [uninitialized] [APSInt] [APFloat],...
Definition: APValue.h:122
clang::ASTContext
Holds long-lived AST nodes (such as types and decls) that can be referred to throughout the semantic ...
Definition: ASTContext.h:188
clang::ASTContext::getBaseElementType
QualType getBaseElementType(const ArrayType *VAT) const
Return the innermost element type of an array type.
Definition: ASTContext.cpp:7718
clang::ActionResult::get
PtrTy get() const
Definition: Ownership.h:170
clang::ActionResult::isUsable
bool isUsable() const
Definition: Ownership.h:168
clang::ArraySectionExpr::getBaseOriginalType
static QualType getBaseOriginalType(const Expr *Base)
Return original type of the base expression for array section.
Definition: Expr.cpp:5186
clang::ConstantExpr::Create
static ConstantExpr * Create(const ASTContext &Context, Expr *E, const APValue &Result)
Definition: Expr.cpp:349
clang::Expr
This represents one expression.
Definition: Expr.h:110
clang::Expr::IgnoreParenCasts
Expr * IgnoreParenCasts() LLVM_READONLY
Skip past any parentheses and casts which might surround this expression until reaching a fixed point...
Definition: Expr.cpp:3102
clang::Expr::isInstantiationDependent
bool isInstantiationDependent() const
Whether this expression is instantiation-dependent, meaning that it depends in some way on.
Definition: Expr.h:221
clang::Expr::getExprLoc
SourceLocation getExprLoc() const LLVM_READONLY
getExprLoc - Return the preferred location for the arrow when diagnosing a problem with a generic exp...
Definition: Expr.cpp:276
clang::Expr::getIntegerConstantExpr
std::optional< llvm::APSInt > getIntegerConstantExpr(const ASTContext &Ctx, SourceLocation *Loc=nullptr) const
isIntegerConstantExpr - Return the value if this expression is a valid integer constant expression.
Definition: ExprConstant.cpp:17600
clang::Expr::getType
QualType getType() const
Definition: Expr.h:142
clang::FieldDecl
Represents a member of a struct/union/class.
Definition: Decl.h:3033
clang::OpenACCAsyncClause::Create
static OpenACCAsyncClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:239
clang::OpenACCAttachClause::Create
static OpenACCAttachClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:341
clang::OpenACCAutoClause::Create
static OpenACCAutoClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:495
clang::OpenACCClause
This is the base type for all OpenACC Clauses.
Definition: OpenACCClause.h:24
clang::OpenACCClause::getClauseKind
OpenACCClauseKind getClauseKind() const
Definition: OpenACCClause.h:37
clang::OpenACCClause::getBeginLoc
SourceLocation getBeginLoc() const
Definition: OpenACCClause.h:38
clang::OpenACCCollapseClause::Create
static OpenACCCollapseClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, bool HasForce, Expr *LoopCount, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:195
clang::OpenACCCopyClause::Create
static OpenACCCopyClause * Create(const ASTContext &C, OpenACCClauseKind Spelling, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:432
clang::OpenACCCopyInClause::Create
static OpenACCCopyInClause * Create(const ASTContext &C, OpenACCClauseKind Spelling, SourceLocation BeginLoc, SourceLocation LParenLoc, bool IsReadOnly, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:442
clang::OpenACCCopyOutClause::Create
static OpenACCCopyOutClause * Create(const ASTContext &C, OpenACCClauseKind Spelling, SourceLocation BeginLoc, SourceLocation LParenLoc, bool IsZero, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:453
clang::OpenACCCreateClause::Create
static OpenACCCreateClause * Create(const ASTContext &C, OpenACCClauseKind Spelling, SourceLocation BeginLoc, SourceLocation LParenLoc, bool IsZero, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:464
clang::OpenACCDefaultAsyncClause::Create
static OpenACCDefaultAsyncClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:281
clang::OpenACCDefaultClause::Create
static OpenACCDefaultClause * Create(const ASTContext &C, OpenACCDefaultClauseKind K, SourceLocation BeginLoc, SourceLocation LParenLoc, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:56
clang::OpenACCDeleteClause::Create
static OpenACCDeleteClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:361
clang::OpenACCDetachClause::Create
static OpenACCDetachClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:351
clang::OpenACCDeviceClause::Create
static OpenACCDeviceClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:421
clang::OpenACCDeviceNumClause::Create
static OpenACCDeviceNumClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:259
clang::OpenACCDevicePtrClause::Create
static OpenACCDevicePtrClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:381
clang::OpenACCDeviceTypeClause
A 'device_type' or 'dtype' clause, takes a list of either an 'asterisk' or an identifier.
Definition: OpenACCClause.h:195
clang::OpenACCDeviceTypeClause::Create
static OpenACCDeviceTypeClause * Create(const ASTContext &C, OpenACCClauseKind K, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< DeviceTypeArgument > Archs, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:474
clang::OpenACCFinalizeClause::Create
static OpenACCFinalizeClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:568
clang::OpenACCFirstPrivateClause::Create
static OpenACCFirstPrivateClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:332
clang::OpenACCGangClause::Create
static OpenACCGangClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< OpenACCGangKind > GangKinds, ArrayRef< Expr * > IntExprs, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:517
clang::OpenACCHostClause::Create
static OpenACCHostClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:411
clang::OpenACCIfClause::Create
static OpenACCIfClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *ConditionExpr, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:67
clang::OpenACCIfPresentClause::Create
static OpenACCIfPresentClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:576
clang::OpenACCIndependentClause::Create
static OpenACCIndependentClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:503
clang::OpenACCNoCreateClause::Create
static OpenACCNoCreateClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:391
clang::OpenACCNumGangsClause::Create
static OpenACCNumGangsClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > IntExprs, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:302
clang::OpenACCNumWorkersClause::Create
static OpenACCNumWorkersClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:175
clang::OpenACCPresentClause::Create
static OpenACCPresentClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:401
clang::OpenACCPrivateClause::Create
static OpenACCPrivateClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:322
clang::OpenACCReductionClause::Create
static OpenACCReductionClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, OpenACCReductionOperator Operator, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:485
clang::OpenACCSelfClause::Create
static OpenACCSelfClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *ConditionExpr, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:87
clang::OpenACCSeqClause::Create
static OpenACCSeqClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:509
clang::OpenACCTileClause::Create
static OpenACCTileClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > SizeExprs, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:312
clang::OpenACCUseDeviceClause::Create
static OpenACCUseDeviceClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< Expr * > VarList, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:371
clang::OpenACCVectorClause::Create
static OpenACCVectorClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:558
clang::OpenACCVectorLengthClause::Create
static OpenACCVectorLengthClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:220
clang::OpenACCWaitClause::Create
static OpenACCWaitClause * Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *DevNumExpr, SourceLocation QueuesLoc, ArrayRef< Expr * > QueueIdExprs, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:290
clang::OpenACCWorkerClause::Create
static OpenACCWorkerClause * Create(const ASTContext &Ctx, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *IntExpr, SourceLocation EndLoc)
Definition: OpenACCClause.cpp:538
clang::QualType
A (possibly-)qualified type.
Definition: Type.h:929
clang::SemaBase::Diag
SemaDiagnosticBuilder Diag(SourceLocation Loc, unsigned DiagID, bool DeferHint=false)
Emit a diagnostic.
Definition: SemaBase.cpp:60
clang::SemaBase::getASTContext
ASTContext & getASTContext() const
Definition: SemaBase.cpp:9
clang::SemaOpenACC::OpenACCParsedClause
A type to represent all the data for an OpenACC Clause that has been parsed, but not yet created/sema...
Definition: SemaOpenACC.h:202
clang::SemaOpenACC::OpenACCParsedClause::getQueueIdExprs
ArrayRef< Expr * > getQueueIdExprs() const
Definition: SemaOpenACC.h:338
clang::SemaOpenACC::OpenACCParsedClause::getDirectiveKind
OpenACCDirectiveKind getDirectiveKind() const
Definition: SemaOpenACC.h:260
clang::SemaOpenACC::OpenACCParsedClause::getGangKinds
ArrayRef< OpenACCGangKind > getGangKinds() const
Definition: SemaOpenACC.h:380
clang::SemaOpenACC::OpenACCParsedClause::getReductionOp
OpenACCReductionOperator getReductionOp() const
Definition: SemaOpenACC.h:376
clang::SemaOpenACC::OpenACCParsedClause::getClauseKind
OpenACCClauseKind getClauseKind() const
Definition: SemaOpenACC.h:262
clang::SemaOpenACC::OpenACCParsedClause::getLParenLoc
SourceLocation getLParenLoc() const
Definition: SemaOpenACC.h:266
clang::SemaOpenACC::OpenACCParsedClause::getDeviceTypeArchitectures
ArrayRef< DeviceTypeArgument > getDeviceTypeArchitectures() const
Definition: SemaOpenACC.h:460
clang::SemaOpenACC::OpenACCParsedClause::getBeginLoc
SourceLocation getBeginLoc() const
Definition: SemaOpenACC.h:264
clang::SemaOpenACC::OpenACCParsedClause::getQueuesLoc
SourceLocation getQueuesLoc() const
Definition: SemaOpenACC.h:318
clang::SemaOpenACC::OpenACCParsedClause::setVarListDetails
void setVarListDetails(ArrayRef< Expr * > VarList, bool IsReadOnly, bool IsZero)
Definition: SemaOpenACC.h:536
clang::SemaOpenACC::OpenACCParsedClause::getDefaultClauseKind
OpenACCDefaultClauseKind getDefaultClauseKind() const
Definition: SemaOpenACC.h:270
clang::SemaOpenACC::getActiveComputeConstructInfo
ComputeConstructInfo & getActiveComputeConstructInfo()
Definition: SemaOpenACC.h:162
clang::SemaOpenACC::LoopWorkerClauseLoc
SourceLocation LoopWorkerClauseLoc
If there is a current 'active' loop construct with a 'worker' clause on it (on any sort of construct)...
Definition: SemaOpenACC.h:179
clang::SemaOpenACC::ActOnClause
OpenACCClause * ActOnClause(ArrayRef< const OpenACCClause * > ExistingClauses, OpenACCParsedClause &Clause)
Called after parsing an OpenACC Clause so that it can be checked.
Definition: SemaOpenACCClause.cpp:1952
clang::SemaOpenACC::CheckVarIsPointerType
bool CheckVarIsPointerType(OpenACCClauseKind ClauseKind, Expr *VarExpr)
Called to check the 'var' type is a variable of pointer type, necessary for 'deviceptr' and 'attach' ...
Definition: SemaOpenACC.cpp:444
clang::SemaOpenACC::LoopGangClauseOnKernel
struct clang::SemaOpenACC::LoopGangOnKernelTy LoopGangClauseOnKernel
clang::SemaOpenACC::CheckReductionVar
ExprResult CheckReductionVar(OpenACCDirectiveKind DirectiveKind, OpenACCReductionOperator ReductionOp, Expr *VarExpr)
Called while semantically analyzing the reduction clause, ensuring the var is the correct kind of ref...
Definition: SemaOpenACCClause.cpp:1996
clang::SemaOpenACC::CheckCollapseLoopCount
ExprResult CheckCollapseLoopCount(Expr *LoopCount)
Checks the loop depth value for a collapse clause.
Definition: SemaOpenACCClause.cpp:2101
clang::SemaOpenACC::CheckReductionClause
OpenACCClause * CheckReductionClause(ArrayRef< const OpenACCClause * > ExistingClauses, OpenACCDirectiveKind DirectiveKind, SourceLocation BeginLoc, SourceLocation LParenLoc, OpenACCReductionOperator ReductionOp, ArrayRef< Expr * > Vars, SourceLocation EndLoc)
Definition: SemaOpenACCClause.cpp:2212
clang::SemaOpenACC::LoopVectorClauseLoc
SourceLocation LoopVectorClauseLoc
If there is a current 'active' loop construct with a 'vector' clause on it (on any sort of construct)...
Definition: SemaOpenACC.h:184
clang::SemaOpenACC::CheckGangExpr
ExprResult CheckGangExpr(ArrayRef< const OpenACCClause * > ExistingClauses, OpenACCDirectiveKind DK, OpenACCGangKind GK, Expr *E)
Definition: SemaOpenACCClause.cpp:2130
clang::SemaOpenACC::CheckGangClause
OpenACCClause * CheckGangClause(OpenACCDirectiveKind DirKind, ArrayRef< const OpenACCClause * > ExistingClauses, SourceLocation BeginLoc, SourceLocation LParenLoc, ArrayRef< OpenACCGangKind > GangKinds, ArrayRef< Expr * > IntExprs, SourceLocation EndLoc)
Definition: SemaOpenACCClause.cpp:2174
clang::SemaOpenACC::CheckTileSizeExpr
ExprResult CheckTileSizeExpr(Expr *SizeExpr)
Checks a single size expr for a tile clause.
Definition: SemaOpenACCClause.cpp:2073
clang::Sema::getASTContext
ASTContext & getASTContext() const
Definition: Sema.h:532
clang::SourceLocation
Encodes a location in the source.
Definition: SourceLocation.h:88
clang::SourceLocation::isValid
bool isValid() const
Return true if this is a valid SourceLocation object.
Definition: SourceLocation.h:113
clang::Stmt::getBeginLoc
SourceLocation getBeginLoc() const LLVM_READONLY
Definition: Stmt.cpp:346
clang::Type::isIntegerType
bool isIntegerType() const
isIntegerType() does not include complex integers (a GCC extension).
Definition: Type.h:8555
clang::Type::getAsRecordDecl
RecordDecl * getAsRecordDecl() const
Retrieves the RecordDecl this type refers to.
Definition: Type.cpp:1920
clang
The JSON file list parser is used to communicate input to InstallAPI.
Definition: CalledOnceCheck.h:17
clang::OpenACCDirectiveKind
OpenACCDirectiveKind
Definition: OpenACCKinds.h:25
clang::OpenACCReductionOperator
OpenACCReductionOperator
Definition: OpenACCKinds.h:509
clang::isOpenACCComputeDirectiveKind
bool isOpenACCComputeDirectiveKind(OpenACCDirectiveKind K)
Definition: OpenACCKinds.h:149
clang::isOpenACCCombinedDirectiveKind
bool isOpenACCCombinedDirectiveKind(OpenACCDirectiveKind K)
Definition: OpenACCKinds.h:155
clang::OpenACCClauseKind
OpenACCClauseKind
Represents the kind of an OpenACC clause.
Definition: OpenACCKinds.h:178
clang::OpenACCClauseKind::Invalid
@ Invalid
Represents an invalid clause, for the purposes of parsing.
clang::ObjCSubstitutionContext::Result
@ Result
The result type of a method or function.
clang::ExprError
ExprResult ExprError()
Definition: Ownership.h:264
clang::OpenACCGangKind
OpenACCGangKind
Definition: OpenACCKinds.h:568
Generated on Sat Jun 14 2025 07:57:41 for clang by doxygen 1.9.6