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
getOpenMPDirectiveKind(StringRef Str)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
getOpenMPDirectiveName(OpenMPDirectiveKind Kind)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
getOpenMPClauseKind(StringRef Str)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
getOpenMPClauseName(OpenMPClauseKind Kind)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
getOpenMPSimpleClauseType(OpenMPClauseKind Kind,StringRef Str)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 case OMPC_grainsize:
142 case OMPC_nogroup:
143 case OMPC_num_tasks:
144 case OMPC_hint:
145 break;
146 }
147 llvm_unreachable("Invalid OpenMP simple clause kind");
148 }
149
getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,unsigned Type)150 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
151 unsigned Type) {
152 switch (Kind) {
153 case OMPC_default:
154 switch (Type) {
155 case OMPC_DEFAULT_unknown:
156 return "unknown";
157 #define OPENMP_DEFAULT_KIND(Name) \
158 case OMPC_DEFAULT_##Name: \
159 return #Name;
160 #include "clang/Basic/OpenMPKinds.def"
161 }
162 llvm_unreachable("Invalid OpenMP 'default' clause type");
163 case OMPC_proc_bind:
164 switch (Type) {
165 case OMPC_PROC_BIND_unknown:
166 return "unknown";
167 #define OPENMP_PROC_BIND_KIND(Name) \
168 case OMPC_PROC_BIND_##Name: \
169 return #Name;
170 #include "clang/Basic/OpenMPKinds.def"
171 }
172 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
173 case OMPC_schedule:
174 switch (Type) {
175 case OMPC_SCHEDULE_unknown:
176 return "unknown";
177 #define OPENMP_SCHEDULE_KIND(Name) \
178 case OMPC_SCHEDULE_##Name: \
179 return #Name;
180 #include "clang/Basic/OpenMPKinds.def"
181 }
182 case OMPC_depend:
183 switch (Type) {
184 case OMPC_DEPEND_unknown:
185 return "unknown";
186 #define OPENMP_DEPEND_KIND(Name) \
187 case OMPC_DEPEND_##Name: \
188 return #Name;
189 #include "clang/Basic/OpenMPKinds.def"
190 }
191 llvm_unreachable("Invalid OpenMP 'schedule' clause type");
192 case OMPC_linear:
193 switch (Type) {
194 case OMPC_LINEAR_unknown:
195 return "unknown";
196 #define OPENMP_LINEAR_KIND(Name) \
197 case OMPC_LINEAR_##Name: \
198 return #Name;
199 #include "clang/Basic/OpenMPKinds.def"
200 }
201 llvm_unreachable("Invalid OpenMP 'linear' clause type");
202 case OMPC_map:
203 switch (Type) {
204 case OMPC_MAP_unknown:
205 return "unknown";
206 #define OPENMP_MAP_KIND(Name) \
207 case OMPC_MAP_##Name: \
208 return #Name;
209 #include "clang/Basic/OpenMPKinds.def"
210 default:
211 break;
212 }
213 llvm_unreachable("Invalid OpenMP 'map' clause type");
214 case OMPC_unknown:
215 case OMPC_threadprivate:
216 case OMPC_if:
217 case OMPC_final:
218 case OMPC_num_threads:
219 case OMPC_safelen:
220 case OMPC_simdlen:
221 case OMPC_collapse:
222 case OMPC_private:
223 case OMPC_firstprivate:
224 case OMPC_lastprivate:
225 case OMPC_shared:
226 case OMPC_reduction:
227 case OMPC_aligned:
228 case OMPC_copyin:
229 case OMPC_copyprivate:
230 case OMPC_ordered:
231 case OMPC_nowait:
232 case OMPC_untied:
233 case OMPC_mergeable:
234 case OMPC_flush:
235 case OMPC_read:
236 case OMPC_write:
237 case OMPC_update:
238 case OMPC_capture:
239 case OMPC_seq_cst:
240 case OMPC_device:
241 case OMPC_threads:
242 case OMPC_simd:
243 case OMPC_num_teams:
244 case OMPC_thread_limit:
245 case OMPC_priority:
246 case OMPC_grainsize:
247 case OMPC_nogroup:
248 case OMPC_num_tasks:
249 case OMPC_hint:
250 break;
251 }
252 llvm_unreachable("Invalid OpenMP simple clause kind");
253 }
254
isAllowedClauseForDirective(OpenMPDirectiveKind DKind,OpenMPClauseKind CKind)255 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
256 OpenMPClauseKind CKind) {
257 assert(DKind <= OMPD_unknown);
258 assert(CKind <= OMPC_unknown);
259 switch (DKind) {
260 case OMPD_parallel:
261 switch (CKind) {
262 #define OPENMP_PARALLEL_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_simd:
271 switch (CKind) {
272 #define OPENMP_SIMD_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:
281 switch (CKind) {
282 #define OPENMP_FOR_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_for_simd:
291 switch (CKind) {
292 #define OPENMP_FOR_SIMD_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_sections:
301 switch (CKind) {
302 #define OPENMP_SECTIONS_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_single:
311 switch (CKind) {
312 #define OPENMP_SINGLE_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:
321 switch (CKind) {
322 #define OPENMP_PARALLEL_FOR_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_for_simd:
331 switch (CKind) {
332 #define OPENMP_PARALLEL_FOR_SIMD_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_parallel_sections:
341 switch (CKind) {
342 #define OPENMP_PARALLEL_SECTIONS_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_task:
351 switch (CKind) {
352 #define OPENMP_TASK_CLAUSE(Name) \
353 case OMPC_##Name: \
354 return true;
355 #include "clang/Basic/OpenMPKinds.def"
356 default:
357 break;
358 }
359 break;
360 case OMPD_flush:
361 return CKind == OMPC_flush;
362 break;
363 case OMPD_atomic:
364 switch (CKind) {
365 #define OPENMP_ATOMIC_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:
374 switch (CKind) {
375 #define OPENMP_TARGET_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_target_data:
384 switch (CKind) {
385 #define OPENMP_TARGET_DATA_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_teams:
394 switch (CKind) {
395 #define OPENMP_TEAMS_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_cancel:
404 switch (CKind) {
405 #define OPENMP_CANCEL_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_ordered:
414 switch (CKind) {
415 #define OPENMP_ORDERED_CLAUSE(Name) \
416 case OMPC_##Name: \
417 return true;
418 #include "clang/Basic/OpenMPKinds.def"
419 default:
420 break;
421 }
422 break;
423 case OMPD_taskloop:
424 switch (CKind) {
425 #define OPENMP_TASKLOOP_CLAUSE(Name) \
426 case OMPC_##Name: \
427 return true;
428 #include "clang/Basic/OpenMPKinds.def"
429 default:
430 break;
431 }
432 break;
433 case OMPD_taskloop_simd:
434 switch (CKind) {
435 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name) \
436 case OMPC_##Name: \
437 return true;
438 #include "clang/Basic/OpenMPKinds.def"
439 default:
440 break;
441 }
442 break;
443 case OMPD_critical:
444 switch (CKind) {
445 #define OPENMP_CRITICAL_CLAUSE(Name) \
446 case OMPC_##Name: \
447 return true;
448 #include "clang/Basic/OpenMPKinds.def"
449 default:
450 break;
451 }
452 break;
453 case OMPD_distribute:
454 switch (CKind) {
455 #define OPENMP_DISTRIBUTE_CLAUSE(Name) \
456 case OMPC_##Name: \
457 return true;
458 #include "clang/Basic/OpenMPKinds.def"
459 default:
460 break;
461 }
462 break;
463 case OMPD_unknown:
464 case OMPD_threadprivate:
465 case OMPD_section:
466 case OMPD_master:
467 case OMPD_taskyield:
468 case OMPD_barrier:
469 case OMPD_taskwait:
470 case OMPD_taskgroup:
471 case OMPD_cancellation_point:
472 break;
473 }
474 return false;
475 }
476
isOpenMPLoopDirective(OpenMPDirectiveKind DKind)477 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
478 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
479 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
480 DKind == OMPD_taskloop ||
481 DKind == OMPD_taskloop_simd ||
482 DKind == OMPD_distribute; // TODO add next directives.
483 }
484
isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind)485 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
486 return DKind == OMPD_for || DKind == OMPD_for_simd ||
487 DKind == OMPD_sections || DKind == OMPD_section ||
488 DKind == OMPD_single || DKind == OMPD_parallel_for ||
489 DKind == OMPD_parallel_for_simd ||
490 DKind == OMPD_parallel_sections; // TODO add next directives.
491 }
492
isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind)493 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
494 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd;
495 }
496
isOpenMPParallelDirective(OpenMPDirectiveKind DKind)497 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
498 return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
499 DKind == OMPD_parallel_for_simd ||
500 DKind == OMPD_parallel_sections; // TODO add next directives.
501 }
502
isOpenMPTargetDirective(OpenMPDirectiveKind DKind)503 bool clang::isOpenMPTargetDirective(OpenMPDirectiveKind DKind) {
504 return DKind == OMPD_target; // TODO add next directives.
505 }
506
isOpenMPTeamsDirective(OpenMPDirectiveKind DKind)507 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
508 return DKind == OMPD_teams; // TODO add next directives.
509 }
510
isOpenMPSimdDirective(OpenMPDirectiveKind DKind)511 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
512 return DKind == OMPD_simd || DKind == OMPD_for_simd ||
513 DKind == OMPD_parallel_for_simd ||
514 DKind == OMPD_taskloop_simd; // TODO add next directives.
515 }
516
isOpenMPDistributeDirective(OpenMPDirectiveKind Kind)517 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) {
518 return Kind == OMPD_distribute; // TODO add next directives.
519 }
520
isOpenMPPrivate(OpenMPClauseKind Kind)521 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
522 return Kind == OMPC_private || Kind == OMPC_firstprivate ||
523 Kind == OMPC_lastprivate || Kind == OMPC_linear ||
524 Kind == OMPC_reduction; // TODO add next clauses like 'reduction'.
525 }
526
isOpenMPThreadPrivate(OpenMPClauseKind Kind)527 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
528 return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
529 }
530
531