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