1 //===--- OpenMPKinds.cpp - Token Kinds Support ----------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 /// \file 10 /// \brief This file implements the OpenMP enum and support functions. 11 /// 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/Basic/OpenMPKinds.h" 15 #include "clang/Basic/IdentifierTable.h" 16 #include "llvm/ADT/StringRef.h" 17 #include "llvm/ADT/StringSwitch.h" 18 #include "llvm/Support/ErrorHandling.h" 19 #include <cassert> 20 21 using namespace clang; 22 23 OpenMPDirectiveKind clang::getOpenMPDirectiveKind(StringRef Str) { 24 return llvm::StringSwitch<OpenMPDirectiveKind>(Str) 25 #define OPENMP_DIRECTIVE(Name) .Case(#Name, OMPD_##Name) 26 #define OPENMP_DIRECTIVE_EXT(Name, Str) .Case(Str, OMPD_##Name) 27 #include "clang/Basic/OpenMPKinds.def" 28 .Default(OMPD_unknown); 29 } 30 31 const char *clang::getOpenMPDirectiveName(OpenMPDirectiveKind Kind) { 32 assert(Kind <= OMPD_unknown); 33 switch (Kind) { 34 case OMPD_unknown: 35 return "unknown"; 36 #define OPENMP_DIRECTIVE(Name) \ 37 case OMPD_##Name: \ 38 return #Name; 39 #define OPENMP_DIRECTIVE_EXT(Name, Str) \ 40 case OMPD_##Name: \ 41 return Str; 42 #include "clang/Basic/OpenMPKinds.def" 43 break; 44 } 45 llvm_unreachable("Invalid OpenMP directive kind"); 46 } 47 48 OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) { 49 // 'flush' clause cannot be specified explicitly, because this is an implicit 50 // clause for 'flush' directive. If the 'flush' clause is explicitly specified 51 // the Parser should generate a warning about extra tokens at the end of the 52 // directive. 53 if (Str == "flush") 54 return OMPC_unknown; 55 return llvm::StringSwitch<OpenMPClauseKind>(Str) 56 #define OPENMP_CLAUSE(Name, Class) .Case(#Name, OMPC_##Name) 57 #include "clang/Basic/OpenMPKinds.def" 58 .Case("uniform", OMPC_uniform) 59 .Default(OMPC_unknown); 60 } 61 62 const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) { 63 assert(Kind <= OMPC_unknown); 64 switch (Kind) { 65 case OMPC_unknown: 66 return "unknown"; 67 #define OPENMP_CLAUSE(Name, Class) \ 68 case OMPC_##Name: \ 69 return #Name; 70 #include "clang/Basic/OpenMPKinds.def" 71 case OMPC_uniform: 72 return "uniform"; 73 case OMPC_threadprivate: 74 return "threadprivate or thread local"; 75 } 76 llvm_unreachable("Invalid OpenMP clause kind"); 77 } 78 79 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind, 80 StringRef Str) { 81 switch (Kind) { 82 case OMPC_default: 83 return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str) 84 #define OPENMP_DEFAULT_KIND(Name) .Case(#Name, OMPC_DEFAULT_##Name) 85 #include "clang/Basic/OpenMPKinds.def" 86 .Default(OMPC_DEFAULT_unknown); 87 case OMPC_proc_bind: 88 return llvm::StringSwitch<OpenMPProcBindClauseKind>(Str) 89 #define OPENMP_PROC_BIND_KIND(Name) .Case(#Name, OMPC_PROC_BIND_##Name) 90 #include "clang/Basic/OpenMPKinds.def" 91 .Default(OMPC_PROC_BIND_unknown); 92 case OMPC_schedule: 93 return llvm::StringSwitch<unsigned>(Str) 94 #define OPENMP_SCHEDULE_KIND(Name) \ 95 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name)) 96 #define OPENMP_SCHEDULE_MODIFIER(Name) \ 97 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name)) 98 #include "clang/Basic/OpenMPKinds.def" 99 .Default(OMPC_SCHEDULE_unknown); 100 case OMPC_depend: 101 return llvm::StringSwitch<OpenMPDependClauseKind>(Str) 102 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name) 103 #include "clang/Basic/OpenMPKinds.def" 104 .Default(OMPC_DEPEND_unknown); 105 case OMPC_linear: 106 return llvm::StringSwitch<OpenMPLinearClauseKind>(Str) 107 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name) 108 #include "clang/Basic/OpenMPKinds.def" 109 .Default(OMPC_LINEAR_unknown); 110 case OMPC_map: 111 return llvm::StringSwitch<OpenMPMapClauseKind>(Str) 112 #define OPENMP_MAP_KIND(Name) .Case(#Name, OMPC_MAP_##Name) 113 #include "clang/Basic/OpenMPKinds.def" 114 .Default(OMPC_MAP_unknown); 115 case OMPC_dist_schedule: 116 return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str) 117 #define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name) 118 #include "clang/Basic/OpenMPKinds.def" 119 .Default(OMPC_DIST_SCHEDULE_unknown); 120 case OMPC_defaultmap: 121 return llvm::StringSwitch<unsigned>(Str) 122 #define OPENMP_DEFAULTMAP_KIND(Name) \ 123 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name)) 124 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 125 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name)) 126 #include "clang/Basic/OpenMPKinds.def" 127 .Default(OMPC_DEFAULTMAP_unknown); 128 case OMPC_unknown: 129 case OMPC_threadprivate: 130 case OMPC_if: 131 case OMPC_final: 132 case OMPC_num_threads: 133 case OMPC_safelen: 134 case OMPC_simdlen: 135 case OMPC_collapse: 136 case OMPC_private: 137 case OMPC_firstprivate: 138 case OMPC_lastprivate: 139 case OMPC_shared: 140 case OMPC_reduction: 141 case OMPC_aligned: 142 case OMPC_copyin: 143 case OMPC_copyprivate: 144 case OMPC_ordered: 145 case OMPC_nowait: 146 case OMPC_untied: 147 case OMPC_mergeable: 148 case OMPC_flush: 149 case OMPC_read: 150 case OMPC_write: 151 case OMPC_update: 152 case OMPC_capture: 153 case OMPC_seq_cst: 154 case OMPC_device: 155 case OMPC_threads: 156 case OMPC_simd: 157 case OMPC_num_teams: 158 case OMPC_thread_limit: 159 case OMPC_priority: 160 case OMPC_grainsize: 161 case OMPC_nogroup: 162 case OMPC_num_tasks: 163 case OMPC_hint: 164 case OMPC_uniform: 165 case OMPC_to: 166 case OMPC_from: 167 case OMPC_use_device_ptr: 168 case OMPC_is_device_ptr: 169 break; 170 } 171 llvm_unreachable("Invalid OpenMP simple clause kind"); 172 } 173 174 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, 175 unsigned Type) { 176 switch (Kind) { 177 case OMPC_default: 178 switch (Type) { 179 case OMPC_DEFAULT_unknown: 180 return "unknown"; 181 #define OPENMP_DEFAULT_KIND(Name) \ 182 case OMPC_DEFAULT_##Name: \ 183 return #Name; 184 #include "clang/Basic/OpenMPKinds.def" 185 } 186 llvm_unreachable("Invalid OpenMP 'default' clause type"); 187 case OMPC_proc_bind: 188 switch (Type) { 189 case OMPC_PROC_BIND_unknown: 190 return "unknown"; 191 #define OPENMP_PROC_BIND_KIND(Name) \ 192 case OMPC_PROC_BIND_##Name: \ 193 return #Name; 194 #include "clang/Basic/OpenMPKinds.def" 195 } 196 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type"); 197 case OMPC_schedule: 198 switch (Type) { 199 case OMPC_SCHEDULE_unknown: 200 case OMPC_SCHEDULE_MODIFIER_last: 201 return "unknown"; 202 #define OPENMP_SCHEDULE_KIND(Name) \ 203 case OMPC_SCHEDULE_##Name: \ 204 return #Name; 205 #define OPENMP_SCHEDULE_MODIFIER(Name) \ 206 case OMPC_SCHEDULE_MODIFIER_##Name: \ 207 return #Name; 208 #include "clang/Basic/OpenMPKinds.def" 209 } 210 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 211 case OMPC_depend: 212 switch (Type) { 213 case OMPC_DEPEND_unknown: 214 return "unknown"; 215 #define OPENMP_DEPEND_KIND(Name) \ 216 case OMPC_DEPEND_##Name: \ 217 return #Name; 218 #include "clang/Basic/OpenMPKinds.def" 219 } 220 llvm_unreachable("Invalid OpenMP 'depend' clause type"); 221 case OMPC_linear: 222 switch (Type) { 223 case OMPC_LINEAR_unknown: 224 return "unknown"; 225 #define OPENMP_LINEAR_KIND(Name) \ 226 case OMPC_LINEAR_##Name: \ 227 return #Name; 228 #include "clang/Basic/OpenMPKinds.def" 229 } 230 llvm_unreachable("Invalid OpenMP 'linear' clause type"); 231 case OMPC_map: 232 switch (Type) { 233 case OMPC_MAP_unknown: 234 return "unknown"; 235 #define OPENMP_MAP_KIND(Name) \ 236 case OMPC_MAP_##Name: \ 237 return #Name; 238 #include "clang/Basic/OpenMPKinds.def" 239 default: 240 break; 241 } 242 llvm_unreachable("Invalid OpenMP 'map' clause type"); 243 case OMPC_dist_schedule: 244 switch (Type) { 245 case OMPC_DIST_SCHEDULE_unknown: 246 return "unknown"; 247 #define OPENMP_DIST_SCHEDULE_KIND(Name) \ 248 case OMPC_DIST_SCHEDULE_##Name: \ 249 return #Name; 250 #include "clang/Basic/OpenMPKinds.def" 251 } 252 llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type"); 253 case OMPC_defaultmap: 254 switch (Type) { 255 case OMPC_DEFAULTMAP_unknown: 256 case OMPC_DEFAULTMAP_MODIFIER_last: 257 return "unknown"; 258 #define OPENMP_DEFAULTMAP_KIND(Name) \ 259 case OMPC_DEFAULTMAP_##Name: \ 260 return #Name; 261 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 262 case OMPC_DEFAULTMAP_MODIFIER_##Name: \ 263 return #Name; 264 #include "clang/Basic/OpenMPKinds.def" 265 } 266 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 267 case OMPC_unknown: 268 case OMPC_threadprivate: 269 case OMPC_if: 270 case OMPC_final: 271 case OMPC_num_threads: 272 case OMPC_safelen: 273 case OMPC_simdlen: 274 case OMPC_collapse: 275 case OMPC_private: 276 case OMPC_firstprivate: 277 case OMPC_lastprivate: 278 case OMPC_shared: 279 case OMPC_reduction: 280 case OMPC_aligned: 281 case OMPC_copyin: 282 case OMPC_copyprivate: 283 case OMPC_ordered: 284 case OMPC_nowait: 285 case OMPC_untied: 286 case OMPC_mergeable: 287 case OMPC_flush: 288 case OMPC_read: 289 case OMPC_write: 290 case OMPC_update: 291 case OMPC_capture: 292 case OMPC_seq_cst: 293 case OMPC_device: 294 case OMPC_threads: 295 case OMPC_simd: 296 case OMPC_num_teams: 297 case OMPC_thread_limit: 298 case OMPC_priority: 299 case OMPC_grainsize: 300 case OMPC_nogroup: 301 case OMPC_num_tasks: 302 case OMPC_hint: 303 case OMPC_uniform: 304 case OMPC_to: 305 case OMPC_from: 306 case OMPC_use_device_ptr: 307 case OMPC_is_device_ptr: 308 break; 309 } 310 llvm_unreachable("Invalid OpenMP simple clause kind"); 311 } 312 313 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind, 314 OpenMPClauseKind CKind) { 315 assert(DKind <= OMPD_unknown); 316 assert(CKind <= OMPC_unknown); 317 switch (DKind) { 318 case OMPD_parallel: 319 switch (CKind) { 320 #define OPENMP_PARALLEL_CLAUSE(Name) \ 321 case OMPC_##Name: \ 322 return true; 323 #include "clang/Basic/OpenMPKinds.def" 324 default: 325 break; 326 } 327 break; 328 case OMPD_simd: 329 switch (CKind) { 330 #define OPENMP_SIMD_CLAUSE(Name) \ 331 case OMPC_##Name: \ 332 return true; 333 #include "clang/Basic/OpenMPKinds.def" 334 default: 335 break; 336 } 337 break; 338 case OMPD_for: 339 switch (CKind) { 340 #define OPENMP_FOR_CLAUSE(Name) \ 341 case OMPC_##Name: \ 342 return true; 343 #include "clang/Basic/OpenMPKinds.def" 344 default: 345 break; 346 } 347 break; 348 case OMPD_for_simd: 349 switch (CKind) { 350 #define OPENMP_FOR_SIMD_CLAUSE(Name) \ 351 case OMPC_##Name: \ 352 return true; 353 #include "clang/Basic/OpenMPKinds.def" 354 default: 355 break; 356 } 357 break; 358 case OMPD_sections: 359 switch (CKind) { 360 #define OPENMP_SECTIONS_CLAUSE(Name) \ 361 case OMPC_##Name: \ 362 return true; 363 #include "clang/Basic/OpenMPKinds.def" 364 default: 365 break; 366 } 367 break; 368 case OMPD_single: 369 switch (CKind) { 370 #define OPENMP_SINGLE_CLAUSE(Name) \ 371 case OMPC_##Name: \ 372 return true; 373 #include "clang/Basic/OpenMPKinds.def" 374 default: 375 break; 376 } 377 break; 378 case OMPD_parallel_for: 379 switch (CKind) { 380 #define OPENMP_PARALLEL_FOR_CLAUSE(Name) \ 381 case OMPC_##Name: \ 382 return true; 383 #include "clang/Basic/OpenMPKinds.def" 384 default: 385 break; 386 } 387 break; 388 case OMPD_parallel_for_simd: 389 switch (CKind) { 390 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 391 case OMPC_##Name: \ 392 return true; 393 #include "clang/Basic/OpenMPKinds.def" 394 default: 395 break; 396 } 397 break; 398 case OMPD_parallel_sections: 399 switch (CKind) { 400 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) \ 401 case OMPC_##Name: \ 402 return true; 403 #include "clang/Basic/OpenMPKinds.def" 404 default: 405 break; 406 } 407 break; 408 case OMPD_task: 409 switch (CKind) { 410 #define OPENMP_TASK_CLAUSE(Name) \ 411 case OMPC_##Name: \ 412 return true; 413 #include "clang/Basic/OpenMPKinds.def" 414 default: 415 break; 416 } 417 break; 418 case OMPD_flush: 419 return CKind == OMPC_flush; 420 break; 421 case OMPD_atomic: 422 switch (CKind) { 423 #define OPENMP_ATOMIC_CLAUSE(Name) \ 424 case OMPC_##Name: \ 425 return true; 426 #include "clang/Basic/OpenMPKinds.def" 427 default: 428 break; 429 } 430 break; 431 case OMPD_target: 432 switch (CKind) { 433 #define OPENMP_TARGET_CLAUSE(Name) \ 434 case OMPC_##Name: \ 435 return true; 436 #include "clang/Basic/OpenMPKinds.def" 437 default: 438 break; 439 } 440 break; 441 case OMPD_target_data: 442 switch (CKind) { 443 #define OPENMP_TARGET_DATA_CLAUSE(Name) \ 444 case OMPC_##Name: \ 445 return true; 446 #include "clang/Basic/OpenMPKinds.def" 447 default: 448 break; 449 } 450 break; 451 case OMPD_target_enter_data: 452 switch (CKind) { 453 #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name) \ 454 case OMPC_##Name: \ 455 return true; 456 #include "clang/Basic/OpenMPKinds.def" 457 default: 458 break; 459 } 460 break; 461 case OMPD_target_exit_data: 462 switch (CKind) { 463 #define OPENMP_TARGET_EXIT_DATA_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_target_parallel: 472 switch (CKind) { 473 #define OPENMP_TARGET_PARALLEL_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_target_parallel_for: 482 switch (CKind) { 483 #define OPENMP_TARGET_PARALLEL_FOR_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_target_update: 492 switch (CKind) { 493 #define OPENMP_TARGET_UPDATE_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_teams: 502 switch (CKind) { 503 #define OPENMP_TEAMS_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_declare_simd: 512 break; 513 case OMPD_cancel: 514 switch (CKind) { 515 #define OPENMP_CANCEL_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_ordered: 524 switch (CKind) { 525 #define OPENMP_ORDERED_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_taskloop: 534 switch (CKind) { 535 #define OPENMP_TASKLOOP_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_taskloop_simd: 544 switch (CKind) { 545 #define OPENMP_TASKLOOP_SIMD_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_critical: 554 switch (CKind) { 555 #define OPENMP_CRITICAL_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_distribute: 564 switch (CKind) { 565 #define OPENMP_DISTRIBUTE_CLAUSE(Name) \ 566 case OMPC_##Name: \ 567 return true; 568 #include "clang/Basic/OpenMPKinds.def" 569 default: 570 break; 571 } 572 break; 573 case OMPD_distribute_parallel_for: 574 switch (CKind) { 575 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 576 case OMPC_##Name: \ 577 return true; 578 #include "clang/Basic/OpenMPKinds.def" 579 default: 580 break; 581 } 582 break; 583 case OMPD_distribute_parallel_for_simd: 584 switch (CKind) { 585 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 586 case OMPC_##Name: \ 587 return true; 588 #include "clang/Basic/OpenMPKinds.def" 589 default: 590 break; 591 } 592 break; 593 case OMPD_distribute_simd: 594 switch (CKind) { 595 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) \ 596 case OMPC_##Name: \ 597 return true; 598 #include "clang/Basic/OpenMPKinds.def" 599 default: 600 break; 601 } 602 break; 603 case OMPD_target_parallel_for_simd: 604 switch (CKind) { 605 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 606 case OMPC_##Name: \ 607 return true; 608 #include "clang/Basic/OpenMPKinds.def" 609 default: 610 break; 611 } 612 break; 613 case OMPD_declare_target: 614 case OMPD_end_declare_target: 615 case OMPD_unknown: 616 case OMPD_threadprivate: 617 case OMPD_section: 618 case OMPD_master: 619 case OMPD_taskyield: 620 case OMPD_barrier: 621 case OMPD_taskwait: 622 case OMPD_taskgroup: 623 case OMPD_cancellation_point: 624 case OMPD_declare_reduction: 625 break; 626 } 627 return false; 628 } 629 630 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) { 631 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd || 632 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd || 633 DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 634 DKind == OMPD_distribute || DKind == OMPD_target_parallel_for || 635 DKind == OMPD_distribute_parallel_for || 636 DKind == OMPD_distribute_parallel_for_simd || 637 DKind == OMPD_distribute_simd || 638 DKind == OMPD_target_parallel_for_simd; 639 // TODO add next directives. 640 } 641 642 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { 643 return DKind == OMPD_for || DKind == OMPD_for_simd || 644 DKind == OMPD_sections || DKind == OMPD_section || 645 DKind == OMPD_single || DKind == OMPD_parallel_for || 646 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 647 DKind == OMPD_target_parallel_for || 648 DKind == OMPD_distribute_parallel_for || 649 DKind == OMPD_distribute_parallel_for_simd || 650 DKind == OMPD_target_parallel_for_simd; 651 // TODO add next directives. 652 } 653 654 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) { 655 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd; 656 } 657 658 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) { 659 return DKind == OMPD_parallel || DKind == OMPD_parallel_for || 660 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 661 DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for || 662 DKind == OMPD_distribute_parallel_for || 663 DKind == OMPD_distribute_parallel_for_simd || 664 DKind == OMPD_target_parallel_for_simd; 665 // TODO add next directives. 666 } 667 668 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) { 669 // TODO add next directives. 670 return DKind == OMPD_target || DKind == OMPD_target_parallel || 671 DKind == OMPD_target_parallel_for || 672 DKind == OMPD_target_parallel_for_simd; 673 } 674 675 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) { 676 return DKind == OMPD_target_data || DKind == OMPD_target_enter_data || 677 DKind == OMPD_target_exit_data || DKind == OMPD_target_update; 678 } 679 680 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) { 681 return DKind == OMPD_teams; // TODO add next directives. 682 } 683 684 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) { 685 return DKind == OMPD_simd || DKind == OMPD_for_simd || 686 DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd || 687 DKind == OMPD_distribute_parallel_for_simd || 688 DKind == OMPD_distribute_simd; 689 // TODO add next directives. 690 } 691 692 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) { 693 return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for || 694 Kind == OMPD_distribute_parallel_for_simd || 695 Kind == OMPD_distribute_simd; 696 // TODO add next directives. 697 } 698 699 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) { 700 return Kind == OMPC_private || Kind == OMPC_firstprivate || 701 Kind == OMPC_lastprivate || Kind == OMPC_linear || 702 Kind == OMPC_reduction; // TODO add next clauses like 'reduction'. 703 } 704 705 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) { 706 return Kind == OMPC_threadprivate || Kind == OMPC_copyin; 707 } 708 709 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) { 710 return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind); 711 } 712 713 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) { 714 return Kind == OMPD_distribute_parallel_for || 715 Kind == OMPD_distribute_parallel_for_simd || 716 Kind == OMPD_distribute_simd; 717 } 718
