clang  5.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 /// \brief 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<OpenMPMapClauseKind>(Str)
112 #define OPENMP_MAP_KIND(Name) .Case(#Name, OMPC_MAP_##Name)
113 #include "clang/Basic/OpenMPKinds.def"
114  .Default(OMPC_MAP_unknown);
115  case OMPC_dist_schedule:
116  return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str)
117 #define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name)
118 #include "clang/Basic/OpenMPKinds.def"
119  .Default(OMPC_DIST_SCHEDULE_unknown);
120  case OMPC_defaultmap:
121  return llvm::StringSwitch<unsigned>(Str)
122 #define OPENMP_DEFAULTMAP_KIND(Name) \
123  .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name))
124 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \
125  .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name))
126 #include "clang/Basic/OpenMPKinds.def"
127  .Default(OMPC_DEFAULTMAP_unknown);
128  case OMPC_unknown:
129  case OMPC_threadprivate:
130  case OMPC_if:
131  case OMPC_final:
132  case OMPC_num_threads:
133  case OMPC_safelen:
134  case OMPC_simdlen:
135  case OMPC_collapse:
136  case OMPC_private:
137  case OMPC_firstprivate:
138  case OMPC_lastprivate:
139  case OMPC_shared:
140  case OMPC_reduction:
141  case OMPC_task_reduction:
142  case OMPC_aligned:
143  case OMPC_copyin:
144  case OMPC_copyprivate:
145  case OMPC_ordered:
146  case OMPC_nowait:
147  case OMPC_untied:
148  case OMPC_mergeable:
149  case OMPC_flush:
150  case OMPC_read:
151  case OMPC_write:
152  case OMPC_update:
153  case OMPC_capture:
154  case OMPC_seq_cst:
155  case OMPC_device:
156  case OMPC_threads:
157  case OMPC_simd:
158  case OMPC_num_teams:
159  case OMPC_thread_limit:
160  case OMPC_priority:
161  case OMPC_grainsize:
162  case OMPC_nogroup:
163  case OMPC_num_tasks:
164  case OMPC_hint:
165  case OMPC_uniform:
166  case OMPC_to:
167  case OMPC_from:
168  case OMPC_use_device_ptr:
169  case OMPC_is_device_ptr:
170  break;
171  }
172  llvm_unreachable("Invalid OpenMP simple clause kind");
173 }
174 
176  unsigned Type) {
177  switch (Kind) {
178  case OMPC_default:
179  switch (Type) {
181  return "unknown";
182 #define OPENMP_DEFAULT_KIND(Name) \
183  case OMPC_DEFAULT_##Name: \
184  return #Name;
185 #include "clang/Basic/OpenMPKinds.def"
186  }
187  llvm_unreachable("Invalid OpenMP 'default' clause type");
188  case OMPC_proc_bind:
189  switch (Type) {
191  return "unknown";
192 #define OPENMP_PROC_BIND_KIND(Name) \
193  case OMPC_PROC_BIND_##Name: \
194  return #Name;
195 #include "clang/Basic/OpenMPKinds.def"
196  }
197  llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
198  case OMPC_schedule:
199  switch (Type) {
202  return "unknown";
203 #define OPENMP_SCHEDULE_KIND(Name) \
204  case OMPC_SCHEDULE_##Name: \
205  return #Name;
206 #define OPENMP_SCHEDULE_MODIFIER(Name) \
207  case OMPC_SCHEDULE_MODIFIER_##Name: \
208  return #Name;
209 #include "clang/Basic/OpenMPKinds.def"
210  }
211  llvm_unreachable("Invalid OpenMP 'schedule' clause type");
212  case OMPC_depend:
213  switch (Type) {
214  case OMPC_DEPEND_unknown:
215  return "unknown";
216 #define OPENMP_DEPEND_KIND(Name) \
217  case OMPC_DEPEND_##Name: \
218  return #Name;
219 #include "clang/Basic/OpenMPKinds.def"
220  }
221  llvm_unreachable("Invalid OpenMP 'depend' clause type");
222  case OMPC_linear:
223  switch (Type) {
224  case OMPC_LINEAR_unknown:
225  return "unknown";
226 #define OPENMP_LINEAR_KIND(Name) \
227  case OMPC_LINEAR_##Name: \
228  return #Name;
229 #include "clang/Basic/OpenMPKinds.def"
230  }
231  llvm_unreachable("Invalid OpenMP 'linear' clause type");
232  case OMPC_map:
233  switch (Type) {
234  case OMPC_MAP_unknown:
235  return "unknown";
236 #define OPENMP_MAP_KIND(Name) \
237  case OMPC_MAP_##Name: \
238  return #Name;
239 #include "clang/Basic/OpenMPKinds.def"
240  default:
241  break;
242  }
243  llvm_unreachable("Invalid OpenMP 'map' clause type");
244  case OMPC_dist_schedule:
245  switch (Type) {
247  return "unknown";
248 #define OPENMP_DIST_SCHEDULE_KIND(Name) \
249  case OMPC_DIST_SCHEDULE_##Name: \
250  return #Name;
251 #include "clang/Basic/OpenMPKinds.def"
252  }
253  llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type");
254  case OMPC_defaultmap:
255  switch (Type) {
258  return "unknown";
259 #define OPENMP_DEFAULTMAP_KIND(Name) \
260  case OMPC_DEFAULTMAP_##Name: \
261  return #Name;
262 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \
263  case OMPC_DEFAULTMAP_MODIFIER_##Name: \
264  return #Name;
265 #include "clang/Basic/OpenMPKinds.def"
266  }
267  llvm_unreachable("Invalid OpenMP 'schedule' clause type");
268  case OMPC_unknown:
269  case OMPC_threadprivate:
270  case OMPC_if:
271  case OMPC_final:
272  case OMPC_num_threads:
273  case OMPC_safelen:
274  case OMPC_simdlen:
275  case OMPC_collapse:
276  case OMPC_private:
277  case OMPC_firstprivate:
278  case OMPC_lastprivate:
279  case OMPC_shared:
280  case OMPC_reduction:
281  case OMPC_task_reduction:
282  case OMPC_aligned:
283  case OMPC_copyin:
284  case OMPC_copyprivate:
285  case OMPC_ordered:
286  case OMPC_nowait:
287  case OMPC_untied:
288  case OMPC_mergeable:
289  case OMPC_flush:
290  case OMPC_read:
291  case OMPC_write:
292  case OMPC_update:
293  case OMPC_capture:
294  case OMPC_seq_cst:
295  case OMPC_device:
296  case OMPC_threads:
297  case OMPC_simd:
298  case OMPC_num_teams:
299  case OMPC_thread_limit:
300  case OMPC_priority:
301  case OMPC_grainsize:
302  case OMPC_nogroup:
303  case OMPC_num_tasks:
304  case OMPC_hint:
305  case OMPC_uniform:
306  case OMPC_to:
307  case OMPC_from:
308  case OMPC_use_device_ptr:
309  case OMPC_is_device_ptr:
310  break;
311  }
312  llvm_unreachable("Invalid OpenMP simple clause kind");
313 }
314 
316  OpenMPClauseKind CKind) {
317  assert(DKind <= OMPD_unknown);
318  assert(CKind <= OMPC_unknown);
319  switch (DKind) {
320  case OMPD_parallel:
321  switch (CKind) {
322 #define OPENMP_PARALLEL_CLAUSE(Name) \
323  case OMPC_##Name: \
324  return true;
325 #include "clang/Basic/OpenMPKinds.def"
326  default:
327  break;
328  }
329  break;
330  case OMPD_simd:
331  switch (CKind) {
332 #define OPENMP_SIMD_CLAUSE(Name) \
333  case OMPC_##Name: \
334  return true;
335 #include "clang/Basic/OpenMPKinds.def"
336  default:
337  break;
338  }
339  break;
340  case OMPD_for:
341  switch (CKind) {
342 #define OPENMP_FOR_CLAUSE(Name) \
343  case OMPC_##Name: \
344  return true;
345 #include "clang/Basic/OpenMPKinds.def"
346  default:
347  break;
348  }
349  break;
350  case OMPD_for_simd:
351  switch (CKind) {
352 #define OPENMP_FOR_SIMD_CLAUSE(Name) \
353  case OMPC_##Name: \
354  return true;
355 #include "clang/Basic/OpenMPKinds.def"
356  default:
357  break;
358  }
359  break;
360  case OMPD_sections:
361  switch (CKind) {
362 #define OPENMP_SECTIONS_CLAUSE(Name) \
363  case OMPC_##Name: \
364  return true;
365 #include "clang/Basic/OpenMPKinds.def"
366  default:
367  break;
368  }
369  break;
370  case OMPD_single:
371  switch (CKind) {
372 #define OPENMP_SINGLE_CLAUSE(Name) \
373  case OMPC_##Name: \
374  return true;
375 #include "clang/Basic/OpenMPKinds.def"
376  default:
377  break;
378  }
379  break;
380  case OMPD_parallel_for:
381  switch (CKind) {
382 #define OPENMP_PARALLEL_FOR_CLAUSE(Name) \
383  case OMPC_##Name: \
384  return true;
385 #include "clang/Basic/OpenMPKinds.def"
386  default:
387  break;
388  }
389  break;
390  case OMPD_parallel_for_simd:
391  switch (CKind) {
392 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \
393  case OMPC_##Name: \
394  return true;
395 #include "clang/Basic/OpenMPKinds.def"
396  default:
397  break;
398  }
399  break;
400  case OMPD_parallel_sections:
401  switch (CKind) {
402 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) \
403  case OMPC_##Name: \
404  return true;
405 #include "clang/Basic/OpenMPKinds.def"
406  default:
407  break;
408  }
409  break;
410  case OMPD_task:
411  switch (CKind) {
412 #define OPENMP_TASK_CLAUSE(Name) \
413  case OMPC_##Name: \
414  return true;
415 #include "clang/Basic/OpenMPKinds.def"
416  default:
417  break;
418  }
419  break;
420  case OMPD_flush:
421  return CKind == OMPC_flush;
422  break;
423  case OMPD_atomic:
424  switch (CKind) {
425 #define OPENMP_ATOMIC_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_target:
434  switch (CKind) {
435 #define OPENMP_TARGET_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_target_data:
444  switch (CKind) {
445 #define OPENMP_TARGET_DATA_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_target_enter_data:
454  switch (CKind) {
455 #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name) \
456  case OMPC_##Name: \
457  return true;
458 #include "clang/Basic/OpenMPKinds.def"
459  default:
460  break;
461  }
462  break;
463  case OMPD_target_exit_data:
464  switch (CKind) {
465 #define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name) \
466  case OMPC_##Name: \
467  return true;
468 #include "clang/Basic/OpenMPKinds.def"
469  default:
470  break;
471  }
472  break;
473  case OMPD_target_parallel:
474  switch (CKind) {
475 #define OPENMP_TARGET_PARALLEL_CLAUSE(Name) \
476  case OMPC_##Name: \
477  return true;
478 #include "clang/Basic/OpenMPKinds.def"
479  default:
480  break;
481  }
482  break;
483  case OMPD_target_parallel_for:
484  switch (CKind) {
485 #define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name) \
486  case OMPC_##Name: \
487  return true;
488 #include "clang/Basic/OpenMPKinds.def"
489  default:
490  break;
491  }
492  break;
493  case OMPD_target_update:
494  switch (CKind) {
495 #define OPENMP_TARGET_UPDATE_CLAUSE(Name) \
496  case OMPC_##Name: \
497  return true;
498 #include "clang/Basic/OpenMPKinds.def"
499  default:
500  break;
501  }
502  break;
503  case OMPD_teams:
504  switch (CKind) {
505 #define OPENMP_TEAMS_CLAUSE(Name) \
506  case OMPC_##Name: \
507  return true;
508 #include "clang/Basic/OpenMPKinds.def"
509  default:
510  break;
511  }
512  break;
513  case OMPD_declare_simd:
514  break;
515  case OMPD_cancel:
516  switch (CKind) {
517 #define OPENMP_CANCEL_CLAUSE(Name) \
518  case OMPC_##Name: \
519  return true;
520 #include "clang/Basic/OpenMPKinds.def"
521  default:
522  break;
523  }
524  break;
525  case OMPD_ordered:
526  switch (CKind) {
527 #define OPENMP_ORDERED_CLAUSE(Name) \
528  case OMPC_##Name: \
529  return true;
530 #include "clang/Basic/OpenMPKinds.def"
531  default:
532  break;
533  }
534  break;
535  case OMPD_taskloop:
536  switch (CKind) {
537 #define OPENMP_TASKLOOP_CLAUSE(Name) \
538  case OMPC_##Name: \
539  return true;
540 #include "clang/Basic/OpenMPKinds.def"
541  default:
542  break;
543  }
544  break;
545  case OMPD_taskloop_simd:
546  switch (CKind) {
547 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name) \
548  case OMPC_##Name: \
549  return true;
550 #include "clang/Basic/OpenMPKinds.def"
551  default:
552  break;
553  }
554  break;
555  case OMPD_critical:
556  switch (CKind) {
557 #define OPENMP_CRITICAL_CLAUSE(Name) \
558  case OMPC_##Name: \
559  return true;
560 #include "clang/Basic/OpenMPKinds.def"
561  default:
562  break;
563  }
564  break;
565  case OMPD_distribute:
566  switch (CKind) {
567 #define OPENMP_DISTRIBUTE_CLAUSE(Name) \
568  case OMPC_##Name: \
569  return true;
570 #include "clang/Basic/OpenMPKinds.def"
571  default:
572  break;
573  }
574  break;
575  case OMPD_distribute_parallel_for:
576  switch (CKind) {
577 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
578  case OMPC_##Name: \
579  return true;
580 #include "clang/Basic/OpenMPKinds.def"
581  default:
582  break;
583  }
584  break;
585  case OMPD_distribute_parallel_for_simd:
586  switch (CKind) {
587 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
588  case OMPC_##Name: \
589  return true;
590 #include "clang/Basic/OpenMPKinds.def"
591  default:
592  break;
593  }
594  break;
595  case OMPD_distribute_simd:
596  switch (CKind) {
597 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) \
598  case OMPC_##Name: \
599  return true;
600 #include "clang/Basic/OpenMPKinds.def"
601  default:
602  break;
603  }
604  break;
605  case OMPD_target_parallel_for_simd:
606  switch (CKind) {
607 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name) \
608  case OMPC_##Name: \
609  return true;
610 #include "clang/Basic/OpenMPKinds.def"
611  default:
612  break;
613  }
614  break;
615  case OMPD_target_simd:
616  switch (CKind) {
617 #define OPENMP_TARGET_SIMD_CLAUSE(Name) \
618  case OMPC_##Name: \
619  return true;
620 #include "clang/Basic/OpenMPKinds.def"
621  default:
622  break;
623  }
624  break;
625  case OMPD_teams_distribute:
626  switch (CKind) {
627 #define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name) \
628  case OMPC_##Name: \
629  return true;
630 #include "clang/Basic/OpenMPKinds.def"
631  default:
632  break;
633  }
634  break;
635  case OMPD_teams_distribute_simd:
636  switch (CKind) {
637 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \
638  case OMPC_##Name: \
639  return true;
640 #include "clang/Basic/OpenMPKinds.def"
641  default:
642  break;
643  }
644  break;
645  case OMPD_teams_distribute_parallel_for_simd:
646  switch (CKind) {
647 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
648  case OMPC_##Name: \
649  return true;
650 #include "clang/Basic/OpenMPKinds.def"
651  default:
652  break;
653  }
654  break;
655  case OMPD_teams_distribute_parallel_for:
656  switch (CKind) {
657 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
658  case OMPC_##Name: \
659  return true;
660 #include "clang/Basic/OpenMPKinds.def"
661  default:
662  break;
663  }
664  break;
665  case OMPD_target_teams:
666  switch (CKind) {
667 #define OPENMP_TARGET_TEAMS_CLAUSE(Name) \
668  case OMPC_##Name: \
669  return true;
670 #include "clang/Basic/OpenMPKinds.def"
671  default:
672  break;
673  }
674  break;
675  case OMPD_target_teams_distribute:
676  switch (CKind) {
677 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name) \
678  case OMPC_##Name: \
679  return true;
680 #include "clang/Basic/OpenMPKinds.def"
681  default:
682  break;
683  }
684  break;
685  case OMPD_target_teams_distribute_parallel_for:
686  switch (CKind) {
687 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
688  case OMPC_##Name: \
689  return true;
690 #include "clang/Basic/OpenMPKinds.def"
691  default:
692  break;
693  }
694  break;
695  case OMPD_target_teams_distribute_parallel_for_simd:
696  switch (CKind) {
697 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
698  case OMPC_##Name: \
699  return true;
700 #include "clang/Basic/OpenMPKinds.def"
701  default:
702  break;
703  }
704  break;
705  case OMPD_target_teams_distribute_simd:
706  switch (CKind) {
707 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \
708  case OMPC_##Name: \
709  return true;
710 #include "clang/Basic/OpenMPKinds.def"
711  default:
712  break;
713  }
714  break;
715  case OMPD_taskgroup:
716  switch (CKind) {
717 #define OPENMP_TASKGROUP_CLAUSE(Name) \
718  case OMPC_##Name: \
719  return true;
720 #include "clang/Basic/OpenMPKinds.def"
721  default:
722  break;
723  }
724  break;
725  case OMPD_declare_target:
726  case OMPD_end_declare_target:
727  case OMPD_unknown:
728  case OMPD_threadprivate:
729  case OMPD_section:
730  case OMPD_master:
731  case OMPD_taskyield:
732  case OMPD_barrier:
733  case OMPD_taskwait:
734  case OMPD_cancellation_point:
735  case OMPD_declare_reduction:
736  break;
737  }
738  return false;
739 }
740 
742  return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
743  DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
744  DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
745  DKind == OMPD_distribute || DKind == OMPD_target_parallel_for ||
746  DKind == OMPD_distribute_parallel_for ||
747  DKind == OMPD_distribute_parallel_for_simd ||
748  DKind == OMPD_distribute_simd ||
749  DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
750  DKind == OMPD_teams_distribute ||
751  DKind == OMPD_teams_distribute_simd ||
752  DKind == OMPD_teams_distribute_parallel_for_simd ||
753  DKind == OMPD_teams_distribute_parallel_for ||
754  DKind == OMPD_target_teams_distribute ||
755  DKind == OMPD_target_teams_distribute_parallel_for ||
756  DKind == OMPD_target_teams_distribute_parallel_for_simd ||
757  DKind == OMPD_target_teams_distribute_simd;
758 }
759 
761  return DKind == OMPD_for || DKind == OMPD_for_simd ||
762  DKind == OMPD_sections || DKind == OMPD_section ||
763  DKind == OMPD_single || DKind == OMPD_parallel_for ||
764  DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
765  DKind == OMPD_target_parallel_for ||
766  DKind == OMPD_distribute_parallel_for ||
767  DKind == OMPD_distribute_parallel_for_simd ||
768  DKind == OMPD_target_parallel_for_simd ||
769  DKind == OMPD_teams_distribute_parallel_for_simd ||
770  DKind == OMPD_teams_distribute_parallel_for ||
771  DKind == OMPD_target_teams_distribute_parallel_for ||
772  DKind == OMPD_target_teams_distribute_parallel_for_simd;
773 }
774 
776  return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd;
777 }
778 
780  return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
781  DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
782  DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for ||
783  DKind == OMPD_distribute_parallel_for ||
784  DKind == OMPD_distribute_parallel_for_simd ||
785  DKind == OMPD_target_parallel_for_simd ||
786  DKind == OMPD_teams_distribute_parallel_for ||
787  DKind == OMPD_teams_distribute_parallel_for_simd ||
788  DKind == OMPD_target_teams_distribute_parallel_for ||
789  DKind == OMPD_target_teams_distribute_parallel_for_simd;
790 }
791 
793  return DKind == OMPD_target || DKind == OMPD_target_parallel ||
794  DKind == OMPD_target_parallel_for ||
795  DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
796  DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
797  DKind == OMPD_target_teams_distribute_parallel_for ||
798  DKind == OMPD_target_teams_distribute_parallel_for_simd ||
799  DKind == OMPD_target_teams_distribute_simd;
800 }
801 
803  return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
804  DKind == OMPD_target_exit_data || DKind == OMPD_target_update;
805 }
806 
808  return DKind == OMPD_teams || DKind == OMPD_teams_distribute ||
809  DKind == OMPD_teams_distribute_simd ||
810  DKind == OMPD_teams_distribute_parallel_for_simd ||
811  DKind == OMPD_teams_distribute_parallel_for;
812 }
813 
815  return isOpenMPNestingTeamsDirective(DKind) ||
816  DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
817  DKind == OMPD_target_teams_distribute_parallel_for ||
818  DKind == OMPD_target_teams_distribute_parallel_for_simd ||
819  DKind == OMPD_target_teams_distribute_simd;
820 }
821 
823  return DKind == OMPD_simd || DKind == OMPD_for_simd ||
824  DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd ||
825  DKind == OMPD_distribute_parallel_for_simd ||
826  DKind == OMPD_distribute_simd || DKind == OMPD_target_simd ||
827  DKind == OMPD_teams_distribute_simd ||
828  DKind == OMPD_teams_distribute_parallel_for_simd ||
829  DKind == OMPD_target_teams_distribute_parallel_for_simd ||
830  DKind == OMPD_target_teams_distribute_simd;
831 }
832 
834  return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for ||
835  Kind == OMPD_distribute_parallel_for_simd ||
836  Kind == OMPD_distribute_simd;
837  // TODO add next directives.
838 }
839 
841  return isOpenMPNestingDistributeDirective(Kind) ||
842  Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd ||
843  Kind == OMPD_teams_distribute_parallel_for_simd ||
844  Kind == OMPD_teams_distribute_parallel_for ||
845  Kind == OMPD_target_teams_distribute ||
846  Kind == OMPD_target_teams_distribute_parallel_for ||
847  Kind == OMPD_target_teams_distribute_parallel_for_simd ||
848  Kind == OMPD_target_teams_distribute_simd;
849 }
850 
852  return Kind == OMPC_private || Kind == OMPC_firstprivate ||
853  Kind == OMPC_lastprivate || Kind == OMPC_linear ||
854  Kind == OMPC_reduction ||
855  Kind == OMPC_task_reduction; // TODO add next clauses like 'reduction'.
856 }
857 
859  return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
860 }
861 
863  return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
864 }
865 
867  return Kind == OMPD_distribute_parallel_for ||
868  Kind == OMPD_distribute_parallel_for_simd ||
869  Kind == OMPD_teams_distribute_parallel_for_simd ||
870  Kind == OMPD_teams_distribute_parallel_for ||
871  Kind == OMPD_target_teams_distribute_parallel_for ||
872  Kind == OMPD_target_teams_distribute_parallel_for_simd;
873 }
874 
876  SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions,
877  OpenMPDirectiveKind DKind) {
878  assert(DKind <= OMPD_unknown);
879  switch (DKind) {
880  case OMPD_parallel:
881  case OMPD_parallel_for:
882  case OMPD_parallel_for_simd:
883  case OMPD_parallel_sections:
884  case OMPD_distribute_parallel_for:
885  CaptureRegions.push_back(OMPD_parallel);
886  break;
887  case OMPD_target_teams:
888  CaptureRegions.push_back(OMPD_target);
889  CaptureRegions.push_back(OMPD_teams);
890  break;
891  case OMPD_teams:
892  case OMPD_simd:
893  case OMPD_for:
894  case OMPD_for_simd:
895  case OMPD_sections:
896  case OMPD_section:
897  case OMPD_single:
898  case OMPD_master:
899  case OMPD_critical:
900  case OMPD_taskgroup:
901  case OMPD_distribute:
902  case OMPD_ordered:
903  case OMPD_atomic:
904  case OMPD_target_data:
905  case OMPD_target:
906  case OMPD_target_parallel_for:
907  case OMPD_target_parallel_for_simd:
908  case OMPD_target_simd:
909  case OMPD_task:
910  case OMPD_taskloop:
911  case OMPD_taskloop_simd:
912  case OMPD_distribute_parallel_for_simd:
913  case OMPD_distribute_simd:
914  case OMPD_teams_distribute:
915  case OMPD_teams_distribute_simd:
916  case OMPD_teams_distribute_parallel_for_simd:
917  case OMPD_teams_distribute_parallel_for:
918  case OMPD_target_teams_distribute:
919  case OMPD_target_teams_distribute_parallel_for:
920  case OMPD_target_teams_distribute_parallel_for_simd:
921  case OMPD_target_teams_distribute_simd:
922  CaptureRegions.push_back(DKind);
923  break;
924  case OMPD_target_parallel:
925  CaptureRegions.push_back(OMPD_target);
926  CaptureRegions.push_back(OMPD_parallel);
927  break;
928  case OMPD_threadprivate:
929  case OMPD_taskyield:
930  case OMPD_barrier:
931  case OMPD_taskwait:
932  case OMPD_cancellation_point:
933  case OMPD_cancel:
934  case OMPD_flush:
935  case OMPD_target_enter_data:
936  case OMPD_target_exit_data:
937  case OMPD_declare_reduction:
938  case OMPD_declare_simd:
939  case OMPD_declare_target:
940  case OMPD_end_declare_target:
941  case OMPD_target_update:
942  llvm_unreachable("OpenMP Directive is not allowed");
943  case OMPD_unknown:
944  llvm_unreachable("Unknown OpenMP directive");
945  }
946 }
#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:1303
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...
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 'private', 'firstprivate', 'reduction' 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 ...
StringRef Name
Definition: USRFinder.cpp:123
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 'threadprivate', 'copyin' or 'copyprivate'.
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...