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