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       .Default(OMPC_unknown);
  59 }
  60
  61 const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) {
  62   assert(Kind <= OMPC_unknown);
  63   switch (Kind) {
  64   case OMPC_unknown:
  65     return "unknown";
  66 #define OPENMP_CLAUSE(Name, Class)                                             \
  67   case OMPC_##Name:                                                            \
  68     return #Name;
  69 #include "clang/Basic/OpenMPKinds.def"
  70   case OMPC_threadprivate:
  71     return "threadprivate or thread local";
  72   }
  73   llvm_unreachable("Invalid OpenMP clause kind");
  74 }
  75
  76 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind,
  77                                           StringRef Str) {
  78   switch (Kind) {
  79   case OMPC_default:
  80     return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str)
  81 #define OPENMP_DEFAULT_KIND(Name) .Case(#Name, OMPC_DEFAULT_##Name)
  82 #include "clang/Basic/OpenMPKinds.def"
  83         .Default(OMPC_DEFAULT_unknown);
  84   case OMPC_proc_bind:
  85     return llvm::StringSwitch<OpenMPProcBindClauseKind>(Str)
  86 #define OPENMP_PROC_BIND_KIND(Name) .Case(#Name, OMPC_PROC_BIND_##Name)
  87 #include "clang/Basic/OpenMPKinds.def"
  88         .Default(OMPC_PROC_BIND_unknown);
  89   case OMPC_schedule:
  90     return llvm::StringSwitch<unsigned>(Str)
  91 #define OPENMP_SCHEDULE_KIND(Name)                                             \
  92   .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name))
  93 #define OPENMP_SCHEDULE_MODIFIER(Name)                                         \
  94   .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name))
  95 #include "clang/Basic/OpenMPKinds.def"
  96         .Default(OMPC_SCHEDULE_unknown);
  97   case OMPC_depend:
  98     return llvm::StringSwitch<OpenMPDependClauseKind>(Str)
  99 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name)
 100 #include "clang/Basic/OpenMPKinds.def"
 101         .Default(OMPC_DEPEND_unknown);
 102   case OMPC_linear:
 103     return llvm::StringSwitch<OpenMPLinearClauseKind>(Str)
 104 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name)
 105 #include "clang/Basic/OpenMPKinds.def"
 106         .Default(OMPC_LINEAR_unknown);
 107   case OMPC_map:
 108     return llvm::StringSwitch<OpenMPMapClauseKind>(Str)
 109 #define OPENMP_MAP_KIND(Name) .Case(#Name, OMPC_MAP_##Name)
 110 #include "clang/Basic/OpenMPKinds.def"
 111         .Default(OMPC_MAP_unknown);
 112   case OMPC_unknown:
 113   case OMPC_threadprivate:
 114   case OMPC_if:
 115   case OMPC_final:
 116   case OMPC_num_threads:
 117   case OMPC_safelen:
 118   case OMPC_simdlen:
 119   case OMPC_collapse:
 120   case OMPC_private:
 121   case OMPC_firstprivate:
 122   case OMPC_lastprivate:
 123   case OMPC_shared:
 124   case OMPC_reduction:
 125   case OMPC_aligned:
 126   case OMPC_copyin:
 127   case OMPC_copyprivate:
 128   case OMPC_ordered:
 129   case OMPC_nowait:
 130   case OMPC_untied:
 131   case OMPC_mergeable:
 132   case OMPC_flush:
 133   case OMPC_read:
 134   case OMPC_write:
 135   case OMPC_update:
 136   case OMPC_capture:
 137   case OMPC_seq_cst:
 138   case OMPC_device:
 139   case OMPC_threads:
 140   case OMPC_simd:
 141   case OMPC_num_teams:
 142   case OMPC_thread_limit:
 143   case OMPC_priority:
 144   case OMPC_grainsize:
 145   case OMPC_nogroup:
 146   case OMPC_num_tasks:
 147   case OMPC_hint:
 148     break;
 149   }
 150   llvm_unreachable("Invalid OpenMP simple clause kind");
 151 }
 152
 153 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
 154                                                  unsigned Type) {
 155   switch (Kind) {
 156   case OMPC_default:
 157     switch (Type) {
 158     case OMPC_DEFAULT_unknown:
 159       return "unknown";
 160 #define OPENMP_DEFAULT_KIND(Name)                                              \
 161   case OMPC_DEFAULT_##Name:                                                    \
 162     return #Name;
 163 #include "clang/Basic/OpenMPKinds.def"
 164     }
 165     llvm_unreachable("Invalid OpenMP 'default' clause type");
 166   case OMPC_proc_bind:
 167     switch (Type) {
 168     case OMPC_PROC_BIND_unknown:
 169       return "unknown";
 170 #define OPENMP_PROC_BIND_KIND(Name)                                            \
 171   case OMPC_PROC_BIND_##Name:                                                  \
 172     return #Name;
 173 #include "clang/Basic/OpenMPKinds.def"
 174     }
 175     llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
 176   case OMPC_schedule:
 177     switch (Type) {
 178     case OMPC_SCHEDULE_unknown:
 179     case OMPC_SCHEDULE_MODIFIER_last:
 180       return "unknown";
 181 #define OPENMP_SCHEDULE_KIND(Name)                                             \
 182     case OMPC_SCHEDULE_##Name:                                                 \
 183       return #Name;
 184 #define OPENMP_SCHEDULE_MODIFIER(Name)                                         \
 185     case OMPC_SCHEDULE_MODIFIER_##Name:                                        \
 186       return #Name;
 187 #include "clang/Basic/OpenMPKinds.def"
 188     }
 189     llvm_unreachable("Invalid OpenMP 'schedule' clause type");
 190   case OMPC_depend:
 191     switch (Type) {
 192     case OMPC_DEPEND_unknown:
 193       return "unknown";
 194 #define OPENMP_DEPEND_KIND(Name)                                             \
 195   case OMPC_DEPEND_##Name:                                                   \
 196     return #Name;
 197 #include "clang/Basic/OpenMPKinds.def"
 198     }
 199     llvm_unreachable("Invalid OpenMP 'depend' clause type");
 200   case OMPC_linear:
 201     switch (Type) {
 202     case OMPC_LINEAR_unknown:
 203       return "unknown";
 204 #define OPENMP_LINEAR_KIND(Name)                                             \
 205   case OMPC_LINEAR_##Name:                                                   \
 206     return #Name;
 207 #include "clang/Basic/OpenMPKinds.def"
 208     }
 209     llvm_unreachable("Invalid OpenMP 'linear' clause type");
 210   case OMPC_map:
 211     switch (Type) {
 212     case OMPC_MAP_unknown:
 213       return "unknown";
 214 #define OPENMP_MAP_KIND(Name)                                                \
 215   case OMPC_MAP_##Name:                                                      \
 216     return #Name;
 217 #include "clang/Basic/OpenMPKinds.def"
 218     default:
 219       break;
 220     }
 221     llvm_unreachable("Invalid OpenMP 'map' clause type");
 222   case OMPC_unknown:
 223   case OMPC_threadprivate:
 224   case OMPC_if:
 225   case OMPC_final:
 226   case OMPC_num_threads:
 227   case OMPC_safelen:
 228   case OMPC_simdlen:
 229   case OMPC_collapse:
 230   case OMPC_private:
 231   case OMPC_firstprivate:
 232   case OMPC_lastprivate:
 233   case OMPC_shared:
 234   case OMPC_reduction:
 235   case OMPC_aligned:
 236   case OMPC_copyin:
 237   case OMPC_copyprivate:
 238   case OMPC_ordered:
 239   case OMPC_nowait:
 240   case OMPC_untied:
 241   case OMPC_mergeable:
 242   case OMPC_flush:
 243   case OMPC_read:
 244   case OMPC_write:
 245   case OMPC_update:
 246   case OMPC_capture:
 247   case OMPC_seq_cst:
 248   case OMPC_device:
 249   case OMPC_threads:
 250   case OMPC_simd:
 251   case OMPC_num_teams:
 252   case OMPC_thread_limit:
 253   case OMPC_priority:
 254   case OMPC_grainsize:
 255   case OMPC_nogroup:
 256   case OMPC_num_tasks:
 257   case OMPC_hint:
 258     break;
 259   }
 260   llvm_unreachable("Invalid OpenMP simple clause kind");
 261 }
 262
 263 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
 264                                         OpenMPClauseKind CKind) {
 265   assert(DKind <= OMPD_unknown);
 266   assert(CKind <= OMPC_unknown);
 267   switch (DKind) {
 268   case OMPD_parallel:
 269     switch (CKind) {
 270 #define OPENMP_PARALLEL_CLAUSE(Name)                                           \
 271   case OMPC_##Name:                                                            \
 272     return true;
 273 #include "clang/Basic/OpenMPKinds.def"
 274     default:
 275       break;
 276     }
 277     break;
 278   case OMPD_simd:
 279     switch (CKind) {
 280 #define OPENMP_SIMD_CLAUSE(Name)                                               \
 281   case OMPC_##Name:                                                            \
 282     return true;
 283 #include "clang/Basic/OpenMPKinds.def"
 284     default:
 285       break;
 286     }
 287     break;
 288   case OMPD_for:
 289     switch (CKind) {
 290 #define OPENMP_FOR_CLAUSE(Name)                                                \
 291   case OMPC_##Name:                                                            \
 292     return true;
 293 #include "clang/Basic/OpenMPKinds.def"
 294     default:
 295       break;
 296     }
 297     break;
 298   case OMPD_for_simd:
 299     switch (CKind) {
 300 #define OPENMP_FOR_SIMD_CLAUSE(Name)                                           \
 301   case OMPC_##Name:                                                            \
 302     return true;
 303 #include "clang/Basic/OpenMPKinds.def"
 304     default:
 305       break;
 306     }
 307     break;
 308   case OMPD_sections:
 309     switch (CKind) {
 310 #define OPENMP_SECTIONS_CLAUSE(Name)                                           \
 311   case OMPC_##Name:                                                            \
 312     return true;
 313 #include "clang/Basic/OpenMPKinds.def"
 314     default:
 315       break;
 316     }
 317     break;
 318   case OMPD_single:
 319     switch (CKind) {
 320 #define OPENMP_SINGLE_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_parallel_for:
 329     switch (CKind) {
 330 #define OPENMP_PARALLEL_FOR_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_parallel_for_simd:
 339     switch (CKind) {
 340 #define OPENMP_PARALLEL_FOR_SIMD_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_parallel_sections:
 349     switch (CKind) {
 350 #define OPENMP_PARALLEL_SECTIONS_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_task:
 359     switch (CKind) {
 360 #define OPENMP_TASK_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_flush:
 369     return CKind == OMPC_flush;
 370     break;
 371   case OMPD_atomic:
 372     switch (CKind) {
 373 #define OPENMP_ATOMIC_CLAUSE(Name)                                             \
 374   case OMPC_##Name:                                                            \
 375     return true;
 376 #include "clang/Basic/OpenMPKinds.def"
 377     default:
 378       break;
 379     }
 380     break;
 381   case OMPD_target:
 382     switch (CKind) {
 383 #define OPENMP_TARGET_CLAUSE(Name)                                             \
 384   case OMPC_##Name:                                                            \
 385     return true;
 386 #include "clang/Basic/OpenMPKinds.def"
 387     default:
 388       break;
 389     }
 390     break;
 391   case OMPD_target_data:
 392     switch (CKind) {
 393 #define OPENMP_TARGET_DATA_CLAUSE(Name)                                        \
 394   case OMPC_##Name:                                                            \
 395     return true;
 396 #include "clang/Basic/OpenMPKinds.def"
 397     default:
 398       break;
 399     }
 400     break;
 401   case OMPD_teams:
 402     switch (CKind) {
 403 #define OPENMP_TEAMS_CLAUSE(Name)                                              \
 404   case OMPC_##Name:                                                            \
 405     return true;
 406 #include "clang/Basic/OpenMPKinds.def"
 407     default:
 408       break;
 409     }
 410     break;
 411   case OMPD_cancel:
 412     switch (CKind) {
 413 #define OPENMP_CANCEL_CLAUSE(Name)                                             \
 414   case OMPC_##Name:                                                            \
 415     return true;
 416 #include "clang/Basic/OpenMPKinds.def"
 417     default:
 418       break;
 419     }
 420     break;
 421   case OMPD_ordered:
 422     switch (CKind) {
 423 #define OPENMP_ORDERED_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_taskloop:
 432     switch (CKind) {
 433 #define OPENMP_TASKLOOP_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_taskloop_simd:
 442     switch (CKind) {
 443 #define OPENMP_TASKLOOP_SIMD_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_critical:
 452     switch (CKind) {
 453 #define OPENMP_CRITICAL_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_distribute:
 462     switch (CKind) {
 463 #define OPENMP_DISTRIBUTE_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_unknown:
 472   case OMPD_threadprivate:
 473   case OMPD_section:
 474   case OMPD_master:
 475   case OMPD_taskyield:
 476   case OMPD_barrier:
 477   case OMPD_taskwait:
 478   case OMPD_taskgroup:
 479   case OMPD_cancellation_point:
 480     break;
 481   }
 482   return false;
 483 }
 484
 485 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) {
 486   return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd ||
 487          DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd ||
 488          DKind == OMPD_taskloop ||
 489          DKind == OMPD_taskloop_simd ||
 490          DKind == OMPD_distribute; // TODO add next directives.
 491 }
 492
 493 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) {
 494   return DKind == OMPD_for || DKind == OMPD_for_simd ||
 495          DKind == OMPD_sections || DKind == OMPD_section ||
 496          DKind == OMPD_single || DKind == OMPD_parallel_for ||
 497          DKind == OMPD_parallel_for_simd ||
 498          DKind == OMPD_parallel_sections; // TODO add next directives.
 499 }
 500
 501 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) {
 502   return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd;
 503 }
 504
 505 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) {
 506   return DKind == OMPD_parallel || DKind == OMPD_parallel_for ||
 507          DKind == OMPD_parallel_for_simd ||
 508          DKind == OMPD_parallel_sections; // TODO add next directives.
 509 }
 510
 511 bool clang::isOpenMPTargetDirective(OpenMPDirectiveKind DKind) {
 512   return DKind == OMPD_target; // TODO add next directives.
 513 }
 514
 515 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) {
 516   return DKind == OMPD_teams; // TODO add next directives.
 517 }
 518
 519 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) {
 520   return DKind == OMPD_simd || DKind == OMPD_for_simd ||
 521          DKind == OMPD_parallel_for_simd ||
 522          DKind == OMPD_taskloop_simd; // TODO add next directives.
 523 }
 524
 525 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) {
 526   return Kind == OMPD_distribute; // TODO add next directives.
 527 }
 528
 529 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) {
 530   return Kind == OMPC_private || Kind == OMPC_firstprivate ||
 531          Kind == OMPC_lastprivate || Kind == OMPC_linear ||
 532          Kind == OMPC_reduction; // TODO add next clauses like 'reduction'.
 533 }
 534
 535 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) {
 536   return Kind == OMPC_threadprivate || Kind == OMPC_copyin;
 537 }
 538