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 /// \brief 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<OpenMPMapClauseKind>(Str)
 112 #define OPENMP_MAP_KIND(Name) .Case(#Name, OMPC_MAP_##Name)
 113 #include "clang/Basic/OpenMPKinds.def"
 114         .Default(OMPC_MAP_unknown);
 115   case OMPC_dist_schedule:
 116     return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str)
 117 #define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name)
 118 #include "clang/Basic/OpenMPKinds.def"
 119         .Default(OMPC_DIST_SCHEDULE_unknown);
 120   case OMPC_defaultmap:
 121     return llvm::StringSwitch<unsigned>(Str)
 122 #define OPENMP_DEFAULTMAP_KIND(Name)                                           \
 123   .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name))
 124 #define OPENMP_DEFAULTMAP_MODIFIER(Name)                                       \
 125   .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name))
 126 #include "clang/Basic/OpenMPKinds.def"
 127         .Default(OMPC_DEFAULTMAP_unknown);
 128   case OMPC_unknown:
 129   case OMPC_threadprivate:
 130   case OMPC_if:
 131   case OMPC_final:
 132   case OMPC_num_threads:
 133   case OMPC_safelen:
 134   case OMPC_simdlen:
 135   case OMPC_collapse:
 136   case OMPC_private:
 137   case OMPC_firstprivate:
 138   case OMPC_lastprivate:
 139   case OMPC_shared:
 140   case OMPC_reduction:
 141   case OMPC_aligned:
 142   case OMPC_copyin:
 143   case OMPC_copyprivate:
 144   case OMPC_ordered:
 145   case OMPC_nowait:
 146   case OMPC_untied:
 147   case OMPC_mergeable:
 148   case OMPC_flush:
 149   case OMPC_read:
 150   case OMPC_write:
 151   case OMPC_update:
 152   case OMPC_capture:
 153   case OMPC_seq_cst:
 154   case OMPC_device:
 155   case OMPC_threads:
 156   case OMPC_simd:
 157   case OMPC_num_teams:
 158   case OMPC_thread_limit:
 159   case OMPC_priority:
 160   case OMPC_grainsize:
 161   case OMPC_nogroup:
 162   case OMPC_num_tasks:
 163   case OMPC_hint:
 164   case OMPC_uniform:
 165   case OMPC_to:
 166   case OMPC_from:
 167   case OMPC_use_device_ptr:
 168   case OMPC_is_device_ptr:
 169     break;
 170   }
 171   llvm_unreachable("Invalid OpenMP simple clause kind");
 172 }
 173
 174 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
 175                                                  unsigned Type) {
 176   switch (Kind) {
 177   case OMPC_default:
 178     switch (Type) {
 179     case OMPC_DEFAULT_unknown:
 180       return "unknown";
 181 #define OPENMP_DEFAULT_KIND(Name)                                              \
 182   case OMPC_DEFAULT_##Name:                                                    \
 183     return #Name;
 184 #include "clang/Basic/OpenMPKinds.def"
 185     }
 186     llvm_unreachable("Invalid OpenMP 'default' clause type");
 187   case OMPC_proc_bind:
 188     switch (Type) {
 189     case OMPC_PROC_BIND_unknown:
 190       return "unknown";
 191 #define OPENMP_PROC_BIND_KIND(Name)                                            \
 192   case OMPC_PROC_BIND_##Name:                                                  \
 193     return #Name;
 194 #include "clang/Basic/OpenMPKinds.def"
 195     }
 196     llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
 197   case OMPC_schedule:
 198     switch (Type) {
 199     case OMPC_SCHEDULE_unknown:
 200     case OMPC_SCHEDULE_MODIFIER_last:
 201       return "unknown";
 202 #define OPENMP_SCHEDULE_KIND(Name)                                             \
 203     case OMPC_SCHEDULE_##Name:                                                 \
 204       return #Name;
 205 #define OPENMP_SCHEDULE_MODIFIER(Name)                                         \
 206     case OMPC_SCHEDULE_MODIFIER_##Name:                                        \
 207       return #Name;
 208 #include "clang/Basic/OpenMPKinds.def"
 209     }
 210     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
 211   case OMPC_depend:
 212     switch (Type) {
 213     case OMPC_DEPEND_unknown:
 214       return "unknown";
 215 #define OPENMP_DEPEND_KIND(Name)                                             \
 216   case OMPC_DEPEND_##Name:                                                   \
 217     return #Name;
 218 #include "clang/Basic/OpenMPKinds.def"
 219     }
 220     llvm_unreachable("Invalid OpenMP 'depend' clause type");
 221   case OMPC_linear:
 222     switch (Type) {
 223     case OMPC_LINEAR_unknown:
 224       return "unknown";
 225 #define OPENMP_LINEAR_KIND(Name)                                             \
 226   case OMPC_LINEAR_##Name:                                                   \
 227     return #Name;
 228 #include "clang/Basic/OpenMPKinds.def"
 229     }
 230     llvm_unreachable("Invalid OpenMP 'linear' clause type");
 231   case OMPC_map:
 232     switch (Type) {
 233     case OMPC_MAP_unknown:
 234       return "unknown";
 235 #define OPENMP_MAP_KIND(Name)                                                \
 236   case OMPC_MAP_##Name:                                                      \
 237     return #Name;
 238 #include "clang/Basic/OpenMPKinds.def"
 239     default:
 240       break;
 241     }
 242     llvm_unreachable("Invalid OpenMP 'map' clause type");
 243   case OMPC_dist_schedule:
 244     switch (Type) {
 245     case OMPC_DIST_SCHEDULE_unknown:
 246       return "unknown";
 247 #define OPENMP_DIST_SCHEDULE_KIND(Name)                                      \
 248   case OMPC_DIST_SCHEDULE_##Name:                                            \
 249     return #Name;
 250 #include "clang/Basic/OpenMPKinds.def"
 251     }
 252     llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type");
 253   case OMPC_defaultmap:
 254     switch (Type) {
 255     case OMPC_DEFAULTMAP_unknown:
 256     case OMPC_DEFAULTMAP_MODIFIER_last:
 257       return "unknown";
 258 #define OPENMP_DEFAULTMAP_KIND(Name)                                         \
 259     case OMPC_DEFAULTMAP_##Name:                                             \
 260       return #Name;
 261 #define OPENMP_DEFAULTMAP_MODIFIER(Name)                                     \
 262     case OMPC_DEFAULTMAP_MODIFIER_##Name:                                    \
 263       return #Name;
 264 #include "clang/Basic/OpenMPKinds.def"
 265     }
 266     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
 267   case OMPC_unknown:
 268   case OMPC_threadprivate:
 269   case OMPC_if:
 270   case OMPC_final:
 271   case OMPC_num_threads:
 272   case OMPC_safelen:
 273   case OMPC_simdlen:
 274   case OMPC_collapse:
 275   case OMPC_private:
 276   case OMPC_firstprivate:
 277   case OMPC_lastprivate:
 278   case OMPC_shared:
 279   case OMPC_reduction:
 280   case OMPC_aligned:
 281   case OMPC_copyin:
 282   case OMPC_copyprivate:
 283   case OMPC_ordered:
 284   case OMPC_nowait:
 285   case OMPC_untied:
 286   case OMPC_mergeable:
 287   case OMPC_flush:
 288   case OMPC_read:
 289   case OMPC_write:
 290   case OMPC_update:
 291   case OMPC_capture:
 292   case OMPC_seq_cst:
 293   case OMPC_device:
 294   case OMPC_threads:
 295   case OMPC_simd:
 296   case OMPC_num_teams:
 297   case OMPC_thread_limit:
 298   case OMPC_priority:
 299   case OMPC_grainsize:
 300   case OMPC_nogroup:
 301   case OMPC_num_tasks:
 302   case OMPC_hint:
 303   case OMPC_uniform:
 304   case OMPC_to:
 305   case OMPC_from:
 306   case OMPC_use_device_ptr:
 307   case OMPC_is_device_ptr:
 308     break;
 309   }
 310   llvm_unreachable("Invalid OpenMP simple clause kind");
 311 }
 312
 313 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
 314                                         OpenMPClauseKind CKind) {
 315   assert(DKind <= OMPD_unknown);
 316   assert(CKind <= OMPC_unknown);
 317   switch (DKind) {
 318   case OMPD_parallel:
 319     switch (CKind) {
 320 #define OPENMP_PARALLEL_CLAUSE(Name)                                           \
 321   case OMPC_##Name:                                                            \
 322     return true;
 323 #include "clang/Basic/OpenMPKinds.def"
 324     default:
 325       break;
 326     }
 327     break;
 328   case OMPD_simd:
 329     switch (CKind) {
 330 #define OPENMP_SIMD_CLAUSE(Name)                                               \
 331   case OMPC_##Name:                                                            \
 332     return true;
 333 #include "clang/Basic/OpenMPKinds.def"
 334     default:
 335       break;
 336     }
 337     break;
 338   case OMPD_for:
 339     switch (CKind) {
 340 #define OPENMP_FOR_CLAUSE(Name)                                                \
 341   case OMPC_##Name:                                                            \
 342     return true;
 343 #include "clang/Basic/OpenMPKinds.def"
 344     default:
 345       break;
 346     }
 347     break;
 348   case OMPD_for_simd:
 349     switch (CKind) {
 350 #define OPENMP_FOR_SIMD_CLAUSE(Name)                                           \
 351   case OMPC_##Name:                                                            \
 352     return true;
 353 #include "clang/Basic/OpenMPKinds.def"
 354     default:
 355       break;
 356     }
 357     break;
 358   case OMPD_sections:
 359     switch (CKind) {
 360 #define OPENMP_SECTIONS_CLAUSE(Name)                                           \
 361   case OMPC_##Name:                                                            \
 362     return true;
 363 #include "clang/Basic/OpenMPKinds.def"
 364     default:
 365       break;
 366     }
 367     break;
 368   case OMPD_single:
 369     switch (CKind) {
 370 #define OPENMP_SINGLE_CLAUSE(Name)                                             \
 371   case OMPC_##Name:                                                            \
 372     return true;
 373 #include "clang/Basic/OpenMPKinds.def"
 374     default:
 375       break;
 376     }
 377     break;
 378   case OMPD_parallel_for:
 379     switch (CKind) {
 380 #define OPENMP_PARALLEL_FOR_CLAUSE(Name)                                       \
 381   case OMPC_##Name:                                                            \
 382     return true;
 383 #include "clang/Basic/OpenMPKinds.def"
 384     default:
 385       break;
 386     }
 387     break;
 388   case OMPD_parallel_for_simd:
 389     switch (CKind) {
 390 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name)                                  \
 391   case OMPC_##Name:                                                            \
 392     return true;
 393 #include "clang/Basic/OpenMPKinds.def"
 394     default:
 395       break;
 396     }
 397     break;
 398   case OMPD_parallel_sections:
 399     switch (CKind) {
 400 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name)                                  \
 401   case OMPC_##Name:                                                            \
 402     return true;
 403 #include "clang/Basic/OpenMPKinds.def"
 404     default:
 405       break;
 406     }
 407     break;
 408   case OMPD_task:
 409     switch (CKind) {
 410 #define OPENMP_TASK_CLAUSE(Name)                                               \
 411   case OMPC_##Name:                                                            \
 412     return true;
 413 #include "clang/Basic/OpenMPKinds.def"
 414     default:
 415       break;
 416     }
 417     break;
 418   case OMPD_flush:
 419     return CKind == OMPC_flush;
 420     break;
 421   case OMPD_atomic:
 422     switch (CKind) {
 423 #define OPENMP_ATOMIC_CLAUSE(Name)                                             \
 424   case OMPC_##Name:                                                            \
 425     return true;
 426 #include "clang/Basic/OpenMPKinds.def"
 427     default:
 428       break;
 429     }
 430     break;
 431   case OMPD_target:
 432     switch (CKind) {
 433 #define OPENMP_TARGET_CLAUSE(Name)                                             \
 434   case OMPC_##Name:                                                            \
 435     return true;
 436 #include "clang/Basic/OpenMPKinds.def"
 437     default:
 438       break;
 439     }
 440     break;
 441   case OMPD_target_data:
 442     switch (CKind) {
 443 #define OPENMP_TARGET_DATA_CLAUSE(Name)                                        \
 444   case OMPC_##Name:                                                            \
 445     return true;
 446 #include "clang/Basic/OpenMPKinds.def"
 447     default:
 448       break;
 449     }
 450     break;
 451   case OMPD_target_enter_data:
 452     switch (CKind) {
 453 #define OPENMP_TARGET_ENTER_DATA_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_target_exit_data:
 462     switch (CKind) {
 463 #define OPENMP_TARGET_EXIT_DATA_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_target_parallel:
 472     switch (CKind) {
 473 #define OPENMP_TARGET_PARALLEL_CLAUSE(Name)                                    \
 474   case OMPC_##Name:                                                            \
 475     return true;
 476 #include "clang/Basic/OpenMPKinds.def"
 477     default:
 478       break;
 479     }
 480     break;
 481   case OMPD_target_parallel_for:
 482     switch (CKind) {
 483 #define OPENMP_TARGET_PARALLEL_FOR_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_target_update:
 492     switch (CKind) {
 493 #define OPENMP_TARGET_UPDATE_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_teams:
 502     switch (CKind) {
 503 #define OPENMP_TEAMS_CLAUSE(Name)                                              \
 504   case OMPC_##Name:                                                            \
 505     return true;
 506 #include "clang/Basic/OpenMPKinds.def"
 507     default:
 508       break;
 509     }
 510     break;
 511   case OMPD_declare_simd:
 512     break;
 513   case OMPD_cancel:
 514     switch (CKind) {
 515 #define OPENMP_CANCEL_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_ordered:
 524     switch (CKind) {
 525 #define OPENMP_ORDERED_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_taskloop:
 534     switch (CKind) {
 535 #define OPENMP_TASKLOOP_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_taskloop_simd:
 544     switch (CKind) {
 545 #define OPENMP_TASKLOOP_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_critical:
 554     switch (CKind) {
 555 #define OPENMP_CRITICAL_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_distribute:
 564     switch (CKind) {
 565 #define OPENMP_DISTRIBUTE_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_distribute_parallel_for:
 574     switch (CKind) {
 575 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name)                            \
 576   case OMPC_##Name:                                                            \
 577     return true;
 578 #include "clang/Basic/OpenMPKinds.def"
 579     default:
 580       break;
 581     }
 582     break;
 583   case OMPD_distribute_parallel_for_simd:
 584     switch (CKind) {
 585 #define OPENMP_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name)                       \
 586   case OMPC_##Name:                                                            \
 587     return true;
 588 #include "clang/Basic/OpenMPKinds.def"
 589     default:
 590       break;
 591     }
 592     break;
 593   case OMPD_distribute_simd:
 594     switch (CKind) {
 595 #define OPENMP_DISTRIBUTE_SIMD_CLAUSE(Name)                                    \
 596   case OMPC_##Name:                                                            \
 597     return true;
 598 #include "clang/Basic/OpenMPKinds.def"
 599     default:
 600       break;
 601     }
 602     break;
 603   case OMPD_target_parallel_for_simd:
 604     switch (CKind) {
 605 #define OPENMP_TARGET_PARALLEL_FOR_SIMD_CLAUSE(Name)                           \
 606   case OMPC_##Name:                                                            \
 607     return true;
 608 #include "clang/Basic/OpenMPKinds.def"
 609     default:
 610       break;
 611     }
 612     break;
 613   case OMPD_target_simd:
 614     switch (CKind) {
 615 #define OPENMP_TARGET_SIMD_CLAUSE(Name)                                        \
 616   case OMPC_##Name:                                                            \
 617     return true;
 618 #include "clang/Basic/OpenMPKinds.def"
 619     default:
 620       break;
 621     }
 622     break;
 623   case OMPD_teams_distribute:
 624     switch (CKind) {
 625 #define OPENMP_TEAMS_DISTRIBUTE_CLAUSE(Name)                                   \
 626   case OMPC_##Name:                                                            \
 627     return true;
 628 #include "clang/Basic/OpenMPKinds.def"
 629     default:
 630       break;
 631     }
 632     break;
 633   case OMPD_teams_distribute_simd:
 634     switch (CKind) {
 635 #define OPENMP_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name)                              \
 636   case OMPC_##Name:                                                            \
 637     return true;
 638 #include "clang/Basic/OpenMPKinds.def"
 639     default:
 640       break;
 641     }
 642     break;
 643   case OMPD_teams_distribute_parallel_for_simd:
 644     switch (CKind) {
 645 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name)                 \
 646   case OMPC_##Name:                                                            \
 647     return true;
 648 #include "clang/Basic/OpenMPKinds.def"
 649     default:
 650       break;
 651     }
 652     break;
 653   case OMPD_teams_distribute_parallel_for:
 654     switch (CKind) {
 655 #define OPENMP_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name)                      \
 656   case OMPC_##Name:                                                            \
 657     return true;
 658 #include "clang/Basic/OpenMPKinds.def"
 659     default:
 660       break;
 661     }
 662     break;
 663   case OMPD_target_teams:
 664     switch (CKind) {
 665 #define OPENMP_TARGET_TEAMS_CLAUSE(Name)                                       \
 666   case OMPC_##Name:                                                            \
 667     return true;
 668 #include "clang/Basic/OpenMPKinds.def"
 669     default:
 670       break;
 671     }
 672     break;
 673   case OMPD_target_teams_distribute:
 674     switch (CKind) {
 675 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_CLAUSE(Name)                            \
 676   case OMPC_##Name:                                                            \
 677     return true;
 678 #include "clang/Basic/OpenMPKinds.def"
 679     default:
 680       break;
 681     }
 682     break;
 683   case OMPD_target_teams_distribute_parallel_for:
 684     switch (CKind) {
 685 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_CLAUSE(Name)               \
 686   case OMPC_##Name:                                                            \
 687     return true;
 688 #include "clang/Basic/OpenMPKinds.def"
 689     default:
 690       break;
 691     }
 692     break;
 693   case OMPD_target_teams_distribute_parallel_for_simd:
 694     switch (CKind) {
 695 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_PARALLEL_FOR_SIMD_CLAUSE(Name)          \
 696   case OMPC_##Name:                                                            \
 697     return true;
 698 #include "clang/Basic/OpenMPKinds.def"
 699     default:
 700       break;
 701     }
 702     break;
 703   case OMPD_target_teams_distribute_simd:
 704     switch (CKind) {
 705 #define OPENMP_TARGET_TEAMS_DISTRIBUTE_SIMD_CLAUSE(Name)                       \
 706   case OMPC_##Name:                                                            \
 707     return true;
 708 #include "clang/Basic/OpenMPKinds.def"
 709     default:
 710       break;
 711     }
 712     break;
 713   case OMPD_declare_target:
 714   case OMPD_end_declare_target:
 715   case OMPD_unknown:
 716   case OMPD_threadprivate:
 717   case OMPD_section:
 718   case OMPD_master:
 719   case OMPD_taskyield:
 720   case OMPD_barrier:
 721   case OMPD_taskwait:
 722   case OMPD_taskgroup:
 723   case OMPD_cancellation_point:
 724   case OMPD_declare_reduction:
 725     break;
 726   }
 727   return false;
 728 }
 729
 730 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
 731   return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
 732          DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
 733          DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
 734          DKind == OMPD_distribute || DKind == OMPD_target_parallel_for ||
 735          DKind == OMPD_distribute_parallel_for ||
 736          DKind == OMPD_distribute_parallel_for_simd ||
 737          DKind == OMPD_distribute_simd ||
 738          DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
 739          DKind == OMPD_teams_distribute ||
 740          DKind == OMPD_teams_distribute_simd ||
 741          DKind == OMPD_teams_distribute_parallel_for_simd ||
 742          DKind == OMPD_teams_distribute_parallel_for ||
 743          DKind == OMPD_target_teams_distribute ||
 744          DKind == OMPD_target_teams_distribute_parallel_for ||
 745          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 746          DKind == OMPD_target_teams_distribute_simd;
 747 }
 748
 749 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
 750   return DKind == OMPD_for || DKind == OMPD_for_simd ||
 751          DKind == OMPD_sections || DKind == OMPD_section ||
 752          DKind == OMPD_single || DKind == OMPD_parallel_for ||
 753          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
 754          DKind == OMPD_target_parallel_for ||
 755          DKind == OMPD_distribute_parallel_for ||
 756          DKind == OMPD_distribute_parallel_for_simd ||
 757          DKind == OMPD_target_parallel_for_simd ||
 758          DKind == OMPD_teams_distribute_parallel_for_simd ||
 759          DKind == OMPD_teams_distribute_parallel_for ||
 760          DKind == OMPD_target_teams_distribute_parallel_for ||
 761          DKind == OMPD_target_teams_distribute_parallel_for_simd;
 762 }
 763
 764 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
 765   return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd;
 766 }
 767
 768 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
 769   return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
 770          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
 771          DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for ||
 772          DKind == OMPD_distribute_parallel_for ||
 773          DKind == OMPD_distribute_parallel_for_simd ||
 774          DKind == OMPD_target_parallel_for_simd ||
 775          DKind == OMPD_teams_distribute_parallel_for ||
 776          DKind == OMPD_teams_distribute_parallel_for_simd ||
 777          DKind == OMPD_target_teams_distribute_parallel_for ||
 778          DKind == OMPD_target_teams_distribute_parallel_for_simd;
 779 }
 780
 781 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) {
 782   return DKind == OMPD_target || DKind == OMPD_target_parallel ||
 783          DKind == OMPD_target_parallel_for ||
 784          DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
 785          DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
 786          DKind == OMPD_target_teams_distribute_parallel_for ||
 787          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 788          DKind == OMPD_target_teams_distribute_simd;
 789 }
 790
 791 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) {
 792   return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
 793          DKind == OMPD_target_exit_data || DKind == OMPD_target_update;
 794 }
 795
 796 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) {
 797   return DKind == OMPD_teams || DKind == OMPD_teams_distribute ||
 798          DKind == OMPD_teams_distribute_simd ||
 799          DKind == OMPD_teams_distribute_parallel_for_simd ||
 800          DKind == OMPD_teams_distribute_parallel_for;
 801 }
 802
 803 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
 804   return isOpenMPNestingTeamsDirective(DKind) ||
 805          DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
 806          DKind == OMPD_target_teams_distribute_parallel_for ||
 807          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 808          DKind == OMPD_target_teams_distribute_simd;
 809 }
 810
 811 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
 812   return DKind == OMPD_simd || DKind == OMPD_for_simd ||
 813          DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd ||
 814          DKind == OMPD_distribute_parallel_for_simd ||
 815          DKind == OMPD_distribute_simd || DKind == OMPD_target_simd ||
 816          DKind == OMPD_teams_distribute_simd ||
 817          DKind == OMPD_teams_distribute_parallel_for_simd ||
 818          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 819          DKind == OMPD_target_teams_distribute_simd;
 820 }
 821
 822 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) {
 823   return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for ||
 824          Kind == OMPD_distribute_parallel_for_simd ||
 825          Kind == OMPD_distribute_simd;
 826   // TODO add next directives.
 827 }
 828
 829 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) {
 830   return isOpenMPNestingDistributeDirective(Kind) ||
 831          Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd ||
 832          Kind == OMPD_teams_distribute_parallel_for_simd ||
 833          Kind == OMPD_teams_distribute_parallel_for ||
 834          Kind == OMPD_target_teams_distribute ||
 835          Kind == OMPD_target_teams_distribute_parallel_for ||
 836          Kind == OMPD_target_teams_distribute_parallel_for_simd ||
 837          Kind == OMPD_target_teams_distribute_simd;
 838 }
 839
 840 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
 841   return Kind == OMPC_private || Kind == OMPC_firstprivate ||
 842          Kind == OMPC_lastprivate || Kind == OMPC_linear ||
 843          Kind == OMPC_reduction; // TODO add next clauses like 'reduction'.
 844 }
 845
 846 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
 847   return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
 848 }
 849
 850 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) {
 851   return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
 852 }
 853
 854 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) {
 855   return Kind == OMPD_distribute_parallel_for ||
 856          Kind == OMPD_distribute_parallel_for_simd ||
 857          Kind == OMPD_distribute_simd || Kind == OMPD_teams_distribute ||
 858          Kind == OMPD_teams_distribute_simd ||
 859          Kind == OMPD_teams_distribute_parallel_for_simd ||
 860          Kind == OMPD_teams_distribute_parallel_for ||
 861          Kind == OMPD_target_teams_distribute ||
 862          Kind == OMPD_target_teams_distribute_parallel_for ||
 863          Kind == OMPD_target_teams_distribute_parallel_for_simd ||
 864          Kind == OMPD_target_teams_distribute_simd;
 865 }
 866
 867 void clang::getOpenMPCaptureRegions(
 868     SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions,
 869     OpenMPDirectiveKind DKind) {
 870   assert(DKind <= OMPD_unknown);
 871   switch (DKind) {
 872   case OMPD_parallel:
 873   case OMPD_parallel_for:
 874   case OMPD_parallel_for_simd:
 875   case OMPD_parallel_sections:
 876   case OMPD_distribute_parallel_for:
 877     CaptureRegions.push_back(OMPD_parallel);
 878     break;
 879   case OMPD_target_teams:
 880     CaptureRegions.push_back(OMPD_target);
 881     CaptureRegions.push_back(OMPD_teams);
 882     break;
 883   case OMPD_teams:
 884   case OMPD_simd:
 885   case OMPD_for:
 886   case OMPD_for_simd:
 887   case OMPD_sections:
 888   case OMPD_section:
 889   case OMPD_single:
 890   case OMPD_master:
 891   case OMPD_critical:
 892   case OMPD_taskgroup:
 893   case OMPD_distribute:
 894   case OMPD_ordered:
 895   case OMPD_atomic:
 896   case OMPD_target_data:
 897   case OMPD_target:
 898   case OMPD_target_parallel_for:
 899   case OMPD_target_parallel_for_simd:
 900   case OMPD_target_simd:
 901   case OMPD_task:
 902   case OMPD_taskloop:
 903   case OMPD_taskloop_simd:
 904   case OMPD_distribute_parallel_for_simd:
 905   case OMPD_distribute_simd:
 906   case OMPD_teams_distribute:
 907   case OMPD_teams_distribute_simd:
 908   case OMPD_teams_distribute_parallel_for_simd:
 909   case OMPD_teams_distribute_parallel_for:
 910   case OMPD_target_teams_distribute:
 911   case OMPD_target_teams_distribute_parallel_for:
 912   case OMPD_target_teams_distribute_parallel_for_simd:
 913   case OMPD_target_teams_distribute_simd:
 914     CaptureRegions.push_back(DKind);
 915     break;
 916   case OMPD_target_parallel:
 917     CaptureRegions.push_back(OMPD_target);
 918     CaptureRegions.push_back(OMPD_parallel);
 919     break;
 920   case OMPD_threadprivate:
 921   case OMPD_taskyield:
 922   case OMPD_barrier:
 923   case OMPD_taskwait:
 924   case OMPD_cancellation_point:
 925   case OMPD_cancel:
 926   case OMPD_flush:
 927   case OMPD_target_enter_data:
 928   case OMPD_target_exit_data:
 929   case OMPD_declare_reduction:
 930   case OMPD_declare_simd:
 931   case OMPD_declare_target:
 932   case OMPD_end_declare_target:
 933   case OMPD_target_update:
 934     llvm_unreachable("OpenMP Directive is not allowed");
 935   case OMPD_unknown:
 936     llvm_unreachable("Unknown OpenMP directive");
 937   }
 938 }