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_device: 219 case OMPC_threads: 220 case OMPC_simd: 221 case OMPC_num_teams: 222 case OMPC_thread_limit: 223 case OMPC_priority: 224 case OMPC_grainsize: 225 case OMPC_nogroup: 226 case OMPC_num_tasks: 227 case OMPC_hint: 228 case OMPC_uniform: 229 case OMPC_use_device_ptr: 230 case OMPC_is_device_ptr: 231 case OMPC_unified_address: 232 case OMPC_unified_shared_memory: 233 case OMPC_reverse_offload: 234 case OMPC_dynamic_allocators: 235 case OMPC_match: 236 case OMPC_nontemporal: 237 break; 238 } 239 llvm_unreachable("Invalid OpenMP simple clause kind"); 240 } 241 242 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, 243 unsigned Type) { 244 switch (Kind) { 245 case OMPC_default: 246 switch (Type) { 247 case OMPC_DEFAULT_unknown: 248 return "unknown"; 249 #define OPENMP_DEFAULT_KIND(Name) \ 250 case OMPC_DEFAULT_##Name: \ 251 return #Name; 252 #include "clang/Basic/OpenMPKinds.def" 253 } 254 llvm_unreachable("Invalid OpenMP 'default' clause type"); 255 case OMPC_proc_bind: 256 switch (Type) { 257 #define OMP_PROC_BIND_KIND(Enum, Name, Value) \ 258 case Value: \ 259 return Name; 260 #include "llvm/Frontend/OpenMP/OMPKinds.def" 261 } 262 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type"); 263 case OMPC_schedule: 264 switch (Type) { 265 case OMPC_SCHEDULE_unknown: 266 case OMPC_SCHEDULE_MODIFIER_last: 267 return "unknown"; 268 #define OPENMP_SCHEDULE_KIND(Name) \ 269 case OMPC_SCHEDULE_##Name: \ 270 return #Name; 271 #define OPENMP_SCHEDULE_MODIFIER(Name) \ 272 case OMPC_SCHEDULE_MODIFIER_##Name: \ 273 return #Name; 274 #include "clang/Basic/OpenMPKinds.def" 275 } 276 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 277 case OMPC_depend: 278 switch (Type) { 279 case OMPC_DEPEND_unknown: 280 return "unknown"; 281 #define OPENMP_DEPEND_KIND(Name) \ 282 case OMPC_DEPEND_##Name: \ 283 return #Name; 284 #include "clang/Basic/OpenMPKinds.def" 285 } 286 llvm_unreachable("Invalid OpenMP 'depend' clause type"); 287 case OMPC_linear: 288 switch (Type) { 289 case OMPC_LINEAR_unknown: 290 return "unknown"; 291 #define OPENMP_LINEAR_KIND(Name) \ 292 case OMPC_LINEAR_##Name: \ 293 return #Name; 294 #include "clang/Basic/OpenMPKinds.def" 295 } 296 llvm_unreachable("Invalid OpenMP 'linear' clause type"); 297 case OMPC_map: 298 switch (Type) { 299 case OMPC_MAP_unknown: 300 case OMPC_MAP_MODIFIER_last: 301 return "unknown"; 302 #define OPENMP_MAP_KIND(Name) \ 303 case OMPC_MAP_##Name: \ 304 return #Name; 305 #define OPENMP_MAP_MODIFIER_KIND(Name) \ 306 case OMPC_MAP_MODIFIER_##Name: \ 307 return #Name; 308 #include "clang/Basic/OpenMPKinds.def" 309 default: 310 break; 311 } 312 llvm_unreachable("Invalid OpenMP 'map' clause type"); 313 case OMPC_to: 314 switch (Type) { 315 case OMPC_TO_MODIFIER_unknown: 316 return "unknown"; 317 #define OPENMP_TO_MODIFIER_KIND(Name) \ 318 case OMPC_TO_MODIFIER_##Name: \ 319 return #Name; 320 #include "clang/Basic/OpenMPKinds.def" 321 default: 322 break; 323 } 324 llvm_unreachable("Invalid OpenMP 'to' clause type"); 325 case OMPC_from: 326 switch (Type) { 327 case OMPC_FROM_MODIFIER_unknown: 328 return "unknown"; 329 #define OPENMP_FROM_MODIFIER_KIND(Name) \ 330 case OMPC_FROM_MODIFIER_##Name: \ 331 return #Name; 332 #include "clang/Basic/OpenMPKinds.def" 333 default: 334 break; 335 } 336 llvm_unreachable("Invalid OpenMP 'from' clause type"); 337 case OMPC_dist_schedule: 338 switch (Type) { 339 case OMPC_DIST_SCHEDULE_unknown: 340 return "unknown"; 341 #define OPENMP_DIST_SCHEDULE_KIND(Name) \ 342 case OMPC_DIST_SCHEDULE_##Name: \ 343 return #Name; 344 #include "clang/Basic/OpenMPKinds.def" 345 } 346 llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type"); 347 case OMPC_defaultmap: 348 switch (Type) { 349 case OMPC_DEFAULTMAP_unknown: 350 case OMPC_DEFAULTMAP_MODIFIER_last: 351 return "unknown"; 352 #define OPENMP_DEFAULTMAP_KIND(Name) \ 353 case OMPC_DEFAULTMAP_##Name: \ 354 return #Name; 355 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 356 case OMPC_DEFAULTMAP_MODIFIER_##Name: \ 357 return #Name; 358 #include "clang/Basic/OpenMPKinds.def" 359 } 360 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 361 case OMPC_atomic_default_mem_order: 362 switch (Type) { 363 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown: 364 return "unknown"; 365 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \ 366 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name: \ 367 return #Name; 368 #include "clang/Basic/OpenMPKinds.def" 369 } 370 llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type"); 371 case OMPC_device_type: 372 switch (Type) { 373 case OMPC_DEVICE_TYPE_unknown: 374 return "unknown"; 375 #define OPENMP_DEVICE_TYPE_KIND(Name) \ 376 case OMPC_DEVICE_TYPE_##Name: \ 377 return #Name; 378 #include "clang/Basic/OpenMPKinds.def" 379 } 380 llvm_unreachable("Invalid OpenMP 'device_type' clause type"); 381 case OMPC_lastprivate: 382 switch (Type) { 383 case OMPC_LASTPRIVATE_unknown: 384 return "unknown"; 385 #define OPENMP_LASTPRIVATE_KIND(Name) \ 386 case OMPC_LASTPRIVATE_##Name: \ 387 return #Name; 388 #include "clang/Basic/OpenMPKinds.def" 389 } 390 llvm_unreachable("Invalid OpenMP 'lastprivate' clause type"); 391 case OMPC_order: 392 switch (Type) { 393 case OMPC_ORDER_unknown: 394 return "unknown"; 395 #define OPENMP_ORDER_KIND(Name) \ 396 case OMPC_ORDER_##Name: \ 397 return #Name; 398 #include "clang/Basic/OpenMPKinds.def" 399 } 400 llvm_unreachable("Invalid OpenMP 'order' clause type"); 401 case OMPC_unknown: 402 case OMPC_threadprivate: 403 case OMPC_if: 404 case OMPC_final: 405 case OMPC_num_threads: 406 case OMPC_safelen: 407 case OMPC_simdlen: 408 case OMPC_allocator: 409 case OMPC_allocate: 410 case OMPC_collapse: 411 case OMPC_private: 412 case OMPC_firstprivate: 413 case OMPC_shared: 414 case OMPC_reduction: 415 case OMPC_task_reduction: 416 case OMPC_in_reduction: 417 case OMPC_aligned: 418 case OMPC_copyin: 419 case OMPC_copyprivate: 420 case OMPC_ordered: 421 case OMPC_nowait: 422 case OMPC_untied: 423 case OMPC_mergeable: 424 case OMPC_flush: 425 case OMPC_read: 426 case OMPC_write: 427 case OMPC_update: 428 case OMPC_capture: 429 case OMPC_seq_cst: 430 case OMPC_acq_rel: 431 case OMPC_device: 432 case OMPC_threads: 433 case OMPC_simd: 434 case OMPC_num_teams: 435 case OMPC_thread_limit: 436 case OMPC_priority: 437 case OMPC_grainsize: 438 case OMPC_nogroup: 439 case OMPC_num_tasks: 440 case OMPC_hint: 441 case OMPC_uniform: 442 case OMPC_use_device_ptr: 443 case OMPC_is_device_ptr: 444 case OMPC_unified_address: 445 case OMPC_unified_shared_memory: 446 case OMPC_reverse_offload: 447 case OMPC_dynamic_allocators: 448 case OMPC_match: 449 case OMPC_nontemporal: 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 switch (CKind) { 573 #define OPENMP_TASK_CLAUSE(Name) \ 574 case OMPC_##Name: \ 575 return true; 576 #include "clang/Basic/OpenMPKinds.def" 577 default: 578 break; 579 } 580 break; 581 case OMPD_flush: 582 if (CKind == OMPC_flush) 583 return true; 584 if (OpenMPVersion < 50) 585 return false; 586 switch (CKind) { 587 #define OPENMP_FLUSH_CLAUSE(Name) \ 588 case OMPC_##Name: \ 589 return true; 590 #include "clang/Basic/OpenMPKinds.def" 591 default: 592 break; 593 } 594 break; 595 case OMPD_atomic: 596 if (OpenMPVersion < 50 && CKind == OMPC_acq_rel) 597 return false; 598 switch (CKind) { 599 #define OPENMP_ATOMIC_CLAUSE(Name) \ 600 case OMPC_##Name: \ 601 return true; 602 #include "clang/Basic/OpenMPKinds.def" 603 default: 604 break; 605 } 606 break; 607 case OMPD_target: 608 switch (CKind) { 609 #define OPENMP_TARGET_CLAUSE(Name) \ 610 case OMPC_##Name: \ 611 return true; 612 #include "clang/Basic/OpenMPKinds.def" 613 default: 614 break; 615 } 616 break; 617 case OMPD_requires: 618 switch (CKind) { 619 #define OPENMP_REQUIRES_CLAUSE(Name) \ 620 case OMPC_##Name: \ 621 return true; 622 #include "clang/Basic/OpenMPKinds.def" 623 default: 624 break; 625 } 626 break; 627 case OMPD_target_data: 628 switch (CKind) { 629 #define OPENMP_TARGET_DATA_CLAUSE(Name) \ 630 case OMPC_##Name: \ 631 return true; 632 #include "clang/Basic/OpenMPKinds.def" 633 default: 634 break; 635 } 636 break; 637 case OMPD_target_enter_data: 638 switch (CKind) { 639 #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name) \ 640 case OMPC_##Name: \ 641 return true; 642 #include "clang/Basic/OpenMPKinds.def" 643 default: 644 break; 645 } 646 break; 647 case OMPD_target_exit_data: 648 switch (CKind) { 649 #define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name) \ 650 case OMPC_##Name: \ 651 return true; 652 #include "clang/Basic/OpenMPKinds.def" 653 default: 654 break; 655 } 656 break; 657 case OMPD_target_parallel: 658 switch (CKind) { 659 #define OPENMP_TARGET_PARALLEL_CLAUSE(Name) \ 660 case OMPC_##Name: \ 661 return true; 662 #include "clang/Basic/OpenMPKinds.def" 663 default: 664 break; 665 } 666 break; 667 case OMPD_target_parallel_for: 668 switch (CKind) { 669 #define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name) \ 670 case OMPC_##Name: \ 671 return true; 672 #include "clang/Basic/OpenMPKinds.def" 673 default: 674 break; 675 } 676 break; 677 case OMPD_target_update: 678 switch (CKind) { 679 #define OPENMP_TARGET_UPDATE_CLAUSE(Name) \ 680 case OMPC_##Name: \ 681 return true; 682 #include "clang/Basic/OpenMPKinds.def" 683 default: 684 break; 685 } 686 break; 687 case OMPD_teams: 688 switch (CKind) { 689 #define OPENMP_TEAMS_CLAUSE(Name) \ 690 case OMPC_##Name: \ 691 return true; 692 #include "clang/Basic/OpenMPKinds.def" 693 default: 694 break; 695 } 696 break; 697 case OMPD_cancel: 698 switch (CKind) { 699 #define OPENMP_CANCEL_CLAUSE(Name) \ 700 case OMPC_##Name: \ 701 return true; 702 #include "clang/Basic/OpenMPKinds.def" 703 default: 704 break; 705 } 706 break; 707 case OMPD_ordered: 708 switch (CKind) { 709 #define OPENMP_ORDERED_CLAUSE(Name) \ 710 case OMPC_##Name: \ 711 return true; 712 #include "clang/Basic/OpenMPKinds.def" 713 default: 714 break; 715 } 716 break; 717 case OMPD_taskloop: 718 switch (CKind) { 719 #define OPENMP_TASKLOOP_CLAUSE(Name) \ 720 case OMPC_##Name: \ 721 return true; 722 #include "clang/Basic/OpenMPKinds.def" 723 default: 724 break; 725 } 726 break; 727 case OMPD_taskloop_simd: 728 switch (CKind) { 729 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name) \ 730 case OMPC_##Name: \ 731 return true; 732 #include "clang/Basic/OpenMPKinds.def" 733 default: 734 break; 735 } 736 break; 737 case OMPD_master_taskloop: 738 switch (CKind) { 739 #define OPENMP_MASTER_TASKLOOP_CLAUSE(Name) \ 740 case OMPC_##Name: \ 741 return true; 742 #include "clang/Basic/OpenMPKinds.def" 743 default: 744 break; 745 } 746 break; 747 case OMPD_master_taskloop_simd: 748 switch (CKind) { 749 #define OPENMP_MASTER_TASKLOOP_SIMD_CLAUSE(Name) \ 750 case OMPC_##Name: \ 751 return true; 752 #include "clang/Basic/OpenMPKinds.def" 753 default: 754 break; 755 } 756 break; 757 case OMPD_parallel_master_taskloop: 758 switch (CKind) { 759 #define OPENMP_PARALLEL_MASTER_TASKLOOP_CLAUSE(Name) \ 760 case OMPC_##Name: \ 761 return true; 762 #include "clang/Basic/OpenMPKinds.def" 763 default: 764 break; 765 } 766 break; 767 case OMPD_parallel_master_taskloop_simd: 768 switch (CKind) { 769 #define OPENMP_PARALLEL_MASTER_TASKLOOP_SIMD_CLAUSE(Name) \ 770 case OMPC_##Name: \ 771 return true; 772 #include "clang/Basic/OpenMPKinds.def" 773 default: 774 break; 775 } 776 break; 777 case OMPD_critical: 778 switch (CKind) { 779 #define OPENMP_CRITICAL_CLAUSE(Name) \ 780 case OMPC_##Name: \ 781 return true; 782 #include "clang/Basic/OpenMPKinds.def" 783 default: 784 break; 785 } 786 break; 787 case OMPD_distribute: 788 switch (CKind) { 789 #define OPENMP_DISTRIBUTE_CLAUSE(Name) \ 790 case OMPC_##Name: \ 791 return true; 792 #include "clang/Basic/OpenMPKinds.def" 793 default: 794 break; 795 } 796 break; 797 case OMPD_distribute_parallel_for: 798 switch (CKind) { 799 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 800 case OMPC_##Name: \ 801 return true; 802 #include "clang/Basic/OpenMPKinds.def" 803 default: 804 break; 805 } 806 break; 807 case OMPD_distribute_parallel_for_simd: 808 switch (CKind) { 809 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 810 case OMPC_##Name: \ 811 return true; 812 #include "clang/Basic/OpenMPKinds.def" 813 default: 814 break; 815 } 816 break; 817 case OMPD_distribute_simd: 818 if (OpenMPVersion < 50 && CKind == OMPC_if) 819 return false; 820 switch (CKind) { 821 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) \ 822 case OMPC_##Name: \ 823 return true; 824 #include "clang/Basic/OpenMPKinds.def" 825 default: 826 break; 827 } 828 break; 829 case OMPD_target_parallel_for_simd: 830 switch (CKind) { 831 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 832 case OMPC_##Name: \ 833 return true; 834 #include "clang/Basic/OpenMPKinds.def" 835 default: 836 break; 837 } 838 break; 839 case OMPD_target_simd: 840 switch (CKind) { 841 #define OPENMP_TARGET_SIMD_CLAUSE(Name) \ 842 case OMPC_##Name: \ 843 return true; 844 #include "clang/Basic/OpenMPKinds.def" 845 default: 846 break; 847 } 848 break; 849 case OMPD_teams_distribute: 850 switch (CKind) { 851 #define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name) \ 852 case OMPC_##Name: \ 853 return true; 854 #include "clang/Basic/OpenMPKinds.def" 855 default: 856 break; 857 } 858 break; 859 case OMPD_teams_distribute_simd: 860 if (OpenMPVersion < 50 && CKind == OMPC_if) 861 return false; 862 switch (CKind) { 863 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \ 864 case OMPC_##Name: \ 865 return true; 866 #include "clang/Basic/OpenMPKinds.def" 867 default: 868 break; 869 } 870 break; 871 case OMPD_teams_distribute_parallel_for_simd: 872 switch (CKind) { 873 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 874 case OMPC_##Name: \ 875 return true; 876 #include "clang/Basic/OpenMPKinds.def" 877 default: 878 break; 879 } 880 break; 881 case OMPD_teams_distribute_parallel_for: 882 switch (CKind) { 883 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 884 case OMPC_##Name: \ 885 return true; 886 #include "clang/Basic/OpenMPKinds.def" 887 default: 888 break; 889 } 890 break; 891 case OMPD_target_teams: 892 switch (CKind) { 893 #define OPENMP_TARGET_TEAMS_CLAUSE(Name) \ 894 case OMPC_##Name: \ 895 return true; 896 #include "clang/Basic/OpenMPKinds.def" 897 default: 898 break; 899 } 900 break; 901 case OMPD_target_teams_distribute: 902 switch (CKind) { 903 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name) \ 904 case OMPC_##Name: \ 905 return true; 906 #include "clang/Basic/OpenMPKinds.def" 907 default: 908 break; 909 } 910 break; 911 case OMPD_target_teams_distribute_parallel_for: 912 switch (CKind) { 913 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 914 case OMPC_##Name: \ 915 return true; 916 #include "clang/Basic/OpenMPKinds.def" 917 default: 918 break; 919 } 920 break; 921 case OMPD_target_teams_distribute_parallel_for_simd: 922 switch (CKind) { 923 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 924 case OMPC_##Name: \ 925 return true; 926 #include "clang/Basic/OpenMPKinds.def" 927 default: 928 break; 929 } 930 break; 931 case OMPD_target_teams_distribute_simd: 932 switch (CKind) { 933 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \ 934 case OMPC_##Name: \ 935 return true; 936 #include "clang/Basic/OpenMPKinds.def" 937 default: 938 break; 939 } 940 break; 941 case OMPD_taskgroup: 942 switch (CKind) { 943 #define OPENMP_TASKGROUP_CLAUSE(Name) \ 944 case OMPC_##Name: \ 945 return true; 946 #include "clang/Basic/OpenMPKinds.def" 947 default: 948 break; 949 } 950 break; 951 case OMPD_declare_mapper: 952 switch (CKind) { 953 #define OPENMP_DECLARE_MAPPER_CLAUSE(Name) \ 954 case OMPC_##Name: \ 955 return true; 956 #include "clang/Basic/OpenMPKinds.def" 957 default: 958 break; 959 } 960 break; 961 case OMPD_allocate: 962 switch (CKind) { 963 #define OPENMP_ALLOCATE_CLAUSE(Name) \ 964 case OMPC_##Name: \ 965 return true; 966 #include "clang/Basic/OpenMPKinds.def" 967 default: 968 break; 969 } 970 break; 971 case OMPD_declare_variant: 972 switch (CKind) { 973 #define OPENMP_DECLARE_VARIANT_CLAUSE(Name) \ 974 case OMPC_##Name: \ 975 return true; 976 #include "clang/Basic/OpenMPKinds.def" 977 default: 978 break; 979 } 980 break; 981 case OMPD_declare_target: 982 case OMPD_end_declare_target: 983 case OMPD_unknown: 984 case OMPD_threadprivate: 985 case OMPD_section: 986 case OMPD_master: 987 case OMPD_taskyield: 988 case OMPD_barrier: 989 case OMPD_taskwait: 990 case OMPD_cancellation_point: 991 case OMPD_declare_reduction: 992 case OMPD_declare_simd: 993 break; 994 } 995 return false; 996 } 997 998 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) { 999 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd || 1000 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd || 1001 DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 1002 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 1003 DKind == OMPD_parallel_master_taskloop || 1004 DKind == OMPD_parallel_master_taskloop_simd || 1005 DKind == OMPD_distribute || DKind == OMPD_target_parallel_for || 1006 DKind == OMPD_distribute_parallel_for || 1007 DKind == OMPD_distribute_parallel_for_simd || 1008 DKind == OMPD_distribute_simd || 1009 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 1010 DKind == OMPD_teams_distribute || 1011 DKind == OMPD_teams_distribute_simd || 1012 DKind == OMPD_teams_distribute_parallel_for_simd || 1013 DKind == OMPD_teams_distribute_parallel_for || 1014 DKind == OMPD_target_teams_distribute || 1015 DKind == OMPD_target_teams_distribute_parallel_for || 1016 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1017 DKind == OMPD_target_teams_distribute_simd; 1018 } 1019 1020 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { 1021 return DKind == OMPD_for || DKind == OMPD_for_simd || 1022 DKind == OMPD_sections || DKind == OMPD_section || 1023 DKind == OMPD_single || DKind == OMPD_parallel_for || 1024 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 1025 DKind == OMPD_target_parallel_for || 1026 DKind == OMPD_distribute_parallel_for || 1027 DKind == OMPD_distribute_parallel_for_simd || 1028 DKind == OMPD_target_parallel_for_simd || 1029 DKind == OMPD_teams_distribute_parallel_for_simd || 1030 DKind == OMPD_teams_distribute_parallel_for || 1031 DKind == OMPD_target_teams_distribute_parallel_for || 1032 DKind == OMPD_target_teams_distribute_parallel_for_simd; 1033 } 1034 1035 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) { 1036 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 1037 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 1038 DKind == OMPD_parallel_master_taskloop || 1039 DKind == OMPD_parallel_master_taskloop_simd; 1040 } 1041 1042 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) { 1043 return DKind == OMPD_parallel || DKind == OMPD_parallel_for || 1044 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 1045 DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for || 1046 DKind == OMPD_distribute_parallel_for || 1047 DKind == OMPD_distribute_parallel_for_simd || 1048 DKind == OMPD_target_parallel_for_simd || 1049 DKind == OMPD_teams_distribute_parallel_for || 1050 DKind == OMPD_teams_distribute_parallel_for_simd || 1051 DKind == OMPD_target_teams_distribute_parallel_for || 1052 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1053 DKind == OMPD_parallel_master || 1054 DKind == OMPD_parallel_master_taskloop || 1055 DKind == OMPD_parallel_master_taskloop_simd; 1056 } 1057 1058 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) { 1059 return DKind == OMPD_target || DKind == OMPD_target_parallel || 1060 DKind == OMPD_target_parallel_for || 1061 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 1062 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 1063 DKind == OMPD_target_teams_distribute_parallel_for || 1064 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1065 DKind == OMPD_target_teams_distribute_simd; 1066 } 1067 1068 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) { 1069 return DKind == OMPD_target_data || DKind == OMPD_target_enter_data || 1070 DKind == OMPD_target_exit_data || DKind == OMPD_target_update; 1071 } 1072 1073 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) { 1074 return DKind == OMPD_teams || DKind == OMPD_teams_distribute || 1075 DKind == OMPD_teams_distribute_simd || 1076 DKind == OMPD_teams_distribute_parallel_for_simd || 1077 DKind == OMPD_teams_distribute_parallel_for; 1078 } 1079 1080 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) { 1081 return isOpenMPNestingTeamsDirective(DKind) || 1082 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 1083 DKind == OMPD_target_teams_distribute_parallel_for || 1084 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1085 DKind == OMPD_target_teams_distribute_simd; 1086 } 1087 1088 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) { 1089 return DKind == OMPD_simd || DKind == OMPD_for_simd || 1090 DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd || 1091 DKind == OMPD_master_taskloop_simd || 1092 DKind == OMPD_parallel_master_taskloop_simd || 1093 DKind == OMPD_distribute_parallel_for_simd || 1094 DKind == OMPD_distribute_simd || DKind == OMPD_target_simd || 1095 DKind == OMPD_teams_distribute_simd || 1096 DKind == OMPD_teams_distribute_parallel_for_simd || 1097 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1098 DKind == OMPD_target_teams_distribute_simd || 1099 DKind == OMPD_target_parallel_for_simd; 1100 } 1101 1102 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) { 1103 return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for || 1104 Kind == OMPD_distribute_parallel_for_simd || 1105 Kind == OMPD_distribute_simd; 1106 // TODO add next directives. 1107 } 1108 1109 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) { 1110 return isOpenMPNestingDistributeDirective(Kind) || 1111 Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd || 1112 Kind == OMPD_teams_distribute_parallel_for_simd || 1113 Kind == OMPD_teams_distribute_parallel_for || 1114 Kind == OMPD_target_teams_distribute || 1115 Kind == OMPD_target_teams_distribute_parallel_for || 1116 Kind == OMPD_target_teams_distribute_parallel_for_simd || 1117 Kind == OMPD_target_teams_distribute_simd; 1118 } 1119 1120 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) { 1121 return Kind == OMPC_private || Kind == OMPC_firstprivate || 1122 Kind == OMPC_lastprivate || Kind == OMPC_linear || 1123 Kind == OMPC_reduction || Kind == OMPC_task_reduction || 1124 Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'. 1125 } 1126 1127 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) { 1128 return Kind == OMPC_threadprivate || Kind == OMPC_copyin; 1129 } 1130 1131 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) { 1132 return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind); 1133 } 1134 1135 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) { 1136 return Kind == OMPD_distribute_parallel_for || 1137 Kind == OMPD_distribute_parallel_for_simd || 1138 Kind == OMPD_teams_distribute_parallel_for_simd || 1139 Kind == OMPD_teams_distribute_parallel_for || 1140 Kind == OMPD_target_teams_distribute_parallel_for || 1141 Kind == OMPD_target_teams_distribute_parallel_for_simd; 1142 } 1143 1144 void clang::getOpenMPCaptureRegions( 1145 SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions, 1146 OpenMPDirectiveKind DKind) { 1147 assert(DKind <= OMPD_unknown); 1148 switch (DKind) { 1149 case OMPD_parallel: 1150 case OMPD_parallel_for: 1151 case OMPD_parallel_for_simd: 1152 case OMPD_parallel_master: 1153 case OMPD_parallel_sections: 1154 case OMPD_distribute_parallel_for: 1155 case OMPD_distribute_parallel_for_simd: 1156 CaptureRegions.push_back(OMPD_parallel); 1157 break; 1158 case OMPD_target_teams: 1159 case OMPD_target_teams_distribute: 1160 case OMPD_target_teams_distribute_simd: 1161 CaptureRegions.push_back(OMPD_task); 1162 CaptureRegions.push_back(OMPD_target); 1163 CaptureRegions.push_back(OMPD_teams); 1164 break; 1165 case OMPD_teams: 1166 case OMPD_teams_distribute: 1167 case OMPD_teams_distribute_simd: 1168 CaptureRegions.push_back(OMPD_teams); 1169 break; 1170 case OMPD_target: 1171 case OMPD_target_simd: 1172 CaptureRegions.push_back(OMPD_task); 1173 CaptureRegions.push_back(OMPD_target); 1174 break; 1175 case OMPD_teams_distribute_parallel_for: 1176 case OMPD_teams_distribute_parallel_for_simd: 1177 CaptureRegions.push_back(OMPD_teams); 1178 CaptureRegions.push_back(OMPD_parallel); 1179 break; 1180 case OMPD_target_parallel: 1181 case OMPD_target_parallel_for: 1182 case OMPD_target_parallel_for_simd: 1183 CaptureRegions.push_back(OMPD_task); 1184 CaptureRegions.push_back(OMPD_target); 1185 CaptureRegions.push_back(OMPD_parallel); 1186 break; 1187 case OMPD_task: 1188 case OMPD_target_enter_data: 1189 case OMPD_target_exit_data: 1190 case OMPD_target_update: 1191 CaptureRegions.push_back(OMPD_task); 1192 break; 1193 case OMPD_taskloop: 1194 case OMPD_taskloop_simd: 1195 case OMPD_master_taskloop: 1196 case OMPD_master_taskloop_simd: 1197 CaptureRegions.push_back(OMPD_taskloop); 1198 break; 1199 case OMPD_parallel_master_taskloop: 1200 case OMPD_parallel_master_taskloop_simd: 1201 CaptureRegions.push_back(OMPD_parallel); 1202 CaptureRegions.push_back(OMPD_taskloop); 1203 break; 1204 case OMPD_target_teams_distribute_parallel_for: 1205 case OMPD_target_teams_distribute_parallel_for_simd: 1206 CaptureRegions.push_back(OMPD_task); 1207 CaptureRegions.push_back(OMPD_target); 1208 CaptureRegions.push_back(OMPD_teams); 1209 CaptureRegions.push_back(OMPD_parallel); 1210 break; 1211 case OMPD_simd: 1212 case OMPD_for: 1213 case OMPD_for_simd: 1214 case OMPD_sections: 1215 case OMPD_section: 1216 case OMPD_single: 1217 case OMPD_master: 1218 case OMPD_critical: 1219 case OMPD_taskgroup: 1220 case OMPD_distribute: 1221 case OMPD_ordered: 1222 case OMPD_atomic: 1223 case OMPD_target_data: 1224 case OMPD_distribute_simd: 1225 CaptureRegions.push_back(OMPD_unknown); 1226 break; 1227 case OMPD_threadprivate: 1228 case OMPD_allocate: 1229 case OMPD_taskyield: 1230 case OMPD_barrier: 1231 case OMPD_taskwait: 1232 case OMPD_cancellation_point: 1233 case OMPD_cancel: 1234 case OMPD_flush: 1235 case OMPD_declare_reduction: 1236 case OMPD_declare_mapper: 1237 case OMPD_declare_simd: 1238 case OMPD_declare_target: 1239 case OMPD_end_declare_target: 1240 case OMPD_requires: 1241 case OMPD_declare_variant: 1242 llvm_unreachable("OpenMP Directive is not allowed"); 1243 case OMPD_unknown: 1244 llvm_unreachable("Unknown OpenMP directive"); 1245 } 1246 } 1247