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_at:
 108     return llvm::StringSwitch<OpenMPAtClauseKind>(Str)
 109 #define OPENMP_AT_KIND(Name) .Case(#Name, OMPC_AT_##Name)
 110 #include "clang/Basic/OpenMPKinds.def"
 111         .Default(OMPC_AT_unknown);
 112   case OMPC_severity:
 113     return llvm::StringSwitch<OpenMPSeverityClauseKind>(Str)
 114 #define OPENMP_SEVERITY_KIND(Name) .Case(#Name, OMPC_SEVERITY_##Name)
 115 #include "clang/Basic/OpenMPKinds.def"
 116         .Default(OMPC_SEVERITY_unknown);
 117   case OMPC_lastprivate:
 118     return llvm::StringSwitch<OpenMPLastprivateModifier>(Str)
 119 #define OPENMP_LASTPRIVATE_KIND(Name) .Case(#Name, OMPC_LASTPRIVATE_##Name)
 120 #include "clang/Basic/OpenMPKinds.def"
 121         .Default(OMPC_LASTPRIVATE_unknown);
 122   case OMPC_order:
 123     return llvm::StringSwitch<unsigned>(Str)
 124 #define OPENMP_ORDER_KIND(Name)                                                \
 125   .Case(#Name, static_cast<unsigned>(OMPC_ORDER_##Name))
 126 #define OPENMP_ORDER_MODIFIER(Name)                                            \
 127   .Case(#Name, static_cast<unsigned>(OMPC_ORDER_MODIFIER_##Name))
 128 #include "clang/Basic/OpenMPKinds.def"
 129         .Default(OMPC_ORDER_unknown);
 130   case OMPC_update:
 131     return llvm::StringSwitch<OpenMPDependClauseKind>(Str)
 132 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name)
 133 #include "clang/Basic/OpenMPKinds.def"
 134         .Default(OMPC_DEPEND_unknown);
 135   case OMPC_device:
 136     return llvm::StringSwitch<OpenMPDeviceClauseModifier>(Str)
 137 #define OPENMP_DEVICE_MODIFIER(Name) .Case(#Name, OMPC_DEVICE_##Name)
 138 #include "clang/Basic/OpenMPKinds.def"
 139         .Default(OMPC_DEVICE_unknown);
 140   case OMPC_reduction:
 141     return llvm::StringSwitch<OpenMPReductionClauseModifier>(Str)
 142 #define OPENMP_REDUCTION_MODIFIER(Name) .Case(#Name, OMPC_REDUCTION_##Name)
 143 #include "clang/Basic/OpenMPKinds.def"
 144         .Default(OMPC_REDUCTION_unknown);
 145   case OMPC_adjust_args:
 146     return llvm::StringSwitch<OpenMPAdjustArgsOpKind>(Str)
 147 #define OPENMP_ADJUST_ARGS_KIND(Name) .Case(#Name, OMPC_ADJUST_ARGS_##Name)
 148 #include "clang/Basic/OpenMPKinds.def"
 149         .Default(OMPC_ADJUST_ARGS_unknown);
 150   case OMPC_bind:
 151     return llvm::StringSwitch<unsigned>(Str)
 152 #define OPENMP_BIND_KIND(Name) .Case(#Name, OMPC_BIND_##Name)
 153 #include "clang/Basic/OpenMPKinds.def"
 154         .Default(OMPC_BIND_unknown);
 155   case OMPC_grainsize: {
 156     unsigned Type = llvm::StringSwitch<unsigned>(Str)
 157 #define OPENMP_GRAINSIZE_MODIFIER(Name) .Case(#Name, OMPC_GRAINSIZE_##Name)
 158 #include "clang/Basic/OpenMPKinds.def"
 159                         .Default(OMPC_GRAINSIZE_unknown);
 160     if (LangOpts.OpenMP < 51)
 161       return OMPC_GRAINSIZE_unknown;
 162     return Type;
 163   }
 164   case OMPC_num_tasks: {
 165     unsigned Type = llvm::StringSwitch<unsigned>(Str)
 166 #define OPENMP_NUMTASKS_MODIFIER(Name) .Case(#Name, OMPC_NUMTASKS_##Name)
 167 #include "clang/Basic/OpenMPKinds.def"
 168                         .Default(OMPC_NUMTASKS_unknown);
 169     if (LangOpts.OpenMP < 51)
 170       return OMPC_NUMTASKS_unknown;
 171     return Type;
 172   }
 173   case OMPC_unknown:
 174   case OMPC_threadprivate:
 175   case OMPC_if:
 176   case OMPC_final:
 177   case OMPC_num_threads:
 178   case OMPC_safelen:
 179   case OMPC_simdlen:
 180   case OMPC_sizes:
 181   case OMPC_allocator:
 182   case OMPC_allocate:
 183   case OMPC_collapse:
 184   case OMPC_private:
 185   case OMPC_firstprivate:
 186   case OMPC_shared:
 187   case OMPC_task_reduction:
 188   case OMPC_in_reduction:
 189   case OMPC_aligned:
 190   case OMPC_copyin:
 191   case OMPC_copyprivate:
 192   case OMPC_ordered:
 193   case OMPC_nowait:
 194   case OMPC_untied:
 195   case OMPC_mergeable:
 196   case OMPC_flush:
 197   case OMPC_depobj:
 198   case OMPC_read:
 199   case OMPC_write:
 200   case OMPC_capture:
 201   case OMPC_compare:
 202   case OMPC_seq_cst:
 203   case OMPC_acq_rel:
 204   case OMPC_acquire:
 205   case OMPC_release:
 206   case OMPC_relaxed:
 207   case OMPC_threads:
 208   case OMPC_simd:
 209   case OMPC_num_teams:
 210   case OMPC_thread_limit:
 211   case OMPC_priority:
 212   case OMPC_nogroup:
 213   case OMPC_hint:
 214   case OMPC_uniform:
 215   case OMPC_use_device_ptr:
 216   case OMPC_use_device_addr:
 217   case OMPC_is_device_ptr:
 218   case OMPC_has_device_addr:
 219   case OMPC_unified_address:
 220   case OMPC_unified_shared_memory:
 221   case OMPC_reverse_offload:
 222   case OMPC_dynamic_allocators:
 223   case OMPC_match:
 224   case OMPC_nontemporal:
 225   case OMPC_destroy:
 226   case OMPC_novariants:
 227   case OMPC_nocontext:
 228   case OMPC_detach:
 229   case OMPC_inclusive:
 230   case OMPC_exclusive:
 231   case OMPC_uses_allocators:
 232   case OMPC_affinity:
 233   case OMPC_when:
 234   case OMPC_append_args:
 235     break;
 236   default:
 237     break;
 238   }
 239   llvm_unreachable("Invalid OpenMP simple clause kind");
 240 }
 241
 242 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
 243                                                  unsigned Type) {
 244   switch (Kind) {
 245   case OMPC_default:
 246     switch (llvm::omp::DefaultKind(Type)) {
 247 #define OMP_DEFAULT_KIND(Enum, Name)                                           \
 248   case Enum:                                                                   \
 249     return Name;
 250 #include "llvm/Frontend/OpenMP/OMPKinds.def"
 251     }
 252     llvm_unreachable("Invalid OpenMP 'default' clause type");
 253   case OMPC_proc_bind:
 254     switch (Type) {
 255 #define OMP_PROC_BIND_KIND(Enum, Name, Value)                                  \
 256   case Value:                                                                  \
 257     return Name;
 258 #include "llvm/Frontend/OpenMP/OMPKinds.def"
 259     }
 260     llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
 261   case OMPC_schedule:
 262     switch (Type) {
 263     case OMPC_SCHEDULE_unknown:
 264     case OMPC_SCHEDULE_MODIFIER_last:
 265       return "unknown";
 266 #define OPENMP_SCHEDULE_KIND(Name)                                             \
 267     case OMPC_SCHEDULE_##Name:                                                 \
 268       return #Name;
 269 #define OPENMP_SCHEDULE_MODIFIER(Name)                                         \
 270     case OMPC_SCHEDULE_MODIFIER_##Name:                                        \
 271       return #Name;
 272 #include "clang/Basic/OpenMPKinds.def"
 273     }
 274     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
 275   case OMPC_depend:
 276     switch (Type) {
 277     case OMPC_DEPEND_unknown:
 278       return "unknown";
 279 #define OPENMP_DEPEND_KIND(Name)                                             \
 280   case OMPC_DEPEND_##Name:                                                   \
 281     return #Name;
 282 #include "clang/Basic/OpenMPKinds.def"
 283     }
 284     llvm_unreachable("Invalid OpenMP 'depend' clause type");
 285   case OMPC_linear:
 286     switch (Type) {
 287     case OMPC_LINEAR_unknown:
 288       return "unknown";
 289 #define OPENMP_LINEAR_KIND(Name)                                             \
 290   case OMPC_LINEAR_##Name:                                                   \
 291     return #Name;
 292 #include "clang/Basic/OpenMPKinds.def"
 293     }
 294     llvm_unreachable("Invalid OpenMP 'linear' clause type");
 295   case OMPC_map:
 296     switch (Type) {
 297     case OMPC_MAP_unknown:
 298     case OMPC_MAP_MODIFIER_last:
 299       return "unknown";
 300 #define OPENMP_MAP_KIND(Name)                                                \
 301   case OMPC_MAP_##Name:                                                      \
 302     return #Name;
 303 #define OPENMP_MAP_MODIFIER_KIND(Name)                                       \
 304   case OMPC_MAP_MODIFIER_##Name:                                             \
 305     return #Name;
 306 #include "clang/Basic/OpenMPKinds.def"
 307     default:
 308       break;
 309     }
 310     llvm_unreachable("Invalid OpenMP 'map' clause type");
 311   case OMPC_to:
 312   case OMPC_from:
 313     switch (Type) {
 314     case OMPC_MOTION_MODIFIER_unknown:
 315       return "unknown";
 316 #define OPENMP_MOTION_MODIFIER_KIND(Name)                                      \
 317   case OMPC_MOTION_MODIFIER_##Name:                                            \
 318     return #Name;
 319 #include "clang/Basic/OpenMPKinds.def"
 320     default:
 321       break;
 322     }
 323     llvm_unreachable("Invalid OpenMP 'to' or 'from' clause type");
 324   case OMPC_dist_schedule:
 325     switch (Type) {
 326     case OMPC_DIST_SCHEDULE_unknown:
 327       return "unknown";
 328 #define OPENMP_DIST_SCHEDULE_KIND(Name)                                      \
 329   case OMPC_DIST_SCHEDULE_##Name:                                            \
 330     return #Name;
 331 #include "clang/Basic/OpenMPKinds.def"
 332     }
 333     llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type");
 334   case OMPC_defaultmap:
 335     switch (Type) {
 336     case OMPC_DEFAULTMAP_unknown:
 337     case OMPC_DEFAULTMAP_MODIFIER_last:
 338       return "unknown";
 339 #define OPENMP_DEFAULTMAP_KIND(Name)                                         \
 340     case OMPC_DEFAULTMAP_##Name:                                             \
 341       return #Name;
 342 #define OPENMP_DEFAULTMAP_MODIFIER(Name)                                     \
 343     case OMPC_DEFAULTMAP_MODIFIER_##Name:                                    \
 344       return #Name;
 345 #include "clang/Basic/OpenMPKinds.def"
 346     }
 347     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
 348   case OMPC_atomic_default_mem_order:
 349     switch (Type) {
 350     case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown:
 351       return "unknown";
 352 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name)                           \
 353     case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name:                               \
 354       return #Name;
 355 #include "clang/Basic/OpenMPKinds.def"
 356 }
 357     llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type");
 358   case OMPC_device_type:
 359     switch (Type) {
 360     case OMPC_DEVICE_TYPE_unknown:
 361       return "unknown";
 362 #define OPENMP_DEVICE_TYPE_KIND(Name)                                          \
 363     case OMPC_DEVICE_TYPE_##Name:                                              \
 364       return #Name;
 365 #include "clang/Basic/OpenMPKinds.def"
 366     }
 367     llvm_unreachable("Invalid OpenMP 'device_type' clause type");
 368   case OMPC_at:
 369     switch (Type) {
 370     case OMPC_AT_unknown:
 371       return "unknown";
 372 #define OPENMP_AT_KIND(Name)                                                   \
 373   case OMPC_AT_##Name:                                                         \
 374     return #Name;
 375 #include "clang/Basic/OpenMPKinds.def"
 376     }
 377     llvm_unreachable("Invalid OpenMP 'at' clause type");
 378   case OMPC_severity:
 379     switch (Type) {
 380     case OMPC_SEVERITY_unknown:
 381       return "unknown";
 382 #define OPENMP_SEVERITY_KIND(Name)                                             \
 383   case OMPC_SEVERITY_##Name:                                                   \
 384     return #Name;
 385 #include "clang/Basic/OpenMPKinds.def"
 386     }
 387     llvm_unreachable("Invalid OpenMP 'severity' clause type");
 388   case OMPC_lastprivate:
 389     switch (Type) {
 390     case OMPC_LASTPRIVATE_unknown:
 391       return "unknown";
 392 #define OPENMP_LASTPRIVATE_KIND(Name)                                          \
 393     case OMPC_LASTPRIVATE_##Name:                                              \
 394       return #Name;
 395 #include "clang/Basic/OpenMPKinds.def"
 396     }
 397     llvm_unreachable("Invalid OpenMP 'lastprivate' clause type");
 398   case OMPC_order:
 399     switch (Type) {
 400     case OMPC_ORDER_unknown:
 401     case OMPC_ORDER_MODIFIER_last:
 402       return "unknown";
 403 #define OPENMP_ORDER_KIND(Name)                                                \
 404   case OMPC_ORDER_##Name:                                                      \
 405     return #Name;
 406 #define OPENMP_ORDER_MODIFIER(Name)                                            \
 407   case OMPC_ORDER_MODIFIER_##Name:                                             \
 408     return #Name;
 409 #include "clang/Basic/OpenMPKinds.def"
 410     }
 411     llvm_unreachable("Invalid OpenMP 'order' clause type");
 412   case OMPC_update:
 413     switch (Type) {
 414     case OMPC_DEPEND_unknown:
 415       return "unknown";
 416 #define OPENMP_DEPEND_KIND(Name)                                               \
 417   case OMPC_DEPEND_##Name:                                                     \
 418     return #Name;
 419 #include "clang/Basic/OpenMPKinds.def"
 420     }
 421     llvm_unreachable("Invalid OpenMP 'depend' clause type");
 422   case OMPC_device:
 423     switch (Type) {
 424     case OMPC_DEVICE_unknown:
 425       return "unknown";
 426 #define OPENMP_DEVICE_MODIFIER(Name)                                           \
 427   case OMPC_DEVICE_##Name:                                                     \
 428     return #Name;
 429 #include "clang/Basic/OpenMPKinds.def"
 430     }
 431     llvm_unreachable("Invalid OpenMP 'device' clause modifier");
 432   case OMPC_reduction:
 433     switch (Type) {
 434     case OMPC_REDUCTION_unknown:
 435       return "unknown";
 436 #define OPENMP_REDUCTION_MODIFIER(Name)                                        \
 437   case OMPC_REDUCTION_##Name:                                                  \
 438     return #Name;
 439 #include "clang/Basic/OpenMPKinds.def"
 440     }
 441     llvm_unreachable("Invalid OpenMP 'reduction' clause modifier");
 442   case OMPC_adjust_args:
 443     switch (Type) {
 444     case OMPC_ADJUST_ARGS_unknown:
 445       return "unknown";
 446 #define OPENMP_ADJUST_ARGS_KIND(Name)                                          \
 447   case OMPC_ADJUST_ARGS_##Name:                                                \
 448     return #Name;
 449 #include "clang/Basic/OpenMPKinds.def"
 450     }
 451     llvm_unreachable("Invalid OpenMP 'adjust_args' clause kind");
 452   case OMPC_bind:
 453     switch (Type) {
 454     case OMPC_BIND_unknown:
 455       return "unknown";
 456 #define OPENMP_BIND_KIND(Name)                                                 \
 457   case OMPC_BIND_##Name:                                                       \
 458     return #Name;
 459 #include "clang/Basic/OpenMPKinds.def"
 460     }
 461     llvm_unreachable("Invalid OpenMP 'bind' clause type");
 462   case OMPC_grainsize:
 463     switch (Type) {
 464     case OMPC_GRAINSIZE_unknown:
 465       return "unknown";
 466 #define OPENMP_GRAINSIZE_MODIFIER(Name)                                        \
 467   case OMPC_GRAINSIZE_##Name:                                                  \
 468     return #Name;
 469 #include "clang/Basic/OpenMPKinds.def"
 470     }
 471     llvm_unreachable("Invalid OpenMP 'grainsize' clause modifier");
 472   case OMPC_num_tasks:
 473     switch (Type) {
 474     case OMPC_NUMTASKS_unknown:
 475       return "unknown";
 476 #define OPENMP_NUMTASKS_MODIFIER(Name)                                         \
 477   case OMPC_NUMTASKS_##Name:                                                   \
 478     return #Name;
 479 #include "clang/Basic/OpenMPKinds.def"
 480     }
 481     llvm_unreachable("Invalid OpenMP 'num_tasks' clause modifier");
 482   case OMPC_unknown:
 483   case OMPC_threadprivate:
 484   case OMPC_if:
 485   case OMPC_final:
 486   case OMPC_num_threads:
 487   case OMPC_safelen:
 488   case OMPC_simdlen:
 489   case OMPC_sizes:
 490   case OMPC_allocator:
 491   case OMPC_allocate:
 492   case OMPC_collapse:
 493   case OMPC_private:
 494   case OMPC_firstprivate:
 495   case OMPC_shared:
 496   case OMPC_task_reduction:
 497   case OMPC_in_reduction:
 498   case OMPC_aligned:
 499   case OMPC_copyin:
 500   case OMPC_copyprivate:
 501   case OMPC_ordered:
 502   case OMPC_nowait:
 503   case OMPC_untied:
 504   case OMPC_mergeable:
 505   case OMPC_flush:
 506   case OMPC_depobj:
 507   case OMPC_read:
 508   case OMPC_write:
 509   case OMPC_capture:
 510   case OMPC_compare:
 511   case OMPC_seq_cst:
 512   case OMPC_acq_rel:
 513   case OMPC_acquire:
 514   case OMPC_release:
 515   case OMPC_relaxed:
 516   case OMPC_threads:
 517   case OMPC_simd:
 518   case OMPC_num_teams:
 519   case OMPC_thread_limit:
 520   case OMPC_priority:
 521   case OMPC_nogroup:
 522   case OMPC_hint:
 523   case OMPC_uniform:
 524   case OMPC_use_device_ptr:
 525   case OMPC_use_device_addr:
 526   case OMPC_is_device_ptr:
 527   case OMPC_has_device_addr:
 528   case OMPC_unified_address:
 529   case OMPC_unified_shared_memory:
 530   case OMPC_reverse_offload:
 531   case OMPC_dynamic_allocators:
 532   case OMPC_match:
 533   case OMPC_nontemporal:
 534   case OMPC_destroy:
 535   case OMPC_detach:
 536   case OMPC_novariants:
 537   case OMPC_nocontext:
 538   case OMPC_inclusive:
 539   case OMPC_exclusive:
 540   case OMPC_uses_allocators:
 541   case OMPC_affinity:
 542   case OMPC_when:
 543   case OMPC_append_args:
 544     break;
 545   default:
 546     break;
 547   }
 548   llvm_unreachable("Invalid OpenMP simple clause kind");
 549 }
 550
 551 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
 552   return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
 553          DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
 554          DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
 555          DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd ||
 556          DKind == OMPD_parallel_master_taskloop ||
 557          DKind == OMPD_parallel_master_taskloop_simd ||
 558          DKind == OMPD_masked_taskloop || DKind == OMPD_masked_taskloop_simd ||
 559          DKind == OMPD_parallel_masked_taskloop || DKind == OMPD_distribute ||
 560          DKind == OMPD_parallel_masked_taskloop_simd ||
 561          DKind == OMPD_target_parallel_for ||
 562          DKind == OMPD_distribute_parallel_for ||
 563          DKind == OMPD_distribute_parallel_for_simd ||
 564          DKind == OMPD_distribute_simd ||
 565          DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
 566          DKind == OMPD_teams_distribute ||
 567          DKind == OMPD_teams_distribute_simd ||
 568          DKind == OMPD_teams_distribute_parallel_for_simd ||
 569          DKind == OMPD_teams_distribute_parallel_for ||
 570          DKind == OMPD_target_teams_distribute ||
 571          DKind == OMPD_target_teams_distribute_parallel_for ||
 572          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 573          DKind == OMPD_target_teams_distribute_simd || DKind == OMPD_tile ||
 574          DKind == OMPD_unroll || DKind == OMPD_loop ||
 575          DKind == OMPD_teams_loop || DKind == OMPD_target_teams_loop ||
 576          DKind == OMPD_parallel_loop || DKind == OMPD_target_parallel_loop;
 577 }
 578
 579 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
 580   return DKind == OMPD_for || DKind == OMPD_for_simd ||
 581          DKind == OMPD_sections || DKind == OMPD_section ||
 582          DKind == OMPD_single || DKind == OMPD_parallel_for ||
 583          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
 584          DKind == OMPD_target_parallel_for ||
 585          DKind == OMPD_distribute_parallel_for ||
 586          DKind == OMPD_distribute_parallel_for_simd ||
 587          DKind == OMPD_target_parallel_for_simd ||
 588          DKind == OMPD_teams_distribute_parallel_for_simd ||
 589          DKind == OMPD_teams_distribute_parallel_for ||
 590          DKind == OMPD_target_teams_distribute_parallel_for ||
 591          DKind == OMPD_target_teams_distribute_parallel_for_simd;
 592 }
 593
 594 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
 595   return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd ||
 596          DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd ||
 597          DKind == OMPD_parallel_master_taskloop ||
 598          DKind == OMPD_masked_taskloop || DKind == OMPD_masked_taskloop_simd ||
 599          DKind == OMPD_parallel_masked_taskloop ||
 600          DKind == OMPD_parallel_masked_taskloop_simd ||
 601          DKind == OMPD_parallel_master_taskloop_simd;
 602 }
 603
 604 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
 605   return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
 606          DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections ||
 607          DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for ||
 608          DKind == OMPD_distribute_parallel_for ||
 609          DKind == OMPD_distribute_parallel_for_simd ||
 610          DKind == OMPD_target_parallel_for_simd ||
 611          DKind == OMPD_teams_distribute_parallel_for ||
 612          DKind == OMPD_teams_distribute_parallel_for_simd ||
 613          DKind == OMPD_target_teams_distribute_parallel_for ||
 614          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 615          DKind == OMPD_parallel_master || DKind == OMPD_parallel_masked ||
 616          DKind == OMPD_parallel_master_taskloop ||
 617          DKind == OMPD_parallel_master_taskloop_simd ||
 618          DKind == OMPD_parallel_masked_taskloop ||
 619          DKind == OMPD_parallel_masked_taskloop_simd ||
 620          DKind == OMPD_parallel_loop || DKind == OMPD_target_parallel_loop;
 621 }
 622
 623 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) {
 624   return DKind == OMPD_target || DKind == OMPD_target_parallel ||
 625          DKind == OMPD_target_parallel_for ||
 626          DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd ||
 627          DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute ||
 628          DKind == OMPD_target_teams_distribute_parallel_for ||
 629          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 630          DKind == OMPD_target_teams_distribute_simd ||
 631          DKind == OMPD_target_teams_loop || DKind == OMPD_target_parallel_loop;
 632 }
 633
 634 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) {
 635   return DKind == OMPD_target_data || DKind == OMPD_target_enter_data ||
 636          DKind == OMPD_target_exit_data || DKind == OMPD_target_update;
 637 }
 638
 639 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) {
 640   return DKind == OMPD_teams || DKind == OMPD_teams_distribute ||
 641          DKind == OMPD_teams_distribute_simd ||
 642          DKind == OMPD_teams_distribute_parallel_for_simd ||
 643          DKind == OMPD_teams_distribute_parallel_for ||
 644          DKind == OMPD_teams_loop;
 645 }
 646
 647 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
 648   return isOpenMPNestingTeamsDirective(DKind) || DKind == OMPD_target_teams ||
 649          DKind == OMPD_target_teams_distribute ||
 650          DKind == OMPD_target_teams_distribute_parallel_for ||
 651          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 652          DKind == OMPD_target_teams_distribute_simd ||
 653          DKind == OMPD_target_teams_loop;
 654 }
 655
 656 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
 657   return DKind == OMPD_simd || DKind == OMPD_for_simd ||
 658          DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd ||
 659          DKind == OMPD_master_taskloop_simd ||
 660          DKind == OMPD_masked_taskloop_simd ||
 661          DKind == OMPD_parallel_master_taskloop_simd ||
 662          DKind == OMPD_parallel_masked_taskloop_simd ||
 663          DKind == OMPD_distribute_parallel_for_simd ||
 664          DKind == OMPD_distribute_simd || DKind == OMPD_target_simd ||
 665          DKind == OMPD_teams_distribute_simd ||
 666          DKind == OMPD_teams_distribute_parallel_for_simd ||
 667          DKind == OMPD_target_teams_distribute_parallel_for_simd ||
 668          DKind == OMPD_target_teams_distribute_simd ||
 669          DKind == OMPD_target_parallel_for_simd;
 670 }
 671
 672 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) {
 673   return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for ||
 674          Kind == OMPD_distribute_parallel_for_simd ||
 675          Kind == OMPD_distribute_simd;
 676   // TODO add next directives.
 677 }
 678
 679 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) {
 680   return isOpenMPNestingDistributeDirective(Kind) ||
 681          Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd ||
 682          Kind == OMPD_teams_distribute_parallel_for_simd ||
 683          Kind == OMPD_teams_distribute_parallel_for ||
 684          Kind == OMPD_target_teams_distribute ||
 685          Kind == OMPD_target_teams_distribute_parallel_for ||
 686          Kind == OMPD_target_teams_distribute_parallel_for_simd ||
 687          Kind == OMPD_target_teams_distribute_simd;
 688 }
 689
 690 bool clang::isOpenMPGenericLoopDirective(OpenMPDirectiveKind Kind) {
 691   return Kind == OMPD_loop || Kind == OMPD_teams_loop ||
 692          Kind == OMPD_target_teams_loop || Kind == OMPD_parallel_loop ||
 693          Kind == OMPD_target_parallel_loop;
 694 }
 695
 696 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
 697   return Kind == OMPC_private || Kind == OMPC_firstprivate ||
 698          Kind == OMPC_lastprivate || Kind == OMPC_linear ||
 699          Kind == OMPC_reduction || Kind == OMPC_task_reduction ||
 700          Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'.
 701 }
 702
 703 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
 704   return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
 705 }
 706
 707 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) {
 708   return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind);
 709 }
 710
 711 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) {
 712   return Kind == OMPD_distribute_parallel_for ||
 713          Kind == OMPD_distribute_parallel_for_simd ||
 714          Kind == OMPD_teams_distribute_parallel_for_simd ||
 715          Kind == OMPD_teams_distribute_parallel_for ||
 716          Kind == OMPD_target_teams_distribute_parallel_for ||
 717          Kind == OMPD_target_teams_distribute_parallel_for_simd;
 718 }
 719
 720 bool clang::isOpenMPLoopTransformationDirective(OpenMPDirectiveKind DKind) {
 721   return DKind == OMPD_tile || DKind == OMPD_unroll;
 722 }
 723
 724 bool clang::isOpenMPCombinedParallelADirective(OpenMPDirectiveKind DKind) {
 725   return DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
 726          DKind == OMPD_parallel_master ||
 727          DKind == OMPD_parallel_master_taskloop ||
 728          DKind == OMPD_parallel_master_taskloop_simd ||
 729          DKind == OMPD_parallel_sections;
 730 }
 731
 732 void clang::getOpenMPCaptureRegions(
 733     SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions,
 734     OpenMPDirectiveKind DKind) {
 735   assert(unsigned(DKind) < llvm::omp::Directive_enumSize);
 736   switch (DKind) {
 737   case OMPD_metadirective:
 738     CaptureRegions.push_back(OMPD_metadirective);
 739     break;
 740   case OMPD_parallel:
 741   case OMPD_parallel_for:
 742   case OMPD_parallel_for_simd:
 743   case OMPD_parallel_master:
 744   case OMPD_parallel_masked:
 745   case OMPD_parallel_sections:
 746   case OMPD_distribute_parallel_for:
 747   case OMPD_distribute_parallel_for_simd:
 748   case OMPD_parallel_loop:
 749     CaptureRegions.push_back(OMPD_parallel);
 750     break;
 751   case OMPD_target_teams:
 752   case OMPD_target_teams_distribute:
 753   case OMPD_target_teams_distribute_simd:
 754   case OMPD_target_teams_loop:
 755     CaptureRegions.push_back(OMPD_task);
 756     CaptureRegions.push_back(OMPD_target);
 757     CaptureRegions.push_back(OMPD_teams);
 758     break;
 759   case OMPD_teams:
 760   case OMPD_teams_distribute:
 761   case OMPD_teams_distribute_simd:
 762     CaptureRegions.push_back(OMPD_teams);
 763     break;
 764   case OMPD_target:
 765   case OMPD_target_simd:
 766     CaptureRegions.push_back(OMPD_task);
 767     CaptureRegions.push_back(OMPD_target);
 768     break;
 769   case OMPD_teams_distribute_parallel_for:
 770   case OMPD_teams_distribute_parallel_for_simd:
 771     CaptureRegions.push_back(OMPD_teams);
 772     CaptureRegions.push_back(OMPD_parallel);
 773     break;
 774   case OMPD_target_parallel:
 775   case OMPD_target_parallel_for:
 776   case OMPD_target_parallel_for_simd:
 777   case OMPD_target_parallel_loop:
 778     CaptureRegions.push_back(OMPD_task);
 779     CaptureRegions.push_back(OMPD_target);
 780     CaptureRegions.push_back(OMPD_parallel);
 781     break;
 782   case OMPD_task:
 783   case OMPD_target_enter_data:
 784   case OMPD_target_exit_data:
 785   case OMPD_target_update:
 786     CaptureRegions.push_back(OMPD_task);
 787     break;
 788   case OMPD_taskloop:
 789   case OMPD_taskloop_simd:
 790   case OMPD_master_taskloop:
 791   case OMPD_master_taskloop_simd:
 792   case OMPD_masked_taskloop:
 793   case OMPD_masked_taskloop_simd:
 794     CaptureRegions.push_back(OMPD_taskloop);
 795     break;
 796   case OMPD_parallel_masked_taskloop:
 797   case OMPD_parallel_masked_taskloop_simd:
 798   case OMPD_parallel_master_taskloop:
 799   case OMPD_parallel_master_taskloop_simd:
 800     CaptureRegions.push_back(OMPD_parallel);
 801     CaptureRegions.push_back(OMPD_taskloop);
 802     break;
 803   case OMPD_target_teams_distribute_parallel_for:
 804   case OMPD_target_teams_distribute_parallel_for_simd:
 805     CaptureRegions.push_back(OMPD_task);
 806     CaptureRegions.push_back(OMPD_target);
 807     CaptureRegions.push_back(OMPD_teams);
 808     CaptureRegions.push_back(OMPD_parallel);
 809     break;
 810   case OMPD_teams_loop:
 811     CaptureRegions.push_back(OMPD_teams);
 812     break;
 813   case OMPD_nothing:
 814     CaptureRegions.push_back(OMPD_nothing);
 815     break;
 816   case OMPD_loop:
 817     // TODO: 'loop' may require different capture regions depending on the bind
 818     // clause or the parent directive when there is no bind clause. Use
 819     // OMPD_unknown for now.
 820   case OMPD_simd:
 821   case OMPD_for:
 822   case OMPD_for_simd:
 823   case OMPD_sections:
 824   case OMPD_section:
 825   case OMPD_single:
 826   case OMPD_master:
 827   case OMPD_critical:
 828   case OMPD_taskgroup:
 829   case OMPD_distribute:
 830   case OMPD_ordered:
 831   case OMPD_atomic:
 832   case OMPD_target_data:
 833   case OMPD_distribute_simd:
 834   case OMPD_dispatch:
 835     CaptureRegions.push_back(OMPD_unknown);
 836     break;
 837   case OMPD_tile:
 838   case OMPD_unroll:
 839     // loop transformations do not introduce captures.
 840     break;
 841   case OMPD_threadprivate:
 842   case OMPD_allocate:
 843   case OMPD_taskyield:
 844   case OMPD_barrier:
 845   case OMPD_error:
 846   case OMPD_taskwait:
 847   case OMPD_cancellation_point:
 848   case OMPD_cancel:
 849   case OMPD_flush:
 850   case OMPD_depobj:
 851   case OMPD_scan:
 852   case OMPD_declare_reduction:
 853   case OMPD_declare_mapper:
 854   case OMPD_declare_simd:
 855   case OMPD_declare_target:
 856   case OMPD_end_declare_target:
 857   case OMPD_requires:
 858   case OMPD_declare_variant:
 859   case OMPD_begin_declare_variant:
 860   case OMPD_end_declare_variant:
 861     llvm_unreachable("OpenMP Directive is not allowed");
 862   case OMPD_unknown:
 863   default:
 864     llvm_unreachable("Unknown OpenMP directive");
 865   }
 866 }