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