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