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 <= OMPD_unknown);
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     break;
40   }
41   llvm_unreachable("Invalid OpenMP directive kind");
42 }
43 
44 OpenMPClauseKind clang::getOpenMPClauseKind(StringRef Str) {
45   return llvm::StringSwitch<OpenMPClauseKind>(Str)
46 #define OPENMP_CLAUSE(Name, Class) \
47            .Case(#Name, OMPC_##Name)
48 #include "clang/Basic/OpenMPKinds.def"
49            .Default(OMPC_unknown);
50 }
51 
52 const char *clang::getOpenMPClauseName(OpenMPClauseKind Kind) {
53   assert(Kind <= OMPC_unknown);
54   switch (Kind) {
55   case OMPC_unknown:
56     return "unknown";
57 #define OPENMP_CLAUSE(Name, Class) \
58   case OMPC_##Name : return #Name;
59 #include "clang/Basic/OpenMPKinds.def"
60   case OMPC_threadprivate:
61     return "threadprivate or thread local";
62   }
63   llvm_unreachable("Invalid OpenMP clause kind");
64 }
65 
66 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind,
67                                           StringRef Str) {
68   switch (Kind) {
69   case OMPC_default:
70     return llvm::StringSwitch<OpenMPDefaultClauseKind>(Str)
71 #define OPENMP_DEFAULT_KIND(Name) \
72              .Case(#Name, OMPC_DEFAULT_##Name)
73 #include "clang/Basic/OpenMPKinds.def"
74              .Default(OMPC_DEFAULT_unknown);
75   case OMPC_proc_bind:
76     return llvm::StringSwitch<OpenMPProcBindClauseKind>(Str)
77 #define OPENMP_PROC_BIND_KIND(Name) \
78              .Case(#Name, OMPC_PROC_BIND_##Name)
79 #include "clang/Basic/OpenMPKinds.def"
80              .Default(OMPC_PROC_BIND_unknown);
81   case OMPC_unknown:
82   case OMPC_threadprivate:
83   case OMPC_if:
84   case OMPC_num_threads:
85   case OMPC_safelen:
86   case OMPC_collapse:
87   case OMPC_private:
88   case OMPC_firstprivate:
89   case OMPC_lastprivate:
90   case OMPC_shared:
91   case OMPC_linear:
92   case OMPC_aligned:
93   case OMPC_copyin:
94     break;
95   }
96   llvm_unreachable("Invalid OpenMP simple clause kind");
97 }
98 
99 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
100                                                  unsigned Type) {
101   switch (Kind) {
102   case OMPC_default:
103     switch (Type) {
104     case OMPC_DEFAULT_unknown:
105       return "unknown";
106 #define OPENMP_DEFAULT_KIND(Name) \
107     case OMPC_DEFAULT_##Name : return #Name;
108 #include "clang/Basic/OpenMPKinds.def"
109     }
110     llvm_unreachable("Invalid OpenMP 'default' clause type");
111   case OMPC_proc_bind:
112     switch (Type) {
113     case OMPC_PROC_BIND_unknown:
114       return "unknown";
115 #define OPENMP_PROC_BIND_KIND(Name) \
116     case OMPC_PROC_BIND_##Name : return #Name;
117 #include "clang/Basic/OpenMPKinds.def"
118     }
119     llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
120   case OMPC_unknown:
121   case OMPC_threadprivate:
122   case OMPC_if:
123   case OMPC_num_threads:
124   case OMPC_safelen:
125   case OMPC_collapse:
126   case OMPC_private:
127   case OMPC_firstprivate:
128   case OMPC_lastprivate:
129   case OMPC_shared:
130   case OMPC_linear:
131   case OMPC_aligned:
132   case OMPC_copyin:
133     break;
134   }
135   llvm_unreachable("Invalid OpenMP simple clause kind");
136 }
137 
138 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
139                                         OpenMPClauseKind CKind) {
140   assert(DKind <= OMPD_unknown);
141   assert(CKind <= OMPC_unknown);
142   switch (DKind) {
143   case OMPD_parallel:
144     switch (CKind) {
145 #define OPENMP_PARALLEL_CLAUSE(Name) \
146     case OMPC_##Name: return true;
147 #include "clang/Basic/OpenMPKinds.def"
148     default:
149       break;
150     }
151     break;
152   case OMPD_simd:
153     switch (CKind) {
154 #define OPENMP_SIMD_CLAUSE(Name) \
155     case OMPC_##Name: return true;
156 #include "clang/Basic/OpenMPKinds.def"
157     default:
158       break;
159     }
160     break;
161   case OMPD_unknown:
162   case OMPD_threadprivate:
163   case OMPD_task:
164     break;
165   }
166   return false;
167 }
168