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