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