1 //===--- OpenMPKinds.cpp - Token Kinds Support ----------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 /// \file 9 /// This file implements the OpenMP enum and support functions. 10 /// 11 //===----------------------------------------------------------------------===// 12 13 #include "clang/Basic/OpenMPKinds.h" 14 #include "clang/Basic/IdentifierTable.h" 15 #include "llvm/ADT/StringRef.h" 16 #include "llvm/ADT/StringSwitch.h" 17 #include "llvm/Support/ErrorHandling.h" 18 #include <cassert> 19 20 using namespace clang; 21 using namespace llvm::omp; 22 23 OpenMPContextSelectorSetKind 24 clang::getOpenMPContextSelectorSet(llvm::StringRef Str) { 25 return llvm::StringSwitch<OpenMPContextSelectorSetKind>(Str) 26 #define OPENMP_CONTEXT_SELECTOR_SET(Name) .Case(#Name, OMP_CTX_SET_##Name) 27 #include "clang/Basic/OpenMPKinds.def" 28 .Default(OMP_CTX_SET_unknown); 29 } 30 31 llvm::StringRef 32 clang::getOpenMPContextSelectorSetName(OpenMPContextSelectorSetKind Kind) { 33 switch (Kind) { 34 case OMP_CTX_SET_unknown: 35 return "unknown"; 36 #define OPENMP_CONTEXT_SELECTOR_SET(Name) \ 37 case OMP_CTX_SET_##Name: \ 38 return #Name; 39 #include "clang/Basic/OpenMPKinds.def" 40 break; 41 } 42 llvm_unreachable("Invalid OpenMP context selector set kind"); 43 } 44 45 OpenMPContextSelectorKind clang::getOpenMPContextSelector(llvm::StringRef Str) { 46 return llvm::StringSwitch<OpenMPContextSelectorKind>(Str) 47 #define OPENMP_CONTEXT_SELECTOR(Name) .Case(#Name, OMP_CTX_##Name) 48 #include "clang/Basic/OpenMPKinds.def" 49 .Default(OMP_CTX_unknown); 50 } 51 52 llvm::StringRef 53 clang::getOpenMPContextSelectorName(OpenMPContextSelectorKind Kind) { 54 switch (Kind) { 55 case OMP_CTX_unknown: 56 return "unknown"; 57 #define OPENMP_CONTEXT_SELECTOR(Name) \ 58 case OMP_CTX_##Name: \ 59 return #Name; 60 #include "clang/Basic/OpenMPKinds.def" 61 break; 62 } 63 llvm_unreachable("Invalid OpenMP context selector kind"); 64 } 65 66 OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) { 67 // 'flush' clause cannot be specified explicitly, because this is an implicit 68 // clause for 'flush' directive. If the 'flush' clause is explicitly specified 69 // the Parser should generate a warning about extra tokens at the end of the 70 // directive. 71 if (Str == "flush") 72 return OMPC_unknown; 73 return llvm::StringSwitch<OpenMPClauseKind>(Str) 74 #define OPENMP_CLAUSE(Name, Class) .Case(#Name, OMPC_##Name) 75 #include "clang/Basic/OpenMPKinds.def" 76 .Case("uniform", OMPC_uniform) 77 .Case("device_type", OMPC_device_type) 78 .Case("match", OMPC_match) 79 .Default(OMPC_unknown); 80 } 81 82 const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) { 83 assert(Kind <= OMPC_unknown); 84 switch (Kind) { 85 case OMPC_unknown: 86 return "unknown"; 87 #define OPENMP_CLAUSE(Name, Class) \ 88 case OMPC_##Name: \ 89 return #Name; 90 #include "clang/Basic/OpenMPKinds.def" 91 case OMPC_uniform: 92 return "uniform"; 93 case OMPC_threadprivate: 94 return "threadprivate or thread local"; 95 case OMPC_device_type: 96 return "device_type"; 97 case OMPC_match: 98 return "match"; 99 } 100 llvm_unreachable("Invalid OpenMP clause kind"); 101 } 102 103 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind, 104 StringRef Str) { 105 switch (Kind) { 106 case OMPC_default: 107 return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str) 108 #define OPENMP_DEFAULT_KIND(Name) .Case(#Name, OMPC_DEFAULT_##Name) 109 #include "clang/Basic/OpenMPKinds.def" 110 .Default(OMPC_DEFAULT_unknown); 111 case OMPC_proc_bind: 112 return llvm::StringSwitch<unsigned>(Str) 113 #define OMP_PROC_BIND_KIND(Enum, Name, Value) .Case(Name, Value) 114 #include "llvm/Frontend/OpenMP/OMPKinds.def" 115 .Default(unsigned(llvm::omp::OMP_PROC_BIND_unknown)); 116 case OMPC_schedule: 117 return llvm::StringSwitch<unsigned>(Str) 118 #define OPENMP_SCHEDULE_KIND(Name) \ 119 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name)) 120 #define OPENMP_SCHEDULE_MODIFIER(Name) \ 121 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name)) 122 #include "clang/Basic/OpenMPKinds.def" 123 .Default(OMPC_SCHEDULE_unknown); 124 case OMPC_depend: 125 return llvm::StringSwitch<OpenMPDependClauseKind>(Str) 126 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name) 127 #include "clang/Basic/OpenMPKinds.def" 128 .Default(OMPC_DEPEND_unknown); 129 case OMPC_linear: 130 return llvm::StringSwitch<OpenMPLinearClauseKind>(Str) 131 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name) 132 #include "clang/Basic/OpenMPKinds.def" 133 .Default(OMPC_LINEAR_unknown); 134 case OMPC_map: 135 return llvm::StringSwitch<unsigned>(Str) 136 #define OPENMP_MAP_KIND(Name) \ 137 .Case(#Name, static_cast<unsigned>(OMPC_MAP_##Name)) 138 #define OPENMP_MAP_MODIFIER_KIND(Name) \ 139 .Case(#Name, static_cast<unsigned>(OMPC_MAP_MODIFIER_##Name)) 140 #include "clang/Basic/OpenMPKinds.def" 141 .Default(OMPC_MAP_unknown); 142 case OMPC_to: 143 return llvm::StringSwitch<unsigned>(Str) 144 #define OPENMP_TO_MODIFIER_KIND(Name) \ 145 .Case(#Name, static_cast<unsigned>(OMPC_TO_MODIFIER_##Name)) 146 #include "clang/Basic/OpenMPKinds.def" 147 .Default(OMPC_TO_MODIFIER_unknown); 148 case OMPC_from: 149 return llvm::StringSwitch<unsigned>(Str) 150 #define OPENMP_FROM_MODIFIER_KIND(Name) \ 151 .Case(#Name, static_cast<unsigned>(OMPC_FROM_MODIFIER_##Name)) 152 #include "clang/Basic/OpenMPKinds.def" 153 .Default(OMPC_FROM_MODIFIER_unknown); 154 case OMPC_dist_schedule: 155 return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str) 156 #define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name) 157 #include "clang/Basic/OpenMPKinds.def" 158 .Default(OMPC_DIST_SCHEDULE_unknown); 159 case OMPC_defaultmap: 160 return llvm::StringSwitch<unsigned>(Str) 161 #define OPENMP_DEFAULTMAP_KIND(Name) \ 162 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name)) 163 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 164 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name)) 165 #include "clang/Basic/OpenMPKinds.def" 166 .Default(OMPC_DEFAULTMAP_unknown); 167 case OMPC_atomic_default_mem_order: 168 return llvm::StringSwitch<OpenMPAtomicDefaultMemOrderClauseKind>(Str) 169 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \ 170 .Case(#Name, OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name) 171 #include "clang/Basic/OpenMPKinds.def" 172 .Default(OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown); 173 case OMPC_device_type: 174 return llvm::StringSwitch<OpenMPDeviceType>(Str) 175 #define OPENMP_DEVICE_TYPE_KIND(Name) .Case(#Name, OMPC_DEVICE_TYPE_##Name) 176 #include "clang/Basic/OpenMPKinds.def" 177 .Default(OMPC_DEVICE_TYPE_unknown); 178 case OMPC_lastprivate: 179 return llvm::StringSwitch<OpenMPLastprivateModifier>(Str) 180 #define OPENMP_LASTPRIVATE_KIND(Name) .Case(#Name, OMPC_LASTPRIVATE_##Name) 181 #include "clang/Basic/OpenMPKinds.def" 182 .Default(OMPC_LASTPRIVATE_unknown); 183 case OMPC_order: 184 return llvm::StringSwitch<OpenMPOrderClauseKind>(Str) 185 #define OPENMP_ORDER_KIND(Name) .Case(#Name, OMPC_ORDER_##Name) 186 #include "clang/Basic/OpenMPKinds.def" 187 .Default(OMPC_ORDER_unknown); 188 case OMPC_unknown: 189 case OMPC_threadprivate: 190 case OMPC_if: 191 case OMPC_final: 192 case OMPC_num_threads: 193 case OMPC_safelen: 194 case OMPC_simdlen: 195 case OMPC_allocator: 196 case OMPC_allocate: 197 case OMPC_collapse: 198 case OMPC_private: 199 case OMPC_firstprivate: 200 case OMPC_shared: 201 case OMPC_reduction: 202 case OMPC_task_reduction: 203 case OMPC_in_reduction: 204 case OMPC_aligned: 205 case OMPC_copyin: 206 case OMPC_copyprivate: 207 case OMPC_ordered: 208 case OMPC_nowait: 209 case OMPC_untied: 210 case OMPC_mergeable: 211 case OMPC_flush: 212 case OMPC_read: 213 case OMPC_write: 214 case OMPC_update: 215 case OMPC_capture: 216 case OMPC_seq_cst: 217 case OMPC_acq_rel: 218 case OMPC_acquire: 219 case OMPC_release: 220 case OMPC_relaxed: 221 case OMPC_device: 222 case OMPC_threads: 223 case OMPC_simd: 224 case OMPC_num_teams: 225 case OMPC_thread_limit: 226 case OMPC_priority: 227 case OMPC_grainsize: 228 case OMPC_nogroup: 229 case OMPC_num_tasks: 230 case OMPC_hint: 231 case OMPC_uniform: 232 case OMPC_use_device_ptr: 233 case OMPC_is_device_ptr: 234 case OMPC_unified_address: 235 case OMPC_unified_shared_memory: 236 case OMPC_reverse_offload: 237 case OMPC_dynamic_allocators: 238 case OMPC_match: 239 case OMPC_nontemporal: 240 break; 241 } 242 llvm_unreachable("Invalid OpenMP simple clause kind"); 243 } 244 245 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, 246 unsigned Type) { 247 switch (Kind) { 248 case OMPC_default: 249 switch (Type) { 250 case OMPC_DEFAULT_unknown: 251 return "unknown"; 252 #define OPENMP_DEFAULT_KIND(Name) \ 253 case OMPC_DEFAULT_##Name: \ 254 return #Name; 255 #include "clang/Basic/OpenMPKinds.def" 256 } 257 llvm_unreachable("Invalid OpenMP 'default' clause type"); 258 case OMPC_proc_bind: 259 switch (Type) { 260 #define OMP_PROC_BIND_KIND(Enum, Name, Value) \ 261 case Value: \ 262 return Name; 263 #include "llvm/Frontend/OpenMP/OMPKinds.def" 264 } 265 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type"); 266 case OMPC_schedule: 267 switch (Type) { 268 case OMPC_SCHEDULE_unknown: 269 case OMPC_SCHEDULE_MODIFIER_last: 270 return "unknown"; 271 #define OPENMP_SCHEDULE_KIND(Name) \ 272 case OMPC_SCHEDULE_##Name: \ 273 return #Name; 274 #define OPENMP_SCHEDULE_MODIFIER(Name) \ 275 case OMPC_SCHEDULE_MODIFIER_##Name: \ 276 return #Name; 277 #include "clang/Basic/OpenMPKinds.def" 278 } 279 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 280 case OMPC_depend: 281 switch (Type) { 282 case OMPC_DEPEND_unknown: 283 return "unknown"; 284 #define OPENMP_DEPEND_KIND(Name) \ 285 case OMPC_DEPEND_##Name: \ 286 return #Name; 287 #include "clang/Basic/OpenMPKinds.def" 288 } 289 llvm_unreachable("Invalid OpenMP 'depend' clause type"); 290 case OMPC_linear: 291 switch (Type) { 292 case OMPC_LINEAR_unknown: 293 return "unknown"; 294 #define OPENMP_LINEAR_KIND(Name) \ 295 case OMPC_LINEAR_##Name: \ 296 return #Name; 297 #include "clang/Basic/OpenMPKinds.def" 298 } 299 llvm_unreachable("Invalid OpenMP 'linear' clause type"); 300 case OMPC_map: 301 switch (Type) { 302 case OMPC_MAP_unknown: 303 case OMPC_MAP_MODIFIER_last: 304 return "unknown"; 305 #define OPENMP_MAP_KIND(Name) \ 306 case OMPC_MAP_##Name: \ 307 return #Name; 308 #define OPENMP_MAP_MODIFIER_KIND(Name) \ 309 case OMPC_MAP_MODIFIER_##Name: \ 310 return #Name; 311 #include "clang/Basic/OpenMPKinds.def" 312 default: 313 break; 314 } 315 llvm_unreachable("Invalid OpenMP 'map' clause type"); 316 case OMPC_to: 317 switch (Type) { 318 case OMPC_TO_MODIFIER_unknown: 319 return "unknown"; 320 #define OPENMP_TO_MODIFIER_KIND(Name) \ 321 case OMPC_TO_MODIFIER_##Name: \ 322 return #Name; 323 #include "clang/Basic/OpenMPKinds.def" 324 default: 325 break; 326 } 327 llvm_unreachable("Invalid OpenMP 'to' clause type"); 328 case OMPC_from: 329 switch (Type) { 330 case OMPC_FROM_MODIFIER_unknown: 331 return "unknown"; 332 #define OPENMP_FROM_MODIFIER_KIND(Name) \ 333 case OMPC_FROM_MODIFIER_##Name: \ 334 return #Name; 335 #include "clang/Basic/OpenMPKinds.def" 336 default: 337 break; 338 } 339 llvm_unreachable("Invalid OpenMP 'from' clause type"); 340 case OMPC_dist_schedule: 341 switch (Type) { 342 case OMPC_DIST_SCHEDULE_unknown: 343 return "unknown"; 344 #define OPENMP_DIST_SCHEDULE_KIND(Name) \ 345 case OMPC_DIST_SCHEDULE_##Name: \ 346 return #Name; 347 #include "clang/Basic/OpenMPKinds.def" 348 } 349 llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type"); 350 case OMPC_defaultmap: 351 switch (Type) { 352 case OMPC_DEFAULTMAP_unknown: 353 case OMPC_DEFAULTMAP_MODIFIER_last: 354 return "unknown"; 355 #define OPENMP_DEFAULTMAP_KIND(Name) \ 356 case OMPC_DEFAULTMAP_##Name: \ 357 return #Name; 358 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 359 case OMPC_DEFAULTMAP_MODIFIER_##Name: \ 360 return #Name; 361 #include "clang/Basic/OpenMPKinds.def" 362 } 363 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 364 case OMPC_atomic_default_mem_order: 365 switch (Type) { 366 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown: 367 return "unknown"; 368 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \ 369 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name: \ 370 return #Name; 371 #include "clang/Basic/OpenMPKinds.def" 372 } 373 llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type"); 374 case OMPC_device_type: 375 switch (Type) { 376 case OMPC_DEVICE_TYPE_unknown: 377 return "unknown"; 378 #define OPENMP_DEVICE_TYPE_KIND(Name) \ 379 case OMPC_DEVICE_TYPE_##Name: \ 380 return #Name; 381 #include "clang/Basic/OpenMPKinds.def" 382 } 383 llvm_unreachable("Invalid OpenMP 'device_type' clause type"); 384 case OMPC_lastprivate: 385 switch (Type) { 386 case OMPC_LASTPRIVATE_unknown: 387 return "unknown"; 388 #define OPENMP_LASTPRIVATE_KIND(Name) \ 389 case OMPC_LASTPRIVATE_##Name: \ 390 return #Name; 391 #include "clang/Basic/OpenMPKinds.def" 392 } 393 llvm_unreachable("Invalid OpenMP 'lastprivate' clause type"); 394 case OMPC_order: 395 switch (Type) { 396 case OMPC_ORDER_unknown: 397 return "unknown"; 398 #define OPENMP_ORDER_KIND(Name) \ 399 case OMPC_ORDER_##Name: \ 400 return #Name; 401 #include "clang/Basic/OpenMPKinds.def" 402 } 403 llvm_unreachable("Invalid OpenMP 'order' clause type"); 404 case OMPC_unknown: 405 case OMPC_threadprivate: 406 case OMPC_if: 407 case OMPC_final: 408 case OMPC_num_threads: 409 case OMPC_safelen: 410 case OMPC_simdlen: 411 case OMPC_allocator: 412 case OMPC_allocate: 413 case OMPC_collapse: 414 case OMPC_private: 415 case OMPC_firstprivate: 416 case OMPC_shared: 417 case OMPC_reduction: 418 case OMPC_task_reduction: 419 case OMPC_in_reduction: 420 case OMPC_aligned: 421 case OMPC_copyin: 422 case OMPC_copyprivate: 423 case OMPC_ordered: 424 case OMPC_nowait: 425 case OMPC_untied: 426 case OMPC_mergeable: 427 case OMPC_flush: 428 case OMPC_read: 429 case OMPC_write: 430 case OMPC_update: 431 case OMPC_capture: 432 case OMPC_seq_cst: 433 case OMPC_acq_rel: 434 case OMPC_acquire: 435 case OMPC_release: 436 case OMPC_relaxed: 437 case OMPC_device: 438 case OMPC_threads: 439 case OMPC_simd: 440 case OMPC_num_teams: 441 case OMPC_thread_limit: 442 case OMPC_priority: 443 case OMPC_grainsize: 444 case OMPC_nogroup: 445 case OMPC_num_tasks: 446 case OMPC_hint: 447 case OMPC_uniform: 448 case OMPC_use_device_ptr: 449 case OMPC_is_device_ptr: 450 case OMPC_unified_address: 451 case OMPC_unified_shared_memory: 452 case OMPC_reverse_offload: 453 case OMPC_dynamic_allocators: 454 case OMPC_match: 455 case OMPC_nontemporal: 456 break; 457 } 458 llvm_unreachable("Invalid OpenMP simple clause kind"); 459 } 460 461 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind, 462 OpenMPClauseKind CKind, 463 unsigned OpenMPVersion) { 464 assert(unsigned(DKind) <= unsigned(OMPD_unknown)); 465 assert(CKind <= OMPC_unknown); 466 // Nontemporal clause is not supported in OpenMP < 5.0. 467 if (OpenMPVersion < 50 && CKind == OMPC_nontemporal) 468 return false; 469 // Order clause is not supported in OpenMP < 5.0. 470 if (OpenMPVersion < 50 && CKind == OMPC_order) 471 return false; 472 switch (DKind) { 473 case OMPD_parallel: 474 switch (CKind) { 475 #define OPENMP_PARALLEL_CLAUSE(Name) \ 476 case OMPC_##Name: \ 477 return true; 478 #include "clang/Basic/OpenMPKinds.def" 479 default: 480 break; 481 } 482 break; 483 case OMPD_simd: 484 if (OpenMPVersion < 50 && CKind == OMPC_if) 485 return false; 486 switch (CKind) { 487 #define OPENMP_SIMD_CLAUSE(Name) \ 488 case OMPC_##Name: \ 489 return true; 490 #include "clang/Basic/OpenMPKinds.def" 491 default: 492 break; 493 } 494 break; 495 case OMPD_for: 496 switch (CKind) { 497 #define OPENMP_FOR_CLAUSE(Name) \ 498 case OMPC_##Name: \ 499 return true; 500 #include "clang/Basic/OpenMPKinds.def" 501 default: 502 break; 503 } 504 break; 505 case OMPD_for_simd: 506 if (OpenMPVersion < 50 && CKind == OMPC_if) 507 return false; 508 switch (CKind) { 509 #define OPENMP_FOR_SIMD_CLAUSE(Name) \ 510 case OMPC_##Name: \ 511 return true; 512 #include "clang/Basic/OpenMPKinds.def" 513 default: 514 break; 515 } 516 break; 517 case OMPD_sections: 518 switch (CKind) { 519 #define OPENMP_SECTIONS_CLAUSE(Name) \ 520 case OMPC_##Name: \ 521 return true; 522 #include "clang/Basic/OpenMPKinds.def" 523 default: 524 break; 525 } 526 break; 527 case OMPD_single: 528 switch (CKind) { 529 #define OPENMP_SINGLE_CLAUSE(Name) \ 530 case OMPC_##Name: \ 531 return true; 532 #include "clang/Basic/OpenMPKinds.def" 533 default: 534 break; 535 } 536 break; 537 case OMPD_parallel_for: 538 switch (CKind) { 539 #define OPENMP_PARALLEL_FOR_CLAUSE(Name) \ 540 case OMPC_##Name: \ 541 return true; 542 #include "clang/Basic/OpenMPKinds.def" 543 default: 544 break; 545 } 546 break; 547 case OMPD_parallel_for_simd: 548 switch (CKind) { 549 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 550 case OMPC_##Name: \ 551 return true; 552 #include "clang/Basic/OpenMPKinds.def" 553 default: 554 break; 555 } 556 break; 557 case OMPD_parallel_master: 558 switch (CKind) { 559 #define OPENMP_PARALLEL_MASTER_CLAUSE(Name) \ 560 case OMPC_##Name: \ 561 return true; 562 #include "clang/Basic/OpenMPKinds.def" 563 default: 564 break; 565 } 566 break; 567 case OMPD_parallel_sections: 568 switch (CKind) { 569 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) \ 570 case OMPC_##Name: \ 571 return true; 572 #include "clang/Basic/OpenMPKinds.def" 573 default: 574 break; 575 } 576 break; 577 case OMPD_task: 578 switch (CKind) { 579 #define OPENMP_TASK_CLAUSE(Name) \ 580 case OMPC_##Name: \ 581 return true; 582 #include "clang/Basic/OpenMPKinds.def" 583 default: 584 break; 585 } 586 break; 587 case OMPD_flush: 588 if (CKind == OMPC_flush) 589 return true; 590 if (OpenMPVersion < 50) 591 return false; 592 switch (CKind) { 593 #define OPENMP_FLUSH_CLAUSE(Name) \ 594 case OMPC_##Name: \ 595 return true; 596 #include "clang/Basic/OpenMPKinds.def" 597 default: 598 break; 599 } 600 break; 601 case OMPD_atomic: 602 if (OpenMPVersion < 50 && 603 (CKind == OMPC_acq_rel || CKind == OMPC_acquire || 604 CKind == OMPC_release || CKind == OMPC_relaxed || CKind == OMPC_hint)) 605 return false; 606 switch (CKind) { 607 #define OPENMP_ATOMIC_CLAUSE(Name) \ 608 case OMPC_##Name: \ 609 return true; 610 #include "clang/Basic/OpenMPKinds.def" 611 default: 612 break; 613 } 614 break; 615 case OMPD_target: 616 switch (CKind) { 617 #define OPENMP_TARGET_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_requires: 626 switch (CKind) { 627 #define OPENMP_REQUIRES_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_target_data: 636 switch (CKind) { 637 #define OPENMP_TARGET_DATA_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_enter_data: 646 switch (CKind) { 647 #define OPENMP_TARGET_ENTER_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_exit_data: 656 switch (CKind) { 657 #define OPENMP_TARGET_EXIT_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_parallel: 666 switch (CKind) { 667 #define OPENMP_TARGET_PARALLEL_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_for: 676 switch (CKind) { 677 #define OPENMP_TARGET_PARALLEL_FOR_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_update: 686 switch (CKind) { 687 #define OPENMP_TARGET_UPDATE_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_teams: 696 switch (CKind) { 697 #define OPENMP_TEAMS_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_cancel: 706 switch (CKind) { 707 #define OPENMP_CANCEL_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_ordered: 716 switch (CKind) { 717 #define OPENMP_ORDERED_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_taskloop: 726 switch (CKind) { 727 #define OPENMP_TASKLOOP_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_simd: 736 switch (CKind) { 737 #define OPENMP_TASKLOOP_SIMD_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_master_taskloop: 746 switch (CKind) { 747 #define OPENMP_MASTER_TASKLOOP_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_simd: 756 switch (CKind) { 757 #define OPENMP_MASTER_TASKLOOP_SIMD_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_parallel_master_taskloop: 766 switch (CKind) { 767 #define OPENMP_PARALLEL_MASTER_TASKLOOP_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_simd: 776 switch (CKind) { 777 #define OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_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_critical: 786 switch (CKind) { 787 #define OPENMP_CRITICAL_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_distribute: 796 switch (CKind) { 797 #define OPENMP_DISTRIBUTE_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_parallel_for: 806 switch (CKind) { 807 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_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_simd: 816 switch (CKind) { 817 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_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_simd: 826 if (OpenMPVersion < 50 && CKind == OMPC_if) 827 return false; 828 switch (CKind) { 829 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) \ 830 case OMPC_##Name: \ 831 return true; 832 #include "clang/Basic/OpenMPKinds.def" 833 default: 834 break; 835 } 836 break; 837 case OMPD_target_parallel_for_simd: 838 switch (CKind) { 839 #define OPENMP_TARGET_PARALLEL_FOR_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_simd: 848 switch (CKind) { 849 #define OPENMP_TARGET_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_teams_distribute: 858 switch (CKind) { 859 #define OPENMP_TEAMS_DISTRIBUTE_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_simd: 868 if (OpenMPVersion < 50 && CKind == OMPC_if) 869 return false; 870 switch (CKind) { 871 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \ 872 case OMPC_##Name: \ 873 return true; 874 #include "clang/Basic/OpenMPKinds.def" 875 default: 876 break; 877 } 878 break; 879 case OMPD_teams_distribute_parallel_for_simd: 880 switch (CKind) { 881 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_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: 890 switch (CKind) { 891 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_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_target_teams: 900 switch (CKind) { 901 #define OPENMP_TARGET_TEAMS_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_distribute: 910 switch (CKind) { 911 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_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_parallel_for: 920 switch (CKind) { 921 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_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_simd: 930 switch (CKind) { 931 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_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_simd: 940 switch (CKind) { 941 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_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_taskgroup: 950 switch (CKind) { 951 #define OPENMP_TASKGROUP_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_declare_mapper: 960 switch (CKind) { 961 #define OPENMP_DECLARE_MAPPER_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_allocate: 970 switch (CKind) { 971 #define OPENMP_ALLOCATE_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_declare_variant: 980 switch (CKind) { 981 #define OPENMP_DECLARE_VARIANT_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_target: 990 case OMPD_end_declare_target: 991 case OMPD_unknown: 992 case OMPD_threadprivate: 993 case OMPD_section: 994 case OMPD_master: 995 case OMPD_taskyield: 996 case OMPD_barrier: 997 case OMPD_taskwait: 998 case OMPD_cancellation_point: 999 case OMPD_declare_reduction: 1000 case OMPD_declare_simd: 1001 break; 1002 } 1003 return false; 1004 } 1005 1006 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) { 1007 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd || 1008 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd || 1009 DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 1010 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 1011 DKind == OMPD_parallel_master_taskloop || 1012 DKind == OMPD_parallel_master_taskloop_simd || 1013 DKind == OMPD_distribute || DKind == OMPD_target_parallel_for || 1014 DKind == OMPD_distribute_parallel_for || 1015 DKind == OMPD_distribute_parallel_for_simd || 1016 DKind == OMPD_distribute_simd || 1017 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 1018 DKind == OMPD_teams_distribute || 1019 DKind == OMPD_teams_distribute_simd || 1020 DKind == OMPD_teams_distribute_parallel_for_simd || 1021 DKind == OMPD_teams_distribute_parallel_for || 1022 DKind == OMPD_target_teams_distribute || 1023 DKind == OMPD_target_teams_distribute_parallel_for || 1024 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1025 DKind == OMPD_target_teams_distribute_simd; 1026 } 1027 1028 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { 1029 return DKind == OMPD_for || DKind == OMPD_for_simd || 1030 DKind == OMPD_sections || DKind == OMPD_section || 1031 DKind == OMPD_single || DKind == OMPD_parallel_for || 1032 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 1033 DKind == OMPD_target_parallel_for || 1034 DKind == OMPD_distribute_parallel_for || 1035 DKind == OMPD_distribute_parallel_for_simd || 1036 DKind == OMPD_target_parallel_for_simd || 1037 DKind == OMPD_teams_distribute_parallel_for_simd || 1038 DKind == OMPD_teams_distribute_parallel_for || 1039 DKind == OMPD_target_teams_distribute_parallel_for || 1040 DKind == OMPD_target_teams_distribute_parallel_for_simd; 1041 } 1042 1043 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) { 1044 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 1045 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 1046 DKind == OMPD_parallel_master_taskloop || 1047 DKind == OMPD_parallel_master_taskloop_simd; 1048 } 1049 1050 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) { 1051 return DKind == OMPD_parallel || DKind == OMPD_parallel_for || 1052 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 1053 DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for || 1054 DKind == OMPD_distribute_parallel_for || 1055 DKind == OMPD_distribute_parallel_for_simd || 1056 DKind == OMPD_target_parallel_for_simd || 1057 DKind == OMPD_teams_distribute_parallel_for || 1058 DKind == OMPD_teams_distribute_parallel_for_simd || 1059 DKind == OMPD_target_teams_distribute_parallel_for || 1060 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1061 DKind == OMPD_parallel_master || 1062 DKind == OMPD_parallel_master_taskloop || 1063 DKind == OMPD_parallel_master_taskloop_simd; 1064 } 1065 1066 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) { 1067 return DKind == OMPD_target || DKind == OMPD_target_parallel || 1068 DKind == OMPD_target_parallel_for || 1069 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 1070 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 1071 DKind == OMPD_target_teams_distribute_parallel_for || 1072 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1073 DKind == OMPD_target_teams_distribute_simd; 1074 } 1075 1076 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) { 1077 return DKind == OMPD_target_data || DKind == OMPD_target_enter_data || 1078 DKind == OMPD_target_exit_data || DKind == OMPD_target_update; 1079 } 1080 1081 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) { 1082 return DKind == OMPD_teams || DKind == OMPD_teams_distribute || 1083 DKind == OMPD_teams_distribute_simd || 1084 DKind == OMPD_teams_distribute_parallel_for_simd || 1085 DKind == OMPD_teams_distribute_parallel_for; 1086 } 1087 1088 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) { 1089 return isOpenMPNestingTeamsDirective(DKind) || 1090 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 1091 DKind == OMPD_target_teams_distribute_parallel_for || 1092 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1093 DKind == OMPD_target_teams_distribute_simd; 1094 } 1095 1096 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) { 1097 return DKind == OMPD_simd || DKind == OMPD_for_simd || 1098 DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd || 1099 DKind == OMPD_master_taskloop_simd || 1100 DKind == OMPD_parallel_master_taskloop_simd || 1101 DKind == OMPD_distribute_parallel_for_simd || 1102 DKind == OMPD_distribute_simd || DKind == OMPD_target_simd || 1103 DKind == OMPD_teams_distribute_simd || 1104 DKind == OMPD_teams_distribute_parallel_for_simd || 1105 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1106 DKind == OMPD_target_teams_distribute_simd || 1107 DKind == OMPD_target_parallel_for_simd; 1108 } 1109 1110 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) { 1111 return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for || 1112 Kind == OMPD_distribute_parallel_for_simd || 1113 Kind == OMPD_distribute_simd; 1114 // TODO add next directives. 1115 } 1116 1117 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) { 1118 return isOpenMPNestingDistributeDirective(Kind) || 1119 Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd || 1120 Kind == OMPD_teams_distribute_parallel_for_simd || 1121 Kind == OMPD_teams_distribute_parallel_for || 1122 Kind == OMPD_target_teams_distribute || 1123 Kind == OMPD_target_teams_distribute_parallel_for || 1124 Kind == OMPD_target_teams_distribute_parallel_for_simd || 1125 Kind == OMPD_target_teams_distribute_simd; 1126 } 1127 1128 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) { 1129 return Kind == OMPC_private || Kind == OMPC_firstprivate || 1130 Kind == OMPC_lastprivate || Kind == OMPC_linear || 1131 Kind == OMPC_reduction || Kind == OMPC_task_reduction || 1132 Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'. 1133 } 1134 1135 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) { 1136 return Kind == OMPC_threadprivate || Kind == OMPC_copyin; 1137 } 1138 1139 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) { 1140 return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind); 1141 } 1142 1143 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) { 1144 return Kind == OMPD_distribute_parallel_for || 1145 Kind == OMPD_distribute_parallel_for_simd || 1146 Kind == OMPD_teams_distribute_parallel_for_simd || 1147 Kind == OMPD_teams_distribute_parallel_for || 1148 Kind == OMPD_target_teams_distribute_parallel_for || 1149 Kind == OMPD_target_teams_distribute_parallel_for_simd; 1150 } 1151 1152 void clang::getOpenMPCaptureRegions( 1153 SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions, 1154 OpenMPDirectiveKind DKind) { 1155 assert(DKind <= OMPD_unknown); 1156 switch (DKind) { 1157 case OMPD_parallel: 1158 case OMPD_parallel_for: 1159 case OMPD_parallel_for_simd: 1160 case OMPD_parallel_master: 1161 case OMPD_parallel_sections: 1162 case OMPD_distribute_parallel_for: 1163 case OMPD_distribute_parallel_for_simd: 1164 CaptureRegions.push_back(OMPD_parallel); 1165 break; 1166 case OMPD_target_teams: 1167 case OMPD_target_teams_distribute: 1168 case OMPD_target_teams_distribute_simd: 1169 CaptureRegions.push_back(OMPD_task); 1170 CaptureRegions.push_back(OMPD_target); 1171 CaptureRegions.push_back(OMPD_teams); 1172 break; 1173 case OMPD_teams: 1174 case OMPD_teams_distribute: 1175 case OMPD_teams_distribute_simd: 1176 CaptureRegions.push_back(OMPD_teams); 1177 break; 1178 case OMPD_target: 1179 case OMPD_target_simd: 1180 CaptureRegions.push_back(OMPD_task); 1181 CaptureRegions.push_back(OMPD_target); 1182 break; 1183 case OMPD_teams_distribute_parallel_for: 1184 case OMPD_teams_distribute_parallel_for_simd: 1185 CaptureRegions.push_back(OMPD_teams); 1186 CaptureRegions.push_back(OMPD_parallel); 1187 break; 1188 case OMPD_target_parallel: 1189 case OMPD_target_parallel_for: 1190 case OMPD_target_parallel_for_simd: 1191 CaptureRegions.push_back(OMPD_task); 1192 CaptureRegions.push_back(OMPD_target); 1193 CaptureRegions.push_back(OMPD_parallel); 1194 break; 1195 case OMPD_task: 1196 case OMPD_target_enter_data: 1197 case OMPD_target_exit_data: 1198 case OMPD_target_update: 1199 CaptureRegions.push_back(OMPD_task); 1200 break; 1201 case OMPD_taskloop: 1202 case OMPD_taskloop_simd: 1203 case OMPD_master_taskloop: 1204 case OMPD_master_taskloop_simd: 1205 CaptureRegions.push_back(OMPD_taskloop); 1206 break; 1207 case OMPD_parallel_master_taskloop: 1208 case OMPD_parallel_master_taskloop_simd: 1209 CaptureRegions.push_back(OMPD_parallel); 1210 CaptureRegions.push_back(OMPD_taskloop); 1211 break; 1212 case OMPD_target_teams_distribute_parallel_for: 1213 case OMPD_target_teams_distribute_parallel_for_simd: 1214 CaptureRegions.push_back(OMPD_task); 1215 CaptureRegions.push_back(OMPD_target); 1216 CaptureRegions.push_back(OMPD_teams); 1217 CaptureRegions.push_back(OMPD_parallel); 1218 break; 1219 case OMPD_simd: 1220 case OMPD_for: 1221 case OMPD_for_simd: 1222 case OMPD_sections: 1223 case OMPD_section: 1224 case OMPD_single: 1225 case OMPD_master: 1226 case OMPD_critical: 1227 case OMPD_taskgroup: 1228 case OMPD_distribute: 1229 case OMPD_ordered: 1230 case OMPD_atomic: 1231 case OMPD_target_data: 1232 case OMPD_distribute_simd: 1233 CaptureRegions.push_back(OMPD_unknown); 1234 break; 1235 case OMPD_threadprivate: 1236 case OMPD_allocate: 1237 case OMPD_taskyield: 1238 case OMPD_barrier: 1239 case OMPD_taskwait: 1240 case OMPD_cancellation_point: 1241 case OMPD_cancel: 1242 case OMPD_flush: 1243 case OMPD_declare_reduction: 1244 case OMPD_declare_mapper: 1245 case OMPD_declare_simd: 1246 case OMPD_declare_target: 1247 case OMPD_end_declare_target: 1248 case OMPD_requires: 1249 case OMPD_declare_variant: 1250 llvm_unreachable("OpenMP Directive is not allowed"); 1251 case OMPD_unknown: 1252 llvm_unreachable("Unknown OpenMP directive"); 1253 } 1254 } 1255