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_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_declare_target:
 614   case OMPD_end_declare_target:
 615   case OMPD_unknown:
 616   case OMPD_threadprivate:
 617   case OMPD_section:
 618   case OMPD_master:
 619   case OMPD_taskyield:
 620   case OMPD_barrier:
 621   case OMPD_taskwait:
 622   case OMPD_taskgroup:
 623   case OMPD_cancellation_point:
 624   case OMPD_declare_reduction:
 625     break;
 626   }
 627   return false;
 628 }
 629
 630 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
 631   return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
 632          DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
 633          DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
 634          DKind == OMPD_distribute || DKind == OMPD_target_parallel_for ||
 635          DKind == OMPD_distribute_parallel_for ||
 636          DKind == OMPD_distribute_parallel_for_simd ||
 637          DKind == OMPD_distribute_simd ||
 638          DKind == OMPD_target_parallel_for_simd;
 639   // TODO add next directives.
 640 }
 641
 642 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
 643   return DKind == OMPD_for || DKind == OMPD_for_simd ||
 644          DKind == OMPD_sections || DKind == OMPD_section ||
 645          DKind == OMPD_single || DKind == OMPD_parallel_for ||
 646          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
 647          DKind == OMPD_target_parallel_for ||
 648          DKind == OMPD_distribute_parallel_for ||
 649          DKind == OMPD_distribute_parallel_for_simd ||
 650          DKind == OMPD_target_parallel_for_simd;
 651   // TODO add next directives.
 652 }
 653
 654 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
 655   return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd;
 656 }
 657
 658 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
 659   return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
 660          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
 661          DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for ||
 662          DKind == OMPD_distribute_parallel_for ||
 663          DKind == OMPD_distribute_parallel_for_simd ||
 664          DKind == OMPD_target_parallel_for_simd;
 665   // TODO add next directives.
 666 }
 667
 668 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) {
 669   // TODO add next directives.
 670   return DKind == OMPD_target || DKind == OMPD_target_parallel ||
 671          DKind == OMPD_target_parallel_for ||
 672          DKind == OMPD_target_parallel_for_simd;
 673 }
 674
 675 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) {
 676   return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
 677          DKind == OMPD_target_exit_data || DKind == OMPD_target_update;
 678 }
 679
 680 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
 681   return DKind == OMPD_teams; // TODO add next directives.
 682 }
 683
 684 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
 685   return DKind == OMPD_simd || DKind == OMPD_for_simd ||
 686          DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd ||
 687          DKind == OMPD_distribute_parallel_for_simd ||
 688          DKind == OMPD_distribute_simd;
 689   // TODO add next directives.
 690 }
 691
 692 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) {
 693   return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for ||
 694          Kind == OMPD_distribute_parallel_for_simd ||
 695          Kind == OMPD_distribute_simd;
 696   // TODO add next directives.
 697 }
 698
 699 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
 700   return Kind == OMPC_private || Kind == OMPC_firstprivate ||
 701          Kind == OMPC_lastprivate || Kind == OMPC_linear ||
 702          Kind == OMPC_reduction; // TODO add next clauses like 'reduction'.
 703 }
 704
 705 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
 706   return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
 707 }
 708
 709 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) {
 710   return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
 711 }
 712
 713 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) {
 714   return Kind == OMPD_distribute_parallel_for ||
 715          Kind == OMPD_distribute_parallel_for_simd ||
 716          Kind == OMPD_distribute_simd;
 717 }