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