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