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_reduction:
92   case OMPC_linear:
93   case OMPC_aligned:
94   case OMPC_copyin:
95     break;
96   }
97   llvm_unreachable("Invalid OpenMP simple clause kind");
98 }
99 
100 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind,
101                                                  unsigned Type) {
102   switch (Kind) {
103   case OMPC_default:
104     switch (Type) {
105     case OMPC_DEFAULT_unknown:
106       return "unknown";
107 #define OPENMP_DEFAULT_KIND(Name) \
108     case OMPC_DEFAULT_##Name : return #Name;
109 #include "clang/Basic/OpenMPKinds.def"
110     }
111     llvm_unreachable("Invalid OpenMP 'default' clause type");
112   case OMPC_proc_bind:
113     switch (Type) {
114     case OMPC_PROC_BIND_unknown:
115       return "unknown";
116 #define OPENMP_PROC_BIND_KIND(Name) \
117     case OMPC_PROC_BIND_##Name : return #Name;
118 #include "clang/Basic/OpenMPKinds.def"
119     }
120     llvm_unreachable("Invalid OpenMP 'proc_bind' clause type");
121   case OMPC_unknown:
122   case OMPC_threadprivate:
123   case OMPC_if:
124   case OMPC_num_threads:
125   case OMPC_safelen:
126   case OMPC_collapse:
127   case OMPC_private:
128   case OMPC_firstprivate:
129   case OMPC_lastprivate:
130   case OMPC_shared:
131   case OMPC_reduction:
132   case OMPC_linear:
133   case OMPC_aligned:
134   case OMPC_copyin:
135     break;
136   }
137   llvm_unreachable("Invalid OpenMP simple clause kind");
138 }
139 
140 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind,
141                                         OpenMPClauseKind CKind) {
142   assert(DKind <= OMPD_unknown);
143   assert(CKind <= OMPC_unknown);
144   switch (DKind) {
145   case OMPD_parallel:
146     switch (CKind) {
147 #define OPENMP_PARALLEL_CLAUSE(Name) \
148     case OMPC_##Name: return true;
149 #include "clang/Basic/OpenMPKinds.def"
150     default:
151       break;
152     }
153     break;
154   case OMPD_simd:
155     switch (CKind) {
156 #define OPENMP_SIMD_CLAUSE(Name) \
157     case OMPC_##Name: return true;
158 #include "clang/Basic/OpenMPKinds.def"
159     default:
160       break;
161     }
162     break;
163   case OMPD_unknown:
164   case OMPD_threadprivate:
165   case OMPD_task:
166     break;
167   }
168   return false;
169 }
170