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   case OMPC_priority:
141     break;
142   }
143   llvm_unreachable("Invalid OpenMP simple clause kind");
144 }
145 
146 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
147                                                  unsigned Type) {
148   switch (Kind) {
149   case OMPC_default:
150     switch (Type) {
151     case OMPC_DEFAULT_unknown:
152       return "unknown";
153 #define OPENMP_DEFAULT_KIND(Name)                                              \
154   case OMPC_DEFAULT_##Name:                                                    \
155     return #Name;
156 #include "clang/Basic/OpenMPKinds.def"
157     }
158     llvm_unreachable("Invalid OpenMP 'default' clause type");
159   case OMPC_proc_bind:
160     switch (Type) {
161     case OMPC_PROC_BIND_unknown:
162       return "unknown";
163 #define OPENMP_PROC_BIND_KIND(Name)                                            \
164   case OMPC_PROC_BIND_##Name:                                                  \
165     return #Name;
166 #include "clang/Basic/OpenMPKinds.def"
167     }
168     llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
169   case OMPC_schedule:
170     switch (Type) {
171     case OMPC_SCHEDULE_unknown:
172       return "unknown";
173 #define OPENMP_SCHEDULE_KIND(Name)                                             \
174   case OMPC_SCHEDULE_##Name:                                                   \
175     return #Name;
176 #include "clang/Basic/OpenMPKinds.def"
177     }
178   case OMPC_depend:
179     switch (Type) {
180     case OMPC_DEPEND_unknown:
181       return "unknown";
182 #define OPENMP_DEPEND_KIND(Name)                                             \
183   case OMPC_DEPEND_##Name:                                                   \
184     return #Name;
185 #include "clang/Basic/OpenMPKinds.def"
186     }
187     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
188   case OMPC_linear:
189     switch (Type) {
190     case OMPC_LINEAR_unknown:
191       return "unknown";
192 #define OPENMP_LINEAR_KIND(Name)                                             \
193   case OMPC_LINEAR_##Name:                                                   \
194     return #Name;
195 #include "clang/Basic/OpenMPKinds.def"
196     }
197     llvm_unreachable("Invalid OpenMP 'linear' clause type");
198   case OMPC_map:
199     switch (Type) {
200     case OMPC_MAP_unknown:
201       return "unknown";
202 #define OPENMP_MAP_KIND(Name)                                                \
203   case OMPC_MAP_##Name:                                                      \
204     return #Name;
205 #include "clang/Basic/OpenMPKinds.def"
206     default:
207       break;
208     }
209     llvm_unreachable("Invalid OpenMP 'map' clause type");
210   case OMPC_unknown:
211   case OMPC_threadprivate:
212   case OMPC_if:
213   case OMPC_final:
214   case OMPC_num_threads:
215   case OMPC_safelen:
216   case OMPC_simdlen:
217   case OMPC_collapse:
218   case OMPC_private:
219   case OMPC_firstprivate:
220   case OMPC_lastprivate:
221   case OMPC_shared:
222   case OMPC_reduction:
223   case OMPC_aligned:
224   case OMPC_copyin:
225   case OMPC_copyprivate:
226   case OMPC_ordered:
227   case OMPC_nowait:
228   case OMPC_untied:
229   case OMPC_mergeable:
230   case OMPC_flush:
231   case OMPC_read:
232   case OMPC_write:
233   case OMPC_update:
234   case OMPC_capture:
235   case OMPC_seq_cst:
236   case OMPC_device:
237   case OMPC_threads:
238   case OMPC_simd:
239   case OMPC_num_teams:
240   case OMPC_thread_limit:
241   case OMPC_priority:
242     break;
243   }
244   llvm_unreachable("Invalid OpenMP simple clause kind");
245 }
246 
247 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
248                                         OpenMPClauseKind CKind) {
249   assert(DKind <= OMPD_unknown);
250   assert(CKind <= OMPC_unknown);
251   switch (DKind) {
252   case OMPD_parallel:
253     switch (CKind) {
254 #define OPENMP_PARALLEL_CLAUSE(Name)                                           \
255   case OMPC_##Name:                                                            \
256     return true;
257 #include "clang/Basic/OpenMPKinds.def"
258     default:
259       break;
260     }
261     break;
262   case OMPD_simd:
263     switch (CKind) {
264 #define OPENMP_SIMD_CLAUSE(Name)                                               \
265   case OMPC_##Name:                                                            \
266     return true;
267 #include "clang/Basic/OpenMPKinds.def"
268     default:
269       break;
270     }
271     break;
272   case OMPD_for:
273     switch (CKind) {
274 #define OPENMP_FOR_CLAUSE(Name)                                                \
275   case OMPC_##Name:                                                            \
276     return true;
277 #include "clang/Basic/OpenMPKinds.def"
278     default:
279       break;
280     }
281     break;
282   case OMPD_for_simd:
283     switch (CKind) {
284 #define OPENMP_FOR_SIMD_CLAUSE(Name)                                           \
285   case OMPC_##Name:                                                            \
286     return true;
287 #include "clang/Basic/OpenMPKinds.def"
288     default:
289       break;
290     }
291     break;
292   case OMPD_sections:
293     switch (CKind) {
294 #define OPENMP_SECTIONS_CLAUSE(Name)                                           \
295   case OMPC_##Name:                                                            \
296     return true;
297 #include "clang/Basic/OpenMPKinds.def"
298     default:
299       break;
300     }
301     break;
302   case OMPD_single:
303     switch (CKind) {
304 #define OPENMP_SINGLE_CLAUSE(Name)                                             \
305   case OMPC_##Name:                                                            \
306     return true;
307 #include "clang/Basic/OpenMPKinds.def"
308     default:
309       break;
310     }
311     break;
312   case OMPD_parallel_for:
313     switch (CKind) {
314 #define OPENMP_PARALLEL_FOR_CLAUSE(Name)                                       \
315   case OMPC_##Name:                                                            \
316     return true;
317 #include "clang/Basic/OpenMPKinds.def"
318     default:
319       break;
320     }
321     break;
322   case OMPD_parallel_for_simd:
323     switch (CKind) {
324 #define OPENMP_PARALLEL_FOR_SIMD_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_parallel_sections:
333     switch (CKind) {
334 #define OPENMP_PARALLEL_SECTIONS_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_task:
343     switch (CKind) {
344 #define OPENMP_TASK_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_flush:
353     return CKind == OMPC_flush;
354     break;
355   case OMPD_atomic:
356     switch (CKind) {
357 #define OPENMP_ATOMIC_CLAUSE(Name)                                             \
358   case OMPC_##Name:                                                            \
359     return true;
360 #include "clang/Basic/OpenMPKinds.def"
361     default:
362       break;
363     }
364     break;
365   case OMPD_target:
366     switch (CKind) {
367 #define OPENMP_TARGET_CLAUSE(Name)                                             \
368   case OMPC_##Name:                                                            \
369     return true;
370 #include "clang/Basic/OpenMPKinds.def"
371     default:
372       break;
373     }
374     break;
375   case OMPD_target_data:
376     switch (CKind) {
377 #define OPENMP_TARGET_DATA_CLAUSE(Name)                                        \
378   case OMPC_##Name:                                                            \
379     return true;
380 #include "clang/Basic/OpenMPKinds.def"
381     default:
382       break;
383     }
384     break;
385   case OMPD_teams:
386     switch (CKind) {
387 #define OPENMP_TEAMS_CLAUSE(Name)                                              \
388   case OMPC_##Name:                                                            \
389     return true;
390 #include "clang/Basic/OpenMPKinds.def"
391     default:
392       break;
393     }
394     break;
395   case OMPD_cancel:
396     switch (CKind) {
397 #define OPENMP_CANCEL_CLAUSE(Name)                                             \
398   case OMPC_##Name:                                                            \
399     return true;
400 #include "clang/Basic/OpenMPKinds.def"
401     default:
402       break;
403     }
404     break;
405   case OMPD_ordered:
406     switch (CKind) {
407 #define OPENMP_ORDERED_CLAUSE(Name)                                            \
408   case OMPC_##Name:                                                            \
409     return true;
410 #include "clang/Basic/OpenMPKinds.def"
411     default:
412       break;
413     }
414     break;
415   case OMPD_taskloop:
416     switch (CKind) {
417 #define OPENMP_TASKLOOP_CLAUSE(Name)                                           \
418   case OMPC_##Name:                                                            \
419     return true;
420 #include "clang/Basic/OpenMPKinds.def"
421     default:
422       break;
423     }
424     break;
425   case OMPD_taskloop_simd:
426     switch (CKind) {
427 #define OPENMP_TASKLOOP_SIMD_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_unknown:
436   case OMPD_threadprivate:
437   case OMPD_section:
438   case OMPD_master:
439   case OMPD_critical:
440   case OMPD_taskyield:
441   case OMPD_barrier:
442   case OMPD_taskwait:
443   case OMPD_taskgroup:
444   case OMPD_cancellation_point:
445     break;
446   }
447   return false;
448 }
449 
450 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
451   return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
452          DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
453          DKind == OMPD_taskloop ||
454          DKind == OMPD_taskloop_simd; // TODO add next directives.
455 }
456 
457 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
458   return DKind == OMPD_for || DKind == OMPD_for_simd ||
459          DKind == OMPD_sections || DKind == OMPD_section ||
460          DKind == OMPD_single || DKind == OMPD_parallel_for ||
461          DKind == OMPD_parallel_for_simd ||
462          DKind == OMPD_parallel_sections; // TODO add next directives.
463 }
464 
465 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
466   return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd;
467 }
468 
469 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
470   return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
471          DKind == OMPD_parallel_for_simd ||
472          DKind == OMPD_parallel_sections; // TODO add next directives.
473 }
474 
475 bool clang::isOpenMPTargetDirective(OpenMPDirectiveKind DKind) {
476   return DKind == OMPD_target; // TODO add next directives.
477 }
478 
479 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
480   return DKind == OMPD_teams; // TODO add next directives.
481 }
482 
483 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
484   return DKind == OMPD_simd || DKind == OMPD_for_simd ||
485          DKind == OMPD_parallel_for_simd ||
486          DKind == OMPD_taskloop_simd; // TODO add next directives.
487 }
488 
489 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
490   return Kind == OMPC_private || Kind == OMPC_firstprivate ||
491          Kind == OMPC_lastprivate || Kind == OMPC_linear ||
492          Kind == OMPC_reduction; // TODO add next clauses like 'reduction'.
493 }
494 
495 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
496   return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
497 }
498 
499