clang  8.0.0
OpenMPKinds.cpp
Go to the documentation of this file.
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 
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 
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 
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 
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 
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 
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)
134  .Case(#Name, OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name)
135 #include "clang/Basic/OpenMPKinds.def"
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 
190  unsigned Type) {
191  switch (Kind) {
192  case OMPC_default:
193  switch (Type) {
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) {
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) {
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:
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) {
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) {
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) {
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 
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 
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 
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 
819  return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd;
820 }
821 
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 
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 
846  return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
847  DKind == OMPD_target_exit_data || DKind == OMPD_target_update;
848 }
849 
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 
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 
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 
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 
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 
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 
903  return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
904 }
905 
907  return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
908 }
909 
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 
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 }
#define OPENMP_MAP_KIND(Name)
bool isOpenMPNestingDistributeDirective(OpenMPDirectiveKind DKind)
Checks if the specified composite/combined directive constitutes a distribute directive in the outerm...
bool isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a target data offload directive.
The base class of the type hierarchy.
Definition: Type.h:1407
const char * getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, unsigned Type)
bool isAllowedClauseForDirective(OpenMPDirectiveKind DKind, OpenMPClauseKind CKind)
#define OPENMP_LINEAR_KIND(Name)
const char * getOpenMPClauseName(OpenMPClauseKind Kind)
Definition: OpenMPKinds.cpp:62
bool isOpenMPTaskingDirective(OpenMPDirectiveKind Kind)
Checks if the specified directive kind is one of tasking directives - task, taskloop or taksloop simd...
#define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name)
Defines some OpenMP-specific enums and functions.
bool isOpenMPTeamsDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a teams-kind directive.
OpenMPClauseKind getOpenMPClauseKind(llvm::StringRef Str)
bool isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a target code offload directive.
#define OPENMP_DEFAULTMAP_KIND(Name)
bool isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a worksharing directive.
#define OPENMP_CLAUSE(Name, Class)
#define OPENMP_PROC_BIND_KIND(Name)
bool isOpenMPPrivate(OpenMPClauseKind Kind)
Checks if the specified clause is one of private clauses like &#39;private&#39;, &#39;firstprivate&#39;, &#39;reduction&#39; etc.
bool isOpenMPParallelDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a parallel-kind directive.
#define OPENMP_DEPEND_KIND(Name)
OpenMPClauseKind
OpenMP clauses.
Definition: OpenMPKinds.h:33
#define OPENMP_DIRECTIVE(Name)
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
bool isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a taskloop directive.
Kind
OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:23
bool isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind)
Checks if the specified directive kind is one of the composite or combined directives that need loop ...
Dataflow Directional Tag Classes.
bool isOpenMPSimdDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a simd directive.
#define OPENMP_DEFAULT_KIND(Name)
bool isOpenMPThreadPrivate(OpenMPClauseKind Kind)
Checks if the specified clause is one of threadprivate clauses like &#39;threadprivate&#39;, &#39;copyin&#39; or &#39;copyprivate&#39;.
void getOpenMPCaptureRegions(llvm::SmallVectorImpl< OpenMPDirectiveKind > &CaptureRegions, OpenMPDirectiveKind DKind)
Return the captured regions of an OpenMP directive.
unsigned getOpenMPSimpleClauseType(OpenMPClauseKind Kind, llvm::StringRef Str)
bool isOpenMPDistributeDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a distribute directive.
OpenMPDirectiveKind getOpenMPDirectiveKind(llvm::StringRef Str)
const char * getOpenMPDirectiveName(OpenMPDirectiveKind Kind)
Definition: OpenMPKinds.cpp:31
#define OPENMP_SCHEDULE_KIND(Name)
bool isOpenMPLoopDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a directive with an associated loop construct.
#define OPENMP_DIST_SCHEDULE_KIND(Name)
bool isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind)
Checks if the specified composite/combined directive constitutes a teams directive in the outermost n...