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_allocator: 156 case OMPC_allocate: 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_allocator: 339 case OMPC_allocate: 340 case OMPC_collapse: 341 case OMPC_private: 342 case OMPC_firstprivate: 343 case OMPC_lastprivate: 344 case OMPC_shared: 345 case OMPC_reduction: 346 case OMPC_task_reduction: 347 case OMPC_in_reduction: 348 case OMPC_aligned: 349 case OMPC_copyin: 350 case OMPC_copyprivate: 351 case OMPC_ordered: 352 case OMPC_nowait: 353 case OMPC_untied: 354 case OMPC_mergeable: 355 case OMPC_flush: 356 case OMPC_read: 357 case OMPC_write: 358 case OMPC_update: 359 case OMPC_capture: 360 case OMPC_seq_cst: 361 case OMPC_device: 362 case OMPC_threads: 363 case OMPC_simd: 364 case OMPC_num_teams: 365 case OMPC_thread_limit: 366 case OMPC_priority: 367 case OMPC_grainsize: 368 case OMPC_nogroup: 369 case OMPC_num_tasks: 370 case OMPC_hint: 371 case OMPC_uniform: 372 case OMPC_use_device_ptr: 373 case OMPC_is_device_ptr: 374 case OMPC_unified_address: 375 case OMPC_unified_shared_memory: 376 case OMPC_reverse_offload: 377 case OMPC_dynamic_allocators: 378 break; 379 } 380 llvm_unreachable("Invalid OpenMP simple clause kind"); 381 } 382 383 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind, 384 OpenMPClauseKind CKind) { 385 assert(DKind <= OMPD_unknown); 386 assert(CKind <= OMPC_unknown); 387 switch (DKind) { 388 case OMPD_parallel: 389 switch (CKind) { 390 #define OPENMP_PARALLEL_CLAUSE(Name) \ 391 case OMPC_##Name: \ 392 return true; 393 #include "clang/Basic/OpenMPKinds.def" 394 default: 395 break; 396 } 397 break; 398 case OMPD_simd: 399 switch (CKind) { 400 #define OPENMP_SIMD_CLAUSE(Name) \ 401 case OMPC_##Name: \ 402 return true; 403 #include "clang/Basic/OpenMPKinds.def" 404 default: 405 break; 406 } 407 break; 408 case OMPD_for: 409 switch (CKind) { 410 #define OPENMP_FOR_CLAUSE(Name) \ 411 case OMPC_##Name: \ 412 return true; 413 #include "clang/Basic/OpenMPKinds.def" 414 default: 415 break; 416 } 417 break; 418 case OMPD_for_simd: 419 switch (CKind) { 420 #define OPENMP_FOR_SIMD_CLAUSE(Name) \ 421 case OMPC_##Name: \ 422 return true; 423 #include "clang/Basic/OpenMPKinds.def" 424 default: 425 break; 426 } 427 break; 428 case OMPD_sections: 429 switch (CKind) { 430 #define OPENMP_SECTIONS_CLAUSE(Name) \ 431 case OMPC_##Name: \ 432 return true; 433 #include "clang/Basic/OpenMPKinds.def" 434 default: 435 break; 436 } 437 break; 438 case OMPD_single: 439 switch (CKind) { 440 #define OPENMP_SINGLE_CLAUSE(Name) \ 441 case OMPC_##Name: \ 442 return true; 443 #include "clang/Basic/OpenMPKinds.def" 444 default: 445 break; 446 } 447 break; 448 case OMPD_parallel_for: 449 switch (CKind) { 450 #define OPENMP_PARALLEL_FOR_CLAUSE(Name) \ 451 case OMPC_##Name: \ 452 return true; 453 #include "clang/Basic/OpenMPKinds.def" 454 default: 455 break; 456 } 457 break; 458 case OMPD_parallel_for_simd: 459 switch (CKind) { 460 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 461 case OMPC_##Name: \ 462 return true; 463 #include "clang/Basic/OpenMPKinds.def" 464 default: 465 break; 466 } 467 break; 468 case OMPD_parallel_sections: 469 switch (CKind) { 470 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) \ 471 case OMPC_##Name: \ 472 return true; 473 #include "clang/Basic/OpenMPKinds.def" 474 default: 475 break; 476 } 477 break; 478 case OMPD_task: 479 switch (CKind) { 480 #define OPENMP_TASK_CLAUSE(Name) \ 481 case OMPC_##Name: \ 482 return true; 483 #include "clang/Basic/OpenMPKinds.def" 484 default: 485 break; 486 } 487 break; 488 case OMPD_flush: 489 return CKind == OMPC_flush; 490 break; 491 case OMPD_atomic: 492 switch (CKind) { 493 #define OPENMP_ATOMIC_CLAUSE(Name) \ 494 case OMPC_##Name: \ 495 return true; 496 #include "clang/Basic/OpenMPKinds.def" 497 default: 498 break; 499 } 500 break; 501 case OMPD_target: 502 switch (CKind) { 503 #define OPENMP_TARGET_CLAUSE(Name) \ 504 case OMPC_##Name: \ 505 return true; 506 #include "clang/Basic/OpenMPKinds.def" 507 default: 508 break; 509 } 510 break; 511 case OMPD_requires: 512 switch (CKind) { 513 #define OPENMP_REQUIRES_CLAUSE(Name) \ 514 case OMPC_##Name: \ 515 return true; 516 #include "clang/Basic/OpenMPKinds.def" 517 default: 518 break; 519 } 520 break; 521 case OMPD_target_data: 522 switch (CKind) { 523 #define OPENMP_TARGET_DATA_CLAUSE(Name) \ 524 case OMPC_##Name: \ 525 return true; 526 #include "clang/Basic/OpenMPKinds.def" 527 default: 528 break; 529 } 530 break; 531 case OMPD_target_enter_data: 532 switch (CKind) { 533 #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name) \ 534 case OMPC_##Name: \ 535 return true; 536 #include "clang/Basic/OpenMPKinds.def" 537 default: 538 break; 539 } 540 break; 541 case OMPD_target_exit_data: 542 switch (CKind) { 543 #define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name) \ 544 case OMPC_##Name: \ 545 return true; 546 #include "clang/Basic/OpenMPKinds.def" 547 default: 548 break; 549 } 550 break; 551 case OMPD_target_parallel: 552 switch (CKind) { 553 #define OPENMP_TARGET_PARALLEL_CLAUSE(Name) \ 554 case OMPC_##Name: \ 555 return true; 556 #include "clang/Basic/OpenMPKinds.def" 557 default: 558 break; 559 } 560 break; 561 case OMPD_target_parallel_for: 562 switch (CKind) { 563 #define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name) \ 564 case OMPC_##Name: \ 565 return true; 566 #include "clang/Basic/OpenMPKinds.def" 567 default: 568 break; 569 } 570 break; 571 case OMPD_target_update: 572 switch (CKind) { 573 #define OPENMP_TARGET_UPDATE_CLAUSE(Name) \ 574 case OMPC_##Name: \ 575 return true; 576 #include "clang/Basic/OpenMPKinds.def" 577 default: 578 break; 579 } 580 break; 581 case OMPD_teams: 582 switch (CKind) { 583 #define OPENMP_TEAMS_CLAUSE(Name) \ 584 case OMPC_##Name: \ 585 return true; 586 #include "clang/Basic/OpenMPKinds.def" 587 default: 588 break; 589 } 590 break; 591 case OMPD_declare_simd: 592 break; 593 case OMPD_cancel: 594 switch (CKind) { 595 #define OPENMP_CANCEL_CLAUSE(Name) \ 596 case OMPC_##Name: \ 597 return true; 598 #include "clang/Basic/OpenMPKinds.def" 599 default: 600 break; 601 } 602 break; 603 case OMPD_ordered: 604 switch (CKind) { 605 #define OPENMP_ORDERED_CLAUSE(Name) \ 606 case OMPC_##Name: \ 607 return true; 608 #include "clang/Basic/OpenMPKinds.def" 609 default: 610 break; 611 } 612 break; 613 case OMPD_taskloop: 614 switch (CKind) { 615 #define OPENMP_TASKLOOP_CLAUSE(Name) \ 616 case OMPC_##Name: \ 617 return true; 618 #include "clang/Basic/OpenMPKinds.def" 619 default: 620 break; 621 } 622 break; 623 case OMPD_taskloop_simd: 624 switch (CKind) { 625 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name) \ 626 case OMPC_##Name: \ 627 return true; 628 #include "clang/Basic/OpenMPKinds.def" 629 default: 630 break; 631 } 632 break; 633 case OMPD_critical: 634 switch (CKind) { 635 #define OPENMP_CRITICAL_CLAUSE(Name) \ 636 case OMPC_##Name: \ 637 return true; 638 #include "clang/Basic/OpenMPKinds.def" 639 default: 640 break; 641 } 642 break; 643 case OMPD_distribute: 644 switch (CKind) { 645 #define OPENMP_DISTRIBUTE_CLAUSE(Name) \ 646 case OMPC_##Name: \ 647 return true; 648 #include "clang/Basic/OpenMPKinds.def" 649 default: 650 break; 651 } 652 break; 653 case OMPD_distribute_parallel_for: 654 switch (CKind) { 655 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 656 case OMPC_##Name: \ 657 return true; 658 #include "clang/Basic/OpenMPKinds.def" 659 default: 660 break; 661 } 662 break; 663 case OMPD_distribute_parallel_for_simd: 664 switch (CKind) { 665 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 666 case OMPC_##Name: \ 667 return true; 668 #include "clang/Basic/OpenMPKinds.def" 669 default: 670 break; 671 } 672 break; 673 case OMPD_distribute_simd: 674 switch (CKind) { 675 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) \ 676 case OMPC_##Name: \ 677 return true; 678 #include "clang/Basic/OpenMPKinds.def" 679 default: 680 break; 681 } 682 break; 683 case OMPD_target_parallel_for_simd: 684 switch (CKind) { 685 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 686 case OMPC_##Name: \ 687 return true; 688 #include "clang/Basic/OpenMPKinds.def" 689 default: 690 break; 691 } 692 break; 693 case OMPD_target_simd: 694 switch (CKind) { 695 #define OPENMP_TARGET_SIMD_CLAUSE(Name) \ 696 case OMPC_##Name: \ 697 return true; 698 #include "clang/Basic/OpenMPKinds.def" 699 default: 700 break; 701 } 702 break; 703 case OMPD_teams_distribute: 704 switch (CKind) { 705 #define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name) \ 706 case OMPC_##Name: \ 707 return true; 708 #include "clang/Basic/OpenMPKinds.def" 709 default: 710 break; 711 } 712 break; 713 case OMPD_teams_distribute_simd: 714 switch (CKind) { 715 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \ 716 case OMPC_##Name: \ 717 return true; 718 #include "clang/Basic/OpenMPKinds.def" 719 default: 720 break; 721 } 722 break; 723 case OMPD_teams_distribute_parallel_for_simd: 724 switch (CKind) { 725 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 726 case OMPC_##Name: \ 727 return true; 728 #include "clang/Basic/OpenMPKinds.def" 729 default: 730 break; 731 } 732 break; 733 case OMPD_teams_distribute_parallel_for: 734 switch (CKind) { 735 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 736 case OMPC_##Name: \ 737 return true; 738 #include "clang/Basic/OpenMPKinds.def" 739 default: 740 break; 741 } 742 break; 743 case OMPD_target_teams: 744 switch (CKind) { 745 #define OPENMP_TARGET_TEAMS_CLAUSE(Name) \ 746 case OMPC_##Name: \ 747 return true; 748 #include "clang/Basic/OpenMPKinds.def" 749 default: 750 break; 751 } 752 break; 753 case OMPD_target_teams_distribute: 754 switch (CKind) { 755 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name) \ 756 case OMPC_##Name: \ 757 return true; 758 #include "clang/Basic/OpenMPKinds.def" 759 default: 760 break; 761 } 762 break; 763 case OMPD_target_teams_distribute_parallel_for: 764 switch (CKind) { 765 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 766 case OMPC_##Name: \ 767 return true; 768 #include "clang/Basic/OpenMPKinds.def" 769 default: 770 break; 771 } 772 break; 773 case OMPD_target_teams_distribute_parallel_for_simd: 774 switch (CKind) { 775 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 776 case OMPC_##Name: \ 777 return true; 778 #include "clang/Basic/OpenMPKinds.def" 779 default: 780 break; 781 } 782 break; 783 case OMPD_target_teams_distribute_simd: 784 switch (CKind) { 785 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \ 786 case OMPC_##Name: \ 787 return true; 788 #include "clang/Basic/OpenMPKinds.def" 789 default: 790 break; 791 } 792 break; 793 case OMPD_taskgroup: 794 switch (CKind) { 795 #define OPENMP_TASKGROUP_CLAUSE(Name) \ 796 case OMPC_##Name: \ 797 return true; 798 #include "clang/Basic/OpenMPKinds.def" 799 default: 800 break; 801 } 802 break; 803 case OMPD_declare_mapper: 804 switch (CKind) { 805 #define OPENMP_DECLARE_MAPPER_CLAUSE(Name) \ 806 case OMPC_##Name: \ 807 return true; 808 #include "clang/Basic/OpenMPKinds.def" 809 default: 810 break; 811 } 812 break; 813 case OMPD_allocate: 814 switch (CKind) { 815 #define OPENMP_ALLOCATE_CLAUSE(Name) \ 816 case OMPC_##Name: \ 817 return true; 818 #include "clang/Basic/OpenMPKinds.def" 819 default: 820 break; 821 } 822 break; 823 case OMPD_declare_target: 824 case OMPD_end_declare_target: 825 case OMPD_unknown: 826 case OMPD_threadprivate: 827 case OMPD_section: 828 case OMPD_master: 829 case OMPD_taskyield: 830 case OMPD_barrier: 831 case OMPD_taskwait: 832 case OMPD_cancellation_point: 833 case OMPD_declare_reduction: 834 break; 835 } 836 return false; 837 } 838 839 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) { 840 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd || 841 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd || 842 DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 843 DKind == OMPD_distribute || DKind == OMPD_target_parallel_for || 844 DKind == OMPD_distribute_parallel_for || 845 DKind == OMPD_distribute_parallel_for_simd || 846 DKind == OMPD_distribute_simd || 847 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 848 DKind == OMPD_teams_distribute || 849 DKind == OMPD_teams_distribute_simd || 850 DKind == OMPD_teams_distribute_parallel_for_simd || 851 DKind == OMPD_teams_distribute_parallel_for || 852 DKind == OMPD_target_teams_distribute || 853 DKind == OMPD_target_teams_distribute_parallel_for || 854 DKind == OMPD_target_teams_distribute_parallel_for_simd || 855 DKind == OMPD_target_teams_distribute_simd; 856 } 857 858 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { 859 return DKind == OMPD_for || DKind == OMPD_for_simd || 860 DKind == OMPD_sections || DKind == OMPD_section || 861 DKind == OMPD_single || DKind == OMPD_parallel_for || 862 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 863 DKind == OMPD_target_parallel_for || 864 DKind == OMPD_distribute_parallel_for || 865 DKind == OMPD_distribute_parallel_for_simd || 866 DKind == OMPD_target_parallel_for_simd || 867 DKind == OMPD_teams_distribute_parallel_for_simd || 868 DKind == OMPD_teams_distribute_parallel_for || 869 DKind == OMPD_target_teams_distribute_parallel_for || 870 DKind == OMPD_target_teams_distribute_parallel_for_simd; 871 } 872 873 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) { 874 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd; 875 } 876 877 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) { 878 return DKind == OMPD_parallel || DKind == OMPD_parallel_for || 879 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 880 DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for || 881 DKind == OMPD_distribute_parallel_for || 882 DKind == OMPD_distribute_parallel_for_simd || 883 DKind == OMPD_target_parallel_for_simd || 884 DKind == OMPD_teams_distribute_parallel_for || 885 DKind == OMPD_teams_distribute_parallel_for_simd || 886 DKind == OMPD_target_teams_distribute_parallel_for || 887 DKind == OMPD_target_teams_distribute_parallel_for_simd; 888 } 889 890 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) { 891 return DKind == OMPD_target || DKind == OMPD_target_parallel || 892 DKind == OMPD_target_parallel_for || 893 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 894 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 895 DKind == OMPD_target_teams_distribute_parallel_for || 896 DKind == OMPD_target_teams_distribute_parallel_for_simd || 897 DKind == OMPD_target_teams_distribute_simd; 898 } 899 900 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) { 901 return DKind == OMPD_target_data || DKind == OMPD_target_enter_data || 902 DKind == OMPD_target_exit_data || DKind == OMPD_target_update; 903 } 904 905 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) { 906 return DKind == OMPD_teams || DKind == OMPD_teams_distribute || 907 DKind == OMPD_teams_distribute_simd || 908 DKind == OMPD_teams_distribute_parallel_for_simd || 909 DKind == OMPD_teams_distribute_parallel_for; 910 } 911 912 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) { 913 return isOpenMPNestingTeamsDirective(DKind) || 914 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 915 DKind == OMPD_target_teams_distribute_parallel_for || 916 DKind == OMPD_target_teams_distribute_parallel_for_simd || 917 DKind == OMPD_target_teams_distribute_simd; 918 } 919 920 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) { 921 return DKind == OMPD_simd || DKind == OMPD_for_simd || 922 DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd || 923 DKind == OMPD_distribute_parallel_for_simd || 924 DKind == OMPD_distribute_simd || DKind == OMPD_target_simd || 925 DKind == OMPD_teams_distribute_simd || 926 DKind == OMPD_teams_distribute_parallel_for_simd || 927 DKind == OMPD_target_teams_distribute_parallel_for_simd || 928 DKind == OMPD_target_teams_distribute_simd || 929 DKind == OMPD_target_parallel_for_simd; 930 } 931 932 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) { 933 return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for || 934 Kind == OMPD_distribute_parallel_for_simd || 935 Kind == OMPD_distribute_simd; 936 // TODO add next directives. 937 } 938 939 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) { 940 return isOpenMPNestingDistributeDirective(Kind) || 941 Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd || 942 Kind == OMPD_teams_distribute_parallel_for_simd || 943 Kind == OMPD_teams_distribute_parallel_for || 944 Kind == OMPD_target_teams_distribute || 945 Kind == OMPD_target_teams_distribute_parallel_for || 946 Kind == OMPD_target_teams_distribute_parallel_for_simd || 947 Kind == OMPD_target_teams_distribute_simd; 948 } 949 950 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) { 951 return Kind == OMPC_private || Kind == OMPC_firstprivate || 952 Kind == OMPC_lastprivate || Kind == OMPC_linear || 953 Kind == OMPC_reduction || Kind == OMPC_task_reduction || 954 Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'. 955 } 956 957 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) { 958 return Kind == OMPC_threadprivate || Kind == OMPC_copyin; 959 } 960 961 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) { 962 return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind); 963 } 964 965 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) { 966 return Kind == OMPD_distribute_parallel_for || 967 Kind == OMPD_distribute_parallel_for_simd || 968 Kind == OMPD_teams_distribute_parallel_for_simd || 969 Kind == OMPD_teams_distribute_parallel_for || 970 Kind == OMPD_target_teams_distribute_parallel_for || 971 Kind == OMPD_target_teams_distribute_parallel_for_simd; 972 } 973 974 void clang::getOpenMPCaptureRegions( 975 SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions, 976 OpenMPDirectiveKind DKind) { 977 assert(DKind <= OMPD_unknown); 978 switch (DKind) { 979 case OMPD_parallel: 980 case OMPD_parallel_for: 981 case OMPD_parallel_for_simd: 982 case OMPD_parallel_sections: 983 case OMPD_distribute_parallel_for: 984 case OMPD_distribute_parallel_for_simd: 985 CaptureRegions.push_back(OMPD_parallel); 986 break; 987 case OMPD_target_teams: 988 case OMPD_target_teams_distribute: 989 case OMPD_target_teams_distribute_simd: 990 CaptureRegions.push_back(OMPD_task); 991 CaptureRegions.push_back(OMPD_target); 992 CaptureRegions.push_back(OMPD_teams); 993 break; 994 case OMPD_teams: 995 case OMPD_teams_distribute: 996 case OMPD_teams_distribute_simd: 997 CaptureRegions.push_back(OMPD_teams); 998 break; 999 case OMPD_target: 1000 case OMPD_target_simd: 1001 CaptureRegions.push_back(OMPD_task); 1002 CaptureRegions.push_back(OMPD_target); 1003 break; 1004 case OMPD_teams_distribute_parallel_for: 1005 case OMPD_teams_distribute_parallel_for_simd: 1006 CaptureRegions.push_back(OMPD_teams); 1007 CaptureRegions.push_back(OMPD_parallel); 1008 break; 1009 case OMPD_target_parallel: 1010 case OMPD_target_parallel_for: 1011 case OMPD_target_parallel_for_simd: 1012 CaptureRegions.push_back(OMPD_task); 1013 CaptureRegions.push_back(OMPD_target); 1014 CaptureRegions.push_back(OMPD_parallel); 1015 break; 1016 case OMPD_task: 1017 case OMPD_target_enter_data: 1018 case OMPD_target_exit_data: 1019 case OMPD_target_update: 1020 CaptureRegions.push_back(OMPD_task); 1021 break; 1022 case OMPD_taskloop: 1023 case OMPD_taskloop_simd: 1024 CaptureRegions.push_back(OMPD_taskloop); 1025 break; 1026 case OMPD_target_teams_distribute_parallel_for: 1027 case OMPD_target_teams_distribute_parallel_for_simd: 1028 CaptureRegions.push_back(OMPD_task); 1029 CaptureRegions.push_back(OMPD_target); 1030 CaptureRegions.push_back(OMPD_teams); 1031 CaptureRegions.push_back(OMPD_parallel); 1032 break; 1033 case OMPD_simd: 1034 case OMPD_for: 1035 case OMPD_for_simd: 1036 case OMPD_sections: 1037 case OMPD_section: 1038 case OMPD_single: 1039 case OMPD_master: 1040 case OMPD_critical: 1041 case OMPD_taskgroup: 1042 case OMPD_distribute: 1043 case OMPD_ordered: 1044 case OMPD_atomic: 1045 case OMPD_target_data: 1046 case OMPD_distribute_simd: 1047 CaptureRegions.push_back(OMPD_unknown); 1048 break; 1049 case OMPD_threadprivate: 1050 case OMPD_allocate: 1051 case OMPD_taskyield: 1052 case OMPD_barrier: 1053 case OMPD_taskwait: 1054 case OMPD_cancellation_point: 1055 case OMPD_cancel: 1056 case OMPD_flush: 1057 case OMPD_declare_reduction: 1058 case OMPD_declare_mapper: 1059 case OMPD_declare_simd: 1060 case OMPD_declare_target: 1061 case OMPD_end_declare_target: 1062 case OMPD_requires: 1063 llvm_unreachable("OpenMP Directive is not allowed"); 1064 case OMPD_unknown: 1065 llvm_unreachable("Unknown OpenMP directive"); 1066 } 1067 } 1068