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