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