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<OpenMPScheduleClauseKind>(Str) 91 #define OPENMP_SCHEDULE_KIND(Name) .Case(#Name, OMPC_SCHEDULE_##Name) 92 #include "clang/Basic/OpenMPKinds.def" 93 .Default(OMPC_SCHEDULE_unknown); 94 case OMPC_depend: 95 return llvm::StringSwitch<OpenMPDependClauseKind>(Str) 96 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name) 97 #include "clang/Basic/OpenMPKinds.def" 98 .Default(OMPC_DEPEND_unknown); 99 case OMPC_unknown: 100 case OMPC_threadprivate: 101 case OMPC_if: 102 case OMPC_final: 103 case OMPC_num_threads: 104 case OMPC_safelen: 105 case OMPC_collapse: 106 case OMPC_private: 107 case OMPC_firstprivate: 108 case OMPC_lastprivate: 109 case OMPC_shared: 110 case OMPC_reduction: 111 case OMPC_linear: 112 case OMPC_aligned: 113 case OMPC_copyin: 114 case OMPC_copyprivate: 115 case OMPC_ordered: 116 case OMPC_nowait: 117 case OMPC_untied: 118 case OMPC_mergeable: 119 case OMPC_flush: 120 case OMPC_read: 121 case OMPC_write: 122 case OMPC_update: 123 case OMPC_capture: 124 case OMPC_seq_cst: 125 case OMPC_device: 126 break; 127 } 128 llvm_unreachable("Invalid OpenMP simple clause kind"); 129 } 130 131 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, 132 unsigned Type) { 133 switch (Kind) { 134 case OMPC_default: 135 switch (Type) { 136 case OMPC_DEFAULT_unknown: 137 return "unknown"; 138 #define OPENMP_DEFAULT_KIND(Name) \ 139 case OMPC_DEFAULT_##Name: \ 140 return #Name; 141 #include "clang/Basic/OpenMPKinds.def" 142 } 143 llvm_unreachable("Invalid OpenMP 'default' clause type"); 144 case OMPC_proc_bind: 145 switch (Type) { 146 case OMPC_PROC_BIND_unknown: 147 return "unknown"; 148 #define OPENMP_PROC_BIND_KIND(Name) \ 149 case OMPC_PROC_BIND_##Name: \ 150 return #Name; 151 #include "clang/Basic/OpenMPKinds.def" 152 } 153 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type"); 154 case OMPC_schedule: 155 switch (Type) { 156 case OMPC_SCHEDULE_unknown: 157 return "unknown"; 158 #define OPENMP_SCHEDULE_KIND(Name) \ 159 case OMPC_SCHEDULE_##Name: \ 160 return #Name; 161 #include "clang/Basic/OpenMPKinds.def" 162 } 163 case OMPC_depend: 164 switch (Type) { 165 case OMPC_DEPEND_unknown: 166 return "unknown"; 167 #define OPENMP_DEPEND_KIND(Name) \ 168 case OMPC_DEPEND_##Name: \ 169 return #Name; 170 #include "clang/Basic/OpenMPKinds.def" 171 } 172 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 173 case OMPC_unknown: 174 case OMPC_threadprivate: 175 case OMPC_if: 176 case OMPC_final: 177 case OMPC_num_threads: 178 case OMPC_safelen: 179 case OMPC_collapse: 180 case OMPC_private: 181 case OMPC_firstprivate: 182 case OMPC_lastprivate: 183 case OMPC_shared: 184 case OMPC_reduction: 185 case OMPC_linear: 186 case OMPC_aligned: 187 case OMPC_copyin: 188 case OMPC_copyprivate: 189 case OMPC_ordered: 190 case OMPC_nowait: 191 case OMPC_untied: 192 case OMPC_mergeable: 193 case OMPC_flush: 194 case OMPC_read: 195 case OMPC_write: 196 case OMPC_update: 197 case OMPC_capture: 198 case OMPC_seq_cst: 199 case OMPC_device: 200 break; 201 } 202 llvm_unreachable("Invalid OpenMP simple clause kind"); 203 } 204 205 bool clang::isAllowedClauseForDirective(OpenMPDirectiveKind DKind, 206 OpenMPClauseKind CKind) { 207 assert(DKind <= OMPD_unknown); 208 assert(CKind <= OMPC_unknown); 209 switch (DKind) { 210 case OMPD_parallel: 211 switch (CKind) { 212 #define OPENMP_PARALLEL_CLAUSE(Name) \ 213 case OMPC_##Name: \ 214 return true; 215 #include "clang/Basic/OpenMPKinds.def" 216 default: 217 break; 218 } 219 break; 220 case OMPD_simd: 221 switch (CKind) { 222 #define OPENMP_SIMD_CLAUSE(Name) \ 223 case OMPC_##Name: \ 224 return true; 225 #include "clang/Basic/OpenMPKinds.def" 226 default: 227 break; 228 } 229 break; 230 case OMPD_for: 231 switch (CKind) { 232 #define OPENMP_FOR_CLAUSE(Name) \ 233 case OMPC_##Name: \ 234 return true; 235 #include "clang/Basic/OpenMPKinds.def" 236 default: 237 break; 238 } 239 break; 240 case OMPD_for_simd: 241 switch (CKind) { 242 #define OPENMP_FOR_SIMD_CLAUSE(Name) \ 243 case OMPC_##Name: \ 244 return true; 245 #include "clang/Basic/OpenMPKinds.def" 246 default: 247 break; 248 } 249 break; 250 case OMPD_sections: 251 switch (CKind) { 252 #define OPENMP_SECTIONS_CLAUSE(Name) \ 253 case OMPC_##Name: \ 254 return true; 255 #include "clang/Basic/OpenMPKinds.def" 256 default: 257 break; 258 } 259 break; 260 case OMPD_single: 261 switch (CKind) { 262 #define OPENMP_SINGLE_CLAUSE(Name) \ 263 case OMPC_##Name: \ 264 return true; 265 #include "clang/Basic/OpenMPKinds.def" 266 default: 267 break; 268 } 269 break; 270 case OMPD_parallel_for: 271 switch (CKind) { 272 #define OPENMP_PARALLEL_FOR_CLAUSE(Name) \ 273 case OMPC_##Name: \ 274 return true; 275 #include "clang/Basic/OpenMPKinds.def" 276 default: 277 break; 278 } 279 break; 280 case OMPD_parallel_for_simd: 281 switch (CKind) { 282 #define OPENMP_PARALLEL_FOR_SIMD_CLAUSE(Name) \ 283 case OMPC_##Name: \ 284 return true; 285 #include "clang/Basic/OpenMPKinds.def" 286 default: 287 break; 288 } 289 break; 290 case OMPD_parallel_sections: 291 switch (CKind) { 292 #define OPENMP_PARALLEL_SECTIONS_CLAUSE(Name) \ 293 case OMPC_##Name: \ 294 return true; 295 #include "clang/Basic/OpenMPKinds.def" 296 default: 297 break; 298 } 299 break; 300 case OMPD_task: 301 switch (CKind) { 302 #define OPENMP_TASK_CLAUSE(Name) \ 303 case OMPC_##Name: \ 304 return true; 305 #include "clang/Basic/OpenMPKinds.def" 306 default: 307 break; 308 } 309 break; 310 case OMPD_flush: 311 return CKind == OMPC_flush; 312 break; 313 case OMPD_atomic: 314 switch (CKind) { 315 #define OPENMP_ATOMIC_CLAUSE(Name) \ 316 case OMPC_##Name: \ 317 return true; 318 #include "clang/Basic/OpenMPKinds.def" 319 default: 320 break; 321 } 322 break; 323 case OMPD_target: 324 switch (CKind) { 325 #define OPENMP_TARGET_CLAUSE(Name) \ 326 case OMPC_##Name: \ 327 return true; 328 #include "clang/Basic/OpenMPKinds.def" 329 default: 330 break; 331 } 332 break; 333 case OMPD_target_data: 334 switch (CKind) { 335 #define OPENMP_TARGET_DATA_CLAUSE(Name) \ 336 case OMPC_##Name: \ 337 return true; 338 #include "clang/Basic/OpenMPKinds.def" 339 default: 340 break; 341 } 342 break; 343 case OMPD_teams: 344 switch (CKind) { 345 #define OPENMP_TEAMS_CLAUSE(Name) \ 346 case OMPC_##Name: \ 347 return true; 348 #include "clang/Basic/OpenMPKinds.def" 349 default: 350 break; 351 } 352 break; 353 case OMPD_unknown: 354 case OMPD_threadprivate: 355 case OMPD_section: 356 case OMPD_master: 357 case OMPD_critical: 358 case OMPD_taskyield: 359 case OMPD_barrier: 360 case OMPD_taskwait: 361 case OMPD_taskgroup: 362 case OMPD_cancellation_point: 363 case OMPD_cancel: 364 case OMPD_ordered: 365 break; 366 } 367 return false; 368 } 369 370 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) { 371 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd || 372 DKind == OMPD_parallel_for || 373 DKind == OMPD_parallel_for_simd; // TODO add next directives. 374 } 375 376 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { 377 return DKind == OMPD_for || DKind == OMPD_for_simd || 378 DKind == OMPD_sections || DKind == OMPD_section || 379 DKind == OMPD_single || DKind == OMPD_parallel_for || 380 DKind == OMPD_parallel_for_simd || 381 DKind == OMPD_parallel_sections; // TODO add next directives. 382 } 383 384 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) { 385 return DKind == OMPD_parallel || DKind == OMPD_parallel_for || 386 DKind == OMPD_parallel_for_simd || 387 DKind == OMPD_parallel_sections; // TODO add next directives. 388 } 389 390 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) { 391 return DKind == OMPD_teams; // TODO add next directives. 392 } 393 394 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) { 395 return DKind == OMPD_simd || DKind == OMPD_for_simd || 396 DKind == OMPD_parallel_for_simd; // TODO add next directives. 397 } 398 399 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) { 400 return Kind == OMPC_private || Kind == OMPC_firstprivate || 401 Kind == OMPC_lastprivate || Kind == OMPC_linear || 402 Kind == OMPC_reduction; // TODO add next clauses like 'reduction'. 403 } 404 405 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) { 406 return Kind == OMPC_threadprivate || Kind == OMPC_copyin; 407 } 408 409