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