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 20using namespace clang; 21using namespace llvm::omp; 22 23unsigned clang::getOpenMPSimpleClauseType(OpenMPClauseKind Kind, StringRef Str, 24 unsigned OpenMPVersion) { 25 switch (Kind) { 26 case OMPC_default: 27 return llvm::StringSwitch<unsigned>(Str) 28#define OMP_DEFAULT_KIND(Enum, Name) .Case(Name, unsigned(Enum)) 29#include "llvm/Frontend/OpenMP/OMPKinds.def" 30 .Default(unsigned(llvm::omp::OMP_DEFAULT_unknown)); 31 case OMPC_proc_bind: 32 return llvm::StringSwitch<unsigned>(Str) 33#define OMP_PROC_BIND_KIND(Enum, Name, Value) .Case(Name, Value) 34#include "llvm/Frontend/OpenMP/OMPKinds.def" 35 .Default(unsigned(llvm::omp::OMP_PROC_BIND_unknown)); 36 case OMPC_schedule: 37 return llvm::StringSwitch<unsigned>(Str) 38#define OPENMP_SCHEDULE_KIND(Name) \ 39 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_##Name)) 40#define OPENMP_SCHEDULE_MODIFIER(Name) \ 41 .Case(#Name, static_cast<unsigned>(OMPC_SCHEDULE_MODIFIER_##Name)) 42#include "clang/Basic/OpenMPKinds.def" 43 .Default(OMPC_SCHEDULE_unknown); 44 case OMPC_depend: 45 return llvm::StringSwitch<OpenMPDependClauseKind>(Str) 46#define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name) 47#include "clang/Basic/OpenMPKinds.def" 48 .Default(OMPC_DEPEND_unknown); 49 case OMPC_linear: 50 return llvm::StringSwitch<OpenMPLinearClauseKind>(Str) 51#define OPENMP_LINEAR_KIND(Name) .Case(#Name, OMPC_LINEAR_##Name) 52#include "clang/Basic/OpenMPKinds.def" 53 .Default(OMPC_LINEAR_unknown); 54 case OMPC_map: { 55 unsigned Type = llvm::StringSwitch<unsigned>(Str) 56#define OPENMP_MAP_KIND(Name) \ 57 .Case(#Name, static_cast<unsigned>(OMPC_MAP_##Name)) 58#define OPENMP_MAP_MODIFIER_KIND(Name) \ 59 .Case(#Name, static_cast<unsigned>(OMPC_MAP_MODIFIER_##Name)) 60#include "clang/Basic/OpenMPKinds.def" 61 .Default(OMPC_MAP_unknown); 62 if (OpenMPVersion < 51 && Type == OMPC_MAP_MODIFIER_present) 63 return OMPC_MAP_MODIFIER_unknown; 64 return Type; 65 } 66 case OMPC_to: 67 case OMPC_from: { 68 unsigned Type = llvm::StringSwitch<unsigned>(Str) 69#define OPENMP_MOTION_MODIFIER_KIND(Name) \ 70 .Case(#Name, static_cast<unsigned>(OMPC_MOTION_MODIFIER_##Name)) 71#include "clang/Basic/OpenMPKinds.def" 72 .Default(OMPC_MOTION_MODIFIER_unknown); 73 if (OpenMPVersion < 51 && Type == OMPC_MOTION_MODIFIER_present) 74 return OMPC_MOTION_MODIFIER_unknown; 75 return Type; 76 } 77 case OMPC_dist_schedule: 78 return llvm::StringSwitch<OpenMPDistScheduleClauseKind>(Str) 79#define OPENMP_DIST_SCHEDULE_KIND(Name) .Case(#Name, OMPC_DIST_SCHEDULE_##Name) 80#include "clang/Basic/OpenMPKinds.def" 81 .Default(OMPC_DIST_SCHEDULE_unknown); 82 case OMPC_defaultmap: 83 return llvm::StringSwitch<unsigned>(Str) 84#define OPENMP_DEFAULTMAP_KIND(Name) \ 85 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_##Name)) 86#define OPENMP_DEFAULTMAP_MODIFIER(Name) \ 87 .Case(#Name, static_cast<unsigned>(OMPC_DEFAULTMAP_MODIFIER_##Name)) 88#include "clang/Basic/OpenMPKinds.def" 89 .Default(OMPC_DEFAULTMAP_unknown); 90 case OMPC_atomic_default_mem_order: 91 return llvm::StringSwitch<OpenMPAtomicDefaultMemOrderClauseKind>(Str) 92#define OPENMP_ATOMIC_DEFAULT_MEM_ORDER_KIND(Name) \ 93 .Case(#Name, OMPC_ATOMIC_DEFAULT_MEM_ORDER_##Name) 94#include "clang/Basic/OpenMPKinds.def" 95 .Default(OMPC_ATOMIC_DEFAULT_MEM_ORDER_unknown); 96 case OMPC_device_type: 97 return llvm::StringSwitch<OpenMPDeviceType>(Str) 98#define OPENMP_DEVICE_TYPE_KIND(Name) .Case(#Name, OMPC_DEVICE_TYPE_##Name) 99#include "clang/Basic/OpenMPKinds.def" 100 .Default(OMPC_DEVICE_TYPE_unknown); 101 case OMPC_lastprivate: 102 return llvm::StringSwitch<OpenMPLastprivateModifier>(Str) 103#define OPENMP_LASTPRIVATE_KIND(Name) .Case(#Name, OMPC_LASTPRIVATE_##Name) 104#include "clang/Basic/OpenMPKinds.def" 105 .Default(OMPC_LASTPRIVATE_unknown); 106 case OMPC_order: 107 return llvm::StringSwitch<OpenMPOrderClauseKind>(Str) 108#define OPENMP_ORDER_KIND(Name) .Case(#Name, OMPC_ORDER_##Name) 109#include "clang/Basic/OpenMPKinds.def" 110 .Default(OMPC_ORDER_unknown); 111 case OMPC_update: 112 return llvm::StringSwitch<OpenMPDependClauseKind>(Str) 113#define OPENMP_DEPEND_KIND(Name) .Case(#Name, OMPC_DEPEND_##Name) 114#include "clang/Basic/OpenMPKinds.def" 115 .Default(OMPC_DEPEND_unknown); 116 case OMPC_device: 117 return llvm::StringSwitch<OpenMPDeviceClauseModifier>(Str) 118#define OPENMP_DEVICE_MODIFIER(Name) .Case(#Name, OMPC_DEVICE_##Name) 119#include "clang/Basic/OpenMPKinds.def" 120 .Default(OMPC_DEVICE_unknown); 121 case OMPC_reduction: 122 return llvm::StringSwitch<OpenMPReductionClauseModifier>(Str) 123#define OPENMP_REDUCTION_MODIFIER(Name) .Case(#Name, OMPC_REDUCTION_##Name) 124#include "clang/Basic/OpenMPKinds.def" 125 .Default(OMPC_REDUCTION_unknown); 126 case OMPC_unknown: 127 case OMPC_threadprivate: 128 case OMPC_if: 129 case OMPC_final: 130 case OMPC_num_threads: 131 case OMPC_safelen: 132 case OMPC_simdlen: 133 case OMPC_sizes: 134 case OMPC_allocator: 135 case OMPC_allocate: 136 case OMPC_collapse: 137 case OMPC_private: 138 case OMPC_firstprivate: 139 case OMPC_shared: 140 case OMPC_task_reduction: 141 case OMPC_in_reduction: 142 case OMPC_aligned: 143 case OMPC_copyin: 144 case OMPC_copyprivate: 145 case OMPC_ordered: 146 case OMPC_nowait: 147 case OMPC_untied: 148 case OMPC_mergeable: 149 case OMPC_flush: 150 case OMPC_depobj: 151 case OMPC_read: 152 case OMPC_write: 153 case OMPC_capture: 154 case OMPC_seq_cst: 155 case OMPC_acq_rel: 156 case OMPC_acquire: 157 case OMPC_release: 158 case OMPC_relaxed: 159 case OMPC_threads: 160 case OMPC_simd: 161 case OMPC_num_teams: 162 case OMPC_thread_limit: 163 case OMPC_priority: 164 case OMPC_grainsize: 165 case OMPC_nogroup: 166 case OMPC_num_tasks: 167 case OMPC_hint: 168 case OMPC_uniform: 169 case OMPC_use_device_ptr: 170 case OMPC_use_device_addr: 171 case OMPC_is_device_ptr: 172 case OMPC_unified_address: 173 case OMPC_unified_shared_memory: 174 case OMPC_reverse_offload: 175 case OMPC_dynamic_allocators: 176 case OMPC_match: 177 case OMPC_nontemporal: 178 case OMPC_destroy: 179 case OMPC_novariants: 180 case OMPC_nocontext: 181 case OMPC_detach: 182 case OMPC_inclusive: 183 case OMPC_exclusive: 184 case OMPC_uses_allocators: 185 case OMPC_affinity: 186 break; 187 default: 188 break; 189 } 190 llvm_unreachable("Invalid OpenMP simple clause kind"); 191} 192 193const char *clang::getOpenMPSimpleClauseTypeName(OpenMPClauseKind Kind, 194 unsigned Type) { 195 switch (Kind) { 196 case OMPC_default: 197 switch (llvm::omp::DefaultKind(Type)) { 198#define OMP_DEFAULT_KIND(Enum, Name) \ 199 case Enum: \ 200 return Name; 201#include "llvm/Frontend/OpenMP/OMPKinds.def" 202 } 203 llvm_unreachable("Invalid OpenMP 'default' clause type"); 204 case OMPC_proc_bind: 205 switch (Type) { 206#define OMP_PROC_BIND_KIND(Enum, Name, Value) \ 207 case Value: \ 208 return Name; 209#include "llvm/Frontend/OpenMP/OMPKinds.def" 210 } 211 llvm_unreachable("Invalid OpenMP 'proc_bind' clause type"); 212 case OMPC_schedule: 213 switch (Type) { 214 case OMPC_SCHEDULE_unknown: 215 case OMPC_SCHEDULE_MODIFIER_last: 216 return "unknown"; 217#define OPENMP_SCHEDULE_KIND(Name) \ 218 case OMPC_SCHEDULE_##Name: \ 219 return #Name; 220#define OPENMP_SCHEDULE_MODIFIER(Name) \ 221 case OMPC_SCHEDULE_MODIFIER_##Name: \ 222 return #Name; 223#include "clang/Basic/OpenMPKinds.def" 224 } 225 llvm_unreachable("Invalid OpenMP 'schedule' clause type"); 226 case OMPC_depend: 227 switch (Type) { 228 case OMPC_DEPEND_unknown: 229 return "unknown"; 230#define OPENMP_DEPEND_KIND(Name) \ 231 case OMPC_DEPEND_##Name: \ 232 return #Name; 233#include "clang/Basic/OpenMPKinds.def" 234 } 235 llvm_unreachable("Invalid OpenMP 'depend' clause type"); 236 case OMPC_linear: 237 switch (Type) { 238 case OMPC_LINEAR_unknown: 239 return "unknown"; 240#define OPENMP_LINEAR_KIND(Name) \ 241 case OMPC_LINEAR_##Name: \ 242 return #Name; 243#include "clang/Basic/OpenMPKinds.def" 244 } 245 llvm_unreachable("Invalid OpenMP 'linear' clause type"); 246 case OMPC_map: 247 switch (Type) { 248 case OMPC_MAP_unknown: 249 case OMPC_MAP_MODIFIER_last: 250 return "unknown"; 251#define OPENMP_MAP_KIND(Name) \ 252 case OMPC_MAP_##Name: \ 253 return #Name; 254#define OPENMP_MAP_MODIFIER_KIND(Name) \ 255 case OMPC_MAP_MODIFIER_##Name: \ 256 return #Name; 257#include "clang/Basic/OpenMPKinds.def" 258 default: 259 break; 260 } 261 llvm_unreachable("Invalid OpenMP 'map' clause type"); 262 case OMPC_to: 263 case OMPC_from: 264 switch (Type) { 265 case OMPC_MOTION_MODIFIER_unknown: 266 return "unknown"; 267#define OPENMP_MOTION_MODIFIER_KIND(Name) \ 268 case OMPC_MOTION_MODIFIER_##Name: \ 269 return #Name; 270#include "clang/Basic/OpenMPKinds.def" 271 default: 272 break; 273 } 274 llvm_unreachable("Invalid OpenMP 'to' or '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_sizes: 377 case OMPC_allocator: 378 case OMPC_allocate: 379 case OMPC_collapse: 380 case OMPC_private: 381 case OMPC_firstprivate: 382 case OMPC_shared: 383 case OMPC_task_reduction: 384 case OMPC_in_reduction: 385 case OMPC_aligned: 386 case OMPC_copyin: 387 case OMPC_copyprivate: 388 case OMPC_ordered: 389 case OMPC_nowait: 390 case OMPC_untied: 391 case OMPC_mergeable: 392 case OMPC_flush: 393 case OMPC_depobj: 394 case OMPC_read: 395 case OMPC_write: 396 case OMPC_capture: 397 case OMPC_seq_cst: 398 case OMPC_acq_rel: 399 case OMPC_acquire: 400 case OMPC_release: 401 case OMPC_relaxed: 402 case OMPC_threads: 403 case OMPC_simd: 404 case OMPC_num_teams: 405 case OMPC_thread_limit: 406 case OMPC_priority: 407 case OMPC_grainsize: 408 case OMPC_nogroup: 409 case OMPC_num_tasks: 410 case OMPC_hint: 411 case OMPC_uniform: 412 case OMPC_use_device_ptr: 413 case OMPC_use_device_addr: 414 case OMPC_is_device_ptr: 415 case OMPC_unified_address: 416 case OMPC_unified_shared_memory: 417 case OMPC_reverse_offload: 418 case OMPC_dynamic_allocators: 419 case OMPC_match: 420 case OMPC_nontemporal: 421 case OMPC_destroy: 422 case OMPC_detach: 423 case OMPC_novariants: 424 case OMPC_nocontext: 425 case OMPC_inclusive: 426 case OMPC_exclusive: 427 case OMPC_uses_allocators: 428 case OMPC_affinity: 429 break; 430 default: 431 break; 432 } 433 llvm_unreachable("Invalid OpenMP simple clause kind"); 434} 435 436bool clang::isOpenMPLoopDirective(OpenMPDirectiveKind DKind) { 437 return DKind == OMPD_simd || DKind == OMPD_for || DKind == OMPD_for_simd || 438 DKind == OMPD_parallel_for || DKind == OMPD_parallel_for_simd || 439 DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 440 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 441 DKind == OMPD_parallel_master_taskloop || 442 DKind == OMPD_parallel_master_taskloop_simd || 443 DKind == OMPD_distribute || DKind == OMPD_target_parallel_for || 444 DKind == OMPD_distribute_parallel_for || 445 DKind == OMPD_distribute_parallel_for_simd || 446 DKind == OMPD_distribute_simd || 447 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 448 DKind == OMPD_teams_distribute || 449 DKind == OMPD_teams_distribute_simd || 450 DKind == OMPD_teams_distribute_parallel_for_simd || 451 DKind == OMPD_teams_distribute_parallel_for || 452 DKind == OMPD_target_teams_distribute || 453 DKind == OMPD_target_teams_distribute_parallel_for || 454 DKind == OMPD_target_teams_distribute_parallel_for_simd || 455 DKind == OMPD_target_teams_distribute_simd || DKind == OMPD_tile; 456} 457 458bool clang::isOpenMPWorksharingDirective(OpenMPDirectiveKind DKind) { 459 return DKind == OMPD_for || DKind == OMPD_for_simd || 460 DKind == OMPD_sections || DKind == OMPD_section || 461 DKind == OMPD_single || DKind == OMPD_parallel_for || 462 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 463 DKind == OMPD_target_parallel_for || 464 DKind == OMPD_distribute_parallel_for || 465 DKind == OMPD_distribute_parallel_for_simd || 466 DKind == OMPD_target_parallel_for_simd || 467 DKind == OMPD_teams_distribute_parallel_for_simd || 468 DKind == OMPD_teams_distribute_parallel_for || 469 DKind == OMPD_target_teams_distribute_parallel_for || 470 DKind == OMPD_target_teams_distribute_parallel_for_simd; 471} 472 473bool clang::isOpenMPTaskLoopDirective(OpenMPDirectiveKind DKind) { 474 return DKind == OMPD_taskloop || DKind == OMPD_taskloop_simd || 475 DKind == OMPD_master_taskloop || DKind == OMPD_master_taskloop_simd || 476 DKind == OMPD_parallel_master_taskloop || 477 DKind == OMPD_parallel_master_taskloop_simd; 478} 479 480bool clang::isOpenMPParallelDirective(OpenMPDirectiveKind DKind) { 481 return DKind == OMPD_parallel || DKind == OMPD_parallel_for || 482 DKind == OMPD_parallel_for_simd || DKind == OMPD_parallel_sections || 483 DKind == OMPD_target_parallel || 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 || 488 DKind == OMPD_teams_distribute_parallel_for_simd || 489 DKind == OMPD_target_teams_distribute_parallel_for || 490 DKind == OMPD_target_teams_distribute_parallel_for_simd || 491 DKind == OMPD_parallel_master || 492 DKind == OMPD_parallel_master_taskloop || 493 DKind == OMPD_parallel_master_taskloop_simd; 494} 495 496bool clang::isOpenMPTargetExecutionDirective(OpenMPDirectiveKind DKind) { 497 return DKind == OMPD_target || DKind == OMPD_target_parallel || 498 DKind == OMPD_target_parallel_for || 499 DKind == OMPD_target_parallel_for_simd || DKind == OMPD_target_simd || 500 DKind == OMPD_target_teams || DKind == OMPD_target_teams_distribute || 501 DKind == OMPD_target_teams_distribute_parallel_for || 502 DKind == OMPD_target_teams_distribute_parallel_for_simd || 503 DKind == OMPD_target_teams_distribute_simd; 504} 505 506bool clang::isOpenMPTargetDataManagementDirective(OpenMPDirectiveKind DKind) { 507 return DKind == OMPD_target_data || DKind == OMPD_target_enter_data || 508 DKind == OMPD_target_exit_data || DKind == OMPD_target_update; 509} 510 511bool clang::isOpenMPNestingTeamsDirective(OpenMPDirectiveKind DKind) { 512 return DKind == OMPD_teams || DKind == OMPD_teams_distribute || 513 DKind == OMPD_teams_distribute_simd || 514 DKind == OMPD_teams_distribute_parallel_for_simd || 515 DKind == OMPD_teams_distribute_parallel_for; 516} 517 518bool clang::isOpenMPTeamsDirective(OpenMPDirectiveKind DKind) { 519 return isOpenMPNestingTeamsDirective(DKind) || 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 526bool clang::isOpenMPSimdDirective(OpenMPDirectiveKind DKind) { 527 return DKind == OMPD_simd || DKind == OMPD_for_simd || 528 DKind == OMPD_parallel_for_simd || DKind == OMPD_taskloop_simd || 529 DKind == OMPD_master_taskloop_simd || 530 DKind == OMPD_parallel_master_taskloop_simd || 531 DKind == OMPD_distribute_parallel_for_simd || 532 DKind == OMPD_distribute_simd || DKind == OMPD_target_simd || 533 DKind == OMPD_teams_distribute_simd || 534 DKind == OMPD_teams_distribute_parallel_for_simd || 535 DKind == OMPD_target_teams_distribute_parallel_for_simd || 536 DKind == OMPD_target_teams_distribute_simd || 537 DKind == OMPD_target_parallel_for_simd; 538} 539 540bool clang::isOpenMPNestingDistributeDirective(OpenMPDirectiveKind Kind) { 541 return Kind == OMPD_distribute || Kind == OMPD_distribute_parallel_for || 542 Kind == OMPD_distribute_parallel_for_simd || 543 Kind == OMPD_distribute_simd; 544 // TODO add next directives. 545} 546 547bool clang::isOpenMPDistributeDirective(OpenMPDirectiveKind Kind) { 548 return isOpenMPNestingDistributeDirective(Kind) || 549 Kind == OMPD_teams_distribute || Kind == OMPD_teams_distribute_simd || 550 Kind == OMPD_teams_distribute_parallel_for_simd || 551 Kind == OMPD_teams_distribute_parallel_for || 552 Kind == OMPD_target_teams_distribute || 553 Kind == OMPD_target_teams_distribute_parallel_for || 554 Kind == OMPD_target_teams_distribute_parallel_for_simd || 555 Kind == OMPD_target_teams_distribute_simd; 556} 557 558bool clang::isOpenMPPrivate(OpenMPClauseKind Kind) { 559 return Kind == OMPC_private || Kind == OMPC_firstprivate || 560 Kind == OMPC_lastprivate || Kind == OMPC_linear || 561 Kind == OMPC_reduction || Kind == OMPC_task_reduction || 562 Kind == OMPC_in_reduction; // TODO add next clauses like 'reduction'. 563} 564 565bool clang::isOpenMPThreadPrivate(OpenMPClauseKind Kind) { 566 return Kind == OMPC_threadprivate || Kind == OMPC_copyin; 567} 568 569bool clang::isOpenMPTaskingDirective(OpenMPDirectiveKind Kind) { 570 return Kind == OMPD_task || isOpenMPTaskLoopDirective(Kind); 571} 572 573bool clang::isOpenMPLoopBoundSharingDirective(OpenMPDirectiveKind Kind) { 574 return Kind == OMPD_distribute_parallel_for || 575 Kind == OMPD_distribute_parallel_for_simd || 576 Kind == OMPD_teams_distribute_parallel_for_simd || 577 Kind == OMPD_teams_distribute_parallel_for || 578 Kind == OMPD_target_teams_distribute_parallel_for || 579 Kind == OMPD_target_teams_distribute_parallel_for_simd; 580} 581 582bool clang::isOpenMPLoopTransformationDirective(OpenMPDirectiveKind DKind) { 583 return DKind == OMPD_tile; 584} 585 586void clang::getOpenMPCaptureRegions( 587 SmallVectorImpl<OpenMPDirectiveKind> &CaptureRegions, 588 OpenMPDirectiveKind DKind) { 589 assert(unsigned(DKind) < llvm::omp::Directive_enumSize); 590 switch (DKind) { 591 case OMPD_parallel: 592 case OMPD_parallel_for: 593 case OMPD_parallel_for_simd: 594 case OMPD_parallel_master: 595 case OMPD_parallel_sections: 596 case OMPD_distribute_parallel_for: 597 case OMPD_distribute_parallel_for_simd: 598 CaptureRegions.push_back(OMPD_parallel); 599 break; 600 case OMPD_target_teams: 601 case OMPD_target_teams_distribute: 602 case OMPD_target_teams_distribute_simd: 603 CaptureRegions.push_back(OMPD_task); 604 CaptureRegions.push_back(OMPD_target); 605 CaptureRegions.push_back(OMPD_teams); 606 break; 607 case OMPD_teams: 608 case OMPD_teams_distribute: 609 case OMPD_teams_distribute_simd: 610 CaptureRegions.push_back(OMPD_teams); 611 break; 612 case OMPD_target: 613 case OMPD_target_simd: 614 CaptureRegions.push_back(OMPD_task); 615 CaptureRegions.push_back(OMPD_target); 616 break; 617 case OMPD_teams_distribute_parallel_for: 618 case OMPD_teams_distribute_parallel_for_simd: 619 CaptureRegions.push_back(OMPD_teams); 620 CaptureRegions.push_back(OMPD_parallel); 621 break; 622 case OMPD_target_parallel: 623 case OMPD_target_parallel_for: 624 case OMPD_target_parallel_for_simd: 625 CaptureRegions.push_back(OMPD_task); 626 CaptureRegions.push_back(OMPD_target); 627 CaptureRegions.push_back(OMPD_parallel); 628 break; 629 case OMPD_task: 630 case OMPD_target_enter_data: 631 case OMPD_target_exit_data: 632 case OMPD_target_update: 633 CaptureRegions.push_back(OMPD_task); 634 break; 635 case OMPD_taskloop: 636 case OMPD_taskloop_simd: 637 case OMPD_master_taskloop: 638 case OMPD_master_taskloop_simd: 639 CaptureRegions.push_back(OMPD_taskloop); 640 break; 641 case OMPD_parallel_master_taskloop: 642 case OMPD_parallel_master_taskloop_simd: 643 CaptureRegions.push_back(OMPD_parallel); 644 CaptureRegions.push_back(OMPD_taskloop); 645 break; 646 case OMPD_target_teams_distribute_parallel_for: 647 case OMPD_target_teams_distribute_parallel_for_simd: 648 CaptureRegions.push_back(OMPD_task); 649 CaptureRegions.push_back(OMPD_target); 650 CaptureRegions.push_back(OMPD_teams); 651 CaptureRegions.push_back(OMPD_parallel); 652 break; 653 case OMPD_simd: 654 case OMPD_for: 655 case OMPD_for_simd: 656 case OMPD_sections: 657 case OMPD_section: 658 case OMPD_single: 659 case OMPD_master: 660 case OMPD_critical: 661 case OMPD_taskgroup: 662 case OMPD_distribute: 663 case OMPD_ordered: 664 case OMPD_atomic: 665 case OMPD_target_data: 666 case OMPD_distribute_simd: 667 case OMPD_dispatch: 668 CaptureRegions.push_back(OMPD_unknown); 669 break; 670 case OMPD_tile: 671 // loop transformations do not introduce captures. 672 break; 673 case OMPD_threadprivate: 674 case OMPD_allocate: 675 case OMPD_taskyield: 676 case OMPD_barrier: 677 case OMPD_taskwait: 678 case OMPD_cancellation_point: 679 case OMPD_cancel: 680 case OMPD_flush: 681 case OMPD_depobj: 682 case OMPD_scan: 683 case OMPD_declare_reduction: 684 case OMPD_declare_mapper: 685 case OMPD_declare_simd: 686 case OMPD_declare_target: 687 case OMPD_end_declare_target: 688 case OMPD_requires: 689 case OMPD_declare_variant: 690 case OMPD_begin_declare_variant: 691 case OMPD_end_declare_variant: 692 llvm_unreachable("OpenMP Directive is not allowed"); 693 case OMPD_unknown: 694 default: 695 llvm_unreachable("Unknown OpenMP directive"); 696 } 697} 698