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 OpenMPContextSelectorSetKind 24 clang::getOpenMPContextSelectorSet(llvm::StringRef Str) { 25 return llvm::StringSwitch<OpenMPContextSelectorSetKind>(Str) 26 #define OPENMP_CONTEXT_SELECTOR_SET(Name) .Case(#Name, OMP_CTX_SET_##Name) 27 #include "clang/Basic/OpenMPKinds.def" 28 .Default(OMP_CTX_SET_unknown); 29 } 30 31 llvm::StringRef 32 clang::getOpenMPContextSelectorSetName(OpenMPContextSelectorSetKind Kind) { 33 switch (Kind) { 34 case OMP_CTX_SET_unknown: 35 return "unknown"; 36 #define OPENMP_CONTEXT_SELECTOR_SET(Name) \ 37 case OMP_CTX_SET_##Name: \ 38 return #Name; 39 #include "clang/Basic/OpenMPKinds.def" 40 break; 41 } 42 llvm_unreachable("Invalid OpenMP context selector set kind"); 43 } 44 45 OpenMPContextSelectorKind clang::getOpenMPContextSelector(llvm::StringRef Str) { 46 return llvm::StringSwitch<OpenMPContextSelectorKind>(Str) 47 #define OPENMP_CONTEXT_SELECTOR(Name) .Case(#Name, OMP_CTX_##Name) 48 #include "clang/Basic/OpenMPKinds.def" 49 .Default(OMP_CTX_unknown); 50 } 51 52 llvm::StringRef 53 clang::getOpenMPContextSelectorName(OpenMPContextSelectorKind Kind) { 54 switch (Kind) { 55 case OMP_CTX_unknown: 56 return "unknown"; 57 #define OPENMP_CONTEXT_SELECTOR(Name) \ 58 case OMP_CTX_##Name: \ 59 return #Name; 60 #include "clang/Basic/OpenMPKinds.def" 61 break; 62 } 63 llvm_unreachable("Invalid OpenMP context selector kind"); 64 } 65 66 OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) { 67 // 'flush' clause cannot be specified explicitly, because this is an implicit 68 // clause for 'flush' directive. If the 'flush' clause is explicitly specified 69 // the Parser should generate a warning about extra tokens at the end of the 70 // directive. 71 if (Str == "flush") 72 return OMPC_unknown; 73 return llvm::StringSwitch<OpenMPClauseKind>(Str) 74 #define OPENMP_CLAUSE(Name, Class) .Case(#Name, OMPC_##Name) 75 #include "clang/Basic/OpenMPKinds.def" 76 .Case("uniform", OMPC_uniform) 77 .Case("device_type", OMPC_device_type) 78 .Case("match", OMPC_match) 79 .Default(OMPC_unknown); 80 } 81 82 const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) { 83 assert(Kind <= OMPC_unknown); 84 switch (Kind) { 85 case OMPC_unknown: 86 return "unknown"; 87 #define OPENMP_CLAUSE(Name, Class) \ 88 case OMPC_##Name: \ 89 return #Name; 90 #include "clang/Basic/OpenMPKinds.def" 91 case OMPC_uniform: 92 return "uniform"; 93 case OMPC_threadprivate: 94 return "threadprivate or thread local"; 95 case OMPC_device_type: 96 return "device_type"; 97 case OMPC_match: 98 return "match"; 99 } 100 llvm_unreachable("Invalid OpenMP clause kind"); 101 } 102 103 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind, 104 StringRef Str) { 105 switch (Kind) { 106 case OMPC_default: 107 return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str) 108 #define OPENMP_DEFAULT_KIND(Name) .Case(#Name, OMPC_DEFAULT_##Name) 109 #include "clang/Basic/OpenMPKinds.def" 110 .Default(OMPC_DEFAULT_unknown); 111 case OMPC_proc_bind: 112 return llvm::StringSwitch<OpenMPProcBindClauseKind>(Str) 113 #define OPENMP_PROC_BIND_KIND(Name) .Case(#Name, OMPC_PROC_BIND_##Name) 114 #include "clang/Basic/OpenMPKinds.def" 115 .Default(OMPC_PROC_BIND_unknown); 116 case OMPC_schedule: 117 return llvm::StringSwitch<unsigned>(Str) 118 #define OPENMP_SCHEDULE_KIND(Name) \ 119 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name)) 120 #define OPENMP_SCHEDULE_MODIFIER(Name) \ 121 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name)) 122 #include "clang/Basic/OpenMPKinds.def" 123 .Default(OMPC_SCHEDULE_unknown); 124 case OMPC_depend: 125 return llvm::StringSwitch<OpenMPDependClauseKind>(Str) 126 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name) 127 #include "clang/Basic/OpenMPKinds.def" 128 .Default(OMPC_DEPEND_unknown); 129 case OMPC_linear: 130 return llvm::StringSwitch<OpenMPLinearClauseKind>(Str) 131 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name) 132 #include "clang/Basic/OpenMPKinds.def" 133 .Default(OMPC_LINEAR_unknown); 134 case OMPC_map: 135 return llvm::StringSwitch<unsigned>(Str) 136 #define OPENMP_MAP_KIND(Name) \ 137 .Case(#Name, static_cast<unsigned>(OMPC_MAP_##Name)) 138 #define OPENMP_MAP_MODIFIER_KIND(Name) \ 139 .Case(#Name, static_cast<unsigned>(OMPC_MAP_MODIFIER_##Name)) 140 #include "clang/Basic/OpenMPKinds.def" 141 .Default(OMPC_MAP_unknown); 142 case OMPC_to: 143 return llvm::StringSwitch<unsigned>(Str) 144 #define OPENMP_TO_MODIFIER_KIND(Name) \ 145 .Case(#Name, static_cast<unsigned>(OMPC_TO_MODIFIER_##Name)) 146 #include "clang/Basic/OpenMPKinds.def" 147 .Default(OMPC_TO_MODIFIER_unknown); 148 case OMPC_from: 149 return llvm::StringSwitch<unsigned>(Str) 150 #define OPENMP_FROM_MODIFIER_KIND(Name) \ 151 .Case(#Name, static_cast<unsigned>(OMPC_FROM_MODIFIER_##Name)) 152 #include "clang/Basic/OpenMPKinds.def" 153 .Default(OMPC_FROM_MODIFIER_unknown); 154 case OMPC_dist_schedule: 155 return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str) 156 #define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name) 157 #include "clang/Basic/OpenMPKinds.def" 158 .Default(OMPC_DIST_SCHEDULE_unknown); 159 case OMPC_defaultmap: 160 return llvm::StringSwitch<unsigned>(Str) 161 #define OPENMP_DEFAULTMAP_KIND(Name) \ 162 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name)) 163 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 164 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name)) 165 #include "clang/Basic/OpenMPKinds.def" 166 .Default(OMPC_DEFAULTMAP_unknown); 167 case OMPC_atomic_default_mem_order: 168 return llvm::StringSwitch<OpenMPAtomicDefaultMemOrderClauseKind>(Str) 169 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \ 170 .Case(#Name, OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name) 171 #include "clang/Basic/OpenMPKinds.def" 172 .Default(OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown); 173 case OMPC_device_type: 174 return llvm::StringSwitch<OpenMPDeviceType>(Str) 175 #define OPENMP_DEVICE_TYPE_KIND(Name) .Case(#Name, OMPC_DEVICE_TYPE_##Name) 176 #include "clang/Basic/OpenMPKinds.def" 177 .Default(OMPC_DEVICE_TYPE_unknown); 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_allocator: 186 case OMPC_allocate: 187 case OMPC_collapse: 188 case OMPC_private: 189 case OMPC_firstprivate: 190 case OMPC_lastprivate: 191 case OMPC_shared: 192 case OMPC_reduction: 193 case OMPC_task_reduction: 194 case OMPC_in_reduction: 195 case OMPC_aligned: 196 case OMPC_copyin: 197 case OMPC_copyprivate: 198 case OMPC_ordered: 199 case OMPC_nowait: 200 case OMPC_untied: 201 case OMPC_mergeable: 202 case OMPC_flush: 203 case OMPC_read: 204 case OMPC_write: 205 case OMPC_update: 206 case OMPC_capture: 207 case OMPC_seq_cst: 208 case OMPC_device: 209 case OMPC_threads: 210 case OMPC_simd: 211 case OMPC_num_teams: 212 case OMPC_thread_limit: 213 case OMPC_priority: 214 case OMPC_grainsize: 215 case OMPC_nogroup: 216 case OMPC_num_tasks: 217 case OMPC_hint: 218 case OMPC_uniform: 219 case OMPC_use_device_ptr: 220 case OMPC_is_device_ptr: 221 case OMPC_unified_address: 222 case OMPC_unified_shared_memory: 223 case OMPC_reverse_offload: 224 case OMPC_dynamic_allocators: 225 case OMPC_match: 226 case OMPC_nontemporal: 227 break; 228 } 229 llvm_unreachable("Invalid OpenMP simple clause kind"); 230 } 231 232 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, 233 unsigned Type) { 234 switch (Kind) { 235 case OMPC_default: 236 switch (Type) { 237 case OMPC_DEFAULT_unknown: 238 return "unknown"; 239 #define OPENMP_DEFAULT_KIND(Name) \ 240 case OMPC_DEFAULT_##Name: \ 241 return #Name; 242 #include "clang/Basic/OpenMPKinds.def" 243 } 244 llvm_unreachable("Invalid OpenMP 'default' clause type"); 245 case OMPC_proc_bind: 246 switch (Type) { 247 case OMPC_PROC_BIND_unknown: 248 return "unknown"; 249 #define OPENMP_PROC_BIND_KIND(Name) \ 250 case OMPC_PROC_BIND_##Name: \ 251 return #Name; 252 #include "clang/Basic/OpenMPKinds.def" 253 } 254 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type"); 255 case OMPC_schedule: 256 switch (Type) { 257 case OMPC_SCHEDULE_unknown: 258 case OMPC_SCHEDULE_MODIFIER_last: 259 return "unknown"; 260 #define OPENMP_SCHEDULE_KIND(Name) \ 261 case OMPC_SCHEDULE_##Name: \ 262 return #Name; 263 #define OPENMP_SCHEDULE_MODIFIER(Name) \ 264 case OMPC_SCHEDULE_MODIFIER_##Name: \ 265 return #Name; 266 #include "clang/Basic/OpenMPKinds.def" 267 } 268 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 269 case OMPC_depend: 270 switch (Type) { 271 case OMPC_DEPEND_unknown: 272 return "unknown"; 273 #define OPENMP_DEPEND_KIND(Name) \ 274 case OMPC_DEPEND_##Name: \ 275 return #Name; 276 #include "clang/Basic/OpenMPKinds.def" 277 } 278 llvm_unreachable("Invalid OpenMP 'depend' clause type"); 279 case OMPC_linear: 280 switch (Type) { 281 case OMPC_LINEAR_unknown: 282 return "unknown"; 283 #define OPENMP_LINEAR_KIND(Name) \ 284 case OMPC_LINEAR_##Name: \ 285 return #Name; 286 #include "clang/Basic/OpenMPKinds.def" 287 } 288 llvm_unreachable("Invalid OpenMP 'linear' clause type"); 289 case OMPC_map: 290 switch (Type) { 291 case OMPC_MAP_unknown: 292 case OMPC_MAP_MODIFIER_last: 293 return "unknown"; 294 #define OPENMP_MAP_KIND(Name) \ 295 case OMPC_MAP_##Name: \ 296 return #Name; 297 #define OPENMP_MAP_MODIFIER_KIND(Name) \ 298 case OMPC_MAP_MODIFIER_##Name: \ 299 return #Name; 300 #include "clang/Basic/OpenMPKinds.def" 301 default: 302 break; 303 } 304 llvm_unreachable("Invalid OpenMP 'map' clause type"); 305 case OMPC_to: 306 switch (Type) { 307 case OMPC_TO_MODIFIER_unknown: 308 return "unknown"; 309 #define OPENMP_TO_MODIFIER_KIND(Name) \ 310 case OMPC_TO_MODIFIER_##Name: \ 311 return #Name; 312 #include "clang/Basic/OpenMPKinds.def" 313 default: 314 break; 315 } 316 llvm_unreachable("Invalid OpenMP 'to' clause type"); 317 case OMPC_from: 318 switch (Type) { 319 case OMPC_FROM_MODIFIER_unknown: 320 return "unknown"; 321 #define OPENMP_FROM_MODIFIER_KIND(Name) \ 322 case OMPC_FROM_MODIFIER_##Name: \ 323 return #Name; 324 #include "clang/Basic/OpenMPKinds.def" 325 default: 326 break; 327 } 328 llvm_unreachable("Invalid OpenMP 'from' clause type"); 329 case OMPC_dist_schedule: 330 switch (Type) { 331 case OMPC_DIST_SCHEDULE_unknown: 332 return "unknown"; 333 #define OPENMP_DIST_SCHEDULE_KIND(Name) \ 334 case OMPC_DIST_SCHEDULE_##Name: \ 335 return #Name; 336 #include "clang/Basic/OpenMPKinds.def" 337 } 338 llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type"); 339 case OMPC_defaultmap: 340 switch (Type) { 341 case OMPC_DEFAULTMAP_unknown: 342 case OMPC_DEFAULTMAP_MODIFIER_last: 343 return "unknown"; 344 #define OPENMP_DEFAULTMAP_KIND(Name) \ 345 case OMPC_DEFAULTMAP_##Name: \ 346 return #Name; 347 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 348 case OMPC_DEFAULTMAP_MODIFIER_##Name: \ 349 return #Name; 350 #include "clang/Basic/OpenMPKinds.def" 351 } 352 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 353 case OMPC_atomic_default_mem_order: 354 switch (Type) { 355 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown: 356 return "unknown"; 357 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \ 358 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name: \ 359 return #Name; 360 #include "clang/Basic/OpenMPKinds.def" 361 } 362 llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type"); 363 case OMPC_device_type: 364 switch (Type) { 365 case OMPC_DEVICE_TYPE_unknown: 366 return "unknown"; 367 #define OPENMP_DEVICE_TYPE_KIND(Name) \ 368 case OMPC_DEVICE_TYPE_##Name: \ 369 return #Name; 370 #include "clang/Basic/OpenMPKinds.def" 371 } 372 llvm_unreachable("Invalid OpenMP 'device_type' clause type"); 373 case OMPC_unknown: 374 case OMPC_threadprivate: 375 case OMPC_if: 376 case OMPC_final: 377 case OMPC_num_threads: 378 case OMPC_safelen: 379 case OMPC_simdlen: 380 case OMPC_allocator: 381 case OMPC_allocate: 382 case OMPC_collapse: 383 case OMPC_private: 384 case OMPC_firstprivate: 385 case OMPC_lastprivate: 386 case OMPC_shared: 387 case OMPC_reduction: 388 case OMPC_task_reduction: 389 case OMPC_in_reduction: 390 case OMPC_aligned: 391 case OMPC_copyin: 392 case OMPC_copyprivate: 393 case OMPC_ordered: 394 case OMPC_nowait: 395 case OMPC_untied: 396 case OMPC_mergeable: 397 case OMPC_flush: 398 case OMPC_read: 399 case OMPC_write: 400 case OMPC_update: 401 case OMPC_capture: 402 case OMPC_seq_cst: 403 case OMPC_device: 404 case OMPC_threads: 405 case OMPC_simd: 406 case OMPC_num_teams: 407 case OMPC_thread_limit: 408 case OMPC_priority: 409 case OMPC_grainsize: 410 case OMPC_nogroup: 411 case OMPC_num_tasks: 412 case OMPC_hint: 413 case OMPC_uniform: 414 case OMPC_use_device_ptr: 415 case OMPC_is_device_ptr: 416 case OMPC_unified_address: 417 case OMPC_unified_shared_memory: 418 case OMPC_reverse_offload: 419 case OMPC_dynamic_allocators: 420 case OMPC_match: 421 case OMPC_nontemporal: 422 break; 423 } 424 llvm_unreachable("Invalid OpenMP simple clause kind"); 425 } 426 427 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind, 428 OpenMPClauseKind CKind, 429 unsigned OpenMPVersion) { 430 assert(unsigned(DKind) <= unsigned(OMPD_unknown)); 431 assert(CKind <= OMPC_unknown); 432 // Nontemporal clause is not supported in OpenMP < 5.0. 433 if (OpenMPVersion < 50 && CKind == OMPC_nontemporal) 434 return false; 435 switch (DKind) { 436 case OMPD_parallel: 437 switch (CKind) { 438 #define OPENMP_PARALLEL_CLAUSE(Name) \ 439 case OMPC_##Name: \ 440 return true; 441 #include "clang/Basic/OpenMPKinds.def" 442 default: 443 break; 444 } 445 break; 446 case OMPD_simd: 447 if (OpenMPVersion < 50 && CKind == OMPC_if) 448 return false; 449 switch (CKind) { 450 #define OPENMP_SIMD_CLAUSE(Name) \ 451 case OMPC_##Name: \ 452 return true; 453 #include "clang/Basic/OpenMPKinds.def" 454 default: 455 break; 456 } 457 break; 458 case OMPD_for: 459 switch (CKind) { 460 #define OPENMP_FOR_CLAUSE(Name) \ 461 case OMPC_##Name: \ 462 return true; 463 #include "clang/Basic/OpenMPKinds.def" 464 default: 465 break; 466 } 467 break; 468 case OMPD_for_simd: 469 if (OpenMPVersion < 50 && CKind == OMPC_if) 470 return false; 471 switch (CKind) { 472 #define OPENMP_FOR_SIMD_CLAUSE(Name) \ 473 case OMPC_##Name: \ 474 return true; 475 #include "clang/Basic/OpenMPKinds.def" 476 default: 477 break; 478 } 479 break; 480 case OMPD_sections: 481 switch (CKind) { 482 #define OPENMP_SECTIONS_CLAUSE(Name) \ 483 case OMPC_##Name: \ 484 return true; 485 #include "clang/Basic/OpenMPKinds.def" 486 default: 487 break; 488 } 489 break; 490 case OMPD_single: 491 switch (CKind) { 492 #define OPENMP_SINGLE_CLAUSE(Name) \ 493 case OMPC_##Name: \ 494 return true; 495 #include "clang/Basic/OpenMPKinds.def" 496 default: 497 break; 498 } 499 break; 500 case OMPD_parallel_for: 501 switch (CKind) { 502 #define OPENMP_PARALLEL_FOR_CLAUSE(Name) \ 503 case OMPC_##Name: \ 504 return true; 505 #include "clang/Basic/OpenMPKinds.def" 506 default: 507 break; 508 } 509 break; 510 case OMPD_parallel_for_simd: 511 switch (CKind) { 512 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 513 case OMPC_##Name: \ 514 return true; 515 #include "clang/Basic/OpenMPKinds.def" 516 default: 517 break; 518 } 519 break; 520 case OMPD_parallel_master: 521 switch (CKind) { 522 #define OPENMP_PARALLEL_MASTER_CLAUSE(Name) \ 523 case OMPC_##Name: \ 524 return true; 525 #include "clang/Basic/OpenMPKinds.def" 526 default: 527 break; 528 } 529 break; 530 case OMPD_parallel_sections: 531 switch (CKind) { 532 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) \ 533 case OMPC_##Name: \ 534 return true; 535 #include "clang/Basic/OpenMPKinds.def" 536 default: 537 break; 538 } 539 break; 540 case OMPD_task: 541 switch (CKind) { 542 #define OPENMP_TASK_CLAUSE(Name) \ 543 case OMPC_##Name: \ 544 return true; 545 #include "clang/Basic/OpenMPKinds.def" 546 default: 547 break; 548 } 549 break; 550 case OMPD_flush: 551 return CKind == OMPC_flush; 552 break; 553 case OMPD_atomic: 554 switch (CKind) { 555 #define OPENMP_ATOMIC_CLAUSE(Name) \ 556 case OMPC_##Name: \ 557 return true; 558 #include "clang/Basic/OpenMPKinds.def" 559 default: 560 break; 561 } 562 break; 563 case OMPD_target: 564 switch (CKind) { 565 #define OPENMP_TARGET_CLAUSE(Name) \ 566 case OMPC_##Name: \ 567 return true; 568 #include "clang/Basic/OpenMPKinds.def" 569 default: 570 break; 571 } 572 break; 573 case OMPD_requires: 574 switch (CKind) { 575 #define OPENMP_REQUIRES_CLAUSE(Name) \ 576 case OMPC_##Name: \ 577 return true; 578 #include "clang/Basic/OpenMPKinds.def" 579 default: 580 break; 581 } 582 break; 583 case OMPD_target_data: 584 switch (CKind) { 585 #define OPENMP_TARGET_DATA_CLAUSE(Name) \ 586 case OMPC_##Name: \ 587 return true; 588 #include "clang/Basic/OpenMPKinds.def" 589 default: 590 break; 591 } 592 break; 593 case OMPD_target_enter_data: 594 switch (CKind) { 595 #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name) \ 596 case OMPC_##Name: \ 597 return true; 598 #include "clang/Basic/OpenMPKinds.def" 599 default: 600 break; 601 } 602 break; 603 case OMPD_target_exit_data: 604 switch (CKind) { 605 #define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name) \ 606 case OMPC_##Name: \ 607 return true; 608 #include "clang/Basic/OpenMPKinds.def" 609 default: 610 break; 611 } 612 break; 613 case OMPD_target_parallel: 614 switch (CKind) { 615 #define OPENMP_TARGET_PARALLEL_CLAUSE(Name) \ 616 case OMPC_##Name: \ 617 return true; 618 #include "clang/Basic/OpenMPKinds.def" 619 default: 620 break; 621 } 622 break; 623 case OMPD_target_parallel_for: 624 switch (CKind) { 625 #define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name) \ 626 case OMPC_##Name: \ 627 return true; 628 #include "clang/Basic/OpenMPKinds.def" 629 default: 630 break; 631 } 632 break; 633 case OMPD_target_update: 634 switch (CKind) { 635 #define OPENMP_TARGET_UPDATE_CLAUSE(Name) \ 636 case OMPC_##Name: \ 637 return true; 638 #include "clang/Basic/OpenMPKinds.def" 639 default: 640 break; 641 } 642 break; 643 case OMPD_teams: 644 switch (CKind) { 645 #define OPENMP_TEAMS_CLAUSE(Name) \ 646 case OMPC_##Name: \ 647 return true; 648 #include "clang/Basic/OpenMPKinds.def" 649 default: 650 break; 651 } 652 break; 653 case OMPD_cancel: 654 switch (CKind) { 655 #define OPENMP_CANCEL_CLAUSE(Name) \ 656 case OMPC_##Name: \ 657 return true; 658 #include "clang/Basic/OpenMPKinds.def" 659 default: 660 break; 661 } 662 break; 663 case OMPD_ordered: 664 switch (CKind) { 665 #define OPENMP_ORDERED_CLAUSE(Name) \ 666 case OMPC_##Name: \ 667 return true; 668 #include "clang/Basic/OpenMPKinds.def" 669 default: 670 break; 671 } 672 break; 673 case OMPD_taskloop: 674 switch (CKind) { 675 #define OPENMP_TASKLOOP_CLAUSE(Name) \ 676 case OMPC_##Name: \ 677 return true; 678 #include "clang/Basic/OpenMPKinds.def" 679 default: 680 break; 681 } 682 break; 683 case OMPD_taskloop_simd: 684 switch (CKind) { 685 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name) \ 686 case OMPC_##Name: \ 687 return true; 688 #include "clang/Basic/OpenMPKinds.def" 689 default: 690 break; 691 } 692 break; 693 case OMPD_master_taskloop: 694 switch (CKind) { 695 #define OPENMP_MASTER_TASKLOOP_CLAUSE(Name) \ 696 case OMPC_##Name: \ 697 return true; 698 #include "clang/Basic/OpenMPKinds.def" 699 default: 700 break; 701 } 702 break; 703 case OMPD_master_taskloop_simd: 704 switch (CKind) { 705 #define OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(Name) \ 706 case OMPC_##Name: \ 707 return true; 708 #include "clang/Basic/OpenMPKinds.def" 709 default: 710 break; 711 } 712 break; 713 case OMPD_parallel_master_taskloop: 714 switch (CKind) { 715 #define OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(Name) \ 716 case OMPC_##Name: \ 717 return true; 718 #include "clang/Basic/OpenMPKinds.def" 719 default: 720 break; 721 } 722 break; 723 case OMPD_parallel_master_taskloop_simd: 724 switch (CKind) { 725 #define OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(Name) \ 726 case OMPC_##Name: \ 727 return true; 728 #include "clang/Basic/OpenMPKinds.def" 729 default: 730 break; 731 } 732 break; 733 case OMPD_critical: 734 switch (CKind) { 735 #define OPENMP_CRITICAL_CLAUSE(Name) \ 736 case OMPC_##Name: \ 737 return true; 738 #include "clang/Basic/OpenMPKinds.def" 739 default: 740 break; 741 } 742 break; 743 case OMPD_distribute: 744 switch (CKind) { 745 #define OPENMP_DISTRIBUTE_CLAUSE(Name) \ 746 case OMPC_##Name: \ 747 return true; 748 #include "clang/Basic/OpenMPKinds.def" 749 default: 750 break; 751 } 752 break; 753 case OMPD_distribute_parallel_for: 754 switch (CKind) { 755 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 756 case OMPC_##Name: \ 757 return true; 758 #include "clang/Basic/OpenMPKinds.def" 759 default: 760 break; 761 } 762 break; 763 case OMPD_distribute_parallel_for_simd: 764 switch (CKind) { 765 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 766 case OMPC_##Name: \ 767 return true; 768 #include "clang/Basic/OpenMPKinds.def" 769 default: 770 break; 771 } 772 break; 773 case OMPD_distribute_simd: 774 if (OpenMPVersion < 50 && CKind == OMPC_if) 775 return false; 776 switch (CKind) { 777 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) \ 778 case OMPC_##Name: \ 779 return true; 780 #include "clang/Basic/OpenMPKinds.def" 781 default: 782 break; 783 } 784 break; 785 case OMPD_target_parallel_for_simd: 786 switch (CKind) { 787 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 788 case OMPC_##Name: \ 789 return true; 790 #include "clang/Basic/OpenMPKinds.def" 791 default: 792 break; 793 } 794 break; 795 case OMPD_target_simd: 796 switch (CKind) { 797 #define OPENMP_TARGET_SIMD_CLAUSE(Name) \ 798 case OMPC_##Name: \ 799 return true; 800 #include "clang/Basic/OpenMPKinds.def" 801 default: 802 break; 803 } 804 break; 805 case OMPD_teams_distribute: 806 switch (CKind) { 807 #define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name) \ 808 case OMPC_##Name: \ 809 return true; 810 #include "clang/Basic/OpenMPKinds.def" 811 default: 812 break; 813 } 814 break; 815 case OMPD_teams_distribute_simd: 816 if (OpenMPVersion < 50 && CKind == OMPC_if) 817 return false; 818 switch (CKind) { 819 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \ 820 case OMPC_##Name: \ 821 return true; 822 #include "clang/Basic/OpenMPKinds.def" 823 default: 824 break; 825 } 826 break; 827 case OMPD_teams_distribute_parallel_for_simd: 828 switch (CKind) { 829 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 830 case OMPC_##Name: \ 831 return true; 832 #include "clang/Basic/OpenMPKinds.def" 833 default: 834 break; 835 } 836 break; 837 case OMPD_teams_distribute_parallel_for: 838 switch (CKind) { 839 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 840 case OMPC_##Name: \ 841 return true; 842 #include "clang/Basic/OpenMPKinds.def" 843 default: 844 break; 845 } 846 break; 847 case OMPD_target_teams: 848 switch (CKind) { 849 #define OPENMP_TARGET_TEAMS_CLAUSE(Name) \ 850 case OMPC_##Name: \ 851 return true; 852 #include "clang/Basic/OpenMPKinds.def" 853 default: 854 break; 855 } 856 break; 857 case OMPD_target_teams_distribute: 858 switch (CKind) { 859 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name) \ 860 case OMPC_##Name: \ 861 return true; 862 #include "clang/Basic/OpenMPKinds.def" 863 default: 864 break; 865 } 866 break; 867 case OMPD_target_teams_distribute_parallel_for: 868 switch (CKind) { 869 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 870 case OMPC_##Name: \ 871 return true; 872 #include "clang/Basic/OpenMPKinds.def" 873 default: 874 break; 875 } 876 break; 877 case OMPD_target_teams_distribute_parallel_for_simd: 878 switch (CKind) { 879 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 880 case OMPC_##Name: \ 881 return true; 882 #include "clang/Basic/OpenMPKinds.def" 883 default: 884 break; 885 } 886 break; 887 case OMPD_target_teams_distribute_simd: 888 switch (CKind) { 889 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \ 890 case OMPC_##Name: \ 891 return true; 892 #include "clang/Basic/OpenMPKinds.def" 893 default: 894 break; 895 } 896 break; 897 case OMPD_taskgroup: 898 switch (CKind) { 899 #define OPENMP_TASKGROUP_CLAUSE(Name) \ 900 case OMPC_##Name: \ 901 return true; 902 #include "clang/Basic/OpenMPKinds.def" 903 default: 904 break; 905 } 906 break; 907 case OMPD_declare_mapper: 908 switch (CKind) { 909 #define OPENMP_DECLARE_MAPPER_CLAUSE(Name) \ 910 case OMPC_##Name: \ 911 return true; 912 #include "clang/Basic/OpenMPKinds.def" 913 default: 914 break; 915 } 916 break; 917 case OMPD_allocate: 918 switch (CKind) { 919 #define OPENMP_ALLOCATE_CLAUSE(Name) \ 920 case OMPC_##Name: \ 921 return true; 922 #include "clang/Basic/OpenMPKinds.def" 923 default: 924 break; 925 } 926 break; 927 case OMPD_declare_variant: 928 switch (CKind) { 929 #define OPENMP_DECLARE_VARIANT_CLAUSE(Name) \ 930 case OMPC_##Name: \ 931 return true; 932 #include "clang/Basic/OpenMPKinds.def" 933 default: 934 break; 935 } 936 break; 937 case OMPD_declare_target: 938 case OMPD_end_declare_target: 939 case OMPD_unknown: 940 case OMPD_threadprivate: 941 case OMPD_section: 942 case OMPD_master: 943 case OMPD_taskyield: 944 case OMPD_barrier: 945 case OMPD_taskwait: 946 case OMPD_cancellation_point: 947 case OMPD_declare_reduction: 948 case OMPD_declare_simd: 949 break; 950 } 951 return false; 952 } 953 954 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) { 955 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd || 956 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd || 957 DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 958 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 959 DKind == OMPD_parallel_master_taskloop || 960 DKind == OMPD_parallel_master_taskloop_simd || 961 DKind == OMPD_distribute || DKind == OMPD_target_parallel_for || 962 DKind == OMPD_distribute_parallel_for || 963 DKind == OMPD_distribute_parallel_for_simd || 964 DKind == OMPD_distribute_simd || 965 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 966 DKind == OMPD_teams_distribute || 967 DKind == OMPD_teams_distribute_simd || 968 DKind == OMPD_teams_distribute_parallel_for_simd || 969 DKind == OMPD_teams_distribute_parallel_for || 970 DKind == OMPD_target_teams_distribute || 971 DKind == OMPD_target_teams_distribute_parallel_for || 972 DKind == OMPD_target_teams_distribute_parallel_for_simd || 973 DKind == OMPD_target_teams_distribute_simd; 974 } 975 976 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { 977 return DKind == OMPD_for || DKind == OMPD_for_simd || 978 DKind == OMPD_sections || DKind == OMPD_section || 979 DKind == OMPD_single || DKind == OMPD_parallel_for || 980 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 981 DKind == OMPD_target_parallel_for || 982 DKind == OMPD_distribute_parallel_for || 983 DKind == OMPD_distribute_parallel_for_simd || 984 DKind == OMPD_target_parallel_for_simd || 985 DKind == OMPD_teams_distribute_parallel_for_simd || 986 DKind == OMPD_teams_distribute_parallel_for || 987 DKind == OMPD_target_teams_distribute_parallel_for || 988 DKind == OMPD_target_teams_distribute_parallel_for_simd; 989 } 990 991 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) { 992 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 993 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 994 DKind == OMPD_parallel_master_taskloop || 995 DKind == OMPD_parallel_master_taskloop_simd; 996 } 997 998 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) { 999 return DKind == OMPD_parallel || DKind == OMPD_parallel_for || 1000 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 1001 DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for || 1002 DKind == OMPD_distribute_parallel_for || 1003 DKind == OMPD_distribute_parallel_for_simd || 1004 DKind == OMPD_target_parallel_for_simd || 1005 DKind == OMPD_teams_distribute_parallel_for || 1006 DKind == OMPD_teams_distribute_parallel_for_simd || 1007 DKind == OMPD_target_teams_distribute_parallel_for || 1008 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1009 DKind == OMPD_parallel_master || 1010 DKind == OMPD_parallel_master_taskloop || 1011 DKind == OMPD_parallel_master_taskloop_simd; 1012 } 1013 1014 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) { 1015 return DKind == OMPD_target || DKind == OMPD_target_parallel || 1016 DKind == OMPD_target_parallel_for || 1017 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 1018 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 1019 DKind == OMPD_target_teams_distribute_parallel_for || 1020 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1021 DKind == OMPD_target_teams_distribute_simd; 1022 } 1023 1024 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) { 1025 return DKind == OMPD_target_data || DKind == OMPD_target_enter_data || 1026 DKind == OMPD_target_exit_data || DKind == OMPD_target_update; 1027 } 1028 1029 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) { 1030 return DKind == OMPD_teams || DKind == OMPD_teams_distribute || 1031 DKind == OMPD_teams_distribute_simd || 1032 DKind == OMPD_teams_distribute_parallel_for_simd || 1033 DKind == OMPD_teams_distribute_parallel_for; 1034 } 1035 1036 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) { 1037 return isOpenMPNestingTeamsDirective(DKind) || 1038 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 1039 DKind == OMPD_target_teams_distribute_parallel_for || 1040 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1041 DKind == OMPD_target_teams_distribute_simd; 1042 } 1043 1044 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) { 1045 return DKind == OMPD_simd || DKind == OMPD_for_simd || 1046 DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd || 1047 DKind == OMPD_master_taskloop_simd || 1048 DKind == OMPD_parallel_master_taskloop_simd || 1049 DKind == OMPD_distribute_parallel_for_simd || 1050 DKind == OMPD_distribute_simd || DKind == OMPD_target_simd || 1051 DKind == OMPD_teams_distribute_simd || 1052 DKind == OMPD_teams_distribute_parallel_for_simd || 1053 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1054 DKind == OMPD_target_teams_distribute_simd || 1055 DKind == OMPD_target_parallel_for_simd; 1056 } 1057 1058 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) { 1059 return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for || 1060 Kind == OMPD_distribute_parallel_for_simd || 1061 Kind == OMPD_distribute_simd; 1062 // TODO add next directives. 1063 } 1064 1065 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) { 1066 return isOpenMPNestingDistributeDirective(Kind) || 1067 Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd || 1068 Kind == OMPD_teams_distribute_parallel_for_simd || 1069 Kind == OMPD_teams_distribute_parallel_for || 1070 Kind == OMPD_target_teams_distribute || 1071 Kind == OMPD_target_teams_distribute_parallel_for || 1072 Kind == OMPD_target_teams_distribute_parallel_for_simd || 1073 Kind == OMPD_target_teams_distribute_simd; 1074 } 1075 1076 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) { 1077 return Kind == OMPC_private || Kind == OMPC_firstprivate || 1078 Kind == OMPC_lastprivate || Kind == OMPC_linear || 1079 Kind == OMPC_reduction || Kind == OMPC_task_reduction || 1080 Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'. 1081 } 1082 1083 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) { 1084 return Kind == OMPC_threadprivate || Kind == OMPC_copyin; 1085 } 1086 1087 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) { 1088 return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind); 1089 } 1090 1091 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) { 1092 return Kind == OMPD_distribute_parallel_for || 1093 Kind == OMPD_distribute_parallel_for_simd || 1094 Kind == OMPD_teams_distribute_parallel_for_simd || 1095 Kind == OMPD_teams_distribute_parallel_for || 1096 Kind == OMPD_target_teams_distribute_parallel_for || 1097 Kind == OMPD_target_teams_distribute_parallel_for_simd; 1098 } 1099 1100 void clang::getOpenMPCaptureRegions( 1101 SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions, 1102 OpenMPDirectiveKind DKind) { 1103 assert(DKind <= OMPD_unknown); 1104 switch (DKind) { 1105 case OMPD_parallel: 1106 case OMPD_parallel_for: 1107 case OMPD_parallel_for_simd: 1108 case OMPD_parallel_master: 1109 case OMPD_parallel_sections: 1110 case OMPD_distribute_parallel_for: 1111 case OMPD_distribute_parallel_for_simd: 1112 CaptureRegions.push_back(OMPD_parallel); 1113 break; 1114 case OMPD_target_teams: 1115 case OMPD_target_teams_distribute: 1116 case OMPD_target_teams_distribute_simd: 1117 CaptureRegions.push_back(OMPD_task); 1118 CaptureRegions.push_back(OMPD_target); 1119 CaptureRegions.push_back(OMPD_teams); 1120 break; 1121 case OMPD_teams: 1122 case OMPD_teams_distribute: 1123 case OMPD_teams_distribute_simd: 1124 CaptureRegions.push_back(OMPD_teams); 1125 break; 1126 case OMPD_target: 1127 case OMPD_target_simd: 1128 CaptureRegions.push_back(OMPD_task); 1129 CaptureRegions.push_back(OMPD_target); 1130 break; 1131 case OMPD_teams_distribute_parallel_for: 1132 case OMPD_teams_distribute_parallel_for_simd: 1133 CaptureRegions.push_back(OMPD_teams); 1134 CaptureRegions.push_back(OMPD_parallel); 1135 break; 1136 case OMPD_target_parallel: 1137 case OMPD_target_parallel_for: 1138 case OMPD_target_parallel_for_simd: 1139 CaptureRegions.push_back(OMPD_task); 1140 CaptureRegions.push_back(OMPD_target); 1141 CaptureRegions.push_back(OMPD_parallel); 1142 break; 1143 case OMPD_task: 1144 case OMPD_target_enter_data: 1145 case OMPD_target_exit_data: 1146 case OMPD_target_update: 1147 CaptureRegions.push_back(OMPD_task); 1148 break; 1149 case OMPD_taskloop: 1150 case OMPD_taskloop_simd: 1151 case OMPD_master_taskloop: 1152 case OMPD_master_taskloop_simd: 1153 CaptureRegions.push_back(OMPD_taskloop); 1154 break; 1155 case OMPD_parallel_master_taskloop: 1156 case OMPD_parallel_master_taskloop_simd: 1157 CaptureRegions.push_back(OMPD_parallel); 1158 CaptureRegions.push_back(OMPD_taskloop); 1159 break; 1160 case OMPD_target_teams_distribute_parallel_for: 1161 case OMPD_target_teams_distribute_parallel_for_simd: 1162 CaptureRegions.push_back(OMPD_task); 1163 CaptureRegions.push_back(OMPD_target); 1164 CaptureRegions.push_back(OMPD_teams); 1165 CaptureRegions.push_back(OMPD_parallel); 1166 break; 1167 case OMPD_simd: 1168 case OMPD_for: 1169 case OMPD_for_simd: 1170 case OMPD_sections: 1171 case OMPD_section: 1172 case OMPD_single: 1173 case OMPD_master: 1174 case OMPD_critical: 1175 case OMPD_taskgroup: 1176 case OMPD_distribute: 1177 case OMPD_ordered: 1178 case OMPD_atomic: 1179 case OMPD_target_data: 1180 case OMPD_distribute_simd: 1181 CaptureRegions.push_back(OMPD_unknown); 1182 break; 1183 case OMPD_threadprivate: 1184 case OMPD_allocate: 1185 case OMPD_taskyield: 1186 case OMPD_barrier: 1187 case OMPD_taskwait: 1188 case OMPD_cancellation_point: 1189 case OMPD_cancel: 1190 case OMPD_flush: 1191 case OMPD_declare_reduction: 1192 case OMPD_declare_mapper: 1193 case OMPD_declare_simd: 1194 case OMPD_declare_target: 1195 case OMPD_end_declare_target: 1196 case OMPD_requires: 1197 case OMPD_declare_variant: 1198 llvm_unreachable("OpenMP Directive is not allowed"); 1199 case OMPD_unknown: 1200 llvm_unreachable("Unknown OpenMP directive"); 1201 } 1202 } 1203