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 /// \brief 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<OpenMPMapClauseKind>(Str) 112 #define OPENMP_MAP_KIND(Name) .Case(#Name, OMPC_MAP_##Name) 113 #include "clang/Basic/OpenMPKinds.def" 114 .Default(OMPC_MAP_unknown); 115 case OMPC_dist_schedule: 116 return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str) 117 #define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name) 118 #include "clang/Basic/OpenMPKinds.def" 119 .Default(OMPC_DIST_SCHEDULE_unknown); 120 case OMPC_defaultmap: 121 return llvm::StringSwitch<unsigned>(Str) 122 #define OPENMP_DEFAULTMAP_KIND(Name) \ 123 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name)) 124 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 125 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name)) 126 #include "clang/Basic/OpenMPKinds.def" 127 .Default(OMPC_DEFAULTMAP_unknown); 128 case OMPC_unknown: 129 case OMPC_threadprivate: 130 case OMPC_if: 131 case OMPC_final: 132 case OMPC_num_threads: 133 case OMPC_safelen: 134 case OMPC_simdlen: 135 case OMPC_collapse: 136 case OMPC_private: 137 case OMPC_firstprivate: 138 case OMPC_lastprivate: 139 case OMPC_shared: 140 case OMPC_reduction: 141 case OMPC_task_reduction: 142 case OMPC_aligned: 143 case OMPC_copyin: 144 case OMPC_copyprivate: 145 case OMPC_ordered: 146 case OMPC_nowait: 147 case OMPC_untied: 148 case OMPC_mergeable: 149 case OMPC_flush: 150 case OMPC_read: 151 case OMPC_write: 152 case OMPC_update: 153 case OMPC_capture: 154 case OMPC_seq_cst: 155 case OMPC_device: 156 case OMPC_threads: 157 case OMPC_simd: 158 case OMPC_num_teams: 159 case OMPC_thread_limit: 160 case OMPC_priority: 161 case OMPC_grainsize: 162 case OMPC_nogroup: 163 case OMPC_num_tasks: 164 case OMPC_hint: 165 case OMPC_uniform: 166 case OMPC_to: 167 case OMPC_from: 168 case OMPC_use_device_ptr: 169 case OMPC_is_device_ptr: 170 break; 171 } 172 llvm_unreachable("Invalid OpenMP simple clause kind"); 173 } 174 175 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, 176 unsigned Type) { 177 switch (Kind) { 178 case OMPC_default: 179 switch (Type) { 180 case OMPC_DEFAULT_unknown: 181 return "unknown"; 182 #define OPENMP_DEFAULT_KIND(Name) \ 183 case OMPC_DEFAULT_##Name: \ 184 return #Name; 185 #include "clang/Basic/OpenMPKinds.def" 186 } 187 llvm_unreachable("Invalid OpenMP 'default' clause type"); 188 case OMPC_proc_bind: 189 switch (Type) { 190 case OMPC_PROC_BIND_unknown: 191 return "unknown"; 192 #define OPENMP_PROC_BIND_KIND(Name) \ 193 case OMPC_PROC_BIND_##Name: \ 194 return #Name; 195 #include "clang/Basic/OpenMPKinds.def" 196 } 197 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type"); 198 case OMPC_schedule: 199 switch (Type) { 200 case OMPC_SCHEDULE_unknown: 201 case OMPC_SCHEDULE_MODIFIER_last: 202 return "unknown"; 203 #define OPENMP_SCHEDULE_KIND(Name) \ 204 case OMPC_SCHEDULE_##Name: \ 205 return #Name; 206 #define OPENMP_SCHEDULE_MODIFIER(Name) \ 207 case OMPC_SCHEDULE_MODIFIER_##Name: \ 208 return #Name; 209 #include "clang/Basic/OpenMPKinds.def" 210 } 211 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 212 case OMPC_depend: 213 switch (Type) { 214 case OMPC_DEPEND_unknown: 215 return "unknown"; 216 #define OPENMP_DEPEND_KIND(Name) \ 217 case OMPC_DEPEND_##Name: \ 218 return #Name; 219 #include "clang/Basic/OpenMPKinds.def" 220 } 221 llvm_unreachable("Invalid OpenMP 'depend' clause type"); 222 case OMPC_linear: 223 switch (Type) { 224 case OMPC_LINEAR_unknown: 225 return "unknown"; 226 #define OPENMP_LINEAR_KIND(Name) \ 227 case OMPC_LINEAR_##Name: \ 228 return #Name; 229 #include "clang/Basic/OpenMPKinds.def" 230 } 231 llvm_unreachable("Invalid OpenMP 'linear' clause type"); 232 case OMPC_map: 233 switch (Type) { 234 case OMPC_MAP_unknown: 235 return "unknown"; 236 #define OPENMP_MAP_KIND(Name) \ 237 case OMPC_MAP_##Name: \ 238 return #Name; 239 #include "clang/Basic/OpenMPKinds.def" 240 default: 241 break; 242 } 243 llvm_unreachable("Invalid OpenMP 'map' clause type"); 244 case OMPC_dist_schedule: 245 switch (Type) { 246 case OMPC_DIST_SCHEDULE_unknown: 247 return "unknown"; 248 #define OPENMP_DIST_SCHEDULE_KIND(Name) \ 249 case OMPC_DIST_SCHEDULE_##Name: \ 250 return #Name; 251 #include "clang/Basic/OpenMPKinds.def" 252 } 253 llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type"); 254 case OMPC_defaultmap: 255 switch (Type) { 256 case OMPC_DEFAULTMAP_unknown: 257 case OMPC_DEFAULTMAP_MODIFIER_last: 258 return "unknown"; 259 #define OPENMP_DEFAULTMAP_KIND(Name) \ 260 case OMPC_DEFAULTMAP_##Name: \ 261 return #Name; 262 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 263 case OMPC_DEFAULTMAP_MODIFIER_##Name: \ 264 return #Name; 265 #include "clang/Basic/OpenMPKinds.def" 266 } 267 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 268 case OMPC_unknown: 269 case OMPC_threadprivate: 270 case OMPC_if: 271 case OMPC_final: 272 case OMPC_num_threads: 273 case OMPC_safelen: 274 case OMPC_simdlen: 275 case OMPC_collapse: 276 case OMPC_private: 277 case OMPC_firstprivate: 278 case OMPC_lastprivate: 279 case OMPC_shared: 280 case OMPC_reduction: 281 case OMPC_task_reduction: 282 case OMPC_aligned: 283 case OMPC_copyin: 284 case OMPC_copyprivate: 285 case OMPC_ordered: 286 case OMPC_nowait: 287 case OMPC_untied: 288 case OMPC_mergeable: 289 case OMPC_flush: 290 case OMPC_read: 291 case OMPC_write: 292 case OMPC_update: 293 case OMPC_capture: 294 case OMPC_seq_cst: 295 case OMPC_device: 296 case OMPC_threads: 297 case OMPC_simd: 298 case OMPC_num_teams: 299 case OMPC_thread_limit: 300 case OMPC_priority: 301 case OMPC_grainsize: 302 case OMPC_nogroup: 303 case OMPC_num_tasks: 304 case OMPC_hint: 305 case OMPC_uniform: 306 case OMPC_to: 307 case OMPC_from: 308 case OMPC_use_device_ptr: 309 case OMPC_is_device_ptr: 310 break; 311 } 312 llvm_unreachable("Invalid OpenMP simple clause kind"); 313 } 314 315 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind, 316 OpenMPClauseKind CKind) { 317 assert(DKind <= OMPD_unknown); 318 assert(CKind <= OMPC_unknown); 319 switch (DKind) { 320 case OMPD_parallel: 321 switch (CKind) { 322 #define OPENMP_PARALLEL_CLAUSE(Name) \ 323 case OMPC_##Name: \ 324 return true; 325 #include "clang/Basic/OpenMPKinds.def" 326 default: 327 break; 328 } 329 break; 330 case OMPD_simd: 331 switch (CKind) { 332 #define OPENMP_SIMD_CLAUSE(Name) \ 333 case OMPC_##Name: \ 334 return true; 335 #include "clang/Basic/OpenMPKinds.def" 336 default: 337 break; 338 } 339 break; 340 case OMPD_for: 341 switch (CKind) { 342 #define OPENMP_FOR_CLAUSE(Name) \ 343 case OMPC_##Name: \ 344 return true; 345 #include "clang/Basic/OpenMPKinds.def" 346 default: 347 break; 348 } 349 break; 350 case OMPD_for_simd: 351 switch (CKind) { 352 #define OPENMP_FOR_SIMD_CLAUSE(Name) \ 353 case OMPC_##Name: \ 354 return true; 355 #include "clang/Basic/OpenMPKinds.def" 356 default: 357 break; 358 } 359 break; 360 case OMPD_sections: 361 switch (CKind) { 362 #define OPENMP_SECTIONS_CLAUSE(Name) \ 363 case OMPC_##Name: \ 364 return true; 365 #include "clang/Basic/OpenMPKinds.def" 366 default: 367 break; 368 } 369 break; 370 case OMPD_single: 371 switch (CKind) { 372 #define OPENMP_SINGLE_CLAUSE(Name) \ 373 case OMPC_##Name: \ 374 return true; 375 #include "clang/Basic/OpenMPKinds.def" 376 default: 377 break; 378 } 379 break; 380 case OMPD_parallel_for: 381 switch (CKind) { 382 #define OPENMP_PARALLEL_FOR_CLAUSE(Name) \ 383 case OMPC_##Name: \ 384 return true; 385 #include "clang/Basic/OpenMPKinds.def" 386 default: 387 break; 388 } 389 break; 390 case OMPD_parallel_for_simd: 391 switch (CKind) { 392 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 393 case OMPC_##Name: \ 394 return true; 395 #include "clang/Basic/OpenMPKinds.def" 396 default: 397 break; 398 } 399 break; 400 case OMPD_parallel_sections: 401 switch (CKind) { 402 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) \ 403 case OMPC_##Name: \ 404 return true; 405 #include "clang/Basic/OpenMPKinds.def" 406 default: 407 break; 408 } 409 break; 410 case OMPD_task: 411 switch (CKind) { 412 #define OPENMP_TASK_CLAUSE(Name) \ 413 case OMPC_##Name: \ 414 return true; 415 #include "clang/Basic/OpenMPKinds.def" 416 default: 417 break; 418 } 419 break; 420 case OMPD_flush: 421 return CKind == OMPC_flush; 422 break; 423 case OMPD_atomic: 424 switch (CKind) { 425 #define OPENMP_ATOMIC_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_target: 434 switch (CKind) { 435 #define OPENMP_TARGET_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_target_data: 444 switch (CKind) { 445 #define OPENMP_TARGET_DATA_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_target_enter_data: 454 switch (CKind) { 455 #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name) \ 456 case OMPC_##Name: \ 457 return true; 458 #include "clang/Basic/OpenMPKinds.def" 459 default: 460 break; 461 } 462 break; 463 case OMPD_target_exit_data: 464 switch (CKind) { 465 #define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name) \ 466 case OMPC_##Name: \ 467 return true; 468 #include "clang/Basic/OpenMPKinds.def" 469 default: 470 break; 471 } 472 break; 473 case OMPD_target_parallel: 474 switch (CKind) { 475 #define OPENMP_TARGET_PARALLEL_CLAUSE(Name) \ 476 case OMPC_##Name: \ 477 return true; 478 #include "clang/Basic/OpenMPKinds.def" 479 default: 480 break; 481 } 482 break; 483 case OMPD_target_parallel_for: 484 switch (CKind) { 485 #define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name) \ 486 case OMPC_##Name: \ 487 return true; 488 #include "clang/Basic/OpenMPKinds.def" 489 default: 490 break; 491 } 492 break; 493 case OMPD_target_update: 494 switch (CKind) { 495 #define OPENMP_TARGET_UPDATE_CLAUSE(Name) \ 496 case OMPC_##Name: \ 497 return true; 498 #include "clang/Basic/OpenMPKinds.def" 499 default: 500 break; 501 } 502 break; 503 case OMPD_teams: 504 switch (CKind) { 505 #define OPENMP_TEAMS_CLAUSE(Name) \ 506 case OMPC_##Name: \ 507 return true; 508 #include "clang/Basic/OpenMPKinds.def" 509 default: 510 break; 511 } 512 break; 513 case OMPD_declare_simd: 514 break; 515 case OMPD_cancel: 516 switch (CKind) { 517 #define OPENMP_CANCEL_CLAUSE(Name) \ 518 case OMPC_##Name: \ 519 return true; 520 #include "clang/Basic/OpenMPKinds.def" 521 default: 522 break; 523 } 524 break; 525 case OMPD_ordered: 526 switch (CKind) { 527 #define OPENMP_ORDERED_CLAUSE(Name) \ 528 case OMPC_##Name: \ 529 return true; 530 #include "clang/Basic/OpenMPKinds.def" 531 default: 532 break; 533 } 534 break; 535 case OMPD_taskloop: 536 switch (CKind) { 537 #define OPENMP_TASKLOOP_CLAUSE(Name) \ 538 case OMPC_##Name: \ 539 return true; 540 #include "clang/Basic/OpenMPKinds.def" 541 default: 542 break; 543 } 544 break; 545 case OMPD_taskloop_simd: 546 switch (CKind) { 547 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name) \ 548 case OMPC_##Name: \ 549 return true; 550 #include "clang/Basic/OpenMPKinds.def" 551 default: 552 break; 553 } 554 break; 555 case OMPD_critical: 556 switch (CKind) { 557 #define OPENMP_CRITICAL_CLAUSE(Name) \ 558 case OMPC_##Name: \ 559 return true; 560 #include "clang/Basic/OpenMPKinds.def" 561 default: 562 break; 563 } 564 break; 565 case OMPD_distribute: 566 switch (CKind) { 567 #define OPENMP_DISTRIBUTE_CLAUSE(Name) \ 568 case OMPC_##Name: \ 569 return true; 570 #include "clang/Basic/OpenMPKinds.def" 571 default: 572 break; 573 } 574 break; 575 case OMPD_distribute_parallel_for: 576 switch (CKind) { 577 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 578 case OMPC_##Name: \ 579 return true; 580 #include "clang/Basic/OpenMPKinds.def" 581 default: 582 break; 583 } 584 break; 585 case OMPD_distribute_parallel_for_simd: 586 switch (CKind) { 587 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 588 case OMPC_##Name: \ 589 return true; 590 #include "clang/Basic/OpenMPKinds.def" 591 default: 592 break; 593 } 594 break; 595 case OMPD_distribute_simd: 596 switch (CKind) { 597 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) \ 598 case OMPC_##Name: \ 599 return true; 600 #include "clang/Basic/OpenMPKinds.def" 601 default: 602 break; 603 } 604 break; 605 case OMPD_target_parallel_for_simd: 606 switch (CKind) { 607 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 608 case OMPC_##Name: \ 609 return true; 610 #include "clang/Basic/OpenMPKinds.def" 611 default: 612 break; 613 } 614 break; 615 case OMPD_target_simd: 616 switch (CKind) { 617 #define OPENMP_TARGET_SIMD_CLAUSE(Name) \ 618 case OMPC_##Name: \ 619 return true; 620 #include "clang/Basic/OpenMPKinds.def" 621 default: 622 break; 623 } 624 break; 625 case OMPD_teams_distribute: 626 switch (CKind) { 627 #define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name) \ 628 case OMPC_##Name: \ 629 return true; 630 #include "clang/Basic/OpenMPKinds.def" 631 default: 632 break; 633 } 634 break; 635 case OMPD_teams_distribute_simd: 636 switch (CKind) { 637 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \ 638 case OMPC_##Name: \ 639 return true; 640 #include "clang/Basic/OpenMPKinds.def" 641 default: 642 break; 643 } 644 break; 645 case OMPD_teams_distribute_parallel_for_simd: 646 switch (CKind) { 647 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 648 case OMPC_##Name: \ 649 return true; 650 #include "clang/Basic/OpenMPKinds.def" 651 default: 652 break; 653 } 654 break; 655 case OMPD_teams_distribute_parallel_for: 656 switch (CKind) { 657 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 658 case OMPC_##Name: \ 659 return true; 660 #include "clang/Basic/OpenMPKinds.def" 661 default: 662 break; 663 } 664 break; 665 case OMPD_target_teams: 666 switch (CKind) { 667 #define OPENMP_TARGET_TEAMS_CLAUSE(Name) \ 668 case OMPC_##Name: \ 669 return true; 670 #include "clang/Basic/OpenMPKinds.def" 671 default: 672 break; 673 } 674 break; 675 case OMPD_target_teams_distribute: 676 switch (CKind) { 677 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name) \ 678 case OMPC_##Name: \ 679 return true; 680 #include "clang/Basic/OpenMPKinds.def" 681 default: 682 break; 683 } 684 break; 685 case OMPD_target_teams_distribute_parallel_for: 686 switch (CKind) { 687 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 688 case OMPC_##Name: \ 689 return true; 690 #include "clang/Basic/OpenMPKinds.def" 691 default: 692 break; 693 } 694 break; 695 case OMPD_target_teams_distribute_parallel_for_simd: 696 switch (CKind) { 697 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 698 case OMPC_##Name: \ 699 return true; 700 #include "clang/Basic/OpenMPKinds.def" 701 default: 702 break; 703 } 704 break; 705 case OMPD_target_teams_distribute_simd: 706 switch (CKind) { 707 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \ 708 case OMPC_##Name: \ 709 return true; 710 #include "clang/Basic/OpenMPKinds.def" 711 default: 712 break; 713 } 714 break; 715 case OMPD_taskgroup: 716 switch (CKind) { 717 #define OPENMP_TASKGROUP_CLAUSE(Name) \ 718 case OMPC_##Name: \ 719 return true; 720 #include "clang/Basic/OpenMPKinds.def" 721 default: 722 break; 723 } 724 break; 725 case OMPD_declare_target: 726 case OMPD_end_declare_target: 727 case OMPD_unknown: 728 case OMPD_threadprivate: 729 case OMPD_section: 730 case OMPD_master: 731 case OMPD_taskyield: 732 case OMPD_barrier: 733 case OMPD_taskwait: 734 case OMPD_cancellation_point: 735 case OMPD_declare_reduction: 736 break; 737 } 738 return false; 739 } 740 741 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) { 742 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd || 743 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd || 744 DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 745 DKind == OMPD_distribute || DKind == OMPD_target_parallel_for || 746 DKind == OMPD_distribute_parallel_for || 747 DKind == OMPD_distribute_parallel_for_simd || 748 DKind == OMPD_distribute_simd || 749 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 750 DKind == OMPD_teams_distribute || 751 DKind == OMPD_teams_distribute_simd || 752 DKind == OMPD_teams_distribute_parallel_for_simd || 753 DKind == OMPD_teams_distribute_parallel_for || 754 DKind == OMPD_target_teams_distribute || 755 DKind == OMPD_target_teams_distribute_parallel_for || 756 DKind == OMPD_target_teams_distribute_parallel_for_simd || 757 DKind == OMPD_target_teams_distribute_simd; 758 } 759 760 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { 761 return DKind == OMPD_for || DKind == OMPD_for_simd || 762 DKind == OMPD_sections || DKind == OMPD_section || 763 DKind == OMPD_single || DKind == OMPD_parallel_for || 764 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 765 DKind == OMPD_target_parallel_for || 766 DKind == OMPD_distribute_parallel_for || 767 DKind == OMPD_distribute_parallel_for_simd || 768 DKind == OMPD_target_parallel_for_simd || 769 DKind == OMPD_teams_distribute_parallel_for_simd || 770 DKind == OMPD_teams_distribute_parallel_for || 771 DKind == OMPD_target_teams_distribute_parallel_for || 772 DKind == OMPD_target_teams_distribute_parallel_for_simd; 773 } 774 775 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) { 776 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd; 777 } 778 779 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) { 780 return DKind == OMPD_parallel || DKind == OMPD_parallel_for || 781 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 782 DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for || 783 DKind == OMPD_distribute_parallel_for || 784 DKind == OMPD_distribute_parallel_for_simd || 785 DKind == OMPD_target_parallel_for_simd || 786 DKind == OMPD_teams_distribute_parallel_for || 787 DKind == OMPD_teams_distribute_parallel_for_simd || 788 DKind == OMPD_target_teams_distribute_parallel_for || 789 DKind == OMPD_target_teams_distribute_parallel_for_simd; 790 } 791 792 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) { 793 return DKind == OMPD_target || DKind == OMPD_target_parallel || 794 DKind == OMPD_target_parallel_for || 795 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 796 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 797 DKind == OMPD_target_teams_distribute_parallel_for || 798 DKind == OMPD_target_teams_distribute_parallel_for_simd || 799 DKind == OMPD_target_teams_distribute_simd; 800 } 801 802 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) { 803 return DKind == OMPD_target_data || DKind == OMPD_target_enter_data || 804 DKind == OMPD_target_exit_data || DKind == OMPD_target_update; 805 } 806 807 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) { 808 return DKind == OMPD_teams || DKind == OMPD_teams_distribute || 809 DKind == OMPD_teams_distribute_simd || 810 DKind == OMPD_teams_distribute_parallel_for_simd || 811 DKind == OMPD_teams_distribute_parallel_for; 812 } 813 814 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) { 815 return isOpenMPNestingTeamsDirective(DKind) || 816 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 817 DKind == OMPD_target_teams_distribute_parallel_for || 818 DKind == OMPD_target_teams_distribute_parallel_for_simd || 819 DKind == OMPD_target_teams_distribute_simd; 820 } 821 822 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) { 823 return DKind == OMPD_simd || DKind == OMPD_for_simd || 824 DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd || 825 DKind == OMPD_distribute_parallel_for_simd || 826 DKind == OMPD_distribute_simd || DKind == OMPD_target_simd || 827 DKind == OMPD_teams_distribute_simd || 828 DKind == OMPD_teams_distribute_parallel_for_simd || 829 DKind == OMPD_target_teams_distribute_parallel_for_simd || 830 DKind == OMPD_target_teams_distribute_simd; 831 } 832 833 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) { 834 return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for || 835 Kind == OMPD_distribute_parallel_for_simd || 836 Kind == OMPD_distribute_simd; 837 // TODO add next directives. 838 } 839 840 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) { 841 return isOpenMPNestingDistributeDirective(Kind) || 842 Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd || 843 Kind == OMPD_teams_distribute_parallel_for_simd || 844 Kind == OMPD_teams_distribute_parallel_for || 845 Kind == OMPD_target_teams_distribute || 846 Kind == OMPD_target_teams_distribute_parallel_for || 847 Kind == OMPD_target_teams_distribute_parallel_for_simd || 848 Kind == OMPD_target_teams_distribute_simd; 849 } 850 851 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) { 852 return Kind == OMPC_private || Kind == OMPC_firstprivate || 853 Kind == OMPC_lastprivate || Kind == OMPC_linear || 854 Kind == OMPC_reduction || 855 Kind == OMPC_task_reduction; // TODO add next clauses like 'reduction'. 856 } 857 858 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) { 859 return Kind == OMPC_threadprivate || Kind == OMPC_copyin; 860 } 861 862 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) { 863 return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind); 864 } 865 866 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) { 867 return Kind == OMPD_distribute_parallel_for || 868 Kind == OMPD_distribute_parallel_for_simd || 869 Kind == OMPD_teams_distribute_parallel_for_simd || 870 Kind == OMPD_teams_distribute_parallel_for || 871 Kind == OMPD_target_teams_distribute_parallel_for || 872 Kind == OMPD_target_teams_distribute_parallel_for_simd; 873 } 874 875 void clang::getOpenMPCaptureRegions( 876 SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions, 877 OpenMPDirectiveKind DKind) { 878 assert(DKind <= OMPD_unknown); 879 switch (DKind) { 880 case OMPD_parallel: 881 case OMPD_parallel_for: 882 case OMPD_parallel_for_simd: 883 case OMPD_parallel_sections: 884 case OMPD_distribute_parallel_for: 885 CaptureRegions.push_back(OMPD_parallel); 886 break; 887 case OMPD_target_teams: 888 CaptureRegions.push_back(OMPD_target); 889 CaptureRegions.push_back(OMPD_teams); 890 break; 891 case OMPD_teams: 892 case OMPD_simd: 893 case OMPD_for: 894 case OMPD_for_simd: 895 case OMPD_sections: 896 case OMPD_section: 897 case OMPD_single: 898 case OMPD_master: 899 case OMPD_critical: 900 case OMPD_taskgroup: 901 case OMPD_distribute: 902 case OMPD_ordered: 903 case OMPD_atomic: 904 case OMPD_target_data: 905 case OMPD_target: 906 case OMPD_target_parallel_for: 907 case OMPD_target_parallel_for_simd: 908 case OMPD_target_simd: 909 case OMPD_task: 910 case OMPD_taskloop: 911 case OMPD_taskloop_simd: 912 case OMPD_distribute_parallel_for_simd: 913 case OMPD_distribute_simd: 914 case OMPD_teams_distribute: 915 case OMPD_teams_distribute_simd: 916 case OMPD_teams_distribute_parallel_for_simd: 917 case OMPD_teams_distribute_parallel_for: 918 case OMPD_target_teams_distribute: 919 case OMPD_target_teams_distribute_parallel_for: 920 case OMPD_target_teams_distribute_parallel_for_simd: 921 case OMPD_target_teams_distribute_simd: 922 CaptureRegions.push_back(DKind); 923 break; 924 case OMPD_target_parallel: 925 CaptureRegions.push_back(OMPD_target); 926 CaptureRegions.push_back(OMPD_parallel); 927 break; 928 case OMPD_threadprivate: 929 case OMPD_taskyield: 930 case OMPD_barrier: 931 case OMPD_taskwait: 932 case OMPD_cancellation_point: 933 case OMPD_cancel: 934 case OMPD_flush: 935 case OMPD_target_enter_data: 936 case OMPD_target_exit_data: 937 case OMPD_declare_reduction: 938 case OMPD_declare_simd: 939 case OMPD_declare_target: 940 case OMPD_end_declare_target: 941 case OMPD_target_update: 942 llvm_unreachable("OpenMP Directive is not allowed"); 943 case OMPD_unknown: 944 llvm_unreachable("Unknown OpenMP directive"); 945 } 946 } 947