clang  10.0.0git
OpenMPKinds.cpp
Go to the documentation of this file.
1 //===--- OpenMPKinds.cpp - Token Kinds Support ----------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 /// \file
9 /// This file implements the OpenMP enum and support functions.
10 ///
11 //===----------------------------------------------------------------------===//
12 
15 #include "llvm/ADT/StringRef.h"
16 #include "llvm/ADT/StringSwitch.h"
17 #include "llvm/Support/ErrorHandling.h"
18 #include <cassert>
19 
20 using namespace clang;
21 using namespace llvm::omp;
22 
24 clang::getOpenMPContextSelectorSet(llvm::StringRef Str) {
25  return llvm::StringSwitch<OpenMPContextSelectorSetKind>(Str)
26 #define OPENMP_CONTEXT_SELECTOR_SET(Name) .Case(#Name, OMP_CTX_SET_##Name)
27 #include "clang/Basic/OpenMPKinds.def"
28  .Default(OMP_CTX_SET_unknown);
29 }
30 
31 llvm::StringRef
33  switch (Kind) {
35  return "unknown";
36 #define OPENMP_CONTEXT_SELECTOR_SET(Name) \
37  case OMP_CTX_SET_##Name: \
38  return #Name;
39 #include "clang/Basic/OpenMPKinds.def"
40  break;
41  }
42  llvm_unreachable("Invalid OpenMP context selector set kind");
43 }
44 
46  return llvm::StringSwitch<OpenMPContextSelectorKind>(Str)
47 #define OPENMP_CONTEXT_SELECTOR(Name) .Case(#Name, OMP_CTX_##Name)
48 #include "clang/Basic/OpenMPKinds.def"
49  .Default(OMP_CTX_unknown);
50 }
51 
52 llvm::StringRef
54  switch (Kind) {
55  case OMP_CTX_unknown:
56  return "unknown";
57 #define OPENMP_CONTEXT_SELECTOR(Name) \
58  case OMP_CTX_##Name: \
59  return #Name;
60 #include "clang/Basic/OpenMPKinds.def"
61  break;
62  }
63  llvm_unreachable("Invalid OpenMP context selector kind");
64 }
65 
67  // 'flush' clause cannot be specified explicitly, because this is an implicit
68  // clause for 'flush' directive. If the 'flush' clause is explicitly specified
69  // the Parser should generate a warning about extra tokens at the end of the
70  // directive.
71  if (Str == "flush")
72  return OMPC_unknown;
73  return llvm::StringSwitch<OpenMPClauseKind>(Str)
74 #define OPENMP_CLAUSE(Name, Class) .Case(#Name, OMPC_##Name)
75 #include "clang/Basic/OpenMPKinds.def"
76  .Case("uniform", OMPC_uniform)
77  .Case("device_type", OMPC_device_type)
78  .Case("match", OMPC_match)
79  .Default(OMPC_unknown);
80 }
81 
83  assert(Kind <= OMPC_unknown);
84  switch (Kind) {
85  case OMPC_unknown:
86  return "unknown";
87 #define OPENMP_CLAUSE(Name, Class) \
88  case OMPC_##Name: \
89  return #Name;
90 #include "clang/Basic/OpenMPKinds.def"
91  case OMPC_uniform:
92  return "uniform";
93  case OMPC_threadprivate:
94  return "threadprivate or thread local";
95  case OMPC_device_type:
96  return "device_type";
97  case OMPC_match:
98  return "match";
99  }
100  llvm_unreachable("Invalid OpenMP clause kind");
101 }
102 
104  StringRef Str) {
105  switch (Kind) {
106  case OMPC_default:
107  return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str)
108 #define OPENMP_DEFAULT_KIND(Name) .Case(#Name, OMPC_DEFAULT_##Name)
109 #include "clang/Basic/OpenMPKinds.def"
110  .Default(OMPC_DEFAULT_unknown);
111  case OMPC_proc_bind:
112  return llvm::StringSwitch<unsigned>(Str)
113 #define OMP_PROC_BIND_KIND(Enum, Name, Value) .Case(Name, Value)
114 #include "llvm/Frontend/OpenMP/OMPKinds.def"
115  .Default(unsigned(llvm::omp::OMP_PROC_BIND_unknown));
116  case OMPC_schedule:
117  return llvm::StringSwitch<unsigned>(Str)
118 #define OPENMP_SCHEDULE_KIND(Name) \
119  .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name))
120 #define OPENMP_SCHEDULE_MODIFIER(Name) \
121  .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name))
122 #include "clang/Basic/OpenMPKinds.def"
123  .Default(OMPC_SCHEDULE_unknown);
124  case OMPC_depend:
125  return llvm::StringSwitch<OpenMPDependClauseKind>(Str)
126 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name)
127 #include "clang/Basic/OpenMPKinds.def"
128  .Default(OMPC_DEPEND_unknown);
129  case OMPC_linear:
130  return llvm::StringSwitch<OpenMPLinearClauseKind>(Str)
131 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name)
132 #include "clang/Basic/OpenMPKinds.def"
133  .Default(OMPC_LINEAR_unknown);
134  case OMPC_map:
135  return llvm::StringSwitch<unsigned>(Str)
136 #define OPENMP_MAP_KIND(Name) \
137  .Case(#Name, static_cast<unsigned>(OMPC_MAP_##Name))
138 #define OPENMP_MAP_MODIFIER_KIND(Name) \
139  .Case(#Name, static_cast<unsigned>(OMPC_MAP_MODIFIER_##Name))
140 #include "clang/Basic/OpenMPKinds.def"
141  .Default(OMPC_MAP_unknown);
142  case OMPC_to:
143  return llvm::StringSwitch<unsigned>(Str)
144 #define OPENMP_TO_MODIFIER_KIND(Name) \
145  .Case(#Name, static_cast<unsigned>(OMPC_TO_MODIFIER_##Name))
146 #include "clang/Basic/OpenMPKinds.def"
147  .Default(OMPC_TO_MODIFIER_unknown);
148  case OMPC_from:
149  return llvm::StringSwitch<unsigned>(Str)
150 #define OPENMP_FROM_MODIFIER_KIND(Name) \
151  .Case(#Name, static_cast<unsigned>(OMPC_FROM_MODIFIER_##Name))
152 #include "clang/Basic/OpenMPKinds.def"
153  .Default(OMPC_FROM_MODIFIER_unknown);
154  case OMPC_dist_schedule:
155  return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str)
156 #define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name)
157 #include "clang/Basic/OpenMPKinds.def"
158  .Default(OMPC_DIST_SCHEDULE_unknown);
159  case OMPC_defaultmap:
160  return llvm::StringSwitch<unsigned>(Str)
161 #define OPENMP_DEFAULTMAP_KIND(Name) \
162  .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name))
163 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \
164  .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name))
165 #include "clang/Basic/OpenMPKinds.def"
166  .Default(OMPC_DEFAULTMAP_unknown);
167  case OMPC_atomic_default_mem_order:
168  return llvm::StringSwitch<OpenMPAtomicDefaultMemOrderClauseKind>(Str)
170  .Case(#Name, OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name)
171 #include "clang/Basic/OpenMPKinds.def"
173  case OMPC_device_type:
174  return llvm::StringSwitch<OpenMPDeviceType>(Str)
175 #define OPENMP_DEVICE_TYPE_KIND(Name) .Case(#Name, OMPC_DEVICE_TYPE_##Name)
176 #include "clang/Basic/OpenMPKinds.def"
177  .Default(OMPC_DEVICE_TYPE_unknown);
178  case OMPC_lastprivate:
179  return llvm::StringSwitch<OpenMPLastprivateModifier>(Str)
180 #define OPENMP_LASTPRIVATE_KIND(Name) .Case(#Name, OMPC_LASTPRIVATE_##Name)
181 #include "clang/Basic/OpenMPKinds.def"
182  .Default(OMPC_LASTPRIVATE_unknown);
183  case OMPC_unknown:
184  case OMPC_threadprivate:
185  case OMPC_if:
186  case OMPC_final:
187  case OMPC_num_threads:
188  case OMPC_safelen:
189  case OMPC_simdlen:
190  case OMPC_allocator:
191  case OMPC_allocate:
192  case OMPC_collapse:
193  case OMPC_private:
194  case OMPC_firstprivate:
195  case OMPC_shared:
196  case OMPC_reduction:
197  case OMPC_task_reduction:
198  case OMPC_in_reduction:
199  case OMPC_aligned:
200  case OMPC_copyin:
201  case OMPC_copyprivate:
202  case OMPC_ordered:
203  case OMPC_nowait:
204  case OMPC_untied:
205  case OMPC_mergeable:
206  case OMPC_flush:
207  case OMPC_read:
208  case OMPC_write:
209  case OMPC_update:
210  case OMPC_capture:
211  case OMPC_seq_cst:
212  case OMPC_device:
213  case OMPC_threads:
214  case OMPC_simd:
215  case OMPC_num_teams:
216  case OMPC_thread_limit:
217  case OMPC_priority:
218  case OMPC_grainsize:
219  case OMPC_nogroup:
220  case OMPC_num_tasks:
221  case OMPC_hint:
222  case OMPC_uniform:
223  case OMPC_use_device_ptr:
224  case OMPC_is_device_ptr:
225  case OMPC_unified_address:
226  case OMPC_unified_shared_memory:
227  case OMPC_reverse_offload:
228  case OMPC_dynamic_allocators:
229  case OMPC_match:
230  case OMPC_nontemporal:
231  break;
232  }
233  llvm_unreachable("Invalid OpenMP simple clause kind");
234 }
235 
237  unsigned Type) {
238  switch (Kind) {
239  case OMPC_default:
240  switch (Type) {
242  return "unknown";
243 #define OPENMP_DEFAULT_KIND(Name) \
244  case OMPC_DEFAULT_##Name: \
245  return #Name;
246 #include "clang/Basic/OpenMPKinds.def"
247  }
248  llvm_unreachable("Invalid OpenMP 'default' clause type");
249  case OMPC_proc_bind:
250  switch (Type) {
251 #define OMP_PROC_BIND_KIND(Enum, Name, Value) \
252  case Value: \
253  return Name;
254 #include "llvm/Frontend/OpenMP/OMPKinds.def"
255  }
256  llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
257  case OMPC_schedule:
258  switch (Type) {
261  return "unknown";
262 #define OPENMP_SCHEDULE_KIND(Name) \
263  case OMPC_SCHEDULE_##Name: \
264  return #Name;
265 #define OPENMP_SCHEDULE_MODIFIER(Name) \
266  case OMPC_SCHEDULE_MODIFIER_##Name: \
267  return #Name;
268 #include "clang/Basic/OpenMPKinds.def"
269  }
270  llvm_unreachable("Invalid OpenMP 'schedule' clause type");
271  case OMPC_depend:
272  switch (Type) {
273  case OMPC_DEPEND_unknown:
274  return "unknown";
275 #define OPENMP_DEPEND_KIND(Name) \
276  case OMPC_DEPEND_##Name: \
277  return #Name;
278 #include "clang/Basic/OpenMPKinds.def"
279  }
280  llvm_unreachable("Invalid OpenMP 'depend' clause type");
281  case OMPC_linear:
282  switch (Type) {
283  case OMPC_LINEAR_unknown:
284  return "unknown";
285 #define OPENMP_LINEAR_KIND(Name) \
286  case OMPC_LINEAR_##Name: \
287  return #Name;
288 #include "clang/Basic/OpenMPKinds.def"
289  }
290  llvm_unreachable("Invalid OpenMP 'linear' clause type");
291  case OMPC_map:
292  switch (Type) {
293  case OMPC_MAP_unknown:
295  return "unknown";
296 #define OPENMP_MAP_KIND(Name) \
297  case OMPC_MAP_##Name: \
298  return #Name;
299 #define OPENMP_MAP_MODIFIER_KIND(Name) \
300  case OMPC_MAP_MODIFIER_##Name: \
301  return #Name;
302 #include "clang/Basic/OpenMPKinds.def"
303  default:
304  break;
305  }
306  llvm_unreachable("Invalid OpenMP 'map' clause type");
307  case OMPC_to:
308  switch (Type) {
310  return "unknown";
311 #define OPENMP_TO_MODIFIER_KIND(Name) \
312  case OMPC_TO_MODIFIER_##Name: \
313  return #Name;
314 #include "clang/Basic/OpenMPKinds.def"
315  default:
316  break;
317  }
318  llvm_unreachable("Invalid OpenMP 'to' clause type");
319  case OMPC_from:
320  switch (Type) {
322  return "unknown";
323 #define OPENMP_FROM_MODIFIER_KIND(Name) \
324  case OMPC_FROM_MODIFIER_##Name: \
325  return #Name;
326 #include "clang/Basic/OpenMPKinds.def"
327  default:
328  break;
329  }
330  llvm_unreachable("Invalid OpenMP 'from' clause type");
331  case OMPC_dist_schedule:
332  switch (Type) {
334  return "unknown";
335 #define OPENMP_DIST_SCHEDULE_KIND(Name) \
336  case OMPC_DIST_SCHEDULE_##Name: \
337  return #Name;
338 #include "clang/Basic/OpenMPKinds.def"
339  }
340  llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type");
341  case OMPC_defaultmap:
342  switch (Type) {
345  return "unknown";
346 #define OPENMP_DEFAULTMAP_KIND(Name) \
347  case OMPC_DEFAULTMAP_##Name: \
348  return #Name;
349 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \
350  case OMPC_DEFAULTMAP_MODIFIER_##Name: \
351  return #Name;
352 #include "clang/Basic/OpenMPKinds.def"
353  }
354  llvm_unreachable("Invalid OpenMP 'schedule' clause type");
355  case OMPC_atomic_default_mem_order:
356  switch (Type) {
358  return "unknown";
359 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \
360  case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name: \
361  return #Name;
362 #include "clang/Basic/OpenMPKinds.def"
363 }
364  llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type");
365  case OMPC_device_type:
366  switch (Type) {
368  return "unknown";
369 #define OPENMP_DEVICE_TYPE_KIND(Name) \
370  case OMPC_DEVICE_TYPE_##Name: \
371  return #Name;
372 #include "clang/Basic/OpenMPKinds.def"
373  }
374  llvm_unreachable("Invalid OpenMP 'device_type' clause type");
375  case OMPC_lastprivate:
376  switch (Type) {
378  return "unknown";
379 #define OPENMP_LASTPRIVATE_KIND(Name) \
380  case OMPC_LASTPRIVATE_##Name: \
381  return #Name;
382 #include "clang/Basic/OpenMPKinds.def"
383  }
384  llvm_unreachable("Invalid OpenMP 'lastprivate' clause type");
385  case OMPC_unknown:
386  case OMPC_threadprivate:
387  case OMPC_if:
388  case OMPC_final:
389  case OMPC_num_threads:
390  case OMPC_safelen:
391  case OMPC_simdlen:
392  case OMPC_allocator:
393  case OMPC_allocate:
394  case OMPC_collapse:
395  case OMPC_private:
396  case OMPC_firstprivate:
397  case OMPC_shared:
398  case OMPC_reduction:
399  case OMPC_task_reduction:
400  case OMPC_in_reduction:
401  case OMPC_aligned:
402  case OMPC_copyin:
403  case OMPC_copyprivate:
404  case OMPC_ordered:
405  case OMPC_nowait:
406  case OMPC_untied:
407  case OMPC_mergeable:
408  case OMPC_flush:
409  case OMPC_read:
410  case OMPC_write:
411  case OMPC_update:
412  case OMPC_capture:
413  case OMPC_seq_cst:
414  case OMPC_device:
415  case OMPC_threads:
416  case OMPC_simd:
417  case OMPC_num_teams:
418  case OMPC_thread_limit:
419  case OMPC_priority:
420  case OMPC_grainsize:
421  case OMPC_nogroup:
422  case OMPC_num_tasks:
423  case OMPC_hint:
424  case OMPC_uniform:
425  case OMPC_use_device_ptr:
426  case OMPC_is_device_ptr:
427  case OMPC_unified_address:
428  case OMPC_unified_shared_memory:
429  case OMPC_reverse_offload:
430  case OMPC_dynamic_allocators:
431  case OMPC_match:
432  case OMPC_nontemporal:
433  break;
434  }
435  llvm_unreachable("Invalid OpenMP simple clause kind");
436 }
437 
439  OpenMPClauseKind CKind,
440  unsigned OpenMPVersion) {
441  assert(unsigned(DKind) <= unsigned(OMPD_unknown));
442  assert(CKind <= OMPC_unknown);
443  // Nontemporal clause is not supported in OpenMP < 5.0.
444  if (OpenMPVersion < 50 && CKind == OMPC_nontemporal)
445  return false;
446  switch (DKind) {
447  case OMPD_parallel:
448  switch (CKind) {
449 #define OPENMP_PARALLEL_CLAUSE(Name) \
450  case OMPC_##Name: \
451  return true;
452 #include "clang/Basic/OpenMPKinds.def"
453  default:
454  break;
455  }
456  break;
457  case OMPD_simd:
458  if (OpenMPVersion < 50 && CKind == OMPC_if)
459  return false;
460  switch (CKind) {
461 #define OPENMP_SIMD_CLAUSE(Name) \
462  case OMPC_##Name: \
463  return true;
464 #include "clang/Basic/OpenMPKinds.def"
465  default:
466  break;
467  }
468  break;
469  case OMPD_for:
470  switch (CKind) {
471 #define OPENMP_FOR_CLAUSE(Name) \
472  case OMPC_##Name: \
473  return true;
474 #include "clang/Basic/OpenMPKinds.def"
475  default:
476  break;
477  }
478  break;
479  case OMPD_for_simd:
480  if (OpenMPVersion < 50 && CKind == OMPC_if)
481  return false;
482  switch (CKind) {
483 #define OPENMP_FOR_SIMD_CLAUSE(Name) \
484  case OMPC_##Name: \
485  return true;
486 #include "clang/Basic/OpenMPKinds.def"
487  default:
488  break;
489  }
490  break;
491  case OMPD_sections:
492  switch (CKind) {
493 #define OPENMP_SECTIONS_CLAUSE(Name) \
494  case OMPC_##Name: \
495  return true;
496 #include "clang/Basic/OpenMPKinds.def"
497  default:
498  break;
499  }
500  break;
501  case OMPD_single:
502  switch (CKind) {
503 #define OPENMP_SINGLE_CLAUSE(Name) \
504  case OMPC_##Name: \
505  return true;
506 #include "clang/Basic/OpenMPKinds.def"
507  default:
508  break;
509  }
510  break;
511  case OMPD_parallel_for:
512  switch (CKind) {
513 #define OPENMP_PARALLEL_FOR_CLAUSE(Name) \
514  case OMPC_##Name: \
515  return true;
516 #include "clang/Basic/OpenMPKinds.def"
517  default:
518  break;
519  }
520  break;
521  case OMPD_parallel_for_simd:
522  switch (CKind) {
523 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \
524  case OMPC_##Name: \
525  return true;
526 #include "clang/Basic/OpenMPKinds.def"
527  default:
528  break;
529  }
530  break;
531  case OMPD_parallel_master:
532  switch (CKind) {
533 #define OPENMP_PARALLEL_MASTER_CLAUSE(Name) \
534  case OMPC_##Name: \
535  return true;
536 #include "clang/Basic/OpenMPKinds.def"
537  default:
538  break;
539  }
540  break;
541  case OMPD_parallel_sections:
542  switch (CKind) {
543 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) \
544  case OMPC_##Name: \
545  return true;
546 #include "clang/Basic/OpenMPKinds.def"
547  default:
548  break;
549  }
550  break;
551  case OMPD_task:
552  switch (CKind) {
553 #define OPENMP_TASK_CLAUSE(Name) \
554  case OMPC_##Name: \
555  return true;
556 #include "clang/Basic/OpenMPKinds.def"
557  default:
558  break;
559  }
560  break;
561  case OMPD_flush:
562  return CKind == OMPC_flush;
563  break;
564  case OMPD_atomic:
565  switch (CKind) {
566 #define OPENMP_ATOMIC_CLAUSE(Name) \
567  case OMPC_##Name: \
568  return true;
569 #include "clang/Basic/OpenMPKinds.def"
570  default:
571  break;
572  }
573  break;
574  case OMPD_target:
575  switch (CKind) {
576 #define OPENMP_TARGET_CLAUSE(Name) \
577  case OMPC_##Name: \
578  return true;
579 #include "clang/Basic/OpenMPKinds.def"
580  default:
581  break;
582  }
583  break;
584  case OMPD_requires:
585  switch (CKind) {
586 #define OPENMP_REQUIRES_CLAUSE(Name) \
587  case OMPC_##Name: \
588  return true;
589 #include "clang/Basic/OpenMPKinds.def"
590  default:
591  break;
592  }
593  break;
594  case OMPD_target_data:
595  switch (CKind) {
596 #define OPENMP_TARGET_DATA_CLAUSE(Name) \
597  case OMPC_##Name: \
598  return true;
599 #include "clang/Basic/OpenMPKinds.def"
600  default:
601  break;
602  }
603  break;
604  case OMPD_target_enter_data:
605  switch (CKind) {
606 #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name) \
607  case OMPC_##Name: \
608  return true;
609 #include "clang/Basic/OpenMPKinds.def"
610  default:
611  break;
612  }
613  break;
614  case OMPD_target_exit_data:
615  switch (CKind) {
616 #define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name) \
617  case OMPC_##Name: \
618  return true;
619 #include "clang/Basic/OpenMPKinds.def"
620  default:
621  break;
622  }
623  break;
624  case OMPD_target_parallel:
625  switch (CKind) {
626 #define OPENMP_TARGET_PARALLEL_CLAUSE(Name) \
627  case OMPC_##Name: \
628  return true;
629 #include "clang/Basic/OpenMPKinds.def"
630  default:
631  break;
632  }
633  break;
634  case OMPD_target_parallel_for:
635  switch (CKind) {
636 #define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name) \
637  case OMPC_##Name: \
638  return true;
639 #include "clang/Basic/OpenMPKinds.def"
640  default:
641  break;
642  }
643  break;
644  case OMPD_target_update:
645  switch (CKind) {
646 #define OPENMP_TARGET_UPDATE_CLAUSE(Name) \
647  case OMPC_##Name: \
648  return true;
649 #include "clang/Basic/OpenMPKinds.def"
650  default:
651  break;
652  }
653  break;
654  case OMPD_teams:
655  switch (CKind) {
656 #define OPENMP_TEAMS_CLAUSE(Name) \
657  case OMPC_##Name: \
658  return true;
659 #include "clang/Basic/OpenMPKinds.def"
660  default:
661  break;
662  }
663  break;
664  case OMPD_cancel:
665  switch (CKind) {
666 #define OPENMP_CANCEL_CLAUSE(Name) \
667  case OMPC_##Name: \
668  return true;
669 #include "clang/Basic/OpenMPKinds.def"
670  default:
671  break;
672  }
673  break;
674  case OMPD_ordered:
675  switch (CKind) {
676 #define OPENMP_ORDERED_CLAUSE(Name) \
677  case OMPC_##Name: \
678  return true;
679 #include "clang/Basic/OpenMPKinds.def"
680  default:
681  break;
682  }
683  break;
684  case OMPD_taskloop:
685  switch (CKind) {
686 #define OPENMP_TASKLOOP_CLAUSE(Name) \
687  case OMPC_##Name: \
688  return true;
689 #include "clang/Basic/OpenMPKinds.def"
690  default:
691  break;
692  }
693  break;
694  case OMPD_taskloop_simd:
695  switch (CKind) {
696 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name) \
697  case OMPC_##Name: \
698  return true;
699 #include "clang/Basic/OpenMPKinds.def"
700  default:
701  break;
702  }
703  break;
704  case OMPD_master_taskloop:
705  switch (CKind) {
706 #define OPENMP_MASTER_TASKLOOP_CLAUSE(Name) \
707  case OMPC_##Name: \
708  return true;
709 #include "clang/Basic/OpenMPKinds.def"
710  default:
711  break;
712  }
713  break;
714  case OMPD_master_taskloop_simd:
715  switch (CKind) {
716 #define OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(Name) \
717  case OMPC_##Name: \
718  return true;
719 #include "clang/Basic/OpenMPKinds.def"
720  default:
721  break;
722  }
723  break;
724  case OMPD_parallel_master_taskloop:
725  switch (CKind) {
726 #define OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(Name) \
727  case OMPC_##Name: \
728  return true;
729 #include "clang/Basic/OpenMPKinds.def"
730  default:
731  break;
732  }
733  break;
734  case OMPD_parallel_master_taskloop_simd:
735  switch (CKind) {
736 #define OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(Name) \
737  case OMPC_##Name: \
738  return true;
739 #include "clang/Basic/OpenMPKinds.def"
740  default:
741  break;
742  }
743  break;
744  case OMPD_critical:
745  switch (CKind) {
746 #define OPENMP_CRITICAL_CLAUSE(Name) \
747  case OMPC_##Name: \
748  return true;
749 #include "clang/Basic/OpenMPKinds.def"
750  default:
751  break;
752  }
753  break;
754  case OMPD_distribute:
755  switch (CKind) {
756 #define OPENMP_DISTRIBUTE_CLAUSE(Name) \
757  case OMPC_##Name: \
758  return true;
759 #include "clang/Basic/OpenMPKinds.def"
760  default:
761  break;
762  }
763  break;
764  case OMPD_distribute_parallel_for:
765  switch (CKind) {
766 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
767  case OMPC_##Name: \
768  return true;
769 #include "clang/Basic/OpenMPKinds.def"
770  default:
771  break;
772  }
773  break;
774  case OMPD_distribute_parallel_for_simd:
775  switch (CKind) {
776 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
777  case OMPC_##Name: \
778  return true;
779 #include "clang/Basic/OpenMPKinds.def"
780  default:
781  break;
782  }
783  break;
784  case OMPD_distribute_simd:
785  if (OpenMPVersion < 50 && CKind == OMPC_if)
786  return false;
787  switch (CKind) {
788 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) \
789  case OMPC_##Name: \
790  return true;
791 #include "clang/Basic/OpenMPKinds.def"
792  default:
793  break;
794  }
795  break;
796  case OMPD_target_parallel_for_simd:
797  switch (CKind) {
798 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name) \
799  case OMPC_##Name: \
800  return true;
801 #include "clang/Basic/OpenMPKinds.def"
802  default:
803  break;
804  }
805  break;
806  case OMPD_target_simd:
807  switch (CKind) {
808 #define OPENMP_TARGET_SIMD_CLAUSE(Name) \
809  case OMPC_##Name: \
810  return true;
811 #include "clang/Basic/OpenMPKinds.def"
812  default:
813  break;
814  }
815  break;
816  case OMPD_teams_distribute:
817  switch (CKind) {
818 #define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name) \
819  case OMPC_##Name: \
820  return true;
821 #include "clang/Basic/OpenMPKinds.def"
822  default:
823  break;
824  }
825  break;
826  case OMPD_teams_distribute_simd:
827  if (OpenMPVersion < 50 && CKind == OMPC_if)
828  return false;
829  switch (CKind) {
830 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \
831  case OMPC_##Name: \
832  return true;
833 #include "clang/Basic/OpenMPKinds.def"
834  default:
835  break;
836  }
837  break;
838  case OMPD_teams_distribute_parallel_for_simd:
839  switch (CKind) {
840 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
841  case OMPC_##Name: \
842  return true;
843 #include "clang/Basic/OpenMPKinds.def"
844  default:
845  break;
846  }
847  break;
848  case OMPD_teams_distribute_parallel_for:
849  switch (CKind) {
850 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
851  case OMPC_##Name: \
852  return true;
853 #include "clang/Basic/OpenMPKinds.def"
854  default:
855  break;
856  }
857  break;
858  case OMPD_target_teams:
859  switch (CKind) {
860 #define OPENMP_TARGET_TEAMS_CLAUSE(Name) \
861  case OMPC_##Name: \
862  return true;
863 #include "clang/Basic/OpenMPKinds.def"
864  default:
865  break;
866  }
867  break;
868  case OMPD_target_teams_distribute:
869  switch (CKind) {
870 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name) \
871  case OMPC_##Name: \
872  return true;
873 #include "clang/Basic/OpenMPKinds.def"
874  default:
875  break;
876  }
877  break;
878  case OMPD_target_teams_distribute_parallel_for:
879  switch (CKind) {
880 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
881  case OMPC_##Name: \
882  return true;
883 #include "clang/Basic/OpenMPKinds.def"
884  default:
885  break;
886  }
887  break;
888  case OMPD_target_teams_distribute_parallel_for_simd:
889  switch (CKind) {
890 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
891  case OMPC_##Name: \
892  return true;
893 #include "clang/Basic/OpenMPKinds.def"
894  default:
895  break;
896  }
897  break;
898  case OMPD_target_teams_distribute_simd:
899  switch (CKind) {
900 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \
901  case OMPC_##Name: \
902  return true;
903 #include "clang/Basic/OpenMPKinds.def"
904  default:
905  break;
906  }
907  break;
908  case OMPD_taskgroup:
909  switch (CKind) {
910 #define OPENMP_TASKGROUP_CLAUSE(Name) \
911  case OMPC_##Name: \
912  return true;
913 #include "clang/Basic/OpenMPKinds.def"
914  default:
915  break;
916  }
917  break;
918  case OMPD_declare_mapper:
919  switch (CKind) {
920 #define OPENMP_DECLARE_MAPPER_CLAUSE(Name) \
921  case OMPC_##Name: \
922  return true;
923 #include "clang/Basic/OpenMPKinds.def"
924  default:
925  break;
926  }
927  break;
928  case OMPD_allocate:
929  switch (CKind) {
930 #define OPENMP_ALLOCATE_CLAUSE(Name) \
931  case OMPC_##Name: \
932  return true;
933 #include "clang/Basic/OpenMPKinds.def"
934  default:
935  break;
936  }
937  break;
938  case OMPD_declare_variant:
939  switch (CKind) {
940 #define OPENMP_DECLARE_VARIANT_CLAUSE(Name) \
941  case OMPC_##Name: \
942  return true;
943 #include "clang/Basic/OpenMPKinds.def"
944  default:
945  break;
946  }
947  break;
948  case OMPD_declare_target:
949  case OMPD_end_declare_target:
950  case OMPD_unknown:
951  case OMPD_threadprivate:
952  case OMPD_section:
953  case OMPD_master:
954  case OMPD_taskyield:
955  case OMPD_barrier:
956  case OMPD_taskwait:
957  case OMPD_cancellation_point:
958  case OMPD_declare_reduction:
959  case OMPD_declare_simd:
960  break;
961  }
962  return false;
963 }
964 
966  return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
967  DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
968  DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
969  DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd ||
970  DKind == OMPD_parallel_master_taskloop ||
971  DKind == OMPD_parallel_master_taskloop_simd ||
972  DKind == OMPD_distribute || DKind == OMPD_target_parallel_for ||
973  DKind == OMPD_distribute_parallel_for ||
974  DKind == OMPD_distribute_parallel_for_simd ||
975  DKind == OMPD_distribute_simd ||
976  DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
977  DKind == OMPD_teams_distribute ||
978  DKind == OMPD_teams_distribute_simd ||
979  DKind == OMPD_teams_distribute_parallel_for_simd ||
980  DKind == OMPD_teams_distribute_parallel_for ||
981  DKind == OMPD_target_teams_distribute ||
982  DKind == OMPD_target_teams_distribute_parallel_for ||
983  DKind == OMPD_target_teams_distribute_parallel_for_simd ||
984  DKind == OMPD_target_teams_distribute_simd;
985 }
986 
988  return DKind == OMPD_for || DKind == OMPD_for_simd ||
989  DKind == OMPD_sections || DKind == OMPD_section ||
990  DKind == OMPD_single || DKind == OMPD_parallel_for ||
991  DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
992  DKind == OMPD_target_parallel_for ||
993  DKind == OMPD_distribute_parallel_for ||
994  DKind == OMPD_distribute_parallel_for_simd ||
995  DKind == OMPD_target_parallel_for_simd ||
996  DKind == OMPD_teams_distribute_parallel_for_simd ||
997  DKind == OMPD_teams_distribute_parallel_for ||
998  DKind == OMPD_target_teams_distribute_parallel_for ||
999  DKind == OMPD_target_teams_distribute_parallel_for_simd;
1000 }
1001 
1003  return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
1004  DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd ||
1005  DKind == OMPD_parallel_master_taskloop ||
1006  DKind == OMPD_parallel_master_taskloop_simd;
1007 }
1008 
1010  return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
1011  DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
1012  DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for ||
1013  DKind == OMPD_distribute_parallel_for ||
1014  DKind == OMPD_distribute_parallel_for_simd ||
1015  DKind == OMPD_target_parallel_for_simd ||
1016  DKind == OMPD_teams_distribute_parallel_for ||
1017  DKind == OMPD_teams_distribute_parallel_for_simd ||
1018  DKind == OMPD_target_teams_distribute_parallel_for ||
1019  DKind == OMPD_target_teams_distribute_parallel_for_simd ||
1020  DKind == OMPD_parallel_master ||
1021  DKind == OMPD_parallel_master_taskloop ||
1022  DKind == OMPD_parallel_master_taskloop_simd;
1023 }
1024 
1026  return DKind == OMPD_target || DKind == OMPD_target_parallel ||
1027  DKind == OMPD_target_parallel_for ||
1028  DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
1029  DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
1030  DKind == OMPD_target_teams_distribute_parallel_for ||
1031  DKind == OMPD_target_teams_distribute_parallel_for_simd ||
1032  DKind == OMPD_target_teams_distribute_simd;
1033 }
1034 
1036  return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
1037  DKind == OMPD_target_exit_data || DKind == OMPD_target_update;
1038 }
1039 
1041  return DKind == OMPD_teams || DKind == OMPD_teams_distribute ||
1042  DKind == OMPD_teams_distribute_simd ||
1043  DKind == OMPD_teams_distribute_parallel_for_simd ||
1044  DKind == OMPD_teams_distribute_parallel_for;
1045 }
1046 
1048  return isOpenMPNestingTeamsDirective(DKind) ||
1049  DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
1050  DKind == OMPD_target_teams_distribute_parallel_for ||
1051  DKind == OMPD_target_teams_distribute_parallel_for_simd ||
1052  DKind == OMPD_target_teams_distribute_simd;
1053 }
1054 
1056  return DKind == OMPD_simd || DKind == OMPD_for_simd ||
1057  DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd ||
1058  DKind == OMPD_master_taskloop_simd ||
1059  DKind == OMPD_parallel_master_taskloop_simd ||
1060  DKind == OMPD_distribute_parallel_for_simd ||
1061  DKind == OMPD_distribute_simd || DKind == OMPD_target_simd ||
1062  DKind == OMPD_teams_distribute_simd ||
1063  DKind == OMPD_teams_distribute_parallel_for_simd ||
1064  DKind == OMPD_target_teams_distribute_parallel_for_simd ||
1065  DKind == OMPD_target_teams_distribute_simd ||
1066  DKind == OMPD_target_parallel_for_simd;
1067 }
1068 
1070  return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for ||
1071  Kind == OMPD_distribute_parallel_for_simd ||
1072  Kind == OMPD_distribute_simd;
1073  // TODO add next directives.
1074 }
1075 
1077  return isOpenMPNestingDistributeDirective(Kind) ||
1078  Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd ||
1079  Kind == OMPD_teams_distribute_parallel_for_simd ||
1080  Kind == OMPD_teams_distribute_parallel_for ||
1081  Kind == OMPD_target_teams_distribute ||
1082  Kind == OMPD_target_teams_distribute_parallel_for ||
1083  Kind == OMPD_target_teams_distribute_parallel_for_simd ||
1084  Kind == OMPD_target_teams_distribute_simd;
1085 }
1086 
1088  return Kind == OMPC_private || Kind == OMPC_firstprivate ||
1089  Kind == OMPC_lastprivate || Kind == OMPC_linear ||
1090  Kind == OMPC_reduction || Kind == OMPC_task_reduction ||
1091  Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'.
1092 }
1093 
1095  return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
1096 }
1097 
1099  return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
1100 }
1101 
1103  return Kind == OMPD_distribute_parallel_for ||
1104  Kind == OMPD_distribute_parallel_for_simd ||
1105  Kind == OMPD_teams_distribute_parallel_for_simd ||
1106  Kind == OMPD_teams_distribute_parallel_for ||
1107  Kind == OMPD_target_teams_distribute_parallel_for ||
1108  Kind == OMPD_target_teams_distribute_parallel_for_simd;
1109 }
1110 
1112  SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions,
1113  OpenMPDirectiveKind DKind) {
1114  assert(DKind <= OMPD_unknown);
1115  switch (DKind) {
1116  case OMPD_parallel:
1117  case OMPD_parallel_for:
1118  case OMPD_parallel_for_simd:
1119  case OMPD_parallel_master:
1120  case OMPD_parallel_sections:
1121  case OMPD_distribute_parallel_for:
1122  case OMPD_distribute_parallel_for_simd:
1123  CaptureRegions.push_back(OMPD_parallel);
1124  break;
1125  case OMPD_target_teams:
1126  case OMPD_target_teams_distribute:
1127  case OMPD_target_teams_distribute_simd:
1128  CaptureRegions.push_back(OMPD_task);
1129  CaptureRegions.push_back(OMPD_target);
1130  CaptureRegions.push_back(OMPD_teams);
1131  break;
1132  case OMPD_teams:
1133  case OMPD_teams_distribute:
1134  case OMPD_teams_distribute_simd:
1135  CaptureRegions.push_back(OMPD_teams);
1136  break;
1137  case OMPD_target:
1138  case OMPD_target_simd:
1139  CaptureRegions.push_back(OMPD_task);
1140  CaptureRegions.push_back(OMPD_target);
1141  break;
1142  case OMPD_teams_distribute_parallel_for:
1143  case OMPD_teams_distribute_parallel_for_simd:
1144  CaptureRegions.push_back(OMPD_teams);
1145  CaptureRegions.push_back(OMPD_parallel);
1146  break;
1147  case OMPD_target_parallel:
1148  case OMPD_target_parallel_for:
1149  case OMPD_target_parallel_for_simd:
1150  CaptureRegions.push_back(OMPD_task);
1151  CaptureRegions.push_back(OMPD_target);
1152  CaptureRegions.push_back(OMPD_parallel);
1153  break;
1154  case OMPD_task:
1155  case OMPD_target_enter_data:
1156  case OMPD_target_exit_data:
1157  case OMPD_target_update:
1158  CaptureRegions.push_back(OMPD_task);
1159  break;
1160  case OMPD_taskloop:
1161  case OMPD_taskloop_simd:
1162  case OMPD_master_taskloop:
1163  case OMPD_master_taskloop_simd:
1164  CaptureRegions.push_back(OMPD_taskloop);
1165  break;
1166  case OMPD_parallel_master_taskloop:
1167  case OMPD_parallel_master_taskloop_simd:
1168  CaptureRegions.push_back(OMPD_parallel);
1169  CaptureRegions.push_back(OMPD_taskloop);
1170  break;
1171  case OMPD_target_teams_distribute_parallel_for:
1172  case OMPD_target_teams_distribute_parallel_for_simd:
1173  CaptureRegions.push_back(OMPD_task);
1174  CaptureRegions.push_back(OMPD_target);
1175  CaptureRegions.push_back(OMPD_teams);
1176  CaptureRegions.push_back(OMPD_parallel);
1177  break;
1178  case OMPD_simd:
1179  case OMPD_for:
1180  case OMPD_for_simd:
1181  case OMPD_sections:
1182  case OMPD_section:
1183  case OMPD_single:
1184  case OMPD_master:
1185  case OMPD_critical:
1186  case OMPD_taskgroup:
1187  case OMPD_distribute:
1188  case OMPD_ordered:
1189  case OMPD_atomic:
1190  case OMPD_target_data:
1191  case OMPD_distribute_simd:
1192  CaptureRegions.push_back(OMPD_unknown);
1193  break;
1194  case OMPD_threadprivate:
1195  case OMPD_allocate:
1196  case OMPD_taskyield:
1197  case OMPD_barrier:
1198  case OMPD_taskwait:
1199  case OMPD_cancellation_point:
1200  case OMPD_cancel:
1201  case OMPD_flush:
1202  case OMPD_declare_reduction:
1203  case OMPD_declare_mapper:
1204  case OMPD_declare_simd:
1205  case OMPD_declare_target:
1206  case OMPD_end_declare_target:
1207  case OMPD_requires:
1208  case OMPD_declare_variant:
1209  llvm_unreachable("OpenMP Directive is not allowed");
1210  case OMPD_unknown:
1211  llvm_unreachable("Unknown OpenMP directive");
1212  }
1213 }
#define OPENMP_MAP_KIND(Name)
#define OPENMP_CONTEXT_SELECTOR_SET(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:1450
const char * getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, unsigned Type)
#define OPENMP_LINEAR_KIND(Name)
const char * getOpenMPClauseName(OpenMPClauseKind Kind)
Definition: OpenMPKinds.cpp:82
llvm::StringRef getOpenMPContextSelectorName(OpenMPContextSelectorKind Kind)
Definition: OpenMPKinds.cpp:53
bool isOpenMPTaskingDirective(OpenMPDirectiveKind Kind)
Checks if the specified directive kind is one of tasking directives - task, taskloop, taksloop simd, master taskloop, parallel master taskloop, master taskloop simd, or parallel master taskloop simd.
OpenMPContextSelectorKind
OpenMP context selectors.
Definition: OpenMPKinds.h:30
#define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name)
Defines some OpenMP-specific enums and functions.
#define OPENMP_LASTPRIVATE_KIND(Name)
OpenMPContextSelectorSetKind
OpenMP context selector sets.
Definition: OpenMPKinds.h:23
bool isAllowedClauseForDirective(OpenMPDirectiveKind DKind, OpenMPClauseKind CKind, unsigned OpenMPVersion)
bool isOpenMPTeamsDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a teams-kind directive.
OpenMPClauseKind getOpenMPClauseKind(llvm::StringRef Str)
OpenMPContextSelectorSetKind getOpenMPContextSelectorSet(llvm::StringRef Str)
Definition: OpenMPKinds.cpp:24
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.
llvm::omp::Directive OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:62
#define OPENMP_CLAUSE(Name, Class)
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:65
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
llvm::StringRef getOpenMPContextSelectorSetName(OpenMPContextSelectorSetKind Kind)
Definition: OpenMPKinds.cpp:32
bool isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a taskloop directive.
#define OPENMP_CONTEXT_SELECTOR(Name)
Kind
bool isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind)
Checks if the specified directive kind is one of the composite or combined directives that need loop ...
#define OPENMP_TO_MODIFIER_KIND(Name)
Dataflow Directional Tag Classes.
bool isOpenMPSimdDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a simd directive.
#define OPENMP_FROM_MODIFIER_KIND(Name)
#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.
#define OPENMP_SCHEDULE_KIND(Name)
OpenMPContextSelectorKind getOpenMPContextSelector(llvm::StringRef Str)
Definition: OpenMPKinds.cpp:45
bool isOpenMPLoopDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a directive with an associated loop construct.
#define OPENMP_DIST_SCHEDULE_KIND(Name)
#define OMP_PROC_BIND_KIND(Enum, Name, Value)
bool isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind)
Checks if the specified composite/combined directive constitutes a teams directive in the outermost n...
#define OPENMP_DEVICE_TYPE_KIND(Name)