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