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