contrib/llvm/tools/clang/lib/Basic/OpenMPKinds.cpp

   1 //===--- OpenMPKinds.cpp - Token Kinds Support ----------------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 /// \file
  10 /// This file implements the OpenMP enum and support functions.
  11 ///
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "clang/Basic/OpenMPKinds.h"
  15 #include "clang/Basic/IdentifierTable.h"
  16 #include "llvm/ADT/StringRef.h"
  17 #include "llvm/ADT/StringSwitch.h"
  18 #include "llvm/Support/ErrorHandling.h"
  19 #include <cassert>
  20
  21 using namespace clang;
  22
  23 OpenMPDirectiveKind clang::getOpenMPDirectiveKind(StringRef Str) {
  24   return llvm::StringSwitch<OpenMPDirectiveKind>(Str)
  25 #define OPENMP_DIRECTIVE(Name) .Case(#Name, OMPD_##Name)
  26 #define OPENMP_DIRECTIVE_EXT(Name, Str) .Case(Str, OMPD_##Name)
  27 #include "clang/Basic/OpenMPKinds.def"
  28       .Default(OMPD_unknown);
  29 }
  30
  31 const char *clang::getOpenMPDirectiveName(OpenMPDirectiveKind Kind) {
  32   assert(Kind <= OMPD_unknown);
  33   switch (Kind) {
  34   case OMPD_unknown:
  35     return "unknown";
  36 #define OPENMP_DIRECTIVE(Name)                                                 \
  37   case OMPD_##Name:                                                            \
  38     return #Name;
  39 #define OPENMP_DIRECTIVE_EXT(Name, Str)                                        \
  40   case OMPD_##Name:                                                            \
  41     return Str;
  42 #include "clang/Basic/OpenMPKinds.def"
  43     break;
  44   }
  45   llvm_unreachable("Invalid OpenMP directive kind");
  46 }
  47
  48 OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) {
  49   // 'flush' clause cannot be specified explicitly, because this is an implicit
  50   // clause for 'flush' directive. If the 'flush' clause is explicitly specified
  51   // the Parser should generate a warning about extra tokens at the end of the
  52   // directive.
  53   if (Str == "flush")
  54     return OMPC_unknown;
  55   return llvm::StringSwitch<OpenMPClauseKind>(Str)
  56 #define OPENMP_CLAUSE(Name, Class) .Case(#Name, OMPC_##Name)
  57 #include "clang/Basic/OpenMPKinds.def"
  58       .Case("uniform", OMPC_uniform)
  59       .Default(OMPC_unknown);
  60 }
  61
  62 const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) {
  63   assert(Kind <= OMPC_unknown);
  64   switch (Kind) {
  65   case OMPC_unknown:
  66     return "unknown";
  67 #define OPENMP_CLAUSE(Name, Class)                                             \
  68   case OMPC_##Name:                                                            \
  69     return #Name;
  70 #include "clang/Basic/OpenMPKinds.def"
  71   case OMPC_uniform:
  72     return "uniform";
  73   case OMPC_threadprivate:
  74     return "threadprivate or thread local";
  75   }
  76   llvm_unreachable("Invalid OpenMP clause kind");
  77 }
  78
  79 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind,
  80                                           StringRef Str) {
  81   switch (Kind) {
  82   case OMPC_default:
  83     return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str)
  84 #define OPENMP_DEFAULT_KIND(Name) .Case(#Name, OMPC_DEFAULT_##Name)
  85 #include "clang/Basic/OpenMPKinds.def"
  86         .Default(OMPC_DEFAULT_unknown);
  87   case OMPC_proc_bind:
  88     return llvm::StringSwitch<OpenMPProcBindClauseKind>(Str)
  89 #define OPENMP_PROC_BIND_KIND(Name) .Case(#Name, OMPC_PROC_BIND_##Name)
  90 #include "clang/Basic/OpenMPKinds.def"
  91         .Default(OMPC_PROC_BIND_unknown);
  92   case OMPC_schedule:
  93     return llvm::StringSwitch<unsigned>(Str)
  94 #define OPENMP_SCHEDULE_KIND(Name)                                             \
  95   .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name))
  96 #define OPENMP_SCHEDULE_MODIFIER(Name)                                         \
  97   .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name))
  98 #include "clang/Basic/OpenMPKinds.def"
  99         .Default(OMPC_SCHEDULE_unknown);
 100   case OMPC_depend:
 101     return llvm::StringSwitch<OpenMPDependClauseKind>(Str)
 102 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name)
 103 #include "clang/Basic/OpenMPKinds.def"
 104         .Default(OMPC_DEPEND_unknown);
 105   case OMPC_linear:
 106     return llvm::StringSwitch<OpenMPLinearClauseKind>(Str)
 107 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name)
 108 #include "clang/Basic/OpenMPKinds.def"
 109         .Default(OMPC_LINEAR_unknown);
 110   case OMPC_map:
 111     return llvm::StringSwitch<unsigned>(Str)
 112 #define OPENMP_MAP_KIND(Name)                                                  \
 113   .Case(#Name, static_cast<unsigned>(OMPC_MAP_##Name))
 114 #define OPENMP_MAP_MODIFIER_KIND(Name)                                         \
 115   .Case(#Name, static_cast<unsigned>(OMPC_MAP_MODIFIER_##Name))
 116 #include "clang/Basic/OpenMPKinds.def"
 117         .Default(OMPC_MAP_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_unknown:
 138   case OMPC_threadprivate:
 139   case OMPC_if:
 140   case OMPC_final:
 141   case OMPC_num_threads:
 142   case OMPC_safelen:
 143   case OMPC_simdlen:
 144   case OMPC_collapse:
 145   case OMPC_private:
 146   case OMPC_firstprivate:
 147   case OMPC_lastprivate:
 148   case OMPC_shared:
 149   case OMPC_reduction:
 150   case OMPC_task_reduction:
 151   case OMPC_in_reduction:
 152   case OMPC_aligned:
 153   case OMPC_copyin:
 154   case OMPC_copyprivate:
 155   case OMPC_ordered:
 156   case OMPC_nowait:
 157   case OMPC_untied:
 158   case OMPC_mergeable:
 159   case OMPC_flush:
 160   case OMPC_read:
 161   case OMPC_write:
 162   case OMPC_update:
 163   case OMPC_capture:
 164   case OMPC_seq_cst:
 165   case OMPC_device:
 166   case OMPC_threads:
 167   case OMPC_simd:
 168   case OMPC_num_teams:
 169   case OMPC_thread_limit:
 170   case OMPC_priority:
 171   case OMPC_grainsize:
 172   case OMPC_nogroup:
 173   case OMPC_num_tasks:
 174   case OMPC_hint:
 175   case OMPC_uniform:
 176   case OMPC_to:
 177   case OMPC_from:
 178   case OMPC_use_device_ptr:
 179   case OMPC_is_device_ptr:
 180   case OMPC_unified_address:
 181   case OMPC_unified_shared_memory:
 182   case OMPC_reverse_offload:
 183   case OMPC_dynamic_allocators:
 184     break;
 185   }
 186   llvm_unreachable("Invalid OpenMP simple clause kind");
 187 }
 188
 189 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
 190                                                  unsigned Type) {
 191   switch (Kind) {
 192   case OMPC_default:
 193     switch (Type) {
 194     case OMPC_DEFAULT_unknown:
 195       return "unknown";
 196 #define OPENMP_DEFAULT_KIND(Name)                                              \
 197   case OMPC_DEFAULT_##Name:                                                    \
 198     return #Name;
 199 #include "clang/Basic/OpenMPKinds.def"
 200     }
 201     llvm_unreachable("Invalid OpenMP 'default' clause type");
 202   case OMPC_proc_bind:
 203     switch (Type) {
 204     case OMPC_PROC_BIND_unknown:
 205       return "unknown";
 206 #define OPENMP_PROC_BIND_KIND(Name)                                            \
 207   case OMPC_PROC_BIND_##Name:                                                  \
 208     return #Name;
 209 #include "clang/Basic/OpenMPKinds.def"
 210     }
 211     llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
 212   case OMPC_schedule:
 213     switch (Type) {
 214     case OMPC_SCHEDULE_unknown:
 215     case OMPC_SCHEDULE_MODIFIER_last:
 216       return "unknown";
 217 #define OPENMP_SCHEDULE_KIND(Name)                                             \
 218     case OMPC_SCHEDULE_##Name:                                                 \
 219       return #Name;
 220 #define OPENMP_SCHEDULE_MODIFIER(Name)                                         \
 221     case OMPC_SCHEDULE_MODIFIER_##Name:                                        \
 222       return #Name;
 223 #include "clang/Basic/OpenMPKinds.def"
 224     }
 225     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
 226   case OMPC_depend:
 227     switch (Type) {
 228     case OMPC_DEPEND_unknown:
 229       return "unknown";
 230 #define OPENMP_DEPEND_KIND(Name)                                             \
 231   case OMPC_DEPEND_##Name:                                                   \
 232     return #Name;
 233 #include "clang/Basic/OpenMPKinds.def"
 234     }
 235     llvm_unreachable("Invalid OpenMP 'depend' clause type");
 236   case OMPC_linear:
 237     switch (Type) {
 238     case OMPC_LINEAR_unknown:
 239       return "unknown";
 240 #define OPENMP_LINEAR_KIND(Name)                                             \
 241   case OMPC_LINEAR_##Name:                                                   \
 242     return #Name;
 243 #include "clang/Basic/OpenMPKinds.def"
 244     }
 245     llvm_unreachable("Invalid OpenMP 'linear' clause type");
 246   case OMPC_map:
 247     switch (Type) {
 248     case OMPC_MAP_unknown:
 249     case OMPC_MAP_MODIFIER_last:
 250       return "unknown";
 251 #define OPENMP_MAP_KIND(Name)                                                \
 252   case OMPC_MAP_##Name:                                                      \
 253     return #Name;
 254 #define OPENMP_MAP_MODIFIER_KIND(Name)                                       \
 255   case OMPC_MAP_MODIFIER_##Name:                                             \
 256     return #Name;
 257 #include "clang/Basic/OpenMPKinds.def"
 258     default:
 259       break;
 260     }
 261     llvm_unreachable("Invalid OpenMP 'map' clause type");
 262   case OMPC_dist_schedule:
 263     switch (Type) {
 264     case OMPC_DIST_SCHEDULE_unknown:
 265       return "unknown";
 266 #define OPENMP_DIST_SCHEDULE_KIND(Name)                                      \
 267   case OMPC_DIST_SCHEDULE_##Name:                                            \
 268     return #Name;
 269 #include "clang/Basic/OpenMPKinds.def"
 270     }
 271     llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type");
 272   case OMPC_defaultmap:
 273     switch (Type) {
 274     case OMPC_DEFAULTMAP_unknown:
 275     case OMPC_DEFAULTMAP_MODIFIER_last:
 276       return "unknown";
 277 #define OPENMP_DEFAULTMAP_KIND(Name)                                         \
 278     case OMPC_DEFAULTMAP_##Name:                                             \
 279       return #Name;
 280 #define OPENMP_DEFAULTMAP_MODIFIER(Name)                                     \
 281     case OMPC_DEFAULTMAP_MODIFIER_##Name:                                    \
 282       return #Name;
 283 #include "clang/Basic/OpenMPKinds.def"
 284     }
 285     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
 286   case OMPC_atomic_default_mem_order:
 287     switch (Type) {
 288     case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown:
 289       return "unknown";
 290 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name)                           \
 291     case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name:                               \
 292       return #Name;
 293 #include "clang/Basic/OpenMPKinds.def"
 294 }
 295     llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type");
 296   case OMPC_unknown:
 297   case OMPC_threadprivate:
 298   case OMPC_if:
 299   case OMPC_final:
 300   case OMPC_num_threads:
 301   case OMPC_safelen:
 302   case OMPC_simdlen:
 303   case OMPC_collapse:
 304   case OMPC_private:
 305   case OMPC_firstprivate:
 306   case OMPC_lastprivate:
 307   case OMPC_shared:
 308   case OMPC_reduction:
 309   case OMPC_task_reduction:
 310   case OMPC_in_reduction:
 311   case OMPC_aligned:
 312   case OMPC_copyin:
 313   case OMPC_copyprivate:
 314   case OMPC_ordered:
 315   case OMPC_nowait:
 316   case OMPC_untied:
 317   case OMPC_mergeable:
 318   case OMPC_flush:
 319   case OMPC_read:
 320   case OMPC_write:
 321   case OMPC_update:
 322   case OMPC_capture:
 323   case OMPC_seq_cst:
 324   case OMPC_device:
 325   case OMPC_threads:
 326   case OMPC_simd:
 327   case OMPC_num_teams:
 328   case OMPC_thread_limit:
 329   case OMPC_priority:
 330   case OMPC_grainsize:
 331   case OMPC_nogroup:
 332   case OMPC_num_tasks:
 333   case OMPC_hint:
 334   case OMPC_uniform:
 335   case OMPC_to:
 336   case OMPC_from:
 337   case OMPC_use_device_ptr:
 338   case OMPC_is_device_ptr:
 339   case OMPC_unified_address:
 340   case OMPC_unified_shared_memory:
 341   case OMPC_reverse_offload:
 342   case OMPC_dynamic_allocators:
 343     break;
 344   }
 345   llvm_unreachable("Invalid OpenMP simple clause kind");
 346 }
 347
 348 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
 349                                         OpenMPClauseKind CKind) {
 350   assert(DKind <= OMPD_unknown);
 351   assert(CKind <= OMPC_unknown);
 352   switch (DKind) {
 353   case OMPD_parallel:
 354     switch (CKind) {
 355 #define OPENMP_PARALLEL_CLAUSE(Name)                                           \
 356   case OMPC_##Name:                                                            \
 357     return true;
 358 #include "clang/Basic/OpenMPKinds.def"
 359     default:
 360       break;
 361     }
 362     break;
 363   case OMPD_simd:
 364     switch (CKind) {
 365 #define OPENMP_SIMD_CLAUSE(Name)                                               \
 366   case OMPC_##Name:                                                            \
 367     return true;
 368 #include "clang/Basic/OpenMPKinds.def"
 369     default:
 370       break;
 371     }
 372     break;
 373   case OMPD_for:
 374     switch (CKind) {
 375 #define OPENMP_FOR_CLAUSE(Name)                                                \
 376   case OMPC_##Name:                                                            \
 377     return true;
 378 #include "clang/Basic/OpenMPKinds.def"
 379     default:
 380       break;
 381     }
 382     break;
 383   case OMPD_for_simd:
 384     switch (CKind) {
 385 #define OPENMP_FOR_SIMD_CLAUSE(Name)                                           \
 386   case OMPC_##Name:                                                            \
 387     return true;
 388 #include "clang/Basic/OpenMPKinds.def"
 389     default:
 390       break;
 391     }
 392     break;
 393   case OMPD_sections:
 394     switch (CKind) {
 395 #define OPENMP_SECTIONS_CLAUSE(Name)                                           \
 396   case OMPC_##Name:                                                            \
 397     return true;
 398 #include "clang/Basic/OpenMPKinds.def"
 399     default:
 400       break;
 401     }
 402     break;
 403   case OMPD_single:
 404     switch (CKind) {
 405 #define OPENMP_SINGLE_CLAUSE(Name)                                             \
 406   case OMPC_##Name:                                                            \
 407     return true;
 408 #include "clang/Basic/OpenMPKinds.def"
 409     default:
 410       break;
 411     }
 412     break;
 413   case OMPD_parallel_for:
 414     switch (CKind) {
 415 #define OPENMP_PARALLEL_FOR_CLAUSE(Name)                                       \
 416   case OMPC_##Name:                                                            \
 417     return true;
 418 #include "clang/Basic/OpenMPKinds.def"
 419     default:
 420       break;
 421     }
 422     break;
 423   case OMPD_parallel_for_simd:
 424     switch (CKind) {
 425 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name)                                  \
 426   case OMPC_##Name:                                                            \
 427     return true;
 428 #include "clang/Basic/OpenMPKinds.def"
 429     default:
 430       break;
 431     }
 432     break;
 433   case OMPD_parallel_sections:
 434     switch (CKind) {
 435 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name)                                  \
 436   case OMPC_##Name:                                                            \
 437     return true;
 438 #include "clang/Basic/OpenMPKinds.def"
 439     default:
 440       break;
 441     }
 442     break;
 443   case OMPD_task:
 444     switch (CKind) {
 445 #define OPENMP_TASK_CLAUSE(Name)                                               \
 446   case OMPC_##Name:                                                            \
 447     return true;
 448 #include "clang/Basic/OpenMPKinds.def"
 449     default:
 450       break;
 451     }
 452     break;
 453   case OMPD_flush:
 454     return CKind == OMPC_flush;
 455     break;
 456   case OMPD_atomic:
 457     switch (CKind) {
 458 #define OPENMP_ATOMIC_CLAUSE(Name)                                             \
 459   case OMPC_##Name:                                                            \
 460     return true;
 461 #include "clang/Basic/OpenMPKinds.def"
 462     default:
 463       break;
 464     }
 465     break;
 466   case OMPD_target:
 467     switch (CKind) {
 468 #define OPENMP_TARGET_CLAUSE(Name)                                             \
 469   case OMPC_##Name:                                                            \
 470     return true;
 471 #include "clang/Basic/OpenMPKinds.def"
 472     default:
 473       break;
 474     }
 475     break;
 476   case OMPD_requires:
 477     switch (CKind) {
 478 #define OPENMP_REQUIRES_CLAUSE(Name)                                             \
 479   case OMPC_##Name:                                                            \
 480     return true;
 481 #include "clang/Basic/OpenMPKinds.def"
 482     default:
 483       break;
 484     }
 485     break;
 486   case OMPD_target_data:
 487     switch (CKind) {
 488 #define OPENMP_TARGET_DATA_CLAUSE(Name)                                        \
 489   case OMPC_##Name:                                                            \
 490     return true;
 491 #include "clang/Basic/OpenMPKinds.def"
 492     default:
 493       break;
 494     }
 495     break;
 496   case OMPD_target_enter_data:
 497     switch (CKind) {
 498 #define OPENMP_TARGET_ENTER_DATA_CLAUSE(Name)                                  \
 499   case OMPC_##Name:                                                            \
 500     return true;
 501 #include "clang/Basic/OpenMPKinds.def"
 502     default:
 503       break;
 504     }
 505     break;
 506   case OMPD_target_exit_data:
 507     switch (CKind) {
 508 #define OPENMP_TARGET_EXIT_DATA_CLAUSE(Name)                                   \
 509   case OMPC_##Name:                                                            \
 510     return true;
 511 #include "clang/Basic/OpenMPKinds.def"
 512     default:
 513       break;
 514     }
 515     break;
 516   case OMPD_target_parallel:
 517     switch (CKind) {
 518 #define OPENMP_TARGET_PARALLEL_CLAUSE(Name)                                    \
 519   case OMPC_##Name:                                                            \
 520     return true;
 521 #include "clang/Basic/OpenMPKinds.def"
 522     default:
 523       break;
 524     }
 525     break;
 526   case OMPD_target_parallel_for:
 527     switch (CKind) {
 528 #define OPENMP_TARGET_PARALLEL_FOR_CLAUSE(Name)                                \
 529   case OMPC_##Name:                                                            \
 530     return true;
 531 #include "clang/Basic/OpenMPKinds.def"
 532     default:
 533       break;
 534     }
 535     break;
 536   case OMPD_target_update:
 537     switch (CKind) {
 538 #define OPENMP_TARGET_UPDATE_CLAUSE(Name)                                      \
 539   case OMPC_##Name:                                                            \
 540     return true;
 541 #include "clang/Basic/OpenMPKinds.def"
 542     default:
 543       break;
 544     }
 545     break;
 546   case OMPD_teams:
 547     switch (CKind) {
 548 #define OPENMP_TEAMS_CLAUSE(Name)                                              \
 549   case OMPC_##Name:                                                            \
 550     return true;
 551 #include "clang/Basic/OpenMPKinds.def"
 552     default:
 553       break;
 554     }
 555     break;
 556   case OMPD_declare_simd:
 557     break;
 558   case OMPD_cancel:
 559     switch (CKind) {
 560 #define OPENMP_CANCEL_CLAUSE(Name)                                             \
 561   case OMPC_##Name:                                                            \
 562     return true;
 563 #include "clang/Basic/OpenMPKinds.def"
 564     default:
 565       break;
 566     }
 567     break;
 568   case OMPD_ordered:
 569     switch (CKind) {
 570 #define OPENMP_ORDERED_CLAUSE(Name)                                            \
 571   case OMPC_##Name:                                                            \
 572     return true;
 573 #include "clang/Basic/OpenMPKinds.def"
 574     default:
 575       break;
 576     }
 577     break;
 578   case OMPD_taskloop:
 579     switch (CKind) {
 580 #define OPENMP_TASKLOOP_CLAUSE(Name)                                           \
 581   case OMPC_##Name:                                                            \
 582     return true;
 583 #include "clang/Basic/OpenMPKinds.def"
 584     default:
 585       break;
 586     }
 587     break;
 588   case OMPD_taskloop_simd:
 589     switch (CKind) {
 590 #define OPENMP_TASKLOOP_SIMD_CLAUSE(Name)                                      \
 591   case OMPC_##Name:                                                            \
 592     return true;
 593 #include "clang/Basic/OpenMPKinds.def"
 594     default:
 595       break;
 596     }
 597     break;
 598   case OMPD_critical:
 599     switch (CKind) {
 600 #define OPENMP_CRITICAL_CLAUSE(Name)                                           \
 601   case OMPC_##Name:                                                            \
 602     return true;
 603 #include "clang/Basic/OpenMPKinds.def"
 604     default:
 605       break;
 606     }
 607     break;
 608   case OMPD_distribute:
 609     switch (CKind) {
 610 #define OPENMP_DISTRIBUTE_CLAUSE(Name)                                         \
 611   case OMPC_##Name:                                                            \
 612     return true;
 613 #include "clang/Basic/OpenMPKinds.def"
 614     default:
 615       break;
 616     }
 617     break;
 618   case OMPD_distribute_parallel_for:
 619     switch (CKind) {
 620 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name)                            \
 621   case OMPC_##Name:                                                            \
 622     return true;
 623 #include "clang/Basic/OpenMPKinds.def"
 624     default:
 625       break;
 626     }
 627     break;
 628   case OMPD_distribute_parallel_for_simd:
 629     switch (CKind) {
 630 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name)                       \
 631   case OMPC_##Name:                                                            \
 632     return true;
 633 #include "clang/Basic/OpenMPKinds.def"
 634     default:
 635       break;
 636     }
 637     break;
 638   case OMPD_distribute_simd:
 639     switch (CKind) {
 640 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name)                                    \
 641   case OMPC_##Name:                                                            \
 642     return true;
 643 #include "clang/Basic/OpenMPKinds.def"
 644     default:
 645       break;
 646     }
 647     break;
 648   case OMPD_target_parallel_for_simd:
 649     switch (CKind) {
 650 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name)                           \
 651   case OMPC_##Name:                                                            \
 652     return true;
 653 #include "clang/Basic/OpenMPKinds.def"
 654     default:
 655       break;
 656     }
 657     break;
 658   case OMPD_target_simd:
 659     switch (CKind) {
 660 #define OPENMP_TARGET_SIMD_CLAUSE(Name)                                        \
 661   case OMPC_##Name:                                                            \
 662     return true;
 663 #include "clang/Basic/OpenMPKinds.def"
 664     default:
 665       break;
 666     }
 667     break;
 668   case OMPD_teams_distribute:
 669     switch (CKind) {
 670 #define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name)                                   \
 671   case OMPC_##Name:                                                            \
 672     return true;
 673 #include "clang/Basic/OpenMPKinds.def"
 674     default:
 675       break;
 676     }
 677     break;
 678   case OMPD_teams_distribute_simd:
 679     switch (CKind) {
 680 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name)                              \
 681   case OMPC_##Name:                                                            \
 682     return true;
 683 #include "clang/Basic/OpenMPKinds.def"
 684     default:
 685       break;
 686     }
 687     break;
 688   case OMPD_teams_distribute_parallel_for_simd:
 689     switch (CKind) {
 690 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name)                 \
 691   case OMPC_##Name:                                                            \
 692     return true;
 693 #include "clang/Basic/OpenMPKinds.def"
 694     default:
 695       break;
 696     }
 697     break;
 698   case OMPD_teams_distribute_parallel_for:
 699     switch (CKind) {
 700 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name)                      \
 701   case OMPC_##Name:                                                            \
 702     return true;
 703 #include "clang/Basic/OpenMPKinds.def"
 704     default:
 705       break;
 706     }
 707     break;
 708   case OMPD_target_teams:
 709     switch (CKind) {
 710 #define OPENMP_TARGET_TEAMS_CLAUSE(Name)                                       \
 711   case OMPC_##Name:                                                            \
 712     return true;
 713 #include "clang/Basic/OpenMPKinds.def"
 714     default:
 715       break;
 716     }
 717     break;
 718   case OMPD_target_teams_distribute:
 719     switch (CKind) {
 720 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name)                            \
 721   case OMPC_##Name:                                                            \
 722     return true;
 723 #include "clang/Basic/OpenMPKinds.def"
 724     default:
 725       break;
 726     }
 727     break;
 728   case OMPD_target_teams_distribute_parallel_for:
 729     switch (CKind) {
 730 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name)               \
 731   case OMPC_##Name:                                                            \
 732     return true;
 733 #include "clang/Basic/OpenMPKinds.def"
 734     default:
 735       break;
 736     }
 737     break;
 738   case OMPD_target_teams_distribute_parallel_for_simd:
 739     switch (CKind) {
 740 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name)          \
 741   case OMPC_##Name:                                                            \
 742     return true;
 743 #include "clang/Basic/OpenMPKinds.def"
 744     default:
 745       break;
 746     }
 747     break;
 748   case OMPD_target_teams_distribute_simd:
 749     switch (CKind) {
 750 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name)                       \
 751   case OMPC_##Name:                                                            \
 752     return true;
 753 #include "clang/Basic/OpenMPKinds.def"
 754     default:
 755       break;
 756     }
 757     break;
 758   case OMPD_taskgroup:
 759     switch (CKind) {
 760 #define OPENMP_TASKGROUP_CLAUSE(Name)                                          \
 761   case OMPC_##Name:                                                            \
 762     return true;
 763 #include "clang/Basic/OpenMPKinds.def"
 764     default:
 765       break;
 766     }
 767     break;
 768   case OMPD_declare_target:
 769   case OMPD_end_declare_target:
 770   case OMPD_unknown:
 771   case OMPD_threadprivate:
 772   case OMPD_section:
 773   case OMPD_master:
 774   case OMPD_taskyield:
 775   case OMPD_barrier:
 776   case OMPD_taskwait:
 777   case OMPD_cancellation_point:
 778   case OMPD_declare_reduction:
 779     break;
 780   }
 781   return false;
 782 }
 783
 784 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
 785   return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
 786          DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
 787          DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
 788          DKind == OMPD_distribute || DKind == OMPD_target_parallel_for ||
 789          DKind == OMPD_distribute_parallel_for ||
 790          DKind == OMPD_distribute_parallel_for_simd ||
 791          DKind == OMPD_distribute_simd ||
 792          DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
 793          DKind == OMPD_teams_distribute ||
 794          DKind == OMPD_teams_distribute_simd ||
 795          DKind == OMPD_teams_distribute_parallel_for_simd ||
 796          DKind == OMPD_teams_distribute_parallel_for ||
 797          DKind == OMPD_target_teams_distribute ||
 798          DKind == OMPD_target_teams_distribute_parallel_for ||
 799          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 800          DKind == OMPD_target_teams_distribute_simd;
 801 }
 802
 803 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
 804   return DKind == OMPD_for || DKind == OMPD_for_simd ||
 805          DKind == OMPD_sections || DKind == OMPD_section ||
 806          DKind == OMPD_single || DKind == OMPD_parallel_for ||
 807          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
 808          DKind == OMPD_target_parallel_for ||
 809          DKind == OMPD_distribute_parallel_for ||
 810          DKind == OMPD_distribute_parallel_for_simd ||
 811          DKind == OMPD_target_parallel_for_simd ||
 812          DKind == OMPD_teams_distribute_parallel_for_simd ||
 813          DKind == OMPD_teams_distribute_parallel_for ||
 814          DKind == OMPD_target_teams_distribute_parallel_for ||
 815          DKind == OMPD_target_teams_distribute_parallel_for_simd;
 816 }
 817
 818 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
 819   return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd;
 820 }
 821
 822 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
 823   return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
 824          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
 825          DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for ||
 826          DKind == OMPD_distribute_parallel_for ||
 827          DKind == OMPD_distribute_parallel_for_simd ||
 828          DKind == OMPD_target_parallel_for_simd ||
 829          DKind == OMPD_teams_distribute_parallel_for ||
 830          DKind == OMPD_teams_distribute_parallel_for_simd ||
 831          DKind == OMPD_target_teams_distribute_parallel_for ||
 832          DKind == OMPD_target_teams_distribute_parallel_for_simd;
 833 }
 834
 835 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) {
 836   return DKind == OMPD_target || DKind == OMPD_target_parallel ||
 837          DKind == OMPD_target_parallel_for ||
 838          DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
 839          DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
 840          DKind == OMPD_target_teams_distribute_parallel_for ||
 841          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 842          DKind == OMPD_target_teams_distribute_simd;
 843 }
 844
 845 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) {
 846   return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
 847          DKind == OMPD_target_exit_data || DKind == OMPD_target_update;
 848 }
 849
 850 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) {
 851   return DKind == OMPD_teams || DKind == OMPD_teams_distribute ||
 852          DKind == OMPD_teams_distribute_simd ||
 853          DKind == OMPD_teams_distribute_parallel_for_simd ||
 854          DKind == OMPD_teams_distribute_parallel_for;
 855 }
 856
 857 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
 858   return isOpenMPNestingTeamsDirective(DKind) ||
 859          DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
 860          DKind == OMPD_target_teams_distribute_parallel_for ||
 861          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 862          DKind == OMPD_target_teams_distribute_simd;
 863 }
 864
 865 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
 866   return DKind == OMPD_simd || DKind == OMPD_for_simd ||
 867          DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd ||
 868          DKind == OMPD_distribute_parallel_for_simd ||
 869          DKind == OMPD_distribute_simd || DKind == OMPD_target_simd ||
 870          DKind == OMPD_teams_distribute_simd ||
 871          DKind == OMPD_teams_distribute_parallel_for_simd ||
 872          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 873          DKind == OMPD_target_teams_distribute_simd ||
 874          DKind == OMPD_target_parallel_for_simd;
 875 }
 876
 877 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) {
 878   return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for ||
 879          Kind == OMPD_distribute_parallel_for_simd ||
 880          Kind == OMPD_distribute_simd;
 881   // TODO add next directives.
 882 }
 883
 884 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) {
 885   return isOpenMPNestingDistributeDirective(Kind) ||
 886          Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd ||
 887          Kind == OMPD_teams_distribute_parallel_for_simd ||
 888          Kind == OMPD_teams_distribute_parallel_for ||
 889          Kind == OMPD_target_teams_distribute ||
 890          Kind == OMPD_target_teams_distribute_parallel_for ||
 891          Kind == OMPD_target_teams_distribute_parallel_for_simd ||
 892          Kind == OMPD_target_teams_distribute_simd;
 893 }
 894
 895 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
 896   return Kind == OMPC_private || Kind == OMPC_firstprivate ||
 897          Kind == OMPC_lastprivate || Kind == OMPC_linear ||
 898          Kind == OMPC_reduction || Kind == OMPC_task_reduction ||
 899          Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'.
 900 }
 901
 902 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
 903   return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
 904 }
 905
 906 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) {
 907   return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
 908 }
 909
 910 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) {
 911   return Kind == OMPD_distribute_parallel_for ||
 912          Kind == OMPD_distribute_parallel_for_simd ||
 913          Kind == OMPD_teams_distribute_parallel_for_simd ||
 914          Kind == OMPD_teams_distribute_parallel_for ||
 915          Kind == OMPD_target_teams_distribute_parallel_for ||
 916          Kind == OMPD_target_teams_distribute_parallel_for_simd;
 917 }
 918
 919 void clang::getOpenMPCaptureRegions(
 920     SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions,
 921     OpenMPDirectiveKind DKind) {
 922   assert(DKind <= OMPD_unknown);
 923   switch (DKind) {
 924   case OMPD_parallel:
 925   case OMPD_parallel_for:
 926   case OMPD_parallel_for_simd:
 927   case OMPD_parallel_sections:
 928   case OMPD_distribute_parallel_for:
 929   case OMPD_distribute_parallel_for_simd:
 930     CaptureRegions.push_back(OMPD_parallel);
 931     break;
 932   case OMPD_target_teams:
 933   case OMPD_target_teams_distribute:
 934   case OMPD_target_teams_distribute_simd:
 935     CaptureRegions.push_back(OMPD_task);
 936     CaptureRegions.push_back(OMPD_target);
 937     CaptureRegions.push_back(OMPD_teams);
 938     break;
 939   case OMPD_teams:
 940   case OMPD_teams_distribute:
 941   case OMPD_teams_distribute_simd:
 942     CaptureRegions.push_back(OMPD_teams);
 943     break;
 944   case OMPD_target:
 945   case OMPD_target_simd:
 946     CaptureRegions.push_back(OMPD_task);
 947     CaptureRegions.push_back(OMPD_target);
 948     break;
 949   case OMPD_teams_distribute_parallel_for:
 950   case OMPD_teams_distribute_parallel_for_simd:
 951     CaptureRegions.push_back(OMPD_teams);
 952     CaptureRegions.push_back(OMPD_parallel);
 953     break;
 954   case OMPD_target_parallel:
 955   case OMPD_target_parallel_for:
 956   case OMPD_target_parallel_for_simd:
 957     CaptureRegions.push_back(OMPD_task);
 958     CaptureRegions.push_back(OMPD_target);
 959     CaptureRegions.push_back(OMPD_parallel);
 960     break;
 961   case OMPD_task:
 962   case OMPD_target_enter_data:
 963   case OMPD_target_exit_data:
 964   case OMPD_target_update:
 965     CaptureRegions.push_back(OMPD_task);
 966     break;
 967   case OMPD_taskloop:
 968   case OMPD_taskloop_simd:
 969     CaptureRegions.push_back(OMPD_taskloop);
 970     break;
 971   case OMPD_target_teams_distribute_parallel_for:
 972   case OMPD_target_teams_distribute_parallel_for_simd:
 973     CaptureRegions.push_back(OMPD_task);
 974     CaptureRegions.push_back(OMPD_target);
 975     CaptureRegions.push_back(OMPD_teams);
 976     CaptureRegions.push_back(OMPD_parallel);
 977     break;
 978   case OMPD_simd:
 979   case OMPD_for:
 980   case OMPD_for_simd:
 981   case OMPD_sections:
 982   case OMPD_section:
 983   case OMPD_single:
 984   case OMPD_master:
 985   case OMPD_critical:
 986   case OMPD_taskgroup:
 987   case OMPD_distribute:
 988   case OMPD_ordered:
 989   case OMPD_atomic:
 990   case OMPD_target_data:
 991   case OMPD_distribute_simd:
 992     CaptureRegions.push_back(OMPD_unknown);
 993     break;
 994   case OMPD_threadprivate:
 995   case OMPD_taskyield:
 996   case OMPD_barrier:
 997   case OMPD_taskwait:
 998   case OMPD_cancellation_point:
 999   case OMPD_cancel:
1000   case OMPD_flush:
1001   case OMPD_declare_reduction:
1002   case OMPD_declare_simd:
1003   case OMPD_declare_target:
1004   case OMPD_end_declare_target:
1005   case OMPD_requires:
1006     llvm_unreachable("OpenMP Directive is not allowed");
1007   case OMPD_unknown:
1008     llvm_unreachable("Unknown OpenMP directive");
1009   }
1010 }