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