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