Clang Project

clang_source_code/lib/Basic/OpenMPKinds.cpp
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
13#include "clang/Basic/OpenMPKinds.h"
14#include "clang/Basic/IdentifierTable.h"
15#include "llvm/ADT/StringRef.h"
16#include "llvm/ADT/StringSwitch.h"
17#include "llvm/Support/ErrorHandling.h"
18#include <cassert>
19
20using namespace clang;
21
22OpenMPDirectiveKind clang::getOpenMPDirectiveKind(StringRef Str) {
23  return llvm::StringSwitch<OpenMPDirectiveKind>(Str)
24#define OPENMP_DIRECTIVE(Name) .Case(#Name, OMPD_##Name)
25#define OPENMP_DIRECTIVE_EXT(Name, Str) .Case(Str, OMPD_##Name)
26#include "clang/Basic/OpenMPKinds.def"
27      .Default(OMPD_unknown);
28}
29
30const char *clang::getOpenMPDirectiveName(OpenMPDirectiveKind Kind) {
31  assert(Kind <= OMPD_unknown);
32  switch (Kind) {
33  case OMPD_unknown:
34    return "unknown";
35#define OPENMP_DIRECTIVE(Name)                                                 \
36  case OMPD_##Name:                                                            \
37    return #Name;
38#define OPENMP_DIRECTIVE_EXT(Name, Str)                                        \
39  case OMPD_##Name:                                                            \
40    return Str;
41#include "clang/Basic/OpenMPKinds.def"
42    break;
43  }
44  llvm_unreachable("Invalid OpenMP directive kind");
45}
46
47OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) {
48  // 'flush' clause cannot be specified explicitly, because this is an implicit
49  // clause for 'flush' directive. If the 'flush' clause is explicitly specified
50  // the Parser should generate a warning about extra tokens at the end of the
51  // directive.
52  if (Str == "flush")
53    return OMPC_unknown;
54  return llvm::StringSwitch<OpenMPClauseKind>(Str)
55#define OPENMP_CLAUSE(Name, Class) .Case(#Name, OMPC_##Name)
56#include "clang/Basic/OpenMPKinds.def"
57      .Case("uniform", OMPC_uniform)
58      .Default(OMPC_unknown);
59}
60
61const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) {
62  assert(Kind <= OMPC_unknown);
63  switch (Kind) {
64  case OMPC_unknown:
65    return "unknown";
66#define OPENMP_CLAUSE(Name, Class)                                             \
67  case OMPC_##Name:                                                            \
68    return #Name;
69#include "clang/Basic/OpenMPKinds.def"
70  case OMPC_uniform:
71    return "uniform";
72  case OMPC_threadprivate:
73    return "threadprivate or thread local";
74  }
75  llvm_unreachable("Invalid OpenMP clause kind");
76}
77
78unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind,
79                                          StringRef Str) {
80  switch (Kind) {
81  case OMPC_default:
82    return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str)
83#define OPENMP_DEFAULT_KIND(Name) .Case(#Name, OMPC_DEFAULT_##Name)
84#include "clang/Basic/OpenMPKinds.def"
85        .Default(OMPC_DEFAULT_unknown);
86  case OMPC_proc_bind:
87    return llvm::StringSwitch<OpenMPProcBindClauseKind>(Str)
88#define OPENMP_PROC_BIND_KIND(Name) .Case(#Name, OMPC_PROC_BIND_##Name)
89#include "clang/Basic/OpenMPKinds.def"
90        .Default(OMPC_PROC_BIND_unknown);
91  case OMPC_schedule:
92    return llvm::StringSwitch<unsigned>(Str)
93#define OPENMP_SCHEDULE_KIND(Name)                                             \
94  .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name))
95#define OPENMP_SCHEDULE_MODIFIER(Name)                                         \
96  .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name))
97#include "clang/Basic/OpenMPKinds.def"
98        .Default(OMPC_SCHEDULE_unknown);
99  case OMPC_depend:
100    return llvm::StringSwitch<OpenMPDependClauseKind>(Str)
101#define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name)
102#include "clang/Basic/OpenMPKinds.def"
103        .Default(OMPC_DEPEND_unknown);
104  case OMPC_linear:
105    return llvm::StringSwitch<OpenMPLinearClauseKind>(Str)
106#define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name)
107#include "clang/Basic/OpenMPKinds.def"
108        .Default(OMPC_LINEAR_unknown);
109  case OMPC_map:
110    return llvm::StringSwitch<unsigned>(Str)
111#define OPENMP_MAP_KIND(Name)                                                  \
112  .Case(#Name, static_cast<unsigned>(OMPC_MAP_##Name))
113#define OPENMP_MAP_MODIFIER_KIND(Name)                                         \
114  .Case(#Name, static_cast<unsigned>(OMPC_MAP_MODIFIER_##Name))
115#include "clang/Basic/OpenMPKinds.def"
116        .Default(OMPC_MAP_unknown);
117  case OMPC_to:
118    return llvm::StringSwitch<unsigned>(Str)
119#define OPENMP_TO_MODIFIER_KIND(Name)                                          \
120  .Case(#Name, static_cast<unsigned>(OMPC_TO_MODIFIER_##Name))
121#include "clang/Basic/OpenMPKinds.def"
122        .Default(OMPC_TO_MODIFIER_unknown);
123  case OMPC_from:
124    return llvm::StringSwitch<unsigned>(Str)
125#define OPENMP_FROM_MODIFIER_KIND(Name)                                     \
126  .Case(#Name, static_cast<unsigned>(OMPC_FROM_MODIFIER_##Name))
127#include "clang/Basic/OpenMPKinds.def"
128        .Default(OMPC_FROM_MODIFIER_unknown);
129  case OMPC_dist_schedule:
130    return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str)
131#define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name)
132#include "clang/Basic/OpenMPKinds.def"
133        .Default(OMPC_DIST_SCHEDULE_unknown);
134  case OMPC_defaultmap:
135    return llvm::StringSwitch<unsigned>(Str)
136#define OPENMP_DEFAULTMAP_KIND(Name)                                           \
137  .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name))
138#define OPENMP_DEFAULTMAP_MODIFIER(Name)                                       \
139  .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name))
140#include "clang/Basic/OpenMPKinds.def"
141        .Default(OMPC_DEFAULTMAP_unknown);
142  case OMPC_atomic_default_mem_order:
143     return llvm::StringSwitch<OpenMPAtomicDefaultMemOrderClauseKind>(Str)
144#define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name)       \
145  .Case(#Name, OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name)
146#include "clang/Basic/OpenMPKinds.def"
147        .Default(OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown);
148  case OMPC_unknown:
149  case OMPC_threadprivate:
150  case OMPC_if:
151  case OMPC_final:
152  case OMPC_num_threads:
153  case OMPC_safelen:
154  case OMPC_simdlen:
155  case OMPC_allocator:
156  case OMPC_allocate:
157  case OMPC_collapse:
158  case OMPC_private:
159  case OMPC_firstprivate:
160  case OMPC_lastprivate:
161  case OMPC_shared:
162  case OMPC_reduction:
163  case OMPC_task_reduction:
164  case OMPC_in_reduction:
165  case OMPC_aligned:
166  case OMPC_copyin:
167  case OMPC_copyprivate:
168  case OMPC_ordered:
169  case OMPC_nowait:
170  case OMPC_untied:
171  case OMPC_mergeable:
172  case OMPC_flush:
173  case OMPC_read:
174  case OMPC_write:
175  case OMPC_update:
176  case OMPC_capture:
177  case OMPC_seq_cst:
178  case OMPC_device:
179  case OMPC_threads:
180  case OMPC_simd:
181  case OMPC_num_teams:
182  case OMPC_thread_limit:
183  case OMPC_priority:
184  case OMPC_grainsize:
185  case OMPC_nogroup:
186  case OMPC_num_tasks:
187  case OMPC_hint:
188  case OMPC_uniform:
189  case OMPC_use_device_ptr:
190  case OMPC_is_device_ptr:
191  case OMPC_unified_address:
192  case OMPC_unified_shared_memory:
193  case OMPC_reverse_offload:
194  case OMPC_dynamic_allocators:
195    break;
196  }
197  llvm_unreachable("Invalid OpenMP simple clause kind");
198}
199
200const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
201                                                 unsigned Type) {
202  switch (Kind) {
203  case OMPC_default:
204    switch (Type) {
205    case OMPC_DEFAULT_unknown:
206      return "unknown";
207#define OPENMP_DEFAULT_KIND(Name)                                              \
208  case OMPC_DEFAULT_##Name:                                                    \
209    return #Name;
210#include "clang/Basic/OpenMPKinds.def"
211    }
212    llvm_unreachable("Invalid OpenMP 'default' clause type");
213  case OMPC_proc_bind:
214    switch (Type) {
215    case OMPC_PROC_BIND_unknown:
216      return "unknown";
217#define OPENMP_PROC_BIND_KIND(Name)                                            \
218  case OMPC_PROC_BIND_##Name:                                                  \
219    return #Name;
220#include "clang/Basic/OpenMPKinds.def"
221    }
222    llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
223  case OMPC_schedule:
224    switch (Type) {
225    case OMPC_SCHEDULE_unknown:
226    case OMPC_SCHEDULE_MODIFIER_last:
227      return "unknown";
228#define OPENMP_SCHEDULE_KIND(Name)                                             \
229    case OMPC_SCHEDULE_##Name:                                                 \
230      return #Name;
231#define OPENMP_SCHEDULE_MODIFIER(Name)                                         \
232    case OMPC_SCHEDULE_MODIFIER_##Name:                                        \
233      return #Name;
234#include "clang/Basic/OpenMPKinds.def"
235    }
236    llvm_unreachable("Invalid OpenMP 'schedule' clause type");
237  case OMPC_depend:
238    switch (Type) {
239    case OMPC_DEPEND_unknown:
240      return "unknown";
241#define OPENMP_DEPEND_KIND(Name)                                             \
242  case OMPC_DEPEND_##Name:                                                   \
243    return #Name;
244#include "clang/Basic/OpenMPKinds.def"
245    }
246    llvm_unreachable("Invalid OpenMP 'depend' clause type");
247  case OMPC_linear:
248    switch (Type) {
249    case OMPC_LINEAR_unknown:
250      return "unknown";
251#define OPENMP_LINEAR_KIND(Name)                                             \
252  case OMPC_LINEAR_##Name:                                                   \
253    return #Name;
254#include "clang/Basic/OpenMPKinds.def"
255    }
256    llvm_unreachable("Invalid OpenMP 'linear' clause type");
257  case OMPC_map:
258    switch (Type) {
259    case OMPC_MAP_unknown:
260    case OMPC_MAP_MODIFIER_last:
261      return "unknown";
262#define OPENMP_MAP_KIND(Name)                                                \
263  case OMPC_MAP_##Name:                                                      \
264    return #Name;
265#define OPENMP_MAP_MODIFIER_KIND(Name)                                       \
266  case OMPC_MAP_MODIFIER_##Name:                                             \
267    return #Name;
268#include "clang/Basic/OpenMPKinds.def"
269    default:
270      break;
271    }
272    llvm_unreachable("Invalid OpenMP 'map' clause type");
273  case OMPC_to:
274    switch (Type) {
275    case OMPC_TO_MODIFIER_unknown:
276      return "unknown";
277#define OPENMP_TO_MODIFIER_KIND(Name)                                          \
278  case OMPC_TO_MODIFIER_##Name:                                                \
279    return #Name;
280#include "clang/Basic/OpenMPKinds.def"
281    default:
282      break;
283    }
284    llvm_unreachable("Invalid OpenMP 'to' clause type");
285  case OMPC_from:
286    switch (Type) {
287    case OMPC_FROM_MODIFIER_unknown:
288      return "unknown";
289#define OPENMP_FROM_MODIFIER_KIND(Name)                                        \
290  case OMPC_FROM_MODIFIER_##Name:                                              \
291    return #Name;
292#include "clang/Basic/OpenMPKinds.def"
293    default:
294      break;
295    }
296    llvm_unreachable("Invalid OpenMP 'from' clause type");
297  case OMPC_dist_schedule:
298    switch (Type) {
299    case OMPC_DIST_SCHEDULE_unknown:
300      return "unknown";
301#define OPENMP_DIST_SCHEDULE_KIND(Name)                                      \
302  case OMPC_DIST_SCHEDULE_##Name:                                            \
303    return #Name;
304#include "clang/Basic/OpenMPKinds.def"
305    }
306    llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type");
307  case OMPC_defaultmap:
308    switch (Type) {
309    case OMPC_DEFAULTMAP_unknown:
310    case OMPC_DEFAULTMAP_MODIFIER_last:
311      return "unknown";
312#define OPENMP_DEFAULTMAP_KIND(Name)                                         \
313    case OMPC_DEFAULTMAP_##Name:                                             \
314      return #Name;
315#define OPENMP_DEFAULTMAP_MODIFIER(Name)                                     \
316    case OMPC_DEFAULTMAP_MODIFIER_##Name:                                    \
317      return #Name;
318#include "clang/Basic/OpenMPKinds.def"
319    }
320    llvm_unreachable("Invalid OpenMP 'schedule' clause type");
321  case OMPC_atomic_default_mem_order:
322    switch (Type) {
323    case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown:
324      return "unknown";
325#define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name)                           \
326    case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name:                               \
327      return #Name;
328#include "clang/Basic/OpenMPKinds.def"
329}
330    llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type");
331  case OMPC_unknown:
332  case OMPC_threadprivate:
333  case OMPC_if:
334  case OMPC_final:
335  case OMPC_num_threads:
336  case OMPC_safelen:
337  case OMPC_simdlen:
338  case OMPC_allocator:
339  case OMPC_allocate:
340  case OMPC_collapse:
341  case OMPC_private:
342  case OMPC_firstprivate:
343  case OMPC_lastprivate:
344  case OMPC_shared:
345  case OMPC_reduction:
346  case OMPC_task_reduction:
347  case OMPC_in_reduction:
348  case OMPC_aligned:
349  case OMPC_copyin:
350  case OMPC_copyprivate:
351  case OMPC_ordered:
352  case OMPC_nowait:
353  case OMPC_untied:
354  case OMPC_mergeable:
355  case OMPC_flush:
356  case OMPC_read:
357  case OMPC_write:
358  case OMPC_update:
359  case OMPC_capture:
360  case OMPC_seq_cst:
361  case OMPC_device:
362  case OMPC_threads:
363  case OMPC_simd:
364  case OMPC_num_teams:
365  case OMPC_thread_limit:
366  case OMPC_priority:
367  case OMPC_grainsize:
368  case OMPC_nogroup:
369  case OMPC_num_tasks:
370  case OMPC_hint:
371  case OMPC_uniform:
372  case OMPC_use_device_ptr:
373  case OMPC_is_device_ptr:
374  case OMPC_unified_address:
375  case OMPC_unified_shared_memory:
376  case OMPC_reverse_offload:
377  case OMPC_dynamic_allocators:
378    break;
379  }
380  llvm_unreachable("Invalid OpenMP simple clause kind");
381}
382
383bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
384                                        OpenMPClauseKind CKind) {
385  assert(DKind <= OMPD_unknown);
386  assert(CKind <= OMPC_unknown);
387  switch (DKind) {
388  case OMPD_parallel:
389    switch (CKind) {
390#define OPENMP_PARALLEL_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_simd:
399    switch (CKind) {
400#define OPENMP_SIMD_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_for:
409    switch (CKind) {
410#define OPENMP_FOR_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_for_simd:
419    switch (CKind) {
420#define OPENMP_FOR_SIMD_CLAUSE(Name)                                           \
421  case OMPC_##Name:                                                            \
422    return true;
423#include "clang/Basic/OpenMPKinds.def"
424    default:
425      break;
426    }
427    break;
428  case OMPD_sections:
429    switch (CKind) {
430#define OPENMP_SECTIONS_CLAUSE(Name)                                           \
431  case OMPC_##Name:                                                            \
432    return true;
433#include "clang/Basic/OpenMPKinds.def"
434    default:
435      break;
436    }
437    break;
438  case OMPD_single:
439    switch (CKind) {
440#define OPENMP_SINGLE_CLAUSE(Name)                                             \
441  case OMPC_##Name:                                                            \
442    return true;
443#include "clang/Basic/OpenMPKinds.def"
444    default:
445      break;
446    }
447    break;
448  case OMPD_parallel_for:
449    switch (CKind) {
450#define OPENMP_PARALLEL_FOR_CLAUSE(Name)                                       \
451  case OMPC_##Name:                                                            \
452    return true;
453#include "clang/Basic/OpenMPKinds.def"
454    default:
455      break;
456    }
457    break;
458  case OMPD_parallel_for_simd:
459    switch (CKind) {
460#define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name)                                  \
461  case OMPC_##Name:                                                            \
462    return true;
463#include "clang/Basic/OpenMPKinds.def"
464    default:
465      break;
466    }
467    break;
468  case OMPD_parallel_sections:
469    switch (CKind) {
470#define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name)                                  \
471  case OMPC_##Name:                                                            \
472    return true;
473#include "clang/Basic/OpenMPKinds.def"
474    default:
475      break;
476    }
477    break;
478  case OMPD_task:
479    switch (CKind) {
480#define OPENMP_TASK_CLAUSE(Name)                                               \
481  case OMPC_##Name:                                                            \
482    return true;
483#include "clang/Basic/OpenMPKinds.def"
484    default:
485      break;
486    }
487    break;
488  case OMPD_flush:
489    return CKind == OMPC_flush;
490    break;
491  case OMPD_atomic:
492    switch (CKind) {
493#define OPENMP_ATOMIC_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_target:
502    switch (CKind) {
503#define OPENMP_TARGET_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_requires:
512    switch (CKind) {
513#define OPENMP_REQUIRES_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_target_data:
522    switch (CKind) {
523#define OPENMP_TARGET_DATA_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_target_enter_data:
532    switch (CKind) {
533#define OPENMP_TARGET_ENTER_DATA_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_target_exit_data:
542    switch (CKind) {
543#define OPENMP_TARGET_EXIT_DATA_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_target_parallel:
552    switch (CKind) {
553#define OPENMP_TARGET_PARALLEL_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_target_parallel_for:
562    switch (CKind) {
563#define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name)                                \
564  case OMPC_##Name:                                                            \
565    return true;
566#include "clang/Basic/OpenMPKinds.def"
567    default:
568      break;
569    }
570    break;
571  case OMPD_target_update:
572    switch (CKind) {
573#define OPENMP_TARGET_UPDATE_CLAUSE(Name)                                      \
574  case OMPC_##Name:                                                            \
575    return true;
576#include "clang/Basic/OpenMPKinds.def"
577    default:
578      break;
579    }
580    break;
581  case OMPD_teams:
582    switch (CKind) {
583#define OPENMP_TEAMS_CLAUSE(Name)                                              \
584  case OMPC_##Name:                                                            \
585    return true;
586#include "clang/Basic/OpenMPKinds.def"
587    default:
588      break;
589    }
590    break;
591  case OMPD_declare_simd:
592    break;
593  case OMPD_cancel:
594    switch (CKind) {
595#define OPENMP_CANCEL_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_ordered:
604    switch (CKind) {
605#define OPENMP_ORDERED_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_taskloop:
614    switch (CKind) {
615#define OPENMP_TASKLOOP_CLAUSE(Name)                                           \
616  case OMPC_##Name:                                                            \
617    return true;
618#include "clang/Basic/OpenMPKinds.def"
619    default:
620      break;
621    }
622    break;
623  case OMPD_taskloop_simd:
624    switch (CKind) {
625#define OPENMP_TASKLOOP_SIMD_CLAUSE(Name)                                      \
626  case OMPC_##Name:                                                            \
627    return true;
628#include "clang/Basic/OpenMPKinds.def"
629    default:
630      break;
631    }
632    break;
633  case OMPD_critical:
634    switch (CKind) {
635#define OPENMP_CRITICAL_CLAUSE(Name)                                           \
636  case OMPC_##Name:                                                            \
637    return true;
638#include "clang/Basic/OpenMPKinds.def"
639    default:
640      break;
641    }
642    break;
643  case OMPD_distribute:
644    switch (CKind) {
645#define OPENMP_DISTRIBUTE_CLAUSE(Name)                                         \
646  case OMPC_##Name:                                                            \
647    return true;
648#include "clang/Basic/OpenMPKinds.def"
649    default:
650      break;
651    }
652    break;
653  case OMPD_distribute_parallel_for:
654    switch (CKind) {
655#define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name)                            \
656  case OMPC_##Name:                                                            \
657    return true;
658#include "clang/Basic/OpenMPKinds.def"
659    default:
660      break;
661    }
662    break;
663  case OMPD_distribute_parallel_for_simd:
664    switch (CKind) {
665#define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name)                       \
666  case OMPC_##Name:                                                            \
667    return true;
668#include "clang/Basic/OpenMPKinds.def"
669    default:
670      break;
671    }
672    break;
673  case OMPD_distribute_simd:
674    switch (CKind) {
675#define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name)                                    \
676  case OMPC_##Name:                                                            \
677    return true;
678#include "clang/Basic/OpenMPKinds.def"
679    default:
680      break;
681    }
682    break;
683  case OMPD_target_parallel_for_simd:
684    switch (CKind) {
685#define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name)                           \
686  case OMPC_##Name:                                                            \
687    return true;
688#include "clang/Basic/OpenMPKinds.def"
689    default:
690      break;
691    }
692    break;
693  case OMPD_target_simd:
694    switch (CKind) {
695#define OPENMP_TARGET_SIMD_CLAUSE(Name)                                        \
696  case OMPC_##Name:                                                            \
697    return true;
698#include "clang/Basic/OpenMPKinds.def"
699    default:
700      break;
701    }
702    break;
703  case OMPD_teams_distribute:
704    switch (CKind) {
705#define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name)                                   \
706  case OMPC_##Name:                                                            \
707    return true;
708#include "clang/Basic/OpenMPKinds.def"
709    default:
710      break;
711    }
712    break;
713  case OMPD_teams_distribute_simd:
714    switch (CKind) {
715#define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name)                              \
716  case OMPC_##Name:                                                            \
717    return true;
718#include "clang/Basic/OpenMPKinds.def"
719    default:
720      break;
721    }
722    break;
723  case OMPD_teams_distribute_parallel_for_simd:
724    switch (CKind) {
725#define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name)                 \
726  case OMPC_##Name:                                                            \
727    return true;
728#include "clang/Basic/OpenMPKinds.def"
729    default:
730      break;
731    }
732    break;
733  case OMPD_teams_distribute_parallel_for:
734    switch (CKind) {
735#define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name)                      \
736  case OMPC_##Name:                                                            \
737    return true;
738#include "clang/Basic/OpenMPKinds.def"
739    default:
740      break;
741    }
742    break;
743  case OMPD_target_teams:
744    switch (CKind) {
745#define OPENMP_TARGET_TEAMS_CLAUSE(Name)                                       \
746  case OMPC_##Name:                                                            \
747    return true;
748#include "clang/Basic/OpenMPKinds.def"
749    default:
750      break;
751    }
752    break;
753  case OMPD_target_teams_distribute:
754    switch (CKind) {
755#define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name)                            \
756  case OMPC_##Name:                                                            \
757    return true;
758#include "clang/Basic/OpenMPKinds.def"
759    default:
760      break;
761    }
762    break;
763  case OMPD_target_teams_distribute_parallel_for:
764    switch (CKind) {
765#define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name)               \
766  case OMPC_##Name:                                                            \
767    return true;
768#include "clang/Basic/OpenMPKinds.def"
769    default:
770      break;
771    }
772    break;
773  case OMPD_target_teams_distribute_parallel_for_simd:
774    switch (CKind) {
775#define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name)          \
776  case OMPC_##Name:                                                            \
777    return true;
778#include "clang/Basic/OpenMPKinds.def"
779    default:
780      break;
781    }
782    break;
783  case OMPD_target_teams_distribute_simd:
784    switch (CKind) {
785#define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name)                       \
786  case OMPC_##Name:                                                            \
787    return true;
788#include "clang/Basic/OpenMPKinds.def"
789    default:
790      break;
791    }
792    break;
793  case OMPD_taskgroup:
794    switch (CKind) {
795#define OPENMP_TASKGROUP_CLAUSE(Name)                                          \
796  case OMPC_##Name:                                                            \
797    return true;
798#include "clang/Basic/OpenMPKinds.def"
799    default:
800      break;
801    }
802    break;
803  case OMPD_declare_mapper:
804    switch (CKind) {
805#define OPENMP_DECLARE_MAPPER_CLAUSE(Name)                                     \
806  case OMPC_##Name:                                                            \
807    return true;
808#include "clang/Basic/OpenMPKinds.def"
809    default:
810      break;
811    }
812    break;
813  case OMPD_allocate:
814    switch (CKind) {
815#define OPENMP_ALLOCATE_CLAUSE(Name)                                           \
816  case OMPC_##Name:                                                            \
817    return true;
818#include "clang/Basic/OpenMPKinds.def"
819    default:
820      break;
821    }
822    break;
823  case OMPD_declare_target:
824  case OMPD_end_declare_target:
825  case OMPD_unknown:
826  case OMPD_threadprivate:
827  case OMPD_section:
828  case OMPD_master:
829  case OMPD_taskyield:
830  case OMPD_barrier:
831  case OMPD_taskwait:
832  case OMPD_cancellation_point:
833  case OMPD_declare_reduction:
834    break;
835  }
836  return false;
837}
838
839bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
840  return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
841         DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
842         DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
843         DKind == OMPD_distribute || DKind == OMPD_target_parallel_for ||
844         DKind == OMPD_distribute_parallel_for ||
845         DKind == OMPD_distribute_parallel_for_simd ||
846         DKind == OMPD_distribute_simd ||
847         DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
848         DKind == OMPD_teams_distribute ||
849         DKind == OMPD_teams_distribute_simd ||
850         DKind == OMPD_teams_distribute_parallel_for_simd ||
851         DKind == OMPD_teams_distribute_parallel_for ||
852         DKind == OMPD_target_teams_distribute ||
853         DKind == OMPD_target_teams_distribute_parallel_for ||
854         DKind == OMPD_target_teams_distribute_parallel_for_simd ||
855         DKind == OMPD_target_teams_distribute_simd;
856}
857
858bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
859  return DKind == OMPD_for || DKind == OMPD_for_simd ||
860         DKind == OMPD_sections || DKind == OMPD_section ||
861         DKind == OMPD_single || DKind == OMPD_parallel_for ||
862         DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
863         DKind == OMPD_target_parallel_for ||
864         DKind == OMPD_distribute_parallel_for ||
865         DKind == OMPD_distribute_parallel_for_simd ||
866         DKind == OMPD_target_parallel_for_simd ||
867         DKind == OMPD_teams_distribute_parallel_for_simd ||
868         DKind == OMPD_teams_distribute_parallel_for ||
869         DKind == OMPD_target_teams_distribute_parallel_for ||
870         DKind == OMPD_target_teams_distribute_parallel_for_simd;
871}
872
873bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
874  return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd;
875}
876
877bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
878  return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
879         DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
880         DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for ||
881         DKind == OMPD_distribute_parallel_for ||
882         DKind == OMPD_distribute_parallel_for_simd ||
883         DKind == OMPD_target_parallel_for_simd ||
884         DKind == OMPD_teams_distribute_parallel_for ||
885         DKind == OMPD_teams_distribute_parallel_for_simd ||
886         DKind == OMPD_target_teams_distribute_parallel_for ||
887         DKind == OMPD_target_teams_distribute_parallel_for_simd;
888}
889
890bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) {
891  return DKind == OMPD_target || DKind == OMPD_target_parallel ||
892         DKind == OMPD_target_parallel_for ||
893         DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
894         DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
895         DKind == OMPD_target_teams_distribute_parallel_for ||
896         DKind == OMPD_target_teams_distribute_parallel_for_simd ||
897         DKind == OMPD_target_teams_distribute_simd;
898}
899
900bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) {
901  return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
902         DKind == OMPD_target_exit_data || DKind == OMPD_target_update;
903}
904
905bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) {
906  return DKind == OMPD_teams || DKind == OMPD_teams_distribute ||
907         DKind == OMPD_teams_distribute_simd ||
908         DKind == OMPD_teams_distribute_parallel_for_simd ||
909         DKind == OMPD_teams_distribute_parallel_for;
910}
911
912bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
913  return isOpenMPNestingTeamsDirective(DKind) ||
914         DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
915         DKind == OMPD_target_teams_distribute_parallel_for ||
916         DKind == OMPD_target_teams_distribute_parallel_for_simd ||
917         DKind == OMPD_target_teams_distribute_simd;
918}
919
920bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
921  return DKind == OMPD_simd || DKind == OMPD_for_simd ||
922         DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd ||
923         DKind == OMPD_distribute_parallel_for_simd ||
924         DKind == OMPD_distribute_simd || DKind == OMPD_target_simd ||
925         DKind == OMPD_teams_distribute_simd ||
926         DKind == OMPD_teams_distribute_parallel_for_simd ||
927         DKind == OMPD_target_teams_distribute_parallel_for_simd ||
928         DKind == OMPD_target_teams_distribute_simd ||
929         DKind == OMPD_target_parallel_for_simd;
930}
931
932bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) {
933  return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for ||
934         Kind == OMPD_distribute_parallel_for_simd ||
935         Kind == OMPD_distribute_simd;
936  // TODO add next directives.
937}
938
939bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) {
940  return isOpenMPNestingDistributeDirective(Kind) ||
941         Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd ||
942         Kind == OMPD_teams_distribute_parallel_for_simd ||
943         Kind == OMPD_teams_distribute_parallel_for ||
944         Kind == OMPD_target_teams_distribute ||
945         Kind == OMPD_target_teams_distribute_parallel_for ||
946         Kind == OMPD_target_teams_distribute_parallel_for_simd ||
947         Kind == OMPD_target_teams_distribute_simd;
948}
949
950bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
951  return Kind == OMPC_private || Kind == OMPC_firstprivate ||
952         Kind == OMPC_lastprivate || Kind == OMPC_linear ||
953         Kind == OMPC_reduction || Kind == OMPC_task_reduction ||
954         Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'.
955}
956
957bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
958  return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
959}
960
961bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) {
962  return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
963}
964
965bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) {
966  return Kind == OMPD_distribute_parallel_for ||
967         Kind == OMPD_distribute_parallel_for_simd ||
968         Kind == OMPD_teams_distribute_parallel_for_simd ||
969         Kind == OMPD_teams_distribute_parallel_for ||
970         Kind == OMPD_target_teams_distribute_parallel_for ||
971         Kind == OMPD_target_teams_distribute_parallel_for_simd;
972}
973
974void clang::getOpenMPCaptureRegions(
975    SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions,
976    OpenMPDirectiveKind DKind) {
977  assert(DKind <= OMPD_unknown);
978  switch (DKind) {
979  case OMPD_parallel:
980  case OMPD_parallel_for:
981  case OMPD_parallel_for_simd:
982  case OMPD_parallel_sections:
983  case OMPD_distribute_parallel_for:
984  case OMPD_distribute_parallel_for_simd:
985    CaptureRegions.push_back(OMPD_parallel);
986    break;
987  case OMPD_target_teams:
988  case OMPD_target_teams_distribute:
989  case OMPD_target_teams_distribute_simd:
990    CaptureRegions.push_back(OMPD_task);
991    CaptureRegions.push_back(OMPD_target);
992    CaptureRegions.push_back(OMPD_teams);
993    break;
994  case OMPD_teams:
995  case OMPD_teams_distribute:
996  case OMPD_teams_distribute_simd:
997    CaptureRegions.push_back(OMPD_teams);
998    break;
999  case OMPD_target:
1000  case OMPD_target_simd:
1001    CaptureRegions.push_back(OMPD_task);
1002    CaptureRegions.push_back(OMPD_target);
1003    break;
1004  case OMPD_teams_distribute_parallel_for:
1005  case OMPD_teams_distribute_parallel_for_simd:
1006    CaptureRegions.push_back(OMPD_teams);
1007    CaptureRegions.push_back(OMPD_parallel);
1008    break;
1009  case OMPD_target_parallel:
1010  case OMPD_target_parallel_for:
1011  case OMPD_target_parallel_for_simd:
1012    CaptureRegions.push_back(OMPD_task);
1013    CaptureRegions.push_back(OMPD_target);
1014    CaptureRegions.push_back(OMPD_parallel);
1015    break;
1016  case OMPD_task:
1017  case OMPD_target_enter_data:
1018  case OMPD_target_exit_data:
1019  case OMPD_target_update:
1020    CaptureRegions.push_back(OMPD_task);
1021    break;
1022  case OMPD_taskloop:
1023  case OMPD_taskloop_simd:
1024    CaptureRegions.push_back(OMPD_taskloop);
1025    break;
1026  case OMPD_target_teams_distribute_parallel_for:
1027  case OMPD_target_teams_distribute_parallel_for_simd:
1028    CaptureRegions.push_back(OMPD_task);
1029    CaptureRegions.push_back(OMPD_target);
1030    CaptureRegions.push_back(OMPD_teams);
1031    CaptureRegions.push_back(OMPD_parallel);
1032    break;
1033  case OMPD_simd:
1034  case OMPD_for:
1035  case OMPD_for_simd:
1036  case OMPD_sections:
1037  case OMPD_section:
1038  case OMPD_single:
1039  case OMPD_master:
1040  case OMPD_critical:
1041  case OMPD_taskgroup:
1042  case OMPD_distribute:
1043  case OMPD_ordered:
1044  case OMPD_atomic:
1045  case OMPD_target_data:
1046  case OMPD_distribute_simd:
1047    CaptureRegions.push_back(OMPD_unknown);
1048    break;
1049  case OMPD_threadprivate:
1050  case OMPD_allocate:
1051  case OMPD_taskyield:
1052  case OMPD_barrier:
1053  case OMPD_taskwait:
1054  case OMPD_cancellation_point:
1055  case OMPD_cancel:
1056  case OMPD_flush:
1057  case OMPD_declare_reduction:
1058  case OMPD_declare_mapper:
1059  case OMPD_declare_simd:
1060  case OMPD_declare_target:
1061  case OMPD_end_declare_target:
1062  case OMPD_requires:
1063    llvm_unreachable("OpenMP Directive is not allowed");
1064  case OMPD_unknown:
1065    llvm_unreachable("Unknown OpenMP directive");
1066  }
1067}
1068
CodeThinker, Enjoy your reading code