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<OpenMPProcBindClauseKind>(Str) 113 #define OPENMP_PROC_BIND_KIND(Name) .Case(#Name, OMPC_PROC_BIND_##Name) 114 #include "clang/Basic/OpenMPKinds.def" 115 .Default(OMPC_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 case OMPC_PROC_BIND_unknown: 252 return "unknown"; 253 #define OPENMP_PROC_BIND_KIND(Name) \ 254 case OMPC_PROC_BIND_##Name: \ 255 return #Name; 256 #include "clang/Basic/OpenMPKinds.def" 257 } 258 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type"); 259 case OMPC_schedule: 260 switch (Type) { 261 case OMPC_SCHEDULE_unknown: 262 case OMPC_SCHEDULE_MODIFIER_last: 263 return "unknown"; 264 #define OPENMP_SCHEDULE_KIND(Name) \ 265 case OMPC_SCHEDULE_##Name: \ 266 return #Name; 267 #define OPENMP_SCHEDULE_MODIFIER(Name) \ 268 case OMPC_SCHEDULE_MODIFIER_##Name: \ 269 return #Name; 270 #include "clang/Basic/OpenMPKinds.def" 271 } 272 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 273 case OMPC_depend: 274 switch (Type) { 275 case OMPC_DEPEND_unknown: 276 return "unknown"; 277 #define OPENMP_DEPEND_KIND(Name) \ 278 case OMPC_DEPEND_##Name: \ 279 return #Name; 280 #include "clang/Basic/OpenMPKinds.def" 281 } 282 llvm_unreachable("Invalid OpenMP 'depend' clause type"); 283 case OMPC_linear: 284 switch (Type) { 285 case OMPC_LINEAR_unknown: 286 return "unknown"; 287 #define OPENMP_LINEAR_KIND(Name) \ 288 case OMPC_LINEAR_##Name: \ 289 return #Name; 290 #include "clang/Basic/OpenMPKinds.def" 291 } 292 llvm_unreachable("Invalid OpenMP 'linear' clause type"); 293 case OMPC_map: 294 switch (Type) { 295 case OMPC_MAP_unknown: 296 case OMPC_MAP_MODIFIER_last: 297 return "unknown"; 298 #define OPENMP_MAP_KIND(Name) \ 299 case OMPC_MAP_##Name: \ 300 return #Name; 301 #define OPENMP_MAP_MODIFIER_KIND(Name) \ 302 case OMPC_MAP_MODIFIER_##Name: \ 303 return #Name; 304 #include "clang/Basic/OpenMPKinds.def" 305 default: 306 break; 307 } 308 llvm_unreachable("Invalid OpenMP 'map' clause type"); 309 case OMPC_to: 310 switch (Type) { 311 case OMPC_TO_MODIFIER_unknown: 312 return "unknown"; 313 #define OPENMP_TO_MODIFIER_KIND(Name) \ 314 case OMPC_TO_MODIFIER_##Name: \ 315 return #Name; 316 #include "clang/Basic/OpenMPKinds.def" 317 default: 318 break; 319 } 320 llvm_unreachable("Invalid OpenMP 'to' clause type"); 321 case OMPC_from: 322 switch (Type) { 323 case OMPC_FROM_MODIFIER_unknown: 324 return "unknown"; 325 #define OPENMP_FROM_MODIFIER_KIND(Name) \ 326 case OMPC_FROM_MODIFIER_##Name: \ 327 return #Name; 328 #include "clang/Basic/OpenMPKinds.def" 329 default: 330 break; 331 } 332 llvm_unreachable("Invalid OpenMP 'from' clause type"); 333 case OMPC_dist_schedule: 334 switch (Type) { 335 case OMPC_DIST_SCHEDULE_unknown: 336 return "unknown"; 337 #define OPENMP_DIST_SCHEDULE_KIND(Name) \ 338 case OMPC_DIST_SCHEDULE_##Name: \ 339 return #Name; 340 #include "clang/Basic/OpenMPKinds.def" 341 } 342 llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type"); 343 case OMPC_defaultmap: 344 switch (Type) { 345 case OMPC_DEFAULTMAP_unknown: 346 case OMPC_DEFAULTMAP_MODIFIER_last: 347 return "unknown"; 348 #define OPENMP_DEFAULTMAP_KIND(Name) \ 349 case OMPC_DEFAULTMAP_##Name: \ 350 return #Name; 351 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 352 case OMPC_DEFAULTMAP_MODIFIER_##Name: \ 353 return #Name; 354 #include "clang/Basic/OpenMPKinds.def" 355 } 356 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 357 case OMPC_atomic_default_mem_order: 358 switch (Type) { 359 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown: 360 return "unknown"; 361 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \ 362 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name: \ 363 return #Name; 364 #include "clang/Basic/OpenMPKinds.def" 365 } 366 llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type"); 367 case OMPC_device_type: 368 switch (Type) { 369 case OMPC_DEVICE_TYPE_unknown: 370 return "unknown"; 371 #define OPENMP_DEVICE_TYPE_KIND(Name) \ 372 case OMPC_DEVICE_TYPE_##Name: \ 373 return #Name; 374 #include "clang/Basic/OpenMPKinds.def" 375 } 376 llvm_unreachable("Invalid OpenMP 'device_type' clause type"); 377 case OMPC_lastprivate: 378 switch (Type) { 379 case OMPC_LASTPRIVATE_unknown: 380 return "unknown"; 381 #define OPENMP_LASTPRIVATE_KIND(Name) \ 382 case OMPC_LASTPRIVATE_##Name: \ 383 return #Name; 384 #include "clang/Basic/OpenMPKinds.def" 385 } 386 llvm_unreachable("Invalid OpenMP 'lastprivate' clause type"); 387 case OMPC_unknown: 388 case OMPC_threadprivate: 389 case OMPC_if: 390 case OMPC_final: 391 case OMPC_num_threads: 392 case OMPC_safelen: 393 case OMPC_simdlen: 394 case OMPC_allocator: 395 case OMPC_allocate: 396 case OMPC_collapse: 397 case OMPC_private: 398 case OMPC_firstprivate: 399 case OMPC_shared: 400 case OMPC_reduction: 401 case OMPC_task_reduction: 402 case OMPC_in_reduction: 403 case OMPC_aligned: 404 case OMPC_copyin: 405 case OMPC_copyprivate: 406 case OMPC_ordered: 407 case OMPC_nowait: 408 case OMPC_untied: 409 case OMPC_mergeable: 410 case OMPC_flush: 411 case OMPC_read: 412 case OMPC_write: 413 case OMPC_update: 414 case OMPC_capture: 415 case OMPC_seq_cst: 416 case OMPC_device: 417 case OMPC_threads: 418 case OMPC_simd: 419 case OMPC_num_teams: 420 case OMPC_thread_limit: 421 case OMPC_priority: 422 case OMPC_grainsize: 423 case OMPC_nogroup: 424 case OMPC_num_tasks: 425 case OMPC_hint: 426 case OMPC_uniform: 427 case OMPC_use_device_ptr: 428 case OMPC_is_device_ptr: 429 case OMPC_unified_address: 430 case OMPC_unified_shared_memory: 431 case OMPC_reverse_offload: 432 case OMPC_dynamic_allocators: 433 case OMPC_match: 434 case OMPC_nontemporal: 435 break; 436 } 437 llvm_unreachable("Invalid OpenMP simple clause kind"); 438 } 439 440 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind, 441 OpenMPClauseKind CKind, 442 unsigned OpenMPVersion) { 443 assert(unsigned(DKind) <= unsigned(OMPD_unknown)); 444 assert(CKind <= OMPC_unknown); 445 // Nontemporal clause is not supported in OpenMP < 5.0. 446 if (OpenMPVersion < 50 && CKind == OMPC_nontemporal) 447 return false; 448 switch (DKind) { 449 case OMPD_parallel: 450 switch (CKind) { 451 #define OPENMP_PARALLEL_CLAUSE(Name) \ 452 case OMPC_##Name: \ 453 return true; 454 #include "clang/Basic/OpenMPKinds.def" 455 default: 456 break; 457 } 458 break; 459 case OMPD_simd: 460 if (OpenMPVersion < 50 && CKind == OMPC_if) 461 return false; 462 switch (CKind) { 463 #define OPENMP_SIMD_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_for: 472 switch (CKind) { 473 #define OPENMP_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_for_simd: 482 if (OpenMPVersion < 50 && CKind == OMPC_if) 483 return false; 484 switch (CKind) { 485 #define OPENMP_FOR_SIMD_CLAUSE(Name) \ 486 case OMPC_##Name: \ 487 return true; 488 #include "clang/Basic/OpenMPKinds.def" 489 default: 490 break; 491 } 492 break; 493 case OMPD_sections: 494 switch (CKind) { 495 #define OPENMP_SECTIONS_CLAUSE(Name) \ 496 case OMPC_##Name: \ 497 return true; 498 #include "clang/Basic/OpenMPKinds.def" 499 default: 500 break; 501 } 502 break; 503 case OMPD_single: 504 switch (CKind) { 505 #define OPENMP_SINGLE_CLAUSE(Name) \ 506 case OMPC_##Name: \ 507 return true; 508 #include "clang/Basic/OpenMPKinds.def" 509 default: 510 break; 511 } 512 break; 513 case OMPD_parallel_for: 514 switch (CKind) { 515 #define OPENMP_PARALLEL_FOR_CLAUSE(Name) \ 516 case OMPC_##Name: \ 517 return true; 518 #include "clang/Basic/OpenMPKinds.def" 519 default: 520 break; 521 } 522 break; 523 case OMPD_parallel_for_simd: 524 switch (CKind) { 525 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 526 case OMPC_##Name: \ 527 return true; 528 #include "clang/Basic/OpenMPKinds.def" 529 default: 530 break; 531 } 532 break; 533 case OMPD_parallel_master: 534 switch (CKind) { 535 #define OPENMP_PARALLEL_MASTER_CLAUSE(Name) \ 536 case OMPC_##Name: \ 537 return true; 538 #include "clang/Basic/OpenMPKinds.def" 539 default: 540 break; 541 } 542 break; 543 case OMPD_parallel_sections: 544 switch (CKind) { 545 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) \ 546 case OMPC_##Name: \ 547 return true; 548 #include "clang/Basic/OpenMPKinds.def" 549 default: 550 break; 551 } 552 break; 553 case OMPD_task: 554 switch (CKind) { 555 #define OPENMP_TASK_CLAUSE(Name) \ 556 case OMPC_##Name: \ 557 return true; 558 #include "clang/Basic/OpenMPKinds.def" 559 default: 560 break; 561 } 562 break; 563 case OMPD_flush: 564 return CKind == OMPC_flush; 565 break; 566 case OMPD_atomic: 567 switch (CKind) { 568 #define OPENMP_ATOMIC_CLAUSE(Name) \ 569 case OMPC_##Name: \ 570 return true; 571 #include "clang/Basic/OpenMPKinds.def" 572 default: 573 break; 574 } 575 break; 576 case OMPD_target: 577 switch (CKind) { 578 #define OPENMP_TARGET_CLAUSE(Name) \ 579 case OMPC_##Name: \ 580 return true; 581 #include "clang/Basic/OpenMPKinds.def" 582 default: 583 break; 584 } 585 break; 586 case OMPD_requires: 587 switch (CKind) { 588 #define OPENMP_REQUIRES_CLAUSE(Name) \ 589 case OMPC_##Name: \ 590 return true; 591 #include "clang/Basic/OpenMPKinds.def" 592 default: 593 break; 594 } 595 break; 596 case OMPD_target_data: 597 switch (CKind) { 598 #define OPENMP_TARGET_DATA_CLAUSE(Name) \ 599 case OMPC_##Name: \ 600 return true; 601 #include "clang/Basic/OpenMPKinds.def" 602 default: 603 break; 604 } 605 break; 606 case OMPD_target_enter_data: 607 switch (CKind) { 608 #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name) \ 609 case OMPC_##Name: \ 610 return true; 611 #include "clang/Basic/OpenMPKinds.def" 612 default: 613 break; 614 } 615 break; 616 case OMPD_target_exit_data: 617 switch (CKind) { 618 #define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name) \ 619 case OMPC_##Name: \ 620 return true; 621 #include "clang/Basic/OpenMPKinds.def" 622 default: 623 break; 624 } 625 break; 626 case OMPD_target_parallel: 627 switch (CKind) { 628 #define OPENMP_TARGET_PARALLEL_CLAUSE(Name) \ 629 case OMPC_##Name: \ 630 return true; 631 #include "clang/Basic/OpenMPKinds.def" 632 default: 633 break; 634 } 635 break; 636 case OMPD_target_parallel_for: 637 switch (CKind) { 638 #define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name) \ 639 case OMPC_##Name: \ 640 return true; 641 #include "clang/Basic/OpenMPKinds.def" 642 default: 643 break; 644 } 645 break; 646 case OMPD_target_update: 647 switch (CKind) { 648 #define OPENMP_TARGET_UPDATE_CLAUSE(Name) \ 649 case OMPC_##Name: \ 650 return true; 651 #include "clang/Basic/OpenMPKinds.def" 652 default: 653 break; 654 } 655 break; 656 case OMPD_teams: 657 switch (CKind) { 658 #define OPENMP_TEAMS_CLAUSE(Name) \ 659 case OMPC_##Name: \ 660 return true; 661 #include "clang/Basic/OpenMPKinds.def" 662 default: 663 break; 664 } 665 break; 666 case OMPD_cancel: 667 switch (CKind) { 668 #define OPENMP_CANCEL_CLAUSE(Name) \ 669 case OMPC_##Name: \ 670 return true; 671 #include "clang/Basic/OpenMPKinds.def" 672 default: 673 break; 674 } 675 break; 676 case OMPD_ordered: 677 switch (CKind) { 678 #define OPENMP_ORDERED_CLAUSE(Name) \ 679 case OMPC_##Name: \ 680 return true; 681 #include "clang/Basic/OpenMPKinds.def" 682 default: 683 break; 684 } 685 break; 686 case OMPD_taskloop: 687 switch (CKind) { 688 #define OPENMP_TASKLOOP_CLAUSE(Name) \ 689 case OMPC_##Name: \ 690 return true; 691 #include "clang/Basic/OpenMPKinds.def" 692 default: 693 break; 694 } 695 break; 696 case OMPD_taskloop_simd: 697 switch (CKind) { 698 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name) \ 699 case OMPC_##Name: \ 700 return true; 701 #include "clang/Basic/OpenMPKinds.def" 702 default: 703 break; 704 } 705 break; 706 case OMPD_master_taskloop: 707 switch (CKind) { 708 #define OPENMP_MASTER_TASKLOOP_CLAUSE(Name) \ 709 case OMPC_##Name: \ 710 return true; 711 #include "clang/Basic/OpenMPKinds.def" 712 default: 713 break; 714 } 715 break; 716 case OMPD_master_taskloop_simd: 717 switch (CKind) { 718 #define OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(Name) \ 719 case OMPC_##Name: \ 720 return true; 721 #include "clang/Basic/OpenMPKinds.def" 722 default: 723 break; 724 } 725 break; 726 case OMPD_parallel_master_taskloop: 727 switch (CKind) { 728 #define OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(Name) \ 729 case OMPC_##Name: \ 730 return true; 731 #include "clang/Basic/OpenMPKinds.def" 732 default: 733 break; 734 } 735 break; 736 case OMPD_parallel_master_taskloop_simd: 737 switch (CKind) { 738 #define OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(Name) \ 739 case OMPC_##Name: \ 740 return true; 741 #include "clang/Basic/OpenMPKinds.def" 742 default: 743 break; 744 } 745 break; 746 case OMPD_critical: 747 switch (CKind) { 748 #define OPENMP_CRITICAL_CLAUSE(Name) \ 749 case OMPC_##Name: \ 750 return true; 751 #include "clang/Basic/OpenMPKinds.def" 752 default: 753 break; 754 } 755 break; 756 case OMPD_distribute: 757 switch (CKind) { 758 #define OPENMP_DISTRIBUTE_CLAUSE(Name) \ 759 case OMPC_##Name: \ 760 return true; 761 #include "clang/Basic/OpenMPKinds.def" 762 default: 763 break; 764 } 765 break; 766 case OMPD_distribute_parallel_for: 767 switch (CKind) { 768 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 769 case OMPC_##Name: \ 770 return true; 771 #include "clang/Basic/OpenMPKinds.def" 772 default: 773 break; 774 } 775 break; 776 case OMPD_distribute_parallel_for_simd: 777 switch (CKind) { 778 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 779 case OMPC_##Name: \ 780 return true; 781 #include "clang/Basic/OpenMPKinds.def" 782 default: 783 break; 784 } 785 break; 786 case OMPD_distribute_simd: 787 if (OpenMPVersion < 50 && CKind == OMPC_if) 788 return false; 789 switch (CKind) { 790 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) \ 791 case OMPC_##Name: \ 792 return true; 793 #include "clang/Basic/OpenMPKinds.def" 794 default: 795 break; 796 } 797 break; 798 case OMPD_target_parallel_for_simd: 799 switch (CKind) { 800 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 801 case OMPC_##Name: \ 802 return true; 803 #include "clang/Basic/OpenMPKinds.def" 804 default: 805 break; 806 } 807 break; 808 case OMPD_target_simd: 809 switch (CKind) { 810 #define OPENMP_TARGET_SIMD_CLAUSE(Name) \ 811 case OMPC_##Name: \ 812 return true; 813 #include "clang/Basic/OpenMPKinds.def" 814 default: 815 break; 816 } 817 break; 818 case OMPD_teams_distribute: 819 switch (CKind) { 820 #define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name) \ 821 case OMPC_##Name: \ 822 return true; 823 #include "clang/Basic/OpenMPKinds.def" 824 default: 825 break; 826 } 827 break; 828 case OMPD_teams_distribute_simd: 829 if (OpenMPVersion < 50 && CKind == OMPC_if) 830 return false; 831 switch (CKind) { 832 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \ 833 case OMPC_##Name: \ 834 return true; 835 #include "clang/Basic/OpenMPKinds.def" 836 default: 837 break; 838 } 839 break; 840 case OMPD_teams_distribute_parallel_for_simd: 841 switch (CKind) { 842 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 843 case OMPC_##Name: \ 844 return true; 845 #include "clang/Basic/OpenMPKinds.def" 846 default: 847 break; 848 } 849 break; 850 case OMPD_teams_distribute_parallel_for: 851 switch (CKind) { 852 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 853 case OMPC_##Name: \ 854 return true; 855 #include "clang/Basic/OpenMPKinds.def" 856 default: 857 break; 858 } 859 break; 860 case OMPD_target_teams: 861 switch (CKind) { 862 #define OPENMP_TARGET_TEAMS_CLAUSE(Name) \ 863 case OMPC_##Name: \ 864 return true; 865 #include "clang/Basic/OpenMPKinds.def" 866 default: 867 break; 868 } 869 break; 870 case OMPD_target_teams_distribute: 871 switch (CKind) { 872 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name) \ 873 case OMPC_##Name: \ 874 return true; 875 #include "clang/Basic/OpenMPKinds.def" 876 default: 877 break; 878 } 879 break; 880 case OMPD_target_teams_distribute_parallel_for: 881 switch (CKind) { 882 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 883 case OMPC_##Name: \ 884 return true; 885 #include "clang/Basic/OpenMPKinds.def" 886 default: 887 break; 888 } 889 break; 890 case OMPD_target_teams_distribute_parallel_for_simd: 891 switch (CKind) { 892 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 893 case OMPC_##Name: \ 894 return true; 895 #include "clang/Basic/OpenMPKinds.def" 896 default: 897 break; 898 } 899 break; 900 case OMPD_target_teams_distribute_simd: 901 switch (CKind) { 902 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \ 903 case OMPC_##Name: \ 904 return true; 905 #include "clang/Basic/OpenMPKinds.def" 906 default: 907 break; 908 } 909 break; 910 case OMPD_taskgroup: 911 switch (CKind) { 912 #define OPENMP_TASKGROUP_CLAUSE(Name) \ 913 case OMPC_##Name: \ 914 return true; 915 #include "clang/Basic/OpenMPKinds.def" 916 default: 917 break; 918 } 919 break; 920 case OMPD_declare_mapper: 921 switch (CKind) { 922 #define OPENMP_DECLARE_MAPPER_CLAUSE(Name) \ 923 case OMPC_##Name: \ 924 return true; 925 #include "clang/Basic/OpenMPKinds.def" 926 default: 927 break; 928 } 929 break; 930 case OMPD_allocate: 931 switch (CKind) { 932 #define OPENMP_ALLOCATE_CLAUSE(Name) \ 933 case OMPC_##Name: \ 934 return true; 935 #include "clang/Basic/OpenMPKinds.def" 936 default: 937 break; 938 } 939 break; 940 case OMPD_declare_variant: 941 switch (CKind) { 942 #define OPENMP_DECLARE_VARIANT_CLAUSE(Name) \ 943 case OMPC_##Name: \ 944 return true; 945 #include "clang/Basic/OpenMPKinds.def" 946 default: 947 break; 948 } 949 break; 950 case OMPD_declare_target: 951 case OMPD_end_declare_target: 952 case OMPD_unknown: 953 case OMPD_threadprivate: 954 case OMPD_section: 955 case OMPD_master: 956 case OMPD_taskyield: 957 case OMPD_barrier: 958 case OMPD_taskwait: 959 case OMPD_cancellation_point: 960 case OMPD_declare_reduction: 961 case OMPD_declare_simd: 962 break; 963 } 964 return false; 965 } 966 967 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) { 968 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd || 969 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd || 970 DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 971 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 972 DKind == OMPD_parallel_master_taskloop || 973 DKind == OMPD_parallel_master_taskloop_simd || 974 DKind == OMPD_distribute || DKind == OMPD_target_parallel_for || 975 DKind == OMPD_distribute_parallel_for || 976 DKind == OMPD_distribute_parallel_for_simd || 977 DKind == OMPD_distribute_simd || 978 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 979 DKind == OMPD_teams_distribute || 980 DKind == OMPD_teams_distribute_simd || 981 DKind == OMPD_teams_distribute_parallel_for_simd || 982 DKind == OMPD_teams_distribute_parallel_for || 983 DKind == OMPD_target_teams_distribute || 984 DKind == OMPD_target_teams_distribute_parallel_for || 985 DKind == OMPD_target_teams_distribute_parallel_for_simd || 986 DKind == OMPD_target_teams_distribute_simd; 987 } 988 989 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { 990 return DKind == OMPD_for || DKind == OMPD_for_simd || 991 DKind == OMPD_sections || DKind == OMPD_section || 992 DKind == OMPD_single || DKind == OMPD_parallel_for || 993 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 994 DKind == OMPD_target_parallel_for || 995 DKind == OMPD_distribute_parallel_for || 996 DKind == OMPD_distribute_parallel_for_simd || 997 DKind == OMPD_target_parallel_for_simd || 998 DKind == OMPD_teams_distribute_parallel_for_simd || 999 DKind == OMPD_teams_distribute_parallel_for || 1000 DKind == OMPD_target_teams_distribute_parallel_for || 1001 DKind == OMPD_target_teams_distribute_parallel_for_simd; 1002 } 1003 1004 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) { 1005 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 1006 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 1007 DKind == OMPD_parallel_master_taskloop || 1008 DKind == OMPD_parallel_master_taskloop_simd; 1009 } 1010 1011 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) { 1012 return DKind == OMPD_parallel || DKind == OMPD_parallel_for || 1013 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 1014 DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for || 1015 DKind == OMPD_distribute_parallel_for || 1016 DKind == OMPD_distribute_parallel_for_simd || 1017 DKind == OMPD_target_parallel_for_simd || 1018 DKind == OMPD_teams_distribute_parallel_for || 1019 DKind == OMPD_teams_distribute_parallel_for_simd || 1020 DKind == OMPD_target_teams_distribute_parallel_for || 1021 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1022 DKind == OMPD_parallel_master || 1023 DKind == OMPD_parallel_master_taskloop || 1024 DKind == OMPD_parallel_master_taskloop_simd; 1025 } 1026 1027 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) { 1028 return DKind == OMPD_target || DKind == OMPD_target_parallel || 1029 DKind == OMPD_target_parallel_for || 1030 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 1031 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 1032 DKind == OMPD_target_teams_distribute_parallel_for || 1033 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1034 DKind == OMPD_target_teams_distribute_simd; 1035 } 1036 1037 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) { 1038 return DKind == OMPD_target_data || DKind == OMPD_target_enter_data || 1039 DKind == OMPD_target_exit_data || DKind == OMPD_target_update; 1040 } 1041 1042 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) { 1043 return DKind == OMPD_teams || DKind == OMPD_teams_distribute || 1044 DKind == OMPD_teams_distribute_simd || 1045 DKind == OMPD_teams_distribute_parallel_for_simd || 1046 DKind == OMPD_teams_distribute_parallel_for; 1047 } 1048 1049 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) { 1050 return isOpenMPNestingTeamsDirective(DKind) || 1051 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 1052 DKind == OMPD_target_teams_distribute_parallel_for || 1053 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1054 DKind == OMPD_target_teams_distribute_simd; 1055 } 1056 1057 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) { 1058 return DKind == OMPD_simd || DKind == OMPD_for_simd || 1059 DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd || 1060 DKind == OMPD_master_taskloop_simd || 1061 DKind == OMPD_parallel_master_taskloop_simd || 1062 DKind == OMPD_distribute_parallel_for_simd || 1063 DKind == OMPD_distribute_simd || DKind == OMPD_target_simd || 1064 DKind == OMPD_teams_distribute_simd || 1065 DKind == OMPD_teams_distribute_parallel_for_simd || 1066 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1067 DKind == OMPD_target_teams_distribute_simd || 1068 DKind == OMPD_target_parallel_for_simd; 1069 } 1070 1071 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) { 1072 return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for || 1073 Kind == OMPD_distribute_parallel_for_simd || 1074 Kind == OMPD_distribute_simd; 1075 // TODO add next directives. 1076 } 1077 1078 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) { 1079 return isOpenMPNestingDistributeDirective(Kind) || 1080 Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd || 1081 Kind == OMPD_teams_distribute_parallel_for_simd || 1082 Kind == OMPD_teams_distribute_parallel_for || 1083 Kind == OMPD_target_teams_distribute || 1084 Kind == OMPD_target_teams_distribute_parallel_for || 1085 Kind == OMPD_target_teams_distribute_parallel_for_simd || 1086 Kind == OMPD_target_teams_distribute_simd; 1087 } 1088 1089 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) { 1090 return Kind == OMPC_private || Kind == OMPC_firstprivate || 1091 Kind == OMPC_lastprivate || Kind == OMPC_linear || 1092 Kind == OMPC_reduction || Kind == OMPC_task_reduction || 1093 Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'. 1094 } 1095 1096 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) { 1097 return Kind == OMPC_threadprivate || Kind == OMPC_copyin; 1098 } 1099 1100 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) { 1101 return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind); 1102 } 1103 1104 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) { 1105 return Kind == OMPD_distribute_parallel_for || 1106 Kind == OMPD_distribute_parallel_for_simd || 1107 Kind == OMPD_teams_distribute_parallel_for_simd || 1108 Kind == OMPD_teams_distribute_parallel_for || 1109 Kind == OMPD_target_teams_distribute_parallel_for || 1110 Kind == OMPD_target_teams_distribute_parallel_for_simd; 1111 } 1112 1113 void clang::getOpenMPCaptureRegions( 1114 SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions, 1115 OpenMPDirectiveKind DKind) { 1116 assert(DKind <= OMPD_unknown); 1117 switch (DKind) { 1118 case OMPD_parallel: 1119 case OMPD_parallel_for: 1120 case OMPD_parallel_for_simd: 1121 case OMPD_parallel_master: 1122 case OMPD_parallel_sections: 1123 case OMPD_distribute_parallel_for: 1124 case OMPD_distribute_parallel_for_simd: 1125 CaptureRegions.push_back(OMPD_parallel); 1126 break; 1127 case OMPD_target_teams: 1128 case OMPD_target_teams_distribute: 1129 case OMPD_target_teams_distribute_simd: 1130 CaptureRegions.push_back(OMPD_task); 1131 CaptureRegions.push_back(OMPD_target); 1132 CaptureRegions.push_back(OMPD_teams); 1133 break; 1134 case OMPD_teams: 1135 case OMPD_teams_distribute: 1136 case OMPD_teams_distribute_simd: 1137 CaptureRegions.push_back(OMPD_teams); 1138 break; 1139 case OMPD_target: 1140 case OMPD_target_simd: 1141 CaptureRegions.push_back(OMPD_task); 1142 CaptureRegions.push_back(OMPD_target); 1143 break; 1144 case OMPD_teams_distribute_parallel_for: 1145 case OMPD_teams_distribute_parallel_for_simd: 1146 CaptureRegions.push_back(OMPD_teams); 1147 CaptureRegions.push_back(OMPD_parallel); 1148 break; 1149 case OMPD_target_parallel: 1150 case OMPD_target_parallel_for: 1151 case OMPD_target_parallel_for_simd: 1152 CaptureRegions.push_back(OMPD_task); 1153 CaptureRegions.push_back(OMPD_target); 1154 CaptureRegions.push_back(OMPD_parallel); 1155 break; 1156 case OMPD_task: 1157 case OMPD_target_enter_data: 1158 case OMPD_target_exit_data: 1159 case OMPD_target_update: 1160 CaptureRegions.push_back(OMPD_task); 1161 break; 1162 case OMPD_taskloop: 1163 case OMPD_taskloop_simd: 1164 case OMPD_master_taskloop: 1165 case OMPD_master_taskloop_simd: 1166 CaptureRegions.push_back(OMPD_taskloop); 1167 break; 1168 case OMPD_parallel_master_taskloop: 1169 case OMPD_parallel_master_taskloop_simd: 1170 CaptureRegions.push_back(OMPD_parallel); 1171 CaptureRegions.push_back(OMPD_taskloop); 1172 break; 1173 case OMPD_target_teams_distribute_parallel_for: 1174 case OMPD_target_teams_distribute_parallel_for_simd: 1175 CaptureRegions.push_back(OMPD_task); 1176 CaptureRegions.push_back(OMPD_target); 1177 CaptureRegions.push_back(OMPD_teams); 1178 CaptureRegions.push_back(OMPD_parallel); 1179 break; 1180 case OMPD_simd: 1181 case OMPD_for: 1182 case OMPD_for_simd: 1183 case OMPD_sections: 1184 case OMPD_section: 1185 case OMPD_single: 1186 case OMPD_master: 1187 case OMPD_critical: 1188 case OMPD_taskgroup: 1189 case OMPD_distribute: 1190 case OMPD_ordered: 1191 case OMPD_atomic: 1192 case OMPD_target_data: 1193 case OMPD_distribute_simd: 1194 CaptureRegions.push_back(OMPD_unknown); 1195 break; 1196 case OMPD_threadprivate: 1197 case OMPD_allocate: 1198 case OMPD_taskyield: 1199 case OMPD_barrier: 1200 case OMPD_taskwait: 1201 case OMPD_cancellation_point: 1202 case OMPD_cancel: 1203 case OMPD_flush: 1204 case OMPD_declare_reduction: 1205 case OMPD_declare_mapper: 1206 case OMPD_declare_simd: 1207 case OMPD_declare_target: 1208 case OMPD_end_declare_target: 1209 case OMPD_requires: 1210 case OMPD_declare_variant: 1211 llvm_unreachable("OpenMP Directive is not allowed"); 1212 case OMPD_unknown: 1213 llvm_unreachable("Unknown OpenMP directive"); 1214 } 1215 } 1216