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