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