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 | |
20 | using namespace clang; |
21 | using namespace llvm::omp; |
22 | |
23 | unsigned 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(Value: 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(Value: 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(Value: 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(Value: 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(Value: 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(Value: 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(Value: 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(Value: 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(Value: 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(Value: OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown); |
107 | case OMPC_fail: |
108 | return static_cast<unsigned int>(llvm::StringSwitch<llvm::omp::Clause>(Str) |
109 | #define OPENMP_ATOMIC_FAIL_MODIFIER(Name) .Case(#Name, OMPC_##Name) |
110 | #include "clang/Basic/OpenMPKinds.def" |
111 | .Default(OMPC_unknown)); |
112 | case OMPC_device_type: |
113 | return llvm::StringSwitch<OpenMPDeviceType>(Str) |
114 | #define OPENMP_DEVICE_TYPE_KIND(Name) .Case(#Name, OMPC_DEVICE_TYPE_##Name) |
115 | #include "clang/Basic/OpenMPKinds.def" |
116 | .Default(Value: OMPC_DEVICE_TYPE_unknown); |
117 | case OMPC_at: |
118 | return llvm::StringSwitch<OpenMPAtClauseKind>(Str) |
119 | #define OPENMP_AT_KIND(Name) .Case(#Name, OMPC_AT_##Name) |
120 | #include "clang/Basic/OpenMPKinds.def" |
121 | .Default(Value: OMPC_AT_unknown); |
122 | case OMPC_severity: |
123 | return llvm::StringSwitch<OpenMPSeverityClauseKind>(Str) |
124 | #define OPENMP_SEVERITY_KIND(Name) .Case(#Name, OMPC_SEVERITY_##Name) |
125 | #include "clang/Basic/OpenMPKinds.def" |
126 | .Default(Value: OMPC_SEVERITY_unknown); |
127 | case OMPC_lastprivate: |
128 | return llvm::StringSwitch<OpenMPLastprivateModifier>(Str) |
129 | #define OPENMP_LASTPRIVATE_KIND(Name) .Case(#Name, OMPC_LASTPRIVATE_##Name) |
130 | #include "clang/Basic/OpenMPKinds.def" |
131 | .Default(Value: OMPC_LASTPRIVATE_unknown); |
132 | case OMPC_order: |
133 | return llvm::StringSwitch<unsigned>(Str) |
134 | #define OPENMP_ORDER_KIND(Name) \ |
135 | .Case(#Name, static_cast<unsigned>(OMPC_ORDER_##Name)) |
136 | #define OPENMP_ORDER_MODIFIER(Name) \ |
137 | .Case(#Name, static_cast<unsigned>(OMPC_ORDER_MODIFIER_##Name)) |
138 | #include "clang/Basic/OpenMPKinds.def" |
139 | .Default(Value: OMPC_ORDER_unknown); |
140 | case OMPC_update: |
141 | return llvm::StringSwitch<OpenMPDependClauseKind>(Str) |
142 | #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name) |
143 | #include "clang/Basic/OpenMPKinds.def" |
144 | .Default(Value: OMPC_DEPEND_unknown); |
145 | case OMPC_device: |
146 | return llvm::StringSwitch<OpenMPDeviceClauseModifier>(Str) |
147 | #define OPENMP_DEVICE_MODIFIER(Name) .Case(#Name, OMPC_DEVICE_##Name) |
148 | #include "clang/Basic/OpenMPKinds.def" |
149 | .Default(Value: OMPC_DEVICE_unknown); |
150 | case OMPC_reduction: |
151 | return llvm::StringSwitch<OpenMPReductionClauseModifier>(Str) |
152 | #define OPENMP_REDUCTION_MODIFIER(Name) .Case(#Name, OMPC_REDUCTION_##Name) |
153 | #include "clang/Basic/OpenMPKinds.def" |
154 | .Default(Value: OMPC_REDUCTION_unknown); |
155 | case OMPC_adjust_args: |
156 | return llvm::StringSwitch<OpenMPAdjustArgsOpKind>(Str) |
157 | #define OPENMP_ADJUST_ARGS_KIND(Name) .Case(#Name, OMPC_ADJUST_ARGS_##Name) |
158 | #include "clang/Basic/OpenMPKinds.def" |
159 | .Default(Value: OMPC_ADJUST_ARGS_unknown); |
160 | case OMPC_bind: |
161 | return llvm::StringSwitch<unsigned>(Str) |
162 | #define OPENMP_BIND_KIND(Name) .Case(#Name, OMPC_BIND_##Name) |
163 | #include "clang/Basic/OpenMPKinds.def" |
164 | .Default(Value: OMPC_BIND_unknown); |
165 | case OMPC_grainsize: { |
166 | unsigned Type = llvm::StringSwitch<unsigned>(Str) |
167 | #define OPENMP_GRAINSIZE_MODIFIER(Name) .Case(#Name, OMPC_GRAINSIZE_##Name) |
168 | #include "clang/Basic/OpenMPKinds.def" |
169 | .Default(Value: OMPC_GRAINSIZE_unknown); |
170 | if (LangOpts.OpenMP < 51) |
171 | return OMPC_GRAINSIZE_unknown; |
172 | return Type; |
173 | } |
174 | case OMPC_num_tasks: { |
175 | unsigned Type = llvm::StringSwitch<unsigned>(Str) |
176 | #define OPENMP_NUMTASKS_MODIFIER(Name) .Case(#Name, OMPC_NUMTASKS_##Name) |
177 | #include "clang/Basic/OpenMPKinds.def" |
178 | .Default(Value: OMPC_NUMTASKS_unknown); |
179 | if (LangOpts.OpenMP < 51) |
180 | return OMPC_NUMTASKS_unknown; |
181 | return Type; |
182 | } |
183 | case OMPC_allocate: |
184 | return llvm::StringSwitch<OpenMPAllocateClauseModifier>(Str) |
185 | #define OPENMP_ALLOCATE_MODIFIER(Name) .Case(#Name, OMPC_ALLOCATE_##Name) |
186 | #include "clang/Basic/OpenMPKinds.def" |
187 | .Default(Value: OMPC_ALLOCATE_unknown); |
188 | case OMPC_unknown: |
189 | case OMPC_threadprivate: |
190 | case OMPC_if: |
191 | case OMPC_final: |
192 | case OMPC_num_threads: |
193 | case OMPC_safelen: |
194 | case OMPC_simdlen: |
195 | case OMPC_sizes: |
196 | case OMPC_permutation: |
197 | case OMPC_allocator: |
198 | case OMPC_collapse: |
199 | case OMPC_private: |
200 | case OMPC_firstprivate: |
201 | case OMPC_shared: |
202 | case OMPC_task_reduction: |
203 | case OMPC_in_reduction: |
204 | case OMPC_aligned: |
205 | case OMPC_copyin: |
206 | case OMPC_copyprivate: |
207 | case OMPC_ordered: |
208 | case OMPC_nowait: |
209 | case OMPC_untied: |
210 | case OMPC_mergeable: |
211 | case OMPC_flush: |
212 | case OMPC_depobj: |
213 | case OMPC_read: |
214 | case OMPC_write: |
215 | case OMPC_capture: |
216 | case OMPC_compare: |
217 | case OMPC_seq_cst: |
218 | case OMPC_acq_rel: |
219 | case OMPC_acquire: |
220 | case OMPC_release: |
221 | case OMPC_relaxed: |
222 | case OMPC_threads: |
223 | case OMPC_simd: |
224 | case OMPC_num_teams: |
225 | case OMPC_thread_limit: |
226 | case OMPC_priority: |
227 | case OMPC_nogroup: |
228 | case OMPC_hint: |
229 | case OMPC_uniform: |
230 | case OMPC_use_device_ptr: |
231 | case OMPC_use_device_addr: |
232 | case OMPC_is_device_ptr: |
233 | case OMPC_has_device_addr: |
234 | case OMPC_unified_address: |
235 | case OMPC_unified_shared_memory: |
236 | case OMPC_reverse_offload: |
237 | case OMPC_dynamic_allocators: |
238 | case OMPC_self_maps: |
239 | case OMPC_match: |
240 | case OMPC_nontemporal: |
241 | case OMPC_destroy: |
242 | case OMPC_novariants: |
243 | case OMPC_nocontext: |
244 | case OMPC_detach: |
245 | case OMPC_inclusive: |
246 | case OMPC_exclusive: |
247 | case OMPC_uses_allocators: |
248 | case OMPC_affinity: |
249 | case OMPC_when: |
250 | case OMPC_append_args: |
251 | break; |
252 | default: |
253 | break; |
254 | } |
255 | llvm_unreachable("Invalid OpenMP simple clause kind"); |
256 | } |
257 | |
258 | const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, |
259 | unsigned Type) { |
260 | switch (Kind) { |
261 | case OMPC_default: |
262 | switch (llvm::omp::DefaultKind(Type)) { |
263 | #define OMP_DEFAULT_KIND(Enum, Name) \ |
264 | case Enum: \ |
265 | return Name; |
266 | #include "llvm/Frontend/OpenMP/OMPKinds.def" |
267 | } |
268 | llvm_unreachable("Invalid OpenMP 'default' clause type"); |
269 | case OMPC_proc_bind: |
270 | switch (Type) { |
271 | #define OMP_PROC_BIND_KIND(Enum, Name, Value) \ |
272 | case Value: \ |
273 | return Name; |
274 | #include "llvm/Frontend/OpenMP/OMPKinds.def" |
275 | } |
276 | llvm_unreachable("Invalid OpenMP 'proc_bind' clause type"); |
277 | case OMPC_schedule: |
278 | switch (Type) { |
279 | case OMPC_SCHEDULE_unknown: |
280 | case OMPC_SCHEDULE_MODIFIER_last: |
281 | return "unknown"; |
282 | #define OPENMP_SCHEDULE_KIND(Name) \ |
283 | case OMPC_SCHEDULE_##Name: \ |
284 | return #Name; |
285 | #define OPENMP_SCHEDULE_MODIFIER(Name) \ |
286 | case OMPC_SCHEDULE_MODIFIER_##Name: \ |
287 | return #Name; |
288 | #include "clang/Basic/OpenMPKinds.def" |
289 | } |
290 | llvm_unreachable("Invalid OpenMP 'schedule' clause type"); |
291 | case OMPC_depend: |
292 | switch (Type) { |
293 | case OMPC_DEPEND_unknown: |
294 | return "unknown"; |
295 | #define OPENMP_DEPEND_KIND(Name) \ |
296 | case OMPC_DEPEND_##Name: \ |
297 | return #Name; |
298 | #include "clang/Basic/OpenMPKinds.def" |
299 | } |
300 | llvm_unreachable("Invalid OpenMP 'depend' clause type"); |
301 | case OMPC_doacross: |
302 | switch (Type) { |
303 | case OMPC_DOACROSS_unknown: |
304 | return "unknown"; |
305 | #define OPENMP_DOACROSS_MODIFIER(Name) \ |
306 | case OMPC_DOACROSS_##Name: \ |
307 | return #Name; |
308 | #include "clang/Basic/OpenMPKinds.def" |
309 | } |
310 | llvm_unreachable("Invalid OpenMP 'doacross' clause type"); |
311 | case OMPC_linear: |
312 | switch (Type) { |
313 | case OMPC_LINEAR_unknown: |
314 | return "unknown"; |
315 | #define OPENMP_LINEAR_KIND(Name) \ |
316 | case OMPC_LINEAR_##Name: \ |
317 | return #Name; |
318 | #include "clang/Basic/OpenMPKinds.def" |
319 | } |
320 | llvm_unreachable("Invalid OpenMP 'linear' clause type"); |
321 | case OMPC_map: |
322 | switch (Type) { |
323 | case OMPC_MAP_unknown: |
324 | case OMPC_MAP_MODIFIER_last: |
325 | return "unknown"; |
326 | #define OPENMP_MAP_KIND(Name) \ |
327 | case OMPC_MAP_##Name: \ |
328 | return #Name; |
329 | #define OPENMP_MAP_MODIFIER_KIND(Name) \ |
330 | case OMPC_MAP_MODIFIER_##Name: \ |
331 | return #Name; |
332 | #include "clang/Basic/OpenMPKinds.def" |
333 | default: |
334 | break; |
335 | } |
336 | llvm_unreachable("Invalid OpenMP 'map' clause type"); |
337 | case OMPC_to: |
338 | case OMPC_from: |
339 | switch (Type) { |
340 | case OMPC_MOTION_MODIFIER_unknown: |
341 | return "unknown"; |
342 | #define OPENMP_MOTION_MODIFIER_KIND(Name) \ |
343 | case OMPC_MOTION_MODIFIER_##Name: \ |
344 | return #Name; |
345 | #include "clang/Basic/OpenMPKinds.def" |
346 | default: |
347 | break; |
348 | } |
349 | llvm_unreachable("Invalid OpenMP 'to' or 'from' clause type"); |
350 | case OMPC_dist_schedule: |
351 | switch (Type) { |
352 | case OMPC_DIST_SCHEDULE_unknown: |
353 | return "unknown"; |
354 | #define OPENMP_DIST_SCHEDULE_KIND(Name) \ |
355 | case OMPC_DIST_SCHEDULE_##Name: \ |
356 | return #Name; |
357 | #include "clang/Basic/OpenMPKinds.def" |
358 | } |
359 | llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type"); |
360 | case OMPC_defaultmap: |
361 | switch (Type) { |
362 | case OMPC_DEFAULTMAP_unknown: |
363 | case OMPC_DEFAULTMAP_MODIFIER_last: |
364 | return "unknown"; |
365 | #define OPENMP_DEFAULTMAP_KIND(Name) \ |
366 | case OMPC_DEFAULTMAP_##Name: \ |
367 | return #Name; |
368 | #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ |
369 | case OMPC_DEFAULTMAP_MODIFIER_##Name: \ |
370 | return #Name; |
371 | #include "clang/Basic/OpenMPKinds.def" |
372 | } |
373 | llvm_unreachable("Invalid OpenMP 'schedule' clause type"); |
374 | case OMPC_atomic_default_mem_order: |
375 | switch (Type) { |
376 | case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown: |
377 | return "unknown"; |
378 | #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \ |
379 | case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name: \ |
380 | return #Name; |
381 | #include "clang/Basic/OpenMPKinds.def" |
382 | } |
383 | llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type"); |
384 | case OMPC_device_type: |
385 | switch (Type) { |
386 | case OMPC_DEVICE_TYPE_unknown: |
387 | return "unknown"; |
388 | #define OPENMP_DEVICE_TYPE_KIND(Name) \ |
389 | case OMPC_DEVICE_TYPE_##Name: \ |
390 | return #Name; |
391 | #include "clang/Basic/OpenMPKinds.def" |
392 | } |
393 | llvm_unreachable("Invalid OpenMP 'device_type' clause type"); |
394 | case OMPC_at: |
395 | switch (Type) { |
396 | case OMPC_AT_unknown: |
397 | return "unknown"; |
398 | #define OPENMP_AT_KIND(Name) \ |
399 | case OMPC_AT_##Name: \ |
400 | return #Name; |
401 | #include "clang/Basic/OpenMPKinds.def" |
402 | } |
403 | llvm_unreachable("Invalid OpenMP 'at' clause type"); |
404 | case OMPC_severity: |
405 | switch (Type) { |
406 | case OMPC_SEVERITY_unknown: |
407 | return "unknown"; |
408 | #define OPENMP_SEVERITY_KIND(Name) \ |
409 | case OMPC_SEVERITY_##Name: \ |
410 | return #Name; |
411 | #include "clang/Basic/OpenMPKinds.def" |
412 | } |
413 | llvm_unreachable("Invalid OpenMP 'severity' clause type"); |
414 | case OMPC_lastprivate: |
415 | switch (Type) { |
416 | case OMPC_LASTPRIVATE_unknown: |
417 | return "unknown"; |
418 | #define OPENMP_LASTPRIVATE_KIND(Name) \ |
419 | case OMPC_LASTPRIVATE_##Name: \ |
420 | return #Name; |
421 | #include "clang/Basic/OpenMPKinds.def" |
422 | } |
423 | llvm_unreachable("Invalid OpenMP 'lastprivate' clause type"); |
424 | case OMPC_order: |
425 | switch (Type) { |
426 | case OMPC_ORDER_unknown: |
427 | case OMPC_ORDER_MODIFIER_last: |
428 | return "unknown"; |
429 | #define OPENMP_ORDER_KIND(Name) \ |
430 | case OMPC_ORDER_##Name: \ |
431 | return #Name; |
432 | #define OPENMP_ORDER_MODIFIER(Name) \ |
433 | case OMPC_ORDER_MODIFIER_##Name: \ |
434 | return #Name; |
435 | #include "clang/Basic/OpenMPKinds.def" |
436 | } |
437 | llvm_unreachable("Invalid OpenMP 'order' clause type"); |
438 | case OMPC_update: |
439 | switch (Type) { |
440 | case OMPC_DEPEND_unknown: |
441 | return "unknown"; |
442 | #define OPENMP_DEPEND_KIND(Name) \ |
443 | case OMPC_DEPEND_##Name: \ |
444 | return #Name; |
445 | #include "clang/Basic/OpenMPKinds.def" |
446 | } |
447 | llvm_unreachable("Invalid OpenMP 'depend' clause type"); |
448 | case OMPC_fail: { |
449 | OpenMPClauseKind CK = static_cast<OpenMPClauseKind>(Type); |
450 | return getOpenMPClauseName(CK).data(); |
451 | llvm_unreachable("Invalid OpenMP 'fail' clause modifier"); |
452 | } |
453 | case OMPC_device: |
454 | switch (Type) { |
455 | case OMPC_DEVICE_unknown: |
456 | return "unknown"; |
457 | #define OPENMP_DEVICE_MODIFIER(Name) \ |
458 | case OMPC_DEVICE_##Name: \ |
459 | return #Name; |
460 | #include "clang/Basic/OpenMPKinds.def" |
461 | } |
462 | llvm_unreachable("Invalid OpenMP 'device' clause modifier"); |
463 | case OMPC_reduction: |
464 | switch (Type) { |
465 | case OMPC_REDUCTION_unknown: |
466 | return "unknown"; |
467 | #define OPENMP_REDUCTION_MODIFIER(Name) \ |
468 | case OMPC_REDUCTION_##Name: \ |
469 | return #Name; |
470 | #include "clang/Basic/OpenMPKinds.def" |
471 | } |
472 | llvm_unreachable("Invalid OpenMP 'reduction' clause modifier"); |
473 | case OMPC_adjust_args: |
474 | switch (Type) { |
475 | case OMPC_ADJUST_ARGS_unknown: |
476 | return "unknown"; |
477 | #define OPENMP_ADJUST_ARGS_KIND(Name) \ |
478 | case OMPC_ADJUST_ARGS_##Name: \ |
479 | return #Name; |
480 | #include "clang/Basic/OpenMPKinds.def" |
481 | } |
482 | llvm_unreachable("Invalid OpenMP 'adjust_args' clause kind"); |
483 | case OMPC_bind: |
484 | switch (Type) { |
485 | case OMPC_BIND_unknown: |
486 | return "unknown"; |
487 | #define OPENMP_BIND_KIND(Name) \ |
488 | case OMPC_BIND_##Name: \ |
489 | return #Name; |
490 | #include "clang/Basic/OpenMPKinds.def" |
491 | } |
492 | llvm_unreachable("Invalid OpenMP 'bind' clause type"); |
493 | case OMPC_grainsize: |
494 | switch (Type) { |
495 | case OMPC_GRAINSIZE_unknown: |
496 | return "unknown"; |
497 | #define OPENMP_GRAINSIZE_MODIFIER(Name) \ |
498 | case OMPC_GRAINSIZE_##Name: \ |
499 | return #Name; |
500 | #include "clang/Basic/OpenMPKinds.def" |
501 | } |
502 | llvm_unreachable("Invalid OpenMP 'grainsize' clause modifier"); |
503 | case OMPC_num_tasks: |
504 | switch (Type) { |
505 | case OMPC_NUMTASKS_unknown: |
506 | return "unknown"; |
507 | #define OPENMP_NUMTASKS_MODIFIER(Name) \ |
508 | case OMPC_NUMTASKS_##Name: \ |
509 | return #Name; |
510 | #include "clang/Basic/OpenMPKinds.def" |
511 | } |
512 | llvm_unreachable("Invalid OpenMP 'num_tasks' clause modifier"); |
513 | case OMPC_allocate: |
514 | switch (Type) { |
515 | case OMPC_ALLOCATE_unknown: |
516 | return "unknown"; |
517 | #define OPENMP_ALLOCATE_MODIFIER(Name) \ |
518 | case OMPC_ALLOCATE_##Name: \ |
519 | return #Name; |
520 | #include "clang/Basic/OpenMPKinds.def" |
521 | } |
522 | llvm_unreachable("Invalid OpenMP 'allocate' clause modifier"); |
523 | case OMPC_unknown: |
524 | case OMPC_threadprivate: |
525 | case OMPC_if: |
526 | case OMPC_final: |
527 | case OMPC_num_threads: |
528 | case OMPC_safelen: |
529 | case OMPC_simdlen: |
530 | case OMPC_sizes: |
531 | case OMPC_permutation: |
532 | case OMPC_allocator: |
533 | case OMPC_collapse: |
534 | case OMPC_private: |
535 | case OMPC_firstprivate: |
536 | case OMPC_shared: |
537 | case OMPC_task_reduction: |
538 | case OMPC_in_reduction: |
539 | case OMPC_aligned: |
540 | case OMPC_copyin: |
541 | case OMPC_copyprivate: |
542 | case OMPC_ordered: |
543 | case OMPC_nowait: |
544 | case OMPC_untied: |
545 | case OMPC_mergeable: |
546 | case OMPC_flush: |
547 | case OMPC_depobj: |
548 | case OMPC_read: |
549 | case OMPC_write: |
550 | case OMPC_capture: |
551 | case OMPC_compare: |
552 | case OMPC_seq_cst: |
553 | case OMPC_acq_rel: |
554 | case OMPC_acquire: |
555 | case OMPC_release: |
556 | case OMPC_relaxed: |
557 | case OMPC_threads: |
558 | case OMPC_simd: |
559 | case OMPC_num_teams: |
560 | case OMPC_thread_limit: |
561 | case OMPC_priority: |
562 | case OMPC_nogroup: |
563 | case OMPC_hint: |
564 | case OMPC_uniform: |
565 | case OMPC_use_device_ptr: |
566 | case OMPC_use_device_addr: |
567 | case OMPC_is_device_ptr: |
568 | case OMPC_has_device_addr: |
569 | case OMPC_unified_address: |
570 | case OMPC_unified_shared_memory: |
571 | case OMPC_reverse_offload: |
572 | case OMPC_dynamic_allocators: |
573 | case OMPC_self_maps: |
574 | case OMPC_match: |
575 | case OMPC_nontemporal: |
576 | case OMPC_destroy: |
577 | case OMPC_detach: |
578 | case OMPC_novariants: |
579 | case OMPC_nocontext: |
580 | case OMPC_inclusive: |
581 | case OMPC_exclusive: |
582 | case OMPC_uses_allocators: |
583 | case OMPC_affinity: |
584 | case OMPC_when: |
585 | case OMPC_append_args: |
586 | break; |
587 | default: |
588 | break; |
589 | } |
590 | llvm_unreachable("Invalid OpenMP simple clause kind"); |
591 | } |
592 | |
593 | bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) { |
594 | return getDirectiveAssociation(DKind) == Association::Loop; |
595 | } |
596 | |
597 | bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { |
598 | return DKind == OMPD_for || DKind == OMPD_for_simd || |
599 | DKind == OMPD_sections || DKind == OMPD_section || |
600 | DKind == OMPD_single || DKind == OMPD_parallel_for || |
601 | DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || |
602 | DKind == OMPD_target_parallel_for || |
603 | DKind == OMPD_distribute_parallel_for || |
604 | DKind == OMPD_distribute_parallel_for_simd || |
605 | DKind == OMPD_target_parallel_for_simd || |
606 | DKind == OMPD_teams_distribute_parallel_for_simd || |
607 | DKind == OMPD_teams_distribute_parallel_for || |
608 | DKind == OMPD_target_teams_distribute_parallel_for || |
609 | DKind == OMPD_target_teams_distribute_parallel_for_simd || |
610 | DKind == OMPD_parallel_loop || DKind == OMPD_teams_loop || |
611 | DKind == OMPD_target_parallel_loop || DKind == OMPD_target_teams_loop; |
612 | } |
613 | |
614 | bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) { |
615 | return DKind == OMPD_taskloop || |
616 | llvm::is_contained(getLeafConstructs(DKind), OMPD_taskloop); |
617 | } |
618 | |
619 | bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) { |
620 | if (DKind == OMPD_teams_loop) |
621 | return true; |
622 | return DKind == OMPD_parallel || |
623 | llvm::is_contained(getLeafConstructs(DKind), OMPD_parallel); |
624 | } |
625 | |
626 | bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) { |
627 | return DKind == OMPD_target || |
628 | llvm::is_contained(getLeafConstructs(DKind), OMPD_target); |
629 | } |
630 | |
631 | bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) { |
632 | return DKind == OMPD_target_data || DKind == OMPD_target_enter_data || |
633 | DKind == OMPD_target_exit_data || DKind == OMPD_target_update; |
634 | } |
635 | |
636 | bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) { |
637 | if (DKind == OMPD_teams) |
638 | return true; |
639 | ArrayRef<Directive> Leaves = getLeafConstructs(DKind); |
640 | return !Leaves.empty() && Leaves.front() == OMPD_teams; |
641 | } |
642 | |
643 | bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) { |
644 | return DKind == OMPD_teams || |
645 | llvm::is_contained(getLeafConstructs(DKind), OMPD_teams); |
646 | } |
647 | |
648 | bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) { |
649 | // Avoid OMPD_declare_simd |
650 | if (getDirectiveAssociation(DKind) != Association::Loop) |
651 | return false; |
652 | // Formally, OMPD_end_do_simd also has a loop association, but |
653 | // it's a Fortran-specific directive. |
654 | |
655 | return DKind == OMPD_simd || |
656 | llvm::is_contained(getLeafConstructs(DKind), OMPD_simd); |
657 | } |
658 | |
659 | bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) { |
660 | if (Kind == OMPD_distribute) |
661 | return true; |
662 | ArrayRef<Directive> Leaves = getLeafConstructs(Kind); |
663 | return !Leaves.empty() && Leaves.front() == OMPD_distribute; |
664 | } |
665 | |
666 | bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) { |
667 | return Kind == OMPD_distribute || |
668 | llvm::is_contained(getLeafConstructs(Kind), OMPD_distribute); |
669 | } |
670 | |
671 | bool clang::isOpenMPGenericLoopDirective(OpenMPDirectiveKind Kind) { |
672 | if (Kind == OMPD_loop) |
673 | return true; |
674 | ArrayRef<Directive> Leaves = getLeafConstructs(Kind); |
675 | return !Leaves.empty() && Leaves.back() == OMPD_loop; |
676 | } |
677 | |
678 | bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) { |
679 | return Kind == OMPC_private || Kind == OMPC_firstprivate || |
680 | Kind == OMPC_lastprivate || Kind == OMPC_linear || |
681 | Kind == OMPC_reduction || Kind == OMPC_task_reduction || |
682 | Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'. |
683 | } |
684 | |
685 | bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) { |
686 | return Kind == OMPC_threadprivate || Kind == OMPC_copyin; |
687 | } |
688 | |
689 | bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) { |
690 | return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind); |
691 | } |
692 | |
693 | bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) { |
694 | return Kind == OMPD_distribute_parallel_for || |
695 | Kind == OMPD_distribute_parallel_for_simd || |
696 | Kind == OMPD_teams_distribute_parallel_for_simd || |
697 | Kind == OMPD_teams_distribute_parallel_for || |
698 | Kind == OMPD_target_teams_distribute_parallel_for || |
699 | Kind == OMPD_target_teams_distribute_parallel_for_simd || |
700 | Kind == OMPD_teams_loop || Kind == OMPD_target_teams_loop; |
701 | } |
702 | |
703 | bool clang::isOpenMPLoopTransformationDirective(OpenMPDirectiveKind DKind) { |
704 | return DKind == OMPD_tile || DKind == OMPD_unroll || DKind == OMPD_reverse || |
705 | DKind == OMPD_interchange || DKind == OMPD_stripe; |
706 | } |
707 | |
708 | bool clang::isOpenMPCombinedParallelADirective(OpenMPDirectiveKind DKind) { |
709 | return DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd || |
710 | DKind == OMPD_parallel_master || |
711 | DKind == OMPD_parallel_master_taskloop || |
712 | DKind == OMPD_parallel_master_taskloop_simd || |
713 | DKind == OMPD_parallel_sections; |
714 | } |
715 | |
716 | bool clang::needsTaskBasedThreadLimit(OpenMPDirectiveKind DKind) { |
717 | return DKind == OMPD_target || DKind == OMPD_target_parallel || |
718 | DKind == OMPD_target_parallel_for || |
719 | DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || |
720 | DKind == OMPD_target_parallel_loop; |
721 | } |
722 | |
723 | bool clang::isOpenMPExecutableDirective(OpenMPDirectiveKind DKind) { |
724 | if (DKind == OMPD_error) |
725 | return true; |
726 | Category Cat = getDirectiveCategory(DKind); |
727 | return Cat == Category::Executable || Cat == Category::Subsidiary; |
728 | } |
729 | |
730 | bool clang::isOpenMPInformationalDirective(OpenMPDirectiveKind DKind) { |
731 | if (DKind == OMPD_error) |
732 | return true; |
733 | Category Cat = getDirectiveCategory(DKind); |
734 | return Cat == Category::Informational; |
735 | } |
736 | |
737 | bool clang::isOpenMPCapturingDirective(OpenMPDirectiveKind DKind) { |
738 | if (isOpenMPExecutableDirective(DKind)) { |
739 | switch (DKind) { |
740 | case OMPD_atomic: |
741 | case OMPD_barrier: |
742 | case OMPD_cancel: |
743 | case OMPD_cancellation_point: |
744 | case OMPD_critical: |
745 | case OMPD_depobj: |
746 | case OMPD_error: |
747 | case OMPD_flush: |
748 | case OMPD_masked: |
749 | case OMPD_master: |
750 | case OMPD_section: |
751 | case OMPD_taskwait: |
752 | case OMPD_taskyield: |
753 | case OMPD_assume: |
754 | return false; |
755 | default: |
756 | return !isOpenMPLoopTransformationDirective(DKind); |
757 | } |
758 | } |
759 | // Non-executable directives. |
760 | switch (DKind) { |
761 | case OMPD_metadirective: |
762 | case OMPD_nothing: |
763 | return true; |
764 | default: |
765 | break; |
766 | } |
767 | return false; |
768 | } |
769 | |
770 | bool clang::isOpenMPOrderConcurrentNestableDirective( |
771 | OpenMPDirectiveKind DKind, const LangOptions &LangOpts) { |
772 | // Directives strictly nestable in a construct with order(concurrent) are: |
773 | // OpenMP 5.x: loop, parallel, simd, combined directive starting with parallel |
774 | // OpenMP 6.0: above plus atomic and all loop-transformation directives |
775 | |
776 | if (DKind == OMPD_loop || DKind == OMPD_parallel || DKind == OMPD_simd || |
777 | isOpenMPCombinedParallelADirective(DKind)) |
778 | return true; |
779 | |
780 | if (LangOpts.OpenMP >= 60) |
781 | return DKind == OMPD_atomic || |
782 | isOpenMPLoopTransformationDirective(DKind); |
783 | |
784 | return false; |
785 | } |
786 | |
787 | void clang::getOpenMPCaptureRegions( |
788 | SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions, |
789 | OpenMPDirectiveKind DKind) { |
790 | assert(unsigned(DKind) < llvm::omp::Directive_enumSize); |
791 | assert(isOpenMPCapturingDirective(DKind) && "Expecting capturing directive"); |
792 | |
793 | auto GetRegionsForLeaf = [&](OpenMPDirectiveKind LKind) { |
794 | assert(isLeafConstruct(LKind) && "Epecting leaf directive"); |
795 | // Whether a leaf would require OMPD_unknown if it occured on its own. |
796 | switch (LKind) { |
797 | case OMPD_metadirective: |
798 | CaptureRegions.push_back(OMPD_metadirective); |
799 | break; |
800 | case OMPD_nothing: |
801 | CaptureRegions.push_back(OMPD_nothing); |
802 | break; |
803 | case OMPD_parallel: |
804 | CaptureRegions.push_back(OMPD_parallel); |
805 | break; |
806 | case OMPD_target: |
807 | CaptureRegions.push_back(OMPD_task); |
808 | CaptureRegions.push_back(OMPD_target); |
809 | break; |
810 | case OMPD_task: |
811 | case OMPD_target_enter_data: |
812 | case OMPD_target_exit_data: |
813 | case OMPD_target_update: |
814 | CaptureRegions.push_back(OMPD_task); |
815 | break; |
816 | case OMPD_teams: |
817 | CaptureRegions.push_back(OMPD_teams); |
818 | break; |
819 | case OMPD_taskloop: |
820 | CaptureRegions.push_back(OMPD_taskloop); |
821 | break; |
822 | case OMPD_loop: |
823 | // TODO: 'loop' may require different capture regions depending on the |
824 | // bind clause or the parent directive when there is no bind clause. |
825 | // If any of the directives that push regions here are parents of 'loop', |
826 | // assume 'parallel'. Otherwise do nothing. |
827 | if (!CaptureRegions.empty() && |
828 | !llvm::is_contained(CaptureRegions, OMPD_parallel)) |
829 | CaptureRegions.push_back(OMPD_parallel); |
830 | else |
831 | return true; |
832 | break; |
833 | case OMPD_dispatch: |
834 | case OMPD_distribute: |
835 | case OMPD_for: |
836 | case OMPD_ordered: |
837 | case OMPD_scope: |
838 | case OMPD_sections: |
839 | case OMPD_simd: |
840 | case OMPD_single: |
841 | case OMPD_target_data: |
842 | case OMPD_taskgroup: |
843 | case OMPD_stripe: |
844 | // These directives (when standalone) use OMPD_unknown as the region, |
845 | // but when they're constituents of a compound directive, and other |
846 | // leafs from that directive have specific regions, then these directives |
847 | // add no additional regions. |
848 | return true; |
849 | case OMPD_masked: |
850 | case OMPD_master: |
851 | return false; |
852 | default: |
853 | llvm::errs() << getOpenMPDirectiveName(LKind, llvm::omp::FallbackVersion) |
854 | << '\n'; |
855 | llvm_unreachable("Unexpected directive"); |
856 | } |
857 | return false; |
858 | }; |
859 | |
860 | bool MayNeedUnknownRegion = false; |
861 | for (OpenMPDirectiveKind L : getLeafConstructsOrSelf(DKind)) |
862 | MayNeedUnknownRegion |= GetRegionsForLeaf(L); |
863 | |
864 | // We need OMPD_unknown when no regions were added, and specific leaf |
865 | // constructs were present. Push a single OMPD_unknown as the capture |
866 | /// region. |
867 | if (CaptureRegions.empty() && MayNeedUnknownRegion) |
868 | CaptureRegions.push_back(OMPD_unknown); |
869 | |
870 | // OMPD_unknown is only expected as the only region. If other regions |
871 | // are present OMPD_unknown should not be present. |
872 | assert((CaptureRegions[0] == OMPD_unknown || |
873 | !llvm::is_contained(CaptureRegions, OMPD_unknown)) && |
874 | "Misplaced OMPD_unknown"); |
875 | } |
876 | |
877 | bool clang::checkFailClauseParameter(OpenMPClauseKind FailClauseParameter) { |
878 | return FailClauseParameter == llvm::omp::OMPC_acquire || |
879 | FailClauseParameter == llvm::omp::OMPC_relaxed || |
880 | FailClauseParameter == llvm::omp::OMPC_seq_cst; |
881 | } |
882 | |
883 |
Definitions
- getOpenMPSimpleClauseType
- getOpenMPSimpleClauseTypeName
- isOpenMPLoopDirective
- isOpenMPWorksharingDirective
- isOpenMPTaskLoopDirective
- isOpenMPParallelDirective
- isOpenMPTargetExecutionDirective
- isOpenMPTargetDataManagementDirective
- isOpenMPNestingTeamsDirective
- isOpenMPTeamsDirective
- isOpenMPSimdDirective
- isOpenMPNestingDistributeDirective
- isOpenMPDistributeDirective
- isOpenMPGenericLoopDirective
- isOpenMPPrivate
- isOpenMPThreadPrivate
- isOpenMPTaskingDirective
- isOpenMPLoopBoundSharingDirective
- isOpenMPLoopTransformationDirective
- isOpenMPCombinedParallelADirective
- needsTaskBasedThreadLimit
- isOpenMPExecutableDirective
- isOpenMPInformationalDirective
- isOpenMPCapturingDirective
- isOpenMPOrderConcurrentNestableDirective
- getOpenMPCaptureRegions
Improve your Profiling and Debugging skills
Find out more