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 22 OpenMPDirectiveKind clang::getOpenMPDirectiveKind(StringRef Str) { 23 return llvm::StringSwitch<OpenMPDirectiveKind>(Str) 24 #define OPENMP_DIRECTIVE(Name) .Case(#Name, OMPD_##Name) 25 #define OPENMP_DIRECTIVE_EXT(Name, Str) .Case(Str, OMPD_##Name) 26 #include "clang/Basic/OpenMPKinds.def" 27 .Default(OMPD_unknown); 28 } 29 30 const char *clang::getOpenMPDirectiveName(OpenMPDirectiveKind Kind) { 31 assert(Kind <= OMPD_unknown); 32 switch (Kind) { 33 case OMPD_unknown: 34 return "unknown"; 35 #define OPENMP_DIRECTIVE(Name) \ 36 case OMPD_##Name: \ 37 return #Name; 38 #define OPENMP_DIRECTIVE_EXT(Name, Str) \ 39 case OMPD_##Name: \ 40 return Str; 41 #include "clang/Basic/OpenMPKinds.def" 42 break; 43 } 44 llvm_unreachable("Invalid OpenMP directive kind"); 45 } 46 47 OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) { 48 // 'flush' clause cannot be specified explicitly, because this is an implicit 49 // clause for 'flush' directive. If the 'flush' clause is explicitly specified 50 // the Parser should generate a warning about extra tokens at the end of the 51 // directive. 52 if (Str == "flush") 53 return OMPC_unknown; 54 return llvm::StringSwitch<OpenMPClauseKind>(Str) 55 #define OPENMP_CLAUSE(Name, Class) .Case(#Name, OMPC_##Name) 56 #include "clang/Basic/OpenMPKinds.def" 57 .Case("uniform", OMPC_uniform) 58 .Default(OMPC_unknown); 59 } 60 61 const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) { 62 assert(Kind <= OMPC_unknown); 63 switch (Kind) { 64 case OMPC_unknown: 65 return "unknown"; 66 #define OPENMP_CLAUSE(Name, Class) \ 67 case OMPC_##Name: \ 68 return #Name; 69 #include "clang/Basic/OpenMPKinds.def" 70 case OMPC_uniform: 71 return "uniform"; 72 case OMPC_threadprivate: 73 return "threadprivate or thread local"; 74 case OMPC_allocate: 75 return "allocate"; 76 } 77 llvm_unreachable("Invalid OpenMP clause kind"); 78 } 79 80 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind, 81 StringRef Str) { 82 switch (Kind) { 83 case OMPC_default: 84 return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str) 85 #define OPENMP_DEFAULT_KIND(Name) .Case(#Name, OMPC_DEFAULT_##Name) 86 #include "clang/Basic/OpenMPKinds.def" 87 .Default(OMPC_DEFAULT_unknown); 88 case OMPC_proc_bind: 89 return llvm::StringSwitch<OpenMPProcBindClauseKind>(Str) 90 #define OPENMP_PROC_BIND_KIND(Name) .Case(#Name, OMPC_PROC_BIND_##Name) 91 #include "clang/Basic/OpenMPKinds.def" 92 .Default(OMPC_PROC_BIND_unknown); 93 case OMPC_schedule: 94 return llvm::StringSwitch<unsigned>(Str) 95 #define OPENMP_SCHEDULE_KIND(Name) \ 96 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name)) 97 #define OPENMP_SCHEDULE_MODIFIER(Name) \ 98 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name)) 99 #include "clang/Basic/OpenMPKinds.def" 100 .Default(OMPC_SCHEDULE_unknown); 101 case OMPC_depend: 102 return llvm::StringSwitch<OpenMPDependClauseKind>(Str) 103 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name) 104 #include "clang/Basic/OpenMPKinds.def" 105 .Default(OMPC_DEPEND_unknown); 106 case OMPC_linear: 107 return llvm::StringSwitch<OpenMPLinearClauseKind>(Str) 108 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name) 109 #include "clang/Basic/OpenMPKinds.def" 110 .Default(OMPC_LINEAR_unknown); 111 case OMPC_map: 112 return llvm::StringSwitch<unsigned>(Str) 113 #define OPENMP_MAP_KIND(Name) \ 114 .Case(#Name, static_cast<unsigned>(OMPC_MAP_##Name)) 115 #define OPENMP_MAP_MODIFIER_KIND(Name) \ 116 .Case(#Name, static_cast<unsigned>(OMPC_MAP_MODIFIER_##Name)) 117 #include "clang/Basic/OpenMPKinds.def" 118 .Default(OMPC_MAP_unknown); 119 case OMPC_to: 120 return llvm::StringSwitch<unsigned>(Str) 121 #define OPENMP_TO_MODIFIER_KIND(Name) \ 122 .Case(#Name, static_cast<unsigned>(OMPC_TO_MODIFIER_##Name)) 123 #include "clang/Basic/OpenMPKinds.def" 124 .Default(OMPC_TO_MODIFIER_unknown); 125 case OMPC_from: 126 return llvm::StringSwitch<unsigned>(Str) 127 #define OPENMP_FROM_MODIFIER_KIND(Name) \ 128 .Case(#Name, static_cast<unsigned>(OMPC_FROM_MODIFIER_##Name)) 129 #include "clang/Basic/OpenMPKinds.def" 130 .Default(OMPC_FROM_MODIFIER_unknown); 131 case OMPC_dist_schedule: 132 return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str) 133 #define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name) 134 #include "clang/Basic/OpenMPKinds.def" 135 .Default(OMPC_DIST_SCHEDULE_unknown); 136 case OMPC_defaultmap: 137 return llvm::StringSwitch<unsigned>(Str) 138 #define OPENMP_DEFAULTMAP_KIND(Name) \ 139 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name)) 140 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 141 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name)) 142 #include "clang/Basic/OpenMPKinds.def" 143 .Default(OMPC_DEFAULTMAP_unknown); 144 case OMPC_atomic_default_mem_order: 145 return llvm::StringSwitch<OpenMPAtomicDefaultMemOrderClauseKind>(Str) 146 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \ 147 .Case(#Name, OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name) 148 #include "clang/Basic/OpenMPKinds.def" 149 .Default(OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown); 150 case OMPC_unknown: 151 case OMPC_threadprivate: 152 case OMPC_allocate: 153 case OMPC_if: 154 case OMPC_final: 155 case OMPC_num_threads: 156 case OMPC_safelen: 157 case OMPC_simdlen: 158 case OMPC_allocator: 159 case OMPC_collapse: 160 case OMPC_private: 161 case OMPC_firstprivate: 162 case OMPC_lastprivate: 163 case OMPC_shared: 164 case OMPC_reduction: 165 case OMPC_task_reduction: 166 case OMPC_in_reduction: 167 case OMPC_aligned: 168 case OMPC_copyin: 169 case OMPC_copyprivate: 170 case OMPC_ordered: 171 case OMPC_nowait: 172 case OMPC_untied: 173 case OMPC_mergeable: 174 case OMPC_flush: 175 case OMPC_read: 176 case OMPC_write: 177 case OMPC_update: 178 case OMPC_capture: 179 case OMPC_seq_cst: 180 case OMPC_device: 181 case OMPC_threads: 182 case OMPC_simd: 183 case OMPC_num_teams: 184 case OMPC_thread_limit: 185 case OMPC_priority: 186 case OMPC_grainsize: 187 case OMPC_nogroup: 188 case OMPC_num_tasks: 189 case OMPC_hint: 190 case OMPC_uniform: 191 case OMPC_use_device_ptr: 192 case OMPC_is_device_ptr: 193 case OMPC_unified_address: 194 case OMPC_unified_shared_memory: 195 case OMPC_reverse_offload: 196 case OMPC_dynamic_allocators: 197 break; 198 } 199 llvm_unreachable("Invalid OpenMP simple clause kind"); 200 } 201 202 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, 203 unsigned Type) { 204 switch (Kind) { 205 case OMPC_default: 206 switch (Type) { 207 case OMPC_DEFAULT_unknown: 208 return "unknown"; 209 #define OPENMP_DEFAULT_KIND(Name) \ 210 case OMPC_DEFAULT_##Name: \ 211 return #Name; 212 #include "clang/Basic/OpenMPKinds.def" 213 } 214 llvm_unreachable("Invalid OpenMP 'default' clause type"); 215 case OMPC_proc_bind: 216 switch (Type) { 217 case OMPC_PROC_BIND_unknown: 218 return "unknown"; 219 #define OPENMP_PROC_BIND_KIND(Name) \ 220 case OMPC_PROC_BIND_##Name: \ 221 return #Name; 222 #include "clang/Basic/OpenMPKinds.def" 223 } 224 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type"); 225 case OMPC_schedule: 226 switch (Type) { 227 case OMPC_SCHEDULE_unknown: 228 case OMPC_SCHEDULE_MODIFIER_last: 229 return "unknown"; 230 #define OPENMP_SCHEDULE_KIND(Name) \ 231 case OMPC_SCHEDULE_##Name: \ 232 return #Name; 233 #define OPENMP_SCHEDULE_MODIFIER(Name) \ 234 case OMPC_SCHEDULE_MODIFIER_##Name: \ 235 return #Name; 236 #include "clang/Basic/OpenMPKinds.def" 237 } 238 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 239 case OMPC_depend: 240 switch (Type) { 241 case OMPC_DEPEND_unknown: 242 return "unknown"; 243 #define OPENMP_DEPEND_KIND(Name) \ 244 case OMPC_DEPEND_##Name: \ 245 return #Name; 246 #include "clang/Basic/OpenMPKinds.def" 247 } 248 llvm_unreachable("Invalid OpenMP 'depend' clause type"); 249 case OMPC_linear: 250 switch (Type) { 251 case OMPC_LINEAR_unknown: 252 return "unknown"; 253 #define OPENMP_LINEAR_KIND(Name) \ 254 case OMPC_LINEAR_##Name: \ 255 return #Name; 256 #include "clang/Basic/OpenMPKinds.def" 257 } 258 llvm_unreachable("Invalid OpenMP 'linear' clause type"); 259 case OMPC_map: 260 switch (Type) { 261 case OMPC_MAP_unknown: 262 case OMPC_MAP_MODIFIER_last: 263 return "unknown"; 264 #define OPENMP_MAP_KIND(Name) \ 265 case OMPC_MAP_##Name: \ 266 return #Name; 267 #define OPENMP_MAP_MODIFIER_KIND(Name) \ 268 case OMPC_MAP_MODIFIER_##Name: \ 269 return #Name; 270 #include "clang/Basic/OpenMPKinds.def" 271 default: 272 break; 273 } 274 llvm_unreachable("Invalid OpenMP 'map' clause type"); 275 case OMPC_to: 276 switch (Type) { 277 case OMPC_TO_MODIFIER_unknown: 278 return "unknown"; 279 #define OPENMP_TO_MODIFIER_KIND(Name) \ 280 case OMPC_TO_MODIFIER_##Name: \ 281 return #Name; 282 #include "clang/Basic/OpenMPKinds.def" 283 default: 284 break; 285 } 286 llvm_unreachable("Invalid OpenMP 'to' clause type"); 287 case OMPC_from: 288 switch (Type) { 289 case OMPC_FROM_MODIFIER_unknown: 290 return "unknown"; 291 #define OPENMP_FROM_MODIFIER_KIND(Name) \ 292 case OMPC_FROM_MODIFIER_##Name: \ 293 return #Name; 294 #include "clang/Basic/OpenMPKinds.def" 295 default: 296 break; 297 } 298 llvm_unreachable("Invalid OpenMP 'from' clause type"); 299 case OMPC_dist_schedule: 300 switch (Type) { 301 case OMPC_DIST_SCHEDULE_unknown: 302 return "unknown"; 303 #define OPENMP_DIST_SCHEDULE_KIND(Name) \ 304 case OMPC_DIST_SCHEDULE_##Name: \ 305 return #Name; 306 #include "clang/Basic/OpenMPKinds.def" 307 } 308 llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type"); 309 case OMPC_defaultmap: 310 switch (Type) { 311 case OMPC_DEFAULTMAP_unknown: 312 case OMPC_DEFAULTMAP_MODIFIER_last: 313 return "unknown"; 314 #define OPENMP_DEFAULTMAP_KIND(Name) \ 315 case OMPC_DEFAULTMAP_##Name: \ 316 return #Name; 317 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 318 case OMPC_DEFAULTMAP_MODIFIER_##Name: \ 319 return #Name; 320 #include "clang/Basic/OpenMPKinds.def" 321 } 322 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 323 case OMPC_atomic_default_mem_order: 324 switch (Type) { 325 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown: 326 return "unknown"; 327 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \ 328 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name: \ 329 return #Name; 330 #include "clang/Basic/OpenMPKinds.def" 331 } 332 llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type"); 333 case OMPC_unknown: 334 case OMPC_threadprivate: 335 case OMPC_allocate: 336 case OMPC_if: 337 case OMPC_final: 338 case OMPC_num_threads: 339 case OMPC_safelen: 340 case OMPC_simdlen: 341 case OMPC_allocator: 342 case OMPC_collapse: 343 case OMPC_private: 344 case OMPC_firstprivate: 345 case OMPC_lastprivate: 346 case OMPC_shared: 347 case OMPC_reduction: 348 case OMPC_task_reduction: 349 case OMPC_in_reduction: 350 case OMPC_aligned: 351 case OMPC_copyin: 352 case OMPC_copyprivate: 353 case OMPC_ordered: 354 case OMPC_nowait: 355 case OMPC_untied: 356 case OMPC_mergeable: 357 case OMPC_flush: 358 case OMPC_read: 359 case OMPC_write: 360 case OMPC_update: 361 case OMPC_capture: 362 case OMPC_seq_cst: 363 case OMPC_device: 364 case OMPC_threads: 365 case OMPC_simd: 366 case OMPC_num_teams: 367 case OMPC_thread_limit: 368 case OMPC_priority: 369 case OMPC_grainsize: 370 case OMPC_nogroup: 371 case OMPC_num_tasks: 372 case OMPC_hint: 373 case OMPC_uniform: 374 case OMPC_use_device_ptr: 375 case OMPC_is_device_ptr: 376 case OMPC_unified_address: 377 case OMPC_unified_shared_memory: 378 case OMPC_reverse_offload: 379 case OMPC_dynamic_allocators: 380 break; 381 } 382 llvm_unreachable("Invalid OpenMP simple clause kind"); 383 } 384 385 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind, 386 OpenMPClauseKind CKind) { 387 assert(DKind <= OMPD_unknown); 388 assert(CKind <= OMPC_unknown); 389 switch (DKind) { 390 case OMPD_parallel: 391 switch (CKind) { 392 #define OPENMP_PARALLEL_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_simd: 401 switch (CKind) { 402 #define OPENMP_SIMD_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_for: 411 switch (CKind) { 412 #define OPENMP_FOR_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_for_simd: 421 switch (CKind) { 422 #define OPENMP_FOR_SIMD_CLAUSE(Name) \ 423 case OMPC_##Name: \ 424 return true; 425 #include "clang/Basic/OpenMPKinds.def" 426 default: 427 break; 428 } 429 break; 430 case OMPD_sections: 431 switch (CKind) { 432 #define OPENMP_SECTIONS_CLAUSE(Name) \ 433 case OMPC_##Name: \ 434 return true; 435 #include "clang/Basic/OpenMPKinds.def" 436 default: 437 break; 438 } 439 break; 440 case OMPD_single: 441 switch (CKind) { 442 #define OPENMP_SINGLE_CLAUSE(Name) \ 443 case OMPC_##Name: \ 444 return true; 445 #include "clang/Basic/OpenMPKinds.def" 446 default: 447 break; 448 } 449 break; 450 case OMPD_parallel_for: 451 switch (CKind) { 452 #define OPENMP_PARALLEL_FOR_CLAUSE(Name) \ 453 case OMPC_##Name: \ 454 return true; 455 #include "clang/Basic/OpenMPKinds.def" 456 default: 457 break; 458 } 459 break; 460 case OMPD_parallel_for_simd: 461 switch (CKind) { 462 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 463 case OMPC_##Name: \ 464 return true; 465 #include "clang/Basic/OpenMPKinds.def" 466 default: 467 break; 468 } 469 break; 470 case OMPD_parallel_sections: 471 switch (CKind) { 472 #define OPENMP_PARALLEL_SECTIONS_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_task: 481 switch (CKind) { 482 #define OPENMP_TASK_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_flush: 491 return CKind == OMPC_flush; 492 break; 493 case OMPD_atomic: 494 switch (CKind) { 495 #define OPENMP_ATOMIC_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_target: 504 switch (CKind) { 505 #define OPENMP_TARGET_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_requires: 514 switch (CKind) { 515 #define OPENMP_REQUIRES_CLAUSE(Name) \ 516 case OMPC_##Name: \ 517 return true; 518 #include "clang/Basic/OpenMPKinds.def" 519 default: 520 break; 521 } 522 break; 523 case OMPD_target_data: 524 switch (CKind) { 525 #define OPENMP_TARGET_DATA_CLAUSE(Name) \ 526 case OMPC_##Name: \ 527 return true; 528 #include "clang/Basic/OpenMPKinds.def" 529 default: 530 break; 531 } 532 break; 533 case OMPD_target_enter_data: 534 switch (CKind) { 535 #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name) \ 536 case OMPC_##Name: \ 537 return true; 538 #include "clang/Basic/OpenMPKinds.def" 539 default: 540 break; 541 } 542 break; 543 case OMPD_target_exit_data: 544 switch (CKind) { 545 #define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name) \ 546 case OMPC_##Name: \ 547 return true; 548 #include "clang/Basic/OpenMPKinds.def" 549 default: 550 break; 551 } 552 break; 553 case OMPD_target_parallel: 554 switch (CKind) { 555 #define OPENMP_TARGET_PARALLEL_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_parallel_for: 564 switch (CKind) { 565 #define OPENMP_TARGET_PARALLEL_FOR_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_target_update: 574 switch (CKind) { 575 #define OPENMP_TARGET_UPDATE_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_teams: 584 switch (CKind) { 585 #define OPENMP_TEAMS_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_declare_simd: 594 break; 595 case OMPD_cancel: 596 switch (CKind) { 597 #define OPENMP_CANCEL_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_ordered: 606 switch (CKind) { 607 #define OPENMP_ORDERED_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_taskloop: 616 switch (CKind) { 617 #define OPENMP_TASKLOOP_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_taskloop_simd: 626 switch (CKind) { 627 #define OPENMP_TASKLOOP_SIMD_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_critical: 636 switch (CKind) { 637 #define OPENMP_CRITICAL_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_distribute: 646 switch (CKind) { 647 #define OPENMP_DISTRIBUTE_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_distribute_parallel_for: 656 switch (CKind) { 657 #define OPENMP_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_distribute_parallel_for_simd: 666 switch (CKind) { 667 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_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_distribute_simd: 676 switch (CKind) { 677 #define OPENMP_DISTRIBUTE_SIMD_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_parallel_for_simd: 686 switch (CKind) { 687 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_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_simd: 696 switch (CKind) { 697 #define OPENMP_TARGET_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_teams_distribute: 706 switch (CKind) { 707 #define OPENMP_TEAMS_DISTRIBUTE_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_teams_distribute_simd: 716 switch (CKind) { 717 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_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_teams_distribute_parallel_for_simd: 726 switch (CKind) { 727 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 728 case OMPC_##Name: \ 729 return true; 730 #include "clang/Basic/OpenMPKinds.def" 731 default: 732 break; 733 } 734 break; 735 case OMPD_teams_distribute_parallel_for: 736 switch (CKind) { 737 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 738 case OMPC_##Name: \ 739 return true; 740 #include "clang/Basic/OpenMPKinds.def" 741 default: 742 break; 743 } 744 break; 745 case OMPD_target_teams: 746 switch (CKind) { 747 #define OPENMP_TARGET_TEAMS_CLAUSE(Name) \ 748 case OMPC_##Name: \ 749 return true; 750 #include "clang/Basic/OpenMPKinds.def" 751 default: 752 break; 753 } 754 break; 755 case OMPD_target_teams_distribute: 756 switch (CKind) { 757 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name) \ 758 case OMPC_##Name: \ 759 return true; 760 #include "clang/Basic/OpenMPKinds.def" 761 default: 762 break; 763 } 764 break; 765 case OMPD_target_teams_distribute_parallel_for: 766 switch (CKind) { 767 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 768 case OMPC_##Name: \ 769 return true; 770 #include "clang/Basic/OpenMPKinds.def" 771 default: 772 break; 773 } 774 break; 775 case OMPD_target_teams_distribute_parallel_for_simd: 776 switch (CKind) { 777 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_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_teams_distribute_simd: 786 switch (CKind) { 787 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_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_taskgroup: 796 switch (CKind) { 797 #define OPENMP_TASKGROUP_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_declare_mapper: 806 switch (CKind) { 807 #define OPENMP_DECLARE_MAPPER_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_allocate: 816 switch (CKind) { 817 #define OPENMP_ALLOCATE_CLAUSE(Name) \ 818 case OMPC_##Name: \ 819 return true; 820 #include "clang/Basic/OpenMPKinds.def" 821 default: 822 break; 823 } 824 break; 825 case OMPD_declare_target: 826 case OMPD_end_declare_target: 827 case OMPD_unknown: 828 case OMPD_threadprivate: 829 case OMPD_section: 830 case OMPD_master: 831 case OMPD_taskyield: 832 case OMPD_barrier: 833 case OMPD_taskwait: 834 case OMPD_cancellation_point: 835 case OMPD_declare_reduction: 836 break; 837 } 838 return false; 839 } 840 841 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) { 842 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd || 843 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd || 844 DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 845 DKind == OMPD_distribute || DKind == OMPD_target_parallel_for || 846 DKind == OMPD_distribute_parallel_for || 847 DKind == OMPD_distribute_parallel_for_simd || 848 DKind == OMPD_distribute_simd || 849 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 850 DKind == OMPD_teams_distribute || 851 DKind == OMPD_teams_distribute_simd || 852 DKind == OMPD_teams_distribute_parallel_for_simd || 853 DKind == OMPD_teams_distribute_parallel_for || 854 DKind == OMPD_target_teams_distribute || 855 DKind == OMPD_target_teams_distribute_parallel_for || 856 DKind == OMPD_target_teams_distribute_parallel_for_simd || 857 DKind == OMPD_target_teams_distribute_simd; 858 } 859 860 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { 861 return DKind == OMPD_for || DKind == OMPD_for_simd || 862 DKind == OMPD_sections || DKind == OMPD_section || 863 DKind == OMPD_single || DKind == OMPD_parallel_for || 864 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 865 DKind == OMPD_target_parallel_for || 866 DKind == OMPD_distribute_parallel_for || 867 DKind == OMPD_distribute_parallel_for_simd || 868 DKind == OMPD_target_parallel_for_simd || 869 DKind == OMPD_teams_distribute_parallel_for_simd || 870 DKind == OMPD_teams_distribute_parallel_for || 871 DKind == OMPD_target_teams_distribute_parallel_for || 872 DKind == OMPD_target_teams_distribute_parallel_for_simd; 873 } 874 875 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) { 876 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd; 877 } 878 879 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) { 880 return DKind == OMPD_parallel || DKind == OMPD_parallel_for || 881 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 882 DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for || 883 DKind == OMPD_distribute_parallel_for || 884 DKind == OMPD_distribute_parallel_for_simd || 885 DKind == OMPD_target_parallel_for_simd || 886 DKind == OMPD_teams_distribute_parallel_for || 887 DKind == OMPD_teams_distribute_parallel_for_simd || 888 DKind == OMPD_target_teams_distribute_parallel_for || 889 DKind == OMPD_target_teams_distribute_parallel_for_simd; 890 } 891 892 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) { 893 return DKind == OMPD_target || DKind == OMPD_target_parallel || 894 DKind == OMPD_target_parallel_for || 895 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 896 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 897 DKind == OMPD_target_teams_distribute_parallel_for || 898 DKind == OMPD_target_teams_distribute_parallel_for_simd || 899 DKind == OMPD_target_teams_distribute_simd; 900 } 901 902 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) { 903 return DKind == OMPD_target_data || DKind == OMPD_target_enter_data || 904 DKind == OMPD_target_exit_data || DKind == OMPD_target_update; 905 } 906 907 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) { 908 return DKind == OMPD_teams || DKind == OMPD_teams_distribute || 909 DKind == OMPD_teams_distribute_simd || 910 DKind == OMPD_teams_distribute_parallel_for_simd || 911 DKind == OMPD_teams_distribute_parallel_for; 912 } 913 914 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) { 915 return isOpenMPNestingTeamsDirective(DKind) || 916 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 917 DKind == OMPD_target_teams_distribute_parallel_for || 918 DKind == OMPD_target_teams_distribute_parallel_for_simd || 919 DKind == OMPD_target_teams_distribute_simd; 920 } 921 922 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) { 923 return DKind == OMPD_simd || DKind == OMPD_for_simd || 924 DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd || 925 DKind == OMPD_distribute_parallel_for_simd || 926 DKind == OMPD_distribute_simd || DKind == OMPD_target_simd || 927 DKind == OMPD_teams_distribute_simd || 928 DKind == OMPD_teams_distribute_parallel_for_simd || 929 DKind == OMPD_target_teams_distribute_parallel_for_simd || 930 DKind == OMPD_target_teams_distribute_simd || 931 DKind == OMPD_target_parallel_for_simd; 932 } 933 934 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) { 935 return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for || 936 Kind == OMPD_distribute_parallel_for_simd || 937 Kind == OMPD_distribute_simd; 938 // TODO add next directives. 939 } 940 941 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) { 942 return isOpenMPNestingDistributeDirective(Kind) || 943 Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd || 944 Kind == OMPD_teams_distribute_parallel_for_simd || 945 Kind == OMPD_teams_distribute_parallel_for || 946 Kind == OMPD_target_teams_distribute || 947 Kind == OMPD_target_teams_distribute_parallel_for || 948 Kind == OMPD_target_teams_distribute_parallel_for_simd || 949 Kind == OMPD_target_teams_distribute_simd; 950 } 951 952 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) { 953 return Kind == OMPC_private || Kind == OMPC_firstprivate || 954 Kind == OMPC_lastprivate || Kind == OMPC_linear || 955 Kind == OMPC_reduction || Kind == OMPC_task_reduction || 956 Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'. 957 } 958 959 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) { 960 return Kind == OMPC_threadprivate || Kind == OMPC_copyin; 961 } 962 963 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) { 964 return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind); 965 } 966 967 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) { 968 return Kind == OMPD_distribute_parallel_for || 969 Kind == OMPD_distribute_parallel_for_simd || 970 Kind == OMPD_teams_distribute_parallel_for_simd || 971 Kind == OMPD_teams_distribute_parallel_for || 972 Kind == OMPD_target_teams_distribute_parallel_for || 973 Kind == OMPD_target_teams_distribute_parallel_for_simd; 974 } 975 976 void clang::getOpenMPCaptureRegions( 977 SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions, 978 OpenMPDirectiveKind DKind) { 979 assert(DKind <= OMPD_unknown); 980 switch (DKind) { 981 case OMPD_parallel: 982 case OMPD_parallel_for: 983 case OMPD_parallel_for_simd: 984 case OMPD_parallel_sections: 985 case OMPD_distribute_parallel_for: 986 case OMPD_distribute_parallel_for_simd: 987 CaptureRegions.push_back(OMPD_parallel); 988 break; 989 case OMPD_target_teams: 990 case OMPD_target_teams_distribute: 991 case OMPD_target_teams_distribute_simd: 992 CaptureRegions.push_back(OMPD_task); 993 CaptureRegions.push_back(OMPD_target); 994 CaptureRegions.push_back(OMPD_teams); 995 break; 996 case OMPD_teams: 997 case OMPD_teams_distribute: 998 case OMPD_teams_distribute_simd: 999 CaptureRegions.push_back(OMPD_teams); 1000 break; 1001 case OMPD_target: 1002 case OMPD_target_simd: 1003 CaptureRegions.push_back(OMPD_task); 1004 CaptureRegions.push_back(OMPD_target); 1005 break; 1006 case OMPD_teams_distribute_parallel_for: 1007 case OMPD_teams_distribute_parallel_for_simd: 1008 CaptureRegions.push_back(OMPD_teams); 1009 CaptureRegions.push_back(OMPD_parallel); 1010 break; 1011 case OMPD_target_parallel: 1012 case OMPD_target_parallel_for: 1013 case OMPD_target_parallel_for_simd: 1014 CaptureRegions.push_back(OMPD_task); 1015 CaptureRegions.push_back(OMPD_target); 1016 CaptureRegions.push_back(OMPD_parallel); 1017 break; 1018 case OMPD_task: 1019 case OMPD_target_enter_data: 1020 case OMPD_target_exit_data: 1021 case OMPD_target_update: 1022 CaptureRegions.push_back(OMPD_task); 1023 break; 1024 case OMPD_taskloop: 1025 case OMPD_taskloop_simd: 1026 CaptureRegions.push_back(OMPD_taskloop); 1027 break; 1028 case OMPD_target_teams_distribute_parallel_for: 1029 case OMPD_target_teams_distribute_parallel_for_simd: 1030 CaptureRegions.push_back(OMPD_task); 1031 CaptureRegions.push_back(OMPD_target); 1032 CaptureRegions.push_back(OMPD_teams); 1033 CaptureRegions.push_back(OMPD_parallel); 1034 break; 1035 case OMPD_simd: 1036 case OMPD_for: 1037 case OMPD_for_simd: 1038 case OMPD_sections: 1039 case OMPD_section: 1040 case OMPD_single: 1041 case OMPD_master: 1042 case OMPD_critical: 1043 case OMPD_taskgroup: 1044 case OMPD_distribute: 1045 case OMPD_ordered: 1046 case OMPD_atomic: 1047 case OMPD_target_data: 1048 case OMPD_distribute_simd: 1049 CaptureRegions.push_back(OMPD_unknown); 1050 break; 1051 case OMPD_threadprivate: 1052 case OMPD_allocate: 1053 case OMPD_taskyield: 1054 case OMPD_barrier: 1055 case OMPD_taskwait: 1056 case OMPD_cancellation_point: 1057 case OMPD_cancel: 1058 case OMPD_flush: 1059 case OMPD_declare_reduction: 1060 case OMPD_declare_mapper: 1061 case OMPD_declare_simd: 1062 case OMPD_declare_target: 1063 case OMPD_end_declare_target: 1064 case OMPD_requires: 1065 llvm_unreachable("OpenMP Directive is not allowed"); 1066 case OMPD_unknown: 1067 llvm_unreachable("Unknown OpenMP directive"); 1068 } 1069 } 1070