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_adjust_args: 129 return llvm::StringSwitch<OpenMPAdjustArgsOpKind>(Str) 130 #define OPENMP_ADJUST_ARGS_KIND(Name) .Case(#Name, OMPC_ADJUST_ARGS_##Name) 131 #include "clang/Basic/OpenMPKinds.def" 132 .Default(OMPC_ADJUST_ARGS_unknown); 133 case OMPC_unknown: 134 case OMPC_threadprivate: 135 case OMPC_if: 136 case OMPC_final: 137 case OMPC_num_threads: 138 case OMPC_safelen: 139 case OMPC_simdlen: 140 case OMPC_sizes: 141 case OMPC_allocator: 142 case OMPC_allocate: 143 case OMPC_collapse: 144 case OMPC_private: 145 case OMPC_firstprivate: 146 case OMPC_shared: 147 case OMPC_task_reduction: 148 case OMPC_in_reduction: 149 case OMPC_aligned: 150 case OMPC_copyin: 151 case OMPC_copyprivate: 152 case OMPC_ordered: 153 case OMPC_nowait: 154 case OMPC_untied: 155 case OMPC_mergeable: 156 case OMPC_flush: 157 case OMPC_depobj: 158 case OMPC_read: 159 case OMPC_write: 160 case OMPC_capture: 161 case OMPC_seq_cst: 162 case OMPC_acq_rel: 163 case OMPC_acquire: 164 case OMPC_release: 165 case OMPC_relaxed: 166 case OMPC_threads: 167 case OMPC_simd: 168 case OMPC_num_teams: 169 case OMPC_thread_limit: 170 case OMPC_priority: 171 case OMPC_grainsize: 172 case OMPC_nogroup: 173 case OMPC_num_tasks: 174 case OMPC_hint: 175 case OMPC_uniform: 176 case OMPC_use_device_ptr: 177 case OMPC_use_device_addr: 178 case OMPC_is_device_ptr: 179 case OMPC_unified_address: 180 case OMPC_unified_shared_memory: 181 case OMPC_reverse_offload: 182 case OMPC_dynamic_allocators: 183 case OMPC_match: 184 case OMPC_nontemporal: 185 case OMPC_destroy: 186 case OMPC_novariants: 187 case OMPC_nocontext: 188 case OMPC_detach: 189 case OMPC_inclusive: 190 case OMPC_exclusive: 191 case OMPC_uses_allocators: 192 case OMPC_affinity: 193 case OMPC_when: 194 case OMPC_append_args: 195 break; 196 default: 197 break; 198 } 199 llvm_unreachable("Invalid OpenMP simple clause kind"); 200 } 201 202 const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, 203 unsigned Type) { 204 switch (Kind) { 205 case OMPC_default: 206 switch (llvm::omp::DefaultKind(Type)) { 207 #define OMP_DEFAULT_KIND(Enum, Name) \ 208 case Enum: \ 209 return Name; 210 #include "llvm/Frontend/OpenMP/OMPKinds.def" 211 } 212 llvm_unreachable("Invalid OpenMP 'default' clause type"); 213 case OMPC_proc_bind: 214 switch (Type) { 215 #define OMP_PROC_BIND_KIND(Enum, Name, Value) \ 216 case Value: \ 217 return Name; 218 #include "llvm/Frontend/OpenMP/OMPKinds.def" 219 } 220 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type"); 221 case OMPC_schedule: 222 switch (Type) { 223 case OMPC_SCHEDULE_unknown: 224 case OMPC_SCHEDULE_MODIFIER_last: 225 return "unknown"; 226 #define OPENMP_SCHEDULE_KIND(Name) \ 227 case OMPC_SCHEDULE_##Name: \ 228 return #Name; 229 #define OPENMP_SCHEDULE_MODIFIER(Name) \ 230 case OMPC_SCHEDULE_MODIFIER_##Name: \ 231 return #Name; 232 #include "clang/Basic/OpenMPKinds.def" 233 } 234 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 235 case OMPC_depend: 236 switch (Type) { 237 case OMPC_DEPEND_unknown: 238 return "unknown"; 239 #define OPENMP_DEPEND_KIND(Name) \ 240 case OMPC_DEPEND_##Name: \ 241 return #Name; 242 #include "clang/Basic/OpenMPKinds.def" 243 } 244 llvm_unreachable("Invalid OpenMP 'depend' clause type"); 245 case OMPC_linear: 246 switch (Type) { 247 case OMPC_LINEAR_unknown: 248 return "unknown"; 249 #define OPENMP_LINEAR_KIND(Name) \ 250 case OMPC_LINEAR_##Name: \ 251 return #Name; 252 #include "clang/Basic/OpenMPKinds.def" 253 } 254 llvm_unreachable("Invalid OpenMP 'linear' clause type"); 255 case OMPC_map: 256 switch (Type) { 257 case OMPC_MAP_unknown: 258 case OMPC_MAP_MODIFIER_last: 259 return "unknown"; 260 #define OPENMP_MAP_KIND(Name) \ 261 case OMPC_MAP_##Name: \ 262 return #Name; 263 #define OPENMP_MAP_MODIFIER_KIND(Name) \ 264 case OMPC_MAP_MODIFIER_##Name: \ 265 return #Name; 266 #include "clang/Basic/OpenMPKinds.def" 267 default: 268 break; 269 } 270 llvm_unreachable("Invalid OpenMP 'map' clause type"); 271 case OMPC_to: 272 case OMPC_from: 273 switch (Type) { 274 case OMPC_MOTION_MODIFIER_unknown: 275 return "unknown"; 276 #define OPENMP_MOTION_MODIFIER_KIND(Name) \ 277 case OMPC_MOTION_MODIFIER_##Name: \ 278 return #Name; 279 #include "clang/Basic/OpenMPKinds.def" 280 default: 281 break; 282 } 283 llvm_unreachable("Invalid OpenMP 'to' or '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_adjust_args: 379 switch (Type) { 380 case OMPC_ADJUST_ARGS_unknown: 381 return "unknown"; 382 #define OPENMP_ADJUST_ARGS_KIND(Name) \ 383 case OMPC_ADJUST_ARGS_##Name: \ 384 return #Name; 385 #include "clang/Basic/OpenMPKinds.def" 386 } 387 llvm_unreachable("Invalid OpenMP 'adjust_args' clause kind"); 388 case OMPC_unknown: 389 case OMPC_threadprivate: 390 case OMPC_if: 391 case OMPC_final: 392 case OMPC_num_threads: 393 case OMPC_safelen: 394 case OMPC_simdlen: 395 case OMPC_sizes: 396 case OMPC_allocator: 397 case OMPC_allocate: 398 case OMPC_collapse: 399 case OMPC_private: 400 case OMPC_firstprivate: 401 case OMPC_shared: 402 case OMPC_task_reduction: 403 case OMPC_in_reduction: 404 case OMPC_aligned: 405 case OMPC_copyin: 406 case OMPC_copyprivate: 407 case OMPC_ordered: 408 case OMPC_nowait: 409 case OMPC_untied: 410 case OMPC_mergeable: 411 case OMPC_flush: 412 case OMPC_depobj: 413 case OMPC_read: 414 case OMPC_write: 415 case OMPC_capture: 416 case OMPC_seq_cst: 417 case OMPC_acq_rel: 418 case OMPC_acquire: 419 case OMPC_release: 420 case OMPC_relaxed: 421 case OMPC_threads: 422 case OMPC_simd: 423 case OMPC_num_teams: 424 case OMPC_thread_limit: 425 case OMPC_priority: 426 case OMPC_grainsize: 427 case OMPC_nogroup: 428 case OMPC_num_tasks: 429 case OMPC_hint: 430 case OMPC_uniform: 431 case OMPC_use_device_ptr: 432 case OMPC_use_device_addr: 433 case OMPC_is_device_ptr: 434 case OMPC_unified_address: 435 case OMPC_unified_shared_memory: 436 case OMPC_reverse_offload: 437 case OMPC_dynamic_allocators: 438 case OMPC_match: 439 case OMPC_nontemporal: 440 case OMPC_destroy: 441 case OMPC_detach: 442 case OMPC_novariants: 443 case OMPC_nocontext: 444 case OMPC_inclusive: 445 case OMPC_exclusive: 446 case OMPC_uses_allocators: 447 case OMPC_affinity: 448 case OMPC_when: 449 case OMPC_append_args: 450 break; 451 default: 452 break; 453 } 454 llvm_unreachable("Invalid OpenMP simple clause kind"); 455 } 456 457 bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) { 458 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd || 459 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd || 460 DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 461 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 462 DKind == OMPD_parallel_master_taskloop || 463 DKind == OMPD_parallel_master_taskloop_simd || 464 DKind == OMPD_distribute || DKind == OMPD_target_parallel_for || 465 DKind == OMPD_distribute_parallel_for || 466 DKind == OMPD_distribute_parallel_for_simd || 467 DKind == OMPD_distribute_simd || 468 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 469 DKind == OMPD_teams_distribute || 470 DKind == OMPD_teams_distribute_simd || 471 DKind == OMPD_teams_distribute_parallel_for_simd || 472 DKind == OMPD_teams_distribute_parallel_for || 473 DKind == OMPD_target_teams_distribute || 474 DKind == OMPD_target_teams_distribute_parallel_for || 475 DKind == OMPD_target_teams_distribute_parallel_for_simd || 476 DKind == OMPD_target_teams_distribute_simd || DKind == OMPD_tile || 477 DKind == OMPD_unroll || DKind == OMPD_loop; 478 } 479 480 bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { 481 return DKind == OMPD_for || DKind == OMPD_for_simd || 482 DKind == OMPD_sections || DKind == OMPD_section || 483 DKind == OMPD_single || DKind == OMPD_parallel_for || 484 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 485 DKind == OMPD_target_parallel_for || 486 DKind == OMPD_distribute_parallel_for || 487 DKind == OMPD_distribute_parallel_for_simd || 488 DKind == OMPD_target_parallel_for_simd || 489 DKind == OMPD_teams_distribute_parallel_for_simd || 490 DKind == OMPD_teams_distribute_parallel_for || 491 DKind == OMPD_target_teams_distribute_parallel_for || 492 DKind == OMPD_target_teams_distribute_parallel_for_simd; 493 } 494 495 bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) { 496 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 497 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 498 DKind == OMPD_parallel_master_taskloop || 499 DKind == OMPD_parallel_master_taskloop_simd; 500 } 501 502 bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) { 503 return DKind == OMPD_parallel || DKind == OMPD_parallel_for || 504 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 505 DKind == OMPD_target_parallel || DKind == OMPD_target_parallel_for || 506 DKind == OMPD_distribute_parallel_for || 507 DKind == OMPD_distribute_parallel_for_simd || 508 DKind == OMPD_target_parallel_for_simd || 509 DKind == OMPD_teams_distribute_parallel_for || 510 DKind == OMPD_teams_distribute_parallel_for_simd || 511 DKind == OMPD_target_teams_distribute_parallel_for || 512 DKind == OMPD_target_teams_distribute_parallel_for_simd || 513 DKind == OMPD_parallel_master || 514 DKind == OMPD_parallel_master_taskloop || 515 DKind == OMPD_parallel_master_taskloop_simd; 516 } 517 518 bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) { 519 return DKind == OMPD_target || DKind == OMPD_target_parallel || 520 DKind == OMPD_target_parallel_for || 521 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 522 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 523 DKind == OMPD_target_teams_distribute_parallel_for || 524 DKind == OMPD_target_teams_distribute_parallel_for_simd || 525 DKind == OMPD_target_teams_distribute_simd; 526 } 527 528 bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) { 529 return DKind == OMPD_target_data || DKind == OMPD_target_enter_data || 530 DKind == OMPD_target_exit_data || DKind == OMPD_target_update; 531 } 532 533 bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) { 534 return DKind == OMPD_teams || DKind == OMPD_teams_distribute || 535 DKind == OMPD_teams_distribute_simd || 536 DKind == OMPD_teams_distribute_parallel_for_simd || 537 DKind == OMPD_teams_distribute_parallel_for; 538 } 539 540 bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) { 541 return isOpenMPNestingTeamsDirective(DKind) || 542 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 543 DKind == OMPD_target_teams_distribute_parallel_for || 544 DKind == OMPD_target_teams_distribute_parallel_for_simd || 545 DKind == OMPD_target_teams_distribute_simd; 546 } 547 548 bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) { 549 return DKind == OMPD_simd || DKind == OMPD_for_simd || 550 DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd || 551 DKind == OMPD_master_taskloop_simd || 552 DKind == OMPD_parallel_master_taskloop_simd || 553 DKind == OMPD_distribute_parallel_for_simd || 554 DKind == OMPD_distribute_simd || DKind == OMPD_target_simd || 555 DKind == OMPD_teams_distribute_simd || 556 DKind == OMPD_teams_distribute_parallel_for_simd || 557 DKind == OMPD_target_teams_distribute_parallel_for_simd || 558 DKind == OMPD_target_teams_distribute_simd || 559 DKind == OMPD_target_parallel_for_simd; 560 } 561 562 bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) { 563 return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for || 564 Kind == OMPD_distribute_parallel_for_simd || 565 Kind == OMPD_distribute_simd; 566 // TODO add next directives. 567 } 568 569 bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) { 570 return isOpenMPNestingDistributeDirective(Kind) || 571 Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd || 572 Kind == OMPD_teams_distribute_parallel_for_simd || 573 Kind == OMPD_teams_distribute_parallel_for || 574 Kind == OMPD_target_teams_distribute || 575 Kind == OMPD_target_teams_distribute_parallel_for || 576 Kind == OMPD_target_teams_distribute_parallel_for_simd || 577 Kind == OMPD_target_teams_distribute_simd; 578 } 579 580 bool clang::isOpenMPGenericLoopDirective(OpenMPDirectiveKind Kind) { 581 return Kind == OMPD_loop; 582 } 583 584 bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) { 585 return Kind == OMPC_private || Kind == OMPC_firstprivate || 586 Kind == OMPC_lastprivate || Kind == OMPC_linear || 587 Kind == OMPC_reduction || Kind == OMPC_task_reduction || 588 Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'. 589 } 590 591 bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) { 592 return Kind == OMPC_threadprivate || Kind == OMPC_copyin; 593 } 594 595 bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) { 596 return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind); 597 } 598 599 bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) { 600 return Kind == OMPD_distribute_parallel_for || 601 Kind == OMPD_distribute_parallel_for_simd || 602 Kind == OMPD_teams_distribute_parallel_for_simd || 603 Kind == OMPD_teams_distribute_parallel_for || 604 Kind == OMPD_target_teams_distribute_parallel_for || 605 Kind == OMPD_target_teams_distribute_parallel_for_simd; 606 } 607 608 bool clang::isOpenMPLoopTransformationDirective(OpenMPDirectiveKind DKind) { 609 return DKind == OMPD_tile || DKind == OMPD_unroll; 610 } 611 612 void clang::getOpenMPCaptureRegions( 613 SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions, 614 OpenMPDirectiveKind DKind) { 615 assert(unsigned(DKind) < llvm::omp::Directive_enumSize); 616 switch (DKind) { 617 case OMPD_metadirective: 618 CaptureRegions.push_back(OMPD_metadirective); 619 break; 620 case OMPD_parallel: 621 case OMPD_parallel_for: 622 case OMPD_parallel_for_simd: 623 case OMPD_parallel_master: 624 case OMPD_parallel_sections: 625 case OMPD_distribute_parallel_for: 626 case OMPD_distribute_parallel_for_simd: 627 CaptureRegions.push_back(OMPD_parallel); 628 break; 629 case OMPD_target_teams: 630 case OMPD_target_teams_distribute: 631 case OMPD_target_teams_distribute_simd: 632 CaptureRegions.push_back(OMPD_task); 633 CaptureRegions.push_back(OMPD_target); 634 CaptureRegions.push_back(OMPD_teams); 635 break; 636 case OMPD_teams: 637 case OMPD_teams_distribute: 638 case OMPD_teams_distribute_simd: 639 CaptureRegions.push_back(OMPD_teams); 640 break; 641 case OMPD_target: 642 case OMPD_target_simd: 643 CaptureRegions.push_back(OMPD_task); 644 CaptureRegions.push_back(OMPD_target); 645 break; 646 case OMPD_teams_distribute_parallel_for: 647 case OMPD_teams_distribute_parallel_for_simd: 648 CaptureRegions.push_back(OMPD_teams); 649 CaptureRegions.push_back(OMPD_parallel); 650 break; 651 case OMPD_target_parallel: 652 case OMPD_target_parallel_for: 653 case OMPD_target_parallel_for_simd: 654 CaptureRegions.push_back(OMPD_task); 655 CaptureRegions.push_back(OMPD_target); 656 CaptureRegions.push_back(OMPD_parallel); 657 break; 658 case OMPD_task: 659 case OMPD_target_enter_data: 660 case OMPD_target_exit_data: 661 case OMPD_target_update: 662 CaptureRegions.push_back(OMPD_task); 663 break; 664 case OMPD_taskloop: 665 case OMPD_taskloop_simd: 666 case OMPD_master_taskloop: 667 case OMPD_master_taskloop_simd: 668 CaptureRegions.push_back(OMPD_taskloop); 669 break; 670 case OMPD_parallel_master_taskloop: 671 case OMPD_parallel_master_taskloop_simd: 672 CaptureRegions.push_back(OMPD_parallel); 673 CaptureRegions.push_back(OMPD_taskloop); 674 break; 675 case OMPD_target_teams_distribute_parallel_for: 676 case OMPD_target_teams_distribute_parallel_for_simd: 677 CaptureRegions.push_back(OMPD_task); 678 CaptureRegions.push_back(OMPD_target); 679 CaptureRegions.push_back(OMPD_teams); 680 CaptureRegions.push_back(OMPD_parallel); 681 break; 682 case OMPD_loop: 683 // TODO: 'loop' may require different capture regions depending on the bind 684 // clause or the parent directive when there is no bind clause. Use 685 // OMPD_unknown for now. 686 case OMPD_simd: 687 case OMPD_for: 688 case OMPD_for_simd: 689 case OMPD_sections: 690 case OMPD_section: 691 case OMPD_single: 692 case OMPD_master: 693 case OMPD_critical: 694 case OMPD_taskgroup: 695 case OMPD_distribute: 696 case OMPD_ordered: 697 case OMPD_atomic: 698 case OMPD_target_data: 699 case OMPD_distribute_simd: 700 case OMPD_dispatch: 701 CaptureRegions.push_back(OMPD_unknown); 702 break; 703 case OMPD_tile: 704 case OMPD_unroll: 705 // loop transformations do not introduce captures. 706 break; 707 case OMPD_threadprivate: 708 case OMPD_allocate: 709 case OMPD_taskyield: 710 case OMPD_barrier: 711 case OMPD_taskwait: 712 case OMPD_cancellation_point: 713 case OMPD_cancel: 714 case OMPD_flush: 715 case OMPD_depobj: 716 case OMPD_scan: 717 case OMPD_declare_reduction: 718 case OMPD_declare_mapper: 719 case OMPD_declare_simd: 720 case OMPD_declare_target: 721 case OMPD_end_declare_target: 722 case OMPD_requires: 723 case OMPD_declare_variant: 724 case OMPD_begin_declare_variant: 725 case OMPD_end_declare_variant: 726 llvm_unreachable("OpenMP Directive is not allowed"); 727 case OMPD_unknown: 728 default: 729 llvm_unreachable("Unknown OpenMP directive"); 730 } 731 } 732