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_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 case OMPC_from: 262 switch (Type) { 263 case OMPC_MOTION_MODIFIER_unknown: 264 return "unknown"; 265 #define OPENMP_MOTION_MODIFIER_KIND(Name) \ 266 case OMPC_MOTION_MODIFIER_##Name: \ 267 return #Name; 268 #include "clang/Basic/OpenMPKinds.def" 269 default: 270 break; 271 } 272 llvm_unreachable("Invalid OpenMP 'to' or 'from' clause type"); 273 case OMPC_dist_schedule: 274 switch (Type) { 275 case OMPC_DIST_SCHEDULE_unknown: 276 return "unknown"; 277 #define OPENMP_DIST_SCHEDULE_KIND(Name) \ 278 case OMPC_DIST_SCHEDULE_##Name: \ 279 return #Name; 280 #include "clang/Basic/OpenMPKinds.def" 281 } 282 llvm_unreachable("Invalid OpenMP 'dist_schedule' clause type"); 283 case OMPC_defaultmap: 284 switch (Type) { 285 case OMPC_DEFAULTMAP_unknown: 286 case OMPC_DEFAULTMAP_MODIFIER_last: 287 return "unknown"; 288 #define OPENMP_DEFAULTMAP_KIND(Name) \ 289 case OMPC_DEFAULTMAP_##Name: \ 290 return #Name; 291 #define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 292 case OMPC_DEFAULTMAP_MODIFIER_##Name: \ 293 return #Name; 294 #include "clang/Basic/OpenMPKinds.def" 295 } 296 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 297 case OMPC_atomic_default_mem_order: 298 switch (Type) { 299 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown: 300 return "unknown"; 301 #define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \ 302 case OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name: \ 303 return #Name; 304 #include "clang/Basic/OpenMPKinds.def" 305 } 306 llvm_unreachable("Invalid OpenMP 'atomic_default_mem_order' clause type"); 307 case OMPC_device_type: 308 switch (Type) { 309 case OMPC_DEVICE_TYPE_unknown: 310 return "unknown"; 311 #define OPENMP_DEVICE_TYPE_KIND(Name) \ 312 case OMPC_DEVICE_TYPE_##Name: \ 313 return #Name; 314 #include "clang/Basic/OpenMPKinds.def" 315 } 316 llvm_unreachable("Invalid OpenMP 'device_type' clause type"); 317 case OMPC_lastprivate: 318 switch (Type) { 319 case OMPC_LASTPRIVATE_unknown: 320 return "unknown"; 321 #define OPENMP_LASTPRIVATE_KIND(Name) \ 322 case OMPC_LASTPRIVATE_##Name: \ 323 return #Name; 324 #include "clang/Basic/OpenMPKinds.def" 325 } 326 llvm_unreachable("Invalid OpenMP 'lastprivate' clause type"); 327 case OMPC_order: 328 switch (Type) { 329 case OMPC_ORDER_unknown: 330 return "unknown"; 331 #define OPENMP_ORDER_KIND(Name) \ 332 case OMPC_ORDER_##Name: \ 333 return #Name; 334 #include "clang/Basic/OpenMPKinds.def" 335 } 336 llvm_unreachable("Invalid OpenMP 'order' clause type"); 337 case OMPC_update: 338 switch (Type) { 339 case OMPC_DEPEND_unknown: 340 return "unknown"; 341 #define OPENMP_DEPEND_KIND(Name) \ 342 case OMPC_DEPEND_##Name: \ 343 return #Name; 344 #include "clang/Basic/OpenMPKinds.def" 345 } 346 llvm_unreachable("Invalid OpenMP 'depend' clause type"); 347 case OMPC_device: 348 switch (Type) { 349 case OMPC_DEVICE_unknown: 350 return "unknown"; 351 #define OPENMP_DEVICE_MODIFIER(Name) \ 352 case OMPC_DEVICE_##Name: \ 353 return #Name; 354 #include "clang/Basic/OpenMPKinds.def" 355 } 356 llvm_unreachable("Invalid OpenMP 'device' clause modifier"); 357 case OMPC_reduction: 358 switch (Type) { 359 case OMPC_REDUCTION_unknown: 360 return "unknown"; 361 #define OPENMP_REDUCTION_MODIFIER(Name) \ 362 case OMPC_REDUCTION_##Name: \ 363 return #Name; 364 #include "clang/Basic/OpenMPKinds.def" 365 } 366 llvm_unreachable("Invalid OpenMP 'reduction' clause modifier"); 367 case OMPC_unknown: 368 case OMPC_threadprivate: 369 case OMPC_if: 370 case OMPC_final: 371 case OMPC_num_threads: 372 case OMPC_safelen: 373 case OMPC_simdlen: 374 case OMPC_sizes: 375 case OMPC_allocator: 376 case OMPC_allocate: 377 case OMPC_collapse: 378 case OMPC_private: 379 case OMPC_firstprivate: 380 case OMPC_shared: 381 case OMPC_task_reduction: 382 case OMPC_in_reduction: 383 case OMPC_aligned: 384 case OMPC_copyin: 385 case OMPC_copyprivate: 386 case OMPC_ordered: 387 case OMPC_nowait: 388 case OMPC_untied: 389 case OMPC_mergeable: 390 case OMPC_flush: 391 case OMPC_depobj: 392 case OMPC_read: 393 case OMPC_write: 394 case OMPC_capture: 395 case OMPC_seq_cst: 396 case OMPC_acq_rel: 397 case OMPC_acquire: 398 case OMPC_release: 399 case OMPC_relaxed: 400 case OMPC_threads: 401 case OMPC_simd: 402 case OMPC_num_teams: 403 case OMPC_thread_limit: 404 case OMPC_priority: 405 case OMPC_grainsize: 406 case OMPC_nogroup: 407 case OMPC_num_tasks: 408 case OMPC_hint: 409 case OMPC_uniform: 410 case OMPC_use_device_ptr: 411 case OMPC_use_device_addr: 412 case OMPC_is_device_ptr: 413 case OMPC_unified_address: 414 case OMPC_unified_shared_memory: 415 case OMPC_reverse_offload: 416 case OMPC_dynamic_allocators: 417 case OMPC_match: 418 case OMPC_nontemporal: 419 case OMPC_destroy: 420 case OMPC_detach: 421 case OMPC_inclusive: 422 case OMPC_exclusive: 423 case OMPC_uses_allocators: 424 case OMPC_affinity: 425 break; 426 default: 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 || DKind == OMPD_tile; 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 bool clang::isOpenMPLoopTransformationDirective(OpenMPDirectiveKind DKind) { 579 return DKind == OMPD_tile; 580 } 581 582 void clang::getOpenMPCaptureRegions( 583 SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions, 584 OpenMPDirectiveKind DKind) { 585 assert(unsigned(DKind) < llvm::omp::Directive_enumSize); 586 switch (DKind) { 587 case OMPD_parallel: 588 case OMPD_parallel_for: 589 case OMPD_parallel_for_simd: 590 case OMPD_parallel_master: 591 case OMPD_parallel_sections: 592 case OMPD_distribute_parallel_for: 593 case OMPD_distribute_parallel_for_simd: 594 CaptureRegions.push_back(OMPD_parallel); 595 break; 596 case OMPD_target_teams: 597 case OMPD_target_teams_distribute: 598 case OMPD_target_teams_distribute_simd: 599 CaptureRegions.push_back(OMPD_task); 600 CaptureRegions.push_back(OMPD_target); 601 CaptureRegions.push_back(OMPD_teams); 602 break; 603 case OMPD_teams: 604 case OMPD_teams_distribute: 605 case OMPD_teams_distribute_simd: 606 CaptureRegions.push_back(OMPD_teams); 607 break; 608 case OMPD_target: 609 case OMPD_target_simd: 610 CaptureRegions.push_back(OMPD_task); 611 CaptureRegions.push_back(OMPD_target); 612 break; 613 case OMPD_teams_distribute_parallel_for: 614 case OMPD_teams_distribute_parallel_for_simd: 615 CaptureRegions.push_back(OMPD_teams); 616 CaptureRegions.push_back(OMPD_parallel); 617 break; 618 case OMPD_target_parallel: 619 case OMPD_target_parallel_for: 620 case OMPD_target_parallel_for_simd: 621 CaptureRegions.push_back(OMPD_task); 622 CaptureRegions.push_back(OMPD_target); 623 CaptureRegions.push_back(OMPD_parallel); 624 break; 625 case OMPD_task: 626 case OMPD_target_enter_data: 627 case OMPD_target_exit_data: 628 case OMPD_target_update: 629 CaptureRegions.push_back(OMPD_task); 630 break; 631 case OMPD_taskloop: 632 case OMPD_taskloop_simd: 633 case OMPD_master_taskloop: 634 case OMPD_master_taskloop_simd: 635 CaptureRegions.push_back(OMPD_taskloop); 636 break; 637 case OMPD_parallel_master_taskloop: 638 case OMPD_parallel_master_taskloop_simd: 639 CaptureRegions.push_back(OMPD_parallel); 640 CaptureRegions.push_back(OMPD_taskloop); 641 break; 642 case OMPD_target_teams_distribute_parallel_for: 643 case OMPD_target_teams_distribute_parallel_for_simd: 644 CaptureRegions.push_back(OMPD_task); 645 CaptureRegions.push_back(OMPD_target); 646 CaptureRegions.push_back(OMPD_teams); 647 CaptureRegions.push_back(OMPD_parallel); 648 break; 649 case OMPD_simd: 650 case OMPD_for: 651 case OMPD_for_simd: 652 case OMPD_sections: 653 case OMPD_section: 654 case OMPD_single: 655 case OMPD_master: 656 case OMPD_critical: 657 case OMPD_taskgroup: 658 case OMPD_distribute: 659 case OMPD_ordered: 660 case OMPD_atomic: 661 case OMPD_target_data: 662 case OMPD_distribute_simd: 663 CaptureRegions.push_back(OMPD_unknown); 664 break; 665 case OMPD_tile: 666 // loop transformations do not introduce captures. 667 break; 668 case OMPD_threadprivate: 669 case OMPD_allocate: 670 case OMPD_taskyield: 671 case OMPD_barrier: 672 case OMPD_taskwait: 673 case OMPD_cancellation_point: 674 case OMPD_cancel: 675 case OMPD_flush: 676 case OMPD_depobj: 677 case OMPD_scan: 678 case OMPD_declare_reduction: 679 case OMPD_declare_mapper: 680 case OMPD_declare_simd: 681 case OMPD_declare_target: 682 case OMPD_end_declare_target: 683 case OMPD_requires: 684 case OMPD_declare_variant: 685 case OMPD_begin_declare_variant: 686 case OMPD_end_declare_variant: 687 llvm_unreachable("OpenMP Directive is not allowed"); 688 case OMPD_unknown: 689 default: 690 llvm_unreachable("Unknown OpenMP directive"); 691 } 692 } 693