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 
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       .Default(OMPC_unknown);
59 }
60 
61 const 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_threadprivate:
71     return "threadprivate or thread local";
72   }
73   llvm_unreachable("Invalid OpenMP clause kind");
74 }
75 
76 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind,
77                                           StringRef Str) {
78   switch (Kind) {
79   case OMPC_default:
80     return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str)
81 #define OPENMP_DEFAULT_KIND(Name) .Case(#Name, OMPC_DEFAULT_##Name)
82 #include "clang/Basic/OpenMPKinds.def"
83         .Default(OMPC_DEFAULT_unknown);
84   case OMPC_proc_bind:
85     return llvm::StringSwitch<OpenMPProcBindClauseKind>(Str)
86 #define OPENMP_PROC_BIND_KIND(Name) .Case(#Name, OMPC_PROC_BIND_##Name)
87 #include "clang/Basic/OpenMPKinds.def"
88         .Default(OMPC_PROC_BIND_unknown);
89   case OMPC_schedule:
90     return llvm::StringSwitch<OpenMPScheduleClauseKind>(Str)
91 #define OPENMP_SCHEDULE_KIND(Name) .Case(#Name, OMPC_SCHEDULE_##Name)
92 #include "clang/Basic/OpenMPKinds.def"
93         .Default(OMPC_SCHEDULE_unknown);
94   case OMPC_depend:
95     return llvm::StringSwitch<OpenMPDependClauseKind>(Str)
96 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name)
97 #include "clang/Basic/OpenMPKinds.def"
98         .Default(OMPC_DEPEND_unknown);
99   case OMPC_linear:
100     return llvm::StringSwitch<OpenMPLinearClauseKind>(Str)
101 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name)
102 #include "clang/Basic/OpenMPKinds.def"
103         .Default(OMPC_LINEAR_unknown);
104   case OMPC_unknown:
105   case OMPC_threadprivate:
106   case OMPC_if:
107   case OMPC_final:
108   case OMPC_num_threads:
109   case OMPC_safelen:
110   case OMPC_simdlen:
111   case OMPC_collapse:
112   case OMPC_private:
113   case OMPC_firstprivate:
114   case OMPC_lastprivate:
115   case OMPC_shared:
116   case OMPC_reduction:
117   case OMPC_aligned:
118   case OMPC_copyin:
119   case OMPC_copyprivate:
120   case OMPC_ordered:
121   case OMPC_nowait:
122   case OMPC_untied:
123   case OMPC_mergeable:
124   case OMPC_flush:
125   case OMPC_read:
126   case OMPC_write:
127   case OMPC_update:
128   case OMPC_capture:
129   case OMPC_seq_cst:
130   case OMPC_device:
131   case OMPC_threads:
132   case OMPC_simd:
133     break;
134   }
135   llvm_unreachable("Invalid OpenMP simple clause kind");
136 }
137 
138 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
139                                                  unsigned Type) {
140   switch (Kind) {
141   case OMPC_default:
142     switch (Type) {
143     case OMPC_DEFAULT_unknown:
144       return "unknown";
145 #define OPENMP_DEFAULT_KIND(Name)                                              \
146   case OMPC_DEFAULT_##Name:                                                    \
147     return #Name;
148 #include "clang/Basic/OpenMPKinds.def"
149     }
150     llvm_unreachable("Invalid OpenMP 'default' clause type");
151   case OMPC_proc_bind:
152     switch (Type) {
153     case OMPC_PROC_BIND_unknown:
154       return "unknown";
155 #define OPENMP_PROC_BIND_KIND(Name)                                            \
156   case OMPC_PROC_BIND_##Name:                                                  \
157     return #Name;
158 #include "clang/Basic/OpenMPKinds.def"
159     }
160     llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
161   case OMPC_schedule:
162     switch (Type) {
163     case OMPC_SCHEDULE_unknown:
164       return "unknown";
165 #define OPENMP_SCHEDULE_KIND(Name)                                             \
166   case OMPC_SCHEDULE_##Name:                                                   \
167     return #Name;
168 #include "clang/Basic/OpenMPKinds.def"
169     }
170   case OMPC_depend:
171     switch (Type) {
172     case OMPC_DEPEND_unknown:
173       return "unknown";
174 #define OPENMP_DEPEND_KIND(Name)                                             \
175   case OMPC_DEPEND_##Name:                                                   \
176     return #Name;
177 #include "clang/Basic/OpenMPKinds.def"
178     }
179     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
180   case OMPC_linear:
181     switch (Type) {
182     case OMPC_LINEAR_unknown:
183       return "unknown";
184 #define OPENMP_LINEAR_KIND(Name)                                             \
185   case OMPC_LINEAR_##Name:                                                   \
186     return #Name;
187 #include "clang/Basic/OpenMPKinds.def"
188     }
189     llvm_unreachable("Invalid OpenMP 'linear' clause type");
190   case OMPC_unknown:
191   case OMPC_threadprivate:
192   case OMPC_if:
193   case OMPC_final:
194   case OMPC_num_threads:
195   case OMPC_safelen:
196   case OMPC_simdlen:
197   case OMPC_collapse:
198   case OMPC_private:
199   case OMPC_firstprivate:
200   case OMPC_lastprivate:
201   case OMPC_shared:
202   case OMPC_reduction:
203   case OMPC_aligned:
204   case OMPC_copyin:
205   case OMPC_copyprivate:
206   case OMPC_ordered:
207   case OMPC_nowait:
208   case OMPC_untied:
209   case OMPC_mergeable:
210   case OMPC_flush:
211   case OMPC_read:
212   case OMPC_write:
213   case OMPC_update:
214   case OMPC_capture:
215   case OMPC_seq_cst:
216   case OMPC_device:
217   case OMPC_threads:
218   case OMPC_simd:
219     break;
220   }
221   llvm_unreachable("Invalid OpenMP simple clause kind");
222 }
223 
224 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
225                                         OpenMPClauseKind CKind) {
226   assert(DKind <= OMPD_unknown);
227   assert(CKind <= OMPC_unknown);
228   switch (DKind) {
229   case OMPD_parallel:
230     switch (CKind) {
231 #define OPENMP_PARALLEL_CLAUSE(Name)                                           \
232   case OMPC_##Name:                                                            \
233     return true;
234 #include "clang/Basic/OpenMPKinds.def"
235     default:
236       break;
237     }
238     break;
239   case OMPD_simd:
240     switch (CKind) {
241 #define OPENMP_SIMD_CLAUSE(Name)                                               \
242   case OMPC_##Name:                                                            \
243     return true;
244 #include "clang/Basic/OpenMPKinds.def"
245     default:
246       break;
247     }
248     break;
249   case OMPD_for:
250     switch (CKind) {
251 #define OPENMP_FOR_CLAUSE(Name)                                                \
252   case OMPC_##Name:                                                            \
253     return true;
254 #include "clang/Basic/OpenMPKinds.def"
255     default:
256       break;
257     }
258     break;
259   case OMPD_for_simd:
260     switch (CKind) {
261 #define OPENMP_FOR_SIMD_CLAUSE(Name)                                           \
262   case OMPC_##Name:                                                            \
263     return true;
264 #include "clang/Basic/OpenMPKinds.def"
265     default:
266       break;
267     }
268     break;
269   case OMPD_sections:
270     switch (CKind) {
271 #define OPENMP_SECTIONS_CLAUSE(Name)                                           \
272   case OMPC_##Name:                                                            \
273     return true;
274 #include "clang/Basic/OpenMPKinds.def"
275     default:
276       break;
277     }
278     break;
279   case OMPD_single:
280     switch (CKind) {
281 #define OPENMP_SINGLE_CLAUSE(Name)                                             \
282   case OMPC_##Name:                                                            \
283     return true;
284 #include "clang/Basic/OpenMPKinds.def"
285     default:
286       break;
287     }
288     break;
289   case OMPD_parallel_for:
290     switch (CKind) {
291 #define OPENMP_PARALLEL_FOR_CLAUSE(Name)                                       \
292   case OMPC_##Name:                                                            \
293     return true;
294 #include "clang/Basic/OpenMPKinds.def"
295     default:
296       break;
297     }
298     break;
299   case OMPD_parallel_for_simd:
300     switch (CKind) {
301 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name)                                  \
302   case OMPC_##Name:                                                            \
303     return true;
304 #include "clang/Basic/OpenMPKinds.def"
305     default:
306       break;
307     }
308     break;
309   case OMPD_parallel_sections:
310     switch (CKind) {
311 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name)                                  \
312   case OMPC_##Name:                                                            \
313     return true;
314 #include "clang/Basic/OpenMPKinds.def"
315     default:
316       break;
317     }
318     break;
319   case OMPD_task:
320     switch (CKind) {
321 #define OPENMP_TASK_CLAUSE(Name)                                               \
322   case OMPC_##Name:                                                            \
323     return true;
324 #include "clang/Basic/OpenMPKinds.def"
325     default:
326       break;
327     }
328     break;
329   case OMPD_flush:
330     return CKind == OMPC_flush;
331     break;
332   case OMPD_atomic:
333     switch (CKind) {
334 #define OPENMP_ATOMIC_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_target:
343     switch (CKind) {
344 #define OPENMP_TARGET_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_target_data:
353     switch (CKind) {
354 #define OPENMP_TARGET_DATA_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_teams:
363     switch (CKind) {
364 #define OPENMP_TEAMS_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_cancel:
373     switch (CKind) {
374 #define OPENMP_CANCEL_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_ordered:
383     switch (CKind) {
384 #define OPENMP_ORDERED_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_unknown:
393   case OMPD_threadprivate:
394   case OMPD_section:
395   case OMPD_master:
396   case OMPD_critical:
397   case OMPD_taskyield:
398   case OMPD_barrier:
399   case OMPD_taskwait:
400   case OMPD_taskgroup:
401   case OMPD_cancellation_point:
402     break;
403   }
404   return false;
405 }
406 
407 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
408   return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
409          DKind == OMPD_parallel_for ||
410          DKind == OMPD_parallel_for_simd; // TODO add next directives.
411 }
412 
413 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
414   return DKind == OMPD_for || DKind == OMPD_for_simd ||
415          DKind == OMPD_sections || DKind == OMPD_section ||
416          DKind == OMPD_single || DKind == OMPD_parallel_for ||
417          DKind == OMPD_parallel_for_simd ||
418          DKind == OMPD_parallel_sections; // TODO add next directives.
419 }
420 
421 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
422   return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
423          DKind == OMPD_parallel_for_simd ||
424          DKind == OMPD_parallel_sections; // TODO add next directives.
425 }
426 
427 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
428   return DKind == OMPD_teams; // TODO add next directives.
429 }
430 
431 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
432   return DKind == OMPD_simd || DKind == OMPD_for_simd ||
433          DKind == OMPD_parallel_for_simd; // TODO add next directives.
434 }
435 
436 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
437   return Kind == OMPC_private || Kind == OMPC_firstprivate ||
438          Kind == OMPC_lastprivate || Kind == OMPC_linear ||
439          Kind == OMPC_reduction; // TODO add next clauses like 'reduction'.
440 }
441 
442 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
443   return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
444 }
445 
446