clang  3.9.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_aligned:
142  case OMPC_copyin:
143  case OMPC_copyprivate:
144  case OMPC_ordered:
145  case OMPC_nowait:
146  case OMPC_untied:
147  case OMPC_mergeable:
148  case OMPC_flush:
149  case OMPC_read:
150  case OMPC_write:
151  case OMPC_update:
152  case OMPC_capture:
153  case OMPC_seq_cst:
154  case OMPC_device:
155  case OMPC_threads:
156  case OMPC_simd:
157  case OMPC_num_teams:
158  case OMPC_thread_limit:
159  case OMPC_priority:
160  case OMPC_grainsize:
161  case OMPC_nogroup:
162  case OMPC_num_tasks:
163  case OMPC_hint:
164  case OMPC_uniform:
165  case OMPC_to:
166  case OMPC_from:
167  case OMPC_use_device_ptr:
168  case OMPC_is_device_ptr:
169  break;
170  }
171  llvm_unreachable("Invalid OpenMP simple clause kind");
172 }
173 
175  unsigned Type) {
176  switch (Kind) {
177  case OMPC_default:
178  switch (Type) {
180  return "unknown";
181 #define OPENMP_DEFAULT_KIND(Name) \
182  case OMPC_DEFAULT_##Name: \
183  return #Name;
184 #include "clang/Basic/OpenMPKinds.def"
185  }
186  llvm_unreachable("Invalid OpenMP 'default' clause type");
187  case OMPC_proc_bind:
188  switch (Type) {
190  return "unknown";
191 #define OPENMP_PROC_BIND_KIND(Name) \
192  case OMPC_PROC_BIND_##Name: \
193  return #Name;
194 #include "clang/Basic/OpenMPKinds.def"
195  }
196  llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
197  case OMPC_schedule:
198  switch (Type) {
201  return "unknown";
202 #define OPENMP_SCHEDULE_KIND(Name) \
203  case OMPC_SCHEDULE_##Name: \
204  return #Name;
205 #define OPENMP_SCHEDULE_MODIFIER(Name) \
206  case OMPC_SCHEDULE_MODIFIER_##Name: \
207  return #Name;
208 #include "clang/Basic/OpenMPKinds.def"
209  }
210  llvm_unreachable("Invalid OpenMP 'schedule' clause type");
211  case OMPC_depend:
212  switch (Type) {
213  case OMPC_DEPEND_unknown:
214  return "unknown";
215 #define OPENMP_DEPEND_KIND(Name) \
216  case OMPC_DEPEND_##Name: \
217  return #Name;
218 #include "clang/Basic/OpenMPKinds.def"
219  }
220  llvm_unreachable("Invalid OpenMP 'depend' clause type");
221  case OMPC_linear:
222  switch (Type) {
223  case OMPC_LINEAR_unknown:
224  return "unknown";
225 #define OPENMP_LINEAR_KIND(Name) \
226  case OMPC_LINEAR_##Name: \
227  return #Name;
228 #include "clang/Basic/OpenMPKinds.def"
229  }
230  llvm_unreachable("Invalid OpenMP 'linear' clause type");
231  case OMPC_map:
232  switch (Type) {
233  case OMPC_MAP_unknown:
234  return "unknown";
235 #define OPENMP_MAP_KIND(Name) \
236  case OMPC_MAP_##Name: \
237  return #Name;
238 #include "clang/Basic/OpenMPKinds.def"
239  default:
240  break;
241  }
242  llvm_unreachable("Invalid OpenMP 'map' clause type");
243  case OMPC_dist_schedule:
244  switch (Type) {
246  return "unknown";
247 #define OPENMP_DIST_SCHEDULE_KIND(Name) \
248  case OMPC_DIST_SCHEDULE_##Name: \
249  return #Name;
250 #include "clang/Basic/OpenMPKinds.def"
251  }
252  llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type");
253  case OMPC_defaultmap:
254  switch (Type) {
257  return "unknown";
258 #define OPENMP_DEFAULTMAP_KIND(Name) \
259  case OMPC_DEFAULTMAP_##Name: \
260  return #Name;
261 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \
262  case OMPC_DEFAULTMAP_MODIFIER_##Name: \
263  return #Name;
264 #include "clang/Basic/OpenMPKinds.def"
265  }
266  llvm_unreachable("Invalid OpenMP 'schedule' clause type");
267  case OMPC_unknown:
268  case OMPC_threadprivate:
269  case OMPC_if:
270  case OMPC_final:
271  case OMPC_num_threads:
272  case OMPC_safelen:
273  case OMPC_simdlen:
274  case OMPC_collapse:
275  case OMPC_private:
276  case OMPC_firstprivate:
277  case OMPC_lastprivate:
278  case OMPC_shared:
279  case OMPC_reduction:
280  case OMPC_aligned:
281  case OMPC_copyin:
282  case OMPC_copyprivate:
283  case OMPC_ordered:
284  case OMPC_nowait:
285  case OMPC_untied:
286  case OMPC_mergeable:
287  case OMPC_flush:
288  case OMPC_read:
289  case OMPC_write:
290  case OMPC_update:
291  case OMPC_capture:
292  case OMPC_seq_cst:
293  case OMPC_device:
294  case OMPC_threads:
295  case OMPC_simd:
296  case OMPC_num_teams:
297  case OMPC_thread_limit:
298  case OMPC_priority:
299  case OMPC_grainsize:
300  case OMPC_nogroup:
301  case OMPC_num_tasks:
302  case OMPC_hint:
303  case OMPC_uniform:
304  case OMPC_to:
305  case OMPC_from:
306  case OMPC_use_device_ptr:
307  case OMPC_is_device_ptr:
308  break;
309  }
310  llvm_unreachable("Invalid OpenMP simple clause kind");
311 }
312 
314  OpenMPClauseKind CKind) {
315  assert(DKind <= OMPD_unknown);
316  assert(CKind <= OMPC_unknown);
317  switch (DKind) {
318  case OMPD_parallel:
319  switch (CKind) {
320 #define OPENMP_PARALLEL_CLAUSE(Name) \
321  case OMPC_##Name: \
322  return true;
323 #include "clang/Basic/OpenMPKinds.def"
324  default:
325  break;
326  }
327  break;
328  case OMPD_simd:
329  switch (CKind) {
330 #define OPENMP_SIMD_CLAUSE(Name) \
331  case OMPC_##Name: \
332  return true;
333 #include "clang/Basic/OpenMPKinds.def"
334  default:
335  break;
336  }
337  break;
338  case OMPD_for:
339  switch (CKind) {
340 #define OPENMP_FOR_CLAUSE(Name) \
341  case OMPC_##Name: \
342  return true;
343 #include "clang/Basic/OpenMPKinds.def"
344  default:
345  break;
346  }
347  break;
348  case OMPD_for_simd:
349  switch (CKind) {
350 #define OPENMP_FOR_SIMD_CLAUSE(Name) \
351  case OMPC_##Name: \
352  return true;
353 #include "clang/Basic/OpenMPKinds.def"
354  default:
355  break;
356  }
357  break;
358  case OMPD_sections:
359  switch (CKind) {
360 #define OPENMP_SECTIONS_CLAUSE(Name) \
361  case OMPC_##Name: \
362  return true;
363 #include "clang/Basic/OpenMPKinds.def"
364  default:
365  break;
366  }
367  break;
368  case OMPD_single:
369  switch (CKind) {
370 #define OPENMP_SINGLE_CLAUSE(Name) \
371  case OMPC_##Name: \
372  return true;
373 #include "clang/Basic/OpenMPKinds.def"
374  default:
375  break;
376  }
377  break;
378  case OMPD_parallel_for:
379  switch (CKind) {
380 #define OPENMP_PARALLEL_FOR_CLAUSE(Name) \
381  case OMPC_##Name: \
382  return true;
383 #include "clang/Basic/OpenMPKinds.def"
384  default:
385  break;
386  }
387  break;
388  case OMPD_parallel_for_simd:
389  switch (CKind) {
390 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \
391  case OMPC_##Name: \
392  return true;
393 #include "clang/Basic/OpenMPKinds.def"
394  default:
395  break;
396  }
397  break;
398  case OMPD_parallel_sections:
399  switch (CKind) {
400 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) \
401  case OMPC_##Name: \
402  return true;
403 #include "clang/Basic/OpenMPKinds.def"
404  default:
405  break;
406  }
407  break;
408  case OMPD_task:
409  switch (CKind) {
410 #define OPENMP_TASK_CLAUSE(Name) \
411  case OMPC_##Name: \
412  return true;
413 #include "clang/Basic/OpenMPKinds.def"
414  default:
415  break;
416  }
417  break;
418  case OMPD_flush:
419  return CKind == OMPC_flush;
420  break;
421  case OMPD_atomic:
422  switch (CKind) {
423 #define OPENMP_ATOMIC_CLAUSE(Name) \
424  case OMPC_##Name: \
425  return true;
426 #include "clang/Basic/OpenMPKinds.def"
427  default:
428  break;
429  }
430  break;
431  case OMPD_target:
432  switch (CKind) {
433 #define OPENMP_TARGET_CLAUSE(Name) \
434  case OMPC_##Name: \
435  return true;
436 #include "clang/Basic/OpenMPKinds.def"
437  default:
438  break;
439  }
440  break;
441  case OMPD_target_data:
442  switch (CKind) {
443 #define OPENMP_TARGET_DATA_CLAUSE(Name) \
444  case OMPC_##Name: \
445  return true;
446 #include "clang/Basic/OpenMPKinds.def"
447  default:
448  break;
449  }
450  break;
451  case OMPD_target_enter_data:
452  switch (CKind) {
453 #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name) \
454  case OMPC_##Name: \
455  return true;
456 #include "clang/Basic/OpenMPKinds.def"
457  default:
458  break;
459  }
460  break;
461  case OMPD_target_exit_data:
462  switch (CKind) {
463 #define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name) \
464  case OMPC_##Name: \
465  return true;
466 #include "clang/Basic/OpenMPKinds.def"
467  default:
468  break;
469  }
470  break;
471  case OMPD_target_parallel:
472  switch (CKind) {
473 #define OPENMP_TARGET_PARALLEL_CLAUSE(Name) \
474  case OMPC_##Name: \
475  return true;
476 #include "clang/Basic/OpenMPKinds.def"
477  default:
478  break;
479  }
480  break;
481  case OMPD_target_parallel_for:
482  switch (CKind) {
483 #define OPENMP_TARGET_PARALLEL_FOR_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_target_update:
492  switch (CKind) {
493 #define OPENMP_TARGET_UPDATE_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_teams:
502  switch (CKind) {
503 #define OPENMP_TEAMS_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_declare_simd:
512  break;
513  case OMPD_cancel:
514  switch (CKind) {
515 #define OPENMP_CANCEL_CLAUSE(Name) \
516  case OMPC_##Name: \
517  return true;
518 #include "clang/Basic/OpenMPKinds.def"
519  default:
520  break;
521  }
522  break;
523  case OMPD_ordered:
524  switch (CKind) {
525 #define OPENMP_ORDERED_CLAUSE(Name) \
526  case OMPC_##Name: \
527  return true;
528 #include "clang/Basic/OpenMPKinds.def"
529  default:
530  break;
531  }
532  break;
533  case OMPD_taskloop:
534  switch (CKind) {
535 #define OPENMP_TASKLOOP_CLAUSE(Name) \
536  case OMPC_##Name: \
537  return true;
538 #include "clang/Basic/OpenMPKinds.def"
539  default:
540  break;
541  }
542  break;
543  case OMPD_taskloop_simd:
544  switch (CKind) {
545 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name) \
546  case OMPC_##Name: \
547  return true;
548 #include "clang/Basic/OpenMPKinds.def"
549  default:
550  break;
551  }
552  break;
553  case OMPD_critical:
554  switch (CKind) {
555 #define OPENMP_CRITICAL_CLAUSE(Name) \
556  case OMPC_##Name: \
557  return true;
558 #include "clang/Basic/OpenMPKinds.def"
559  default:
560  break;
561  }
562  break;
563  case OMPD_distribute:
564  switch (CKind) {
565 #define OPENMP_DISTRIBUTE_CLAUSE(Name) \
566  case OMPC_##Name: \
567  return true;
568 #include "clang/Basic/OpenMPKinds.def"
569  default:
570  break;
571  }
572  break;
573  case OMPD_distribute_parallel_for:
574  switch (CKind) {
575 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \
576  case OMPC_##Name: \
577  return true;
578 #include "clang/Basic/OpenMPKinds.def"
579  default:
580  break;
581  }
582  break;
583  case OMPD_distribute_parallel_for_simd:
584  switch (CKind) {
585 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \
586  case OMPC_##Name: \
587  return true;
588 #include "clang/Basic/OpenMPKinds.def"
589  default:
590  break;
591  }
592  break;
593  case OMPD_distribute_simd:
594  switch (CKind) {
595 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) \
596  case OMPC_##Name: \
597  return true;
598 #include "clang/Basic/OpenMPKinds.def"
599  default:
600  break;
601  }
602  break;
603  case OMPD_target_parallel_for_simd:
604  switch (CKind) {
605 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name) \
606  case OMPC_##Name: \
607  return true;
608 #include "clang/Basic/OpenMPKinds.def"
609  default:
610  break;
611  }
612  break;
613  case OMPD_declare_target:
614  case OMPD_end_declare_target:
615  case OMPD_unknown:
616  case OMPD_threadprivate:
617  case OMPD_section:
618  case OMPD_master:
619  case OMPD_taskyield:
620  case OMPD_barrier:
621  case OMPD_taskwait:
622  case OMPD_taskgroup:
623  case OMPD_cancellation_point:
624  case OMPD_declare_reduction:
625  break;
626  }
627  return false;
628 }
629 
631  return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
632  DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
633  DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
634  DKind == OMPD_distribute || DKind == OMPD_target_parallel_for ||
635  DKind == OMPD_distribute_parallel_for ||
636  DKind == OMPD_distribute_parallel_for_simd ||
637  DKind == OMPD_distribute_simd ||
638  DKind == OMPD_target_parallel_for_simd;
639  // TODO add next directives.
640 }
641 
643  return DKind == OMPD_for || DKind == OMPD_for_simd ||
644  DKind == OMPD_sections || DKind == OMPD_section ||
645  DKind == OMPD_single || DKind == OMPD_parallel_for ||
646  DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
647  DKind == OMPD_target_parallel_for ||
648  DKind == OMPD_distribute_parallel_for ||
649  DKind == OMPD_distribute_parallel_for_simd ||
650  DKind == OMPD_target_parallel_for_simd;
651  // TODO add next directives.
652 }
653 
655  return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd;
656 }
657 
659  return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
660  DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
661  DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for ||
662  DKind == OMPD_distribute_parallel_for ||
663  DKind == OMPD_distribute_parallel_for_simd ||
664  DKind == OMPD_target_parallel_for_simd;
665  // TODO add next directives.
666 }
667 
669  // TODO add next directives.
670  return DKind == OMPD_target || DKind == OMPD_target_parallel ||
671  DKind == OMPD_target_parallel_for ||
672  DKind == OMPD_target_parallel_for_simd;
673 }
674 
676  return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
677  DKind == OMPD_target_exit_data || DKind == OMPD_target_update;
678 }
679 
681  return DKind == OMPD_teams; // TODO add next directives.
682 }
683 
685  return DKind == OMPD_simd || DKind == OMPD_for_simd ||
686  DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd ||
687  DKind == OMPD_distribute_parallel_for_simd ||
688  DKind == OMPD_distribute_simd;
689  // TODO add next directives.
690 }
691 
693  return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for ||
694  Kind == OMPD_distribute_parallel_for_simd ||
695  Kind == OMPD_distribute_simd;
696  // TODO add next directives.
697 }
698 
700  return Kind == OMPC_private || Kind == OMPC_firstprivate ||
701  Kind == OMPC_lastprivate || Kind == OMPC_linear ||
702  Kind == OMPC_reduction; // TODO add next clauses like 'reduction'.
703 }
704 
706  return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
707 }
708 
710  return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
711 }
712 
714  return Kind == OMPD_distribute_parallel_for ||
715  Kind == OMPD_distribute_parallel_for_simd ||
716  Kind == OMPD_distribute_simd;
717 }
#define OPENMP_MAP_KIND(Name)
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:1281
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
class LLVM_ALIGNAS(8) DependentTemplateSpecializationType const IdentifierInfo * Name
Represents a template specialization type whose template cannot be resolved, e.g. ...
Definition: Type.h:4549
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 ...
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'.
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)