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) \
  26            .Case(#Name, OMPD_##Name)
  27 #include "clang/Basic/OpenMPKinds.def"
  28            .Default(OMPD_unknown);
  29 }
  30
  31 const char *clang::getOpenMPDirectiveName(OpenMPDirectiveKind Kind) {
  32   assert(Kind < NUM_OPENMP_DIRECTIVES);
  33   switch (Kind) {
  34   case OMPD_unknown:
  35     return "unknown";
  36 #define OPENMP_DIRECTIVE(Name) \
  37   case OMPD_##Name : return #Name;
  38 #include "clang/Basic/OpenMPKinds.def"
  39   case NUM_OPENMP_DIRECTIVES:
  40     break;
  41   }
  42   llvm_unreachable("Invalid OpenMP directive kind");
  43 }
  44
  45 OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) {
  46   return llvm::StringSwitch<OpenMPClauseKind>(Str)
  47 #define OPENMP_CLAUSE(Name, Class) \
  48            .Case(#Name, OMPC_##Name)
  49 #include "clang/Basic/OpenMPKinds.def"
  50            .Default(OMPC_unknown);
  51 }
  52
  53 const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) {
  54   assert(Kind < NUM_OPENMP_CLAUSES);
  55   switch (Kind) {
  56   case OMPC_unknown:
  57     return "unknown";
  58 #define OPENMP_CLAUSE(Name, Class) \
  59   case OMPC_##Name : return #Name;
  60 #include "clang/Basic/OpenMPKinds.def"
  61   case OMPC_threadprivate:
  62     return "threadprivate or thread local";
  63   case NUM_OPENMP_CLAUSES:
  64     break;
  65   }
  66   llvm_unreachable("Invalid OpenMP clause kind");
  67 }
  68
  69 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind,
  70                                           StringRef Str) {
  71   switch (Kind) {
  72   case OMPC_default:
  73     return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str)
  74 #define OPENMP_DEFAULT_KIND(Name) \
  75              .Case(#Name, OMPC_DEFAULT_##Name)
  76 #include "clang/Basic/OpenMPKinds.def"
  77              .Default(OMPC_DEFAULT_unknown);
  78   case OMPC_unknown:
  79   case OMPC_threadprivate:
  80   case OMPC_private:
  81   case OMPC_firstprivate:
  82   case OMPC_shared:
  83   case NUM_OPENMP_CLAUSES:
  84     break;
  85   }
  86   llvm_unreachable("Invalid OpenMP simple clause kind");
  87 }
  88
  89 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
  90                                                  unsigned Type) {
  91   switch (Kind) {
  92   case OMPC_default:
  93     switch (Type) {
  94     case OMPC_DEFAULT_unknown:
  95       return "unknown";
  96 #define OPENMP_DEFAULT_KIND(Name) \
  97     case OMPC_DEFAULT_##Name : return #Name;
  98 #include "clang/Basic/OpenMPKinds.def"
  99     }
 100     llvm_unreachable("Invalid OpenMP 'default' clause type");
 101   case OMPC_unknown:
 102   case OMPC_threadprivate:
 103   case OMPC_private:
 104   case OMPC_firstprivate:
 105   case OMPC_shared:
 106   case NUM_OPENMP_CLAUSES:
 107     break;
 108   }
 109   llvm_unreachable("Invalid OpenMP simple clause kind");
 110 }
 111
 112 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
 113                                         OpenMPClauseKind CKind) {
 114   assert(DKind < NUM_OPENMP_DIRECTIVES);
 115   assert(CKind < NUM_OPENMP_CLAUSES);
 116   switch (DKind) {
 117   case OMPD_parallel:
 118     switch (CKind) {
 119 #define OPENMP_PARALLEL_CLAUSE(Name) \
 120     case OMPC_##Name: return true;
 121 #include "clang/Basic/OpenMPKinds.def"
 122     default:
 123       break;
 124     }
 125     break;
 126   case OMPD_unknown:
 127   case OMPD_threadprivate:
 128   case OMPD_task:
 129   case NUM_OPENMP_DIRECTIVES:
 130     break;
 131   }
 132   return false;
 133 }