clang/lib/Basic/OpenMPKinds.cpp

   1 //===--- OpenMPKinds.cpp - Token Kinds Support ----------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 /// \file
   9 /// This file implements the OpenMP enum and support functions.
  10 ///
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "clang/Basic/OpenMPKinds.h"
  14 #include "clang/Basic/IdentifierTable.h"
  15 #include "llvm/ADT/StringRef.h"
  16 #include "llvm/ADT/StringSwitch.h"
  17 #include "llvm/Support/ErrorHandling.h"
  18 #include <cassert>
  19
  20 using namespace clang;
  21 using namespace llvm::omp;
  22
  23 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind, StringRef Str,
  24                                           const LangOptions &LangOpts) {
  25   switch (Kind) {
  26   case OMPC_default:
  27     return llvm::StringSwitch<unsigned>(Str)
  28 #define OMP_DEFAULT_KIND(Enum, Name) .Case(Name, unsigned(Enum))
  29 #include "llvm/Frontend/OpenMP/OMPKinds.def"
  30         .Default(unsigned(llvm::omp::OMP_DEFAULT_unknown));
  31   case OMPC_proc_bind:
  32     return llvm::StringSwitch<unsigned>(Str)
  33 #define OMP_PROC_BIND_KIND(Enum, Name, Value) .Case(Name, Value)
  34 #include "llvm/Frontend/OpenMP/OMPKinds.def"
  35         .Default(unsigned(llvm::omp::OMP_PROC_BIND_unknown));
  36   case OMPC_schedule:
  37     return llvm::StringSwitch<unsigned>(Str)
  38 #define OPENMP_SCHEDULE_KIND(Name)                                             \
  39   .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name))
  40 #define OPENMP_SCHEDULE_MODIFIER(Name)                                         \
  41   .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name))
  42 #include "clang/Basic/OpenMPKinds.def"
  43         .Default(OMPC_SCHEDULE_unknown);
  44   case OMPC_depend: {
  45     unsigned Type = llvm::StringSwitch<unsigned>(Str)
  46 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name)
  47 #include "clang/Basic/OpenMPKinds.def"
  48                         .Default(OMPC_DEPEND_unknown);
  49     if (LangOpts.OpenMP < 51 && Type == OMPC_DEPEND_inoutset)
  50       return OMPC_DEPEND_unknown;
  51     return Type;
  52   }
  53   case OMPC_linear:
  54     return llvm::StringSwitch<OpenMPLinearClauseKind>(Str)
  55 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name)
  56 #include "clang/Basic/OpenMPKinds.def"
  57         .Default(OMPC_LINEAR_unknown);
  58   case OMPC_map: {
  59     unsigned Type = llvm::StringSwitch<unsigned>(Str)
  60 #define OPENMP_MAP_KIND(Name)                                                  \
  61   .Case(#Name, static_cast<unsigned>(OMPC_MAP_##Name))
  62 #define OPENMP_MAP_MODIFIER_KIND(Name)                                         \
  63   .Case(#Name, static_cast<unsigned>(OMPC_MAP_MODIFIER_##Name))
  64 #include "clang/Basic/OpenMPKinds.def"
  65         .Default(OMPC_MAP_unknown);
  66     if (LangOpts.OpenMP < 51 && Type == OMPC_MAP_MODIFIER_present)
  67       return OMPC_MAP_MODIFIER_unknown;
  68     if (!LangOpts.OpenMPExtensions && Type == OMPC_MAP_MODIFIER_ompx_hold)
  69       return OMPC_MAP_MODIFIER_unknown;
  70     return Type;
  71   }
  72   case OMPC_to:
  73   case OMPC_from: {
  74     unsigned Type = llvm::StringSwitch<unsigned>(Str)
  75 #define OPENMP_MOTION_MODIFIER_KIND(Name)                                      \
  76   .Case(#Name, static_cast<unsigned>(OMPC_MOTION_MODIFIER_##Name))
  77 #include "clang/Basic/OpenMPKinds.def"
  78         .Default(OMPC_MOTION_MODIFIER_unknown);
  79     if (LangOpts.OpenMP < 51 && Type == OMPC_MOTION_MODIFIER_present)
  80       return OMPC_MOTION_MODIFIER_unknown;
  81     return Type;
  82   }
  83   case OMPC_dist_schedule:
  84     return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str)
  85 #define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name)
  86 #include "clang/Basic/OpenMPKinds.def"
  87         .Default(OMPC_DIST_SCHEDULE_unknown);
  88   case OMPC_defaultmap:
  89     return llvm::StringSwitch<unsigned>(Str)
  90 #define OPENMP_DEFAULTMAP_KIND(Name)                                           \
  91   .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name))
  92 #define OPENMP_DEFAULTMAP_MODIFIER(Name)                                       \
  93   .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name))
  94 #include "clang/Basic/OpenMPKinds.def"
  95         .Default(OMPC_DEFAULTMAP_unknown);
  96   case OMPC_atomic_default_mem_order:
  97      return llvm::StringSwitch<OpenMPAtomicDefaultMemOrderClauseKind>(Str)
  98 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name)       \
  99   .Case(#Name, OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name)
 100 #include "clang/Basic/OpenMPKinds.def"
 101         .Default(OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown);
 102   case OMPC_device_type:
 103     return llvm::StringSwitch<OpenMPDeviceType>(Str)
 104 #define OPENMP_DEVICE_TYPE_KIND(Name) .Case(#Name, OMPC_DEVICE_TYPE_##Name)
 105 #include "clang/Basic/OpenMPKinds.def"
 106         .Default(OMPC_DEVICE_TYPE_unknown);
 107   case OMPC_lastprivate:
 108     return llvm::StringSwitch<OpenMPLastprivateModifier>(Str)
 109 #define OPENMP_LASTPRIVATE_KIND(Name) .Case(#Name, OMPC_LASTPRIVATE_##Name)
 110 #include "clang/Basic/OpenMPKinds.def"
 111         .Default(OMPC_LASTPRIVATE_unknown);
 112   case OMPC_order:
 113     return llvm::StringSwitch<OpenMPOrderClauseKind>(Str)
 114 #define OPENMP_ORDER_KIND(Name) .Case(#Name, OMPC_ORDER_##Name)
 115 #include "clang/Basic/OpenMPKinds.def"
 116         .Default(OMPC_ORDER_unknown);
 117   case OMPC_update:
 118     return llvm::StringSwitch<OpenMPDependClauseKind>(Str)
 119 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name)
 120 #include "clang/Basic/OpenMPKinds.def"
 121         .Default(OMPC_DEPEND_unknown);
 122   case OMPC_device:
 123     return llvm::StringSwitch<OpenMPDeviceClauseModifier>(Str)
 124 #define OPENMP_DEVICE_MODIFIER(Name) .Case(#Name, OMPC_DEVICE_##Name)
 125 #include "clang/Basic/OpenMPKinds.def"
 126         .Default(OMPC_DEVICE_unknown);
 127   case OMPC_reduction:
 128     return llvm::StringSwitch<OpenMPReductionClauseModifier>(Str)
 129 #define OPENMP_REDUCTION_MODIFIER(Name) .Case(#Name, OMPC_REDUCTION_##Name)
 130 #include "clang/Basic/OpenMPKinds.def"
 131         .Default(OMPC_REDUCTION_unknown);
 132   case OMPC_adjust_args:
 133     return llvm::StringSwitch<OpenMPAdjustArgsOpKind>(Str)
 134 #define OPENMP_ADJUST_ARGS_KIND(Name) .Case(#Name, OMPC_ADJUST_ARGS_##Name)
 135 #include "clang/Basic/OpenMPKinds.def"
 136         .Default(OMPC_ADJUST_ARGS_unknown);
 137   case OMPC_bind:
 138     return llvm::StringSwitch<unsigned>(Str)
 139 #define OPENMP_BIND_KIND(Name) .Case(#Name, OMPC_BIND_##Name)
 140 #include "clang/Basic/OpenMPKinds.def"
 141         .Default(OMPC_BIND_unknown);
 142   case OMPC_unknown:
 143   case OMPC_threadprivate:
 144   case OMPC_if:
 145   case OMPC_final:
 146   case OMPC_num_threads:
 147   case OMPC_safelen:
 148   case OMPC_simdlen:
 149   case OMPC_sizes:
 150   case OMPC_allocator:
 151   case OMPC_allocate:
 152   case OMPC_collapse:
 153   case OMPC_private:
 154   case OMPC_firstprivate:
 155   case OMPC_shared:
 156   case OMPC_task_reduction:
 157   case OMPC_in_reduction:
 158   case OMPC_aligned:
 159   case OMPC_copyin:
 160   case OMPC_copyprivate:
 161   case OMPC_ordered:
 162   case OMPC_nowait:
 163   case OMPC_untied:
 164   case OMPC_mergeable:
 165   case OMPC_flush:
 166   case OMPC_depobj:
 167   case OMPC_read:
 168   case OMPC_write:
 169   case OMPC_capture:
 170   case OMPC_compare:
 171   case OMPC_seq_cst:
 172   case OMPC_acq_rel:
 173   case OMPC_acquire:
 174   case OMPC_release:
 175   case OMPC_relaxed:
 176   case OMPC_threads:
 177   case OMPC_simd:
 178   case OMPC_num_teams:
 179   case OMPC_thread_limit:
 180   case OMPC_priority:
 181   case OMPC_grainsize:
 182   case OMPC_nogroup:
 183   case OMPC_num_tasks:
 184   case OMPC_hint:
 185   case OMPC_uniform:
 186   case OMPC_use_device_ptr:
 187   case OMPC_use_device_addr:
 188   case OMPC_is_device_ptr:
 189   case OMPC_has_device_addr:
 190   case OMPC_unified_address:
 191   case OMPC_unified_shared_memory:
 192   case OMPC_reverse_offload:
 193   case OMPC_dynamic_allocators:
 194   case OMPC_match:
 195   case OMPC_nontemporal:
 196   case OMPC_destroy:
 197   case OMPC_novariants:
 198   case OMPC_nocontext:
 199   case OMPC_detach:
 200   case OMPC_inclusive:
 201   case OMPC_exclusive:
 202   case OMPC_uses_allocators:
 203   case OMPC_affinity:
 204   case OMPC_when:
 205   case OMPC_append_args:
 206     break;
 207   default:
 208     break;
 209   }
 210   llvm_unreachable("Invalid OpenMP simple clause kind");
 211 }
 212
 213 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
 214                                                  unsigned Type) {
 215   switch (Kind) {
 216   case OMPC_default:
 217     switch (llvm::omp::DefaultKind(Type)) {
 218 #define OMP_DEFAULT_KIND(Enum, Name)                                           \
 219   case Enum:                                                                   \
 220     return Name;
 221 #include "llvm/Frontend/OpenMP/OMPKinds.def"
 222     }
 223     llvm_unreachable("Invalid OpenMP 'default' clause type");
 224   case OMPC_proc_bind:
 225     switch (Type) {
 226 #define OMP_PROC_BIND_KIND(Enum, Name, Value)                                  \
 227   case Value:                                                                  \
 228     return Name;
 229 #include "llvm/Frontend/OpenMP/OMPKinds.def"
 230     }
 231     llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
 232   case OMPC_schedule:
 233     switch (Type) {
 234     case OMPC_SCHEDULE_unknown:
 235     case OMPC_SCHEDULE_MODIFIER_last:
 236       return "unknown";
 237 #define OPENMP_SCHEDULE_KIND(Name)                                             \
 238     case OMPC_SCHEDULE_##Name:                                                 \
 239       return #Name;
 240 #define OPENMP_SCHEDULE_MODIFIER(Name)                                         \
 241     case OMPC_SCHEDULE_MODIFIER_##Name:                                        \
 242       return #Name;
 243 #include "clang/Basic/OpenMPKinds.def"
 244     }
 245     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
 246   case OMPC_depend:
 247     switch (Type) {
 248     case OMPC_DEPEND_unknown:
 249       return "unknown";
 250 #define OPENMP_DEPEND_KIND(Name)                                             \
 251   case OMPC_DEPEND_##Name:                                                   \
 252     return #Name;
 253 #include "clang/Basic/OpenMPKinds.def"
 254     }
 255     llvm_unreachable("Invalid OpenMP 'depend' clause type");
 256   case OMPC_linear:
 257     switch (Type) {
 258     case OMPC_LINEAR_unknown:
 259       return "unknown";
 260 #define OPENMP_LINEAR_KIND(Name)                                             \
 261   case OMPC_LINEAR_##Name:                                                   \
 262     return #Name;
 263 #include "clang/Basic/OpenMPKinds.def"
 264     }
 265     llvm_unreachable("Invalid OpenMP 'linear' clause type");
 266   case OMPC_map:
 267     switch (Type) {
 268     case OMPC_MAP_unknown:
 269     case OMPC_MAP_MODIFIER_last:
 270       return "unknown";
 271 #define OPENMP_MAP_KIND(Name)                                                \
 272   case OMPC_MAP_##Name:                                                      \
 273     return #Name;
 274 #define OPENMP_MAP_MODIFIER_KIND(Name)                                       \
 275   case OMPC_MAP_MODIFIER_##Name:                                             \
 276     return #Name;
 277 #include "clang/Basic/OpenMPKinds.def"
 278     default:
 279       break;
 280     }
 281     llvm_unreachable("Invalid OpenMP 'map' clause type");
 282   case OMPC_to:
 283   case OMPC_from:
 284     switch (Type) {
 285     case OMPC_MOTION_MODIFIER_unknown:
 286       return "unknown";
 287 #define OPENMP_MOTION_MODIFIER_KIND(Name)                                      \
 288   case OMPC_MOTION_MODIFIER_##Name:                                            \
 289     return #Name;
 290 #include "clang/Basic/OpenMPKinds.def"
 291     default:
 292       break;
 293     }
 294     llvm_unreachable("Invalid OpenMP 'to' or 'from' clause type");
 295   case OMPC_dist_schedule:
 296     switch (Type) {
 297     case OMPC_DIST_SCHEDULE_unknown:
 298       return "unknown";
 299 #define OPENMP_DIST_SCHEDULE_KIND(Name)                                      \
 300   case OMPC_DIST_SCHEDULE_##Name:                                            \
 301     return #Name;
 302 #include "clang/Basic/OpenMPKinds.def"
 303     }
 304     llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type");
 305   case OMPC_defaultmap:
 306     switch (Type) {
 307     case OMPC_DEFAULTMAP_unknown:
 308     case OMPC_DEFAULTMAP_MODIFIER_last:
 309       return "unknown";
 310 #define OPENMP_DEFAULTMAP_KIND(Name)                                         \
 311     case OMPC_DEFAULTMAP_##Name:                                             \
 312       return #Name;
 313 #define OPENMP_DEFAULTMAP_MODIFIER(Name)                                     \
 314     case OMPC_DEFAULTMAP_MODIFIER_##Name:                                    \
 315       return #Name;
 316 #include "clang/Basic/OpenMPKinds.def"
 317     }
 318     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
 319   case OMPC_atomic_default_mem_order:
 320     switch (Type) {
 321     case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown:
 322       return "unknown";
 323 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name)                           \
 324     case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name:                               \
 325       return #Name;
 326 #include "clang/Basic/OpenMPKinds.def"
 327 }
 328     llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type");
 329   case OMPC_device_type:
 330     switch (Type) {
 331     case OMPC_DEVICE_TYPE_unknown:
 332       return "unknown";
 333 #define OPENMP_DEVICE_TYPE_KIND(Name)                                          \
 334     case OMPC_DEVICE_TYPE_##Name:                                              \
 335       return #Name;
 336 #include "clang/Basic/OpenMPKinds.def"
 337     }
 338     llvm_unreachable("Invalid OpenMP 'device_type' clause type");
 339   case OMPC_lastprivate:
 340     switch (Type) {
 341     case OMPC_LASTPRIVATE_unknown:
 342       return "unknown";
 343 #define OPENMP_LASTPRIVATE_KIND(Name)                                          \
 344     case OMPC_LASTPRIVATE_##Name:                                              \
 345       return #Name;
 346 #include "clang/Basic/OpenMPKinds.def"
 347     }
 348     llvm_unreachable("Invalid OpenMP 'lastprivate' clause type");
 349   case OMPC_order:
 350     switch (Type) {
 351     case OMPC_ORDER_unknown:
 352       return "unknown";
 353 #define OPENMP_ORDER_KIND(Name)                                                \
 354     case OMPC_ORDER_##Name:                                                    \
 355       return #Name;
 356 #include "clang/Basic/OpenMPKinds.def"
 357     }
 358     llvm_unreachable("Invalid OpenMP 'order' clause type");
 359   case OMPC_update:
 360     switch (Type) {
 361     case OMPC_DEPEND_unknown:
 362       return "unknown";
 363 #define OPENMP_DEPEND_KIND(Name)                                               \
 364   case OMPC_DEPEND_##Name:                                                     \
 365     return #Name;
 366 #include "clang/Basic/OpenMPKinds.def"
 367     }
 368     llvm_unreachable("Invalid OpenMP 'depend' clause type");
 369   case OMPC_device:
 370     switch (Type) {
 371     case OMPC_DEVICE_unknown:
 372       return "unknown";
 373 #define OPENMP_DEVICE_MODIFIER(Name)                                           \
 374   case OMPC_DEVICE_##Name:                                                     \
 375     return #Name;
 376 #include "clang/Basic/OpenMPKinds.def"
 377     }
 378     llvm_unreachable("Invalid OpenMP 'device' clause modifier");
 379   case OMPC_reduction:
 380     switch (Type) {
 381     case OMPC_REDUCTION_unknown:
 382       return "unknown";
 383 #define OPENMP_REDUCTION_MODIFIER(Name)                                        \
 384   case OMPC_REDUCTION_##Name:                                                  \
 385     return #Name;
 386 #include "clang/Basic/OpenMPKinds.def"
 387     }
 388     llvm_unreachable("Invalid OpenMP 'reduction' clause modifier");
 389   case OMPC_adjust_args:
 390     switch (Type) {
 391     case OMPC_ADJUST_ARGS_unknown:
 392       return "unknown";
 393 #define OPENMP_ADJUST_ARGS_KIND(Name)                                          \
 394   case OMPC_ADJUST_ARGS_##Name:                                                \
 395     return #Name;
 396 #include "clang/Basic/OpenMPKinds.def"
 397     }
 398     llvm_unreachable("Invalid OpenMP 'adjust_args' clause kind");
 399   case OMPC_bind:
 400     switch (Type) {
 401     case OMPC_BIND_unknown:
 402       return "unknown";
 403 #define OPENMP_BIND_KIND(Name)                                                 \
 404   case OMPC_BIND_##Name:                                                       \
 405     return #Name;
 406 #include "clang/Basic/OpenMPKinds.def"
 407     }
 408     llvm_unreachable("Invalid OpenMP 'bind' clause type");
 409   case OMPC_unknown:
 410   case OMPC_threadprivate:
 411   case OMPC_if:
 412   case OMPC_final:
 413   case OMPC_num_threads:
 414   case OMPC_safelen:
 415   case OMPC_simdlen:
 416   case OMPC_sizes:
 417   case OMPC_allocator:
 418   case OMPC_allocate:
 419   case OMPC_collapse:
 420   case OMPC_private:
 421   case OMPC_firstprivate:
 422   case OMPC_shared:
 423   case OMPC_task_reduction:
 424   case OMPC_in_reduction:
 425   case OMPC_aligned:
 426   case OMPC_copyin:
 427   case OMPC_copyprivate:
 428   case OMPC_ordered:
 429   case OMPC_nowait:
 430   case OMPC_untied:
 431   case OMPC_mergeable:
 432   case OMPC_flush:
 433   case OMPC_depobj:
 434   case OMPC_read:
 435   case OMPC_write:
 436   case OMPC_capture:
 437   case OMPC_compare:
 438   case OMPC_seq_cst:
 439   case OMPC_acq_rel:
 440   case OMPC_acquire:
 441   case OMPC_release:
 442   case OMPC_relaxed:
 443   case OMPC_threads:
 444   case OMPC_simd:
 445   case OMPC_num_teams:
 446   case OMPC_thread_limit:
 447   case OMPC_priority:
 448   case OMPC_grainsize:
 449   case OMPC_nogroup:
 450   case OMPC_num_tasks:
 451   case OMPC_hint:
 452   case OMPC_uniform:
 453   case OMPC_use_device_ptr:
 454   case OMPC_use_device_addr:
 455   case OMPC_is_device_ptr:
 456   case OMPC_has_device_addr:
 457   case OMPC_unified_address:
 458   case OMPC_unified_shared_memory:
 459   case OMPC_reverse_offload:
 460   case OMPC_dynamic_allocators:
 461   case OMPC_match:
 462   case OMPC_nontemporal:
 463   case OMPC_destroy:
 464   case OMPC_detach:
 465   case OMPC_novariants:
 466   case OMPC_nocontext:
 467   case OMPC_inclusive:
 468   case OMPC_exclusive:
 469   case OMPC_uses_allocators:
 470   case OMPC_affinity:
 471   case OMPC_when:
 472   case OMPC_append_args:
 473     break;
 474   default:
 475     break;
 476   }
 477   llvm_unreachable("Invalid OpenMP simple clause kind");
 478 }
 479
 480 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
 481   return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
 482          DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
 483          DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
 484          DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd ||
 485          DKind == OMPD_parallel_master_taskloop ||
 486          DKind == OMPD_parallel_master_taskloop_simd ||
 487          DKind == OMPD_masked_taskloop || DKind == OMPD_masked_taskloop_simd ||
 488          DKind == OMPD_parallel_masked_taskloop || DKind == OMPD_distribute ||
 489          DKind == OMPD_parallel_masked_taskloop_simd ||
 490          DKind == OMPD_target_parallel_for ||
 491          DKind == OMPD_distribute_parallel_for ||
 492          DKind == OMPD_distribute_parallel_for_simd ||
 493          DKind == OMPD_distribute_simd ||
 494          DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
 495          DKind == OMPD_teams_distribute ||
 496          DKind == OMPD_teams_distribute_simd ||
 497          DKind == OMPD_teams_distribute_parallel_for_simd ||
 498          DKind == OMPD_teams_distribute_parallel_for ||
 499          DKind == OMPD_target_teams_distribute ||
 500          DKind == OMPD_target_teams_distribute_parallel_for ||
 501          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 502          DKind == OMPD_target_teams_distribute_simd || DKind == OMPD_tile ||
 503          DKind == OMPD_unroll || DKind == OMPD_loop ||
 504          DKind == OMPD_teams_loop || DKind == OMPD_target_teams_loop ||
 505          DKind == OMPD_parallel_loop || DKind == OMPD_target_parallel_loop;
 506 }
 507
 508 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
 509   return DKind == OMPD_for || DKind == OMPD_for_simd ||
 510          DKind == OMPD_sections || DKind == OMPD_section ||
 511          DKind == OMPD_single || DKind == OMPD_parallel_for ||
 512          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
 513          DKind == OMPD_target_parallel_for ||
 514          DKind == OMPD_distribute_parallel_for ||
 515          DKind == OMPD_distribute_parallel_for_simd ||
 516          DKind == OMPD_target_parallel_for_simd ||
 517          DKind == OMPD_teams_distribute_parallel_for_simd ||
 518          DKind == OMPD_teams_distribute_parallel_for ||
 519          DKind == OMPD_target_teams_distribute_parallel_for ||
 520          DKind == OMPD_target_teams_distribute_parallel_for_simd;
 521 }
 522
 523 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
 524   return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
 525          DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd ||
 526          DKind == OMPD_parallel_master_taskloop ||
 527          DKind == OMPD_masked_taskloop || DKind == OMPD_masked_taskloop_simd ||
 528          DKind == OMPD_parallel_masked_taskloop ||
 529          DKind == OMPD_parallel_masked_taskloop_simd ||
 530          DKind == OMPD_parallel_master_taskloop_simd;
 531 }
 532
 533 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
 534   return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
 535          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
 536          DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for ||
 537          DKind == OMPD_distribute_parallel_for ||
 538          DKind == OMPD_distribute_parallel_for_simd ||
 539          DKind == OMPD_target_parallel_for_simd ||
 540          DKind == OMPD_teams_distribute_parallel_for ||
 541          DKind == OMPD_teams_distribute_parallel_for_simd ||
 542          DKind == OMPD_target_teams_distribute_parallel_for ||
 543          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 544          DKind == OMPD_parallel_master || DKind == OMPD_parallel_masked ||
 545          DKind == OMPD_parallel_master_taskloop ||
 546          DKind == OMPD_parallel_master_taskloop_simd ||
 547          DKind == OMPD_parallel_masked_taskloop ||
 548          DKind == OMPD_parallel_masked_taskloop_simd ||
 549          DKind == OMPD_parallel_loop || DKind == OMPD_target_parallel_loop;
 550 }
 551
 552 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) {
 553   return DKind == OMPD_target || DKind == OMPD_target_parallel ||
 554          DKind == OMPD_target_parallel_for ||
 555          DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
 556          DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
 557          DKind == OMPD_target_teams_distribute_parallel_for ||
 558          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 559          DKind == OMPD_target_teams_distribute_simd ||
 560          DKind == OMPD_target_teams_loop || DKind == OMPD_target_parallel_loop;
 561 }
 562
 563 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) {
 564   return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
 565          DKind == OMPD_target_exit_data || DKind == OMPD_target_update;
 566 }
 567
 568 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) {
 569   return DKind == OMPD_teams || DKind == OMPD_teams_distribute ||
 570          DKind == OMPD_teams_distribute_simd ||
 571          DKind == OMPD_teams_distribute_parallel_for_simd ||
 572          DKind == OMPD_teams_distribute_parallel_for ||
 573          DKind == OMPD_teams_loop;
 574 }
 575
 576 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
 577   return isOpenMPNestingTeamsDirective(DKind) || DKind == OMPD_target_teams ||
 578          DKind == OMPD_target_teams_distribute ||
 579          DKind == OMPD_target_teams_distribute_parallel_for ||
 580          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 581          DKind == OMPD_target_teams_distribute_simd ||
 582          DKind == OMPD_target_teams_loop;
 583 }
 584
 585 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
 586   return DKind == OMPD_simd || DKind == OMPD_for_simd ||
 587          DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd ||
 588          DKind == OMPD_master_taskloop_simd ||
 589          DKind == OMPD_masked_taskloop_simd ||
 590          DKind == OMPD_parallel_master_taskloop_simd ||
 591          DKind == OMPD_parallel_masked_taskloop_simd ||
 592          DKind == OMPD_distribute_parallel_for_simd ||
 593          DKind == OMPD_distribute_simd || DKind == OMPD_target_simd ||
 594          DKind == OMPD_teams_distribute_simd ||
 595          DKind == OMPD_teams_distribute_parallel_for_simd ||
 596          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 597          DKind == OMPD_target_teams_distribute_simd ||
 598          DKind == OMPD_target_parallel_for_simd;
 599 }
 600
 601 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) {
 602   return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for ||
 603          Kind == OMPD_distribute_parallel_for_simd ||
 604          Kind == OMPD_distribute_simd;
 605   // TODO add next directives.
 606 }
 607
 608 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) {
 609   return isOpenMPNestingDistributeDirective(Kind) ||
 610          Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd ||
 611          Kind == OMPD_teams_distribute_parallel_for_simd ||
 612          Kind == OMPD_teams_distribute_parallel_for ||
 613          Kind == OMPD_target_teams_distribute ||
 614          Kind == OMPD_target_teams_distribute_parallel_for ||
 615          Kind == OMPD_target_teams_distribute_parallel_for_simd ||
 616          Kind == OMPD_target_teams_distribute_simd;
 617 }
 618
 619 bool clang::isOpenMPGenericLoopDirective(OpenMPDirectiveKind Kind) {
 620   return Kind == OMPD_loop || Kind == OMPD_teams_loop ||
 621          Kind == OMPD_target_teams_loop || Kind == OMPD_parallel_loop ||
 622          Kind == OMPD_target_parallel_loop;
 623 }
 624
 625 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
 626   return Kind == OMPC_private || Kind == OMPC_firstprivate ||
 627          Kind == OMPC_lastprivate || Kind == OMPC_linear ||
 628          Kind == OMPC_reduction || Kind == OMPC_task_reduction ||
 629          Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'.
 630 }
 631
 632 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
 633   return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
 634 }
 635
 636 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) {
 637   return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
 638 }
 639
 640 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) {
 641   return Kind == OMPD_distribute_parallel_for ||
 642          Kind == OMPD_distribute_parallel_for_simd ||
 643          Kind == OMPD_teams_distribute_parallel_for_simd ||
 644          Kind == OMPD_teams_distribute_parallel_for ||
 645          Kind == OMPD_target_teams_distribute_parallel_for ||
 646          Kind == OMPD_target_teams_distribute_parallel_for_simd;
 647 }
 648
 649 bool clang::isOpenMPLoopTransformationDirective(OpenMPDirectiveKind DKind) {
 650   return DKind == OMPD_tile || DKind == OMPD_unroll;
 651 }
 652
 653 void clang::getOpenMPCaptureRegions(
 654     SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions,
 655     OpenMPDirectiveKind DKind) {
 656   assert(unsigned(DKind) < llvm::omp::Directive_enumSize);
 657   switch (DKind) {
 658   case OMPD_metadirective:
 659     CaptureRegions.push_back(OMPD_metadirective);
 660     break;
 661   case OMPD_parallel:
 662   case OMPD_parallel_for:
 663   case OMPD_parallel_for_simd:
 664   case OMPD_parallel_master:
 665   case OMPD_parallel_masked:
 666   case OMPD_parallel_sections:
 667   case OMPD_distribute_parallel_for:
 668   case OMPD_distribute_parallel_for_simd:
 669   case OMPD_parallel_loop:
 670     CaptureRegions.push_back(OMPD_parallel);
 671     break;
 672   case OMPD_target_teams:
 673   case OMPD_target_teams_distribute:
 674   case OMPD_target_teams_distribute_simd:
 675   case OMPD_target_teams_loop:
 676     CaptureRegions.push_back(OMPD_task);
 677     CaptureRegions.push_back(OMPD_target);
 678     CaptureRegions.push_back(OMPD_teams);
 679     break;
 680   case OMPD_teams:
 681   case OMPD_teams_distribute:
 682   case OMPD_teams_distribute_simd:
 683     CaptureRegions.push_back(OMPD_teams);
 684     break;
 685   case OMPD_target:
 686   case OMPD_target_simd:
 687     CaptureRegions.push_back(OMPD_task);
 688     CaptureRegions.push_back(OMPD_target);
 689     break;
 690   case OMPD_teams_distribute_parallel_for:
 691   case OMPD_teams_distribute_parallel_for_simd:
 692     CaptureRegions.push_back(OMPD_teams);
 693     CaptureRegions.push_back(OMPD_parallel);
 694     break;
 695   case OMPD_target_parallel:
 696   case OMPD_target_parallel_for:
 697   case OMPD_target_parallel_for_simd:
 698   case OMPD_target_parallel_loop:
 699     CaptureRegions.push_back(OMPD_task);
 700     CaptureRegions.push_back(OMPD_target);
 701     CaptureRegions.push_back(OMPD_parallel);
 702     break;
 703   case OMPD_task:
 704   case OMPD_target_enter_data:
 705   case OMPD_target_exit_data:
 706   case OMPD_target_update:
 707     CaptureRegions.push_back(OMPD_task);
 708     break;
 709   case OMPD_taskloop:
 710   case OMPD_taskloop_simd:
 711   case OMPD_master_taskloop:
 712   case OMPD_master_taskloop_simd:
 713   case OMPD_masked_taskloop:
 714   case OMPD_masked_taskloop_simd:
 715     CaptureRegions.push_back(OMPD_taskloop);
 716     break;
 717   case OMPD_parallel_masked_taskloop:
 718   case OMPD_parallel_masked_taskloop_simd:
 719   case OMPD_parallel_master_taskloop:
 720   case OMPD_parallel_master_taskloop_simd:
 721     CaptureRegions.push_back(OMPD_parallel);
 722     CaptureRegions.push_back(OMPD_taskloop);
 723     break;
 724   case OMPD_target_teams_distribute_parallel_for:
 725   case OMPD_target_teams_distribute_parallel_for_simd:
 726     CaptureRegions.push_back(OMPD_task);
 727     CaptureRegions.push_back(OMPD_target);
 728     CaptureRegions.push_back(OMPD_teams);
 729     CaptureRegions.push_back(OMPD_parallel);
 730     break;
 731   case OMPD_teams_loop:
 732     CaptureRegions.push_back(OMPD_teams);
 733     break;
 734   case OMPD_nothing:
 735     CaptureRegions.push_back(OMPD_nothing);
 736     break;
 737   case OMPD_loop:
 738     // TODO: 'loop' may require different capture regions depending on the bind
 739     // clause or the parent directive when there is no bind clause. Use
 740     // OMPD_unknown for now.
 741   case OMPD_simd:
 742   case OMPD_for:
 743   case OMPD_for_simd:
 744   case OMPD_sections:
 745   case OMPD_section:
 746   case OMPD_single:
 747   case OMPD_master:
 748   case OMPD_critical:
 749   case OMPD_taskgroup:
 750   case OMPD_distribute:
 751   case OMPD_ordered:
 752   case OMPD_atomic:
 753   case OMPD_target_data:
 754   case OMPD_distribute_simd:
 755   case OMPD_dispatch:
 756     CaptureRegions.push_back(OMPD_unknown);
 757     break;
 758   case OMPD_tile:
 759   case OMPD_unroll:
 760     // loop transformations do not introduce captures.
 761     break;
 762   case OMPD_threadprivate:
 763   case OMPD_allocate:
 764   case OMPD_taskyield:
 765   case OMPD_barrier:
 766   case OMPD_taskwait:
 767   case OMPD_cancellation_point:
 768   case OMPD_cancel:
 769   case OMPD_flush:
 770   case OMPD_depobj:
 771   case OMPD_scan:
 772   case OMPD_declare_reduction:
 773   case OMPD_declare_mapper:
 774   case OMPD_declare_simd:
 775   case OMPD_declare_target:
 776   case OMPD_end_declare_target:
 777   case OMPD_requires:
 778   case OMPD_declare_variant:
 779   case OMPD_begin_declare_variant:
 780   case OMPD_end_declare_variant:
 781     llvm_unreachable("OpenMP Directive is not allowed");
 782   case OMPD_unknown:
 783   default:
 784     llvm_unreachable("Unknown OpenMP directive");
 785   }
 786 }