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