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_map:
105     return llvm::StringSwitch<OpenMPMapClauseKind>(Str)
106 #define OPENMP_MAP_KIND(Name) .Case(#Name, OMPC_MAP_##Name)
107 #include "clang/Basic/OpenMPKinds.def"
108         .Default(OMPC_MAP_unknown);
109   case OMPC_unknown:
110   case OMPC_threadprivate:
111   case OMPC_if:
112   case OMPC_final:
113   case OMPC_num_threads:
114   case OMPC_safelen:
115   case OMPC_simdlen:
116   case OMPC_collapse:
117   case OMPC_private:
118   case OMPC_firstprivate:
119   case OMPC_lastprivate:
120   case OMPC_shared:
121   case OMPC_reduction:
122   case OMPC_aligned:
123   case OMPC_copyin:
124   case OMPC_copyprivate:
125   case OMPC_ordered:
126   case OMPC_nowait:
127   case OMPC_untied:
128   case OMPC_mergeable:
129   case OMPC_flush:
130   case OMPC_read:
131   case OMPC_write:
132   case OMPC_update:
133   case OMPC_capture:
134   case OMPC_seq_cst:
135   case OMPC_device:
136   case OMPC_threads:
137   case OMPC_simd:
138   case OMPC_num_teams:
139   case OMPC_thread_limit:
140     break;
141   }
142   llvm_unreachable("Invalid OpenMP simple clause kind");
143 }
144 
145 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
146                                                  unsigned Type) {
147   switch (Kind) {
148   case OMPC_default:
149     switch (Type) {
150     case OMPC_DEFAULT_unknown:
151       return "unknown";
152 #define OPENMP_DEFAULT_KIND(Name)                                              \
153   case OMPC_DEFAULT_##Name:                                                    \
154     return #Name;
155 #include "clang/Basic/OpenMPKinds.def"
156     }
157     llvm_unreachable("Invalid OpenMP 'default' clause type");
158   case OMPC_proc_bind:
159     switch (Type) {
160     case OMPC_PROC_BIND_unknown:
161       return "unknown";
162 #define OPENMP_PROC_BIND_KIND(Name)                                            \
163   case OMPC_PROC_BIND_##Name:                                                  \
164     return #Name;
165 #include "clang/Basic/OpenMPKinds.def"
166     }
167     llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
168   case OMPC_schedule:
169     switch (Type) {
170     case OMPC_SCHEDULE_unknown:
171       return "unknown";
172 #define OPENMP_SCHEDULE_KIND(Name)                                             \
173   case OMPC_SCHEDULE_##Name:                                                   \
174     return #Name;
175 #include "clang/Basic/OpenMPKinds.def"
176     }
177   case OMPC_depend:
178     switch (Type) {
179     case OMPC_DEPEND_unknown:
180       return "unknown";
181 #define OPENMP_DEPEND_KIND(Name)                                             \
182   case OMPC_DEPEND_##Name:                                                   \
183     return #Name;
184 #include "clang/Basic/OpenMPKinds.def"
185     }
186     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
187   case OMPC_linear:
188     switch (Type) {
189     case OMPC_LINEAR_unknown:
190       return "unknown";
191 #define OPENMP_LINEAR_KIND(Name)                                             \
192   case OMPC_LINEAR_##Name:                                                   \
193     return #Name;
194 #include "clang/Basic/OpenMPKinds.def"
195     }
196     llvm_unreachable("Invalid OpenMP 'linear' clause type");
197   case OMPC_map:
198     switch (Type) {
199     case OMPC_MAP_unknown:
200       return "unknown";
201 #define OPENMP_MAP_KIND(Name)                                                \
202   case OMPC_MAP_##Name:                                                      \
203     return #Name;
204 #include "clang/Basic/OpenMPKinds.def"
205     default:
206       break;
207     }
208     llvm_unreachable("Invalid OpenMP 'map' clause type");
209   case OMPC_unknown:
210   case OMPC_threadprivate:
211   case OMPC_if:
212   case OMPC_final:
213   case OMPC_num_threads:
214   case OMPC_safelen:
215   case OMPC_simdlen:
216   case OMPC_collapse:
217   case OMPC_private:
218   case OMPC_firstprivate:
219   case OMPC_lastprivate:
220   case OMPC_shared:
221   case OMPC_reduction:
222   case OMPC_aligned:
223   case OMPC_copyin:
224   case OMPC_copyprivate:
225   case OMPC_ordered:
226   case OMPC_nowait:
227   case OMPC_untied:
228   case OMPC_mergeable:
229   case OMPC_flush:
230   case OMPC_read:
231   case OMPC_write:
232   case OMPC_update:
233   case OMPC_capture:
234   case OMPC_seq_cst:
235   case OMPC_device:
236   case OMPC_threads:
237   case OMPC_simd:
238   case OMPC_num_teams:
239   case OMPC_thread_limit:
240     break;
241   }
242   llvm_unreachable("Invalid OpenMP simple clause kind");
243 }
244 
245 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
246                                         OpenMPClauseKind CKind) {
247   assert(DKind <= OMPD_unknown);
248   assert(CKind <= OMPC_unknown);
249   switch (DKind) {
250   case OMPD_parallel:
251     switch (CKind) {
252 #define OPENMP_PARALLEL_CLAUSE(Name)                                           \
253   case OMPC_##Name:                                                            \
254     return true;
255 #include "clang/Basic/OpenMPKinds.def"
256     default:
257       break;
258     }
259     break;
260   case OMPD_simd:
261     switch (CKind) {
262 #define OPENMP_SIMD_CLAUSE(Name)                                               \
263   case OMPC_##Name:                                                            \
264     return true;
265 #include "clang/Basic/OpenMPKinds.def"
266     default:
267       break;
268     }
269     break;
270   case OMPD_for:
271     switch (CKind) {
272 #define OPENMP_FOR_CLAUSE(Name)                                                \
273   case OMPC_##Name:                                                            \
274     return true;
275 #include "clang/Basic/OpenMPKinds.def"
276     default:
277       break;
278     }
279     break;
280   case OMPD_for_simd:
281     switch (CKind) {
282 #define OPENMP_FOR_SIMD_CLAUSE(Name)                                           \
283   case OMPC_##Name:                                                            \
284     return true;
285 #include "clang/Basic/OpenMPKinds.def"
286     default:
287       break;
288     }
289     break;
290   case OMPD_sections:
291     switch (CKind) {
292 #define OPENMP_SECTIONS_CLAUSE(Name)                                           \
293   case OMPC_##Name:                                                            \
294     return true;
295 #include "clang/Basic/OpenMPKinds.def"
296     default:
297       break;
298     }
299     break;
300   case OMPD_single:
301     switch (CKind) {
302 #define OPENMP_SINGLE_CLAUSE(Name)                                             \
303   case OMPC_##Name:                                                            \
304     return true;
305 #include "clang/Basic/OpenMPKinds.def"
306     default:
307       break;
308     }
309     break;
310   case OMPD_parallel_for:
311     switch (CKind) {
312 #define OPENMP_PARALLEL_FOR_CLAUSE(Name)                                       \
313   case OMPC_##Name:                                                            \
314     return true;
315 #include "clang/Basic/OpenMPKinds.def"
316     default:
317       break;
318     }
319     break;
320   case OMPD_parallel_for_simd:
321     switch (CKind) {
322 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name)                                  \
323   case OMPC_##Name:                                                            \
324     return true;
325 #include "clang/Basic/OpenMPKinds.def"
326     default:
327       break;
328     }
329     break;
330   case OMPD_parallel_sections:
331     switch (CKind) {
332 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name)                                  \
333   case OMPC_##Name:                                                            \
334     return true;
335 #include "clang/Basic/OpenMPKinds.def"
336     default:
337       break;
338     }
339     break;
340   case OMPD_task:
341     switch (CKind) {
342 #define OPENMP_TASK_CLAUSE(Name)                                               \
343   case OMPC_##Name:                                                            \
344     return true;
345 #include "clang/Basic/OpenMPKinds.def"
346     default:
347       break;
348     }
349     break;
350   case OMPD_flush:
351     return CKind == OMPC_flush;
352     break;
353   case OMPD_atomic:
354     switch (CKind) {
355 #define OPENMP_ATOMIC_CLAUSE(Name)                                             \
356   case OMPC_##Name:                                                            \
357     return true;
358 #include "clang/Basic/OpenMPKinds.def"
359     default:
360       break;
361     }
362     break;
363   case OMPD_target:
364     switch (CKind) {
365 #define OPENMP_TARGET_CLAUSE(Name)                                             \
366   case OMPC_##Name:                                                            \
367     return true;
368 #include "clang/Basic/OpenMPKinds.def"
369     default:
370       break;
371     }
372     break;
373   case OMPD_target_data:
374     switch (CKind) {
375 #define OPENMP_TARGET_DATA_CLAUSE(Name)                                        \
376   case OMPC_##Name:                                                            \
377     return true;
378 #include "clang/Basic/OpenMPKinds.def"
379     default:
380       break;
381     }
382     break;
383   case OMPD_teams:
384     switch (CKind) {
385 #define OPENMP_TEAMS_CLAUSE(Name)                                              \
386   case OMPC_##Name:                                                            \
387     return true;
388 #include "clang/Basic/OpenMPKinds.def"
389     default:
390       break;
391     }
392     break;
393   case OMPD_cancel:
394     switch (CKind) {
395 #define OPENMP_CANCEL_CLAUSE(Name)                                             \
396   case OMPC_##Name:                                                            \
397     return true;
398 #include "clang/Basic/OpenMPKinds.def"
399     default:
400       break;
401     }
402     break;
403   case OMPD_ordered:
404     switch (CKind) {
405 #define OPENMP_ORDERED_CLAUSE(Name)                                             \
406   case OMPC_##Name:                                                            \
407     return true;
408 #include "clang/Basic/OpenMPKinds.def"
409     default:
410       break;
411     }
412     break;
413   case OMPD_unknown:
414   case OMPD_threadprivate:
415   case OMPD_section:
416   case OMPD_master:
417   case OMPD_critical:
418   case OMPD_taskyield:
419   case OMPD_barrier:
420   case OMPD_taskwait:
421   case OMPD_taskgroup:
422   case OMPD_cancellation_point:
423     break;
424   }
425   return false;
426 }
427 
428 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
429   return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
430          DKind == OMPD_parallel_for ||
431          DKind == OMPD_parallel_for_simd; // TODO add next directives.
432 }
433 
434 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
435   return DKind == OMPD_for || DKind == OMPD_for_simd ||
436          DKind == OMPD_sections || DKind == OMPD_section ||
437          DKind == OMPD_single || DKind == OMPD_parallel_for ||
438          DKind == OMPD_parallel_for_simd ||
439          DKind == OMPD_parallel_sections; // TODO add next directives.
440 }
441 
442 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
443   return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
444          DKind == OMPD_parallel_for_simd ||
445          DKind == OMPD_parallel_sections; // TODO add next directives.
446 }
447 
448 bool clang::isOpenMPTargetDirective(OpenMPDirectiveKind DKind) {
449   return DKind == OMPD_target; // TODO add next directives.
450 }
451 
452 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
453   return DKind == OMPD_teams; // TODO add next directives.
454 }
455 
456 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
457   return DKind == OMPD_simd || DKind == OMPD_for_simd ||
458          DKind == OMPD_parallel_for_simd; // TODO add next directives.
459 }
460 
461 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
462   return Kind == OMPC_private || Kind == OMPC_firstprivate ||
463          Kind == OMPC_lastprivate || Kind == OMPC_linear ||
464          Kind == OMPC_reduction; // TODO add next clauses like 'reduction'.
465 }
466 
467 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
468   return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
469 }
470 
471