1#ifdef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
2#undef GEN_FLANG_DIRECTIVE_CLAUSE_SETS
3
4namespace llvm::acc {
5
6// Sets for atomic
7
8static AccClauseSet allowedClauses_ACCD_atomic {
9};
10
11static AccClauseSet allowedOnceClauses_ACCD_atomic {
12 Clause::ACCC_if,
13};
14
15static AccClauseSet allowedExclusiveClauses_ACCD_atomic {
16};
17
18static AccClauseSet requiredClauses_ACCD_atomic {
19};
20// Sets for cache
21
22static AccClauseSet allowedClauses_ACCD_cache {
23};
24
25static AccClauseSet allowedOnceClauses_ACCD_cache {
26};
27
28static AccClauseSet allowedExclusiveClauses_ACCD_cache {
29};
30
31static AccClauseSet requiredClauses_ACCD_cache {
32};
33// Sets for data
34
35static AccClauseSet allowedClauses_ACCD_data {
36 Clause::ACCC_async,
37 Clause::ACCC_device_type,
38 Clause::ACCC_wait,
39};
40
41static AccClauseSet allowedOnceClauses_ACCD_data {
42 Clause::ACCC_if,
43 Clause::ACCC_default,
44};
45
46static AccClauseSet allowedExclusiveClauses_ACCD_data {
47};
48
49static AccClauseSet requiredClauses_ACCD_data {
50 Clause::ACCC_attach,
51 Clause::ACCC_copy,
52 Clause::ACCC_copyin,
53 Clause::ACCC_copyout,
54 Clause::ACCC_create,
55 Clause::ACCC_default,
56 Clause::ACCC_deviceptr,
57 Clause::ACCC_no_create,
58 Clause::ACCC_present,
59};
60// Sets for declare
61
62static AccClauseSet allowedClauses_ACCD_declare {
63 Clause::ACCC_copy,
64 Clause::ACCC_copyin,
65 Clause::ACCC_copyout,
66 Clause::ACCC_create,
67 Clause::ACCC_present,
68 Clause::ACCC_deviceptr,
69 Clause::ACCC_device_resident,
70 Clause::ACCC_link,
71};
72
73static AccClauseSet allowedOnceClauses_ACCD_declare {
74};
75
76static AccClauseSet allowedExclusiveClauses_ACCD_declare {
77};
78
79static AccClauseSet requiredClauses_ACCD_declare {
80};
81// Sets for enter data
82
83static AccClauseSet allowedClauses_ACCD_enter_data {
84 Clause::ACCC_wait,
85};
86
87static AccClauseSet allowedOnceClauses_ACCD_enter_data {
88 Clause::ACCC_async,
89 Clause::ACCC_if,
90};
91
92static AccClauseSet allowedExclusiveClauses_ACCD_enter_data {
93};
94
95static AccClauseSet requiredClauses_ACCD_enter_data {
96 Clause::ACCC_attach,
97 Clause::ACCC_create,
98 Clause::ACCC_copyin,
99};
100// Sets for exit data
101
102static AccClauseSet allowedClauses_ACCD_exit_data {
103 Clause::ACCC_finalize,
104 Clause::ACCC_wait,
105};
106
107static AccClauseSet allowedOnceClauses_ACCD_exit_data {
108 Clause::ACCC_async,
109 Clause::ACCC_if,
110};
111
112static AccClauseSet allowedExclusiveClauses_ACCD_exit_data {
113};
114
115static AccClauseSet requiredClauses_ACCD_exit_data {
116 Clause::ACCC_copyout,
117 Clause::ACCC_delete,
118 Clause::ACCC_detach,
119};
120// Sets for host_data
121
122static AccClauseSet allowedClauses_ACCD_host_data {
123 Clause::ACCC_if_present,
124};
125
126static AccClauseSet allowedOnceClauses_ACCD_host_data {
127 Clause::ACCC_if,
128};
129
130static AccClauseSet allowedExclusiveClauses_ACCD_host_data {
131};
132
133static AccClauseSet requiredClauses_ACCD_host_data {
134 Clause::ACCC_use_device,
135};
136// Sets for init
137
138static AccClauseSet allowedClauses_ACCD_init {
139 Clause::ACCC_device_type,
140};
141
142static AccClauseSet allowedOnceClauses_ACCD_init {
143 Clause::ACCC_device_num,
144 Clause::ACCC_if,
145};
146
147static AccClauseSet allowedExclusiveClauses_ACCD_init {
148};
149
150static AccClauseSet requiredClauses_ACCD_init {
151};
152// Sets for kernels
153
154static AccClauseSet allowedClauses_ACCD_kernels {
155 Clause::ACCC_async,
156 Clause::ACCC_attach,
157 Clause::ACCC_copy,
158 Clause::ACCC_copyin,
159 Clause::ACCC_copyout,
160 Clause::ACCC_create,
161 Clause::ACCC_device_type,
162 Clause::ACCC_no_create,
163 Clause::ACCC_num_gangs,
164 Clause::ACCC_num_workers,
165 Clause::ACCC_present,
166 Clause::ACCC_deviceptr,
167 Clause::ACCC_vector_length,
168 Clause::ACCC_wait,
169};
170
171static AccClauseSet allowedOnceClauses_ACCD_kernels {
172 Clause::ACCC_default,
173 Clause::ACCC_if,
174 Clause::ACCC_self,
175};
176
177static AccClauseSet allowedExclusiveClauses_ACCD_kernels {
178};
179
180static AccClauseSet requiredClauses_ACCD_kernels {
181};
182// Sets for kernels loop
183
184static AccClauseSet allowedClauses_ACCD_kernels_loop {
185 Clause::ACCC_async,
186 Clause::ACCC_attach,
187 Clause::ACCC_collapse,
188 Clause::ACCC_copy,
189 Clause::ACCC_copyin,
190 Clause::ACCC_copyout,
191 Clause::ACCC_create,
192 Clause::ACCC_deviceptr,
193 Clause::ACCC_device_type,
194 Clause::ACCC_gang,
195 Clause::ACCC_no_create,
196 Clause::ACCC_num_gangs,
197 Clause::ACCC_num_workers,
198 Clause::ACCC_present,
199 Clause::ACCC_private,
200 Clause::ACCC_reduction,
201 Clause::ACCC_shortloop,
202 Clause::ACCC_tile,
203 Clause::ACCC_vector,
204 Clause::ACCC_vector_length,
205 Clause::ACCC_wait,
206 Clause::ACCC_worker,
207};
208
209static AccClauseSet allowedOnceClauses_ACCD_kernels_loop {
210 Clause::ACCC_default,
211 Clause::ACCC_if,
212 Clause::ACCC_self,
213};
214
215static AccClauseSet allowedExclusiveClauses_ACCD_kernels_loop {
216 Clause::ACCC_auto,
217 Clause::ACCC_independent,
218 Clause::ACCC_seq,
219};
220
221static AccClauseSet requiredClauses_ACCD_kernels_loop {
222};
223// Sets for loop
224
225static AccClauseSet allowedClauses_ACCD_loop {
226 Clause::ACCC_device_type,
227 Clause::ACCC_private,
228 Clause::ACCC_reduction,
229 Clause::ACCC_collapse,
230 Clause::ACCC_gang,
231 Clause::ACCC_shortloop,
232 Clause::ACCC_tile,
233 Clause::ACCC_vector,
234 Clause::ACCC_worker,
235};
236
237static AccClauseSet allowedOnceClauses_ACCD_loop {
238};
239
240static AccClauseSet allowedExclusiveClauses_ACCD_loop {
241 Clause::ACCC_auto,
242 Clause::ACCC_independent,
243 Clause::ACCC_seq,
244};
245
246static AccClauseSet requiredClauses_ACCD_loop {
247};
248// Sets for parallel
249
250static AccClauseSet allowedClauses_ACCD_parallel {
251 Clause::ACCC_attach,
252 Clause::ACCC_async,
253 Clause::ACCC_copy,
254 Clause::ACCC_copyin,
255 Clause::ACCC_copyout,
256 Clause::ACCC_create,
257 Clause::ACCC_deviceptr,
258 Clause::ACCC_device_type,
259 Clause::ACCC_no_create,
260 Clause::ACCC_num_gangs,
261 Clause::ACCC_num_workers,
262 Clause::ACCC_present,
263 Clause::ACCC_private,
264 Clause::ACCC_firstprivate,
265 Clause::ACCC_reduction,
266 Clause::ACCC_wait,
267 Clause::ACCC_vector_length,
268};
269
270static AccClauseSet allowedOnceClauses_ACCD_parallel {
271 Clause::ACCC_default,
272 Clause::ACCC_if,
273 Clause::ACCC_self,
274};
275
276static AccClauseSet allowedExclusiveClauses_ACCD_parallel {
277};
278
279static AccClauseSet requiredClauses_ACCD_parallel {
280};
281// Sets for parallel loop
282
283static AccClauseSet allowedClauses_ACCD_parallel_loop {
284 Clause::ACCC_async,
285 Clause::ACCC_attach,
286 Clause::ACCC_collapse,
287 Clause::ACCC_copy,
288 Clause::ACCC_copyin,
289 Clause::ACCC_copyout,
290 Clause::ACCC_create,
291 Clause::ACCC_deviceptr,
292 Clause::ACCC_device_type,
293 Clause::ACCC_firstprivate,
294 Clause::ACCC_gang,
295 Clause::ACCC_no_create,
296 Clause::ACCC_num_gangs,
297 Clause::ACCC_num_workers,
298 Clause::ACCC_present,
299 Clause::ACCC_private,
300 Clause::ACCC_reduction,
301 Clause::ACCC_shortloop,
302 Clause::ACCC_tile,
303 Clause::ACCC_vector,
304 Clause::ACCC_vector_length,
305 Clause::ACCC_wait,
306 Clause::ACCC_worker,
307};
308
309static AccClauseSet allowedOnceClauses_ACCD_parallel_loop {
310 Clause::ACCC_default,
311 Clause::ACCC_if,
312 Clause::ACCC_self,
313};
314
315static AccClauseSet allowedExclusiveClauses_ACCD_parallel_loop {
316 Clause::ACCC_auto,
317 Clause::ACCC_independent,
318 Clause::ACCC_seq,
319};
320
321static AccClauseSet requiredClauses_ACCD_parallel_loop {
322};
323// Sets for routine
324
325static AccClauseSet allowedClauses_ACCD_routine {
326 Clause::ACCC_bind,
327 Clause::ACCC_device_type,
328 Clause::ACCC_gang,
329 Clause::ACCC_seq,
330 Clause::ACCC_vector,
331 Clause::ACCC_worker,
332};
333
334static AccClauseSet allowedOnceClauses_ACCD_routine {
335 Clause::ACCC_nohost,
336};
337
338static AccClauseSet allowedExclusiveClauses_ACCD_routine {
339};
340
341static AccClauseSet requiredClauses_ACCD_routine {
342};
343// Sets for serial
344
345static AccClauseSet allowedClauses_ACCD_serial {
346 Clause::ACCC_async,
347 Clause::ACCC_attach,
348 Clause::ACCC_copy,
349 Clause::ACCC_copyin,
350 Clause::ACCC_copyout,
351 Clause::ACCC_create,
352 Clause::ACCC_deviceptr,
353 Clause::ACCC_device_type,
354 Clause::ACCC_no_create,
355 Clause::ACCC_present,
356 Clause::ACCC_private,
357 Clause::ACCC_firstprivate,
358 Clause::ACCC_reduction,
359 Clause::ACCC_wait,
360};
361
362static AccClauseSet allowedOnceClauses_ACCD_serial {
363 Clause::ACCC_default,
364 Clause::ACCC_if,
365 Clause::ACCC_self,
366};
367
368static AccClauseSet allowedExclusiveClauses_ACCD_serial {
369};
370
371static AccClauseSet requiredClauses_ACCD_serial {
372};
373// Sets for serial loop
374
375static AccClauseSet allowedClauses_ACCD_serial_loop {
376 Clause::ACCC_async,
377 Clause::ACCC_attach,
378 Clause::ACCC_collapse,
379 Clause::ACCC_copy,
380 Clause::ACCC_copyin,
381 Clause::ACCC_copyout,
382 Clause::ACCC_create,
383 Clause::ACCC_deviceptr,
384 Clause::ACCC_device_type,
385 Clause::ACCC_firstprivate,
386 Clause::ACCC_gang,
387 Clause::ACCC_no_create,
388 Clause::ACCC_present,
389 Clause::ACCC_private,
390 Clause::ACCC_reduction,
391 Clause::ACCC_shortloop,
392 Clause::ACCC_tile,
393 Clause::ACCC_vector,
394 Clause::ACCC_wait,
395 Clause::ACCC_worker,
396};
397
398static AccClauseSet allowedOnceClauses_ACCD_serial_loop {
399 Clause::ACCC_default,
400 Clause::ACCC_if,
401 Clause::ACCC_self,
402};
403
404static AccClauseSet allowedExclusiveClauses_ACCD_serial_loop {
405 Clause::ACCC_auto,
406 Clause::ACCC_independent,
407 Clause::ACCC_seq,
408};
409
410static AccClauseSet requiredClauses_ACCD_serial_loop {
411};
412// Sets for set
413
414static AccClauseSet allowedClauses_ACCD_set {
415};
416
417static AccClauseSet allowedOnceClauses_ACCD_set {
418 Clause::ACCC_default_async,
419 Clause::ACCC_device_num,
420 Clause::ACCC_device_type,
421 Clause::ACCC_if,
422};
423
424static AccClauseSet allowedExclusiveClauses_ACCD_set {
425};
426
427static AccClauseSet requiredClauses_ACCD_set {
428 Clause::ACCC_default_async,
429 Clause::ACCC_device_num,
430 Clause::ACCC_device_type,
431};
432// Sets for shutdown
433
434static AccClauseSet allowedClauses_ACCD_shutdown {
435 Clause::ACCC_device_type,
436};
437
438static AccClauseSet allowedOnceClauses_ACCD_shutdown {
439 Clause::ACCC_device_num,
440 Clause::ACCC_if,
441};
442
443static AccClauseSet allowedExclusiveClauses_ACCD_shutdown {
444};
445
446static AccClauseSet requiredClauses_ACCD_shutdown {
447};
448// Sets for unknown
449
450static AccClauseSet allowedClauses_ACCD_unknown {
451};
452
453static AccClauseSet allowedOnceClauses_ACCD_unknown {
454};
455
456static AccClauseSet allowedExclusiveClauses_ACCD_unknown {
457};
458
459static AccClauseSet requiredClauses_ACCD_unknown {
460};
461// Sets for update
462
463static AccClauseSet allowedClauses_ACCD_update {
464 Clause::ACCC_device_type,
465 Clause::ACCC_if_present,
466 Clause::ACCC_wait,
467};
468
469static AccClauseSet allowedOnceClauses_ACCD_update {
470 Clause::ACCC_async,
471 Clause::ACCC_if,
472};
473
474static AccClauseSet allowedExclusiveClauses_ACCD_update {
475};
476
477static AccClauseSet requiredClauses_ACCD_update {
478 Clause::ACCC_device,
479 Clause::ACCC_host,
480 Clause::ACCC_self,
481};
482// Sets for wait
483
484static AccClauseSet allowedClauses_ACCD_wait {
485};
486
487static AccClauseSet allowedOnceClauses_ACCD_wait {
488 Clause::ACCC_async,
489 Clause::ACCC_if,
490};
491
492static AccClauseSet allowedExclusiveClauses_ACCD_wait {
493};
494
495static AccClauseSet requiredClauses_ACCD_wait {
496};
497
498} // namespace llvm::acc
499
500#endif // GEN_FLANG_DIRECTIVE_CLAUSE_SETS
501
502#ifdef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
503#undef GEN_FLANG_DIRECTIVE_CLAUSE_MAP
504
505{
506 {llvm::acc::Directive::ACCD_atomic,
507 {
508 llvm::acc::allowedClauses_ACCD_atomic,
509 llvm::acc::allowedOnceClauses_ACCD_atomic,
510 llvm::acc::allowedExclusiveClauses_ACCD_atomic,
511 llvm::acc::requiredClauses_ACCD_atomic,
512 }
513 },
514 {llvm::acc::Directive::ACCD_cache,
515 {
516 llvm::acc::allowedClauses_ACCD_cache,
517 llvm::acc::allowedOnceClauses_ACCD_cache,
518 llvm::acc::allowedExclusiveClauses_ACCD_cache,
519 llvm::acc::requiredClauses_ACCD_cache,
520 }
521 },
522 {llvm::acc::Directive::ACCD_data,
523 {
524 llvm::acc::allowedClauses_ACCD_data,
525 llvm::acc::allowedOnceClauses_ACCD_data,
526 llvm::acc::allowedExclusiveClauses_ACCD_data,
527 llvm::acc::requiredClauses_ACCD_data,
528 }
529 },
530 {llvm::acc::Directive::ACCD_declare,
531 {
532 llvm::acc::allowedClauses_ACCD_declare,
533 llvm::acc::allowedOnceClauses_ACCD_declare,
534 llvm::acc::allowedExclusiveClauses_ACCD_declare,
535 llvm::acc::requiredClauses_ACCD_declare,
536 }
537 },
538 {llvm::acc::Directive::ACCD_enter_data,
539 {
540 llvm::acc::allowedClauses_ACCD_enter_data,
541 llvm::acc::allowedOnceClauses_ACCD_enter_data,
542 llvm::acc::allowedExclusiveClauses_ACCD_enter_data,
543 llvm::acc::requiredClauses_ACCD_enter_data,
544 }
545 },
546 {llvm::acc::Directive::ACCD_exit_data,
547 {
548 llvm::acc::allowedClauses_ACCD_exit_data,
549 llvm::acc::allowedOnceClauses_ACCD_exit_data,
550 llvm::acc::allowedExclusiveClauses_ACCD_exit_data,
551 llvm::acc::requiredClauses_ACCD_exit_data,
552 }
553 },
554 {llvm::acc::Directive::ACCD_host_data,
555 {
556 llvm::acc::allowedClauses_ACCD_host_data,
557 llvm::acc::allowedOnceClauses_ACCD_host_data,
558 llvm::acc::allowedExclusiveClauses_ACCD_host_data,
559 llvm::acc::requiredClauses_ACCD_host_data,
560 }
561 },
562 {llvm::acc::Directive::ACCD_init,
563 {
564 llvm::acc::allowedClauses_ACCD_init,
565 llvm::acc::allowedOnceClauses_ACCD_init,
566 llvm::acc::allowedExclusiveClauses_ACCD_init,
567 llvm::acc::requiredClauses_ACCD_init,
568 }
569 },
570 {llvm::acc::Directive::ACCD_kernels,
571 {
572 llvm::acc::allowedClauses_ACCD_kernels,
573 llvm::acc::allowedOnceClauses_ACCD_kernels,
574 llvm::acc::allowedExclusiveClauses_ACCD_kernels,
575 llvm::acc::requiredClauses_ACCD_kernels,
576 }
577 },
578 {llvm::acc::Directive::ACCD_kernels_loop,
579 {
580 llvm::acc::allowedClauses_ACCD_kernels_loop,
581 llvm::acc::allowedOnceClauses_ACCD_kernels_loop,
582 llvm::acc::allowedExclusiveClauses_ACCD_kernels_loop,
583 llvm::acc::requiredClauses_ACCD_kernels_loop,
584 }
585 },
586 {llvm::acc::Directive::ACCD_loop,
587 {
588 llvm::acc::allowedClauses_ACCD_loop,
589 llvm::acc::allowedOnceClauses_ACCD_loop,
590 llvm::acc::allowedExclusiveClauses_ACCD_loop,
591 llvm::acc::requiredClauses_ACCD_loop,
592 }
593 },
594 {llvm::acc::Directive::ACCD_parallel,
595 {
596 llvm::acc::allowedClauses_ACCD_parallel,
597 llvm::acc::allowedOnceClauses_ACCD_parallel,
598 llvm::acc::allowedExclusiveClauses_ACCD_parallel,
599 llvm::acc::requiredClauses_ACCD_parallel,
600 }
601 },
602 {llvm::acc::Directive::ACCD_parallel_loop,
603 {
604 llvm::acc::allowedClauses_ACCD_parallel_loop,
605 llvm::acc::allowedOnceClauses_ACCD_parallel_loop,
606 llvm::acc::allowedExclusiveClauses_ACCD_parallel_loop,
607 llvm::acc::requiredClauses_ACCD_parallel_loop,
608 }
609 },
610 {llvm::acc::Directive::ACCD_routine,
611 {
612 llvm::acc::allowedClauses_ACCD_routine,
613 llvm::acc::allowedOnceClauses_ACCD_routine,
614 llvm::acc::allowedExclusiveClauses_ACCD_routine,
615 llvm::acc::requiredClauses_ACCD_routine,
616 }
617 },
618 {llvm::acc::Directive::ACCD_serial,
619 {
620 llvm::acc::allowedClauses_ACCD_serial,
621 llvm::acc::allowedOnceClauses_ACCD_serial,
622 llvm::acc::allowedExclusiveClauses_ACCD_serial,
623 llvm::acc::requiredClauses_ACCD_serial,
624 }
625 },
626 {llvm::acc::Directive::ACCD_serial_loop,
627 {
628 llvm::acc::allowedClauses_ACCD_serial_loop,
629 llvm::acc::allowedOnceClauses_ACCD_serial_loop,
630 llvm::acc::allowedExclusiveClauses_ACCD_serial_loop,
631 llvm::acc::requiredClauses_ACCD_serial_loop,
632 }
633 },
634 {llvm::acc::Directive::ACCD_set,
635 {
636 llvm::acc::allowedClauses_ACCD_set,
637 llvm::acc::allowedOnceClauses_ACCD_set,
638 llvm::acc::allowedExclusiveClauses_ACCD_set,
639 llvm::acc::requiredClauses_ACCD_set,
640 }
641 },
642 {llvm::acc::Directive::ACCD_shutdown,
643 {
644 llvm::acc::allowedClauses_ACCD_shutdown,
645 llvm::acc::allowedOnceClauses_ACCD_shutdown,
646 llvm::acc::allowedExclusiveClauses_ACCD_shutdown,
647 llvm::acc::requiredClauses_ACCD_shutdown,
648 }
649 },
650 {llvm::acc::Directive::ACCD_unknown,
651 {
652 llvm::acc::allowedClauses_ACCD_unknown,
653 llvm::acc::allowedOnceClauses_ACCD_unknown,
654 llvm::acc::allowedExclusiveClauses_ACCD_unknown,
655 llvm::acc::requiredClauses_ACCD_unknown,
656 }
657 },
658 {llvm::acc::Directive::ACCD_update,
659 {
660 llvm::acc::allowedClauses_ACCD_update,
661 llvm::acc::allowedOnceClauses_ACCD_update,
662 llvm::acc::allowedExclusiveClauses_ACCD_update,
663 llvm::acc::requiredClauses_ACCD_update,
664 }
665 },
666 {llvm::acc::Directive::ACCD_wait,
667 {
668 llvm::acc::allowedClauses_ACCD_wait,
669 llvm::acc::allowedOnceClauses_ACCD_wait,
670 llvm::acc::allowedExclusiveClauses_ACCD_wait,
671 llvm::acc::requiredClauses_ACCD_wait,
672 }
673 },
674}
675
676#endif // GEN_FLANG_DIRECTIVE_CLAUSE_MAP
677
678#ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES
679#undef GEN_FLANG_CLAUSE_PARSER_CLASSES
680
681WRAPPER_CLASS(Async, std::optional<ScalarIntExpr>);
682WRAPPER_CLASS(Attach, AccObjectList);
683EMPTY_CLASS(Auto);
684WRAPPER_CLASS(Bind, AccBindClause);
685EMPTY_CLASS(Capture);
686WRAPPER_CLASS(Collapse, AccCollapseArg);
687WRAPPER_CLASS(Copy, AccObjectList);
688WRAPPER_CLASS(Copyin, AccObjectListWithModifier);
689WRAPPER_CLASS(Copyout, AccObjectListWithModifier);
690WRAPPER_CLASS(Create, AccObjectListWithModifier);
691WRAPPER_CLASS(Default, AccDefaultClause);
692WRAPPER_CLASS(DefaultAsync, ScalarIntExpr);
693WRAPPER_CLASS(Delete, AccObjectList);
694WRAPPER_CLASS(Detach, AccObjectList);
695WRAPPER_CLASS(Device, AccObjectList);
696WRAPPER_CLASS(DeviceNum, ScalarIntExpr);
697WRAPPER_CLASS(Deviceptr, AccObjectList);
698WRAPPER_CLASS(DeviceResident, AccObjectList);
699WRAPPER_CLASS(DeviceType, AccDeviceTypeExprList);
700EMPTY_CLASS(Finalize);
701WRAPPER_CLASS(Firstprivate, AccObjectList);
702WRAPPER_CLASS(Gang, std::optional<AccGangArgList>);
703WRAPPER_CLASS(Host, AccObjectList);
704WRAPPER_CLASS(If, ScalarExpr);
705EMPTY_CLASS(IfPresent);
706EMPTY_CLASS(Independent);
707WRAPPER_CLASS(Link, AccObjectList);
708WRAPPER_CLASS(NoCreate, AccObjectList);
709EMPTY_CLASS(Nohost);
710WRAPPER_CLASS(NumGangs, std::list<ScalarIntExpr>);
711WRAPPER_CLASS(NumWorkers, ScalarIntExpr);
712WRAPPER_CLASS(Present, AccObjectList);
713WRAPPER_CLASS(Private, AccObjectList);
714EMPTY_CLASS(Read);
715WRAPPER_CLASS(Reduction, AccObjectListWithReduction);
716WRAPPER_CLASS(Self, std::optional<AccSelfClause>);
717EMPTY_CLASS(Seq);
718EMPTY_CLASS(Shortloop);
719WRAPPER_CLASS(Tile, AccTileExprList);
720EMPTY_CLASS(Unknown);
721WRAPPER_CLASS(UseDevice, AccObjectList);
722WRAPPER_CLASS(Vector, std::optional<ScalarIntExpr>);
723WRAPPER_CLASS(VectorLength, ScalarIntExpr);
724WRAPPER_CLASS(Wait, std::optional<AccWaitArgument>);
725WRAPPER_CLASS(Worker, std::optional<ScalarIntExpr>);
726EMPTY_CLASS(Write);
727
728#endif // GEN_FLANG_CLAUSE_PARSER_CLASSES
729
730#ifdef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
731#undef GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
732
733Async
734, Attach
735, Auto
736, Bind
737, Capture
738, Collapse
739, Copy
740, Copyin
741, Copyout
742, Create
743, Default
744, DefaultAsync
745, Delete
746, Detach
747, Device
748, DeviceNum
749, Deviceptr
750, DeviceResident
751, DeviceType
752, Finalize
753, Firstprivate
754, Gang
755, Host
756, If
757, IfPresent
758, Independent
759, Link
760, NoCreate
761, Nohost
762, NumGangs
763, NumWorkers
764, Present
765, Private
766, Read
767, Reduction
768, Self
769, Seq
770, Shortloop
771, Tile
772, Unknown
773, UseDevice
774, Vector
775, VectorLength
776, Wait
777, Worker
778, Write
779
780#endif // GEN_FLANG_CLAUSE_PARSER_CLASSES_LIST
781
782#ifdef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
783#undef GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
784
785NODE(AccClause, Async)
786NODE(AccClause, Attach)
787NODE(AccClause, Auto)
788NODE(AccClause, Bind)
789NODE(AccClause, Capture)
790NODE(AccClause, Collapse)
791NODE(AccClause, Copy)
792NODE(AccClause, Copyin)
793NODE(AccClause, Copyout)
794NODE(AccClause, Create)
795NODE(AccClause, Default)
796NODE(AccClause, DefaultAsync)
797NODE(AccClause, Delete)
798NODE(AccClause, Detach)
799NODE(AccClause, Device)
800NODE(AccClause, DeviceNum)
801NODE(AccClause, Deviceptr)
802NODE(AccClause, DeviceResident)
803NODE(AccClause, DeviceType)
804NODE(AccClause, Finalize)
805NODE(AccClause, Firstprivate)
806NODE(AccClause, Gang)
807NODE(AccClause, Host)
808NODE(AccClause, If)
809NODE(AccClause, IfPresent)
810NODE(AccClause, Independent)
811NODE(AccClause, Link)
812NODE(AccClause, NoCreate)
813NODE(AccClause, Nohost)
814NODE(AccClause, NumGangs)
815NODE(AccClause, NumWorkers)
816NODE(AccClause, Present)
817NODE(AccClause, Private)
818NODE(AccClause, Read)
819NODE(AccClause, Reduction)
820NODE(AccClause, Self)
821NODE(AccClause, Seq)
822NODE(AccClause, Shortloop)
823NODE(AccClause, Tile)
824NODE(AccClause, Unknown)
825NODE(AccClause, UseDevice)
826NODE(AccClause, Vector)
827NODE(AccClause, VectorLength)
828NODE(AccClause, Wait)
829NODE(AccClause, Worker)
830NODE(AccClause, Write)
831
832#endif // GEN_FLANG_DUMP_PARSE_TREE_CLAUSES
833
834#ifdef GEN_FLANG_CLAUSE_UNPARSE
835#undef GEN_FLANG_CLAUSE_UNPARSE
836
837void Unparse(const AccClause::Async &x) {
838 Word("ASYNC");
839 Walk("(", x.v, ")");
840}
841void Unparse(const AccClause::Attach &x) {
842 Word("ATTACH");
843 Put("(");
844 Walk(x.v);
845 Put(")");
846}
847void Before(const AccClause::Auto &) { Word("AUTO"); }
848void Unparse(const AccClause::Bind &x) {
849 Word("BIND");
850 Put("(");
851 Walk(x.v);
852 Put(")");
853}
854void Before(const AccClause::Capture &) { Word("CAPTURE"); }
855void Unparse(const AccClause::Collapse &x) {
856 Word("COLLAPSE");
857 Put("(");
858 Walk(x.v);
859 Put(")");
860}
861void Unparse(const AccClause::Copy &x) {
862 Word("COPY");
863 Put("(");
864 Walk(x.v);
865 Put(")");
866}
867void Unparse(const AccClause::Copyin &x) {
868 Word("COPYIN");
869 Put("(");
870 Walk(x.v);
871 Put(")");
872}
873void Unparse(const AccClause::Copyout &x) {
874 Word("COPYOUT");
875 Put("(");
876 Walk(x.v);
877 Put(")");
878}
879void Unparse(const AccClause::Create &x) {
880 Word("CREATE");
881 Put("(");
882 Walk(x.v);
883 Put(")");
884}
885void Unparse(const AccClause::Default &x) {
886 Word("DEFAULT");
887 Put("(");
888 Walk(x.v);
889 Put(")");
890}
891void Unparse(const AccClause::DefaultAsync &x) {
892 Word("DEFAULT_ASYNC");
893 Put("(");
894 Walk(x.v);
895 Put(")");
896}
897void Unparse(const AccClause::Delete &x) {
898 Word("DELETE");
899 Put("(");
900 Walk(x.v);
901 Put(")");
902}
903void Unparse(const AccClause::Detach &x) {
904 Word("DETACH");
905 Put("(");
906 Walk(x.v);
907 Put(")");
908}
909void Unparse(const AccClause::Device &x) {
910 Word("DEVICE");
911 Put("(");
912 Walk(x.v);
913 Put(")");
914}
915void Unparse(const AccClause::DeviceNum &x) {
916 Word("DEVICE_NUM");
917 Put("(");
918 Walk(x.v);
919 Put(")");
920}
921void Unparse(const AccClause::Deviceptr &x) {
922 Word("DEVICEPTR");
923 Put("(");
924 Walk(x.v);
925 Put(")");
926}
927void Unparse(const AccClause::DeviceResident &x) {
928 Word("DEVICE_RESIDENT");
929 Put("(");
930 Walk(x.v);
931 Put(")");
932}
933void Unparse(const AccClause::DeviceType &x) {
934 Word("DEVICE_TYPE");
935 Put("(");
936 Walk(x.v);
937 Put(")");
938}
939void Before(const AccClause::Finalize &) { Word("FINALIZE"); }
940void Unparse(const AccClause::Firstprivate &x) {
941 Word("FIRSTPRIVATE");
942 Put("(");
943 Walk(x.v);
944 Put(")");
945}
946void Unparse(const AccClause::Gang &x) {
947 Word("GANG");
948 Walk("(", x.v, ")");
949}
950void Unparse(const AccClause::Host &x) {
951 Word("HOST");
952 Put("(");
953 Walk(x.v);
954 Put(")");
955}
956void Unparse(const AccClause::If &x) {
957 Word("IF");
958 Put("(");
959 Walk(x.v);
960 Put(")");
961}
962void Before(const AccClause::IfPresent &) { Word("IF_PRESENT"); }
963void Before(const AccClause::Independent &) { Word("INDEPENDENT"); }
964void Unparse(const AccClause::Link &x) {
965 Word("LINK");
966 Put("(");
967 Walk(x.v);
968 Put(")");
969}
970void Unparse(const AccClause::NoCreate &x) {
971 Word("NO_CREATE");
972 Put("(");
973 Walk(x.v);
974 Put(")");
975}
976void Before(const AccClause::Nohost &) { Word("NOHOST"); }
977void Unparse(const AccClause::NumGangs &x) {
978 Word("NUM_GANGS");
979 Put("(");
980 Walk(x.v, ",");
981 Put(")");
982}
983void Unparse(const AccClause::NumWorkers &x) {
984 Word("NUM_WORKERS");
985 Put("(");
986 Walk(x.v);
987 Put(")");
988}
989void Unparse(const AccClause::Present &x) {
990 Word("PRESENT");
991 Put("(");
992 Walk(x.v);
993 Put(")");
994}
995void Unparse(const AccClause::Private &x) {
996 Word("PRIVATE");
997 Put("(");
998 Walk(x.v);
999 Put(")");
1000}
1001void Before(const AccClause::Read &) { Word("READ"); }
1002void Unparse(const AccClause::Reduction &x) {
1003 Word("REDUCTION");
1004 Put("(");
1005 Walk(x.v);
1006 Put(")");
1007}
1008void Unparse(const AccClause::Self &x) {
1009 Word("SELF");
1010 Walk("(", x.v, ")");
1011}
1012void Before(const AccClause::Seq &) { Word("SEQ"); }
1013void Before(const AccClause::Shortloop &) { Word("SHORTLOOP"); }
1014void Unparse(const AccClause::Tile &x) {
1015 Word("TILE");
1016 Put("(");
1017 Walk(x.v);
1018 Put(")");
1019}
1020void Before(const AccClause::Unknown &) { Word("UNKNOWN"); }
1021void Unparse(const AccClause::UseDevice &x) {
1022 Word("USE_DEVICE");
1023 Put("(");
1024 Walk(x.v);
1025 Put(")");
1026}
1027void Unparse(const AccClause::Vector &x) {
1028 Word("VECTOR");
1029 Walk("(", x.v, ")");
1030}
1031void Unparse(const AccClause::VectorLength &x) {
1032 Word("VECTOR_LENGTH");
1033 Put("(");
1034 Walk(x.v);
1035 Put(")");
1036}
1037void Unparse(const AccClause::Wait &x) {
1038 Word("WAIT");
1039 Walk("(", x.v, ")");
1040}
1041void Unparse(const AccClause::Worker &x) {
1042 Word("WORKER");
1043 Walk("(", x.v, ")");
1044}
1045void Before(const AccClause::Write &) { Word("WRITE"); }
1046
1047#endif // GEN_FLANG_CLAUSE_UNPARSE
1048
1049#ifdef GEN_FLANG_CLAUSE_CHECK_ENTER
1050#undef GEN_FLANG_CLAUSE_CHECK_ENTER
1051
1052void Enter(const parser::AccClause::Async &);
1053void Enter(const parser::AccClause::Attach &);
1054void Enter(const parser::AccClause::Auto &);
1055void Enter(const parser::AccClause::Bind &);
1056void Enter(const parser::AccClause::Capture &);
1057void Enter(const parser::AccClause::Collapse &);
1058void Enter(const parser::AccClause::Copy &);
1059void Enter(const parser::AccClause::Copyin &);
1060void Enter(const parser::AccClause::Copyout &);
1061void Enter(const parser::AccClause::Create &);
1062void Enter(const parser::AccClause::Default &);
1063void Enter(const parser::AccClause::DefaultAsync &);
1064void Enter(const parser::AccClause::Delete &);
1065void Enter(const parser::AccClause::Detach &);
1066void Enter(const parser::AccClause::Device &);
1067void Enter(const parser::AccClause::DeviceNum &);
1068void Enter(const parser::AccClause::Deviceptr &);
1069void Enter(const parser::AccClause::DeviceResident &);
1070void Enter(const parser::AccClause::DeviceType &);
1071void Enter(const parser::AccClause::Finalize &);
1072void Enter(const parser::AccClause::Firstprivate &);
1073void Enter(const parser::AccClause::Gang &);
1074void Enter(const parser::AccClause::Host &);
1075void Enter(const parser::AccClause::If &);
1076void Enter(const parser::AccClause::IfPresent &);
1077void Enter(const parser::AccClause::Independent &);
1078void Enter(const parser::AccClause::Link &);
1079void Enter(const parser::AccClause::NoCreate &);
1080void Enter(const parser::AccClause::Nohost &);
1081void Enter(const parser::AccClause::NumGangs &);
1082void Enter(const parser::AccClause::NumWorkers &);
1083void Enter(const parser::AccClause::Present &);
1084void Enter(const parser::AccClause::Private &);
1085void Enter(const parser::AccClause::Read &);
1086void Enter(const parser::AccClause::Reduction &);
1087void Enter(const parser::AccClause::Self &);
1088void Enter(const parser::AccClause::Seq &);
1089void Enter(const parser::AccClause::Shortloop &);
1090void Enter(const parser::AccClause::Tile &);
1091void Enter(const parser::AccClause::Unknown &);
1092void Enter(const parser::AccClause::UseDevice &);
1093void Enter(const parser::AccClause::Vector &);
1094void Enter(const parser::AccClause::VectorLength &);
1095void Enter(const parser::AccClause::Wait &);
1096void Enter(const parser::AccClause::Worker &);
1097void Enter(const parser::AccClause::Write &);
1098
1099#endif // GEN_FLANG_CLAUSE_CHECK_ENTER
1100
1101#ifdef GEN_FLANG_CLAUSE_PARSER_KIND_MAP
1102#undef GEN_FLANG_CLAUSE_PARSER_KIND_MAP
1103
1104if constexpr (std::is_same_v<A, parser::AccClause::Async>)
1105 return llvm::acc::Clause::ACCC_async;
1106if constexpr (std::is_same_v<A, parser::AccClause::Attach>)
1107 return llvm::acc::Clause::ACCC_attach;
1108if constexpr (std::is_same_v<A, parser::AccClause::Auto>)
1109 return llvm::acc::Clause::ACCC_auto;
1110if constexpr (std::is_same_v<A, parser::AccClause::Bind>)
1111 return llvm::acc::Clause::ACCC_bind;
1112if constexpr (std::is_same_v<A, parser::AccClause::Capture>)
1113 return llvm::acc::Clause::ACCC_capture;
1114if constexpr (std::is_same_v<A, parser::AccClause::Collapse>)
1115 return llvm::acc::Clause::ACCC_collapse;
1116if constexpr (std::is_same_v<A, parser::AccClause::Copy>)
1117 return llvm::acc::Clause::ACCC_copy;
1118if constexpr (std::is_same_v<A, parser::AccClause::Copyin>)
1119 return llvm::acc::Clause::ACCC_copyin;
1120if constexpr (std::is_same_v<A, parser::AccClause::Copyout>)
1121 return llvm::acc::Clause::ACCC_copyout;
1122if constexpr (std::is_same_v<A, parser::AccClause::Create>)
1123 return llvm::acc::Clause::ACCC_create;
1124if constexpr (std::is_same_v<A, parser::AccClause::Default>)
1125 return llvm::acc::Clause::ACCC_default;
1126if constexpr (std::is_same_v<A, parser::AccClause::DefaultAsync>)
1127 return llvm::acc::Clause::ACCC_default_async;
1128if constexpr (std::is_same_v<A, parser::AccClause::Delete>)
1129 return llvm::acc::Clause::ACCC_delete;
1130if constexpr (std::is_same_v<A, parser::AccClause::Detach>)
1131 return llvm::acc::Clause::ACCC_detach;
1132if constexpr (std::is_same_v<A, parser::AccClause::Device>)
1133 return llvm::acc::Clause::ACCC_device;
1134if constexpr (std::is_same_v<A, parser::AccClause::DeviceNum>)
1135 return llvm::acc::Clause::ACCC_device_num;
1136if constexpr (std::is_same_v<A, parser::AccClause::Deviceptr>)
1137 return llvm::acc::Clause::ACCC_deviceptr;
1138if constexpr (std::is_same_v<A, parser::AccClause::DeviceResident>)
1139 return llvm::acc::Clause::ACCC_device_resident;
1140if constexpr (std::is_same_v<A, parser::AccClause::DeviceType>)
1141 return llvm::acc::Clause::ACCC_device_type;
1142if constexpr (std::is_same_v<A, parser::AccClause::Finalize>)
1143 return llvm::acc::Clause::ACCC_finalize;
1144if constexpr (std::is_same_v<A, parser::AccClause::Firstprivate>)
1145 return llvm::acc::Clause::ACCC_firstprivate;
1146if constexpr (std::is_same_v<A, parser::AccClause::Gang>)
1147 return llvm::acc::Clause::ACCC_gang;
1148if constexpr (std::is_same_v<A, parser::AccClause::Host>)
1149 return llvm::acc::Clause::ACCC_host;
1150if constexpr (std::is_same_v<A, parser::AccClause::If>)
1151 return llvm::acc::Clause::ACCC_if;
1152if constexpr (std::is_same_v<A, parser::AccClause::IfPresent>)
1153 return llvm::acc::Clause::ACCC_if_present;
1154if constexpr (std::is_same_v<A, parser::AccClause::Independent>)
1155 return llvm::acc::Clause::ACCC_independent;
1156if constexpr (std::is_same_v<A, parser::AccClause::Link>)
1157 return llvm::acc::Clause::ACCC_link;
1158if constexpr (std::is_same_v<A, parser::AccClause::NoCreate>)
1159 return llvm::acc::Clause::ACCC_no_create;
1160if constexpr (std::is_same_v<A, parser::AccClause::Nohost>)
1161 return llvm::acc::Clause::ACCC_nohost;
1162if constexpr (std::is_same_v<A, parser::AccClause::NumGangs>)
1163 return llvm::acc::Clause::ACCC_num_gangs;
1164if constexpr (std::is_same_v<A, parser::AccClause::NumWorkers>)
1165 return llvm::acc::Clause::ACCC_num_workers;
1166if constexpr (std::is_same_v<A, parser::AccClause::Present>)
1167 return llvm::acc::Clause::ACCC_present;
1168if constexpr (std::is_same_v<A, parser::AccClause::Private>)
1169 return llvm::acc::Clause::ACCC_private;
1170if constexpr (std::is_same_v<A, parser::AccClause::Read>)
1171 return llvm::acc::Clause::ACCC_read;
1172if constexpr (std::is_same_v<A, parser::AccClause::Reduction>)
1173 return llvm::acc::Clause::ACCC_reduction;
1174if constexpr (std::is_same_v<A, parser::AccClause::Self>)
1175 return llvm::acc::Clause::ACCC_self;
1176if constexpr (std::is_same_v<A, parser::AccClause::Seq>)
1177 return llvm::acc::Clause::ACCC_seq;
1178if constexpr (std::is_same_v<A, parser::AccClause::Shortloop>)
1179 return llvm::acc::Clause::ACCC_shortloop;
1180if constexpr (std::is_same_v<A, parser::AccClause::Tile>)
1181 return llvm::acc::Clause::ACCC_tile;
1182if constexpr (std::is_same_v<A, parser::AccClause::Unknown>)
1183 return llvm::acc::Clause::ACCC_unknown;
1184if constexpr (std::is_same_v<A, parser::AccClause::UseDevice>)
1185 return llvm::acc::Clause::ACCC_use_device;
1186if constexpr (std::is_same_v<A, parser::AccClause::Vector>)
1187 return llvm::acc::Clause::ACCC_vector;
1188if constexpr (std::is_same_v<A, parser::AccClause::VectorLength>)
1189 return llvm::acc::Clause::ACCC_vector_length;
1190if constexpr (std::is_same_v<A, parser::AccClause::Wait>)
1191 return llvm::acc::Clause::ACCC_wait;
1192if constexpr (std::is_same_v<A, parser::AccClause::Worker>)
1193 return llvm::acc::Clause::ACCC_worker;
1194if constexpr (std::is_same_v<A, parser::AccClause::Write>)
1195 return llvm::acc::Clause::ACCC_write;
1196llvm_unreachable("Invalid OpenACC Parser clause");
1197
1198#endif // GEN_FLANG_CLAUSE_PARSER_KIND_MAP
1199
1200#ifdef GEN_FLANG_CLAUSES_PARSER
1201#undef GEN_FLANG_CLAUSES_PARSER
1202
1203TYPE_PARSER(
1204 "write" >> construct<AccClause>(construct<AccClause::Write>()) ||
1205 "worker" >> construct<AccClause>(construct<AccClause::Worker>(maybe(parenthesized("num :" >> scalarIntExpr || scalarIntExpr)))) ||
1206 "wait" >> construct<AccClause>(construct<AccClause::Wait>(maybe(parenthesized(Parser<AccWaitArgument>{})))) ||
1207 "vector_length" >> construct<AccClause>(construct<AccClause::VectorLength>(parenthesized(scalarIntExpr))) ||
1208 "vector" >> construct<AccClause>(construct<AccClause::Vector>(maybe(parenthesized("length :" >> scalarIntExpr || scalarIntExpr)))) ||
1209 "use_device" >> construct<AccClause>(construct<AccClause::UseDevice>(parenthesized(Parser<AccObjectList>{}))) ||
1210 "unknown" >> construct<AccClause>(construct<AccClause::Unknown>()) ||
1211 "tile" >> construct<AccClause>(construct<AccClause::Tile>(parenthesized(Parser<AccTileExprList>{}))) ||
1212 "shortloop" >> construct<AccClause>(construct<AccClause::Shortloop>()) ||
1213 "seq" >> construct<AccClause>(construct<AccClause::Seq>()) ||
1214 "self" >> construct<AccClause>(construct<AccClause::Self>(maybe(parenthesized(Parser<AccSelfClause>{})))) ||
1215 "reduction" >> construct<AccClause>(construct<AccClause::Reduction>(parenthesized(Parser<AccObjectListWithReduction>{}))) ||
1216 "read" >> construct<AccClause>(construct<AccClause::Read>()) ||
1217 "private" >> construct<AccClause>(construct<AccClause::Private>(parenthesized(Parser<AccObjectList>{}))) ||
1218 "present_or_create" >> construct<AccClause>(construct<AccClause::Create>(parenthesized(Parser<AccObjectListWithModifier>{}))) ||
1219 "present_or_copyout" >> construct<AccClause>(construct<AccClause::Copyout>(parenthesized(Parser<AccObjectListWithModifier>{}))) ||
1220 "present_or_copyin" >> construct<AccClause>(construct<AccClause::Copyin>(parenthesized(Parser<AccObjectListWithModifier>{}))) ||
1221 "present_or_copy" >> construct<AccClause>(construct<AccClause::Copy>(parenthesized(Parser<AccObjectList>{}))) ||
1222 "present" >> construct<AccClause>(construct<AccClause::Present>(parenthesized(Parser<AccObjectList>{}))) ||
1223 "pcreate" >> construct<AccClause>(construct<AccClause::Create>(parenthesized(Parser<AccObjectListWithModifier>{}))) ||
1224 "pcopyout" >> construct<AccClause>(construct<AccClause::Copyout>(parenthesized(Parser<AccObjectListWithModifier>{}))) ||
1225 "pcopyin" >> construct<AccClause>(construct<AccClause::Copyin>(parenthesized(Parser<AccObjectListWithModifier>{}))) ||
1226 "pcopy" >> construct<AccClause>(construct<AccClause::Copy>(parenthesized(Parser<AccObjectList>{}))) ||
1227 "num_workers" >> construct<AccClause>(construct<AccClause::NumWorkers>(parenthesized(scalarIntExpr))) ||
1228 "num_gangs" >> construct<AccClause>(construct<AccClause::NumGangs>(parenthesized(nonemptyList(scalarIntExpr)))) ||
1229 "nohost" >> construct<AccClause>(construct<AccClause::Nohost>()) ||
1230 "no_create" >> construct<AccClause>(construct<AccClause::NoCreate>(parenthesized(Parser<AccObjectList>{}))) ||
1231 "link" >> construct<AccClause>(construct<AccClause::Link>(parenthesized(Parser<AccObjectList>{}))) ||
1232 "independent" >> construct<AccClause>(construct<AccClause::Independent>()) ||
1233 "if_present" >> construct<AccClause>(construct<AccClause::IfPresent>()) ||
1234 "if" >> construct<AccClause>(construct<AccClause::If>(parenthesized(scalarExpr))) ||
1235 "host" >> construct<AccClause>(construct<AccClause::Host>(parenthesized(Parser<AccObjectList>{}))) ||
1236 "gang" >> construct<AccClause>(construct<AccClause::Gang>(maybe(parenthesized(Parser<AccGangArgList>{})))) ||
1237 "firstprivate" >> construct<AccClause>(construct<AccClause::Firstprivate>(parenthesized(Parser<AccObjectList>{}))) ||
1238 "finalize" >> construct<AccClause>(construct<AccClause::Finalize>()) ||
1239 "dtype" >> construct<AccClause>(construct<AccClause::DeviceType>(parenthesized(Parser<AccDeviceTypeExprList>{}))) ||
1240 "deviceptr" >> construct<AccClause>(construct<AccClause::Deviceptr>(parenthesized(Parser<AccObjectList>{}))) ||
1241 "device_type" >> construct<AccClause>(construct<AccClause::DeviceType>(parenthesized(Parser<AccDeviceTypeExprList>{}))) ||
1242 "device_resident" >> construct<AccClause>(construct<AccClause::DeviceResident>(parenthesized(Parser<AccObjectList>{}))) ||
1243 "device_num" >> construct<AccClause>(construct<AccClause::DeviceNum>(parenthesized(scalarIntExpr))) ||
1244 "device" >> construct<AccClause>(construct<AccClause::Device>(parenthesized(Parser<AccObjectList>{}))) ||
1245 "detach" >> construct<AccClause>(construct<AccClause::Detach>(parenthesized(Parser<AccObjectList>{}))) ||
1246 "delete" >> construct<AccClause>(construct<AccClause::Delete>(parenthesized(Parser<AccObjectList>{}))) ||
1247 "default_async" >> construct<AccClause>(construct<AccClause::DefaultAsync>(parenthesized(scalarIntExpr))) ||
1248 "default" >> construct<AccClause>(construct<AccClause::Default>(parenthesized(Parser<AccDefaultClause>{}))) ||
1249 "create" >> construct<AccClause>(construct<AccClause::Create>(parenthesized(Parser<AccObjectListWithModifier>{}))) ||
1250 "copyout" >> construct<AccClause>(construct<AccClause::Copyout>(parenthesized(Parser<AccObjectListWithModifier>{}))) ||
1251 "copyin" >> construct<AccClause>(construct<AccClause::Copyin>(parenthesized(Parser<AccObjectListWithModifier>{}))) ||
1252 "copy" >> construct<AccClause>(construct<AccClause::Copy>(parenthesized(Parser<AccObjectList>{}))) ||
1253 "collapse" >> construct<AccClause>(construct<AccClause::Collapse>(parenthesized(Parser<AccCollapseArg>{}))) ||
1254 "capture" >> construct<AccClause>(construct<AccClause::Capture>()) ||
1255 "bind" >> construct<AccClause>(construct<AccClause::Bind>(parenthesized(Parser<AccBindClause>{}))) ||
1256 "auto" >> construct<AccClause>(construct<AccClause::Auto>()) ||
1257 "attach" >> construct<AccClause>(construct<AccClause::Attach>(parenthesized(Parser<AccObjectList>{}))) ||
1258 "async" >> construct<AccClause>(construct<AccClause::Async>(maybe(parenthesized(scalarIntExpr))))
1259)
1260
1261#endif // GEN_FLANG_CLAUSES_PARSER
1262
1263#ifdef GEN_CLANG_DIRECTIVE_CLAUSE_SETS
1264#undef GEN_CLANG_DIRECTIVE_CLAUSE_SETS
1265
1266namespace clang::acc {
1267
1268// Sets for atomic
1269
1270static AccClauseSet allowedClauses_ACCD_atomic {
1271};
1272
1273static AccClauseSet allowedOnceClauses_ACCD_atomic {
1274 OpenACCClauseKind::If,
1275};
1276
1277static AccClauseSet allowedExclusiveClauses_ACCD_atomic {
1278};
1279
1280static AccClauseSet requiredClauses_ACCD_atomic {
1281};
1282// Sets for cache
1283
1284static AccClauseSet allowedClauses_ACCD_cache {
1285};
1286
1287static AccClauseSet allowedOnceClauses_ACCD_cache {
1288};
1289
1290static AccClauseSet allowedExclusiveClauses_ACCD_cache {
1291};
1292
1293static AccClauseSet requiredClauses_ACCD_cache {
1294};
1295// Sets for data
1296
1297static AccClauseSet allowedClauses_ACCD_data {
1298 OpenACCClauseKind::Async,
1299 OpenACCClauseKind::DeviceType,
1300 OpenACCClauseKind::Wait,
1301};
1302
1303static AccClauseSet allowedOnceClauses_ACCD_data {
1304 OpenACCClauseKind::If,
1305 OpenACCClauseKind::Default,
1306};
1307
1308static AccClauseSet allowedExclusiveClauses_ACCD_data {
1309};
1310
1311static AccClauseSet requiredClauses_ACCD_data {
1312 OpenACCClauseKind::Attach,
1313 OpenACCClauseKind::Copy,
1314 OpenACCClauseKind::CopyIn,
1315 OpenACCClauseKind::CopyOut,
1316 OpenACCClauseKind::Create,
1317 OpenACCClauseKind::Default,
1318 OpenACCClauseKind::DevicePtr,
1319 OpenACCClauseKind::NoCreate,
1320 OpenACCClauseKind::Present,
1321};
1322// Sets for declare
1323
1324static AccClauseSet allowedClauses_ACCD_declare {
1325 OpenACCClauseKind::Copy,
1326 OpenACCClauseKind::CopyIn,
1327 OpenACCClauseKind::CopyOut,
1328 OpenACCClauseKind::Create,
1329 OpenACCClauseKind::Present,
1330 OpenACCClauseKind::DevicePtr,
1331 OpenACCClauseKind::DeviceResident,
1332 OpenACCClauseKind::Link,
1333};
1334
1335static AccClauseSet allowedOnceClauses_ACCD_declare {
1336};
1337
1338static AccClauseSet allowedExclusiveClauses_ACCD_declare {
1339};
1340
1341static AccClauseSet requiredClauses_ACCD_declare {
1342};
1343// Sets for enter data
1344
1345static AccClauseSet allowedClauses_ACCD_enter_data {
1346 OpenACCClauseKind::Wait,
1347};
1348
1349static AccClauseSet allowedOnceClauses_ACCD_enter_data {
1350 OpenACCClauseKind::Async,
1351 OpenACCClauseKind::If,
1352};
1353
1354static AccClauseSet allowedExclusiveClauses_ACCD_enter_data {
1355};
1356
1357static AccClauseSet requiredClauses_ACCD_enter_data {
1358 OpenACCClauseKind::Attach,
1359 OpenACCClauseKind::Create,
1360 OpenACCClauseKind::CopyIn,
1361};
1362// Sets for exit data
1363
1364static AccClauseSet allowedClauses_ACCD_exit_data {
1365 OpenACCClauseKind::Finalize,
1366 OpenACCClauseKind::Wait,
1367};
1368
1369static AccClauseSet allowedOnceClauses_ACCD_exit_data {
1370 OpenACCClauseKind::Async,
1371 OpenACCClauseKind::If,
1372};
1373
1374static AccClauseSet allowedExclusiveClauses_ACCD_exit_data {
1375};
1376
1377static AccClauseSet requiredClauses_ACCD_exit_data {
1378 OpenACCClauseKind::CopyOut,
1379 OpenACCClauseKind::Delete,
1380 OpenACCClauseKind::Detach,
1381};
1382// Sets for host_data
1383
1384static AccClauseSet allowedClauses_ACCD_host_data {
1385 OpenACCClauseKind::IfPresent,
1386};
1387
1388static AccClauseSet allowedOnceClauses_ACCD_host_data {
1389 OpenACCClauseKind::If,
1390};
1391
1392static AccClauseSet allowedExclusiveClauses_ACCD_host_data {
1393};
1394
1395static AccClauseSet requiredClauses_ACCD_host_data {
1396 OpenACCClauseKind::UseDevice,
1397};
1398// Sets for init
1399
1400static AccClauseSet allowedClauses_ACCD_init {
1401 OpenACCClauseKind::DeviceType,
1402};
1403
1404static AccClauseSet allowedOnceClauses_ACCD_init {
1405 OpenACCClauseKind::DeviceNum,
1406 OpenACCClauseKind::If,
1407};
1408
1409static AccClauseSet allowedExclusiveClauses_ACCD_init {
1410};
1411
1412static AccClauseSet requiredClauses_ACCD_init {
1413};
1414// Sets for kernels
1415
1416static AccClauseSet allowedClauses_ACCD_kernels {
1417 OpenACCClauseKind::Async,
1418 OpenACCClauseKind::Attach,
1419 OpenACCClauseKind::Copy,
1420 OpenACCClauseKind::CopyIn,
1421 OpenACCClauseKind::CopyOut,
1422 OpenACCClauseKind::Create,
1423 OpenACCClauseKind::DeviceType,
1424 OpenACCClauseKind::NoCreate,
1425 OpenACCClauseKind::NumGangs,
1426 OpenACCClauseKind::NumWorkers,
1427 OpenACCClauseKind::Present,
1428 OpenACCClauseKind::DevicePtr,
1429 OpenACCClauseKind::VectorLength,
1430 OpenACCClauseKind::Wait,
1431};
1432
1433static AccClauseSet allowedOnceClauses_ACCD_kernels {
1434 OpenACCClauseKind::Default,
1435 OpenACCClauseKind::If,
1436 OpenACCClauseKind::Self,
1437};
1438
1439static AccClauseSet allowedExclusiveClauses_ACCD_kernels {
1440};
1441
1442static AccClauseSet requiredClauses_ACCD_kernels {
1443};
1444// Sets for kernels loop
1445
1446static AccClauseSet allowedClauses_ACCD_kernels_loop {
1447 OpenACCClauseKind::Async,
1448 OpenACCClauseKind::Attach,
1449 OpenACCClauseKind::Collapse,
1450 OpenACCClauseKind::Copy,
1451 OpenACCClauseKind::CopyIn,
1452 OpenACCClauseKind::CopyOut,
1453 OpenACCClauseKind::Create,
1454 OpenACCClauseKind::DevicePtr,
1455 OpenACCClauseKind::DeviceType,
1456 OpenACCClauseKind::Gang,
1457 OpenACCClauseKind::NoCreate,
1458 OpenACCClauseKind::NumGangs,
1459 OpenACCClauseKind::NumWorkers,
1460 OpenACCClauseKind::Present,
1461 OpenACCClauseKind::Private,
1462 OpenACCClauseKind::Reduction,
1463 OpenACCClauseKind::Shortloop,
1464 OpenACCClauseKind::Tile,
1465 OpenACCClauseKind::Vector,
1466 OpenACCClauseKind::VectorLength,
1467 OpenACCClauseKind::Wait,
1468 OpenACCClauseKind::Worker,
1469};
1470
1471static AccClauseSet allowedOnceClauses_ACCD_kernels_loop {
1472 OpenACCClauseKind::Default,
1473 OpenACCClauseKind::If,
1474 OpenACCClauseKind::Self,
1475};
1476
1477static AccClauseSet allowedExclusiveClauses_ACCD_kernels_loop {
1478 OpenACCClauseKind::Auto,
1479 OpenACCClauseKind::Independent,
1480 OpenACCClauseKind::Seq,
1481};
1482
1483static AccClauseSet requiredClauses_ACCD_kernels_loop {
1484};
1485// Sets for loop
1486
1487static AccClauseSet allowedClauses_ACCD_loop {
1488 OpenACCClauseKind::DeviceType,
1489 OpenACCClauseKind::Private,
1490 OpenACCClauseKind::Reduction,
1491 OpenACCClauseKind::Collapse,
1492 OpenACCClauseKind::Gang,
1493 OpenACCClauseKind::Shortloop,
1494 OpenACCClauseKind::Tile,
1495 OpenACCClauseKind::Vector,
1496 OpenACCClauseKind::Worker,
1497};
1498
1499static AccClauseSet allowedOnceClauses_ACCD_loop {
1500};
1501
1502static AccClauseSet allowedExclusiveClauses_ACCD_loop {
1503 OpenACCClauseKind::Auto,
1504 OpenACCClauseKind::Independent,
1505 OpenACCClauseKind::Seq,
1506};
1507
1508static AccClauseSet requiredClauses_ACCD_loop {
1509};
1510// Sets for parallel
1511
1512static AccClauseSet allowedClauses_ACCD_parallel {
1513 OpenACCClauseKind::Attach,
1514 OpenACCClauseKind::Async,
1515 OpenACCClauseKind::Copy,
1516 OpenACCClauseKind::CopyIn,
1517 OpenACCClauseKind::CopyOut,
1518 OpenACCClauseKind::Create,
1519 OpenACCClauseKind::DevicePtr,
1520 OpenACCClauseKind::DeviceType,
1521 OpenACCClauseKind::NoCreate,
1522 OpenACCClauseKind::NumGangs,
1523 OpenACCClauseKind::NumWorkers,
1524 OpenACCClauseKind::Present,
1525 OpenACCClauseKind::Private,
1526 OpenACCClauseKind::FirstPrivate,
1527 OpenACCClauseKind::Reduction,
1528 OpenACCClauseKind::Wait,
1529 OpenACCClauseKind::VectorLength,
1530};
1531
1532static AccClauseSet allowedOnceClauses_ACCD_parallel {
1533 OpenACCClauseKind::Default,
1534 OpenACCClauseKind::If,
1535 OpenACCClauseKind::Self,
1536};
1537
1538static AccClauseSet allowedExclusiveClauses_ACCD_parallel {
1539};
1540
1541static AccClauseSet requiredClauses_ACCD_parallel {
1542};
1543// Sets for parallel loop
1544
1545static AccClauseSet allowedClauses_ACCD_parallel_loop {
1546 OpenACCClauseKind::Async,
1547 OpenACCClauseKind::Attach,
1548 OpenACCClauseKind::Collapse,
1549 OpenACCClauseKind::Copy,
1550 OpenACCClauseKind::CopyIn,
1551 OpenACCClauseKind::CopyOut,
1552 OpenACCClauseKind::Create,
1553 OpenACCClauseKind::DevicePtr,
1554 OpenACCClauseKind::DeviceType,
1555 OpenACCClauseKind::FirstPrivate,
1556 OpenACCClauseKind::Gang,
1557 OpenACCClauseKind::NoCreate,
1558 OpenACCClauseKind::NumGangs,
1559 OpenACCClauseKind::NumWorkers,
1560 OpenACCClauseKind::Present,
1561 OpenACCClauseKind::Private,
1562 OpenACCClauseKind::Reduction,
1563 OpenACCClauseKind::Shortloop,
1564 OpenACCClauseKind::Tile,
1565 OpenACCClauseKind::Vector,
1566 OpenACCClauseKind::VectorLength,
1567 OpenACCClauseKind::Wait,
1568 OpenACCClauseKind::Worker,
1569};
1570
1571static AccClauseSet allowedOnceClauses_ACCD_parallel_loop {
1572 OpenACCClauseKind::Default,
1573 OpenACCClauseKind::If,
1574 OpenACCClauseKind::Self,
1575};
1576
1577static AccClauseSet allowedExclusiveClauses_ACCD_parallel_loop {
1578 OpenACCClauseKind::Auto,
1579 OpenACCClauseKind::Independent,
1580 OpenACCClauseKind::Seq,
1581};
1582
1583static AccClauseSet requiredClauses_ACCD_parallel_loop {
1584};
1585// Sets for routine
1586
1587static AccClauseSet allowedClauses_ACCD_routine {
1588 OpenACCClauseKind::Bind,
1589 OpenACCClauseKind::DeviceType,
1590 OpenACCClauseKind::Gang,
1591 OpenACCClauseKind::Seq,
1592 OpenACCClauseKind::Vector,
1593 OpenACCClauseKind::Worker,
1594};
1595
1596static AccClauseSet allowedOnceClauses_ACCD_routine {
1597 OpenACCClauseKind::NoHost,
1598};
1599
1600static AccClauseSet allowedExclusiveClauses_ACCD_routine {
1601};
1602
1603static AccClauseSet requiredClauses_ACCD_routine {
1604};
1605// Sets for serial
1606
1607static AccClauseSet allowedClauses_ACCD_serial {
1608 OpenACCClauseKind::Async,
1609 OpenACCClauseKind::Attach,
1610 OpenACCClauseKind::Copy,
1611 OpenACCClauseKind::CopyIn,
1612 OpenACCClauseKind::CopyOut,
1613 OpenACCClauseKind::Create,
1614 OpenACCClauseKind::DevicePtr,
1615 OpenACCClauseKind::DeviceType,
1616 OpenACCClauseKind::NoCreate,
1617 OpenACCClauseKind::Present,
1618 OpenACCClauseKind::Private,
1619 OpenACCClauseKind::FirstPrivate,
1620 OpenACCClauseKind::Reduction,
1621 OpenACCClauseKind::Wait,
1622};
1623
1624static AccClauseSet allowedOnceClauses_ACCD_serial {
1625 OpenACCClauseKind::Default,
1626 OpenACCClauseKind::If,
1627 OpenACCClauseKind::Self,
1628};
1629
1630static AccClauseSet allowedExclusiveClauses_ACCD_serial {
1631};
1632
1633static AccClauseSet requiredClauses_ACCD_serial {
1634};
1635// Sets for serial loop
1636
1637static AccClauseSet allowedClauses_ACCD_serial_loop {
1638 OpenACCClauseKind::Async,
1639 OpenACCClauseKind::Attach,
1640 OpenACCClauseKind::Collapse,
1641 OpenACCClauseKind::Copy,
1642 OpenACCClauseKind::CopyIn,
1643 OpenACCClauseKind::CopyOut,
1644 OpenACCClauseKind::Create,
1645 OpenACCClauseKind::DevicePtr,
1646 OpenACCClauseKind::DeviceType,
1647 OpenACCClauseKind::FirstPrivate,
1648 OpenACCClauseKind::Gang,
1649 OpenACCClauseKind::NoCreate,
1650 OpenACCClauseKind::Present,
1651 OpenACCClauseKind::Private,
1652 OpenACCClauseKind::Reduction,
1653 OpenACCClauseKind::Shortloop,
1654 OpenACCClauseKind::Tile,
1655 OpenACCClauseKind::Vector,
1656 OpenACCClauseKind::Wait,
1657 OpenACCClauseKind::Worker,
1658};
1659
1660static AccClauseSet allowedOnceClauses_ACCD_serial_loop {
1661 OpenACCClauseKind::Default,
1662 OpenACCClauseKind::If,
1663 OpenACCClauseKind::Self,
1664};
1665
1666static AccClauseSet allowedExclusiveClauses_ACCD_serial_loop {
1667 OpenACCClauseKind::Auto,
1668 OpenACCClauseKind::Independent,
1669 OpenACCClauseKind::Seq,
1670};
1671
1672static AccClauseSet requiredClauses_ACCD_serial_loop {
1673};
1674// Sets for set
1675
1676static AccClauseSet allowedClauses_ACCD_set {
1677};
1678
1679static AccClauseSet allowedOnceClauses_ACCD_set {
1680 OpenACCClauseKind::DefaultAsync,
1681 OpenACCClauseKind::DeviceNum,
1682 OpenACCClauseKind::DeviceType,
1683 OpenACCClauseKind::If,
1684};
1685
1686static AccClauseSet allowedExclusiveClauses_ACCD_set {
1687};
1688
1689static AccClauseSet requiredClauses_ACCD_set {
1690 OpenACCClauseKind::DefaultAsync,
1691 OpenACCClauseKind::DeviceNum,
1692 OpenACCClauseKind::DeviceType,
1693};
1694// Sets for shutdown
1695
1696static AccClauseSet allowedClauses_ACCD_shutdown {
1697 OpenACCClauseKind::DeviceType,
1698};
1699
1700static AccClauseSet allowedOnceClauses_ACCD_shutdown {
1701 OpenACCClauseKind::DeviceNum,
1702 OpenACCClauseKind::If,
1703};
1704
1705static AccClauseSet allowedExclusiveClauses_ACCD_shutdown {
1706};
1707
1708static AccClauseSet requiredClauses_ACCD_shutdown {
1709};
1710// Sets for unknown
1711
1712static AccClauseSet allowedClauses_ACCD_unknown {
1713};
1714
1715static AccClauseSet allowedOnceClauses_ACCD_unknown {
1716};
1717
1718static AccClauseSet allowedExclusiveClauses_ACCD_unknown {
1719};
1720
1721static AccClauseSet requiredClauses_ACCD_unknown {
1722};
1723// Sets for update
1724
1725static AccClauseSet allowedClauses_ACCD_update {
1726 OpenACCClauseKind::DeviceType,
1727 OpenACCClauseKind::IfPresent,
1728 OpenACCClauseKind::Wait,
1729};
1730
1731static AccClauseSet allowedOnceClauses_ACCD_update {
1732 OpenACCClauseKind::Async,
1733 OpenACCClauseKind::If,
1734};
1735
1736static AccClauseSet allowedExclusiveClauses_ACCD_update {
1737};
1738
1739static AccClauseSet requiredClauses_ACCD_update {
1740 OpenACCClauseKind::Device,
1741 OpenACCClauseKind::Host,
1742 OpenACCClauseKind::Self,
1743};
1744// Sets for wait
1745
1746static AccClauseSet allowedClauses_ACCD_wait {
1747};
1748
1749static AccClauseSet allowedOnceClauses_ACCD_wait {
1750 OpenACCClauseKind::Async,
1751 OpenACCClauseKind::If,
1752};
1753
1754static AccClauseSet allowedExclusiveClauses_ACCD_wait {
1755};
1756
1757static AccClauseSet requiredClauses_ACCD_wait {
1758};
1759
1760} // namespace clang::acc
1761
1762#endif // GEN_CLANG_DIRECTIVE_CLAUSE_SETS
1763
1764#ifdef GEN_CLANG_DIRECTIVE_CLAUSE_MAP
1765#undef GEN_CLANG_DIRECTIVE_CLAUSE_MAP
1766
1767{
1768 {clang::OpenACCDirectiveKind::Atomic,
1769 {
1770 clang::acc::allowedClauses_ACCD_atomic,
1771 clang::acc::allowedOnceClauses_ACCD_atomic,
1772 clang::acc::allowedExclusiveClauses_ACCD_atomic,
1773 clang::acc::requiredClauses_ACCD_atomic,
1774 }
1775 },
1776 {clang::OpenACCDirectiveKind::Cache,
1777 {
1778 clang::acc::allowedClauses_ACCD_cache,
1779 clang::acc::allowedOnceClauses_ACCD_cache,
1780 clang::acc::allowedExclusiveClauses_ACCD_cache,
1781 clang::acc::requiredClauses_ACCD_cache,
1782 }
1783 },
1784 {clang::OpenACCDirectiveKind::Data,
1785 {
1786 clang::acc::allowedClauses_ACCD_data,
1787 clang::acc::allowedOnceClauses_ACCD_data,
1788 clang::acc::allowedExclusiveClauses_ACCD_data,
1789 clang::acc::requiredClauses_ACCD_data,
1790 }
1791 },
1792 {clang::OpenACCDirectiveKind::Declare,
1793 {
1794 clang::acc::allowedClauses_ACCD_declare,
1795 clang::acc::allowedOnceClauses_ACCD_declare,
1796 clang::acc::allowedExclusiveClauses_ACCD_declare,
1797 clang::acc::requiredClauses_ACCD_declare,
1798 }
1799 },
1800 {clang::OpenACCDirectiveKind::EnterData,
1801 {
1802 clang::acc::allowedClauses_ACCD_enter_data,
1803 clang::acc::allowedOnceClauses_ACCD_enter_data,
1804 clang::acc::allowedExclusiveClauses_ACCD_enter_data,
1805 clang::acc::requiredClauses_ACCD_enter_data,
1806 }
1807 },
1808 {clang::OpenACCDirectiveKind::ExitData,
1809 {
1810 clang::acc::allowedClauses_ACCD_exit_data,
1811 clang::acc::allowedOnceClauses_ACCD_exit_data,
1812 clang::acc::allowedExclusiveClauses_ACCD_exit_data,
1813 clang::acc::requiredClauses_ACCD_exit_data,
1814 }
1815 },
1816 {clang::OpenACCDirectiveKind::HostData,
1817 {
1818 clang::acc::allowedClauses_ACCD_host_data,
1819 clang::acc::allowedOnceClauses_ACCD_host_data,
1820 clang::acc::allowedExclusiveClauses_ACCD_host_data,
1821 clang::acc::requiredClauses_ACCD_host_data,
1822 }
1823 },
1824 {clang::OpenACCDirectiveKind::Init,
1825 {
1826 clang::acc::allowedClauses_ACCD_init,
1827 clang::acc::allowedOnceClauses_ACCD_init,
1828 clang::acc::allowedExclusiveClauses_ACCD_init,
1829 clang::acc::requiredClauses_ACCD_init,
1830 }
1831 },
1832 {clang::OpenACCDirectiveKind::Kernels,
1833 {
1834 clang::acc::allowedClauses_ACCD_kernels,
1835 clang::acc::allowedOnceClauses_ACCD_kernels,
1836 clang::acc::allowedExclusiveClauses_ACCD_kernels,
1837 clang::acc::requiredClauses_ACCD_kernels,
1838 }
1839 },
1840 {clang::OpenACCDirectiveKind::KernelsLoop,
1841 {
1842 clang::acc::allowedClauses_ACCD_kernels_loop,
1843 clang::acc::allowedOnceClauses_ACCD_kernels_loop,
1844 clang::acc::allowedExclusiveClauses_ACCD_kernels_loop,
1845 clang::acc::requiredClauses_ACCD_kernels_loop,
1846 }
1847 },
1848 {clang::OpenACCDirectiveKind::Loop,
1849 {
1850 clang::acc::allowedClauses_ACCD_loop,
1851 clang::acc::allowedOnceClauses_ACCD_loop,
1852 clang::acc::allowedExclusiveClauses_ACCD_loop,
1853 clang::acc::requiredClauses_ACCD_loop,
1854 }
1855 },
1856 {clang::OpenACCDirectiveKind::Parallel,
1857 {
1858 clang::acc::allowedClauses_ACCD_parallel,
1859 clang::acc::allowedOnceClauses_ACCD_parallel,
1860 clang::acc::allowedExclusiveClauses_ACCD_parallel,
1861 clang::acc::requiredClauses_ACCD_parallel,
1862 }
1863 },
1864 {clang::OpenACCDirectiveKind::ParallelLoop,
1865 {
1866 clang::acc::allowedClauses_ACCD_parallel_loop,
1867 clang::acc::allowedOnceClauses_ACCD_parallel_loop,
1868 clang::acc::allowedExclusiveClauses_ACCD_parallel_loop,
1869 clang::acc::requiredClauses_ACCD_parallel_loop,
1870 }
1871 },
1872 {clang::OpenACCDirectiveKind::Routine,
1873 {
1874 clang::acc::allowedClauses_ACCD_routine,
1875 clang::acc::allowedOnceClauses_ACCD_routine,
1876 clang::acc::allowedExclusiveClauses_ACCD_routine,
1877 clang::acc::requiredClauses_ACCD_routine,
1878 }
1879 },
1880 {clang::OpenACCDirectiveKind::Serial,
1881 {
1882 clang::acc::allowedClauses_ACCD_serial,
1883 clang::acc::allowedOnceClauses_ACCD_serial,
1884 clang::acc::allowedExclusiveClauses_ACCD_serial,
1885 clang::acc::requiredClauses_ACCD_serial,
1886 }
1887 },
1888 {clang::OpenACCDirectiveKind::SerialLoop,
1889 {
1890 clang::acc::allowedClauses_ACCD_serial_loop,
1891 clang::acc::allowedOnceClauses_ACCD_serial_loop,
1892 clang::acc::allowedExclusiveClauses_ACCD_serial_loop,
1893 clang::acc::requiredClauses_ACCD_serial_loop,
1894 }
1895 },
1896 {clang::OpenACCDirectiveKind::Set,
1897 {
1898 clang::acc::allowedClauses_ACCD_set,
1899 clang::acc::allowedOnceClauses_ACCD_set,
1900 clang::acc::allowedExclusiveClauses_ACCD_set,
1901 clang::acc::requiredClauses_ACCD_set,
1902 }
1903 },
1904 {clang::OpenACCDirectiveKind::Shutdown,
1905 {
1906 clang::acc::allowedClauses_ACCD_shutdown,
1907 clang::acc::allowedOnceClauses_ACCD_shutdown,
1908 clang::acc::allowedExclusiveClauses_ACCD_shutdown,
1909 clang::acc::requiredClauses_ACCD_shutdown,
1910 }
1911 },
1912 {clang::OpenACCDirectiveKind::Invalid,
1913 {
1914 clang::acc::allowedClauses_ACCD_unknown,
1915 clang::acc::allowedOnceClauses_ACCD_unknown,
1916 clang::acc::allowedExclusiveClauses_ACCD_unknown,
1917 clang::acc::requiredClauses_ACCD_unknown,
1918 }
1919 },
1920 {clang::OpenACCDirectiveKind::Update,
1921 {
1922 clang::acc::allowedClauses_ACCD_update,
1923 clang::acc::allowedOnceClauses_ACCD_update,
1924 clang::acc::allowedExclusiveClauses_ACCD_update,
1925 clang::acc::requiredClauses_ACCD_update,
1926 }
1927 },
1928 {clang::OpenACCDirectiveKind::Wait,
1929 {
1930 clang::acc::allowedClauses_ACCD_wait,
1931 clang::acc::allowedOnceClauses_ACCD_wait,
1932 clang::acc::allowedExclusiveClauses_ACCD_wait,
1933 clang::acc::requiredClauses_ACCD_wait,
1934 }
1935 },
1936}
1937
1938#endif // GEN_CLANG_DIRECTIVE_CLAUSE_MAP
1939
1940#ifdef GEN_CLANG_CLAUSE_CLASS
1941#undef GEN_CLANG_CLAUSE_CLASS
1942
1943#ifndef CLAUSE
1944#define CLAUSE(Enum, Str, Implicit)
1945#endif
1946#ifndef CLAUSE_CLASS
1947#define CLAUSE_CLASS(Enum, Str, Class)
1948#endif
1949#ifndef CLAUSE_NO_CLASS
1950#define CLAUSE_NO_CLASS(Enum, Str)
1951#endif
1952
1953#define __CLAUSE(Name, Class) \
1954 CLAUSE(ACCC_##Name, #Name, /* Implicit */ false) \
1955 CLAUSE_CLASS(ACCC_##Name, #Name, Class)
1956#define __CLAUSE_NO_CLASS(Name) \
1957 CLAUSE(ACCC_##Name, #Name, /* Implicit */ false) \
1958 CLAUSE_NO_CLASS(ACCC_##Name, #Name)
1959#define __IMPLICIT_CLAUSE_CLASS(Name, Str, Class) \
1960 CLAUSE(ACCC_##Name, Str, /* Implicit */ true) \
1961 CLAUSE_CLASS(ACCC_##Name, Str, Class)
1962#define __IMPLICIT_CLAUSE_NO_CLASS(Name, Str) \
1963 CLAUSE(ACCC_##Name, Str, /* Implicit */ true) \
1964 CLAUSE_NO_CLASS(ACCC_##Name, Str)
1965
1966__CLAUSE_NO_CLASS(async)
1967__CLAUSE_NO_CLASS(attach)
1968__CLAUSE_NO_CLASS(auto)
1969__CLAUSE_NO_CLASS(bind)
1970__CLAUSE_NO_CLASS(capture)
1971__CLAUSE_NO_CLASS(collapse)
1972__CLAUSE_NO_CLASS(copy)
1973__CLAUSE_NO_CLASS(copyin)
1974__CLAUSE_NO_CLASS(copyout)
1975__CLAUSE_NO_CLASS(create)
1976__CLAUSE_NO_CLASS(default)
1977__CLAUSE_NO_CLASS(default_async)
1978__CLAUSE_NO_CLASS(delete)
1979__CLAUSE_NO_CLASS(detach)
1980__CLAUSE_NO_CLASS(device)
1981__CLAUSE_NO_CLASS(device_num)
1982__CLAUSE_NO_CLASS(deviceptr)
1983__CLAUSE_NO_CLASS(device_resident)
1984__CLAUSE_NO_CLASS(device_type)
1985__CLAUSE_NO_CLASS(finalize)
1986__CLAUSE_NO_CLASS(firstprivate)
1987__CLAUSE_NO_CLASS(gang)
1988__CLAUSE_NO_CLASS(host)
1989__CLAUSE_NO_CLASS(if)
1990__CLAUSE_NO_CLASS(if_present)
1991__CLAUSE_NO_CLASS(independent)
1992__CLAUSE_NO_CLASS(link)
1993__CLAUSE_NO_CLASS(no_create)
1994__CLAUSE_NO_CLASS(nohost)
1995__CLAUSE_NO_CLASS(num_gangs)
1996__CLAUSE_NO_CLASS(num_workers)
1997__CLAUSE_NO_CLASS(present)
1998__CLAUSE_NO_CLASS(private)
1999__CLAUSE_NO_CLASS(read)
2000__CLAUSE_NO_CLASS(reduction)
2001__CLAUSE_NO_CLASS(self)
2002__CLAUSE_NO_CLASS(seq)
2003__CLAUSE_NO_CLASS(shortloop)
2004__CLAUSE_NO_CLASS(tile)
2005__CLAUSE_NO_CLASS(unknown)
2006__CLAUSE_NO_CLASS(use_device)
2007__CLAUSE_NO_CLASS(vector)
2008__CLAUSE_NO_CLASS(vector_length)
2009__CLAUSE_NO_CLASS(wait)
2010__CLAUSE_NO_CLASS(worker)
2011__CLAUSE_NO_CLASS(write)
2012
2013#undef __IMPLICIT_CLAUSE_NO_CLASS
2014#undef __IMPLICIT_CLAUSE_CLASS
2015#undef __CLAUSE_NO_CLASS
2016#undef __CLAUSE
2017#undef CLAUSE_NO_CLASS
2018#undef CLAUSE_CLASS
2019#undef CLAUSE
2020
2021#endif // GEN_CLANG_CLAUSE_CLASS
2022
2023#ifdef GEN_DIRECTIVES_IMPL
2024#undef GEN_DIRECTIVES_IMPL
2025
2026#include "llvm/Frontend/Directive/Spelling.h"
2027#include "llvm/Frontend/Directive/Version.h"
2028#include "llvm/Support/ErrorHandling.h"
2029#include <utility>
2030
2031std::pair<llvm::acc::Directive, llvm::directive::VersionRange> llvm::acc::getOpenACCDirectiveKindAndVersions(llvm::StringRef Str) {
2032 directive::VersionRange All; // Default-initialized to "all versions"
2033 return StringSwitch<std::pair<Directive, directive::VersionRange>>(Str)
2034 .Case("atomic", {ACCD_atomic, All})
2035 .Case("cache", {ACCD_cache, All})
2036 .Case("data", {ACCD_data, All})
2037 .Case("declare", {ACCD_declare, All})
2038 .Case("enter data", {ACCD_enter_data, All})
2039 .Case("exit data", {ACCD_exit_data, All})
2040 .Case("host_data", {ACCD_host_data, All})
2041 .Case("init", {ACCD_init, All})
2042 .Case("kernels", {ACCD_kernels, All})
2043 .Case("kernels loop", {ACCD_kernels_loop, All})
2044 .Case("loop", {ACCD_loop, All})
2045 .Case("parallel", {ACCD_parallel, All})
2046 .Case("parallel loop", {ACCD_parallel_loop, All})
2047 .Case("routine", {ACCD_routine, All})
2048 .Case("serial", {ACCD_serial, All})
2049 .Case("serial loop", {ACCD_serial_loop, All})
2050 .Case("set", {ACCD_set, All})
2051 .Case("shutdown", {ACCD_shutdown, All})
2052 .Case("unknown", {ACCD_unknown, All})
2053 .Case("update", {ACCD_update, All})
2054 .Case("wait", {ACCD_wait, All})
2055 .Default({ACCD_unknown, All});
2056}
2057
2058llvm::StringRef llvm::acc::getOpenACCDirectiveName(llvm::acc::Directive Kind, llvm::directive::Version V) {
2059 switch (Kind) {
2060 case ACCD_atomic:
2061 return "atomic";
2062 case ACCD_cache:
2063 return "cache";
2064 case ACCD_data:
2065 return "data";
2066 case ACCD_declare:
2067 return "declare";
2068 case ACCD_enter_data:
2069 return "enter data";
2070 case ACCD_exit_data:
2071 return "exit data";
2072 case ACCD_host_data:
2073 return "host_data";
2074 case ACCD_init:
2075 return "init";
2076 case ACCD_kernels:
2077 return "kernels";
2078 case ACCD_kernels_loop:
2079 return "kernels loop";
2080 case ACCD_loop:
2081 return "loop";
2082 case ACCD_parallel:
2083 return "parallel";
2084 case ACCD_parallel_loop:
2085 return "parallel loop";
2086 case ACCD_routine:
2087 return "routine";
2088 case ACCD_serial:
2089 return "serial";
2090 case ACCD_serial_loop:
2091 return "serial loop";
2092 case ACCD_set:
2093 return "set";
2094 case ACCD_shutdown:
2095 return "shutdown";
2096 case ACCD_unknown:
2097 return "unknown";
2098 case ACCD_update:
2099 return "update";
2100 case ACCD_wait:
2101 return "wait";
2102 }
2103 llvm_unreachable("Invalid OpenACC Directive kind");
2104}
2105
2106std::pair<llvm::acc::Clause, llvm::directive::VersionRange> llvm::acc::getOpenACCClauseKindAndVersions(llvm::StringRef Str) {
2107 directive::VersionRange All; // Default-initialized to "all versions"
2108 return StringSwitch<std::pair<Clause, directive::VersionRange>>(Str)
2109 .Case("async", {ACCC_async, All})
2110 .Case("attach", {ACCC_attach, All})
2111 .Case("auto", {ACCC_auto, All})
2112 .Case("bind", {ACCC_bind, All})
2113 .Case("capture", {ACCC_capture, All})
2114 .Case("collapse", {ACCC_collapse, All})
2115 .Case("copy", {ACCC_copy, All})
2116 .Case("present_or_copy", {ACCC_copy, All})
2117 .Case("pcopy", {ACCC_copy, All})
2118 .Case("copyin", {ACCC_copyin, All})
2119 .Case("present_or_copyin", {ACCC_copyin, All})
2120 .Case("pcopyin", {ACCC_copyin, All})
2121 .Case("copyout", {ACCC_copyout, All})
2122 .Case("present_or_copyout", {ACCC_copyout, All})
2123 .Case("pcopyout", {ACCC_copyout, All})
2124 .Case("create", {ACCC_create, All})
2125 .Case("present_or_create", {ACCC_create, All})
2126 .Case("pcreate", {ACCC_create, All})
2127 .Case("default", {ACCC_default, All})
2128 .Case("default_async", {ACCC_default_async, All})
2129 .Case("delete", {ACCC_delete, All})
2130 .Case("detach", {ACCC_detach, All})
2131 .Case("device", {ACCC_device, All})
2132 .Case("device_num", {ACCC_device_num, All})
2133 .Case("deviceptr", {ACCC_deviceptr, All})
2134 .Case("device_resident", {ACCC_device_resident, All})
2135 .Case("device_type", {ACCC_device_type, All})
2136 .Case("dtype", {ACCC_device_type, All})
2137 .Case("finalize", {ACCC_finalize, All})
2138 .Case("firstprivate", {ACCC_firstprivate, All})
2139 .Case("gang", {ACCC_gang, All})
2140 .Case("host", {ACCC_host, All})
2141 .Case("if", {ACCC_if, All})
2142 .Case("if_present", {ACCC_if_present, All})
2143 .Case("independent", {ACCC_independent, All})
2144 .Case("link", {ACCC_link, All})
2145 .Case("no_create", {ACCC_no_create, All})
2146 .Case("nohost", {ACCC_nohost, All})
2147 .Case("num_gangs", {ACCC_num_gangs, All})
2148 .Case("num_workers", {ACCC_num_workers, All})
2149 .Case("present", {ACCC_present, All})
2150 .Case("private", {ACCC_private, All})
2151 .Case("read", {ACCC_read, All})
2152 .Case("reduction", {ACCC_reduction, All})
2153 .Case("self", {ACCC_self, All})
2154 .Case("seq", {ACCC_seq, All})
2155 .Case("shortloop", {ACCC_shortloop, All})
2156 .Case("tile", {ACCC_tile, All})
2157 .Case("unknown", {ACCC_unknown, All})
2158 .Case("use_device", {ACCC_use_device, All})
2159 .Case("vector", {ACCC_vector, All})
2160 .Case("vector_length", {ACCC_vector_length, All})
2161 .Case("wait", {ACCC_wait, All})
2162 .Case("worker", {ACCC_worker, All})
2163 .Case("write", {ACCC_write, All})
2164 .Default({ACCC_unknown, All});
2165}
2166
2167llvm::StringRef llvm::acc::getOpenACCClauseName(llvm::acc::Clause Kind, llvm::directive::Version V) {
2168 switch (Kind) {
2169 case ACCC_async:
2170 return "async";
2171 case ACCC_attach:
2172 return "attach";
2173 case ACCC_auto:
2174 return "auto";
2175 case ACCC_bind:
2176 return "bind";
2177 case ACCC_capture:
2178 return "capture";
2179 case ACCC_collapse:
2180 return "collapse";
2181 case ACCC_copy: {
2182 static constexpr llvm::directive::Spelling ACCC_copy_spellings[] = {
2183 {"copy", {directive::Version(0), directive::Version(2147483647)}},
2184 {"present_or_copy", {directive::Version(0), directive::Version(2147483647)}},
2185 {"pcopy", {directive::Version(0), directive::Version(2147483647)}},
2186 };
2187 return llvm::directive::FindName(ACCC_copy_spellings, V);
2188 }
2189 case ACCC_copyin: {
2190 static constexpr llvm::directive::Spelling ACCC_copyin_spellings[] = {
2191 {"copyin", {directive::Version(0), directive::Version(2147483647)}},
2192 {"present_or_copyin", {directive::Version(0), directive::Version(2147483647)}},
2193 {"pcopyin", {directive::Version(0), directive::Version(2147483647)}},
2194 };
2195 return llvm::directive::FindName(ACCC_copyin_spellings, V);
2196 }
2197 case ACCC_copyout: {
2198 static constexpr llvm::directive::Spelling ACCC_copyout_spellings[] = {
2199 {"copyout", {directive::Version(0), directive::Version(2147483647)}},
2200 {"present_or_copyout", {directive::Version(0), directive::Version(2147483647)}},
2201 {"pcopyout", {directive::Version(0), directive::Version(2147483647)}},
2202 };
2203 return llvm::directive::FindName(ACCC_copyout_spellings, V);
2204 }
2205 case ACCC_create: {
2206 static constexpr llvm::directive::Spelling ACCC_create_spellings[] = {
2207 {"create", {directive::Version(0), directive::Version(2147483647)}},
2208 {"present_or_create", {directive::Version(0), directive::Version(2147483647)}},
2209 {"pcreate", {directive::Version(0), directive::Version(2147483647)}},
2210 };
2211 return llvm::directive::FindName(ACCC_create_spellings, V);
2212 }
2213 case ACCC_default:
2214 return "default";
2215 case ACCC_default_async:
2216 return "default_async";
2217 case ACCC_delete:
2218 return "delete";
2219 case ACCC_detach:
2220 return "detach";
2221 case ACCC_device:
2222 return "device";
2223 case ACCC_device_num:
2224 return "device_num";
2225 case ACCC_deviceptr:
2226 return "deviceptr";
2227 case ACCC_device_resident:
2228 return "device_resident";
2229 case ACCC_device_type: {
2230 static constexpr llvm::directive::Spelling ACCC_device_type_spellings[] = {
2231 {"device_type", {directive::Version(0), directive::Version(2147483647)}},
2232 {"dtype", {directive::Version(0), directive::Version(2147483647)}},
2233 };
2234 return llvm::directive::FindName(ACCC_device_type_spellings, V);
2235 }
2236 case ACCC_finalize:
2237 return "finalize";
2238 case ACCC_firstprivate:
2239 return "firstprivate";
2240 case ACCC_gang:
2241 return "gang";
2242 case ACCC_host:
2243 return "host";
2244 case ACCC_if:
2245 return "if";
2246 case ACCC_if_present:
2247 return "if_present";
2248 case ACCC_independent:
2249 return "independent";
2250 case ACCC_link:
2251 return "link";
2252 case ACCC_no_create:
2253 return "no_create";
2254 case ACCC_nohost:
2255 return "nohost";
2256 case ACCC_num_gangs:
2257 return "num_gangs";
2258 case ACCC_num_workers:
2259 return "num_workers";
2260 case ACCC_present:
2261 return "present";
2262 case ACCC_private:
2263 return "private";
2264 case ACCC_read:
2265 return "read";
2266 case ACCC_reduction:
2267 return "reduction";
2268 case ACCC_self:
2269 return "self";
2270 case ACCC_seq:
2271 return "seq";
2272 case ACCC_shortloop:
2273 return "shortloop";
2274 case ACCC_tile:
2275 return "tile";
2276 case ACCC_unknown:
2277 return "unknown";
2278 case ACCC_use_device:
2279 return "use_device";
2280 case ACCC_vector:
2281 return "vector";
2282 case ACCC_vector_length:
2283 return "vector_length";
2284 case ACCC_wait:
2285 return "wait";
2286 case ACCC_worker:
2287 return "worker";
2288 case ACCC_write:
2289 return "write";
2290 }
2291 llvm_unreachable("Invalid OpenACC Clause kind");
2292}
2293
2294llvm::acc::DefaultValue llvm::acc::getDefaultValue(llvm::StringRef Str) {
2295 return StringSwitch<DefaultValue>(Str)
2296 .Case("present",ACC_Default_present)
2297 .Case("none",ACC_Default_none)
2298 .Default(ACC_Default_none);
2299}
2300
2301llvm::StringRef llvm::acc::getOpenACCDefaultValueName(llvm::acc::DefaultValue x) {
2302 switch (x) {
2303 case ACC_Default_present:
2304 return "present";
2305 case ACC_Default_none:
2306 return "none";
2307 }
2308 llvm_unreachable("Invalid OpenACC DefaultValue kind");
2309}
2310
2311bool llvm::acc::isAllowedClauseForDirective(llvm::acc::Directive D, llvm::acc::Clause C, llvm::directive::Version V) {
2312 assert(unsigned(D) <= Directive_enumSize);
2313 assert(unsigned(C) <= Clause_enumSize);
2314 switch (D) {
2315 case ACCD_atomic:
2316 switch (C) {
2317 case ACCC_if:
2318 return V >= 34 && V <= 2147483647;
2319 default:
2320 return false;
2321 }
2322 break;
2323 case ACCD_cache:
2324 return false;
2325 break;
2326 case ACCD_data:
2327 switch (C) {
2328 case ACCC_async:
2329 return V >= 32 && V <= 2147483647;
2330 case ACCC_device_type:
2331 return V >= 32 && V <= 2147483647;
2332 case ACCC_wait:
2333 return V >= 32 && V <= 2147483647;
2334 case ACCC_if:
2335 return V >= 1 && V <= 2147483647;
2336 case ACCC_default:
2337 return V >= 1 && V <= 2147483647;
2338 case ACCC_attach:
2339 return V >= 1 && V <= 2147483647;
2340 case ACCC_copy:
2341 return V >= 1 && V <= 2147483647;
2342 case ACCC_copyin:
2343 return V >= 1 && V <= 2147483647;
2344 case ACCC_copyout:
2345 return V >= 1 && V <= 2147483647;
2346 case ACCC_create:
2347 return V >= 1 && V <= 2147483647;
2348 case ACCC_deviceptr:
2349 return V >= 1 && V <= 2147483647;
2350 case ACCC_no_create:
2351 return V >= 1 && V <= 2147483647;
2352 case ACCC_present:
2353 return V >= 1 && V <= 2147483647;
2354 default:
2355 return false;
2356 }
2357 break;
2358 case ACCD_declare:
2359 switch (C) {
2360 case ACCC_copy:
2361 return V >= 1 && V <= 2147483647;
2362 case ACCC_copyin:
2363 return V >= 1 && V <= 2147483647;
2364 case ACCC_copyout:
2365 return V >= 1 && V <= 2147483647;
2366 case ACCC_create:
2367 return V >= 1 && V <= 2147483647;
2368 case ACCC_present:
2369 return V >= 1 && V <= 2147483647;
2370 case ACCC_deviceptr:
2371 return V >= 1 && V <= 2147483647;
2372 case ACCC_device_resident:
2373 return V >= 1 && V <= 2147483647;
2374 case ACCC_link:
2375 return V >= 1 && V <= 2147483647;
2376 default:
2377 return false;
2378 }
2379 break;
2380 case ACCD_enter_data:
2381 switch (C) {
2382 case ACCC_wait:
2383 return V >= 1 && V <= 2147483647;
2384 case ACCC_async:
2385 return V >= 1 && V <= 2147483647;
2386 case ACCC_if:
2387 return V >= 1 && V <= 2147483647;
2388 case ACCC_attach:
2389 return V >= 1 && V <= 2147483647;
2390 case ACCC_create:
2391 return V >= 1 && V <= 2147483647;
2392 case ACCC_copyin:
2393 return V >= 1 && V <= 2147483647;
2394 default:
2395 return false;
2396 }
2397 break;
2398 case ACCD_exit_data:
2399 switch (C) {
2400 case ACCC_finalize:
2401 return V >= 1 && V <= 2147483647;
2402 case ACCC_wait:
2403 return V >= 1 && V <= 2147483647;
2404 case ACCC_async:
2405 return V >= 1 && V <= 2147483647;
2406 case ACCC_if:
2407 return V >= 1 && V <= 2147483647;
2408 case ACCC_copyout:
2409 return V >= 1 && V <= 2147483647;
2410 case ACCC_delete:
2411 return V >= 1 && V <= 2147483647;
2412 case ACCC_detach:
2413 return V >= 1 && V <= 2147483647;
2414 default:
2415 return false;
2416 }
2417 break;
2418 case ACCD_host_data:
2419 switch (C) {
2420 case ACCC_if_present:
2421 return V >= 1 && V <= 2147483647;
2422 case ACCC_if:
2423 return V >= 1 && V <= 2147483647;
2424 case ACCC_use_device:
2425 return V >= 1 && V <= 2147483647;
2426 default:
2427 return false;
2428 }
2429 break;
2430 case ACCD_init:
2431 switch (C) {
2432 case ACCC_device_type:
2433 return V >= 1 && V <= 2147483647;
2434 case ACCC_device_num:
2435 return V >= 1 && V <= 2147483647;
2436 case ACCC_if:
2437 return V >= 1 && V <= 2147483647;
2438 default:
2439 return false;
2440 }
2441 break;
2442 case ACCD_kernels:
2443 switch (C) {
2444 case ACCC_async:
2445 return V >= 1 && V <= 2147483647;
2446 case ACCC_attach:
2447 return V >= 1 && V <= 2147483647;
2448 case ACCC_copy:
2449 return V >= 1 && V <= 2147483647;
2450 case ACCC_copyin:
2451 return V >= 1 && V <= 2147483647;
2452 case ACCC_copyout:
2453 return V >= 1 && V <= 2147483647;
2454 case ACCC_create:
2455 return V >= 1 && V <= 2147483647;
2456 case ACCC_device_type:
2457 return V >= 1 && V <= 2147483647;
2458 case ACCC_no_create:
2459 return V >= 1 && V <= 2147483647;
2460 case ACCC_num_gangs:
2461 return V >= 1 && V <= 2147483647;
2462 case ACCC_num_workers:
2463 return V >= 1 && V <= 2147483647;
2464 case ACCC_present:
2465 return V >= 1 && V <= 2147483647;
2466 case ACCC_deviceptr:
2467 return V >= 1 && V <= 2147483647;
2468 case ACCC_vector_length:
2469 return V >= 1 && V <= 2147483647;
2470 case ACCC_wait:
2471 return V >= 1 && V <= 2147483647;
2472 case ACCC_default:
2473 return V >= 1 && V <= 2147483647;
2474 case ACCC_if:
2475 return V >= 1 && V <= 2147483647;
2476 case ACCC_self:
2477 return V >= 1 && V <= 2147483647;
2478 default:
2479 return false;
2480 }
2481 break;
2482 case ACCD_kernels_loop:
2483 switch (C) {
2484 case ACCC_async:
2485 return V >= 1 && V <= 2147483647;
2486 case ACCC_attach:
2487 return V >= 1 && V <= 2147483647;
2488 case ACCC_collapse:
2489 return V >= 1 && V <= 2147483647;
2490 case ACCC_copy:
2491 return V >= 1 && V <= 2147483647;
2492 case ACCC_copyin:
2493 return V >= 1 && V <= 2147483647;
2494 case ACCC_copyout:
2495 return V >= 1 && V <= 2147483647;
2496 case ACCC_create:
2497 return V >= 1 && V <= 2147483647;
2498 case ACCC_deviceptr:
2499 return V >= 1 && V <= 2147483647;
2500 case ACCC_device_type:
2501 return V >= 1 && V <= 2147483647;
2502 case ACCC_gang:
2503 return V >= 1 && V <= 2147483647;
2504 case ACCC_no_create:
2505 return V >= 1 && V <= 2147483647;
2506 case ACCC_num_gangs:
2507 return V >= 1 && V <= 2147483647;
2508 case ACCC_num_workers:
2509 return V >= 1 && V <= 2147483647;
2510 case ACCC_present:
2511 return V >= 1 && V <= 2147483647;
2512 case ACCC_private:
2513 return V >= 1 && V <= 2147483647;
2514 case ACCC_reduction:
2515 return V >= 1 && V <= 2147483647;
2516 case ACCC_shortloop:
2517 return V >= 1 && V <= 2147483647;
2518 case ACCC_tile:
2519 return V >= 1 && V <= 2147483647;
2520 case ACCC_vector:
2521 return V >= 1 && V <= 2147483647;
2522 case ACCC_vector_length:
2523 return V >= 1 && V <= 2147483647;
2524 case ACCC_wait:
2525 return V >= 1 && V <= 2147483647;
2526 case ACCC_worker:
2527 return V >= 1 && V <= 2147483647;
2528 case ACCC_default:
2529 return V >= 1 && V <= 2147483647;
2530 case ACCC_if:
2531 return V >= 1 && V <= 2147483647;
2532 case ACCC_self:
2533 return V >= 1 && V <= 2147483647;
2534 case ACCC_auto:
2535 return V >= 1 && V <= 2147483647;
2536 case ACCC_independent:
2537 return V >= 1 && V <= 2147483647;
2538 case ACCC_seq:
2539 return V >= 1 && V <= 2147483647;
2540 default:
2541 return false;
2542 }
2543 break;
2544 case ACCD_loop:
2545 switch (C) {
2546 case ACCC_device_type:
2547 return V >= 1 && V <= 2147483647;
2548 case ACCC_private:
2549 return V >= 1 && V <= 2147483647;
2550 case ACCC_reduction:
2551 return V >= 1 && V <= 2147483647;
2552 case ACCC_collapse:
2553 return V >= 1 && V <= 2147483647;
2554 case ACCC_gang:
2555 return V >= 1 && V <= 2147483647;
2556 case ACCC_shortloop:
2557 return V >= 1 && V <= 2147483647;
2558 case ACCC_tile:
2559 return V >= 1 && V <= 2147483647;
2560 case ACCC_vector:
2561 return V >= 1 && V <= 2147483647;
2562 case ACCC_worker:
2563 return V >= 1 && V <= 2147483647;
2564 case ACCC_auto:
2565 return V >= 1 && V <= 2147483647;
2566 case ACCC_independent:
2567 return V >= 1 && V <= 2147483647;
2568 case ACCC_seq:
2569 return V >= 1 && V <= 2147483647;
2570 default:
2571 return false;
2572 }
2573 break;
2574 case ACCD_parallel:
2575 switch (C) {
2576 case ACCC_attach:
2577 return V >= 1 && V <= 2147483647;
2578 case ACCC_async:
2579 return V >= 1 && V <= 2147483647;
2580 case ACCC_copy:
2581 return V >= 1 && V <= 2147483647;
2582 case ACCC_copyin:
2583 return V >= 1 && V <= 2147483647;
2584 case ACCC_copyout:
2585 return V >= 1 && V <= 2147483647;
2586 case ACCC_create:
2587 return V >= 1 && V <= 2147483647;
2588 case ACCC_deviceptr:
2589 return V >= 1 && V <= 2147483647;
2590 case ACCC_device_type:
2591 return V >= 1 && V <= 2147483647;
2592 case ACCC_no_create:
2593 return V >= 1 && V <= 2147483647;
2594 case ACCC_num_gangs:
2595 return V >= 1 && V <= 2147483647;
2596 case ACCC_num_workers:
2597 return V >= 1 && V <= 2147483647;
2598 case ACCC_present:
2599 return V >= 1 && V <= 2147483647;
2600 case ACCC_private:
2601 return V >= 1 && V <= 2147483647;
2602 case ACCC_firstprivate:
2603 return V >= 1 && V <= 2147483647;
2604 case ACCC_reduction:
2605 return V >= 1 && V <= 2147483647;
2606 case ACCC_wait:
2607 return V >= 1 && V <= 2147483647;
2608 case ACCC_vector_length:
2609 return V >= 1 && V <= 2147483647;
2610 case ACCC_default:
2611 return V >= 1 && V <= 2147483647;
2612 case ACCC_if:
2613 return V >= 1 && V <= 2147483647;
2614 case ACCC_self:
2615 return V >= 1 && V <= 2147483647;
2616 default:
2617 return false;
2618 }
2619 break;
2620 case ACCD_parallel_loop:
2621 switch (C) {
2622 case ACCC_async:
2623 return V >= 1 && V <= 2147483647;
2624 case ACCC_attach:
2625 return V >= 1 && V <= 2147483647;
2626 case ACCC_collapse:
2627 return V >= 1 && V <= 2147483647;
2628 case ACCC_copy:
2629 return V >= 1 && V <= 2147483647;
2630 case ACCC_copyin:
2631 return V >= 1 && V <= 2147483647;
2632 case ACCC_copyout:
2633 return V >= 1 && V <= 2147483647;
2634 case ACCC_create:
2635 return V >= 1 && V <= 2147483647;
2636 case ACCC_deviceptr:
2637 return V >= 1 && V <= 2147483647;
2638 case ACCC_device_type:
2639 return V >= 1 && V <= 2147483647;
2640 case ACCC_firstprivate:
2641 return V >= 1 && V <= 2147483647;
2642 case ACCC_gang:
2643 return V >= 1 && V <= 2147483647;
2644 case ACCC_no_create:
2645 return V >= 1 && V <= 2147483647;
2646 case ACCC_num_gangs:
2647 return V >= 1 && V <= 2147483647;
2648 case ACCC_num_workers:
2649 return V >= 1 && V <= 2147483647;
2650 case ACCC_present:
2651 return V >= 1 && V <= 2147483647;
2652 case ACCC_private:
2653 return V >= 1 && V <= 2147483647;
2654 case ACCC_reduction:
2655 return V >= 1 && V <= 2147483647;
2656 case ACCC_shortloop:
2657 return V >= 1 && V <= 2147483647;
2658 case ACCC_tile:
2659 return V >= 1 && V <= 2147483647;
2660 case ACCC_vector:
2661 return V >= 1 && V <= 2147483647;
2662 case ACCC_vector_length:
2663 return V >= 1 && V <= 2147483647;
2664 case ACCC_wait:
2665 return V >= 1 && V <= 2147483647;
2666 case ACCC_worker:
2667 return V >= 1 && V <= 2147483647;
2668 case ACCC_default:
2669 return V >= 1 && V <= 2147483647;
2670 case ACCC_if:
2671 return V >= 1 && V <= 2147483647;
2672 case ACCC_self:
2673 return V >= 1 && V <= 2147483647;
2674 case ACCC_auto:
2675 return V >= 1 && V <= 2147483647;
2676 case ACCC_independent:
2677 return V >= 1 && V <= 2147483647;
2678 case ACCC_seq:
2679 return V >= 1 && V <= 2147483647;
2680 default:
2681 return false;
2682 }
2683 break;
2684 case ACCD_routine:
2685 switch (C) {
2686 case ACCC_bind:
2687 return V >= 1 && V <= 2147483647;
2688 case ACCC_device_type:
2689 return V >= 1 && V <= 2147483647;
2690 case ACCC_gang:
2691 return V >= 1 && V <= 2147483647;
2692 case ACCC_seq:
2693 return V >= 1 && V <= 2147483647;
2694 case ACCC_vector:
2695 return V >= 1 && V <= 2147483647;
2696 case ACCC_worker:
2697 return V >= 1 && V <= 2147483647;
2698 case ACCC_nohost:
2699 return V >= 1 && V <= 2147483647;
2700 default:
2701 return false;
2702 }
2703 break;
2704 case ACCD_serial:
2705 switch (C) {
2706 case ACCC_async:
2707 return V >= 1 && V <= 2147483647;
2708 case ACCC_attach:
2709 return V >= 1 && V <= 2147483647;
2710 case ACCC_copy:
2711 return V >= 1 && V <= 2147483647;
2712 case ACCC_copyin:
2713 return V >= 1 && V <= 2147483647;
2714 case ACCC_copyout:
2715 return V >= 1 && V <= 2147483647;
2716 case ACCC_create:
2717 return V >= 1 && V <= 2147483647;
2718 case ACCC_deviceptr:
2719 return V >= 1 && V <= 2147483647;
2720 case ACCC_device_type:
2721 return V >= 1 && V <= 2147483647;
2722 case ACCC_no_create:
2723 return V >= 1 && V <= 2147483647;
2724 case ACCC_present:
2725 return V >= 1 && V <= 2147483647;
2726 case ACCC_private:
2727 return V >= 1 && V <= 2147483647;
2728 case ACCC_firstprivate:
2729 return V >= 1 && V <= 2147483647;
2730 case ACCC_reduction:
2731 return V >= 1 && V <= 2147483647;
2732 case ACCC_wait:
2733 return V >= 1 && V <= 2147483647;
2734 case ACCC_default:
2735 return V >= 1 && V <= 2147483647;
2736 case ACCC_if:
2737 return V >= 1 && V <= 2147483647;
2738 case ACCC_self:
2739 return V >= 1 && V <= 2147483647;
2740 default:
2741 return false;
2742 }
2743 break;
2744 case ACCD_serial_loop:
2745 switch (C) {
2746 case ACCC_async:
2747 return V >= 1 && V <= 2147483647;
2748 case ACCC_attach:
2749 return V >= 1 && V <= 2147483647;
2750 case ACCC_collapse:
2751 return V >= 1 && V <= 2147483647;
2752 case ACCC_copy:
2753 return V >= 1 && V <= 2147483647;
2754 case ACCC_copyin:
2755 return V >= 1 && V <= 2147483647;
2756 case ACCC_copyout:
2757 return V >= 1 && V <= 2147483647;
2758 case ACCC_create:
2759 return V >= 1 && V <= 2147483647;
2760 case ACCC_deviceptr:
2761 return V >= 1 && V <= 2147483647;
2762 case ACCC_device_type:
2763 return V >= 1 && V <= 2147483647;
2764 case ACCC_firstprivate:
2765 return V >= 1 && V <= 2147483647;
2766 case ACCC_gang:
2767 return V >= 1 && V <= 2147483647;
2768 case ACCC_no_create:
2769 return V >= 1 && V <= 2147483647;
2770 case ACCC_present:
2771 return V >= 1 && V <= 2147483647;
2772 case ACCC_private:
2773 return V >= 1 && V <= 2147483647;
2774 case ACCC_reduction:
2775 return V >= 1 && V <= 2147483647;
2776 case ACCC_shortloop:
2777 return V >= 1 && V <= 2147483647;
2778 case ACCC_tile:
2779 return V >= 1 && V <= 2147483647;
2780 case ACCC_vector:
2781 return V >= 1 && V <= 2147483647;
2782 case ACCC_wait:
2783 return V >= 1 && V <= 2147483647;
2784 case ACCC_worker:
2785 return V >= 1 && V <= 2147483647;
2786 case ACCC_default:
2787 return V >= 1 && V <= 2147483647;
2788 case ACCC_if:
2789 return V >= 1 && V <= 2147483647;
2790 case ACCC_self:
2791 return V >= 1 && V <= 2147483647;
2792 case ACCC_auto:
2793 return V >= 1 && V <= 2147483647;
2794 case ACCC_independent:
2795 return V >= 1 && V <= 2147483647;
2796 case ACCC_seq:
2797 return V >= 1 && V <= 2147483647;
2798 default:
2799 return false;
2800 }
2801 break;
2802 case ACCD_set:
2803 switch (C) {
2804 case ACCC_default_async:
2805 return V >= 1 && V <= 2147483647;
2806 case ACCC_device_num:
2807 return V >= 1 && V <= 2147483647;
2808 case ACCC_device_type:
2809 return V >= 1 && V <= 2147483647;
2810 case ACCC_if:
2811 return V >= 1 && V <= 2147483647;
2812 default:
2813 return false;
2814 }
2815 break;
2816 case ACCD_shutdown:
2817 switch (C) {
2818 case ACCC_device_type:
2819 return V >= 1 && V <= 2147483647;
2820 case ACCC_device_num:
2821 return V >= 1 && V <= 2147483647;
2822 case ACCC_if:
2823 return V >= 1 && V <= 2147483647;
2824 default:
2825 return false;
2826 }
2827 break;
2828 case ACCD_unknown:
2829 return false;
2830 break;
2831 case ACCD_update:
2832 switch (C) {
2833 case ACCC_device_type:
2834 return V >= 1 && V <= 2147483647;
2835 case ACCC_if_present:
2836 return V >= 1 && V <= 2147483647;
2837 case ACCC_wait:
2838 return V >= 1 && V <= 2147483647;
2839 case ACCC_async:
2840 return V >= 1 && V <= 2147483647;
2841 case ACCC_if:
2842 return V >= 1 && V <= 2147483647;
2843 case ACCC_device:
2844 return V >= 1 && V <= 2147483647;
2845 case ACCC_host:
2846 return V >= 1 && V <= 2147483647;
2847 case ACCC_self:
2848 return V >= 1 && V <= 2147483647;
2849 default:
2850 return false;
2851 }
2852 break;
2853 case ACCD_wait:
2854 switch (C) {
2855 case ACCC_async:
2856 return V >= 1 && V <= 2147483647;
2857 case ACCC_if:
2858 return V >= 1 && V <= 2147483647;
2859 default:
2860 return false;
2861 }
2862 break;
2863 }
2864 llvm_unreachable("Invalid OpenACC Directive kind");
2865}
2866
2867bool llvm::acc::isAllowedLoopModifier(llvm::acc::Directive D, llvm::acc::LoopModifier LM) {
2868 assert(unsigned(D) <= Directive_enumSize);
2869 switch (D) {
2870 case ACCD_atomic:
2871 return false;
2872 break;
2873 case ACCD_cache:
2874 return false;
2875 break;
2876 case ACCD_data:
2877 return false;
2878 break;
2879 case ACCD_declare:
2880 return false;
2881 break;
2882 case ACCD_enter_data:
2883 return false;
2884 break;
2885 case ACCD_exit_data:
2886 return false;
2887 break;
2888 case ACCD_host_data:
2889 return false;
2890 break;
2891 case ACCD_init:
2892 return false;
2893 break;
2894 case ACCD_kernels:
2895 return false;
2896 break;
2897 case ACCD_kernels_loop:
2898 return false;
2899 break;
2900 case ACCD_loop:
2901 return false;
2902 break;
2903 case ACCD_parallel:
2904 return false;
2905 break;
2906 case ACCD_parallel_loop:
2907 return false;
2908 break;
2909 case ACCD_routine:
2910 return false;
2911 break;
2912 case ACCD_serial:
2913 return false;
2914 break;
2915 case ACCD_serial_loop:
2916 return false;
2917 break;
2918 case ACCD_set:
2919 return false;
2920 break;
2921 case ACCD_shutdown:
2922 return false;
2923 break;
2924 case ACCD_unknown:
2925 return false;
2926 break;
2927 case ACCD_update:
2928 return false;
2929 break;
2930 case ACCD_wait:
2931 return false;
2932 break;
2933 }
2934 llvm_unreachable("Invalid OpenACC Directive kind");
2935}
2936
2937llvm::StringRef llvm::acc::getLoopModifierName(llvm::acc::LoopModifier Kind, llvm::directive::Version V) {
2938 switch (Kind) {
2939 case flattened:
2940 return "flattened";
2941 case fused:
2942 return "fused";
2943 case grid:
2944 return "grid";
2945 case identity:
2946 return "identity";
2947 case interchanged:
2948 return "interchanged";
2949 case intratile:
2950 return "intratile";
2951 case offsets:
2952 return "offsets";
2953 case reversed:
2954 return "reversed";
2955 case split:
2956 return "split";
2957 case unrolled:
2958 return "unrolled";
2959 }
2960 llvm_unreachable("Invalid LoopModifier kind");
2961}
2962
2963static_assert(sizeof(llvm::acc::Directive) == sizeof(int));
2964[[maybe_unused]] static const llvm::acc::Directive LeafConstructTable[][4] = {
2965 {llvm::acc::ACCD_atomic, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2966 {llvm::acc::ACCD_cache, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2967 {llvm::acc::ACCD_data, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2968 {llvm::acc::ACCD_declare, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2969 {llvm::acc::ACCD_enter_data, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2970 {llvm::acc::ACCD_exit_data, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2971 {llvm::acc::ACCD_host_data, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2972 {llvm::acc::ACCD_init, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2973 {llvm::acc::ACCD_kernels, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2974 {llvm::acc::ACCD_loop, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2975 {llvm::acc::ACCD_parallel, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2976 {llvm::acc::ACCD_routine, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2977 {llvm::acc::ACCD_serial, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2978 {llvm::acc::ACCD_set, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2979 {llvm::acc::ACCD_shutdown, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2980 {llvm::acc::ACCD_unknown, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2981 {llvm::acc::ACCD_update, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2982 {llvm::acc::ACCD_wait, static_cast<llvm::acc::Directive>(0), static_cast<llvm::acc::Directive>(-1), static_cast<llvm::acc::Directive>(-1),},
2983 {llvm::acc::ACCD_kernels_loop, static_cast<llvm::acc::Directive>(2), llvm::acc::ACCD_kernels, llvm::acc::ACCD_loop,},
2984 {llvm::acc::ACCD_parallel_loop, static_cast<llvm::acc::Directive>(2), llvm::acc::ACCD_parallel, llvm::acc::ACCD_loop,},
2985 {llvm::acc::ACCD_serial_loop, static_cast<llvm::acc::Directive>(2), llvm::acc::ACCD_serial, llvm::acc::ACCD_loop,},
2986};
2987
2988[[maybe_unused]] static auto LeafConstructTableEndDirective = LeafConstructTable + 21;
2989
2990[[maybe_unused]] static const int LeafConstructTableOrdering[] = {
2991 0, 1, 2, 3, 4, 5, 6, 7, 8, 18, 9, 10, 19, 11, 12, 20, 13, 14, 15, 16, 17,
2992};
2993
2994#endif // GEN_DIRECTIVES_IMPL
2995
2996