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