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_device: 218 case OMPC_threads: 219 case OMPC_simd: 220 case OMPC_num_teams: 221 case OMPC_thread_limit: 222 case OMPC_priority: 223 case OMPC_grainsize: 224 case OMPC_nogroup: 225 case OMPC_num_tasks: 226 case OMPC_hint: 227 case OMPC_uniform: 228 case OMPC_use_device_ptr: 229 case OMPC_is_device_ptr: 230 case OMPC_unified_address: 231 case OMPC_unified_shared_memory: 232 case OMPC_reverse_offload: 233 case OMPC_dynamic_allocators: 234 case OMPC_match: 235 case OMPC_nontemporal: 236 break; 237 } 238 llvm_unreachable("Invalid OpenMP simple clause kind"); 239 } 240 241 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, 242 unsigned Type) { 243 switch (Kind) { 244 case OMPC_default: 245 switch (Type) { 246 case OMPC_DEFAULT_unknown: 247 return "unknown"; 248 #define OPENMP_DEFAULT_KIND(Name) \ 249 case OMPC_DEFAULT_##Name: \ 250 return #Name; 251 #include "clang/Basic/OpenMPKinds.def" 252 } 253 llvm_unreachable("Invalid OpenMP 'default' clause type"); 254 case OMPC_proc_bind: 255 switch (Type) { 256 #define OMP_PROC_BIND_KIND(Enum, Name, Value) \ 257 case Value: \ 258 return Name; 259 #include "llvm/Frontend/OpenMP/OMPKinds.def" 260 } 261 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type"); 262 case OMPC_schedule: 263 switch (Type) { 264 case OMPC_SCHEDULE_unknown: 265 case OMPC_SCHEDULE_MODIFIER_last: 266 return "unknown"; 267 #define OPENMP_SCHEDULE_KIND(Name) \ 268 case OMPC_SCHEDULE_##Name: \ 269 return #Name; 270 #define OPENMP_SCHEDULE_MODIFIER(Name) \ 271 case OMPC_SCHEDULE_MODIFIER_##Name: \ 272 return #Name; 273 #include "clang/Basic/OpenMPKinds.def" 274 } 275 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 276 case OMPC_depend: 277 switch (Type) { 278 case OMPC_DEPEND_unknown: 279 return "unknown"; 280 #define OPENMP_DEPEND_KIND(Name) \ 281 case OMPC_DEPEND_##Name: \ 282 return #Name; 283 #include "clang/Basic/OpenMPKinds.def" 284 } 285 llvm_unreachable("Invalid OpenMP 'depend' clause type"); 286 case OMPC_linear: 287 switch (Type) { 288 case OMPC_LINEAR_unknown: 289 return "unknown"; 290 #define OPENMP_LINEAR_KIND(Name) \ 291 case OMPC_LINEAR_##Name: \ 292 return #Name; 293 #include "clang/Basic/OpenMPKinds.def" 294 } 295 llvm_unreachable("Invalid OpenMP 'linear' clause type"); 296 case OMPC_map: 297 switch (Type) { 298 case OMPC_MAP_unknown: 299 case OMPC_MAP_MODIFIER_last: 300 return "unknown"; 301 #define OPENMP_MAP_KIND(Name) \ 302 case OMPC_MAP_##Name: \ 303 return #Name; 304 #define OPENMP_MAP_MODIFIER_KIND(Name) \ 305 case OMPC_MAP_MODIFIER_##Name: \ 306 return #Name; 307 #include "clang/Basic/OpenMPKinds.def" 308 default: 309 break; 310 } 311 llvm_unreachable("Invalid OpenMP 'map' clause type"); 312 case OMPC_to: 313 switch (Type) { 314 case OMPC_TO_MODIFIER_unknown: 315 return "unknown"; 316 #define OPENMP_TO_MODIFIER_KIND(Name) \ 317 case OMPC_TO_MODIFIER_##Name: \ 318 return #Name; 319 #include "clang/Basic/OpenMPKinds.def" 320 default: 321 break; 322 } 323 llvm_unreachable("Invalid OpenMP 'to' clause type"); 324 case OMPC_from: 325 switch (Type) { 326 case OMPC_FROM_MODIFIER_unknown: 327 return "unknown"; 328 #define OPENMP_FROM_MODIFIER_KIND(Name) \ 329 case OMPC_FROM_MODIFIER_##Name: \ 330 return #Name; 331 #include "clang/Basic/OpenMPKinds.def" 332 default: 333 break; 334 } 335 llvm_unreachable("Invalid OpenMP 'from' clause type"); 336 case OMPC_dist_schedule: 337 switch (Type) { 338 case OMPC_DIST_SCHEDULE_unknown: 339 return "unknown"; 340 #define OPENMP_DIST_SCHEDULE_KIND(Name) \ 341 case OMPC_DIST_SCHEDULE_##Name: \ 342 return #Name; 343 #include "clang/Basic/OpenMPKinds.def" 344 } 345 llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type"); 346 case OMPC_defaultmap: 347 switch (Type) { 348 case OMPC_DEFAULTMAP_unknown: 349 case OMPC_DEFAULTMAP_MODIFIER_last: 350 return "unknown"; 351 #define OPENMP_DEFAULTMAP_KIND(Name) \ 352 case OMPC_DEFAULTMAP_##Name: \ 353 return #Name; 354 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 355 case OMPC_DEFAULTMAP_MODIFIER_##Name: \ 356 return #Name; 357 #include "clang/Basic/OpenMPKinds.def" 358 } 359 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 360 case OMPC_atomic_default_mem_order: 361 switch (Type) { 362 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown: 363 return "unknown"; 364 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \ 365 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name: \ 366 return #Name; 367 #include "clang/Basic/OpenMPKinds.def" 368 } 369 llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type"); 370 case OMPC_device_type: 371 switch (Type) { 372 case OMPC_DEVICE_TYPE_unknown: 373 return "unknown"; 374 #define OPENMP_DEVICE_TYPE_KIND(Name) \ 375 case OMPC_DEVICE_TYPE_##Name: \ 376 return #Name; 377 #include "clang/Basic/OpenMPKinds.def" 378 } 379 llvm_unreachable("Invalid OpenMP 'device_type' clause type"); 380 case OMPC_lastprivate: 381 switch (Type) { 382 case OMPC_LASTPRIVATE_unknown: 383 return "unknown"; 384 #define OPENMP_LASTPRIVATE_KIND(Name) \ 385 case OMPC_LASTPRIVATE_##Name: \ 386 return #Name; 387 #include "clang/Basic/OpenMPKinds.def" 388 } 389 llvm_unreachable("Invalid OpenMP 'lastprivate' clause type"); 390 case OMPC_order: 391 switch (Type) { 392 case OMPC_ORDER_unknown: 393 return "unknown"; 394 #define OPENMP_ORDER_KIND(Name) \ 395 case OMPC_ORDER_##Name: \ 396 return #Name; 397 #include "clang/Basic/OpenMPKinds.def" 398 } 399 llvm_unreachable("Invalid OpenMP 'order' clause type"); 400 case OMPC_unknown: 401 case OMPC_threadprivate: 402 case OMPC_if: 403 case OMPC_final: 404 case OMPC_num_threads: 405 case OMPC_safelen: 406 case OMPC_simdlen: 407 case OMPC_allocator: 408 case OMPC_allocate: 409 case OMPC_collapse: 410 case OMPC_private: 411 case OMPC_firstprivate: 412 case OMPC_shared: 413 case OMPC_reduction: 414 case OMPC_task_reduction: 415 case OMPC_in_reduction: 416 case OMPC_aligned: 417 case OMPC_copyin: 418 case OMPC_copyprivate: 419 case OMPC_ordered: 420 case OMPC_nowait: 421 case OMPC_untied: 422 case OMPC_mergeable: 423 case OMPC_flush: 424 case OMPC_read: 425 case OMPC_write: 426 case OMPC_update: 427 case OMPC_capture: 428 case OMPC_seq_cst: 429 case OMPC_device: 430 case OMPC_threads: 431 case OMPC_simd: 432 case OMPC_num_teams: 433 case OMPC_thread_limit: 434 case OMPC_priority: 435 case OMPC_grainsize: 436 case OMPC_nogroup: 437 case OMPC_num_tasks: 438 case OMPC_hint: 439 case OMPC_uniform: 440 case OMPC_use_device_ptr: 441 case OMPC_is_device_ptr: 442 case OMPC_unified_address: 443 case OMPC_unified_shared_memory: 444 case OMPC_reverse_offload: 445 case OMPC_dynamic_allocators: 446 case OMPC_match: 447 case OMPC_nontemporal: 448 break; 449 } 450 llvm_unreachable("Invalid OpenMP simple clause kind"); 451 } 452 453 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind, 454 OpenMPClauseKind CKind, 455 unsigned OpenMPVersion) { 456 assert(unsigned(DKind) <= unsigned(OMPD_unknown)); 457 assert(CKind <= OMPC_unknown); 458 // Nontemporal clause is not supported in OpenMP < 5.0. 459 if (OpenMPVersion < 50 && CKind == OMPC_nontemporal) 460 return false; 461 // Order clause is not supported in OpenMP < 5.0. 462 if (OpenMPVersion < 50 && CKind == OMPC_order) 463 return false; 464 switch (DKind) { 465 case OMPD_parallel: 466 switch (CKind) { 467 #define OPENMP_PARALLEL_CLAUSE(Name) \ 468 case OMPC_##Name: \ 469 return true; 470 #include "clang/Basic/OpenMPKinds.def" 471 default: 472 break; 473 } 474 break; 475 case OMPD_simd: 476 if (OpenMPVersion < 50 && CKind == OMPC_if) 477 return false; 478 switch (CKind) { 479 #define OPENMP_SIMD_CLAUSE(Name) \ 480 case OMPC_##Name: \ 481 return true; 482 #include "clang/Basic/OpenMPKinds.def" 483 default: 484 break; 485 } 486 break; 487 case OMPD_for: 488 switch (CKind) { 489 #define OPENMP_FOR_CLAUSE(Name) \ 490 case OMPC_##Name: \ 491 return true; 492 #include "clang/Basic/OpenMPKinds.def" 493 default: 494 break; 495 } 496 break; 497 case OMPD_for_simd: 498 if (OpenMPVersion < 50 && CKind == OMPC_if) 499 return false; 500 switch (CKind) { 501 #define OPENMP_FOR_SIMD_CLAUSE(Name) \ 502 case OMPC_##Name: \ 503 return true; 504 #include "clang/Basic/OpenMPKinds.def" 505 default: 506 break; 507 } 508 break; 509 case OMPD_sections: 510 switch (CKind) { 511 #define OPENMP_SECTIONS_CLAUSE(Name) \ 512 case OMPC_##Name: \ 513 return true; 514 #include "clang/Basic/OpenMPKinds.def" 515 default: 516 break; 517 } 518 break; 519 case OMPD_single: 520 switch (CKind) { 521 #define OPENMP_SINGLE_CLAUSE(Name) \ 522 case OMPC_##Name: \ 523 return true; 524 #include "clang/Basic/OpenMPKinds.def" 525 default: 526 break; 527 } 528 break; 529 case OMPD_parallel_for: 530 switch (CKind) { 531 #define OPENMP_PARALLEL_FOR_CLAUSE(Name) \ 532 case OMPC_##Name: \ 533 return true; 534 #include "clang/Basic/OpenMPKinds.def" 535 default: 536 break; 537 } 538 break; 539 case OMPD_parallel_for_simd: 540 switch (CKind) { 541 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 542 case OMPC_##Name: \ 543 return true; 544 #include "clang/Basic/OpenMPKinds.def" 545 default: 546 break; 547 } 548 break; 549 case OMPD_parallel_master: 550 switch (CKind) { 551 #define OPENMP_PARALLEL_MASTER_CLAUSE(Name) \ 552 case OMPC_##Name: \ 553 return true; 554 #include "clang/Basic/OpenMPKinds.def" 555 default: 556 break; 557 } 558 break; 559 case OMPD_parallel_sections: 560 switch (CKind) { 561 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) \ 562 case OMPC_##Name: \ 563 return true; 564 #include "clang/Basic/OpenMPKinds.def" 565 default: 566 break; 567 } 568 break; 569 case OMPD_task: 570 switch (CKind) { 571 #define OPENMP_TASK_CLAUSE(Name) \ 572 case OMPC_##Name: \ 573 return true; 574 #include "clang/Basic/OpenMPKinds.def" 575 default: 576 break; 577 } 578 break; 579 case OMPD_flush: 580 return CKind == OMPC_flush; 581 break; 582 case OMPD_atomic: 583 switch (CKind) { 584 #define OPENMP_ATOMIC_CLAUSE(Name) \ 585 case OMPC_##Name: \ 586 return true; 587 #include "clang/Basic/OpenMPKinds.def" 588 default: 589 break; 590 } 591 break; 592 case OMPD_target: 593 switch (CKind) { 594 #define OPENMP_TARGET_CLAUSE(Name) \ 595 case OMPC_##Name: \ 596 return true; 597 #include "clang/Basic/OpenMPKinds.def" 598 default: 599 break; 600 } 601 break; 602 case OMPD_requires: 603 switch (CKind) { 604 #define OPENMP_REQUIRES_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_data: 613 switch (CKind) { 614 #define OPENMP_TARGET_DATA_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_target_enter_data: 623 switch (CKind) { 624 #define OPENMP_TARGET_ENTER_DATA_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_exit_data: 633 switch (CKind) { 634 #define OPENMP_TARGET_EXIT_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_parallel: 643 switch (CKind) { 644 #define OPENMP_TARGET_PARALLEL_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_parallel_for: 653 switch (CKind) { 654 #define OPENMP_TARGET_PARALLEL_FOR_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_update: 663 switch (CKind) { 664 #define OPENMP_TARGET_UPDATE_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_teams: 673 switch (CKind) { 674 #define OPENMP_TEAMS_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_cancel: 683 switch (CKind) { 684 #define OPENMP_CANCEL_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_ordered: 693 switch (CKind) { 694 #define OPENMP_ORDERED_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_taskloop: 703 switch (CKind) { 704 #define OPENMP_TASKLOOP_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_taskloop_simd: 713 switch (CKind) { 714 #define OPENMP_TASKLOOP_SIMD_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_master_taskloop: 723 switch (CKind) { 724 #define OPENMP_MASTER_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_master_taskloop_simd: 733 switch (CKind) { 734 #define OPENMP_MASTER_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_parallel_master_taskloop: 743 switch (CKind) { 744 #define OPENMP_PARALLEL_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_parallel_master_taskloop_simd: 753 switch (CKind) { 754 #define OPENMP_PARALLEL_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_critical: 763 switch (CKind) { 764 #define OPENMP_CRITICAL_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_distribute: 773 switch (CKind) { 774 #define OPENMP_DISTRIBUTE_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_distribute_parallel_for: 783 switch (CKind) { 784 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_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_parallel_for_simd: 793 switch (CKind) { 794 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_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_simd: 803 if (OpenMPVersion < 50 && CKind == OMPC_if) 804 return false; 805 switch (CKind) { 806 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name) \ 807 case OMPC_##Name: \ 808 return true; 809 #include "clang/Basic/OpenMPKinds.def" 810 default: 811 break; 812 } 813 break; 814 case OMPD_target_parallel_for_simd: 815 switch (CKind) { 816 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 817 case OMPC_##Name: \ 818 return true; 819 #include "clang/Basic/OpenMPKinds.def" 820 default: 821 break; 822 } 823 break; 824 case OMPD_target_simd: 825 switch (CKind) { 826 #define OPENMP_TARGET_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_teams_distribute: 835 switch (CKind) { 836 #define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name) \ 837 case OMPC_##Name: \ 838 return true; 839 #include "clang/Basic/OpenMPKinds.def" 840 default: 841 break; 842 } 843 break; 844 case OMPD_teams_distribute_simd: 845 if (OpenMPVersion < 50 && CKind == OMPC_if) 846 return false; 847 switch (CKind) { 848 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name) \ 849 case OMPC_##Name: \ 850 return true; 851 #include "clang/Basic/OpenMPKinds.def" 852 default: 853 break; 854 } 855 break; 856 case OMPD_teams_distribute_parallel_for_simd: 857 switch (CKind) { 858 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 859 case OMPC_##Name: \ 860 return true; 861 #include "clang/Basic/OpenMPKinds.def" 862 default: 863 break; 864 } 865 break; 866 case OMPD_teams_distribute_parallel_for: 867 switch (CKind) { 868 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name) \ 869 case OMPC_##Name: \ 870 return true; 871 #include "clang/Basic/OpenMPKinds.def" 872 default: 873 break; 874 } 875 break; 876 case OMPD_target_teams: 877 switch (CKind) { 878 #define OPENMP_TARGET_TEAMS_CLAUSE(Name) \ 879 case OMPC_##Name: \ 880 return true; 881 #include "clang/Basic/OpenMPKinds.def" 882 default: 883 break; 884 } 885 break; 886 case OMPD_target_teams_distribute: 887 switch (CKind) { 888 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_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_distribute_parallel_for: 897 switch (CKind) { 898 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_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_parallel_for_simd: 907 switch (CKind) { 908 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_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_simd: 917 switch (CKind) { 918 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_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_taskgroup: 927 switch (CKind) { 928 #define OPENMP_TASKGROUP_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_declare_mapper: 937 switch (CKind) { 938 #define OPENMP_DECLARE_MAPPER_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_allocate: 947 switch (CKind) { 948 #define OPENMP_ALLOCATE_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_variant: 957 switch (CKind) { 958 #define OPENMP_DECLARE_VARIANT_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_declare_target: 967 case OMPD_end_declare_target: 968 case OMPD_unknown: 969 case OMPD_threadprivate: 970 case OMPD_section: 971 case OMPD_master: 972 case OMPD_taskyield: 973 case OMPD_barrier: 974 case OMPD_taskwait: 975 case OMPD_cancellation_point: 976 case OMPD_declare_reduction: 977 case OMPD_declare_simd: 978 break; 979 } 980 return false; 981 } 982 983 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) { 984 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd || 985 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd || 986 DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 987 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 988 DKind == OMPD_parallel_master_taskloop || 989 DKind == OMPD_parallel_master_taskloop_simd || 990 DKind == OMPD_distribute || DKind == OMPD_target_parallel_for || 991 DKind == OMPD_distribute_parallel_for || 992 DKind == OMPD_distribute_parallel_for_simd || 993 DKind == OMPD_distribute_simd || 994 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 995 DKind == OMPD_teams_distribute || 996 DKind == OMPD_teams_distribute_simd || 997 DKind == OMPD_teams_distribute_parallel_for_simd || 998 DKind == OMPD_teams_distribute_parallel_for || 999 DKind == OMPD_target_teams_distribute || 1000 DKind == OMPD_target_teams_distribute_parallel_for || 1001 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1002 DKind == OMPD_target_teams_distribute_simd; 1003 } 1004 1005 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { 1006 return DKind == OMPD_for || DKind == OMPD_for_simd || 1007 DKind == OMPD_sections || DKind == OMPD_section || 1008 DKind == OMPD_single || DKind == OMPD_parallel_for || 1009 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 1010 DKind == OMPD_target_parallel_for || 1011 DKind == OMPD_distribute_parallel_for || 1012 DKind == OMPD_distribute_parallel_for_simd || 1013 DKind == OMPD_target_parallel_for_simd || 1014 DKind == OMPD_teams_distribute_parallel_for_simd || 1015 DKind == OMPD_teams_distribute_parallel_for || 1016 DKind == OMPD_target_teams_distribute_parallel_for || 1017 DKind == OMPD_target_teams_distribute_parallel_for_simd; 1018 } 1019 1020 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) { 1021 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 1022 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 1023 DKind == OMPD_parallel_master_taskloop || 1024 DKind == OMPD_parallel_master_taskloop_simd; 1025 } 1026 1027 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) { 1028 return DKind == OMPD_parallel || DKind == OMPD_parallel_for || 1029 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 1030 DKind == OMPD_target_parallel || 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 || 1035 DKind == OMPD_teams_distribute_parallel_for_simd || 1036 DKind == OMPD_target_teams_distribute_parallel_for || 1037 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1038 DKind == OMPD_parallel_master || 1039 DKind == OMPD_parallel_master_taskloop || 1040 DKind == OMPD_parallel_master_taskloop_simd; 1041 } 1042 1043 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) { 1044 return DKind == OMPD_target || DKind == OMPD_target_parallel || 1045 DKind == OMPD_target_parallel_for || 1046 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 1047 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 1048 DKind == OMPD_target_teams_distribute_parallel_for || 1049 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1050 DKind == OMPD_target_teams_distribute_simd; 1051 } 1052 1053 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) { 1054 return DKind == OMPD_target_data || DKind == OMPD_target_enter_data || 1055 DKind == OMPD_target_exit_data || DKind == OMPD_target_update; 1056 } 1057 1058 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) { 1059 return DKind == OMPD_teams || DKind == OMPD_teams_distribute || 1060 DKind == OMPD_teams_distribute_simd || 1061 DKind == OMPD_teams_distribute_parallel_for_simd || 1062 DKind == OMPD_teams_distribute_parallel_for; 1063 } 1064 1065 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) { 1066 return isOpenMPNestingTeamsDirective(DKind) || 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::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) { 1074 return DKind == OMPD_simd || DKind == OMPD_for_simd || 1075 DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd || 1076 DKind == OMPD_master_taskloop_simd || 1077 DKind == OMPD_parallel_master_taskloop_simd || 1078 DKind == OMPD_distribute_parallel_for_simd || 1079 DKind == OMPD_distribute_simd || DKind == OMPD_target_simd || 1080 DKind == OMPD_teams_distribute_simd || 1081 DKind == OMPD_teams_distribute_parallel_for_simd || 1082 DKind == OMPD_target_teams_distribute_parallel_for_simd || 1083 DKind == OMPD_target_teams_distribute_simd || 1084 DKind == OMPD_target_parallel_for_simd; 1085 } 1086 1087 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) { 1088 return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for || 1089 Kind == OMPD_distribute_parallel_for_simd || 1090 Kind == OMPD_distribute_simd; 1091 // TODO add next directives. 1092 } 1093 1094 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) { 1095 return isOpenMPNestingDistributeDirective(Kind) || 1096 Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd || 1097 Kind == OMPD_teams_distribute_parallel_for_simd || 1098 Kind == OMPD_teams_distribute_parallel_for || 1099 Kind == OMPD_target_teams_distribute || 1100 Kind == OMPD_target_teams_distribute_parallel_for || 1101 Kind == OMPD_target_teams_distribute_parallel_for_simd || 1102 Kind == OMPD_target_teams_distribute_simd; 1103 } 1104 1105 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) { 1106 return Kind == OMPC_private || Kind == OMPC_firstprivate || 1107 Kind == OMPC_lastprivate || Kind == OMPC_linear || 1108 Kind == OMPC_reduction || Kind == OMPC_task_reduction || 1109 Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'. 1110 } 1111 1112 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) { 1113 return Kind == OMPC_threadprivate || Kind == OMPC_copyin; 1114 } 1115 1116 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) { 1117 return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind); 1118 } 1119 1120 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) { 1121 return Kind == OMPD_distribute_parallel_for || 1122 Kind == OMPD_distribute_parallel_for_simd || 1123 Kind == OMPD_teams_distribute_parallel_for_simd || 1124 Kind == OMPD_teams_distribute_parallel_for || 1125 Kind == OMPD_target_teams_distribute_parallel_for || 1126 Kind == OMPD_target_teams_distribute_parallel_for_simd; 1127 } 1128 1129 void clang::getOpenMPCaptureRegions( 1130 SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions, 1131 OpenMPDirectiveKind DKind) { 1132 assert(DKind <= OMPD_unknown); 1133 switch (DKind) { 1134 case OMPD_parallel: 1135 case OMPD_parallel_for: 1136 case OMPD_parallel_for_simd: 1137 case OMPD_parallel_master: 1138 case OMPD_parallel_sections: 1139 case OMPD_distribute_parallel_for: 1140 case OMPD_distribute_parallel_for_simd: 1141 CaptureRegions.push_back(OMPD_parallel); 1142 break; 1143 case OMPD_target_teams: 1144 case OMPD_target_teams_distribute: 1145 case OMPD_target_teams_distribute_simd: 1146 CaptureRegions.push_back(OMPD_task); 1147 CaptureRegions.push_back(OMPD_target); 1148 CaptureRegions.push_back(OMPD_teams); 1149 break; 1150 case OMPD_teams: 1151 case OMPD_teams_distribute: 1152 case OMPD_teams_distribute_simd: 1153 CaptureRegions.push_back(OMPD_teams); 1154 break; 1155 case OMPD_target: 1156 case OMPD_target_simd: 1157 CaptureRegions.push_back(OMPD_task); 1158 CaptureRegions.push_back(OMPD_target); 1159 break; 1160 case OMPD_teams_distribute_parallel_for: 1161 case OMPD_teams_distribute_parallel_for_simd: 1162 CaptureRegions.push_back(OMPD_teams); 1163 CaptureRegions.push_back(OMPD_parallel); 1164 break; 1165 case OMPD_target_parallel: 1166 case OMPD_target_parallel_for: 1167 case OMPD_target_parallel_for_simd: 1168 CaptureRegions.push_back(OMPD_task); 1169 CaptureRegions.push_back(OMPD_target); 1170 CaptureRegions.push_back(OMPD_parallel); 1171 break; 1172 case OMPD_task: 1173 case OMPD_target_enter_data: 1174 case OMPD_target_exit_data: 1175 case OMPD_target_update: 1176 CaptureRegions.push_back(OMPD_task); 1177 break; 1178 case OMPD_taskloop: 1179 case OMPD_taskloop_simd: 1180 case OMPD_master_taskloop: 1181 case OMPD_master_taskloop_simd: 1182 CaptureRegions.push_back(OMPD_taskloop); 1183 break; 1184 case OMPD_parallel_master_taskloop: 1185 case OMPD_parallel_master_taskloop_simd: 1186 CaptureRegions.push_back(OMPD_parallel); 1187 CaptureRegions.push_back(OMPD_taskloop); 1188 break; 1189 case OMPD_target_teams_distribute_parallel_for: 1190 case OMPD_target_teams_distribute_parallel_for_simd: 1191 CaptureRegions.push_back(OMPD_task); 1192 CaptureRegions.push_back(OMPD_target); 1193 CaptureRegions.push_back(OMPD_teams); 1194 CaptureRegions.push_back(OMPD_parallel); 1195 break; 1196 case OMPD_simd: 1197 case OMPD_for: 1198 case OMPD_for_simd: 1199 case OMPD_sections: 1200 case OMPD_section: 1201 case OMPD_single: 1202 case OMPD_master: 1203 case OMPD_critical: 1204 case OMPD_taskgroup: 1205 case OMPD_distribute: 1206 case OMPD_ordered: 1207 case OMPD_atomic: 1208 case OMPD_target_data: 1209 case OMPD_distribute_simd: 1210 CaptureRegions.push_back(OMPD_unknown); 1211 break; 1212 case OMPD_threadprivate: 1213 case OMPD_allocate: 1214 case OMPD_taskyield: 1215 case OMPD_barrier: 1216 case OMPD_taskwait: 1217 case OMPD_cancellation_point: 1218 case OMPD_cancel: 1219 case OMPD_flush: 1220 case OMPD_declare_reduction: 1221 case OMPD_declare_mapper: 1222 case OMPD_declare_simd: 1223 case OMPD_declare_target: 1224 case OMPD_end_declare_target: 1225 case OMPD_requires: 1226 case OMPD_declare_variant: 1227 llvm_unreachable("OpenMP Directive is not allowed"); 1228 case OMPD_unknown: 1229 llvm_unreachable("Unknown OpenMP directive"); 1230 } 1231 } 1232