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 using namespace llvm::omp; 22 23 OpenMPContextSelectorSetKind 24 clang::getOpenMPContextSelectorSet(llvm::StringRef Str) { 25 return llvm::StringSwitch<OpenMPContextSelectorSetKind>(Str) 26 #define OPENMP_CONTEXT_SELECTOR_SET(Name) .Case(#Name, OMP_CTX_SET_##Name) 27 #include "clang/Basic/OpenMPKinds.def" 28 .Default(OMP_CTX_SET_unknown); 29 } 30 31 llvm::StringRef 32 clang::getOpenMPContextSelectorSetName(OpenMPContextSelectorSetKind Kind) { 33 switch (Kind) { 34 case OMP_CTX_SET_unknown: 35 return "unknown"; 36 #define OPENMP_CONTEXT_SELECTOR_SET(Name) \ 37 case OMP_CTX_SET_##Name: \ 38 return #Name; 39 #include "clang/Basic/OpenMPKinds.def" 40 break; 41 } 42 llvm_unreachable("Invalid OpenMP context selector set kind"); 43 } 44 45 OpenMPContextSelectorKind clang::getOpenMPContextSelector(llvm::StringRef Str) { 46 return llvm::StringSwitch<OpenMPContextSelectorKind>(Str) 47 #define OPENMP_CONTEXT_SELECTOR(Name) .Case(#Name, OMP_CTX_##Name) 48 #include "clang/Basic/OpenMPKinds.def" 49 .Default(OMP_CTX_unknown); 50 } 51 52 llvm::StringRef 53 clang::getOpenMPContextSelectorName(OpenMPContextSelectorKind Kind) { 54 switch (Kind) { 55 case OMP_CTX_unknown: 56 return "unknown"; 57 #define OPENMP_CONTEXT_SELECTOR(Name) \ 58 case OMP_CTX_##Name: \ 59 return #Name; 60 #include "clang/Basic/OpenMPKinds.def" 61 break; 62 } 63 llvm_unreachable("Invalid OpenMP context selector kind"); 64 } 65 66 OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) { 67 // 'flush' clause cannot be specified explicitly, because this is an implicit 68 // clause for 'flush' directive. If the 'flush' clause is explicitly specified 69 // the Parser should generate a warning about extra tokens at the end of the 70 // directive. 71 if (Str == "flush") 72 return OMPC_unknown; 73 return llvm::StringSwitch<OpenMPClauseKind>(Str) 74 #define OPENMP_CLAUSE(Name, Class) .Case(#Name, OMPC_##Name) 75 #include "clang/Basic/OpenMPKinds.def" 76 .Case("uniform", OMPC_uniform) 77 .Case("device_type", OMPC_device_type) 78 .Case("match", OMPC_match) 79 .Default(OMPC_unknown); 80 } 81 82 const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) { 83 assert(Kind <= OMPC_unknown); 84 switch (Kind) { 85 case OMPC_unknown: 86 return "unknown"; 87 #define OPENMP_CLAUSE(Name, Class) \ 88 case OMPC_##Name: \ 89 return #Name; 90 #include "clang/Basic/OpenMPKinds.def" 91 case OMPC_uniform: 92 return "uniform"; 93 case OMPC_threadprivate: 94 return "threadprivate or thread local"; 95 case OMPC_device_type: 96 return "device_type"; 97 case OMPC_match: 98 return "match"; 99 } 100 llvm_unreachable("Invalid OpenMP clause kind"); 101 } 102 103 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind, 104 StringRef Str) { 105 switch (Kind) { 106 case OMPC_default: 107 return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str) 108 #define OPENMP_DEFAULT_KIND(Name) .Case(#Name, OMPC_DEFAULT_##Name) 109 #include "clang/Basic/OpenMPKinds.def" 110 .Default(OMPC_DEFAULT_unknown); 111 case OMPC_proc_bind: 112 return llvm::StringSwitch<unsigned>(Str) 113 #define OMP_PROC_BIND_KIND(Enum, Name, Value) .Case(Name, Value) 114 #include "llvm/Frontend/OpenMP/OMPKinds.def" 115 .Default(unsigned(llvm::omp::OMP_PROC_BIND_unknown)); 116 case OMPC_schedule: 117 return llvm::StringSwitch<unsigned>(Str) 118 #define OPENMP_SCHEDULE_KIND(Name) \ 119 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name)) 120 #define OPENMP_SCHEDULE_MODIFIER(Name) \ 121 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name)) 122 #include "clang/Basic/OpenMPKinds.def" 123 .Default(OMPC_SCHEDULE_unknown); 124 case OMPC_depend: 125 return llvm::StringSwitch<OpenMPDependClauseKind>(Str) 126 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name) 127 #include "clang/Basic/OpenMPKinds.def" 128 .Default(OMPC_DEPEND_unknown); 129 case OMPC_linear: 130 return llvm::StringSwitch<OpenMPLinearClauseKind>(Str) 131 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name) 132 #include "clang/Basic/OpenMPKinds.def" 133 .Default(OMPC_LINEAR_unknown); 134 case OMPC_map: 135 return llvm::StringSwitch<unsigned>(Str) 136 #define OPENMP_MAP_KIND(Name) \ 137 .Case(#Name, static_cast<unsigned>(OMPC_MAP_##Name)) 138 #define OPENMP_MAP_MODIFIER_KIND(Name) \ 139 .Case(#Name, static_cast<unsigned>(OMPC_MAP_MODIFIER_##Name)) 140 #include "clang/Basic/OpenMPKinds.def" 141 .Default(OMPC_MAP_unknown); 142 case OMPC_to: 143 return llvm::StringSwitch<unsigned>(Str) 144 #define OPENMP_TO_MODIFIER_KIND(Name) \ 145 .Case(#Name, static_cast<unsigned>(OMPC_TO_MODIFIER_##Name)) 146 #include "clang/Basic/OpenMPKinds.def" 147 .Default(OMPC_TO_MODIFIER_unknown); 148 case OMPC_from: 149 return llvm::StringSwitch<unsigned>(Str) 150 #define OPENMP_FROM_MODIFIER_KIND(Name) \ 151 .Case(#Name, static_cast<unsigned>(OMPC_FROM_MODIFIER_##Name)) 152 #include "clang/Basic/OpenMPKinds.def" 153 .Default(OMPC_FROM_MODIFIER_unknown); 154 case OMPC_dist_schedule: 155 return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str) 156 #define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name) 157 #include "clang/Basic/OpenMPKinds.def" 158 .Default(OMPC_DIST_SCHEDULE_unknown); 159 case OMPC_defaultmap: 160 return llvm::StringSwitch<unsigned>(Str) 161 #define OPENMP_DEFAULTMAP_KIND(Name) \ 162 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name)) 163 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 164 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name)) 165 #include "clang/Basic/OpenMPKinds.def" 166 .Default(OMPC_DEFAULTMAP_unknown); 167 case OMPC_atomic_default_mem_order: 168 return llvm::StringSwitch<OpenMPAtomicDefaultMemOrderClauseKind>(Str) 169 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \ 170 .Case(#Name, OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name) 171 #include "clang/Basic/OpenMPKinds.def" 172 .Default(OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown); 173 case OMPC_device_type: 174 return llvm::StringSwitch<OpenMPDeviceType>(Str) 175 #define OPENMP_DEVICE_TYPE_KIND(Name) .Case(#Name, OMPC_DEVICE_TYPE_##Name) 176 #include "clang/Basic/OpenMPKinds.def" 177 .Default(OMPC_DEVICE_TYPE_unknown); 178 case OMPC_lastprivate: 179 return llvm::StringSwitch<OpenMPLastprivateModifier>(Str) 180 #define OPENMP_LASTPRIVATE_KIND(Name) .Case(#Name, OMPC_LASTPRIVATE_##Name) 181 #include "clang/Basic/OpenMPKinds.def" 182 .Default(OMPC_LASTPRIVATE_unknown); 183 case OMPC_unknown: 184 case OMPC_threadprivate: 185 case OMPC_if: 186 case OMPC_final: 187 case OMPC_num_threads: 188 case OMPC_safelen: 189 case OMPC_simdlen: 190 case OMPC_allocator: 191 case OMPC_allocate: 192 case OMPC_collapse: 193 case OMPC_private: 194 case OMPC_firstprivate: 195 case OMPC_shared: 196 case OMPC_reduction: 197 case OMPC_task_reduction: 198 case OMPC_in_reduction: 199 case OMPC_aligned: 200 case OMPC_copyin: 201 case OMPC_copyprivate: 202 case OMPC_ordered: 203 case OMPC_nowait: 204 case OMPC_untied: 205 case OMPC_mergeable: 206 case OMPC_flush: 207 case OMPC_read: 208 case OMPC_write: 209 case OMPC_update: 210 case OMPC_capture: 211 case OMPC_seq_cst: 212 case OMPC_device: 213 case OMPC_threads: 214 case OMPC_simd: 215 case OMPC_num_teams: 216 case OMPC_thread_limit: 217 case OMPC_priority: 218 case OMPC_grainsize: 219 case OMPC_nogroup: 220 case OMPC_num_tasks: 221 case OMPC_hint: 222 case OMPC_uniform: 223 case OMPC_use_device_ptr: 224 case OMPC_is_device_ptr: 225 case OMPC_unified_address: 226 case OMPC_unified_shared_memory: 227 case OMPC_reverse_offload: 228 case OMPC_dynamic_allocators: 229 case OMPC_match: 230 case OMPC_nontemporal: 231 break; 232 } 233 llvm_unreachable("Invalid OpenMP simple clause kind"); 234 } 235 236 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, 237 unsigned Type) { 238 switch (Kind) { 239 case OMPC_default: 240 switch (Type) { 241 case OMPC_DEFAULT_unknown: 242 return "unknown"; 243 #define OPENMP_DEFAULT_KIND(Name) \ 244 case OMPC_DEFAULT_##Name: \ 245 return #Name; 246 #include "clang/Basic/OpenMPKinds.def" 247 } 248 llvm_unreachable("Invalid OpenMP 'default' clause type"); 249 case OMPC_proc_bind: 250 switch (Type) { 251 #define OMP_PROC_BIND_KIND(Enum, Name, Value) \ 252 case Value: \ 253 return Name; 254 #include "llvm/Frontend/OpenMP/OMPKinds.def" 255 } 256 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type"); 257 case OMPC_schedule: 258 switch (Type) { 259 case OMPC_SCHEDULE_unknown: 260 case OMPC_SCHEDULE_MODIFIER_last: 261 return "unknown"; 262 #define OPENMP_SCHEDULE_KIND(Name) \ 263 case OMPC_SCHEDULE_##Name: \ 264 return #Name; 265 #define OPENMP_SCHEDULE_MODIFIER(Name) \ 266 case OMPC_SCHEDULE_MODIFIER_##Name: \ 267 return #Name; 268 #include "clang/Basic/OpenMPKinds.def" 269 } 270 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 271 case OMPC_depend: 272 switch (Type) { 273 case OMPC_DEPEND_unknown: 274 return "unknown"; 275 #define OPENMP_DEPEND_KIND(Name) \ 276 case OMPC_DEPEND_##Name: \ 277 return #Name; 278 #include "clang/Basic/OpenMPKinds.def" 279 } 280 llvm_unreachable("Invalid OpenMP 'depend' clause type"); 281 case OMPC_linear: 282 switch (Type) { 283 case OMPC_LINEAR_unknown: 284 return "unknown"; 285 #define OPENMP_LINEAR_KIND(Name) \ 286 case OMPC_LINEAR_##Name: \ 287 return #Name; 288 #include "clang/Basic/OpenMPKinds.def" 289 } 290 llvm_unreachable("Invalid OpenMP 'linear' clause type"); 291 case OMPC_map: 292 switch (Type) { 293 case OMPC_MAP_unknown: 294 case OMPC_MAP_MODIFIER_last: 295 return "unknown"; 296 #define OPENMP_MAP_KIND(Name) \ 297 case OMPC_MAP_##Name: \ 298 return #Name; 299 #define OPENMP_MAP_MODIFIER_KIND(Name) \ 300 case OMPC_MAP_MODIFIER_##Name: \ 301 return #Name; 302 #include "clang/Basic/OpenMPKinds.def" 303 default: 304 break; 305 } 306 llvm_unreachable("Invalid OpenMP 'map' clause type"); 307 case OMPC_to: 308 switch (Type) { 309 case OMPC_TO_MODIFIER_unknown: 310 return "unknown"; 311 #define OPENMP_TO_MODIFIER_KIND(Name) \ 312 case OMPC_TO_MODIFIER_##Name: \ 313 return #Name; 314 #include "clang/Basic/OpenMPKinds.def" 315 default: 316 break; 317 } 318 llvm_unreachable("Invalid OpenMP 'to' clause type"); 319 case OMPC_from: 320 switch (Type) { 321 case OMPC_FROM_MODIFIER_unknown: 322 return "unknown"; 323 #define OPENMP_FROM_MODIFIER_KIND(Name) \ 324 case OMPC_FROM_MODIFIER_##Name: \ 325 return #Name; 326 #include "clang/Basic/OpenMPKinds.def" 327 default: 328 break; 329 } 330 llvm_unreachable("Invalid OpenMP 'from' clause type"); 331 case OMPC_dist_schedule: 332 switch (Type) { 333 case OMPC_DIST_SCHEDULE_unknown: 334 return "unknown"; 335 #define OPENMP_DIST_SCHEDULE_KIND(Name) \ 336 case OMPC_DIST_SCHEDULE_##Name: \ 337 return #Name; 338 #include "clang/Basic/OpenMPKinds.def" 339 } 340 llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type"); 341 case OMPC_defaultmap: 342 switch (Type) { 343 case OMPC_DEFAULTMAP_unknown: 344 case OMPC_DEFAULTMAP_MODIFIER_last: 345 return "unknown"; 346 #define OPENMP_DEFAULTMAP_KIND(Name) \ 347 case OMPC_DEFAULTMAP_##Name: \ 348 return #Name; 349 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 350 case OMPC_DEFAULTMAP_MODIFIER_##Name: \ 351 return #Name; 352 #include "clang/Basic/OpenMPKinds.def" 353 } 354 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 355 case OMPC_atomic_default_mem_order: 356 switch (Type) { 357 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown: 358 return "unknown"; 359 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \ 360 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name: \ 361 return #Name; 362 #include "clang/Basic/OpenMPKinds.def" 363 } 364 llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type"); 365 case OMPC_device_type: 366 switch (Type) { 367 case OMPC_DEVICE_TYPE_unknown: 368 return "unknown"; 369 #define OPENMP_DEVICE_TYPE_KIND(Name) \ 370 case OMPC_DEVICE_TYPE_##Name: \ 371 return #Name; 372 #include "clang/Basic/OpenMPKinds.def" 373 } 374 llvm_unreachable("Invalid OpenMP 'device_type' clause type"); 375 case OMPC_lastprivate: 376 switch (Type) { 377 case OMPC_LASTPRIVATE_unknown: 378 return "unknown"; 379 #define OPENMP_LASTPRIVATE_KIND(Name) \ 380 case OMPC_LASTPRIVATE_##Name: \ 381 return #Name; 382 #include "clang/Basic/OpenMPKinds.def" 383 } 384 llvm_unreachable("Invalid OpenMP 'lastprivate' clause type"); 385 case OMPC_unknown: 386 case OMPC_threadprivate: 387 case OMPC_if: 388 case OMPC_final: 389 case OMPC_num_threads: 390 case OMPC_safelen: 391 case OMPC_simdlen: 392 case OMPC_allocator: 393 case OMPC_allocate: 394 case OMPC_collapse: 395 case OMPC_private: 396 case OMPC_firstprivate: 397 case OMPC_shared: 398 case OMPC_reduction: 399 case OMPC_task_reduction: 400 case OMPC_in_reduction: 401 case OMPC_aligned: 402 case OMPC_copyin: 403 case OMPC_copyprivate: 404 case OMPC_ordered: 405 case OMPC_nowait: 406 case OMPC_untied: 407 case OMPC_mergeable: 408 case OMPC_flush: 409 case OMPC_read: 410 case OMPC_write: 411 case OMPC_update: 412 case OMPC_capture: 413 case OMPC_seq_cst: 414 case OMPC_device: 415 case OMPC_threads: 416 case OMPC_simd: 417 case OMPC_num_teams: 418 case OMPC_thread_limit: 419 case OMPC_priority: 420 case OMPC_grainsize: 421 case OMPC_nogroup: 422 case OMPC_num_tasks: 423 case OMPC_hint: 424 case OMPC_uniform: 425 case OMPC_use_device_ptr: 426 case OMPC_is_device_ptr: 427 case OMPC_unified_address: 428 case OMPC_unified_shared_memory: 429 case OMPC_reverse_offload: 430 case OMPC_dynamic_allocators: 431 case OMPC_match: 432 case OMPC_nontemporal: 433 break; 434 } 435 llvm_unreachable("Invalid OpenMP simple clause kind"); 436 } 437 438 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind, 439 OpenMPClauseKind CKind, 440 unsigned OpenMPVersion) { 441 assert(unsigned(DKind) <= unsigned(OMPD_unknown)); 442 assert(CKind <= OMPC_unknown); 443 // Nontemporal clause is not supported in OpenMP < 5.0. 444 if (OpenMPVersion < 50 && CKind == OMPC_nontemporal) 445 return false; 446 switch (DKind) { 447 case OMPD_parallel: 448 switch (CKind) { 449 #define OPENMP_PARALLEL_CLAUSE(Name) \ 450 case OMPC_##Name: \ 451 return true; 452 #include "clang/Basic/OpenMPKinds.def" 453 default: 454 break; 455 } 456 break; 457 case OMPD_simd: 458 if (OpenMPVersion < 50 && CKind == OMPC_if) 459 return false; 460 switch (CKind) { 461 #define OPENMP_SIMD_CLAUSE(Name) \ 462 case OMPC_##Name: \ 463 return true; 464 #include "clang/Basic/OpenMPKinds.def" 465 default: 466 break; 467 } 468 break; 469 case OMPD_for: 470 switch (CKind) { 471 #define OPENMP_FOR_CLAUSE(Name) \ 472 case OMPC_##Name: \ 473 return true; 474 #include "clang/Basic/OpenMPKinds.def" 475 default: 476 break; 477 } 478 break; 479 case OMPD_for_simd: 480 if (OpenMPVersion < 50 && CKind == OMPC_if) 481 return false; 482 switch (CKind) { 483 #define OPENMP_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_sections: 492 switch (CKind) { 493 #define OPENMP_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_single: 502 switch (CKind) { 503 #define OPENMP_SINGLE_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_parallel_for: 512 switch (CKind) { 513 #define OPENMP_PARALLEL_FOR_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_parallel_for_simd: 522 switch (CKind) { 523 #define OPENMP_PARALLEL_FOR_SIMD_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_parallel_master: 532 switch (CKind) { 533 #define OPENMP_PARALLEL_MASTER_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_parallel_sections: 542 switch (CKind) { 543 #define OPENMP_PARALLEL_SECTIONS_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_task: 552 switch (CKind) { 553 #define OPENMP_TASK_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_flush: 562 return CKind == OMPC_flush; 563 break; 564 case OMPD_atomic: 565 switch (CKind) { 566 #define OPENMP_ATOMIC_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: 575 switch (CKind) { 576 #define OPENMP_TARGET_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_requires: 585 switch (CKind) { 586 #define OPENMP_REQUIRES_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_data: 595 switch (CKind) { 596 #define OPENMP_TARGET_DATA_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_target_enter_data: 605 switch (CKind) { 606 #define OPENMP_TARGET_ENTER_DATA_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_target_exit_data: 615 switch (CKind) { 616 #define OPENMP_TARGET_EXIT_DATA_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_target_parallel: 625 switch (CKind) { 626 #define OPENMP_TARGET_PARALLEL_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_target_parallel_for: 635 switch (CKind) { 636 #define OPENMP_TARGET_PARALLEL_FOR_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_target_update: 645 switch (CKind) { 646 #define OPENMP_TARGET_UPDATE_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_teams: 655 switch (CKind) { 656 #define OPENMP_TEAMS_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_cancel: 665 switch (CKind) { 666 #define OPENMP_CANCEL_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_ordered: 675 switch (CKind) { 676 #define OPENMP_ORDERED_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_taskloop: 685 switch (CKind) { 686 #define OPENMP_TASKLOOP_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_taskloop_simd: 695 switch (CKind) { 696 #define OPENMP_TASKLOOP_SIMD_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_master_taskloop: 705 switch (CKind) { 706 #define OPENMP_MASTER_TASKLOOP_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_master_taskloop_simd: 715 switch (CKind) { 716 #define OPENMP_MASTER_TASKLOOP_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_parallel_master_taskloop: 725 switch (CKind) { 726 #define OPENMP_PARALLEL_MASTER_TASKLOOP_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_parallel_master_taskloop_simd: 735 switch (CKind) { 736 #define OPENMP_PARALLEL_MASTER_TASKLOOP_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_critical: 745 switch (CKind) { 746 #define OPENMP_CRITICAL_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_distribute: 755 switch (CKind) { 756 #define OPENMP_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_distribute_parallel_for: 765 switch (CKind) { 766 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_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_distribute_parallel_for_simd: 775 switch (CKind) { 776 #define OPENMP_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_distribute_simd: 785 if (OpenMPVersion < 50 && CKind == OMPC_if) 786 return false; 787 switch (CKind) { 788 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) \ 789 case OMPC_##Name: \ 790 return true; 791 #include "clang/Basic/OpenMPKinds.def" 792 default: 793 break; 794 } 795 break; 796 case OMPD_target_parallel_for_simd: 797 switch (CKind) { 798 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 799 case OMPC_##Name: \ 800 return true; 801 #include "clang/Basic/OpenMPKinds.def" 802 default: 803 break; 804 } 805 break; 806 case OMPD_target_simd: 807 switch (CKind) { 808 #define OPENMP_TARGET_SIMD_CLAUSE(Name) \ 809 case OMPC_##Name: \ 810 return true; 811 #include "clang/Basic/OpenMPKinds.def" 812 default: 813 break; 814 } 815 break; 816 case OMPD_teams_distribute: 817 switch (CKind) { 818 #define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name) \ 819 case OMPC_##Name: \ 820 return true; 821 #include "clang/Basic/OpenMPKinds.def" 822 default: 823 break; 824 } 825 break; 826 case OMPD_teams_distribute_simd: 827 if (OpenMPVersion < 50 && CKind == OMPC_if) 828 return false; 829 switch (CKind) { 830 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \ 831 case OMPC_##Name: \ 832 return true; 833 #include "clang/Basic/OpenMPKinds.def" 834 default: 835 break; 836 } 837 break; 838 case OMPD_teams_distribute_parallel_for_simd: 839 switch (CKind) { 840 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 841 case OMPC_##Name: \ 842 return true; 843 #include "clang/Basic/OpenMPKinds.def" 844 default: 845 break; 846 } 847 break; 848 case OMPD_teams_distribute_parallel_for: 849 switch (CKind) { 850 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 851 case OMPC_##Name: \ 852 return true; 853 #include "clang/Basic/OpenMPKinds.def" 854 default: 855 break; 856 } 857 break; 858 case OMPD_target_teams: 859 switch (CKind) { 860 #define OPENMP_TARGET_TEAMS_CLAUSE(Name) \ 861 case OMPC_##Name: \ 862 return true; 863 #include "clang/Basic/OpenMPKinds.def" 864 default: 865 break; 866 } 867 break; 868 case OMPD_target_teams_distribute: 869 switch (CKind) { 870 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name) \ 871 case OMPC_##Name: \ 872 return true; 873 #include "clang/Basic/OpenMPKinds.def" 874 default: 875 break; 876 } 877 break; 878 case OMPD_target_teams_distribute_parallel_for: 879 switch (CKind) { 880 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 881 case OMPC_##Name: \ 882 return true; 883 #include "clang/Basic/OpenMPKinds.def" 884 default: 885 break; 886 } 887 break; 888 case OMPD_target_teams_distribute_parallel_for_simd: 889 switch (CKind) { 890 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 891 case OMPC_##Name: \ 892 return true; 893 #include "clang/Basic/OpenMPKinds.def" 894 default: 895 break; 896 } 897 break; 898 case OMPD_target_teams_distribute_simd: 899 switch (CKind) { 900 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \ 901 case OMPC_##Name: \ 902 return true; 903 #include "clang/Basic/OpenMPKinds.def" 904 default: 905 break; 906 } 907 break; 908 case OMPD_taskgroup: 909 switch (CKind) { 910 #define OPENMP_TASKGROUP_CLAUSE(Name) \ 911 case OMPC_##Name: \ 912 return true; 913 #include "clang/Basic/OpenMPKinds.def" 914 default: 915 break; 916 } 917 break; 918 case OMPD_declare_mapper: 919 switch (CKind) { 920 #define OPENMP_DECLARE_MAPPER_CLAUSE(Name) \ 921 case OMPC_##Name: \ 922 return true; 923 #include "clang/Basic/OpenMPKinds.def" 924 default: 925 break; 926 } 927 break; 928 case OMPD_allocate: 929 switch (CKind) { 930 #define OPENMP_ALLOCATE_CLAUSE(Name) \ 931 case OMPC_##Name: \ 932 return true; 933 #include "clang/Basic/OpenMPKinds.def" 934 default: 935 break; 936 } 937 break; 938 case OMPD_declare_variant: 939 switch (CKind) { 940 #define OPENMP_DECLARE_VARIANT_CLAUSE(Name) \ 941 case OMPC_##Name: \ 942 return true; 943 #include "clang/Basic/OpenMPKinds.def" 944 default: 945 break; 946 } 947 break; 948 case OMPD_declare_target: 949 case OMPD_end_declare_target: 950 case OMPD_unknown: 951 case OMPD_threadprivate: 952 case OMPD_section: 953 case OMPD_master: 954 case OMPD_taskyield: 955 case OMPD_barrier: 956 case OMPD_taskwait: 957 case OMPD_cancellation_point: 958 case OMPD_declare_reduction: 959 case OMPD_declare_simd: 960 break; 961 } 962 return false; 963 } 964 965 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) { 966 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd || 967 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd || 968 DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 969 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 970 DKind == OMPD_parallel_master_taskloop || 971 DKind == OMPD_parallel_master_taskloop_simd || 972 DKind == OMPD_distribute || DKind == OMPD_target_parallel_for || 973 DKind == OMPD_distribute_parallel_for || 974 DKind == OMPD_distribute_parallel_for_simd || 975 DKind == OMPD_distribute_simd || 976 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 977 DKind == OMPD_teams_distribute || 978 DKind == OMPD_teams_distribute_simd || 979 DKind == OMPD_teams_distribute_parallel_for_simd || 980 DKind == OMPD_teams_distribute_parallel_for || 981 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::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { 988 return DKind == OMPD_for || DKind == OMPD_for_simd || 989 DKind == OMPD_sections || DKind == OMPD_section || 990 DKind == OMPD_single || DKind == OMPD_parallel_for || 991 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 992 DKind == OMPD_target_parallel_for || 993 DKind == OMPD_distribute_parallel_for || 994 DKind == OMPD_distribute_parallel_for_simd || 995 DKind == OMPD_target_parallel_for_simd || 996 DKind == OMPD_teams_distribute_parallel_for_simd || 997 DKind == OMPD_teams_distribute_parallel_for || 998 DKind == OMPD_target_teams_distribute_parallel_for || 999 DKind == OMPD_target_teams_distribute_parallel_for_simd; 1000 } 1001 1002 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) { 1003 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 1004 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 1005 DKind == OMPD_parallel_master_taskloop || 1006 DKind == OMPD_parallel_master_taskloop_simd; 1007 } 1008 1009 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) { 1010 return DKind == OMPD_parallel || DKind == OMPD_parallel_for || 1011 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 1012 DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for || 1013 DKind == OMPD_distribute_parallel_for || 1014 DKind == OMPD_distribute_parallel_for_simd || 1015 DKind == OMPD_target_parallel_for_simd || 1016 DKind == OMPD_teams_distribute_parallel_for || 1017 DKind == OMPD_teams_distribute_parallel_for_simd || 1018 DKind == OMPD_target_teams_distribute_parallel_for || 1019 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1020 DKind == OMPD_parallel_master || 1021 DKind == OMPD_parallel_master_taskloop || 1022 DKind == OMPD_parallel_master_taskloop_simd; 1023 } 1024 1025 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) { 1026 return DKind == OMPD_target || DKind == OMPD_target_parallel || 1027 DKind == OMPD_target_parallel_for || 1028 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 1029 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 1030 DKind == OMPD_target_teams_distribute_parallel_for || 1031 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1032 DKind == OMPD_target_teams_distribute_simd; 1033 } 1034 1035 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) { 1036 return DKind == OMPD_target_data || DKind == OMPD_target_enter_data || 1037 DKind == OMPD_target_exit_data || DKind == OMPD_target_update; 1038 } 1039 1040 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) { 1041 return DKind == OMPD_teams || DKind == OMPD_teams_distribute || 1042 DKind == OMPD_teams_distribute_simd || 1043 DKind == OMPD_teams_distribute_parallel_for_simd || 1044 DKind == OMPD_teams_distribute_parallel_for; 1045 } 1046 1047 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) { 1048 return isOpenMPNestingTeamsDirective(DKind) || 1049 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 1050 DKind == OMPD_target_teams_distribute_parallel_for || 1051 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1052 DKind == OMPD_target_teams_distribute_simd; 1053 } 1054 1055 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) { 1056 return DKind == OMPD_simd || DKind == OMPD_for_simd || 1057 DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd || 1058 DKind == OMPD_master_taskloop_simd || 1059 DKind == OMPD_parallel_master_taskloop_simd || 1060 DKind == OMPD_distribute_parallel_for_simd || 1061 DKind == OMPD_distribute_simd || DKind == OMPD_target_simd || 1062 DKind == OMPD_teams_distribute_simd || 1063 DKind == OMPD_teams_distribute_parallel_for_simd || 1064 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1065 DKind == OMPD_target_teams_distribute_simd || 1066 DKind == OMPD_target_parallel_for_simd; 1067 } 1068 1069 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) { 1070 return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for || 1071 Kind == OMPD_distribute_parallel_for_simd || 1072 Kind == OMPD_distribute_simd; 1073 // TODO add next directives. 1074 } 1075 1076 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) { 1077 return isOpenMPNestingDistributeDirective(Kind) || 1078 Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd || 1079 Kind == OMPD_teams_distribute_parallel_for_simd || 1080 Kind == OMPD_teams_distribute_parallel_for || 1081 Kind == OMPD_target_teams_distribute || 1082 Kind == OMPD_target_teams_distribute_parallel_for || 1083 Kind == OMPD_target_teams_distribute_parallel_for_simd || 1084 Kind == OMPD_target_teams_distribute_simd; 1085 } 1086 1087 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) { 1088 return Kind == OMPC_private || Kind == OMPC_firstprivate || 1089 Kind == OMPC_lastprivate || Kind == OMPC_linear || 1090 Kind == OMPC_reduction || Kind == OMPC_task_reduction || 1091 Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'. 1092 } 1093 1094 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) { 1095 return Kind == OMPC_threadprivate || Kind == OMPC_copyin; 1096 } 1097 1098 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) { 1099 return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind); 1100 } 1101 1102 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) { 1103 return Kind == OMPD_distribute_parallel_for || 1104 Kind == OMPD_distribute_parallel_for_simd || 1105 Kind == OMPD_teams_distribute_parallel_for_simd || 1106 Kind == OMPD_teams_distribute_parallel_for || 1107 Kind == OMPD_target_teams_distribute_parallel_for || 1108 Kind == OMPD_target_teams_distribute_parallel_for_simd; 1109 } 1110 1111 void clang::getOpenMPCaptureRegions( 1112 SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions, 1113 OpenMPDirectiveKind DKind) { 1114 assert(DKind <= OMPD_unknown); 1115 switch (DKind) { 1116 case OMPD_parallel: 1117 case OMPD_parallel_for: 1118 case OMPD_parallel_for_simd: 1119 case OMPD_parallel_master: 1120 case OMPD_parallel_sections: 1121 case OMPD_distribute_parallel_for: 1122 case OMPD_distribute_parallel_for_simd: 1123 CaptureRegions.push_back(OMPD_parallel); 1124 break; 1125 case OMPD_target_teams: 1126 case OMPD_target_teams_distribute: 1127 case OMPD_target_teams_distribute_simd: 1128 CaptureRegions.push_back(OMPD_task); 1129 CaptureRegions.push_back(OMPD_target); 1130 CaptureRegions.push_back(OMPD_teams); 1131 break; 1132 case OMPD_teams: 1133 case OMPD_teams_distribute: 1134 case OMPD_teams_distribute_simd: 1135 CaptureRegions.push_back(OMPD_teams); 1136 break; 1137 case OMPD_target: 1138 case OMPD_target_simd: 1139 CaptureRegions.push_back(OMPD_task); 1140 CaptureRegions.push_back(OMPD_target); 1141 break; 1142 case OMPD_teams_distribute_parallel_for: 1143 case OMPD_teams_distribute_parallel_for_simd: 1144 CaptureRegions.push_back(OMPD_teams); 1145 CaptureRegions.push_back(OMPD_parallel); 1146 break; 1147 case OMPD_target_parallel: 1148 case OMPD_target_parallel_for: 1149 case OMPD_target_parallel_for_simd: 1150 CaptureRegions.push_back(OMPD_task); 1151 CaptureRegions.push_back(OMPD_target); 1152 CaptureRegions.push_back(OMPD_parallel); 1153 break; 1154 case OMPD_task: 1155 case OMPD_target_enter_data: 1156 case OMPD_target_exit_data: 1157 case OMPD_target_update: 1158 CaptureRegions.push_back(OMPD_task); 1159 break; 1160 case OMPD_taskloop: 1161 case OMPD_taskloop_simd: 1162 case OMPD_master_taskloop: 1163 case OMPD_master_taskloop_simd: 1164 CaptureRegions.push_back(OMPD_taskloop); 1165 break; 1166 case OMPD_parallel_master_taskloop: 1167 case OMPD_parallel_master_taskloop_simd: 1168 CaptureRegions.push_back(OMPD_parallel); 1169 CaptureRegions.push_back(OMPD_taskloop); 1170 break; 1171 case OMPD_target_teams_distribute_parallel_for: 1172 case OMPD_target_teams_distribute_parallel_for_simd: 1173 CaptureRegions.push_back(OMPD_task); 1174 CaptureRegions.push_back(OMPD_target); 1175 CaptureRegions.push_back(OMPD_teams); 1176 CaptureRegions.push_back(OMPD_parallel); 1177 break; 1178 case OMPD_simd: 1179 case OMPD_for: 1180 case OMPD_for_simd: 1181 case OMPD_sections: 1182 case OMPD_section: 1183 case OMPD_single: 1184 case OMPD_master: 1185 case OMPD_critical: 1186 case OMPD_taskgroup: 1187 case OMPD_distribute: 1188 case OMPD_ordered: 1189 case OMPD_atomic: 1190 case OMPD_target_data: 1191 case OMPD_distribute_simd: 1192 CaptureRegions.push_back(OMPD_unknown); 1193 break; 1194 case OMPD_threadprivate: 1195 case OMPD_allocate: 1196 case OMPD_taskyield: 1197 case OMPD_barrier: 1198 case OMPD_taskwait: 1199 case OMPD_cancellation_point: 1200 case OMPD_cancel: 1201 case OMPD_flush: 1202 case OMPD_declare_reduction: 1203 case OMPD_declare_mapper: 1204 case OMPD_declare_simd: 1205 case OMPD_declare_target: 1206 case OMPD_end_declare_target: 1207 case OMPD_requires: 1208 case OMPD_declare_variant: 1209 llvm_unreachable("OpenMP Directive is not allowed"); 1210 case OMPD_unknown: 1211 llvm_unreachable("Unknown OpenMP directive"); 1212 } 1213 } 1214