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