1 //===--- OpenMPKinds.cpp - Token Kinds Support ----------------------------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 /// \file
10 /// This file implements the OpenMP enum and support functions.
11 ///
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/Basic/OpenMPKinds.h"
15 #include "clang/Basic/IdentifierTable.h"
16 #include "llvm/ADT/StringRef.h"
17 #include "llvm/ADT/StringSwitch.h"
18 #include "llvm/Support/ErrorHandling.h"
19 #include <cassert>
20
21 using namespace clang;
22
getOpenMPDirectiveKind(StringRef Str)23 OpenMPDirectiveKind clang::getOpenMPDirectiveKind(StringRef Str) {
24 return llvm::StringSwitch<OpenMPDirectiveKind>(Str)
25 #define OPENMP_DIRECTIVE(Name) .Case(#Name, OMPD_##Name)
26 #define OPENMP_DIRECTIVE_EXT(Name, Str) .Case(Str, OMPD_##Name)
27 #include "clang/Basic/OpenMPKinds.def"
28 .Default(OMPD_unknown);
29 }
30
getOpenMPDirectiveName(OpenMPDirectiveKind Kind)31 const char *clang::getOpenMPDirectiveName(OpenMPDirectiveKind Kind) {
32 assert(Kind <= OMPD_unknown);
33 switch (Kind) {
34 case OMPD_unknown:
35 return "unknown";
36 #define OPENMP_DIRECTIVE(Name) \
37 case OMPD_##Name: \
38 return #Name;
39 #define OPENMP_DIRECTIVE_EXT(Name, Str) \
40 case OMPD_##Name: \
41 return Str;
42 #include "clang/Basic/OpenMPKinds.def"
43 break;
44 }
45 llvm_unreachable("Invalid OpenMP directive kind");
46 }
47
getOpenMPClauseKind(StringRef Str)48 OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) {
49 // 'flush' clause cannot be specified explicitly, because this is an implicit
50 // clause for 'flush' directive. If the 'flush' clause is explicitly specified
51 // the Parser should generate a warning about extra tokens at the end of the
52 // directive.
53 if (Str == "flush")
54 return OMPC_unknown;
55 return llvm::StringSwitch<OpenMPClauseKind>(Str)
56 #define OPENMP_CLAUSE(Name, Class) .Case(#Name, OMPC_##Name)
57 #include "clang/Basic/OpenMPKinds.def"
58 .Case("uniform", OMPC_uniform)
59 .Default(OMPC_unknown);
60 }
61
getOpenMPClauseName(OpenMPClauseKind Kind)62 const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) {
63 assert(Kind <= OMPC_unknown);
64 switch (Kind) {
65 case OMPC_unknown:
66 return "unknown";
67 #define OPENMP_CLAUSE(Name, Class) \
68 case OMPC_##Name: \
69 return #Name;
70 #include "clang/Basic/OpenMPKinds.def"
71 case OMPC_uniform:
72 return "uniform";
73 case OMPC_threadprivate:
74 return "threadprivate or thread local";
75 }
76 llvm_unreachable("Invalid OpenMP clause kind");
77 }
78
getOpenMPSimpleClauseType(OpenMPClauseKind Kind,StringRef Str)79 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind,
80 StringRef Str) {
81 switch (Kind) {
82 case OMPC_default:
83 return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str)
84 #define OPENMP_DEFAULT_KIND(Name) .Case(#Name, OMPC_DEFAULT_##Name)
85 #include "clang/Basic/OpenMPKinds.def"
86 .Default(OMPC_DEFAULT_unknown);
87 case OMPC_proc_bind:
88 return llvm::StringSwitch<OpenMPProcBindClauseKind>(Str)
89 #define OPENMP_PROC_BIND_KIND(Name) .Case(#Name, OMPC_PROC_BIND_##Name)
90 #include "clang/Basic/OpenMPKinds.def"
91 .Default(OMPC_PROC_BIND_unknown);
92 case OMPC_schedule:
93 return llvm::StringSwitch<unsigned>(Str)
94 #define OPENMP_SCHEDULE_KIND(Name) \
95 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name))
96 #define OPENMP_SCHEDULE_MODIFIER(Name) \
97 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name))
98 #include "clang/Basic/OpenMPKinds.def"
99 .Default(OMPC_SCHEDULE_unknown);
100 case OMPC_depend:
101 return llvm::StringSwitch<OpenMPDependClauseKind>(Str)
102 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name)
103 #include "clang/Basic/OpenMPKinds.def"
104 .Default(OMPC_DEPEND_unknown);
105 case OMPC_linear:
106 return llvm::StringSwitch<OpenMPLinearClauseKind>(Str)
107 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name)
108 #include "clang/Basic/OpenMPKinds.def"
109 .Default(OMPC_LINEAR_unknown);
110 case OMPC_map:
111 return llvm::StringSwitch<unsigned>(Str)
112 #define OPENMP_MAP_KIND(Name) \
113 .Case(#Name, static_cast<unsigned>(OMPC_MAP_##Name))
114 #define OPENMP_MAP_MODIFIER_KIND(Name) \
115 .Case(#Name, static_cast<unsigned>(OMPC_MAP_MODIFIER_##Name))
116 #include "clang/Basic/OpenMPKinds.def"
117 .Default(OMPC_MAP_unknown);
118 case OMPC_dist_schedule:
119 return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str)
120 #define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name)
121 #include "clang/Basic/OpenMPKinds.def"
122 .Default(OMPC_DIST_SCHEDULE_unknown);
123 case OMPC_defaultmap:
124 return llvm::StringSwitch<unsigned>(Str)
125 #define OPENMP_DEFAULTMAP_KIND(Name) \
126 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name))
127 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \
128 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name))
129 #include "clang/Basic/OpenMPKinds.def"
130 .Default(OMPC_DEFAULTMAP_unknown);
131 case OMPC_atomic_default_mem_order:
132 return llvm::StringSwitch<OpenMPAtomicDefaultMemOrderClauseKind>(Str)
133 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \
134 .Case(#Name, OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name)
135 #include "clang/Basic/OpenMPKinds.def"
136 .Default(OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown);
137 case OMPC_unknown:
138 case OMPC_threadprivate:
139 case OMPC_if:
140 case OMPC_final:
141 case OMPC_num_threads:
142 case OMPC_safelen:
143 case OMPC_simdlen:
144 case OMPC_collapse:
145 case OMPC_private:
146 case OMPC_firstprivate:
147 case OMPC_lastprivate:
148 case OMPC_shared:
149 case OMPC_reduction:
150 case OMPC_task_reduction:
151 case OMPC_in_reduction:
152 case OMPC_aligned:
153 case OMPC_copyin:
154 case OMPC_copyprivate:
155 case OMPC_ordered:
156 case OMPC_nowait:
157 case OMPC_untied:
158 case OMPC_mergeable:
159 case OMPC_flush:
160 case OMPC_read:
161 case OMPC_write:
162 case OMPC_update:
163 case OMPC_capture:
164 case OMPC_seq_cst:
165 case OMPC_device:
166 case OMPC_threads:
167 case OMPC_simd:
168 case OMPC_num_teams:
169 case OMPC_thread_limit:
170 case OMPC_priority:
171 case OMPC_grainsize:
172 case OMPC_nogroup:
173 case OMPC_num_tasks:
174 case OMPC_hint:
175 case OMPC_uniform:
176 case OMPC_to:
177 case OMPC_from:
178 case OMPC_use_device_ptr:
179 case OMPC_is_device_ptr:
180 case OMPC_unified_address:
181 case OMPC_unified_shared_memory:
182 case OMPC_reverse_offload:
183 case OMPC_dynamic_allocators:
184 break;
185 }
186 llvm_unreachable("Invalid OpenMP simple clause kind");
187 }
188
getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,unsigned Type)189 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
190 unsigned Type) {
191 switch (Kind) {
192 case OMPC_default:
193 switch (Type) {
194 case OMPC_DEFAULT_unknown:
195 return "unknown";
196 #define OPENMP_DEFAULT_KIND(Name) \
197 case OMPC_DEFAULT_##Name: \
198 return #Name;
199 #include "clang/Basic/OpenMPKinds.def"
200 }
201 llvm_unreachable("Invalid OpenMP 'default' clause type");
202 case OMPC_proc_bind:
203 switch (Type) {
204 case OMPC_PROC_BIND_unknown:
205 return "unknown";
206 #define OPENMP_PROC_BIND_KIND(Name) \
207 case OMPC_PROC_BIND_##Name: \
208 return #Name;
209 #include "clang/Basic/OpenMPKinds.def"
210 }
211 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
212 case OMPC_schedule:
213 switch (Type) {
214 case OMPC_SCHEDULE_unknown:
215 case OMPC_SCHEDULE_MODIFIER_last:
216 return "unknown";
217 #define OPENMP_SCHEDULE_KIND(Name) \
218 case OMPC_SCHEDULE_##Name: \
219 return #Name;
220 #define OPENMP_SCHEDULE_MODIFIER(Name) \
221 case OMPC_SCHEDULE_MODIFIER_##Name: \
222 return #Name;
223 #include "clang/Basic/OpenMPKinds.def"
224 }
225 llvm_unreachable("Invalid OpenMP 'schedule' clause type");
226 case OMPC_depend:
227 switch (Type) {
228 case OMPC_DEPEND_unknown:
229 return "unknown";
230 #define OPENMP_DEPEND_KIND(Name) \
231 case OMPC_DEPEND_##Name: \
232 return #Name;
233 #include "clang/Basic/OpenMPKinds.def"
234 }
235 llvm_unreachable("Invalid OpenMP 'depend' clause type");
236 case OMPC_linear:
237 switch (Type) {
238 case OMPC_LINEAR_unknown:
239 return "unknown";
240 #define OPENMP_LINEAR_KIND(Name) \
241 case OMPC_LINEAR_##Name: \
242 return #Name;
243 #include "clang/Basic/OpenMPKinds.def"
244 }
245 llvm_unreachable("Invalid OpenMP 'linear' clause type");
246 case OMPC_map:
247 switch (Type) {
248 case OMPC_MAP_unknown:
249 case OMPC_MAP_MODIFIER_last:
250 return "unknown";
251 #define OPENMP_MAP_KIND(Name) \
252 case OMPC_MAP_##Name: \
253 return #Name;
254 #define OPENMP_MAP_MODIFIER_KIND(Name) \
255 case OMPC_MAP_MODIFIER_##Name: \
256 return #Name;
257 #include "clang/Basic/OpenMPKinds.def"
258 default:
259 break;
260 }
261 llvm_unreachable("Invalid OpenMP 'map' clause type");
262 case OMPC_dist_schedule:
263 switch (Type) {
264 case OMPC_DIST_SCHEDULE_unknown:
265 return "unknown";
266 #define OPENMP_DIST_SCHEDULE_KIND(Name) \
267 case OMPC_DIST_SCHEDULE_##Name: \
268 return #Name;
269 #include "clang/Basic/OpenMPKinds.def"
270 }
271 llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type");
272 case OMPC_defaultmap:
273 switch (Type) {
274 case OMPC_DEFAULTMAP_unknown:
275 case OMPC_DEFAULTMAP_MODIFIER_last:
276 return "unknown";
277 #define OPENMP_DEFAULTMAP_KIND(Name) \
278 case OMPC_DEFAULTMAP_##Name: \
279 return #Name;
280 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \
281 case OMPC_DEFAULTMAP_MODIFIER_##Name: \
282 return #Name;
283 #include "clang/Basic/OpenMPKinds.def"
284 }
285 llvm_unreachable("Invalid OpenMP 'schedule' clause type");
286 case OMPC_atomic_default_mem_order:
287 switch (Type) {
288 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown:
289 return "unknown";
290 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \
291 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name: \
292 return #Name;
293 #include "clang/Basic/OpenMPKinds.def"
294 }
295 llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type");
296 case OMPC_unknown:
297 case OMPC_threadprivate:
298 case OMPC_if:
299 case OMPC_final:
300 case OMPC_num_threads:
301 case OMPC_safelen:
302 case OMPC_simdlen:
303 case OMPC_collapse:
304 case OMPC_private:
305 case OMPC_firstprivate:
306 case OMPC_lastprivate:
307 case OMPC_shared:
308 case OMPC_reduction:
309 case OMPC_task_reduction:
310 case OMPC_in_reduction:
311 case OMPC_aligned:
312 case OMPC_copyin:
313 case OMPC_copyprivate:
314 case OMPC_ordered:
315 case OMPC_nowait:
316 case OMPC_untied:
317 case OMPC_mergeable:
318 case OMPC_flush:
319 case OMPC_read:
320 case OMPC_write:
321 case OMPC_update:
322 case OMPC_capture:
323 case OMPC_seq_cst:
324 case OMPC_device:
325 case OMPC_threads:
326 case OMPC_simd:
327 case OMPC_num_teams:
328 case OMPC_thread_limit:
329 case OMPC_priority:
330 case OMPC_grainsize:
331 case OMPC_nogroup:
332 case OMPC_num_tasks:
333 case OMPC_hint:
334 case OMPC_uniform:
335 case OMPC_to:
336 case OMPC_from:
337 case OMPC_use_device_ptr:
338 case OMPC_is_device_ptr:
339 case OMPC_unified_address:
340 case OMPC_unified_shared_memory:
341 case OMPC_reverse_offload:
342 case OMPC_dynamic_allocators:
343 break;
344 }
345 llvm_unreachable("Invalid OpenMP simple clause kind");
346 }
347
isAllowedClauseForDirective(OpenMPDirectiveKind DKind,OpenMPClauseKind CKind)348 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
349 OpenMPClauseKind CKind) {
350 assert(DKind <= OMPD_unknown);
351 assert(CKind <= OMPC_unknown);
352 switch (DKind) {
353 case OMPD_parallel:
354 switch (CKind) {
355 #define OPENMP_PARALLEL_CLAUSE(Name) \
356 case OMPC_##Name: \
357 return true;
358 #include "clang/Basic/OpenMPKinds.def"
359 default:
360 break;
361 }
362 break;
363 case OMPD_simd:
364 switch (CKind) {
365 #define OPENMP_SIMD_CLAUSE(Name) \
366 case OMPC_##Name: \
367 return true;
368 #include "clang/Basic/OpenMPKinds.def"
369 default:
370 break;
371 }
372 break;
373 case OMPD_for:
374 switch (CKind) {
375 #define OPENMP_FOR_CLAUSE(Name) \
376 case OMPC_##Name: \
377 return true;
378 #include "clang/Basic/OpenMPKinds.def"
379 default:
380 break;
381 }
382 break;
383 case OMPD_for_simd:
384 switch (CKind) {
385 #define OPENMP_FOR_SIMD_CLAUSE(Name) \
386 case OMPC_##Name: \
387 return true;
388 #include "clang/Basic/OpenMPKinds.def"
389 default:
390 break;
391 }
392 break;
393 case OMPD_sections:
394 switch (CKind) {
395 #define OPENMP_SECTIONS_CLAUSE(Name) \
396 case OMPC_##Name: \
397 return true;
398 #include "clang/Basic/OpenMPKinds.def"
399 default:
400 break;
401 }
402 break;
403 case OMPD_single:
404 switch (CKind) {
405 #define OPENMP_SINGLE_CLAUSE(Name) \
406 case OMPC_##Name: \
407 return true;
408 #include "clang/Basic/OpenMPKinds.def"
409 default:
410 break;
411 }
412 break;
413 case OMPD_parallel_for:
414 switch (CKind) {
415 #define OPENMP_PARALLEL_FOR_CLAUSE(Name) \
416 case OMPC_##Name: \
417 return true;
418 #include "clang/Basic/OpenMPKinds.def"
419 default:
420 break;
421 }
422 break;
423 case OMPD_parallel_for_simd:
424 switch (CKind) {
425 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \
426 case OMPC_##Name: \
427 return true;
428 #include "clang/Basic/OpenMPKinds.def"
429 default:
430 break;
431 }
432 break;
433 case OMPD_parallel_sections:
434 switch (CKind) {
435 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) \
436 case OMPC_##Name: \
437 return true;
438 #include "clang/Basic/OpenMPKinds.def"
439 default:
440 break;
441 }
442 break;
443 case OMPD_task:
444 switch (CKind) {
445 #define OPENMP_TASK_CLAUSE(Name) \
446 case OMPC_##Name: \
447 return true;
448 #include "clang/Basic/OpenMPKinds.def"
449 default:
450 break;
451 }
452 break;
453 case OMPD_flush:
454 return CKind == OMPC_flush;
455 break;
456 case OMPD_atomic:
457 switch (CKind) {
458 #define OPENMP_ATOMIC_CLAUSE(Name) \
459 case OMPC_##Name: \
460 return true;
461 #include "clang/Basic/OpenMPKinds.def"
462 default:
463 break;
464 }
465 break;
466 case OMPD_target:
467 switch (CKind) {
468 #define OPENMP_TARGET_CLAUSE(Name) \
469 case OMPC_##Name: \
470 return true;
471 #include "clang/Basic/OpenMPKinds.def"
472 default:
473 break;
474 }
475 break;
476 case OMPD_requires:
477 switch (CKind) {
478 #define OPENMP_REQUIRES_CLAUSE(Name) \
479 case OMPC_##Name: \
480 return true;
481 #include "clang/Basic/OpenMPKinds.def"
482 default:
483 break;
484 }
485 break;
486 case OMPD_target_data:
487 switch (CKind) {
488 #define OPENMP_TARGET_DATA_CLAUSE(Name) \
489 case OMPC_##Name: \
490 return true;
491 #include "clang/Basic/OpenMPKinds.def"
492 default:
493 break;
494 }
495 break;
496 case OMPD_target_enter_data:
497 switch (CKind) {
498 #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name) \
499 case OMPC_##Name: \
500 return true;
501 #include "clang/Basic/OpenMPKinds.def"
502 default:
503 break;
504 }
505 break;
506 case OMPD_target_exit_data:
507 switch (CKind) {
508 #define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name) \
509 case OMPC_##Name: \
510 return true;
511 #include "clang/Basic/OpenMPKinds.def"
512 default:
513 break;
514 }
515 break;
516 case OMPD_target_parallel:
517 switch (CKind) {
518 #define OPENMP_TARGET_PARALLEL_CLAUSE(Name) \
519 case OMPC_##Name: \
520 return true;
521 #include "clang/Basic/OpenMPKinds.def"
522 default:
523 break;
524 }
525 break;
526 case OMPD_target_parallel_for:
527 switch (CKind) {
528 #define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name) \
529 case OMPC_##Name: \
530 return true;
531 #include "clang/Basic/OpenMPKinds.def"
532 default:
533 break;
534 }
535 break;
536 case OMPD_target_update:
537 switch (CKind) {
538 #define OPENMP_TARGET_UPDATE_CLAUSE(Name) \
539 case OMPC_##Name: \
540 return true;
541 #include "clang/Basic/OpenMPKinds.def"
542 default:
543 break;
544 }
545 break;
546 case OMPD_teams:
547 switch (CKind) {
548 #define OPENMP_TEAMS_CLAUSE(Name) \
549 case OMPC_##Name: \
550 return true;
551 #include "clang/Basic/OpenMPKinds.def"
552 default:
553 break;
554 }
555 break;
556 case OMPD_declare_simd:
557 break;
558 case OMPD_cancel:
559 switch (CKind) {
560 #define OPENMP_CANCEL_CLAUSE(Name) \
561 case OMPC_##Name: \
562 return true;
563 #include "clang/Basic/OpenMPKinds.def"
564 default:
565 break;
566 }
567 break;
568 case OMPD_ordered:
569 switch (CKind) {
570 #define OPENMP_ORDERED_CLAUSE(Name) \
571 case OMPC_##Name: \
572 return true;
573 #include "clang/Basic/OpenMPKinds.def"
574 default:
575 break;
576 }
577 break;
578 case OMPD_taskloop:
579 switch (CKind) {
580 #define OPENMP_TASKLOOP_CLAUSE(Name) \
581 case OMPC_##Name: \
582 return true;
583 #include "clang/Basic/OpenMPKinds.def"
584 default:
585 break;
586 }
587 break;
588 case OMPD_taskloop_simd:
589 switch (CKind) {
590 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name) \
591 case OMPC_##Name: \
592 return true;
593 #include "clang/Basic/OpenMPKinds.def"
594 default:
595 break;
596 }
597 break;
598 case OMPD_critical:
599 switch (CKind) {
600 #define OPENMP_CRITICAL_CLAUSE(Name) \
601 case OMPC_##Name: \
602 return true;
603 #include "clang/Basic/OpenMPKinds.def"
604 default:
605 break;
606 }
607 break;
608 case OMPD_distribute:
609 switch (CKind) {
610 #define OPENMP_DISTRIBUTE_CLAUSE(Name) \
611 case OMPC_##Name: \
612 return true;
613 #include "clang/Basic/OpenMPKinds.def"
614 default:
615 break;
616 }
617 break;
618 case OMPD_distribute_parallel_for:
619 switch (CKind) {
620 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
621 case OMPC_##Name: \
622 return true;
623 #include "clang/Basic/OpenMPKinds.def"
624 default:
625 break;
626 }
627 break;
628 case OMPD_distribute_parallel_for_simd:
629 switch (CKind) {
630 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
631 case OMPC_##Name: \
632 return true;
633 #include "clang/Basic/OpenMPKinds.def"
634 default:
635 break;
636 }
637 break;
638 case OMPD_distribute_simd:
639 switch (CKind) {
640 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) \
641 case OMPC_##Name: \
642 return true;
643 #include "clang/Basic/OpenMPKinds.def"
644 default:
645 break;
646 }
647 break;
648 case OMPD_target_parallel_for_simd:
649 switch (CKind) {
650 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name) \
651 case OMPC_##Name: \
652 return true;
653 #include "clang/Basic/OpenMPKinds.def"
654 default:
655 break;
656 }
657 break;
658 case OMPD_target_simd:
659 switch (CKind) {
660 #define OPENMP_TARGET_SIMD_CLAUSE(Name) \
661 case OMPC_##Name: \
662 return true;
663 #include "clang/Basic/OpenMPKinds.def"
664 default:
665 break;
666 }
667 break;
668 case OMPD_teams_distribute:
669 switch (CKind) {
670 #define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name) \
671 case OMPC_##Name: \
672 return true;
673 #include "clang/Basic/OpenMPKinds.def"
674 default:
675 break;
676 }
677 break;
678 case OMPD_teams_distribute_simd:
679 switch (CKind) {
680 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \
681 case OMPC_##Name: \
682 return true;
683 #include "clang/Basic/OpenMPKinds.def"
684 default:
685 break;
686 }
687 break;
688 case OMPD_teams_distribute_parallel_for_simd:
689 switch (CKind) {
690 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
691 case OMPC_##Name: \
692 return true;
693 #include "clang/Basic/OpenMPKinds.def"
694 default:
695 break;
696 }
697 break;
698 case OMPD_teams_distribute_parallel_for:
699 switch (CKind) {
700 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
701 case OMPC_##Name: \
702 return true;
703 #include "clang/Basic/OpenMPKinds.def"
704 default:
705 break;
706 }
707 break;
708 case OMPD_target_teams:
709 switch (CKind) {
710 #define OPENMP_TARGET_TEAMS_CLAUSE(Name) \
711 case OMPC_##Name: \
712 return true;
713 #include "clang/Basic/OpenMPKinds.def"
714 default:
715 break;
716 }
717 break;
718 case OMPD_target_teams_distribute:
719 switch (CKind) {
720 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name) \
721 case OMPC_##Name: \
722 return true;
723 #include "clang/Basic/OpenMPKinds.def"
724 default:
725 break;
726 }
727 break;
728 case OMPD_target_teams_distribute_parallel_for:
729 switch (CKind) {
730 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
731 case OMPC_##Name: \
732 return true;
733 #include "clang/Basic/OpenMPKinds.def"
734 default:
735 break;
736 }
737 break;
738 case OMPD_target_teams_distribute_parallel_for_simd:
739 switch (CKind) {
740 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
741 case OMPC_##Name: \
742 return true;
743 #include "clang/Basic/OpenMPKinds.def"
744 default:
745 break;
746 }
747 break;
748 case OMPD_target_teams_distribute_simd:
749 switch (CKind) {
750 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \
751 case OMPC_##Name: \
752 return true;
753 #include "clang/Basic/OpenMPKinds.def"
754 default:
755 break;
756 }
757 break;
758 case OMPD_taskgroup:
759 switch (CKind) {
760 #define OPENMP_TASKGROUP_CLAUSE(Name) \
761 case OMPC_##Name: \
762 return true;
763 #include "clang/Basic/OpenMPKinds.def"
764 default:
765 break;
766 }
767 break;
768 case OMPD_declare_target:
769 case OMPD_end_declare_target:
770 case OMPD_unknown:
771 case OMPD_threadprivate:
772 case OMPD_section:
773 case OMPD_master:
774 case OMPD_taskyield:
775 case OMPD_barrier:
776 case OMPD_taskwait:
777 case OMPD_cancellation_point:
778 case OMPD_declare_reduction:
779 break;
780 }
781 return false;
782 }
783
isOpenMPLoopDirective(OpenMPDirectiveKind DKind)784 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
785 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
786 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
787 DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
788 DKind == OMPD_distribute || DKind == OMPD_target_parallel_for ||
789 DKind == OMPD_distribute_parallel_for ||
790 DKind == OMPD_distribute_parallel_for_simd ||
791 DKind == OMPD_distribute_simd ||
792 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
793 DKind == OMPD_teams_distribute ||
794 DKind == OMPD_teams_distribute_simd ||
795 DKind == OMPD_teams_distribute_parallel_for_simd ||
796 DKind == OMPD_teams_distribute_parallel_for ||
797 DKind == OMPD_target_teams_distribute ||
798 DKind == OMPD_target_teams_distribute_parallel_for ||
799 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
800 DKind == OMPD_target_teams_distribute_simd;
801 }
802
isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind)803 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
804 return DKind == OMPD_for || DKind == OMPD_for_simd ||
805 DKind == OMPD_sections || DKind == OMPD_section ||
806 DKind == OMPD_single || DKind == OMPD_parallel_for ||
807 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
808 DKind == OMPD_target_parallel_for ||
809 DKind == OMPD_distribute_parallel_for ||
810 DKind == OMPD_distribute_parallel_for_simd ||
811 DKind == OMPD_target_parallel_for_simd ||
812 DKind == OMPD_teams_distribute_parallel_for_simd ||
813 DKind == OMPD_teams_distribute_parallel_for ||
814 DKind == OMPD_target_teams_distribute_parallel_for ||
815 DKind == OMPD_target_teams_distribute_parallel_for_simd;
816 }
817
isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind)818 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
819 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd;
820 }
821
isOpenMPParallelDirective(OpenMPDirectiveKind DKind)822 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
823 return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
824 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
825 DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for ||
826 DKind == OMPD_distribute_parallel_for ||
827 DKind == OMPD_distribute_parallel_for_simd ||
828 DKind == OMPD_target_parallel_for_simd ||
829 DKind == OMPD_teams_distribute_parallel_for ||
830 DKind == OMPD_teams_distribute_parallel_for_simd ||
831 DKind == OMPD_target_teams_distribute_parallel_for ||
832 DKind == OMPD_target_teams_distribute_parallel_for_simd;
833 }
834
isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind)835 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) {
836 return DKind == OMPD_target || DKind == OMPD_target_parallel ||
837 DKind == OMPD_target_parallel_for ||
838 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
839 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
840 DKind == OMPD_target_teams_distribute_parallel_for ||
841 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
842 DKind == OMPD_target_teams_distribute_simd;
843 }
844
isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind)845 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) {
846 return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
847 DKind == OMPD_target_exit_data || DKind == OMPD_target_update;
848 }
849
isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind)850 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) {
851 return DKind == OMPD_teams || DKind == OMPD_teams_distribute ||
852 DKind == OMPD_teams_distribute_simd ||
853 DKind == OMPD_teams_distribute_parallel_for_simd ||
854 DKind == OMPD_teams_distribute_parallel_for;
855 }
856
isOpenMPTeamsDirective(OpenMPDirectiveKind DKind)857 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
858 return isOpenMPNestingTeamsDirective(DKind) ||
859 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
860 DKind == OMPD_target_teams_distribute_parallel_for ||
861 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
862 DKind == OMPD_target_teams_distribute_simd;
863 }
864
isOpenMPSimdDirective(OpenMPDirectiveKind DKind)865 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
866 return DKind == OMPD_simd || DKind == OMPD_for_simd ||
867 DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd ||
868 DKind == OMPD_distribute_parallel_for_simd ||
869 DKind == OMPD_distribute_simd || DKind == OMPD_target_simd ||
870 DKind == OMPD_teams_distribute_simd ||
871 DKind == OMPD_teams_distribute_parallel_for_simd ||
872 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
873 DKind == OMPD_target_teams_distribute_simd ||
874 DKind == OMPD_target_parallel_for_simd;
875 }
876
isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind)877 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) {
878 return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for ||
879 Kind == OMPD_distribute_parallel_for_simd ||
880 Kind == OMPD_distribute_simd;
881 // TODO add next directives.
882 }
883
isOpenMPDistributeDirective(OpenMPDirectiveKind Kind)884 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) {
885 return isOpenMPNestingDistributeDirective(Kind) ||
886 Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd ||
887 Kind == OMPD_teams_distribute_parallel_for_simd ||
888 Kind == OMPD_teams_distribute_parallel_for ||
889 Kind == OMPD_target_teams_distribute ||
890 Kind == OMPD_target_teams_distribute_parallel_for ||
891 Kind == OMPD_target_teams_distribute_parallel_for_simd ||
892 Kind == OMPD_target_teams_distribute_simd;
893 }
894
isOpenMPPrivate(OpenMPClauseKind Kind)895 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
896 return Kind == OMPC_private || Kind == OMPC_firstprivate ||
897 Kind == OMPC_lastprivate || Kind == OMPC_linear ||
898 Kind == OMPC_reduction || Kind == OMPC_task_reduction ||
899 Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'.
900 }
901
isOpenMPThreadPrivate(OpenMPClauseKind Kind)902 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
903 return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
904 }
905
isOpenMPTaskingDirective(OpenMPDirectiveKind Kind)906 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) {
907 return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
908 }
909
isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind)910 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) {
911 return Kind == OMPD_distribute_parallel_for ||
912 Kind == OMPD_distribute_parallel_for_simd ||
913 Kind == OMPD_teams_distribute_parallel_for_simd ||
914 Kind == OMPD_teams_distribute_parallel_for ||
915 Kind == OMPD_target_teams_distribute_parallel_for ||
916 Kind == OMPD_target_teams_distribute_parallel_for_simd;
917 }
918
getOpenMPCaptureRegions(SmallVectorImpl<OpenMPDirectiveKind> & CaptureRegions,OpenMPDirectiveKind DKind)919 void clang::getOpenMPCaptureRegions(
920 SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions,
921 OpenMPDirectiveKind DKind) {
922 assert(DKind <= OMPD_unknown);
923 switch (DKind) {
924 case OMPD_parallel:
925 case OMPD_parallel_for:
926 case OMPD_parallel_for_simd:
927 case OMPD_parallel_sections:
928 case OMPD_distribute_parallel_for:
929 case OMPD_distribute_parallel_for_simd:
930 CaptureRegions.push_back(OMPD_parallel);
931 break;
932 case OMPD_target_teams:
933 case OMPD_target_teams_distribute:
934 case OMPD_target_teams_distribute_simd:
935 CaptureRegions.push_back(OMPD_task);
936 CaptureRegions.push_back(OMPD_target);
937 CaptureRegions.push_back(OMPD_teams);
938 break;
939 case OMPD_teams:
940 case OMPD_teams_distribute:
941 case OMPD_teams_distribute_simd:
942 CaptureRegions.push_back(OMPD_teams);
943 break;
944 case OMPD_target:
945 case OMPD_target_simd:
946 CaptureRegions.push_back(OMPD_task);
947 CaptureRegions.push_back(OMPD_target);
948 break;
949 case OMPD_teams_distribute_parallel_for:
950 case OMPD_teams_distribute_parallel_for_simd:
951 CaptureRegions.push_back(OMPD_teams);
952 CaptureRegions.push_back(OMPD_parallel);
953 break;
954 case OMPD_target_parallel:
955 case OMPD_target_parallel_for:
956 case OMPD_target_parallel_for_simd:
957 CaptureRegions.push_back(OMPD_task);
958 CaptureRegions.push_back(OMPD_target);
959 CaptureRegions.push_back(OMPD_parallel);
960 break;
961 case OMPD_task:
962 case OMPD_target_enter_data:
963 case OMPD_target_exit_data:
964 case OMPD_target_update:
965 CaptureRegions.push_back(OMPD_task);
966 break;
967 case OMPD_taskloop:
968 case OMPD_taskloop_simd:
969 CaptureRegions.push_back(OMPD_taskloop);
970 break;
971 case OMPD_target_teams_distribute_parallel_for:
972 case OMPD_target_teams_distribute_parallel_for_simd:
973 CaptureRegions.push_back(OMPD_task);
974 CaptureRegions.push_back(OMPD_target);
975 CaptureRegions.push_back(OMPD_teams);
976 CaptureRegions.push_back(OMPD_parallel);
977 break;
978 case OMPD_simd:
979 case OMPD_for:
980 case OMPD_for_simd:
981 case OMPD_sections:
982 case OMPD_section:
983 case OMPD_single:
984 case OMPD_master:
985 case OMPD_critical:
986 case OMPD_taskgroup:
987 case OMPD_distribute:
988 case OMPD_ordered:
989 case OMPD_atomic:
990 case OMPD_target_data:
991 case OMPD_distribute_simd:
992 CaptureRegions.push_back(OMPD_unknown);
993 break;
994 case OMPD_threadprivate:
995 case OMPD_taskyield:
996 case OMPD_barrier:
997 case OMPD_taskwait:
998 case OMPD_cancellation_point:
999 case OMPD_cancel:
1000 case OMPD_flush:
1001 case OMPD_declare_reduction:
1002 case OMPD_declare_simd:
1003 case OMPD_declare_target:
1004 case OMPD_end_declare_target:
1005 case OMPD_requires:
1006 llvm_unreachable("OpenMP Directive is not allowed");
1007 case OMPD_unknown:
1008 llvm_unreachable("Unknown OpenMP directive");
1009 }
1010 }
1011