1 //===--- OpenMPKinds.cpp - Token Kinds Support ----------------------------===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 /// \file 9 /// This file implements the OpenMP enum and support functions. 10 /// 11 //===----------------------------------------------------------------------===// 12 13 #include "clang/Basic/OpenMPKinds.h" 14 #include "clang/Basic/IdentifierTable.h" 15 #include "llvm/ADT/StringRef.h" 16 #include "llvm/ADT/StringSwitch.h" 17 #include "llvm/Support/ErrorHandling.h" 18 #include <cassert> 19 20 using namespace clang; 21 using namespace llvm::omp; 22 23 unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind, 24 StringRef Str) { 25 switch (Kind) { 26 case OMPC_default: 27 return llvm::StringSwitch<unsigned>(Str) 28 #define OMP_DEFAULT_KIND(Enum, Name) .Case(Name, unsigned(Enum)) 29 #include "llvm/Frontend/OpenMP/OMPKinds.def" 30 .Default(unsigned(llvm::omp::OMP_DEFAULT_unknown)); 31 case OMPC_proc_bind: 32 return llvm::StringSwitch<unsigned>(Str) 33 #define OMP_PROC_BIND_KIND(Enum, Name, Value) .Case(Name, Value) 34 #include "llvm/Frontend/OpenMP/OMPKinds.def" 35 .Default(unsigned(llvm::omp::OMP_PROC_BIND_unknown)); 36 case OMPC_schedule: 37 return llvm::StringSwitch<unsigned>(Str) 38 #define OPENMP_SCHEDULE_KIND(Name) \ 39 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name)) 40 #define OPENMP_SCHEDULE_MODIFIER(Name) \ 41 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name)) 42 #include "clang/Basic/OpenMPKinds.def" 43 .Default(OMPC_SCHEDULE_unknown); 44 case OMPC_depend: 45 return llvm::StringSwitch<OpenMPDependClauseKind>(Str) 46 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name) 47 #include "clang/Basic/OpenMPKinds.def" 48 .Default(OMPC_DEPEND_unknown); 49 case OMPC_linear: 50 return llvm::StringSwitch<OpenMPLinearClauseKind>(Str) 51 #define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name) 52 #include "clang/Basic/OpenMPKinds.def" 53 .Default(OMPC_LINEAR_unknown); 54 case OMPC_map: 55 return llvm::StringSwitch<unsigned>(Str) 56 #define OPENMP_MAP_KIND(Name) \ 57 .Case(#Name, static_cast<unsigned>(OMPC_MAP_##Name)) 58 #define OPENMP_MAP_MODIFIER_KIND(Name) \ 59 .Case(#Name, static_cast<unsigned>(OMPC_MAP_MODIFIER_##Name)) 60 #include "clang/Basic/OpenMPKinds.def" 61 .Default(OMPC_MAP_unknown); 62 case OMPC_to: 63 return llvm::StringSwitch<unsigned>(Str) 64 #define OPENMP_TO_MODIFIER_KIND(Name) \ 65 .Case(#Name, static_cast<unsigned>(OMPC_TO_MODIFIER_##Name)) 66 #include "clang/Basic/OpenMPKinds.def" 67 .Default(OMPC_TO_MODIFIER_unknown); 68 case OMPC_from: 69 return llvm::StringSwitch<unsigned>(Str) 70 #define OPENMP_FROM_MODIFIER_KIND(Name) \ 71 .Case(#Name, static_cast<unsigned>(OMPC_FROM_MODIFIER_##Name)) 72 #include "clang/Basic/OpenMPKinds.def" 73 .Default(OMPC_FROM_MODIFIER_unknown); 74 case OMPC_dist_schedule: 75 return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str) 76 #define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name) 77 #include "clang/Basic/OpenMPKinds.def" 78 .Default(OMPC_DIST_SCHEDULE_unknown); 79 case OMPC_defaultmap: 80 return llvm::StringSwitch<unsigned>(Str) 81 #define OPENMP_DEFAULTMAP_KIND(Name) \ 82 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name)) 83 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 84 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name)) 85 #include "clang/Basic/OpenMPKinds.def" 86 .Default(OMPC_DEFAULTMAP_unknown); 87 case OMPC_atomic_default_mem_order: 88 return llvm::StringSwitch<OpenMPAtomicDefaultMemOrderClauseKind>(Str) 89 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \ 90 .Case(#Name, OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name) 91 #include "clang/Basic/OpenMPKinds.def" 92 .Default(OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown); 93 case OMPC_device_type: 94 return llvm::StringSwitch<OpenMPDeviceType>(Str) 95 #define OPENMP_DEVICE_TYPE_KIND(Name) .Case(#Name, OMPC_DEVICE_TYPE_##Name) 96 #include "clang/Basic/OpenMPKinds.def" 97 .Default(OMPC_DEVICE_TYPE_unknown); 98 case OMPC_lastprivate: 99 return llvm::StringSwitch<OpenMPLastprivateModifier>(Str) 100 #define OPENMP_LASTPRIVATE_KIND(Name) .Case(#Name, OMPC_LASTPRIVATE_##Name) 101 #include "clang/Basic/OpenMPKinds.def" 102 .Default(OMPC_LASTPRIVATE_unknown); 103 case OMPC_order: 104 return llvm::StringSwitch<OpenMPOrderClauseKind>(Str) 105 #define OPENMP_ORDER_KIND(Name) .Case(#Name, OMPC_ORDER_##Name) 106 #include "clang/Basic/OpenMPKinds.def" 107 .Default(OMPC_ORDER_unknown); 108 case OMPC_update: 109 return llvm::StringSwitch<OpenMPDependClauseKind>(Str) 110 #define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name) 111 #include "clang/Basic/OpenMPKinds.def" 112 .Default(OMPC_DEPEND_unknown); 113 case OMPC_device: 114 return llvm::StringSwitch<OpenMPDeviceClauseModifier>(Str) 115 #define OPENMP_DEVICE_MODIFIER(Name) .Case(#Name, OMPC_DEVICE_##Name) 116 #include "clang/Basic/OpenMPKinds.def" 117 .Default(OMPC_DEVICE_unknown); 118 case OMPC_reduction: 119 return llvm::StringSwitch<OpenMPReductionClauseModifier>(Str) 120 #define OPENMP_REDUCTION_MODIFIER(Name) .Case(#Name, OMPC_REDUCTION_##Name) 121 #include "clang/Basic/OpenMPKinds.def" 122 .Default(OMPC_REDUCTION_unknown); 123 case OMPC_unknown: 124 case OMPC_threadprivate: 125 case OMPC_if: 126 case OMPC_final: 127 case OMPC_num_threads: 128 case OMPC_safelen: 129 case OMPC_simdlen: 130 case OMPC_allocator: 131 case OMPC_allocate: 132 case OMPC_collapse: 133 case OMPC_private: 134 case OMPC_firstprivate: 135 case OMPC_shared: 136 case OMPC_task_reduction: 137 case OMPC_in_reduction: 138 case OMPC_aligned: 139 case OMPC_copyin: 140 case OMPC_copyprivate: 141 case OMPC_ordered: 142 case OMPC_nowait: 143 case OMPC_untied: 144 case OMPC_mergeable: 145 case OMPC_flush: 146 case OMPC_depobj: 147 case OMPC_read: 148 case OMPC_write: 149 case OMPC_capture: 150 case OMPC_seq_cst: 151 case OMPC_acq_rel: 152 case OMPC_acquire: 153 case OMPC_release: 154 case OMPC_relaxed: 155 case OMPC_threads: 156 case OMPC_simd: 157 case OMPC_num_teams: 158 case OMPC_thread_limit: 159 case OMPC_priority: 160 case OMPC_grainsize: 161 case OMPC_nogroup: 162 case OMPC_num_tasks: 163 case OMPC_hint: 164 case OMPC_uniform: 165 case OMPC_use_device_ptr: 166 case OMPC_is_device_ptr: 167 case OMPC_unified_address: 168 case OMPC_unified_shared_memory: 169 case OMPC_reverse_offload: 170 case OMPC_dynamic_allocators: 171 case OMPC_match: 172 case OMPC_nontemporal: 173 case OMPC_destroy: 174 case OMPC_detach: 175 case OMPC_inclusive: 176 case OMPC_exclusive: 177 case OMPC_uses_allocators: 178 case OMPC_affinity: 179 break; 180 } 181 llvm_unreachable("Invalid OpenMP simple clause kind"); 182 } 183 184 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, 185 unsigned Type) { 186 switch (Kind) { 187 case OMPC_default: 188 switch (llvm::omp::DefaultKind(Type)) { 189 #define OMP_DEFAULT_KIND(Enum, Name) \ 190 case Enum: \ 191 return Name; 192 #include "llvm/Frontend/OpenMP/OMPKinds.def" 193 } 194 llvm_unreachable("Invalid OpenMP 'default' clause type"); 195 case OMPC_proc_bind: 196 switch (Type) { 197 #define OMP_PROC_BIND_KIND(Enum, Name, Value) \ 198 case Value: \ 199 return Name; 200 #include "llvm/Frontend/OpenMP/OMPKinds.def" 201 } 202 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type"); 203 case OMPC_schedule: 204 switch (Type) { 205 case OMPC_SCHEDULE_unknown: 206 case OMPC_SCHEDULE_MODIFIER_last: 207 return "unknown"; 208 #define OPENMP_SCHEDULE_KIND(Name) \ 209 case OMPC_SCHEDULE_##Name: \ 210 return #Name; 211 #define OPENMP_SCHEDULE_MODIFIER(Name) \ 212 case OMPC_SCHEDULE_MODIFIER_##Name: \ 213 return #Name; 214 #include "clang/Basic/OpenMPKinds.def" 215 } 216 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 217 case OMPC_depend: 218 switch (Type) { 219 case OMPC_DEPEND_unknown: 220 return "unknown"; 221 #define OPENMP_DEPEND_KIND(Name) \ 222 case OMPC_DEPEND_##Name: \ 223 return #Name; 224 #include "clang/Basic/OpenMPKinds.def" 225 } 226 llvm_unreachable("Invalid OpenMP 'depend' clause type"); 227 case OMPC_linear: 228 switch (Type) { 229 case OMPC_LINEAR_unknown: 230 return "unknown"; 231 #define OPENMP_LINEAR_KIND(Name) \ 232 case OMPC_LINEAR_##Name: \ 233 return #Name; 234 #include "clang/Basic/OpenMPKinds.def" 235 } 236 llvm_unreachable("Invalid OpenMP 'linear' clause type"); 237 case OMPC_map: 238 switch (Type) { 239 case OMPC_MAP_unknown: 240 case OMPC_MAP_MODIFIER_last: 241 return "unknown"; 242 #define OPENMP_MAP_KIND(Name) \ 243 case OMPC_MAP_##Name: \ 244 return #Name; 245 #define OPENMP_MAP_MODIFIER_KIND(Name) \ 246 case OMPC_MAP_MODIFIER_##Name: \ 247 return #Name; 248 #include "clang/Basic/OpenMPKinds.def" 249 default: 250 break; 251 } 252 llvm_unreachable("Invalid OpenMP 'map' clause type"); 253 case OMPC_to: 254 switch (Type) { 255 case OMPC_TO_MODIFIER_unknown: 256 return "unknown"; 257 #define OPENMP_TO_MODIFIER_KIND(Name) \ 258 case OMPC_TO_MODIFIER_##Name: \ 259 return #Name; 260 #include "clang/Basic/OpenMPKinds.def" 261 default: 262 break; 263 } 264 llvm_unreachable("Invalid OpenMP 'to' clause type"); 265 case OMPC_from: 266 switch (Type) { 267 case OMPC_FROM_MODIFIER_unknown: 268 return "unknown"; 269 #define OPENMP_FROM_MODIFIER_KIND(Name) \ 270 case OMPC_FROM_MODIFIER_##Name: \ 271 return #Name; 272 #include "clang/Basic/OpenMPKinds.def" 273 default: 274 break; 275 } 276 llvm_unreachable("Invalid OpenMP 'from' clause type"); 277 case OMPC_dist_schedule: 278 switch (Type) { 279 case OMPC_DIST_SCHEDULE_unknown: 280 return "unknown"; 281 #define OPENMP_DIST_SCHEDULE_KIND(Name) \ 282 case OMPC_DIST_SCHEDULE_##Name: \ 283 return #Name; 284 #include "clang/Basic/OpenMPKinds.def" 285 } 286 llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type"); 287 case OMPC_defaultmap: 288 switch (Type) { 289 case OMPC_DEFAULTMAP_unknown: 290 case OMPC_DEFAULTMAP_MODIFIER_last: 291 return "unknown"; 292 #define OPENMP_DEFAULTMAP_KIND(Name) \ 293 case OMPC_DEFAULTMAP_##Name: \ 294 return #Name; 295 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 296 case OMPC_DEFAULTMAP_MODIFIER_##Name: \ 297 return #Name; 298 #include "clang/Basic/OpenMPKinds.def" 299 } 300 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 301 case OMPC_atomic_default_mem_order: 302 switch (Type) { 303 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown: 304 return "unknown"; 305 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \ 306 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name: \ 307 return #Name; 308 #include "clang/Basic/OpenMPKinds.def" 309 } 310 llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type"); 311 case OMPC_device_type: 312 switch (Type) { 313 case OMPC_DEVICE_TYPE_unknown: 314 return "unknown"; 315 #define OPENMP_DEVICE_TYPE_KIND(Name) \ 316 case OMPC_DEVICE_TYPE_##Name: \ 317 return #Name; 318 #include "clang/Basic/OpenMPKinds.def" 319 } 320 llvm_unreachable("Invalid OpenMP 'device_type' clause type"); 321 case OMPC_lastprivate: 322 switch (Type) { 323 case OMPC_LASTPRIVATE_unknown: 324 return "unknown"; 325 #define OPENMP_LASTPRIVATE_KIND(Name) \ 326 case OMPC_LASTPRIVATE_##Name: \ 327 return #Name; 328 #include "clang/Basic/OpenMPKinds.def" 329 } 330 llvm_unreachable("Invalid OpenMP 'lastprivate' clause type"); 331 case OMPC_order: 332 switch (Type) { 333 case OMPC_ORDER_unknown: 334 return "unknown"; 335 #define OPENMP_ORDER_KIND(Name) \ 336 case OMPC_ORDER_##Name: \ 337 return #Name; 338 #include "clang/Basic/OpenMPKinds.def" 339 } 340 llvm_unreachable("Invalid OpenMP 'order' clause type"); 341 case OMPC_update: 342 switch (Type) { 343 case OMPC_DEPEND_unknown: 344 return "unknown"; 345 #define OPENMP_DEPEND_KIND(Name) \ 346 case OMPC_DEPEND_##Name: \ 347 return #Name; 348 #include "clang/Basic/OpenMPKinds.def" 349 } 350 llvm_unreachable("Invalid OpenMP 'depend' clause type"); 351 case OMPC_device: 352 switch (Type) { 353 case OMPC_DEVICE_unknown: 354 return "unknown"; 355 #define OPENMP_DEVICE_MODIFIER(Name) \ 356 case OMPC_DEVICE_##Name: \ 357 return #Name; 358 #include "clang/Basic/OpenMPKinds.def" 359 } 360 llvm_unreachable("Invalid OpenMP 'device' clause modifier"); 361 case OMPC_reduction: 362 switch (Type) { 363 case OMPC_REDUCTION_unknown: 364 return "unknown"; 365 #define OPENMP_REDUCTION_MODIFIER(Name) \ 366 case OMPC_REDUCTION_##Name: \ 367 return #Name; 368 #include "clang/Basic/OpenMPKinds.def" 369 } 370 llvm_unreachable("Invalid OpenMP 'reduction' clause modifier"); 371 case OMPC_unknown: 372 case OMPC_threadprivate: 373 case OMPC_if: 374 case OMPC_final: 375 case OMPC_num_threads: 376 case OMPC_safelen: 377 case OMPC_simdlen: 378 case OMPC_allocator: 379 case OMPC_allocate: 380 case OMPC_collapse: 381 case OMPC_private: 382 case OMPC_firstprivate: 383 case OMPC_shared: 384 case OMPC_task_reduction: 385 case OMPC_in_reduction: 386 case OMPC_aligned: 387 case OMPC_copyin: 388 case OMPC_copyprivate: 389 case OMPC_ordered: 390 case OMPC_nowait: 391 case OMPC_untied: 392 case OMPC_mergeable: 393 case OMPC_flush: 394 case OMPC_depobj: 395 case OMPC_read: 396 case OMPC_write: 397 case OMPC_capture: 398 case OMPC_seq_cst: 399 case OMPC_acq_rel: 400 case OMPC_acquire: 401 case OMPC_release: 402 case OMPC_relaxed: 403 case OMPC_threads: 404 case OMPC_simd: 405 case OMPC_num_teams: 406 case OMPC_thread_limit: 407 case OMPC_priority: 408 case OMPC_grainsize: 409 case OMPC_nogroup: 410 case OMPC_num_tasks: 411 case OMPC_hint: 412 case OMPC_uniform: 413 case OMPC_use_device_ptr: 414 case OMPC_is_device_ptr: 415 case OMPC_unified_address: 416 case OMPC_unified_shared_memory: 417 case OMPC_reverse_offload: 418 case OMPC_dynamic_allocators: 419 case OMPC_match: 420 case OMPC_nontemporal: 421 case OMPC_destroy: 422 case OMPC_detach: 423 case OMPC_inclusive: 424 case OMPC_exclusive: 425 case OMPC_uses_allocators: 426 case OMPC_affinity: 427 break; 428 } 429 llvm_unreachable("Invalid OpenMP simple clause kind"); 430 } 431 432 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) { 433 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd || 434 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd || 435 DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 436 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 437 DKind == OMPD_parallel_master_taskloop || 438 DKind == OMPD_parallel_master_taskloop_simd || 439 DKind == OMPD_distribute || DKind == OMPD_target_parallel_for || 440 DKind == OMPD_distribute_parallel_for || 441 DKind == OMPD_distribute_parallel_for_simd || 442 DKind == OMPD_distribute_simd || 443 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 444 DKind == OMPD_teams_distribute || 445 DKind == OMPD_teams_distribute_simd || 446 DKind == OMPD_teams_distribute_parallel_for_simd || 447 DKind == OMPD_teams_distribute_parallel_for || 448 DKind == OMPD_target_teams_distribute || 449 DKind == OMPD_target_teams_distribute_parallel_for || 450 DKind == OMPD_target_teams_distribute_parallel_for_simd || 451 DKind == OMPD_target_teams_distribute_simd; 452 } 453 454 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { 455 return DKind == OMPD_for || DKind == OMPD_for_simd || 456 DKind == OMPD_sections || DKind == OMPD_section || 457 DKind == OMPD_single || DKind == OMPD_parallel_for || 458 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 459 DKind == OMPD_target_parallel_for || 460 DKind == OMPD_distribute_parallel_for || 461 DKind == OMPD_distribute_parallel_for_simd || 462 DKind == OMPD_target_parallel_for_simd || 463 DKind == OMPD_teams_distribute_parallel_for_simd || 464 DKind == OMPD_teams_distribute_parallel_for || 465 DKind == OMPD_target_teams_distribute_parallel_for || 466 DKind == OMPD_target_teams_distribute_parallel_for_simd; 467 } 468 469 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) { 470 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 471 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 472 DKind == OMPD_parallel_master_taskloop || 473 DKind == OMPD_parallel_master_taskloop_simd; 474 } 475 476 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) { 477 return DKind == OMPD_parallel || DKind == OMPD_parallel_for || 478 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 479 DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for || 480 DKind == OMPD_distribute_parallel_for || 481 DKind == OMPD_distribute_parallel_for_simd || 482 DKind == OMPD_target_parallel_for_simd || 483 DKind == OMPD_teams_distribute_parallel_for || 484 DKind == OMPD_teams_distribute_parallel_for_simd || 485 DKind == OMPD_target_teams_distribute_parallel_for || 486 DKind == OMPD_target_teams_distribute_parallel_for_simd || 487 DKind == OMPD_parallel_master || 488 DKind == OMPD_parallel_master_taskloop || 489 DKind == OMPD_parallel_master_taskloop_simd; 490 } 491 492 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) { 493 return DKind == OMPD_target || DKind == OMPD_target_parallel || 494 DKind == OMPD_target_parallel_for || 495 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 496 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 497 DKind == OMPD_target_teams_distribute_parallel_for || 498 DKind == OMPD_target_teams_distribute_parallel_for_simd || 499 DKind == OMPD_target_teams_distribute_simd; 500 } 501 502 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) { 503 return DKind == OMPD_target_data || DKind == OMPD_target_enter_data || 504 DKind == OMPD_target_exit_data || DKind == OMPD_target_update; 505 } 506 507 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) { 508 return DKind == OMPD_teams || DKind == OMPD_teams_distribute || 509 DKind == OMPD_teams_distribute_simd || 510 DKind == OMPD_teams_distribute_parallel_for_simd || 511 DKind == OMPD_teams_distribute_parallel_for; 512 } 513 514 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) { 515 return isOpenMPNestingTeamsDirective(DKind) || 516 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 517 DKind == OMPD_target_teams_distribute_parallel_for || 518 DKind == OMPD_target_teams_distribute_parallel_for_simd || 519 DKind == OMPD_target_teams_distribute_simd; 520 } 521 522 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) { 523 return DKind == OMPD_simd || DKind == OMPD_for_simd || 524 DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd || 525 DKind == OMPD_master_taskloop_simd || 526 DKind == OMPD_parallel_master_taskloop_simd || 527 DKind == OMPD_distribute_parallel_for_simd || 528 DKind == OMPD_distribute_simd || DKind == OMPD_target_simd || 529 DKind == OMPD_teams_distribute_simd || 530 DKind == OMPD_teams_distribute_parallel_for_simd || 531 DKind == OMPD_target_teams_distribute_parallel_for_simd || 532 DKind == OMPD_target_teams_distribute_simd || 533 DKind == OMPD_target_parallel_for_simd; 534 } 535 536 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) { 537 return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for || 538 Kind == OMPD_distribute_parallel_for_simd || 539 Kind == OMPD_distribute_simd; 540 // TODO add next directives. 541 } 542 543 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) { 544 return isOpenMPNestingDistributeDirective(Kind) || 545 Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd || 546 Kind == OMPD_teams_distribute_parallel_for_simd || 547 Kind == OMPD_teams_distribute_parallel_for || 548 Kind == OMPD_target_teams_distribute || 549 Kind == OMPD_target_teams_distribute_parallel_for || 550 Kind == OMPD_target_teams_distribute_parallel_for_simd || 551 Kind == OMPD_target_teams_distribute_simd; 552 } 553 554 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) { 555 return Kind == OMPC_private || Kind == OMPC_firstprivate || 556 Kind == OMPC_lastprivate || Kind == OMPC_linear || 557 Kind == OMPC_reduction || Kind == OMPC_task_reduction || 558 Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'. 559 } 560 561 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) { 562 return Kind == OMPC_threadprivate || Kind == OMPC_copyin; 563 } 564 565 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) { 566 return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind); 567 } 568 569 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) { 570 return Kind == OMPD_distribute_parallel_for || 571 Kind == OMPD_distribute_parallel_for_simd || 572 Kind == OMPD_teams_distribute_parallel_for_simd || 573 Kind == OMPD_teams_distribute_parallel_for || 574 Kind == OMPD_target_teams_distribute_parallel_for || 575 Kind == OMPD_target_teams_distribute_parallel_for_simd; 576 } 577 578 void clang::getOpenMPCaptureRegions( 579 SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions, 580 OpenMPDirectiveKind DKind) { 581 assert(DKind <= OMPD_unknown); 582 switch (DKind) { 583 case OMPD_parallel: 584 case OMPD_parallel_for: 585 case OMPD_parallel_for_simd: 586 case OMPD_parallel_master: 587 case OMPD_parallel_sections: 588 case OMPD_distribute_parallel_for: 589 case OMPD_distribute_parallel_for_simd: 590 CaptureRegions.push_back(OMPD_parallel); 591 break; 592 case OMPD_target_teams: 593 case OMPD_target_teams_distribute: 594 case OMPD_target_teams_distribute_simd: 595 CaptureRegions.push_back(OMPD_task); 596 CaptureRegions.push_back(OMPD_target); 597 CaptureRegions.push_back(OMPD_teams); 598 break; 599 case OMPD_teams: 600 case OMPD_teams_distribute: 601 case OMPD_teams_distribute_simd: 602 CaptureRegions.push_back(OMPD_teams); 603 break; 604 case OMPD_target: 605 case OMPD_target_simd: 606 CaptureRegions.push_back(OMPD_task); 607 CaptureRegions.push_back(OMPD_target); 608 break; 609 case OMPD_teams_distribute_parallel_for: 610 case OMPD_teams_distribute_parallel_for_simd: 611 CaptureRegions.push_back(OMPD_teams); 612 CaptureRegions.push_back(OMPD_parallel); 613 break; 614 case OMPD_target_parallel: 615 case OMPD_target_parallel_for: 616 case OMPD_target_parallel_for_simd: 617 CaptureRegions.push_back(OMPD_task); 618 CaptureRegions.push_back(OMPD_target); 619 CaptureRegions.push_back(OMPD_parallel); 620 break; 621 case OMPD_task: 622 case OMPD_target_enter_data: 623 case OMPD_target_exit_data: 624 case OMPD_target_update: 625 CaptureRegions.push_back(OMPD_task); 626 break; 627 case OMPD_taskloop: 628 case OMPD_taskloop_simd: 629 case OMPD_master_taskloop: 630 case OMPD_master_taskloop_simd: 631 CaptureRegions.push_back(OMPD_taskloop); 632 break; 633 case OMPD_parallel_master_taskloop: 634 case OMPD_parallel_master_taskloop_simd: 635 CaptureRegions.push_back(OMPD_parallel); 636 CaptureRegions.push_back(OMPD_taskloop); 637 break; 638 case OMPD_target_teams_distribute_parallel_for: 639 case OMPD_target_teams_distribute_parallel_for_simd: 640 CaptureRegions.push_back(OMPD_task); 641 CaptureRegions.push_back(OMPD_target); 642 CaptureRegions.push_back(OMPD_teams); 643 CaptureRegions.push_back(OMPD_parallel); 644 break; 645 case OMPD_simd: 646 case OMPD_for: 647 case OMPD_for_simd: 648 case OMPD_sections: 649 case OMPD_section: 650 case OMPD_single: 651 case OMPD_master: 652 case OMPD_critical: 653 case OMPD_taskgroup: 654 case OMPD_distribute: 655 case OMPD_ordered: 656 case OMPD_atomic: 657 case OMPD_target_data: 658 case OMPD_distribute_simd: 659 CaptureRegions.push_back(OMPD_unknown); 660 break; 661 case OMPD_threadprivate: 662 case OMPD_allocate: 663 case OMPD_taskyield: 664 case OMPD_barrier: 665 case OMPD_taskwait: 666 case OMPD_cancellation_point: 667 case OMPD_cancel: 668 case OMPD_flush: 669 case OMPD_depobj: 670 case OMPD_scan: 671 case OMPD_declare_reduction: 672 case OMPD_declare_mapper: 673 case OMPD_declare_simd: 674 case OMPD_declare_target: 675 case OMPD_end_declare_target: 676 case OMPD_requires: 677 case OMPD_declare_variant: 678 case OMPD_begin_declare_variant: 679 case OMPD_end_declare_variant: 680 llvm_unreachable("OpenMP Directive is not allowed"); 681 case OMPD_unknown: 682 llvm_unreachable("Unknown OpenMP directive"); 683 } 684 } 685