clang 17.0.0git
OpenMPKinds.cpp
Go to the documentation of this file.
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
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;
21using namespace llvm::omp;
22
23unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind, StringRef Str,
24 const LangOptions &LangOpts) {
25 switch (Kind) {
26 case OMPC_default:
27 return llvm::StringSwitch<unsigned>(Str)
28#define OMP_DEFAULT_KIND(Enum, Name) .Case(Name, unsigned(Enum))
29#include "llvm/Frontend/OpenMP/OMPKinds.def"
30 .Default(unsigned(llvm::omp::OMP_DEFAULT_unknown));
31 case OMPC_proc_bind:
32 return llvm::StringSwitch<unsigned>(Str)
33#define OMP_PROC_BIND_KIND(Enum, Name, Value) .Case(Name, Value)
34#include "llvm/Frontend/OpenMP/OMPKinds.def"
35 .Default(unsigned(llvm::omp::OMP_PROC_BIND_unknown));
36 case OMPC_schedule:
37 return llvm::StringSwitch<unsigned>(Str)
38#define OPENMP_SCHEDULE_KIND(Name) \
39 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name))
40#define OPENMP_SCHEDULE_MODIFIER(Name) \
41 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name))
42#include "clang/Basic/OpenMPKinds.def"
43 .Default(OMPC_SCHEDULE_unknown);
44 case OMPC_depend: {
45 unsigned Type = llvm::StringSwitch<unsigned>(Str)
46#define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name)
47#include "clang/Basic/OpenMPKinds.def"
48 .Default(OMPC_DEPEND_unknown);
49 if (LangOpts.OpenMP < 51 && Type == OMPC_DEPEND_inoutset)
51 return Type;
52 }
53 case OMPC_linear:
54 return llvm::StringSwitch<OpenMPLinearClauseKind>(Str)
55#define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name)
56#include "clang/Basic/OpenMPKinds.def"
57 .Default(OMPC_LINEAR_unknown);
58 case OMPC_map: {
59 unsigned Type = llvm::StringSwitch<unsigned>(Str)
60#define OPENMP_MAP_KIND(Name) \
61 .Case(#Name, static_cast<unsigned>(OMPC_MAP_##Name))
62#define OPENMP_MAP_MODIFIER_KIND(Name) \
63 .Case(#Name, static_cast<unsigned>(OMPC_MAP_MODIFIER_##Name))
64#include "clang/Basic/OpenMPKinds.def"
65 .Default(OMPC_MAP_unknown);
66 if (LangOpts.OpenMP < 51 && Type == OMPC_MAP_MODIFIER_present)
68 if (!LangOpts.OpenMPExtensions && Type == OMPC_MAP_MODIFIER_ompx_hold)
70 return Type;
71 }
72 case OMPC_to:
73 case OMPC_from: {
74 unsigned Type = llvm::StringSwitch<unsigned>(Str)
75#define OPENMP_MOTION_MODIFIER_KIND(Name) \
76 .Case(#Name, static_cast<unsigned>(OMPC_MOTION_MODIFIER_##Name))
77#include "clang/Basic/OpenMPKinds.def"
79 if (LangOpts.OpenMP < 51 && Type == OMPC_MOTION_MODIFIER_present)
81 return Type;
82 }
83 case OMPC_dist_schedule:
84 return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str)
85#define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name)
86#include "clang/Basic/OpenMPKinds.def"
88 case OMPC_defaultmap:
89 return llvm::StringSwitch<unsigned>(Str)
90#define OPENMP_DEFAULTMAP_KIND(Name) \
91 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name))
92#define OPENMP_DEFAULTMAP_MODIFIER(Name) \
93 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name))
94#include "clang/Basic/OpenMPKinds.def"
96 case OMPC_atomic_default_mem_order:
97 return llvm::StringSwitch<OpenMPAtomicDefaultMemOrderClauseKind>(Str)
98#define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \
99 .Case(#Name, OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name)
100#include "clang/Basic/OpenMPKinds.def"
102 case OMPC_device_type:
103 return llvm::StringSwitch<OpenMPDeviceType>(Str)
104#define OPENMP_DEVICE_TYPE_KIND(Name) .Case(#Name, OMPC_DEVICE_TYPE_##Name)
105#include "clang/Basic/OpenMPKinds.def"
106 .Default(OMPC_DEVICE_TYPE_unknown);
107 case OMPC_at:
108 return llvm::StringSwitch<OpenMPAtClauseKind>(Str)
109#define OPENMP_AT_KIND(Name) .Case(#Name, OMPC_AT_##Name)
110#include "clang/Basic/OpenMPKinds.def"
111 .Default(OMPC_AT_unknown);
112 case OMPC_severity:
113 return llvm::StringSwitch<OpenMPSeverityClauseKind>(Str)
114#define OPENMP_SEVERITY_KIND(Name) .Case(#Name, OMPC_SEVERITY_##Name)
115#include "clang/Basic/OpenMPKinds.def"
116 .Default(OMPC_SEVERITY_unknown);
117 case OMPC_lastprivate:
118 return llvm::StringSwitch<OpenMPLastprivateModifier>(Str)
119#define OPENMP_LASTPRIVATE_KIND(Name) .Case(#Name, OMPC_LASTPRIVATE_##Name)
120#include "clang/Basic/OpenMPKinds.def"
121 .Default(OMPC_LASTPRIVATE_unknown);
122 case OMPC_order:
123 return llvm::StringSwitch<unsigned>(Str)
124#define OPENMP_ORDER_KIND(Name) \
125 .Case(#Name, static_cast<unsigned>(OMPC_ORDER_##Name))
126#define OPENMP_ORDER_MODIFIER(Name) \
127 .Case(#Name, static_cast<unsigned>(OMPC_ORDER_MODIFIER_##Name))
128#include "clang/Basic/OpenMPKinds.def"
129 .Default(OMPC_ORDER_unknown);
130 case OMPC_update:
131 return llvm::StringSwitch<OpenMPDependClauseKind>(Str)
132#define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name)
133#include "clang/Basic/OpenMPKinds.def"
134 .Default(OMPC_DEPEND_unknown);
135 case OMPC_device:
136 return llvm::StringSwitch<OpenMPDeviceClauseModifier>(Str)
137#define OPENMP_DEVICE_MODIFIER(Name) .Case(#Name, OMPC_DEVICE_##Name)
138#include "clang/Basic/OpenMPKinds.def"
139 .Default(OMPC_DEVICE_unknown);
140 case OMPC_reduction:
141 return llvm::StringSwitch<OpenMPReductionClauseModifier>(Str)
142#define OPENMP_REDUCTION_MODIFIER(Name) .Case(#Name, OMPC_REDUCTION_##Name)
143#include "clang/Basic/OpenMPKinds.def"
144 .Default(OMPC_REDUCTION_unknown);
145 case OMPC_adjust_args:
146 return llvm::StringSwitch<OpenMPAdjustArgsOpKind>(Str)
147#define OPENMP_ADJUST_ARGS_KIND(Name) .Case(#Name, OMPC_ADJUST_ARGS_##Name)
148#include "clang/Basic/OpenMPKinds.def"
149 .Default(OMPC_ADJUST_ARGS_unknown);
150 case OMPC_bind:
151 return llvm::StringSwitch<unsigned>(Str)
152#define OPENMP_BIND_KIND(Name) .Case(#Name, OMPC_BIND_##Name)
153#include "clang/Basic/OpenMPKinds.def"
154 .Default(OMPC_BIND_unknown);
155 case OMPC_grainsize: {
156 unsigned Type = llvm::StringSwitch<unsigned>(Str)
157#define OPENMP_GRAINSIZE_MODIFIER(Name) .Case(#Name, OMPC_GRAINSIZE_##Name)
158#include "clang/Basic/OpenMPKinds.def"
159 .Default(OMPC_GRAINSIZE_unknown);
160 if (LangOpts.OpenMP < 51)
162 return Type;
163 }
164 case OMPC_num_tasks: {
165 unsigned Type = llvm::StringSwitch<unsigned>(Str)
166#define OPENMP_NUMTASKS_MODIFIER(Name) .Case(#Name, OMPC_NUMTASKS_##Name)
167#include "clang/Basic/OpenMPKinds.def"
168 .Default(OMPC_NUMTASKS_unknown);
169 if (LangOpts.OpenMP < 51)
171 return Type;
172 }
173 case OMPC_unknown:
174 case OMPC_threadprivate:
175 case OMPC_if:
176 case OMPC_final:
177 case OMPC_num_threads:
178 case OMPC_safelen:
179 case OMPC_simdlen:
180 case OMPC_sizes:
181 case OMPC_allocator:
182 case OMPC_allocate:
183 case OMPC_collapse:
184 case OMPC_private:
185 case OMPC_firstprivate:
186 case OMPC_shared:
187 case OMPC_task_reduction:
188 case OMPC_in_reduction:
189 case OMPC_aligned:
190 case OMPC_copyin:
191 case OMPC_copyprivate:
192 case OMPC_ordered:
193 case OMPC_nowait:
194 case OMPC_untied:
195 case OMPC_mergeable:
196 case OMPC_flush:
197 case OMPC_depobj:
198 case OMPC_read:
199 case OMPC_write:
200 case OMPC_capture:
201 case OMPC_compare:
202 case OMPC_seq_cst:
203 case OMPC_acq_rel:
204 case OMPC_acquire:
205 case OMPC_release:
206 case OMPC_relaxed:
207 case OMPC_threads:
208 case OMPC_simd:
209 case OMPC_num_teams:
210 case OMPC_thread_limit:
211 case OMPC_priority:
212 case OMPC_nogroup:
213 case OMPC_hint:
214 case OMPC_uniform:
215 case OMPC_use_device_ptr:
216 case OMPC_use_device_addr:
217 case OMPC_is_device_ptr:
218 case OMPC_has_device_addr:
219 case OMPC_unified_address:
220 case OMPC_unified_shared_memory:
221 case OMPC_reverse_offload:
222 case OMPC_dynamic_allocators:
223 case OMPC_match:
224 case OMPC_nontemporal:
225 case OMPC_destroy:
226 case OMPC_novariants:
227 case OMPC_nocontext:
228 case OMPC_detach:
229 case OMPC_inclusive:
230 case OMPC_exclusive:
231 case OMPC_uses_allocators:
232 case OMPC_affinity:
233 case OMPC_when:
234 case OMPC_append_args:
235 break;
236 default:
237 break;
238 }
239 llvm_unreachable("Invalid OpenMP simple clause kind");
240}
241
243 unsigned Type) {
244 switch (Kind) {
245 case OMPC_default:
246 switch (llvm::omp::DefaultKind(Type)) {
247#define OMP_DEFAULT_KIND(Enum, Name) \
248 case Enum: \
249 return Name;
250#include "llvm/Frontend/OpenMP/OMPKinds.def"
251 }
252 llvm_unreachable("Invalid OpenMP 'default' clause type");
253 case OMPC_proc_bind:
254 switch (Type) {
255#define OMP_PROC_BIND_KIND(Enum, Name, Value) \
256 case Value: \
257 return Name;
258#include "llvm/Frontend/OpenMP/OMPKinds.def"
259 }
260 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
261 case OMPC_schedule:
262 switch (Type) {
265 return "unknown";
266#define OPENMP_SCHEDULE_KIND(Name) \
267 case OMPC_SCHEDULE_##Name: \
268 return #Name;
269#define OPENMP_SCHEDULE_MODIFIER(Name) \
270 case OMPC_SCHEDULE_MODIFIER_##Name: \
271 return #Name;
272#include "clang/Basic/OpenMPKinds.def"
273 }
274 llvm_unreachable("Invalid OpenMP 'schedule' clause type");
275 case OMPC_depend:
276 switch (Type) {
278 return "unknown";
279#define OPENMP_DEPEND_KIND(Name) \
280 case OMPC_DEPEND_##Name: \
281 return #Name;
282#include "clang/Basic/OpenMPKinds.def"
283 }
284 llvm_unreachable("Invalid OpenMP 'depend' clause type");
285 case OMPC_linear:
286 switch (Type) {
288 return "unknown";
289#define OPENMP_LINEAR_KIND(Name) \
290 case OMPC_LINEAR_##Name: \
291 return #Name;
292#include "clang/Basic/OpenMPKinds.def"
293 }
294 llvm_unreachable("Invalid OpenMP 'linear' clause type");
295 case OMPC_map:
296 switch (Type) {
297 case OMPC_MAP_unknown:
299 return "unknown";
300#define OPENMP_MAP_KIND(Name) \
301 case OMPC_MAP_##Name: \
302 return #Name;
303#define OPENMP_MAP_MODIFIER_KIND(Name) \
304 case OMPC_MAP_MODIFIER_##Name: \
305 return #Name;
306#include "clang/Basic/OpenMPKinds.def"
307 default:
308 break;
309 }
310 llvm_unreachable("Invalid OpenMP 'map' clause type");
311 case OMPC_to:
312 case OMPC_from:
313 switch (Type) {
315 return "unknown";
316#define OPENMP_MOTION_MODIFIER_KIND(Name) \
317 case OMPC_MOTION_MODIFIER_##Name: \
318 return #Name;
319#include "clang/Basic/OpenMPKinds.def"
320 default:
321 break;
322 }
323 llvm_unreachable("Invalid OpenMP 'to' or 'from' clause type");
324 case OMPC_dist_schedule:
325 switch (Type) {
327 return "unknown";
328#define OPENMP_DIST_SCHEDULE_KIND(Name) \
329 case OMPC_DIST_SCHEDULE_##Name: \
330 return #Name;
331#include "clang/Basic/OpenMPKinds.def"
332 }
333 llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type");
334 case OMPC_defaultmap:
335 switch (Type) {
338 return "unknown";
339#define OPENMP_DEFAULTMAP_KIND(Name) \
340 case OMPC_DEFAULTMAP_##Name: \
341 return #Name;
342#define OPENMP_DEFAULTMAP_MODIFIER(Name) \
343 case OMPC_DEFAULTMAP_MODIFIER_##Name: \
344 return #Name;
345#include "clang/Basic/OpenMPKinds.def"
346 }
347 llvm_unreachable("Invalid OpenMP 'schedule' clause type");
348 case OMPC_atomic_default_mem_order:
349 switch (Type) {
351 return "unknown";
352#define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \
353 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name: \
354 return #Name;
355#include "clang/Basic/OpenMPKinds.def"
356}
357 llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type");
358 case OMPC_device_type:
359 switch (Type) {
361 return "unknown";
362#define OPENMP_DEVICE_TYPE_KIND(Name) \
363 case OMPC_DEVICE_TYPE_##Name: \
364 return #Name;
365#include "clang/Basic/OpenMPKinds.def"
366 }
367 llvm_unreachable("Invalid OpenMP 'device_type' clause type");
368 case OMPC_at:
369 switch (Type) {
370 case OMPC_AT_unknown:
371 return "unknown";
372#define OPENMP_AT_KIND(Name) \
373 case OMPC_AT_##Name: \
374 return #Name;
375#include "clang/Basic/OpenMPKinds.def"
376 }
377 llvm_unreachable("Invalid OpenMP 'at' clause type");
378 case OMPC_severity:
379 switch (Type) {
381 return "unknown";
382#define OPENMP_SEVERITY_KIND(Name) \
383 case OMPC_SEVERITY_##Name: \
384 return #Name;
385#include "clang/Basic/OpenMPKinds.def"
386 }
387 llvm_unreachable("Invalid OpenMP 'severity' clause type");
388 case OMPC_lastprivate:
389 switch (Type) {
391 return "unknown";
392#define OPENMP_LASTPRIVATE_KIND(Name) \
393 case OMPC_LASTPRIVATE_##Name: \
394 return #Name;
395#include "clang/Basic/OpenMPKinds.def"
396 }
397 llvm_unreachable("Invalid OpenMP 'lastprivate' clause type");
398 case OMPC_order:
399 switch (Type) {
402 return "unknown";
403#define OPENMP_ORDER_KIND(Name) \
404 case OMPC_ORDER_##Name: \
405 return #Name;
406#define OPENMP_ORDER_MODIFIER(Name) \
407 case OMPC_ORDER_MODIFIER_##Name: \
408 return #Name;
409#include "clang/Basic/OpenMPKinds.def"
410 }
411 llvm_unreachable("Invalid OpenMP 'order' clause type");
412 case OMPC_update:
413 switch (Type) {
415 return "unknown";
416#define OPENMP_DEPEND_KIND(Name) \
417 case OMPC_DEPEND_##Name: \
418 return #Name;
419#include "clang/Basic/OpenMPKinds.def"
420 }
421 llvm_unreachable("Invalid OpenMP 'depend' clause type");
422 case OMPC_device:
423 switch (Type) {
425 return "unknown";
426#define OPENMP_DEVICE_MODIFIER(Name) \
427 case OMPC_DEVICE_##Name: \
428 return #Name;
429#include "clang/Basic/OpenMPKinds.def"
430 }
431 llvm_unreachable("Invalid OpenMP 'device' clause modifier");
432 case OMPC_reduction:
433 switch (Type) {
435 return "unknown";
436#define OPENMP_REDUCTION_MODIFIER(Name) \
437 case OMPC_REDUCTION_##Name: \
438 return #Name;
439#include "clang/Basic/OpenMPKinds.def"
440 }
441 llvm_unreachable("Invalid OpenMP 'reduction' clause modifier");
442 case OMPC_adjust_args:
443 switch (Type) {
445 return "unknown";
446#define OPENMP_ADJUST_ARGS_KIND(Name) \
447 case OMPC_ADJUST_ARGS_##Name: \
448 return #Name;
449#include "clang/Basic/OpenMPKinds.def"
450 }
451 llvm_unreachable("Invalid OpenMP 'adjust_args' clause kind");
452 case OMPC_bind:
453 switch (Type) {
455 return "unknown";
456#define OPENMP_BIND_KIND(Name) \
457 case OMPC_BIND_##Name: \
458 return #Name;
459#include "clang/Basic/OpenMPKinds.def"
460 }
461 llvm_unreachable("Invalid OpenMP 'bind' clause type");
462 case OMPC_grainsize:
463 switch (Type) {
465 return "unknown";
466#define OPENMP_GRAINSIZE_MODIFIER(Name) \
467 case OMPC_GRAINSIZE_##Name: \
468 return #Name;
469#include "clang/Basic/OpenMPKinds.def"
470 }
471 llvm_unreachable("Invalid OpenMP 'grainsize' clause modifier");
472 case OMPC_num_tasks:
473 switch (Type) {
475 return "unknown";
476#define OPENMP_NUMTASKS_MODIFIER(Name) \
477 case OMPC_NUMTASKS_##Name: \
478 return #Name;
479#include "clang/Basic/OpenMPKinds.def"
480 }
481 llvm_unreachable("Invalid OpenMP 'num_tasks' clause modifier");
482 case OMPC_unknown:
483 case OMPC_threadprivate:
484 case OMPC_if:
485 case OMPC_final:
486 case OMPC_num_threads:
487 case OMPC_safelen:
488 case OMPC_simdlen:
489 case OMPC_sizes:
490 case OMPC_allocator:
491 case OMPC_allocate:
492 case OMPC_collapse:
493 case OMPC_private:
494 case OMPC_firstprivate:
495 case OMPC_shared:
496 case OMPC_task_reduction:
497 case OMPC_in_reduction:
498 case OMPC_aligned:
499 case OMPC_copyin:
500 case OMPC_copyprivate:
501 case OMPC_ordered:
502 case OMPC_nowait:
503 case OMPC_untied:
504 case OMPC_mergeable:
505 case OMPC_flush:
506 case OMPC_depobj:
507 case OMPC_read:
508 case OMPC_write:
509 case OMPC_capture:
510 case OMPC_compare:
511 case OMPC_seq_cst:
512 case OMPC_acq_rel:
513 case OMPC_acquire:
514 case OMPC_release:
515 case OMPC_relaxed:
516 case OMPC_threads:
517 case OMPC_simd:
518 case OMPC_num_teams:
519 case OMPC_thread_limit:
520 case OMPC_priority:
521 case OMPC_nogroup:
522 case OMPC_hint:
523 case OMPC_uniform:
524 case OMPC_use_device_ptr:
525 case OMPC_use_device_addr:
526 case OMPC_is_device_ptr:
527 case OMPC_has_device_addr:
528 case OMPC_unified_address:
529 case OMPC_unified_shared_memory:
530 case OMPC_reverse_offload:
531 case OMPC_dynamic_allocators:
532 case OMPC_match:
533 case OMPC_nontemporal:
534 case OMPC_destroy:
535 case OMPC_detach:
536 case OMPC_novariants:
537 case OMPC_nocontext:
538 case OMPC_inclusive:
539 case OMPC_exclusive:
540 case OMPC_uses_allocators:
541 case OMPC_affinity:
542 case OMPC_when:
543 case OMPC_append_args:
544 break;
545 default:
546 break;
547 }
548 llvm_unreachable("Invalid OpenMP simple clause kind");
549}
550
552 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
553 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
554 DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
555 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd ||
556 DKind == OMPD_parallel_master_taskloop ||
557 DKind == OMPD_parallel_master_taskloop_simd ||
558 DKind == OMPD_masked_taskloop || DKind == OMPD_masked_taskloop_simd ||
559 DKind == OMPD_parallel_masked_taskloop || DKind == OMPD_distribute ||
560 DKind == OMPD_parallel_masked_taskloop_simd ||
561 DKind == OMPD_target_parallel_for ||
562 DKind == OMPD_distribute_parallel_for ||
563 DKind == OMPD_distribute_parallel_for_simd ||
564 DKind == OMPD_distribute_simd ||
565 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
566 DKind == OMPD_teams_distribute ||
567 DKind == OMPD_teams_distribute_simd ||
568 DKind == OMPD_teams_distribute_parallel_for_simd ||
569 DKind == OMPD_teams_distribute_parallel_for ||
570 DKind == OMPD_target_teams_distribute ||
571 DKind == OMPD_target_teams_distribute_parallel_for ||
572 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
573 DKind == OMPD_target_teams_distribute_simd || DKind == OMPD_tile ||
574 DKind == OMPD_unroll || DKind == OMPD_loop ||
575 DKind == OMPD_teams_loop || DKind == OMPD_target_teams_loop ||
576 DKind == OMPD_parallel_loop || DKind == OMPD_target_parallel_loop;
577}
578
580 return DKind == OMPD_for || DKind == OMPD_for_simd ||
581 DKind == OMPD_sections || DKind == OMPD_section ||
582 DKind == OMPD_single || DKind == OMPD_parallel_for ||
583 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
584 DKind == OMPD_target_parallel_for ||
585 DKind == OMPD_distribute_parallel_for ||
586 DKind == OMPD_distribute_parallel_for_simd ||
587 DKind == OMPD_target_parallel_for_simd ||
588 DKind == OMPD_teams_distribute_parallel_for_simd ||
589 DKind == OMPD_teams_distribute_parallel_for ||
590 DKind == OMPD_target_teams_distribute_parallel_for ||
591 DKind == OMPD_target_teams_distribute_parallel_for_simd;
592}
593
595 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
596 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd ||
597 DKind == OMPD_parallel_master_taskloop ||
598 DKind == OMPD_masked_taskloop || DKind == OMPD_masked_taskloop_simd ||
599 DKind == OMPD_parallel_masked_taskloop ||
600 DKind == OMPD_parallel_masked_taskloop_simd ||
601 DKind == OMPD_parallel_master_taskloop_simd;
602}
603
605 return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
606 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
607 DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for ||
608 DKind == OMPD_distribute_parallel_for ||
609 DKind == OMPD_distribute_parallel_for_simd ||
610 DKind == OMPD_target_parallel_for_simd ||
611 DKind == OMPD_teams_distribute_parallel_for ||
612 DKind == OMPD_teams_distribute_parallel_for_simd ||
613 DKind == OMPD_target_teams_distribute_parallel_for ||
614 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
615 DKind == OMPD_parallel_master || DKind == OMPD_parallel_masked ||
616 DKind == OMPD_parallel_master_taskloop ||
617 DKind == OMPD_parallel_master_taskloop_simd ||
618 DKind == OMPD_parallel_masked_taskloop ||
619 DKind == OMPD_parallel_masked_taskloop_simd ||
620 DKind == OMPD_parallel_loop || DKind == OMPD_target_parallel_loop;
621}
622
624 return DKind == OMPD_target || DKind == OMPD_target_parallel ||
625 DKind == OMPD_target_parallel_for ||
626 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
627 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
628 DKind == OMPD_target_teams_distribute_parallel_for ||
629 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
630 DKind == OMPD_target_teams_distribute_simd ||
631 DKind == OMPD_target_teams_loop || DKind == OMPD_target_parallel_loop;
632}
633
635 return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
636 DKind == OMPD_target_exit_data || DKind == OMPD_target_update;
637}
638
640 return DKind == OMPD_teams || DKind == OMPD_teams_distribute ||
641 DKind == OMPD_teams_distribute_simd ||
642 DKind == OMPD_teams_distribute_parallel_for_simd ||
643 DKind == OMPD_teams_distribute_parallel_for ||
644 DKind == OMPD_teams_loop;
645}
646
648 return isOpenMPNestingTeamsDirective(DKind) || DKind == OMPD_target_teams ||
649 DKind == OMPD_target_teams_distribute ||
650 DKind == OMPD_target_teams_distribute_parallel_for ||
651 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
652 DKind == OMPD_target_teams_distribute_simd ||
653 DKind == OMPD_target_teams_loop;
654}
655
657 return DKind == OMPD_simd || DKind == OMPD_for_simd ||
658 DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd ||
659 DKind == OMPD_master_taskloop_simd ||
660 DKind == OMPD_masked_taskloop_simd ||
661 DKind == OMPD_parallel_master_taskloop_simd ||
662 DKind == OMPD_parallel_masked_taskloop_simd ||
663 DKind == OMPD_distribute_parallel_for_simd ||
664 DKind == OMPD_distribute_simd || DKind == OMPD_target_simd ||
665 DKind == OMPD_teams_distribute_simd ||
666 DKind == OMPD_teams_distribute_parallel_for_simd ||
667 DKind == OMPD_target_teams_distribute_parallel_for_simd ||
668 DKind == OMPD_target_teams_distribute_simd ||
669 DKind == OMPD_target_parallel_for_simd;
670}
671
673 return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for ||
674 Kind == OMPD_distribute_parallel_for_simd ||
675 Kind == OMPD_distribute_simd;
676 // TODO add next directives.
677}
678
681 Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd ||
682 Kind == OMPD_teams_distribute_parallel_for_simd ||
683 Kind == OMPD_teams_distribute_parallel_for ||
684 Kind == OMPD_target_teams_distribute ||
685 Kind == OMPD_target_teams_distribute_parallel_for ||
686 Kind == OMPD_target_teams_distribute_parallel_for_simd ||
687 Kind == OMPD_target_teams_distribute_simd;
688}
689
691 return Kind == OMPD_loop || Kind == OMPD_teams_loop ||
692 Kind == OMPD_target_teams_loop || Kind == OMPD_parallel_loop ||
693 Kind == OMPD_target_parallel_loop;
694}
695
697 return Kind == OMPC_private || Kind == OMPC_firstprivate ||
698 Kind == OMPC_lastprivate || Kind == OMPC_linear ||
699 Kind == OMPC_reduction || Kind == OMPC_task_reduction ||
700 Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'.
701}
702
704 return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
705}
706
708 return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
709}
710
712 return Kind == OMPD_distribute_parallel_for ||
713 Kind == OMPD_distribute_parallel_for_simd ||
714 Kind == OMPD_teams_distribute_parallel_for_simd ||
715 Kind == OMPD_teams_distribute_parallel_for ||
716 Kind == OMPD_target_teams_distribute_parallel_for ||
717 Kind == OMPD_target_teams_distribute_parallel_for_simd;
718}
719
721 return DKind == OMPD_tile || DKind == OMPD_unroll;
722}
723
725 return DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
726 DKind == OMPD_parallel_master ||
727 DKind == OMPD_parallel_master_taskloop ||
728 DKind == OMPD_parallel_master_taskloop_simd ||
729 DKind == OMPD_parallel_sections;
730}
731
734 OpenMPDirectiveKind DKind) {
735 assert(unsigned(DKind) < llvm::omp::Directive_enumSize);
736 switch (DKind) {
737 case OMPD_metadirective:
738 CaptureRegions.push_back(OMPD_metadirective);
739 break;
740 case OMPD_parallel:
741 case OMPD_parallel_for:
742 case OMPD_parallel_for_simd:
743 case OMPD_parallel_master:
744 case OMPD_parallel_masked:
745 case OMPD_parallel_sections:
746 case OMPD_distribute_parallel_for:
747 case OMPD_distribute_parallel_for_simd:
748 case OMPD_parallel_loop:
749 CaptureRegions.push_back(OMPD_parallel);
750 break;
751 case OMPD_target_teams:
752 case OMPD_target_teams_distribute:
753 case OMPD_target_teams_distribute_simd:
754 case OMPD_target_teams_loop:
755 CaptureRegions.push_back(OMPD_task);
756 CaptureRegions.push_back(OMPD_target);
757 CaptureRegions.push_back(OMPD_teams);
758 break;
759 case OMPD_teams:
760 case OMPD_teams_distribute:
761 case OMPD_teams_distribute_simd:
762 CaptureRegions.push_back(OMPD_teams);
763 break;
764 case OMPD_target:
765 case OMPD_target_simd:
766 CaptureRegions.push_back(OMPD_task);
767 CaptureRegions.push_back(OMPD_target);
768 break;
769 case OMPD_teams_distribute_parallel_for:
770 case OMPD_teams_distribute_parallel_for_simd:
771 CaptureRegions.push_back(OMPD_teams);
772 CaptureRegions.push_back(OMPD_parallel);
773 break;
774 case OMPD_target_parallel:
775 case OMPD_target_parallel_for:
776 case OMPD_target_parallel_for_simd:
777 case OMPD_target_parallel_loop:
778 CaptureRegions.push_back(OMPD_task);
779 CaptureRegions.push_back(OMPD_target);
780 CaptureRegions.push_back(OMPD_parallel);
781 break;
782 case OMPD_task:
783 case OMPD_target_enter_data:
784 case OMPD_target_exit_data:
785 case OMPD_target_update:
786 CaptureRegions.push_back(OMPD_task);
787 break;
788 case OMPD_taskloop:
789 case OMPD_taskloop_simd:
790 case OMPD_master_taskloop:
791 case OMPD_master_taskloop_simd:
792 case OMPD_masked_taskloop:
793 case OMPD_masked_taskloop_simd:
794 CaptureRegions.push_back(OMPD_taskloop);
795 break;
796 case OMPD_parallel_masked_taskloop:
797 case OMPD_parallel_masked_taskloop_simd:
798 case OMPD_parallel_master_taskloop:
799 case OMPD_parallel_master_taskloop_simd:
800 CaptureRegions.push_back(OMPD_parallel);
801 CaptureRegions.push_back(OMPD_taskloop);
802 break;
803 case OMPD_target_teams_distribute_parallel_for:
804 case OMPD_target_teams_distribute_parallel_for_simd:
805 CaptureRegions.push_back(OMPD_task);
806 CaptureRegions.push_back(OMPD_target);
807 CaptureRegions.push_back(OMPD_teams);
808 CaptureRegions.push_back(OMPD_parallel);
809 break;
810 case OMPD_teams_loop:
811 CaptureRegions.push_back(OMPD_teams);
812 break;
813 case OMPD_nothing:
814 CaptureRegions.push_back(OMPD_nothing);
815 break;
816 case OMPD_loop:
817 // TODO: 'loop' may require different capture regions depending on the bind
818 // clause or the parent directive when there is no bind clause. Use
819 // OMPD_unknown for now.
820 case OMPD_simd:
821 case OMPD_for:
822 case OMPD_for_simd:
823 case OMPD_sections:
824 case OMPD_section:
825 case OMPD_single:
826 case OMPD_master:
827 case OMPD_critical:
828 case OMPD_taskgroup:
829 case OMPD_distribute:
830 case OMPD_ordered:
831 case OMPD_atomic:
832 case OMPD_target_data:
833 case OMPD_distribute_simd:
834 case OMPD_dispatch:
835 CaptureRegions.push_back(OMPD_unknown);
836 break;
837 case OMPD_tile:
838 case OMPD_unroll:
839 // loop transformations do not introduce captures.
840 break;
841 case OMPD_threadprivate:
842 case OMPD_allocate:
843 case OMPD_taskyield:
844 case OMPD_barrier:
845 case OMPD_error:
846 case OMPD_taskwait:
847 case OMPD_cancellation_point:
848 case OMPD_cancel:
849 case OMPD_flush:
850 case OMPD_depobj:
851 case OMPD_scan:
852 case OMPD_declare_reduction:
853 case OMPD_declare_mapper:
854 case OMPD_declare_simd:
855 case OMPD_declare_target:
856 case OMPD_end_declare_target:
857 case OMPD_requires:
858 case OMPD_declare_variant:
859 case OMPD_begin_declare_variant:
860 case OMPD_end_declare_variant:
861 llvm_unreachable("OpenMP Directive is not allowed");
862 case OMPD_unknown:
863 default:
864 llvm_unreachable("Unknown OpenMP directive");
865 }
866}
Defines the clang::IdentifierInfo, clang::IdentifierTable, and clang::Selector interfaces.
Defines some OpenMP-specific enums and functions.
Keeps track of the various options that can be enabled, which controls the dialect of C or C++ that i...
Definition: LangOptions.h:82
The base class of the type hierarchy.
Definition: Type.h:1566
bool isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a worksharing directive.
bool isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind)
Checks if the specified composite/combined directive constitutes a teams directive in the outermost n...
bool isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a target data offload directive.
bool isOpenMPLoopTransformationDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a loop transformation directive.
llvm::omp::Directive OpenMPDirectiveKind
OpenMP directives.
Definition: OpenMPKinds.h:24
@ OMPC_DEFAULTMAP_MODIFIER_last
Definition: OpenMPKinds.h:123
@ OMPC_ORDER_MODIFIER_last
Definition: OpenMPKinds.h:175
@ OMPC_ADJUST_ARGS_unknown
Definition: OpenMPKinds.h:196
@ OMPC_AT_unknown
Definition: OpenMPKinds.h:138
bool isOpenMPDistributeDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a distribute directive.
@ OMPC_REDUCTION_unknown
Definition: OpenMPKinds.h:189
@ OMPC_DEVICE_TYPE_unknown
Definition: OpenMPKinds.h:153
@ OMPC_SCHEDULE_MODIFIER_last
Definition: OpenMPKinds.h:43
llvm::omp::Clause OpenMPClauseKind
OpenMP clauses.
Definition: OpenMPKinds.h:27
const char * getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, unsigned Type)
bool isOpenMPParallelDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a parallel-kind directive.
bool isOpenMPPrivate(OpenMPClauseKind Kind)
Checks if the specified clause is one of private clauses like 'private', 'firstprivate',...
@ OMPC_DIST_SCHEDULE_unknown
Definition: OpenMPKinds.h:106
bool isOpenMPTaskingDirective(OpenMPDirectiveKind Kind)
Checks if the specified directive kind is one of tasking directives - task, taskloop,...
bool isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a target code offload directive.
bool isOpenMPTeamsDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a teams-kind directive.
bool isOpenMPGenericLoopDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive constitutes a 'loop' directive in the outermost nest.
@ OMPC_BIND_unknown
Definition: OpenMPKinds.h:203
@ OMPC_LASTPRIVATE_unknown
Definition: OpenMPKinds.h:160
@ OMPC_DEPEND_unknown
Definition: OpenMPKinds.h:58
@ OMPC_GRAINSIZE_unknown
Definition: OpenMPKinds.h:209
unsigned getOpenMPSimpleClauseType(OpenMPClauseKind Kind, llvm::StringRef Str, const LangOptions &LangOpts)
@ OMPC_NUMTASKS_unknown
Definition: OpenMPKinds.h:215
bool isOpenMPLoopDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a directive with an associated loop construct.
@ OMPC_SEVERITY_unknown
Definition: OpenMPKinds.h:145
bool isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind)
Checks if the specified directive kind is one of the composite or combined directives that need loop ...
@ OMPC_MOTION_MODIFIER_unknown
Definition: OpenMPKinds.h:95
@ OMPC_DEFAULTMAP_unknown
Definition: OpenMPKinds.h:114
bool isOpenMPThreadPrivate(OpenMPClauseKind Kind)
Checks if the specified clause is one of threadprivate clauses like 'threadprivate',...
@ OMPC_LINEAR_unknown
Definition: OpenMPKinds.h:66
bool isOpenMPSimdDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a simd directive.
void getOpenMPCaptureRegions(llvm::SmallVectorImpl< OpenMPDirectiveKind > &CaptureRegions, OpenMPDirectiveKind DKind)
Return the captured regions of an OpenMP directive.
@ OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown
Definition: OpenMPKinds.h:131
@ OMPC_DEVICE_unknown
Definition: OpenMPKinds.h:50
@ OMPC_MAP_MODIFIER_last
Definition: OpenMPKinds.h:83
@ OMPC_MAP_MODIFIER_unknown
Definition: OpenMPKinds.h:79
bool isOpenMPCombinedParallelADirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a combined construct for which the first construct is a parallel...
bool isOpenMPNestingDistributeDirective(OpenMPDirectiveKind DKind)
Checks if the specified composite/combined directive constitutes a distribute directive in the outerm...
@ OMPC_ORDER_unknown
Definition: OpenMPKinds.h:167
@ OMPC_SCHEDULE_unknown
Definition: OpenMPKinds.h:34
bool isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind)
Checks if the specified directive is a taskloop directive.
@ OMPC_MAP_unknown
Definition: OpenMPKinds.h:74