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