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