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