1 //===- OpenMPClause.cpp - Classes for OpenMP clauses ----------------------===// 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 // 9 // This file implements the subclesses of Stmt class declared in OpenMPClause.h 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "clang/AST/OpenMPClause.h" 14 #include "clang/AST/ASTContext.h" 15 #include "clang/AST/Attr.h" 16 #include "clang/AST/Decl.h" 17 #include "clang/AST/DeclOpenMP.h" 18 #include "clang/Basic/LLVM.h" 19 #include "clang/Basic/OpenMPKinds.h" 20 #include "llvm/ADT/SmallPtrSet.h" 21 #include "llvm/Support/Casting.h" 22 #include "llvm/Support/ErrorHandling.h" 23 #include <algorithm> 24 #include <cassert> 25 26 using namespace clang; 27 using namespace llvm; 28 using namespace omp; 29 30 OMPClause::child_range OMPClause::children() { 31 switch (getClauseKind()) { 32 default: 33 break; 34 #define OMP_CLAUSE_CLASS(Enum, Str, Class) \ 35 case Enum: \ 36 return static_cast<Class *>(this)->children(); 37 #include "llvm/Frontend/OpenMP/OMPKinds.def" 38 } 39 llvm_unreachable("unknown OMPClause"); 40 } 41 42 OMPClause::child_range OMPClause::used_children() { 43 switch (getClauseKind()) { 44 #define OMP_CLAUSE_CLASS(Enum, Str, Class) \ 45 case Enum: \ 46 return static_cast<Class *>(this)->used_children(); 47 #include "llvm/Frontend/OpenMP/OMPKinds.def" 48 case OMPC_threadprivate: 49 case OMPC_uniform: 50 case OMPC_device_type: 51 case OMPC_match: 52 case OMPC_unknown: 53 break; 54 default: 55 break; 56 } 57 llvm_unreachable("unknown OMPClause"); 58 } 59 60 OMPClauseWithPreInit *OMPClauseWithPreInit::get(OMPClause *C) { 61 auto *Res = OMPClauseWithPreInit::get(const_cast<const OMPClause *>(C)); 62 return Res ? const_cast<OMPClauseWithPreInit *>(Res) : nullptr; 63 } 64 65 const OMPClauseWithPreInit *OMPClauseWithPreInit::get(const OMPClause *C) { 66 switch (C->getClauseKind()) { 67 case OMPC_schedule: 68 return static_cast<const OMPScheduleClause *>(C); 69 case OMPC_dist_schedule: 70 return static_cast<const OMPDistScheduleClause *>(C); 71 case OMPC_firstprivate: 72 return static_cast<const OMPFirstprivateClause *>(C); 73 case OMPC_lastprivate: 74 return static_cast<const OMPLastprivateClause *>(C); 75 case OMPC_reduction: 76 return static_cast<const OMPReductionClause *>(C); 77 case OMPC_task_reduction: 78 return static_cast<const OMPTaskReductionClause *>(C); 79 case OMPC_in_reduction: 80 return static_cast<const OMPInReductionClause *>(C); 81 case OMPC_linear: 82 return static_cast<const OMPLinearClause *>(C); 83 case OMPC_if: 84 return static_cast<const OMPIfClause *>(C); 85 case OMPC_num_threads: 86 return static_cast<const OMPNumThreadsClause *>(C); 87 case OMPC_num_teams: 88 return static_cast<const OMPNumTeamsClause *>(C); 89 case OMPC_thread_limit: 90 return static_cast<const OMPThreadLimitClause *>(C); 91 case OMPC_device: 92 return static_cast<const OMPDeviceClause *>(C); 93 case OMPC_grainsize: 94 return static_cast<const OMPGrainsizeClause *>(C); 95 case OMPC_num_tasks: 96 return static_cast<const OMPNumTasksClause *>(C); 97 case OMPC_final: 98 return static_cast<const OMPFinalClause *>(C); 99 case OMPC_priority: 100 return static_cast<const OMPPriorityClause *>(C); 101 case OMPC_default: 102 case OMPC_proc_bind: 103 case OMPC_safelen: 104 case OMPC_simdlen: 105 case OMPC_allocator: 106 case OMPC_allocate: 107 case OMPC_collapse: 108 case OMPC_private: 109 case OMPC_shared: 110 case OMPC_aligned: 111 case OMPC_copyin: 112 case OMPC_copyprivate: 113 case OMPC_ordered: 114 case OMPC_nowait: 115 case OMPC_untied: 116 case OMPC_mergeable: 117 case OMPC_threadprivate: 118 case OMPC_flush: 119 case OMPC_depobj: 120 case OMPC_read: 121 case OMPC_write: 122 case OMPC_update: 123 case OMPC_capture: 124 case OMPC_seq_cst: 125 case OMPC_acq_rel: 126 case OMPC_acquire: 127 case OMPC_release: 128 case OMPC_relaxed: 129 case OMPC_depend: 130 case OMPC_threads: 131 case OMPC_simd: 132 case OMPC_map: 133 case OMPC_nogroup: 134 case OMPC_hint: 135 case OMPC_defaultmap: 136 case OMPC_unknown: 137 case OMPC_uniform: 138 case OMPC_to: 139 case OMPC_from: 140 case OMPC_use_device_ptr: 141 case OMPC_use_device_addr: 142 case OMPC_is_device_ptr: 143 case OMPC_unified_address: 144 case OMPC_unified_shared_memory: 145 case OMPC_reverse_offload: 146 case OMPC_dynamic_allocators: 147 case OMPC_atomic_default_mem_order: 148 case OMPC_device_type: 149 case OMPC_match: 150 case OMPC_nontemporal: 151 case OMPC_order: 152 case OMPC_destroy: 153 case OMPC_detach: 154 case OMPC_inclusive: 155 case OMPC_exclusive: 156 case OMPC_uses_allocators: 157 case OMPC_affinity: 158 break; 159 default: 160 break; 161 } 162 163 return nullptr; 164 } 165 166 OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(OMPClause *C) { 167 auto *Res = OMPClauseWithPostUpdate::get(const_cast<const OMPClause *>(C)); 168 return Res ? const_cast<OMPClauseWithPostUpdate *>(Res) : nullptr; 169 } 170 171 const OMPClauseWithPostUpdate *OMPClauseWithPostUpdate::get(const OMPClause *C) { 172 switch (C->getClauseKind()) { 173 case OMPC_lastprivate: 174 return static_cast<const OMPLastprivateClause *>(C); 175 case OMPC_reduction: 176 return static_cast<const OMPReductionClause *>(C); 177 case OMPC_task_reduction: 178 return static_cast<const OMPTaskReductionClause *>(C); 179 case OMPC_in_reduction: 180 return static_cast<const OMPInReductionClause *>(C); 181 case OMPC_linear: 182 return static_cast<const OMPLinearClause *>(C); 183 case OMPC_schedule: 184 case OMPC_dist_schedule: 185 case OMPC_firstprivate: 186 case OMPC_default: 187 case OMPC_proc_bind: 188 case OMPC_if: 189 case OMPC_final: 190 case OMPC_num_threads: 191 case OMPC_safelen: 192 case OMPC_simdlen: 193 case OMPC_allocator: 194 case OMPC_allocate: 195 case OMPC_collapse: 196 case OMPC_private: 197 case OMPC_shared: 198 case OMPC_aligned: 199 case OMPC_copyin: 200 case OMPC_copyprivate: 201 case OMPC_ordered: 202 case OMPC_nowait: 203 case OMPC_untied: 204 case OMPC_mergeable: 205 case OMPC_threadprivate: 206 case OMPC_flush: 207 case OMPC_depobj: 208 case OMPC_read: 209 case OMPC_write: 210 case OMPC_update: 211 case OMPC_capture: 212 case OMPC_seq_cst: 213 case OMPC_acq_rel: 214 case OMPC_acquire: 215 case OMPC_release: 216 case OMPC_relaxed: 217 case OMPC_depend: 218 case OMPC_device: 219 case OMPC_threads: 220 case OMPC_simd: 221 case OMPC_map: 222 case OMPC_num_teams: 223 case OMPC_thread_limit: 224 case OMPC_priority: 225 case OMPC_grainsize: 226 case OMPC_nogroup: 227 case OMPC_num_tasks: 228 case OMPC_hint: 229 case OMPC_defaultmap: 230 case OMPC_unknown: 231 case OMPC_uniform: 232 case OMPC_to: 233 case OMPC_from: 234 case OMPC_use_device_ptr: 235 case OMPC_use_device_addr: 236 case OMPC_is_device_ptr: 237 case OMPC_unified_address: 238 case OMPC_unified_shared_memory: 239 case OMPC_reverse_offload: 240 case OMPC_dynamic_allocators: 241 case OMPC_atomic_default_mem_order: 242 case OMPC_device_type: 243 case OMPC_match: 244 case OMPC_nontemporal: 245 case OMPC_order: 246 case OMPC_destroy: 247 case OMPC_detach: 248 case OMPC_inclusive: 249 case OMPC_exclusive: 250 case OMPC_uses_allocators: 251 case OMPC_affinity: 252 break; 253 default: 254 break; 255 } 256 257 return nullptr; 258 } 259 260 /// Gets the address of the original, non-captured, expression used in the 261 /// clause as the preinitializer. 262 static Stmt **getAddrOfExprAsWritten(Stmt *S) { 263 if (!S) 264 return nullptr; 265 if (auto *DS = dyn_cast<DeclStmt>(S)) { 266 assert(DS->isSingleDecl() && "Only single expression must be captured."); 267 if (auto *OED = dyn_cast<OMPCapturedExprDecl>(DS->getSingleDecl())) 268 return OED->getInitAddress(); 269 } 270 return nullptr; 271 } 272 273 OMPClause::child_range OMPIfClause::used_children() { 274 if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt())) 275 return child_range(C, C + 1); 276 return child_range(&Condition, &Condition + 1); 277 } 278 279 OMPClause::child_range OMPGrainsizeClause::used_children() { 280 if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt())) 281 return child_range(C, C + 1); 282 return child_range(&Grainsize, &Grainsize + 1); 283 } 284 285 OMPClause::child_range OMPNumTasksClause::used_children() { 286 if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt())) 287 return child_range(C, C + 1); 288 return child_range(&NumTasks, &NumTasks + 1); 289 } 290 291 OMPClause::child_range OMPFinalClause::used_children() { 292 if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt())) 293 return child_range(C, C + 1); 294 return child_range(&Condition, &Condition + 1); 295 } 296 297 OMPClause::child_range OMPPriorityClause::used_children() { 298 if (Stmt **C = getAddrOfExprAsWritten(getPreInitStmt())) 299 return child_range(C, C + 1); 300 return child_range(&Priority, &Priority + 1); 301 } 302 303 OMPOrderedClause *OMPOrderedClause::Create(const ASTContext &C, Expr *Num, 304 unsigned NumLoops, 305 SourceLocation StartLoc, 306 SourceLocation LParenLoc, 307 SourceLocation EndLoc) { 308 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * NumLoops)); 309 auto *Clause = 310 new (Mem) OMPOrderedClause(Num, NumLoops, StartLoc, LParenLoc, EndLoc); 311 for (unsigned I = 0; I < NumLoops; ++I) { 312 Clause->setLoopNumIterations(I, nullptr); 313 Clause->setLoopCounter(I, nullptr); 314 } 315 return Clause; 316 } 317 318 OMPOrderedClause *OMPOrderedClause::CreateEmpty(const ASTContext &C, 319 unsigned NumLoops) { 320 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * NumLoops)); 321 auto *Clause = new (Mem) OMPOrderedClause(NumLoops); 322 for (unsigned I = 0; I < NumLoops; ++I) { 323 Clause->setLoopNumIterations(I, nullptr); 324 Clause->setLoopCounter(I, nullptr); 325 } 326 return Clause; 327 } 328 329 void OMPOrderedClause::setLoopNumIterations(unsigned NumLoop, 330 Expr *NumIterations) { 331 assert(NumLoop < NumberOfLoops && "out of loops number."); 332 getTrailingObjects<Expr *>()[NumLoop] = NumIterations; 333 } 334 335 ArrayRef<Expr *> OMPOrderedClause::getLoopNumIterations() const { 336 return llvm::makeArrayRef(getTrailingObjects<Expr *>(), NumberOfLoops); 337 } 338 339 void OMPOrderedClause::setLoopCounter(unsigned NumLoop, Expr *Counter) { 340 assert(NumLoop < NumberOfLoops && "out of loops number."); 341 getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop] = Counter; 342 } 343 344 Expr *OMPOrderedClause::getLoopCounter(unsigned NumLoop) { 345 assert(NumLoop < NumberOfLoops && "out of loops number."); 346 return getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop]; 347 } 348 349 const Expr *OMPOrderedClause::getLoopCounter(unsigned NumLoop) const { 350 assert(NumLoop < NumberOfLoops && "out of loops number."); 351 return getTrailingObjects<Expr *>()[NumberOfLoops + NumLoop]; 352 } 353 354 OMPUpdateClause *OMPUpdateClause::Create(const ASTContext &C, 355 SourceLocation StartLoc, 356 SourceLocation EndLoc) { 357 return new (C) OMPUpdateClause(StartLoc, EndLoc, /*IsExtended=*/false); 358 } 359 360 OMPUpdateClause * 361 OMPUpdateClause::Create(const ASTContext &C, SourceLocation StartLoc, 362 SourceLocation LParenLoc, SourceLocation ArgumentLoc, 363 OpenMPDependClauseKind DK, SourceLocation EndLoc) { 364 void *Mem = 365 C.Allocate(totalSizeToAlloc<SourceLocation, OpenMPDependClauseKind>(2, 1), 366 alignof(OMPUpdateClause)); 367 auto *Clause = 368 new (Mem) OMPUpdateClause(StartLoc, EndLoc, /*IsExtended=*/true); 369 Clause->setLParenLoc(LParenLoc); 370 Clause->setArgumentLoc(ArgumentLoc); 371 Clause->setDependencyKind(DK); 372 return Clause; 373 } 374 375 OMPUpdateClause *OMPUpdateClause::CreateEmpty(const ASTContext &C, 376 bool IsExtended) { 377 if (!IsExtended) 378 return new (C) OMPUpdateClause(/*IsExtended=*/false); 379 void *Mem = 380 C.Allocate(totalSizeToAlloc<SourceLocation, OpenMPDependClauseKind>(2, 1), 381 alignof(OMPUpdateClause)); 382 auto *Clause = new (Mem) OMPUpdateClause(/*IsExtended=*/true); 383 Clause->IsExtended = true; 384 return Clause; 385 } 386 387 void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) { 388 assert(VL.size() == varlist_size() && 389 "Number of private copies is not the same as the preallocated buffer"); 390 std::copy(VL.begin(), VL.end(), varlist_end()); 391 } 392 393 OMPPrivateClause * 394 OMPPrivateClause::Create(const ASTContext &C, SourceLocation StartLoc, 395 SourceLocation LParenLoc, SourceLocation EndLoc, 396 ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) { 397 // Allocate space for private variables and initializer expressions. 398 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * VL.size())); 399 OMPPrivateClause *Clause = 400 new (Mem) OMPPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size()); 401 Clause->setVarRefs(VL); 402 Clause->setPrivateCopies(PrivateVL); 403 return Clause; 404 } 405 406 OMPPrivateClause *OMPPrivateClause::CreateEmpty(const ASTContext &C, 407 unsigned N) { 408 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * N)); 409 return new (Mem) OMPPrivateClause(N); 410 } 411 412 void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) { 413 assert(VL.size() == varlist_size() && 414 "Number of private copies is not the same as the preallocated buffer"); 415 std::copy(VL.begin(), VL.end(), varlist_end()); 416 } 417 418 void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) { 419 assert(VL.size() == varlist_size() && 420 "Number of inits is not the same as the preallocated buffer"); 421 std::copy(VL.begin(), VL.end(), getPrivateCopies().end()); 422 } 423 424 OMPFirstprivateClause * 425 OMPFirstprivateClause::Create(const ASTContext &C, SourceLocation StartLoc, 426 SourceLocation LParenLoc, SourceLocation EndLoc, 427 ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL, 428 ArrayRef<Expr *> InitVL, Stmt *PreInit) { 429 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * VL.size())); 430 OMPFirstprivateClause *Clause = 431 new (Mem) OMPFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size()); 432 Clause->setVarRefs(VL); 433 Clause->setPrivateCopies(PrivateVL); 434 Clause->setInits(InitVL); 435 Clause->setPreInitStmt(PreInit); 436 return Clause; 437 } 438 439 OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C, 440 unsigned N) { 441 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(3 * N)); 442 return new (Mem) OMPFirstprivateClause(N); 443 } 444 445 void OMPLastprivateClause::setPrivateCopies(ArrayRef<Expr *> PrivateCopies) { 446 assert(PrivateCopies.size() == varlist_size() && 447 "Number of private copies is not the same as the preallocated buffer"); 448 std::copy(PrivateCopies.begin(), PrivateCopies.end(), varlist_end()); 449 } 450 451 void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) { 452 assert(SrcExprs.size() == varlist_size() && "Number of source expressions is " 453 "not the same as the " 454 "preallocated buffer"); 455 std::copy(SrcExprs.begin(), SrcExprs.end(), getPrivateCopies().end()); 456 } 457 458 void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) { 459 assert(DstExprs.size() == varlist_size() && "Number of destination " 460 "expressions is not the same as " 461 "the preallocated buffer"); 462 std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end()); 463 } 464 465 void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) { 466 assert(AssignmentOps.size() == varlist_size() && 467 "Number of assignment expressions is not the same as the preallocated " 468 "buffer"); 469 std::copy(AssignmentOps.begin(), AssignmentOps.end(), 470 getDestinationExprs().end()); 471 } 472 473 OMPLastprivateClause *OMPLastprivateClause::Create( 474 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 475 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs, 476 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps, 477 OpenMPLastprivateModifier LPKind, SourceLocation LPKindLoc, 478 SourceLocation ColonLoc, Stmt *PreInit, Expr *PostUpdate) { 479 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size())); 480 OMPLastprivateClause *Clause = new (Mem) OMPLastprivateClause( 481 StartLoc, LParenLoc, EndLoc, LPKind, LPKindLoc, ColonLoc, VL.size()); 482 Clause->setVarRefs(VL); 483 Clause->setSourceExprs(SrcExprs); 484 Clause->setDestinationExprs(DstExprs); 485 Clause->setAssignmentOps(AssignmentOps); 486 Clause->setPreInitStmt(PreInit); 487 Clause->setPostUpdateExpr(PostUpdate); 488 return Clause; 489 } 490 491 OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C, 492 unsigned N) { 493 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N)); 494 return new (Mem) OMPLastprivateClause(N); 495 } 496 497 OMPSharedClause *OMPSharedClause::Create(const ASTContext &C, 498 SourceLocation StartLoc, 499 SourceLocation LParenLoc, 500 SourceLocation EndLoc, 501 ArrayRef<Expr *> VL) { 502 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size())); 503 OMPSharedClause *Clause = 504 new (Mem) OMPSharedClause(StartLoc, LParenLoc, EndLoc, VL.size()); 505 Clause->setVarRefs(VL); 506 return Clause; 507 } 508 509 OMPSharedClause *OMPSharedClause::CreateEmpty(const ASTContext &C, unsigned N) { 510 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N)); 511 return new (Mem) OMPSharedClause(N); 512 } 513 514 void OMPLinearClause::setPrivates(ArrayRef<Expr *> PL) { 515 assert(PL.size() == varlist_size() && 516 "Number of privates is not the same as the preallocated buffer"); 517 std::copy(PL.begin(), PL.end(), varlist_end()); 518 } 519 520 void OMPLinearClause::setInits(ArrayRef<Expr *> IL) { 521 assert(IL.size() == varlist_size() && 522 "Number of inits is not the same as the preallocated buffer"); 523 std::copy(IL.begin(), IL.end(), getPrivates().end()); 524 } 525 526 void OMPLinearClause::setUpdates(ArrayRef<Expr *> UL) { 527 assert(UL.size() == varlist_size() && 528 "Number of updates is not the same as the preallocated buffer"); 529 std::copy(UL.begin(), UL.end(), getInits().end()); 530 } 531 532 void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) { 533 assert(FL.size() == varlist_size() && 534 "Number of final updates is not the same as the preallocated buffer"); 535 std::copy(FL.begin(), FL.end(), getUpdates().end()); 536 } 537 538 void OMPLinearClause::setUsedExprs(ArrayRef<Expr *> UE) { 539 assert( 540 UE.size() == varlist_size() + 1 && 541 "Number of used expressions is not the same as the preallocated buffer"); 542 std::copy(UE.begin(), UE.end(), getFinals().end() + 2); 543 } 544 545 OMPLinearClause *OMPLinearClause::Create( 546 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 547 OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc, 548 SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL, 549 ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep, 550 Stmt *PreInit, Expr *PostUpdate) { 551 // Allocate space for 5 lists (Vars, Inits, Updates, Finals), 2 expressions 552 // (Step and CalcStep), list of used expression + step. 553 void *Mem = 554 C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size() + 2 + VL.size() + 1)); 555 OMPLinearClause *Clause = new (Mem) OMPLinearClause( 556 StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc, EndLoc, VL.size()); 557 Clause->setVarRefs(VL); 558 Clause->setPrivates(PL); 559 Clause->setInits(IL); 560 // Fill update and final expressions with zeroes, they are provided later, 561 // after the directive construction. 562 std::fill(Clause->getInits().end(), Clause->getInits().end() + VL.size(), 563 nullptr); 564 std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(), 565 nullptr); 566 std::fill(Clause->getUsedExprs().begin(), Clause->getUsedExprs().end(), 567 nullptr); 568 Clause->setStep(Step); 569 Clause->setCalcStep(CalcStep); 570 Clause->setPreInitStmt(PreInit); 571 Clause->setPostUpdateExpr(PostUpdate); 572 return Clause; 573 } 574 575 OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C, 576 unsigned NumVars) { 577 // Allocate space for 5 lists (Vars, Inits, Updates, Finals), 2 expressions 578 // (Step and CalcStep), list of used expression + step. 579 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * NumVars + 2 + NumVars +1)); 580 return new (Mem) OMPLinearClause(NumVars); 581 } 582 583 OMPClause::child_range OMPLinearClause::used_children() { 584 // Range includes only non-nullptr elements. 585 return child_range( 586 reinterpret_cast<Stmt **>(getUsedExprs().begin()), 587 reinterpret_cast<Stmt **>(llvm::find(getUsedExprs(), nullptr))); 588 } 589 590 OMPAlignedClause * 591 OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc, 592 SourceLocation LParenLoc, SourceLocation ColonLoc, 593 SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) { 594 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1)); 595 OMPAlignedClause *Clause = new (Mem) 596 OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size()); 597 Clause->setVarRefs(VL); 598 Clause->setAlignment(A); 599 return Clause; 600 } 601 602 OMPAlignedClause *OMPAlignedClause::CreateEmpty(const ASTContext &C, 603 unsigned NumVars) { 604 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(NumVars + 1)); 605 return new (Mem) OMPAlignedClause(NumVars); 606 } 607 608 void OMPCopyinClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) { 609 assert(SrcExprs.size() == varlist_size() && "Number of source expressions is " 610 "not the same as the " 611 "preallocated buffer"); 612 std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end()); 613 } 614 615 void OMPCopyinClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) { 616 assert(DstExprs.size() == varlist_size() && "Number of destination " 617 "expressions is not the same as " 618 "the preallocated buffer"); 619 std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end()); 620 } 621 622 void OMPCopyinClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) { 623 assert(AssignmentOps.size() == varlist_size() && 624 "Number of assignment expressions is not the same as the preallocated " 625 "buffer"); 626 std::copy(AssignmentOps.begin(), AssignmentOps.end(), 627 getDestinationExprs().end()); 628 } 629 630 OMPCopyinClause *OMPCopyinClause::Create( 631 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 632 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs, 633 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) { 634 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size())); 635 OMPCopyinClause *Clause = 636 new (Mem) OMPCopyinClause(StartLoc, LParenLoc, EndLoc, VL.size()); 637 Clause->setVarRefs(VL); 638 Clause->setSourceExprs(SrcExprs); 639 Clause->setDestinationExprs(DstExprs); 640 Clause->setAssignmentOps(AssignmentOps); 641 return Clause; 642 } 643 644 OMPCopyinClause *OMPCopyinClause::CreateEmpty(const ASTContext &C, unsigned N) { 645 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N)); 646 return new (Mem) OMPCopyinClause(N); 647 } 648 649 void OMPCopyprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) { 650 assert(SrcExprs.size() == varlist_size() && "Number of source expressions is " 651 "not the same as the " 652 "preallocated buffer"); 653 std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end()); 654 } 655 656 void OMPCopyprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) { 657 assert(DstExprs.size() == varlist_size() && "Number of destination " 658 "expressions is not the same as " 659 "the preallocated buffer"); 660 std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end()); 661 } 662 663 void OMPCopyprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) { 664 assert(AssignmentOps.size() == varlist_size() && 665 "Number of assignment expressions is not the same as the preallocated " 666 "buffer"); 667 std::copy(AssignmentOps.begin(), AssignmentOps.end(), 668 getDestinationExprs().end()); 669 } 670 671 OMPCopyprivateClause *OMPCopyprivateClause::Create( 672 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 673 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs, 674 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) { 675 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * VL.size())); 676 OMPCopyprivateClause *Clause = 677 new (Mem) OMPCopyprivateClause(StartLoc, LParenLoc, EndLoc, VL.size()); 678 Clause->setVarRefs(VL); 679 Clause->setSourceExprs(SrcExprs); 680 Clause->setDestinationExprs(DstExprs); 681 Clause->setAssignmentOps(AssignmentOps); 682 return Clause; 683 } 684 685 OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(const ASTContext &C, 686 unsigned N) { 687 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(4 * N)); 688 return new (Mem) OMPCopyprivateClause(N); 689 } 690 691 void OMPReductionClause::setPrivates(ArrayRef<Expr *> Privates) { 692 assert(Privates.size() == varlist_size() && 693 "Number of private copies is not the same as the preallocated buffer"); 694 std::copy(Privates.begin(), Privates.end(), varlist_end()); 695 } 696 697 void OMPReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) { 698 assert( 699 LHSExprs.size() == varlist_size() && 700 "Number of LHS expressions is not the same as the preallocated buffer"); 701 std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end()); 702 } 703 704 void OMPReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) { 705 assert( 706 RHSExprs.size() == varlist_size() && 707 "Number of RHS expressions is not the same as the preallocated buffer"); 708 std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end()); 709 } 710 711 void OMPReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) { 712 assert(ReductionOps.size() == varlist_size() && "Number of reduction " 713 "expressions is not the same " 714 "as the preallocated buffer"); 715 std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end()); 716 } 717 718 void OMPReductionClause::setInscanCopyOps(ArrayRef<Expr *> Ops) { 719 assert(Modifier == OMPC_REDUCTION_inscan && "Expected inscan reduction."); 720 assert(Ops.size() == varlist_size() && "Number of copy " 721 "expressions is not the same " 722 "as the preallocated buffer"); 723 llvm::copy(Ops, getReductionOps().end()); 724 } 725 726 void OMPReductionClause::setInscanCopyArrayTemps( 727 ArrayRef<Expr *> CopyArrayTemps) { 728 assert(Modifier == OMPC_REDUCTION_inscan && "Expected inscan reduction."); 729 assert(CopyArrayTemps.size() == varlist_size() && 730 "Number of copy temp expressions is not the same as the preallocated " 731 "buffer"); 732 llvm::copy(CopyArrayTemps, getInscanCopyOps().end()); 733 } 734 735 void OMPReductionClause::setInscanCopyArrayElems( 736 ArrayRef<Expr *> CopyArrayElems) { 737 assert(Modifier == OMPC_REDUCTION_inscan && "Expected inscan reduction."); 738 assert(CopyArrayElems.size() == varlist_size() && 739 "Number of copy temp expressions is not the same as the preallocated " 740 "buffer"); 741 llvm::copy(CopyArrayElems, getInscanCopyArrayTemps().end()); 742 } 743 744 OMPReductionClause *OMPReductionClause::Create( 745 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 746 SourceLocation ModifierLoc, SourceLocation EndLoc, SourceLocation ColonLoc, 747 OpenMPReductionClauseModifier Modifier, ArrayRef<Expr *> VL, 748 NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, 749 ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs, 750 ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, 751 ArrayRef<Expr *> CopyOps, ArrayRef<Expr *> CopyArrayTemps, 752 ArrayRef<Expr *> CopyArrayElems, Stmt *PreInit, Expr *PostUpdate) { 753 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>( 754 (Modifier == OMPC_REDUCTION_inscan ? 8 : 5) * VL.size())); 755 auto *Clause = new (Mem) 756 OMPReductionClause(StartLoc, LParenLoc, ModifierLoc, EndLoc, ColonLoc, 757 Modifier, VL.size(), QualifierLoc, NameInfo); 758 Clause->setVarRefs(VL); 759 Clause->setPrivates(Privates); 760 Clause->setLHSExprs(LHSExprs); 761 Clause->setRHSExprs(RHSExprs); 762 Clause->setReductionOps(ReductionOps); 763 Clause->setPreInitStmt(PreInit); 764 Clause->setPostUpdateExpr(PostUpdate); 765 if (Modifier == OMPC_REDUCTION_inscan) { 766 Clause->setInscanCopyOps(CopyOps); 767 Clause->setInscanCopyArrayTemps(CopyArrayTemps); 768 Clause->setInscanCopyArrayElems(CopyArrayElems); 769 } else { 770 assert(CopyOps.empty() && 771 "copy operations are expected in inscan reductions only."); 772 assert(CopyArrayTemps.empty() && 773 "copy array temps are expected in inscan reductions only."); 774 assert(CopyArrayElems.empty() && 775 "copy array temps are expected in inscan reductions only."); 776 } 777 return Clause; 778 } 779 780 OMPReductionClause * 781 OMPReductionClause::CreateEmpty(const ASTContext &C, unsigned N, 782 OpenMPReductionClauseModifier Modifier) { 783 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>( 784 (Modifier == OMPC_REDUCTION_inscan ? 8 : 5) * N)); 785 auto *Clause = new (Mem) OMPReductionClause(N); 786 Clause->setModifier(Modifier); 787 return Clause; 788 } 789 790 void OMPTaskReductionClause::setPrivates(ArrayRef<Expr *> Privates) { 791 assert(Privates.size() == varlist_size() && 792 "Number of private copies is not the same as the preallocated buffer"); 793 std::copy(Privates.begin(), Privates.end(), varlist_end()); 794 } 795 796 void OMPTaskReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) { 797 assert( 798 LHSExprs.size() == varlist_size() && 799 "Number of LHS expressions is not the same as the preallocated buffer"); 800 std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end()); 801 } 802 803 void OMPTaskReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) { 804 assert( 805 RHSExprs.size() == varlist_size() && 806 "Number of RHS expressions is not the same as the preallocated buffer"); 807 std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end()); 808 } 809 810 void OMPTaskReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) { 811 assert(ReductionOps.size() == varlist_size() && "Number of task reduction " 812 "expressions is not the same " 813 "as the preallocated buffer"); 814 std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end()); 815 } 816 817 OMPTaskReductionClause *OMPTaskReductionClause::Create( 818 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 819 SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL, 820 NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, 821 ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs, 822 ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, Stmt *PreInit, 823 Expr *PostUpdate) { 824 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * VL.size())); 825 OMPTaskReductionClause *Clause = new (Mem) OMPTaskReductionClause( 826 StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo); 827 Clause->setVarRefs(VL); 828 Clause->setPrivates(Privates); 829 Clause->setLHSExprs(LHSExprs); 830 Clause->setRHSExprs(RHSExprs); 831 Clause->setReductionOps(ReductionOps); 832 Clause->setPreInitStmt(PreInit); 833 Clause->setPostUpdateExpr(PostUpdate); 834 return Clause; 835 } 836 837 OMPTaskReductionClause *OMPTaskReductionClause::CreateEmpty(const ASTContext &C, 838 unsigned N) { 839 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(5 * N)); 840 return new (Mem) OMPTaskReductionClause(N); 841 } 842 843 void OMPInReductionClause::setPrivates(ArrayRef<Expr *> Privates) { 844 assert(Privates.size() == varlist_size() && 845 "Number of private copies is not the same as the preallocated buffer"); 846 std::copy(Privates.begin(), Privates.end(), varlist_end()); 847 } 848 849 void OMPInReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) { 850 assert( 851 LHSExprs.size() == varlist_size() && 852 "Number of LHS expressions is not the same as the preallocated buffer"); 853 std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end()); 854 } 855 856 void OMPInReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) { 857 assert( 858 RHSExprs.size() == varlist_size() && 859 "Number of RHS expressions is not the same as the preallocated buffer"); 860 std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end()); 861 } 862 863 void OMPInReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) { 864 assert(ReductionOps.size() == varlist_size() && "Number of in reduction " 865 "expressions is not the same " 866 "as the preallocated buffer"); 867 std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end()); 868 } 869 870 void OMPInReductionClause::setTaskgroupDescriptors( 871 ArrayRef<Expr *> TaskgroupDescriptors) { 872 assert(TaskgroupDescriptors.size() == varlist_size() && 873 "Number of in reduction descriptors is not the same as the " 874 "preallocated buffer"); 875 std::copy(TaskgroupDescriptors.begin(), TaskgroupDescriptors.end(), 876 getReductionOps().end()); 877 } 878 879 OMPInReductionClause *OMPInReductionClause::Create( 880 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc, 881 SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL, 882 NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo, 883 ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs, 884 ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps, 885 ArrayRef<Expr *> TaskgroupDescriptors, Stmt *PreInit, Expr *PostUpdate) { 886 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(6 * VL.size())); 887 OMPInReductionClause *Clause = new (Mem) OMPInReductionClause( 888 StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo); 889 Clause->setVarRefs(VL); 890 Clause->setPrivates(Privates); 891 Clause->setLHSExprs(LHSExprs); 892 Clause->setRHSExprs(RHSExprs); 893 Clause->setReductionOps(ReductionOps); 894 Clause->setTaskgroupDescriptors(TaskgroupDescriptors); 895 Clause->setPreInitStmt(PreInit); 896 Clause->setPostUpdateExpr(PostUpdate); 897 return Clause; 898 } 899 900 OMPInReductionClause *OMPInReductionClause::CreateEmpty(const ASTContext &C, 901 unsigned N) { 902 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(6 * N)); 903 return new (Mem) OMPInReductionClause(N); 904 } 905 906 OMPAllocateClause * 907 OMPAllocateClause::Create(const ASTContext &C, SourceLocation StartLoc, 908 SourceLocation LParenLoc, Expr *Allocator, 909 SourceLocation ColonLoc, SourceLocation EndLoc, 910 ArrayRef<Expr *> VL) { 911 // Allocate space for private variables and initializer expressions. 912 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size())); 913 auto *Clause = new (Mem) OMPAllocateClause(StartLoc, LParenLoc, Allocator, 914 ColonLoc, EndLoc, VL.size()); 915 Clause->setVarRefs(VL); 916 return Clause; 917 } 918 919 OMPAllocateClause *OMPAllocateClause::CreateEmpty(const ASTContext &C, 920 unsigned N) { 921 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N)); 922 return new (Mem) OMPAllocateClause(N); 923 } 924 925 OMPFlushClause *OMPFlushClause::Create(const ASTContext &C, 926 SourceLocation StartLoc, 927 SourceLocation LParenLoc, 928 SourceLocation EndLoc, 929 ArrayRef<Expr *> VL) { 930 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size() + 1)); 931 OMPFlushClause *Clause = 932 new (Mem) OMPFlushClause(StartLoc, LParenLoc, EndLoc, VL.size()); 933 Clause->setVarRefs(VL); 934 return Clause; 935 } 936 937 OMPFlushClause *OMPFlushClause::CreateEmpty(const ASTContext &C, unsigned N) { 938 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N)); 939 return new (Mem) OMPFlushClause(N); 940 } 941 942 OMPDepobjClause *OMPDepobjClause::Create(const ASTContext &C, 943 SourceLocation StartLoc, 944 SourceLocation LParenLoc, 945 SourceLocation RParenLoc, 946 Expr *Depobj) { 947 auto *Clause = new (C) OMPDepobjClause(StartLoc, LParenLoc, RParenLoc); 948 Clause->setDepobj(Depobj); 949 return Clause; 950 } 951 952 OMPDepobjClause *OMPDepobjClause::CreateEmpty(const ASTContext &C) { 953 return new (C) OMPDepobjClause(); 954 } 955 956 OMPDependClause * 957 OMPDependClause::Create(const ASTContext &C, SourceLocation StartLoc, 958 SourceLocation LParenLoc, SourceLocation EndLoc, 959 Expr *DepModifier, OpenMPDependClauseKind DepKind, 960 SourceLocation DepLoc, SourceLocation ColonLoc, 961 ArrayRef<Expr *> VL, unsigned NumLoops) { 962 void *Mem = C.Allocate( 963 totalSizeToAlloc<Expr *>(VL.size() + /*depend-modifier*/ 1 + NumLoops), 964 alignof(OMPDependClause)); 965 OMPDependClause *Clause = new (Mem) 966 OMPDependClause(StartLoc, LParenLoc, EndLoc, VL.size(), NumLoops); 967 Clause->setVarRefs(VL); 968 Clause->setDependencyKind(DepKind); 969 Clause->setDependencyLoc(DepLoc); 970 Clause->setColonLoc(ColonLoc); 971 Clause->setModifier(DepModifier); 972 for (unsigned I = 0 ; I < NumLoops; ++I) 973 Clause->setLoopData(I, nullptr); 974 return Clause; 975 } 976 977 OMPDependClause *OMPDependClause::CreateEmpty(const ASTContext &C, unsigned N, 978 unsigned NumLoops) { 979 void *Mem = 980 C.Allocate(totalSizeToAlloc<Expr *>(N + /*depend-modifier*/ 1 + NumLoops), 981 alignof(OMPDependClause)); 982 return new (Mem) OMPDependClause(N, NumLoops); 983 } 984 985 void OMPDependClause::setLoopData(unsigned NumLoop, Expr *Cnt) { 986 assert((getDependencyKind() == OMPC_DEPEND_sink || 987 getDependencyKind() == OMPC_DEPEND_source) && 988 NumLoop < NumLoops && 989 "Expected sink or source depend + loop index must be less number of " 990 "loops."); 991 auto *It = std::next(getVarRefs().end(), NumLoop + 1); 992 *It = Cnt; 993 } 994 995 Expr *OMPDependClause::getLoopData(unsigned NumLoop) { 996 assert((getDependencyKind() == OMPC_DEPEND_sink || 997 getDependencyKind() == OMPC_DEPEND_source) && 998 NumLoop < NumLoops && 999 "Expected sink or source depend + loop index must be less number of " 1000 "loops."); 1001 auto *It = std::next(getVarRefs().end(), NumLoop + 1); 1002 return *It; 1003 } 1004 1005 const Expr *OMPDependClause::getLoopData(unsigned NumLoop) const { 1006 assert((getDependencyKind() == OMPC_DEPEND_sink || 1007 getDependencyKind() == OMPC_DEPEND_source) && 1008 NumLoop < NumLoops && 1009 "Expected sink or source depend + loop index must be less number of " 1010 "loops."); 1011 const auto *It = std::next(getVarRefs().end(), NumLoop + 1); 1012 return *It; 1013 } 1014 1015 void OMPDependClause::setModifier(Expr *DepModifier) { 1016 *getVarRefs().end() = DepModifier; 1017 } 1018 Expr *OMPDependClause::getModifier() { return *getVarRefs().end(); } 1019 1020 unsigned OMPClauseMappableExprCommon::getComponentsTotalNumber( 1021 MappableExprComponentListsRef ComponentLists) { 1022 unsigned TotalNum = 0u; 1023 for (auto &C : ComponentLists) 1024 TotalNum += C.size(); 1025 return TotalNum; 1026 } 1027 1028 unsigned OMPClauseMappableExprCommon::getUniqueDeclarationsTotalNumber( 1029 ArrayRef<const ValueDecl *> Declarations) { 1030 unsigned TotalNum = 0u; 1031 llvm::SmallPtrSet<const ValueDecl *, 8> Cache; 1032 for (const ValueDecl *D : Declarations) { 1033 const ValueDecl *VD = D ? cast<ValueDecl>(D->getCanonicalDecl()) : nullptr; 1034 if (Cache.count(VD)) 1035 continue; 1036 ++TotalNum; 1037 Cache.insert(VD); 1038 } 1039 return TotalNum; 1040 } 1041 1042 OMPMapClause *OMPMapClause::Create( 1043 const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars, 1044 ArrayRef<ValueDecl *> Declarations, 1045 MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs, 1046 ArrayRef<OpenMPMapModifierKind> MapModifiers, 1047 ArrayRef<SourceLocation> MapModifiersLoc, 1048 NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId, 1049 OpenMPMapClauseKind Type, bool TypeIsImplicit, SourceLocation TypeLoc) { 1050 OMPMappableExprListSizeTy Sizes; 1051 Sizes.NumVars = Vars.size(); 1052 Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations); 1053 Sizes.NumComponentLists = ComponentLists.size(); 1054 Sizes.NumComponents = getComponentsTotalNumber(ComponentLists); 1055 1056 // We need to allocate: 1057 // 2 x NumVars x Expr* - we have an original list expression and an associated 1058 // user-defined mapper for each clause list entry. 1059 // NumUniqueDeclarations x ValueDecl* - unique base declarations associated 1060 // with each component list. 1061 // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the 1062 // number of lists for each unique declaration and the size of each component 1063 // list. 1064 // NumComponents x MappableComponent - the total of all the components in all 1065 // the lists. 1066 void *Mem = C.Allocate( 1067 totalSizeToAlloc<Expr *, ValueDecl *, unsigned, 1068 OMPClauseMappableExprCommon::MappableComponent>( 1069 2 * Sizes.NumVars, Sizes.NumUniqueDeclarations, 1070 Sizes.NumUniqueDeclarations + Sizes.NumComponentLists, 1071 Sizes.NumComponents)); 1072 OMPMapClause *Clause = new (Mem) 1073 OMPMapClause(MapModifiers, MapModifiersLoc, UDMQualifierLoc, MapperId, 1074 Type, TypeIsImplicit, TypeLoc, Locs, Sizes); 1075 1076 Clause->setVarRefs(Vars); 1077 Clause->setUDMapperRefs(UDMapperRefs); 1078 Clause->setClauseInfo(Declarations, ComponentLists); 1079 Clause->setMapType(Type); 1080 Clause->setMapLoc(TypeLoc); 1081 return Clause; 1082 } 1083 1084 OMPMapClause * 1085 OMPMapClause::CreateEmpty(const ASTContext &C, 1086 const OMPMappableExprListSizeTy &Sizes) { 1087 void *Mem = C.Allocate( 1088 totalSizeToAlloc<Expr *, ValueDecl *, unsigned, 1089 OMPClauseMappableExprCommon::MappableComponent>( 1090 2 * Sizes.NumVars, Sizes.NumUniqueDeclarations, 1091 Sizes.NumUniqueDeclarations + Sizes.NumComponentLists, 1092 Sizes.NumComponents)); 1093 return new (Mem) OMPMapClause(Sizes); 1094 } 1095 1096 OMPToClause *OMPToClause::Create( 1097 const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars, 1098 ArrayRef<ValueDecl *> Declarations, 1099 MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs, 1100 NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId) { 1101 OMPMappableExprListSizeTy Sizes; 1102 Sizes.NumVars = Vars.size(); 1103 Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations); 1104 Sizes.NumComponentLists = ComponentLists.size(); 1105 Sizes.NumComponents = getComponentsTotalNumber(ComponentLists); 1106 1107 // We need to allocate: 1108 // 2 x NumVars x Expr* - we have an original list expression and an associated 1109 // user-defined mapper for each clause list entry. 1110 // NumUniqueDeclarations x ValueDecl* - unique base declarations associated 1111 // with each component list. 1112 // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the 1113 // number of lists for each unique declaration and the size of each component 1114 // list. 1115 // NumComponents x MappableComponent - the total of all the components in all 1116 // the lists. 1117 void *Mem = C.Allocate( 1118 totalSizeToAlloc<Expr *, ValueDecl *, unsigned, 1119 OMPClauseMappableExprCommon::MappableComponent>( 1120 2 * Sizes.NumVars, Sizes.NumUniqueDeclarations, 1121 Sizes.NumUniqueDeclarations + Sizes.NumComponentLists, 1122 Sizes.NumComponents)); 1123 1124 auto *Clause = new (Mem) OMPToClause(UDMQualifierLoc, MapperId, Locs, Sizes); 1125 1126 Clause->setVarRefs(Vars); 1127 Clause->setUDMapperRefs(UDMapperRefs); 1128 Clause->setClauseInfo(Declarations, ComponentLists); 1129 return Clause; 1130 } 1131 1132 OMPToClause *OMPToClause::CreateEmpty(const ASTContext &C, 1133 const OMPMappableExprListSizeTy &Sizes) { 1134 void *Mem = C.Allocate( 1135 totalSizeToAlloc<Expr *, ValueDecl *, unsigned, 1136 OMPClauseMappableExprCommon::MappableComponent>( 1137 2 * Sizes.NumVars, Sizes.NumUniqueDeclarations, 1138 Sizes.NumUniqueDeclarations + Sizes.NumComponentLists, 1139 Sizes.NumComponents)); 1140 return new (Mem) OMPToClause(Sizes); 1141 } 1142 1143 OMPFromClause *OMPFromClause::Create( 1144 const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars, 1145 ArrayRef<ValueDecl *> Declarations, 1146 MappableExprComponentListsRef ComponentLists, ArrayRef<Expr *> UDMapperRefs, 1147 NestedNameSpecifierLoc UDMQualifierLoc, DeclarationNameInfo MapperId) { 1148 OMPMappableExprListSizeTy Sizes; 1149 Sizes.NumVars = Vars.size(); 1150 Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations); 1151 Sizes.NumComponentLists = ComponentLists.size(); 1152 Sizes.NumComponents = getComponentsTotalNumber(ComponentLists); 1153 1154 // We need to allocate: 1155 // 2 x NumVars x Expr* - we have an original list expression and an associated 1156 // user-defined mapper for each clause list entry. 1157 // NumUniqueDeclarations x ValueDecl* - unique base declarations associated 1158 // with each component list. 1159 // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the 1160 // number of lists for each unique declaration and the size of each component 1161 // list. 1162 // NumComponents x MappableComponent - the total of all the components in all 1163 // the lists. 1164 void *Mem = C.Allocate( 1165 totalSizeToAlloc<Expr *, ValueDecl *, unsigned, 1166 OMPClauseMappableExprCommon::MappableComponent>( 1167 2 * Sizes.NumVars, Sizes.NumUniqueDeclarations, 1168 Sizes.NumUniqueDeclarations + Sizes.NumComponentLists, 1169 Sizes.NumComponents)); 1170 1171 auto *Clause = 1172 new (Mem) OMPFromClause(UDMQualifierLoc, MapperId, Locs, Sizes); 1173 1174 Clause->setVarRefs(Vars); 1175 Clause->setUDMapperRefs(UDMapperRefs); 1176 Clause->setClauseInfo(Declarations, ComponentLists); 1177 return Clause; 1178 } 1179 1180 OMPFromClause * 1181 OMPFromClause::CreateEmpty(const ASTContext &C, 1182 const OMPMappableExprListSizeTy &Sizes) { 1183 void *Mem = C.Allocate( 1184 totalSizeToAlloc<Expr *, ValueDecl *, unsigned, 1185 OMPClauseMappableExprCommon::MappableComponent>( 1186 2 * Sizes.NumVars, Sizes.NumUniqueDeclarations, 1187 Sizes.NumUniqueDeclarations + Sizes.NumComponentLists, 1188 Sizes.NumComponents)); 1189 return new (Mem) OMPFromClause(Sizes); 1190 } 1191 1192 void OMPUseDevicePtrClause::setPrivateCopies(ArrayRef<Expr *> VL) { 1193 assert(VL.size() == varlist_size() && 1194 "Number of private copies is not the same as the preallocated buffer"); 1195 std::copy(VL.begin(), VL.end(), varlist_end()); 1196 } 1197 1198 void OMPUseDevicePtrClause::setInits(ArrayRef<Expr *> VL) { 1199 assert(VL.size() == varlist_size() && 1200 "Number of inits is not the same as the preallocated buffer"); 1201 std::copy(VL.begin(), VL.end(), getPrivateCopies().end()); 1202 } 1203 1204 OMPUseDevicePtrClause *OMPUseDevicePtrClause::Create( 1205 const ASTContext &C, const OMPVarListLocTy &Locs, ArrayRef<Expr *> Vars, 1206 ArrayRef<Expr *> PrivateVars, ArrayRef<Expr *> Inits, 1207 ArrayRef<ValueDecl *> Declarations, 1208 MappableExprComponentListsRef ComponentLists) { 1209 OMPMappableExprListSizeTy Sizes; 1210 Sizes.NumVars = Vars.size(); 1211 Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations); 1212 Sizes.NumComponentLists = ComponentLists.size(); 1213 Sizes.NumComponents = getComponentsTotalNumber(ComponentLists); 1214 1215 // We need to allocate: 1216 // NumVars x Expr* - we have an original list expression for each clause 1217 // list entry. 1218 // NumUniqueDeclarations x ValueDecl* - unique base declarations associated 1219 // with each component list. 1220 // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the 1221 // number of lists for each unique declaration and the size of each component 1222 // list. 1223 // NumComponents x MappableComponent - the total of all the components in all 1224 // the lists. 1225 void *Mem = C.Allocate( 1226 totalSizeToAlloc<Expr *, ValueDecl *, unsigned, 1227 OMPClauseMappableExprCommon::MappableComponent>( 1228 3 * Sizes.NumVars, Sizes.NumUniqueDeclarations, 1229 Sizes.NumUniqueDeclarations + Sizes.NumComponentLists, 1230 Sizes.NumComponents)); 1231 1232 OMPUseDevicePtrClause *Clause = new (Mem) OMPUseDevicePtrClause(Locs, Sizes); 1233 1234 Clause->setVarRefs(Vars); 1235 Clause->setPrivateCopies(PrivateVars); 1236 Clause->setInits(Inits); 1237 Clause->setClauseInfo(Declarations, ComponentLists); 1238 return Clause; 1239 } 1240 1241 OMPUseDevicePtrClause * 1242 OMPUseDevicePtrClause::CreateEmpty(const ASTContext &C, 1243 const OMPMappableExprListSizeTy &Sizes) { 1244 void *Mem = C.Allocate( 1245 totalSizeToAlloc<Expr *, ValueDecl *, unsigned, 1246 OMPClauseMappableExprCommon::MappableComponent>( 1247 3 * Sizes.NumVars, Sizes.NumUniqueDeclarations, 1248 Sizes.NumUniqueDeclarations + Sizes.NumComponentLists, 1249 Sizes.NumComponents)); 1250 return new (Mem) OMPUseDevicePtrClause(Sizes); 1251 } 1252 1253 OMPUseDeviceAddrClause * 1254 OMPUseDeviceAddrClause::Create(const ASTContext &C, const OMPVarListLocTy &Locs, 1255 ArrayRef<Expr *> Vars, 1256 ArrayRef<ValueDecl *> Declarations, 1257 MappableExprComponentListsRef ComponentLists) { 1258 OMPMappableExprListSizeTy Sizes; 1259 Sizes.NumVars = Vars.size(); 1260 Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations); 1261 Sizes.NumComponentLists = ComponentLists.size(); 1262 Sizes.NumComponents = getComponentsTotalNumber(ComponentLists); 1263 1264 // We need to allocate: 1265 // 3 x NumVars x Expr* - we have an original list expression for each clause 1266 // list entry and an equal number of private copies and inits. 1267 // NumUniqueDeclarations x ValueDecl* - unique base declarations associated 1268 // with each component list. 1269 // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the 1270 // number of lists for each unique declaration and the size of each component 1271 // list. 1272 // NumComponents x MappableComponent - the total of all the components in all 1273 // the lists. 1274 void *Mem = C.Allocate( 1275 totalSizeToAlloc<Expr *, ValueDecl *, unsigned, 1276 OMPClauseMappableExprCommon::MappableComponent>( 1277 Sizes.NumVars, Sizes.NumUniqueDeclarations, 1278 Sizes.NumUniqueDeclarations + Sizes.NumComponentLists, 1279 Sizes.NumComponents)); 1280 1281 auto *Clause = new (Mem) OMPUseDeviceAddrClause(Locs, Sizes); 1282 1283 Clause->setVarRefs(Vars); 1284 Clause->setClauseInfo(Declarations, ComponentLists); 1285 return Clause; 1286 } 1287 1288 OMPUseDeviceAddrClause * 1289 OMPUseDeviceAddrClause::CreateEmpty(const ASTContext &C, 1290 const OMPMappableExprListSizeTy &Sizes) { 1291 void *Mem = C.Allocate( 1292 totalSizeToAlloc<Expr *, ValueDecl *, unsigned, 1293 OMPClauseMappableExprCommon::MappableComponent>( 1294 Sizes.NumVars, Sizes.NumUniqueDeclarations, 1295 Sizes.NumUniqueDeclarations + Sizes.NumComponentLists, 1296 Sizes.NumComponents)); 1297 return new (Mem) OMPUseDeviceAddrClause(Sizes); 1298 } 1299 1300 OMPIsDevicePtrClause * 1301 OMPIsDevicePtrClause::Create(const ASTContext &C, const OMPVarListLocTy &Locs, 1302 ArrayRef<Expr *> Vars, 1303 ArrayRef<ValueDecl *> Declarations, 1304 MappableExprComponentListsRef ComponentLists) { 1305 OMPMappableExprListSizeTy Sizes; 1306 Sizes.NumVars = Vars.size(); 1307 Sizes.NumUniqueDeclarations = getUniqueDeclarationsTotalNumber(Declarations); 1308 Sizes.NumComponentLists = ComponentLists.size(); 1309 Sizes.NumComponents = getComponentsTotalNumber(ComponentLists); 1310 1311 // We need to allocate: 1312 // NumVars x Expr* - we have an original list expression for each clause list 1313 // entry. 1314 // NumUniqueDeclarations x ValueDecl* - unique base declarations associated 1315 // with each component list. 1316 // (NumUniqueDeclarations + NumComponentLists) x unsigned - we specify the 1317 // number of lists for each unique declaration and the size of each component 1318 // list. 1319 // NumComponents x MappableComponent - the total of all the components in all 1320 // the lists. 1321 void *Mem = C.Allocate( 1322 totalSizeToAlloc<Expr *, ValueDecl *, unsigned, 1323 OMPClauseMappableExprCommon::MappableComponent>( 1324 Sizes.NumVars, Sizes.NumUniqueDeclarations, 1325 Sizes.NumUniqueDeclarations + Sizes.NumComponentLists, 1326 Sizes.NumComponents)); 1327 1328 OMPIsDevicePtrClause *Clause = new (Mem) OMPIsDevicePtrClause(Locs, Sizes); 1329 1330 Clause->setVarRefs(Vars); 1331 Clause->setClauseInfo(Declarations, ComponentLists); 1332 return Clause; 1333 } 1334 1335 OMPIsDevicePtrClause * 1336 OMPIsDevicePtrClause::CreateEmpty(const ASTContext &C, 1337 const OMPMappableExprListSizeTy &Sizes) { 1338 void *Mem = C.Allocate( 1339 totalSizeToAlloc<Expr *, ValueDecl *, unsigned, 1340 OMPClauseMappableExprCommon::MappableComponent>( 1341 Sizes.NumVars, Sizes.NumUniqueDeclarations, 1342 Sizes.NumUniqueDeclarations + Sizes.NumComponentLists, 1343 Sizes.NumComponents)); 1344 return new (Mem) OMPIsDevicePtrClause(Sizes); 1345 } 1346 1347 OMPNontemporalClause *OMPNontemporalClause::Create(const ASTContext &C, 1348 SourceLocation StartLoc, 1349 SourceLocation LParenLoc, 1350 SourceLocation EndLoc, 1351 ArrayRef<Expr *> VL) { 1352 // Allocate space for nontemporal variables + private references. 1353 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * VL.size())); 1354 auto *Clause = 1355 new (Mem) OMPNontemporalClause(StartLoc, LParenLoc, EndLoc, VL.size()); 1356 Clause->setVarRefs(VL); 1357 return Clause; 1358 } 1359 1360 OMPNontemporalClause *OMPNontemporalClause::CreateEmpty(const ASTContext &C, 1361 unsigned N) { 1362 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(2 * N)); 1363 return new (Mem) OMPNontemporalClause(N); 1364 } 1365 1366 void OMPNontemporalClause::setPrivateRefs(ArrayRef<Expr *> VL) { 1367 assert(VL.size() == varlist_size() && "Number of private references is not " 1368 "the same as the preallocated buffer"); 1369 std::copy(VL.begin(), VL.end(), varlist_end()); 1370 } 1371 1372 OMPInclusiveClause *OMPInclusiveClause::Create(const ASTContext &C, 1373 SourceLocation StartLoc, 1374 SourceLocation LParenLoc, 1375 SourceLocation EndLoc, 1376 ArrayRef<Expr *> VL) { 1377 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size())); 1378 auto *Clause = 1379 new (Mem) OMPInclusiveClause(StartLoc, LParenLoc, EndLoc, VL.size()); 1380 Clause->setVarRefs(VL); 1381 return Clause; 1382 } 1383 1384 OMPInclusiveClause *OMPInclusiveClause::CreateEmpty(const ASTContext &C, 1385 unsigned N) { 1386 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N)); 1387 return new (Mem) OMPInclusiveClause(N); 1388 } 1389 1390 OMPExclusiveClause *OMPExclusiveClause::Create(const ASTContext &C, 1391 SourceLocation StartLoc, 1392 SourceLocation LParenLoc, 1393 SourceLocation EndLoc, 1394 ArrayRef<Expr *> VL) { 1395 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(VL.size())); 1396 auto *Clause = 1397 new (Mem) OMPExclusiveClause(StartLoc, LParenLoc, EndLoc, VL.size()); 1398 Clause->setVarRefs(VL); 1399 return Clause; 1400 } 1401 1402 OMPExclusiveClause *OMPExclusiveClause::CreateEmpty(const ASTContext &C, 1403 unsigned N) { 1404 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N)); 1405 return new (Mem) OMPExclusiveClause(N); 1406 } 1407 1408 void OMPUsesAllocatorsClause::setAllocatorsData( 1409 ArrayRef<OMPUsesAllocatorsClause::Data> Data) { 1410 assert(Data.size() == NumOfAllocators && 1411 "Size of allocators data is not the same as the preallocated buffer."); 1412 for (unsigned I = 0, E = Data.size(); I < E; ++I) { 1413 const OMPUsesAllocatorsClause::Data &D = Data[I]; 1414 getTrailingObjects<Expr *>()[I * static_cast<int>(ExprOffsets::Total) + 1415 static_cast<int>(ExprOffsets::Allocator)] = 1416 D.Allocator; 1417 getTrailingObjects<Expr *>()[I * static_cast<int>(ExprOffsets::Total) + 1418 static_cast<int>( 1419 ExprOffsets::AllocatorTraits)] = 1420 D.AllocatorTraits; 1421 getTrailingObjects< 1422 SourceLocation>()[I * static_cast<int>(ParenLocsOffsets::Total) + 1423 static_cast<int>(ParenLocsOffsets::LParen)] = 1424 D.LParenLoc; 1425 getTrailingObjects< 1426 SourceLocation>()[I * static_cast<int>(ParenLocsOffsets::Total) + 1427 static_cast<int>(ParenLocsOffsets::RParen)] = 1428 D.RParenLoc; 1429 } 1430 } 1431 1432 OMPUsesAllocatorsClause::Data 1433 OMPUsesAllocatorsClause::getAllocatorData(unsigned I) const { 1434 OMPUsesAllocatorsClause::Data Data; 1435 Data.Allocator = 1436 getTrailingObjects<Expr *>()[I * static_cast<int>(ExprOffsets::Total) + 1437 static_cast<int>(ExprOffsets::Allocator)]; 1438 Data.AllocatorTraits = 1439 getTrailingObjects<Expr *>()[I * static_cast<int>(ExprOffsets::Total) + 1440 static_cast<int>( 1441 ExprOffsets::AllocatorTraits)]; 1442 Data.LParenLoc = getTrailingObjects< 1443 SourceLocation>()[I * static_cast<int>(ParenLocsOffsets::Total) + 1444 static_cast<int>(ParenLocsOffsets::LParen)]; 1445 Data.RParenLoc = getTrailingObjects< 1446 SourceLocation>()[I * static_cast<int>(ParenLocsOffsets::Total) + 1447 static_cast<int>(ParenLocsOffsets::RParen)]; 1448 return Data; 1449 } 1450 1451 OMPUsesAllocatorsClause * 1452 OMPUsesAllocatorsClause::Create(const ASTContext &C, SourceLocation StartLoc, 1453 SourceLocation LParenLoc, SourceLocation EndLoc, 1454 ArrayRef<OMPUsesAllocatorsClause::Data> Data) { 1455 void *Mem = C.Allocate(totalSizeToAlloc<Expr *, SourceLocation>( 1456 static_cast<int>(ExprOffsets::Total) * Data.size(), 1457 static_cast<int>(ParenLocsOffsets::Total) * Data.size())); 1458 auto *Clause = new (Mem) 1459 OMPUsesAllocatorsClause(StartLoc, LParenLoc, EndLoc, Data.size()); 1460 Clause->setAllocatorsData(Data); 1461 return Clause; 1462 } 1463 1464 OMPUsesAllocatorsClause * 1465 OMPUsesAllocatorsClause::CreateEmpty(const ASTContext &C, unsigned N) { 1466 void *Mem = C.Allocate(totalSizeToAlloc<Expr *, SourceLocation>( 1467 static_cast<int>(ExprOffsets::Total) * N, 1468 static_cast<int>(ParenLocsOffsets::Total) * N)); 1469 return new (Mem) OMPUsesAllocatorsClause(N); 1470 } 1471 1472 OMPAffinityClause * 1473 OMPAffinityClause::Create(const ASTContext &C, SourceLocation StartLoc, 1474 SourceLocation LParenLoc, SourceLocation ColonLoc, 1475 SourceLocation EndLoc, Expr *Modifier, 1476 ArrayRef<Expr *> Locators) { 1477 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(Locators.size() + 1)); 1478 auto *Clause = new (Mem) 1479 OMPAffinityClause(StartLoc, LParenLoc, ColonLoc, EndLoc, Locators.size()); 1480 Clause->setModifier(Modifier); 1481 Clause->setVarRefs(Locators); 1482 return Clause; 1483 } 1484 1485 OMPAffinityClause *OMPAffinityClause::CreateEmpty(const ASTContext &C, 1486 unsigned N) { 1487 void *Mem = C.Allocate(totalSizeToAlloc<Expr *>(N + 1)); 1488 return new (Mem) OMPAffinityClause(N); 1489 } 1490 1491 //===----------------------------------------------------------------------===// 1492 // OpenMP clauses printing methods 1493 //===----------------------------------------------------------------------===// 1494 1495 void OMPClausePrinter::VisitOMPIfClause(OMPIfClause *Node) { 1496 OS << "if("; 1497 if (Node->getNameModifier() != OMPD_unknown) 1498 OS << getOpenMPDirectiveName(Node->getNameModifier()) << ": "; 1499 Node->getCondition()->printPretty(OS, nullptr, Policy, 0); 1500 OS << ")"; 1501 } 1502 1503 void OMPClausePrinter::VisitOMPFinalClause(OMPFinalClause *Node) { 1504 OS << "final("; 1505 Node->getCondition()->printPretty(OS, nullptr, Policy, 0); 1506 OS << ")"; 1507 } 1508 1509 void OMPClausePrinter::VisitOMPNumThreadsClause(OMPNumThreadsClause *Node) { 1510 OS << "num_threads("; 1511 Node->getNumThreads()->printPretty(OS, nullptr, Policy, 0); 1512 OS << ")"; 1513 } 1514 1515 void OMPClausePrinter::VisitOMPSafelenClause(OMPSafelenClause *Node) { 1516 OS << "safelen("; 1517 Node->getSafelen()->printPretty(OS, nullptr, Policy, 0); 1518 OS << ")"; 1519 } 1520 1521 void OMPClausePrinter::VisitOMPSimdlenClause(OMPSimdlenClause *Node) { 1522 OS << "simdlen("; 1523 Node->getSimdlen()->printPretty(OS, nullptr, Policy, 0); 1524 OS << ")"; 1525 } 1526 1527 void OMPClausePrinter::VisitOMPAllocatorClause(OMPAllocatorClause *Node) { 1528 OS << "allocator("; 1529 Node->getAllocator()->printPretty(OS, nullptr, Policy, 0); 1530 OS << ")"; 1531 } 1532 1533 void OMPClausePrinter::VisitOMPCollapseClause(OMPCollapseClause *Node) { 1534 OS << "collapse("; 1535 Node->getNumForLoops()->printPretty(OS, nullptr, Policy, 0); 1536 OS << ")"; 1537 } 1538 1539 void OMPClausePrinter::VisitOMPDetachClause(OMPDetachClause *Node) { 1540 OS << "detach("; 1541 Node->getEventHandler()->printPretty(OS, nullptr, Policy, 0); 1542 OS << ")"; 1543 } 1544 1545 void OMPClausePrinter::VisitOMPDefaultClause(OMPDefaultClause *Node) { 1546 OS << "default(" 1547 << getOpenMPSimpleClauseTypeName(OMPC_default, 1548 unsigned(Node->getDefaultKind())) 1549 << ")"; 1550 } 1551 1552 void OMPClausePrinter::VisitOMPProcBindClause(OMPProcBindClause *Node) { 1553 OS << "proc_bind(" 1554 << getOpenMPSimpleClauseTypeName(OMPC_proc_bind, 1555 unsigned(Node->getProcBindKind())) 1556 << ")"; 1557 } 1558 1559 void OMPClausePrinter::VisitOMPUnifiedAddressClause(OMPUnifiedAddressClause *) { 1560 OS << "unified_address"; 1561 } 1562 1563 void OMPClausePrinter::VisitOMPUnifiedSharedMemoryClause( 1564 OMPUnifiedSharedMemoryClause *) { 1565 OS << "unified_shared_memory"; 1566 } 1567 1568 void OMPClausePrinter::VisitOMPReverseOffloadClause(OMPReverseOffloadClause *) { 1569 OS << "reverse_offload"; 1570 } 1571 1572 void OMPClausePrinter::VisitOMPDynamicAllocatorsClause( 1573 OMPDynamicAllocatorsClause *) { 1574 OS << "dynamic_allocators"; 1575 } 1576 1577 void OMPClausePrinter::VisitOMPAtomicDefaultMemOrderClause( 1578 OMPAtomicDefaultMemOrderClause *Node) { 1579 OS << "atomic_default_mem_order(" 1580 << getOpenMPSimpleClauseTypeName(OMPC_atomic_default_mem_order, 1581 Node->getAtomicDefaultMemOrderKind()) 1582 << ")"; 1583 } 1584 1585 void OMPClausePrinter::VisitOMPScheduleClause(OMPScheduleClause *Node) { 1586 OS << "schedule("; 1587 if (Node->getFirstScheduleModifier() != OMPC_SCHEDULE_MODIFIER_unknown) { 1588 OS << getOpenMPSimpleClauseTypeName(OMPC_schedule, 1589 Node->getFirstScheduleModifier()); 1590 if (Node->getSecondScheduleModifier() != OMPC_SCHEDULE_MODIFIER_unknown) { 1591 OS << ", "; 1592 OS << getOpenMPSimpleClauseTypeName(OMPC_schedule, 1593 Node->getSecondScheduleModifier()); 1594 } 1595 OS << ": "; 1596 } 1597 OS << getOpenMPSimpleClauseTypeName(OMPC_schedule, Node->getScheduleKind()); 1598 if (auto *E = Node->getChunkSize()) { 1599 OS << ", "; 1600 E->printPretty(OS, nullptr, Policy); 1601 } 1602 OS << ")"; 1603 } 1604 1605 void OMPClausePrinter::VisitOMPOrderedClause(OMPOrderedClause *Node) { 1606 OS << "ordered"; 1607 if (auto *Num = Node->getNumForLoops()) { 1608 OS << "("; 1609 Num->printPretty(OS, nullptr, Policy, 0); 1610 OS << ")"; 1611 } 1612 } 1613 1614 void OMPClausePrinter::VisitOMPNowaitClause(OMPNowaitClause *) { 1615 OS << "nowait"; 1616 } 1617 1618 void OMPClausePrinter::VisitOMPUntiedClause(OMPUntiedClause *) { 1619 OS << "untied"; 1620 } 1621 1622 void OMPClausePrinter::VisitOMPNogroupClause(OMPNogroupClause *) { 1623 OS << "nogroup"; 1624 } 1625 1626 void OMPClausePrinter::VisitOMPMergeableClause(OMPMergeableClause *) { 1627 OS << "mergeable"; 1628 } 1629 1630 void OMPClausePrinter::VisitOMPReadClause(OMPReadClause *) { OS << "read"; } 1631 1632 void OMPClausePrinter::VisitOMPWriteClause(OMPWriteClause *) { OS << "write"; } 1633 1634 void OMPClausePrinter::VisitOMPUpdateClause(OMPUpdateClause *Node) { 1635 OS << "update"; 1636 if (Node->isExtended()) { 1637 OS << "("; 1638 OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(), 1639 Node->getDependencyKind()); 1640 OS << ")"; 1641 } 1642 } 1643 1644 void OMPClausePrinter::VisitOMPCaptureClause(OMPCaptureClause *) { 1645 OS << "capture"; 1646 } 1647 1648 void OMPClausePrinter::VisitOMPSeqCstClause(OMPSeqCstClause *) { 1649 OS << "seq_cst"; 1650 } 1651 1652 void OMPClausePrinter::VisitOMPAcqRelClause(OMPAcqRelClause *) { 1653 OS << "acq_rel"; 1654 } 1655 1656 void OMPClausePrinter::VisitOMPAcquireClause(OMPAcquireClause *) { 1657 OS << "acquire"; 1658 } 1659 1660 void OMPClausePrinter::VisitOMPReleaseClause(OMPReleaseClause *) { 1661 OS << "release"; 1662 } 1663 1664 void OMPClausePrinter::VisitOMPRelaxedClause(OMPRelaxedClause *) { 1665 OS << "relaxed"; 1666 } 1667 1668 void OMPClausePrinter::VisitOMPThreadsClause(OMPThreadsClause *) { 1669 OS << "threads"; 1670 } 1671 1672 void OMPClausePrinter::VisitOMPSIMDClause(OMPSIMDClause *) { OS << "simd"; } 1673 1674 void OMPClausePrinter::VisitOMPDeviceClause(OMPDeviceClause *Node) { 1675 OS << "device("; 1676 OpenMPDeviceClauseModifier Modifier = Node->getModifier(); 1677 if (Modifier != OMPC_DEVICE_unknown) { 1678 OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(), Modifier) 1679 << ": "; 1680 } 1681 Node->getDevice()->printPretty(OS, nullptr, Policy, 0); 1682 OS << ")"; 1683 } 1684 1685 void OMPClausePrinter::VisitOMPNumTeamsClause(OMPNumTeamsClause *Node) { 1686 OS << "num_teams("; 1687 Node->getNumTeams()->printPretty(OS, nullptr, Policy, 0); 1688 OS << ")"; 1689 } 1690 1691 void OMPClausePrinter::VisitOMPThreadLimitClause(OMPThreadLimitClause *Node) { 1692 OS << "thread_limit("; 1693 Node->getThreadLimit()->printPretty(OS, nullptr, Policy, 0); 1694 OS << ")"; 1695 } 1696 1697 void OMPClausePrinter::VisitOMPPriorityClause(OMPPriorityClause *Node) { 1698 OS << "priority("; 1699 Node->getPriority()->printPretty(OS, nullptr, Policy, 0); 1700 OS << ")"; 1701 } 1702 1703 void OMPClausePrinter::VisitOMPGrainsizeClause(OMPGrainsizeClause *Node) { 1704 OS << "grainsize("; 1705 Node->getGrainsize()->printPretty(OS, nullptr, Policy, 0); 1706 OS << ")"; 1707 } 1708 1709 void OMPClausePrinter::VisitOMPNumTasksClause(OMPNumTasksClause *Node) { 1710 OS << "num_tasks("; 1711 Node->getNumTasks()->printPretty(OS, nullptr, Policy, 0); 1712 OS << ")"; 1713 } 1714 1715 void OMPClausePrinter::VisitOMPHintClause(OMPHintClause *Node) { 1716 OS << "hint("; 1717 Node->getHint()->printPretty(OS, nullptr, Policy, 0); 1718 OS << ")"; 1719 } 1720 1721 void OMPClausePrinter::VisitOMPDestroyClause(OMPDestroyClause *) { 1722 OS << "destroy"; 1723 } 1724 1725 template<typename T> 1726 void OMPClausePrinter::VisitOMPClauseList(T *Node, char StartSym) { 1727 for (typename T::varlist_iterator I = Node->varlist_begin(), 1728 E = Node->varlist_end(); 1729 I != E; ++I) { 1730 assert(*I && "Expected non-null Stmt"); 1731 OS << (I == Node->varlist_begin() ? StartSym : ','); 1732 if (auto *DRE = dyn_cast<DeclRefExpr>(*I)) { 1733 if (isa<OMPCapturedExprDecl>(DRE->getDecl())) 1734 DRE->printPretty(OS, nullptr, Policy, 0); 1735 else 1736 DRE->getDecl()->printQualifiedName(OS); 1737 } else 1738 (*I)->printPretty(OS, nullptr, Policy, 0); 1739 } 1740 } 1741 1742 void OMPClausePrinter::VisitOMPAllocateClause(OMPAllocateClause *Node) { 1743 if (Node->varlist_empty()) 1744 return; 1745 OS << "allocate"; 1746 if (Expr *Allocator = Node->getAllocator()) { 1747 OS << "("; 1748 Allocator->printPretty(OS, nullptr, Policy, 0); 1749 OS << ":"; 1750 VisitOMPClauseList(Node, ' '); 1751 } else { 1752 VisitOMPClauseList(Node, '('); 1753 } 1754 OS << ")"; 1755 } 1756 1757 void OMPClausePrinter::VisitOMPPrivateClause(OMPPrivateClause *Node) { 1758 if (!Node->varlist_empty()) { 1759 OS << "private"; 1760 VisitOMPClauseList(Node, '('); 1761 OS << ")"; 1762 } 1763 } 1764 1765 void OMPClausePrinter::VisitOMPFirstprivateClause(OMPFirstprivateClause *Node) { 1766 if (!Node->varlist_empty()) { 1767 OS << "firstprivate"; 1768 VisitOMPClauseList(Node, '('); 1769 OS << ")"; 1770 } 1771 } 1772 1773 void OMPClausePrinter::VisitOMPLastprivateClause(OMPLastprivateClause *Node) { 1774 if (!Node->varlist_empty()) { 1775 OS << "lastprivate"; 1776 OpenMPLastprivateModifier LPKind = Node->getKind(); 1777 if (LPKind != OMPC_LASTPRIVATE_unknown) { 1778 OS << "(" 1779 << getOpenMPSimpleClauseTypeName(OMPC_lastprivate, Node->getKind()) 1780 << ":"; 1781 } 1782 VisitOMPClauseList(Node, LPKind == OMPC_LASTPRIVATE_unknown ? '(' : ' '); 1783 OS << ")"; 1784 } 1785 } 1786 1787 void OMPClausePrinter::VisitOMPSharedClause(OMPSharedClause *Node) { 1788 if (!Node->varlist_empty()) { 1789 OS << "shared"; 1790 VisitOMPClauseList(Node, '('); 1791 OS << ")"; 1792 } 1793 } 1794 1795 void OMPClausePrinter::VisitOMPReductionClause(OMPReductionClause *Node) { 1796 if (!Node->varlist_empty()) { 1797 OS << "reduction("; 1798 if (Node->getModifierLoc().isValid()) 1799 OS << getOpenMPSimpleClauseTypeName(OMPC_reduction, Node->getModifier()) 1800 << ", "; 1801 NestedNameSpecifier *QualifierLoc = 1802 Node->getQualifierLoc().getNestedNameSpecifier(); 1803 OverloadedOperatorKind OOK = 1804 Node->getNameInfo().getName().getCXXOverloadedOperator(); 1805 if (QualifierLoc == nullptr && OOK != OO_None) { 1806 // Print reduction identifier in C format 1807 OS << getOperatorSpelling(OOK); 1808 } else { 1809 // Use C++ format 1810 if (QualifierLoc != nullptr) 1811 QualifierLoc->print(OS, Policy); 1812 OS << Node->getNameInfo(); 1813 } 1814 OS << ":"; 1815 VisitOMPClauseList(Node, ' '); 1816 OS << ")"; 1817 } 1818 } 1819 1820 void OMPClausePrinter::VisitOMPTaskReductionClause( 1821 OMPTaskReductionClause *Node) { 1822 if (!Node->varlist_empty()) { 1823 OS << "task_reduction("; 1824 NestedNameSpecifier *QualifierLoc = 1825 Node->getQualifierLoc().getNestedNameSpecifier(); 1826 OverloadedOperatorKind OOK = 1827 Node->getNameInfo().getName().getCXXOverloadedOperator(); 1828 if (QualifierLoc == nullptr && OOK != OO_None) { 1829 // Print reduction identifier in C format 1830 OS << getOperatorSpelling(OOK); 1831 } else { 1832 // Use C++ format 1833 if (QualifierLoc != nullptr) 1834 QualifierLoc->print(OS, Policy); 1835 OS << Node->getNameInfo(); 1836 } 1837 OS << ":"; 1838 VisitOMPClauseList(Node, ' '); 1839 OS << ")"; 1840 } 1841 } 1842 1843 void OMPClausePrinter::VisitOMPInReductionClause(OMPInReductionClause *Node) { 1844 if (!Node->varlist_empty()) { 1845 OS << "in_reduction("; 1846 NestedNameSpecifier *QualifierLoc = 1847 Node->getQualifierLoc().getNestedNameSpecifier(); 1848 OverloadedOperatorKind OOK = 1849 Node->getNameInfo().getName().getCXXOverloadedOperator(); 1850 if (QualifierLoc == nullptr && OOK != OO_None) { 1851 // Print reduction identifier in C format 1852 OS << getOperatorSpelling(OOK); 1853 } else { 1854 // Use C++ format 1855 if (QualifierLoc != nullptr) 1856 QualifierLoc->print(OS, Policy); 1857 OS << Node->getNameInfo(); 1858 } 1859 OS << ":"; 1860 VisitOMPClauseList(Node, ' '); 1861 OS << ")"; 1862 } 1863 } 1864 1865 void OMPClausePrinter::VisitOMPLinearClause(OMPLinearClause *Node) { 1866 if (!Node->varlist_empty()) { 1867 OS << "linear"; 1868 if (Node->getModifierLoc().isValid()) { 1869 OS << '(' 1870 << getOpenMPSimpleClauseTypeName(OMPC_linear, Node->getModifier()); 1871 } 1872 VisitOMPClauseList(Node, '('); 1873 if (Node->getModifierLoc().isValid()) 1874 OS << ')'; 1875 if (Node->getStep() != nullptr) { 1876 OS << ": "; 1877 Node->getStep()->printPretty(OS, nullptr, Policy, 0); 1878 } 1879 OS << ")"; 1880 } 1881 } 1882 1883 void OMPClausePrinter::VisitOMPAlignedClause(OMPAlignedClause *Node) { 1884 if (!Node->varlist_empty()) { 1885 OS << "aligned"; 1886 VisitOMPClauseList(Node, '('); 1887 if (Node->getAlignment() != nullptr) { 1888 OS << ": "; 1889 Node->getAlignment()->printPretty(OS, nullptr, Policy, 0); 1890 } 1891 OS << ")"; 1892 } 1893 } 1894 1895 void OMPClausePrinter::VisitOMPCopyinClause(OMPCopyinClause *Node) { 1896 if (!Node->varlist_empty()) { 1897 OS << "copyin"; 1898 VisitOMPClauseList(Node, '('); 1899 OS << ")"; 1900 } 1901 } 1902 1903 void OMPClausePrinter::VisitOMPCopyprivateClause(OMPCopyprivateClause *Node) { 1904 if (!Node->varlist_empty()) { 1905 OS << "copyprivate"; 1906 VisitOMPClauseList(Node, '('); 1907 OS << ")"; 1908 } 1909 } 1910 1911 void OMPClausePrinter::VisitOMPFlushClause(OMPFlushClause *Node) { 1912 if (!Node->varlist_empty()) { 1913 VisitOMPClauseList(Node, '('); 1914 OS << ")"; 1915 } 1916 } 1917 1918 void OMPClausePrinter::VisitOMPDepobjClause(OMPDepobjClause *Node) { 1919 OS << "("; 1920 Node->getDepobj()->printPretty(OS, nullptr, Policy, 0); 1921 OS << ")"; 1922 } 1923 1924 void OMPClausePrinter::VisitOMPDependClause(OMPDependClause *Node) { 1925 OS << "depend("; 1926 if (Expr *DepModifier = Node->getModifier()) { 1927 DepModifier->printPretty(OS, nullptr, Policy); 1928 OS << ", "; 1929 } 1930 OS << getOpenMPSimpleClauseTypeName(Node->getClauseKind(), 1931 Node->getDependencyKind()); 1932 if (!Node->varlist_empty()) { 1933 OS << " :"; 1934 VisitOMPClauseList(Node, ' '); 1935 } 1936 OS << ")"; 1937 } 1938 1939 void OMPClausePrinter::VisitOMPMapClause(OMPMapClause *Node) { 1940 if (!Node->varlist_empty()) { 1941 OS << "map("; 1942 if (Node->getMapType() != OMPC_MAP_unknown) { 1943 for (unsigned I = 0; I < NumberOfOMPMapClauseModifiers; ++I) { 1944 if (Node->getMapTypeModifier(I) != OMPC_MAP_MODIFIER_unknown) { 1945 OS << getOpenMPSimpleClauseTypeName(OMPC_map, 1946 Node->getMapTypeModifier(I)); 1947 if (Node->getMapTypeModifier(I) == OMPC_MAP_MODIFIER_mapper) { 1948 OS << '('; 1949 NestedNameSpecifier *MapperNNS = 1950 Node->getMapperQualifierLoc().getNestedNameSpecifier(); 1951 if (MapperNNS) 1952 MapperNNS->print(OS, Policy); 1953 OS << Node->getMapperIdInfo() << ')'; 1954 } 1955 OS << ','; 1956 } 1957 } 1958 OS << getOpenMPSimpleClauseTypeName(OMPC_map, Node->getMapType()); 1959 OS << ':'; 1960 } 1961 VisitOMPClauseList(Node, ' '); 1962 OS << ")"; 1963 } 1964 } 1965 1966 void OMPClausePrinter::VisitOMPToClause(OMPToClause *Node) { 1967 if (!Node->varlist_empty()) { 1968 OS << "to"; 1969 DeclarationNameInfo MapperId = Node->getMapperIdInfo(); 1970 if (MapperId.getName() && !MapperId.getName().isEmpty()) { 1971 OS << '('; 1972 OS << "mapper("; 1973 NestedNameSpecifier *MapperNNS = 1974 Node->getMapperQualifierLoc().getNestedNameSpecifier(); 1975 if (MapperNNS) 1976 MapperNNS->print(OS, Policy); 1977 OS << MapperId << "):"; 1978 VisitOMPClauseList(Node, ' '); 1979 } else { 1980 VisitOMPClauseList(Node, '('); 1981 } 1982 OS << ")"; 1983 } 1984 } 1985 1986 void OMPClausePrinter::VisitOMPFromClause(OMPFromClause *Node) { 1987 if (!Node->varlist_empty()) { 1988 OS << "from"; 1989 DeclarationNameInfo MapperId = Node->getMapperIdInfo(); 1990 if (MapperId.getName() && !MapperId.getName().isEmpty()) { 1991 OS << '('; 1992 OS << "mapper("; 1993 NestedNameSpecifier *MapperNNS = 1994 Node->getMapperQualifierLoc().getNestedNameSpecifier(); 1995 if (MapperNNS) 1996 MapperNNS->print(OS, Policy); 1997 OS << MapperId << "):"; 1998 VisitOMPClauseList(Node, ' '); 1999 } else { 2000 VisitOMPClauseList(Node, '('); 2001 } 2002 OS << ")"; 2003 } 2004 } 2005 2006 void OMPClausePrinter::VisitOMPDistScheduleClause(OMPDistScheduleClause *Node) { 2007 OS << "dist_schedule(" << getOpenMPSimpleClauseTypeName( 2008 OMPC_dist_schedule, Node->getDistScheduleKind()); 2009 if (auto *E = Node->getChunkSize()) { 2010 OS << ", "; 2011 E->printPretty(OS, nullptr, Policy); 2012 } 2013 OS << ")"; 2014 } 2015 2016 void OMPClausePrinter::VisitOMPDefaultmapClause(OMPDefaultmapClause *Node) { 2017 OS << "defaultmap("; 2018 OS << getOpenMPSimpleClauseTypeName(OMPC_defaultmap, 2019 Node->getDefaultmapModifier()); 2020 if (Node->getDefaultmapKind() != OMPC_DEFAULTMAP_unknown) { 2021 OS << ": "; 2022 OS << getOpenMPSimpleClauseTypeName(OMPC_defaultmap, 2023 Node->getDefaultmapKind()); 2024 } 2025 OS << ")"; 2026 } 2027 2028 void OMPClausePrinter::VisitOMPUseDevicePtrClause(OMPUseDevicePtrClause *Node) { 2029 if (!Node->varlist_empty()) { 2030 OS << "use_device_ptr"; 2031 VisitOMPClauseList(Node, '('); 2032 OS << ")"; 2033 } 2034 } 2035 2036 void OMPClausePrinter::VisitOMPUseDeviceAddrClause( 2037 OMPUseDeviceAddrClause *Node) { 2038 if (!Node->varlist_empty()) { 2039 OS << "use_device_addr"; 2040 VisitOMPClauseList(Node, '('); 2041 OS << ")"; 2042 } 2043 } 2044 2045 void OMPClausePrinter::VisitOMPIsDevicePtrClause(OMPIsDevicePtrClause *Node) { 2046 if (!Node->varlist_empty()) { 2047 OS << "is_device_ptr"; 2048 VisitOMPClauseList(Node, '('); 2049 OS << ")"; 2050 } 2051 } 2052 2053 void OMPClausePrinter::VisitOMPNontemporalClause(OMPNontemporalClause *Node) { 2054 if (!Node->varlist_empty()) { 2055 OS << "nontemporal"; 2056 VisitOMPClauseList(Node, '('); 2057 OS << ")"; 2058 } 2059 } 2060 2061 void OMPClausePrinter::VisitOMPOrderClause(OMPOrderClause *Node) { 2062 OS << "order(" << getOpenMPSimpleClauseTypeName(OMPC_order, Node->getKind()) 2063 << ")"; 2064 } 2065 2066 void OMPClausePrinter::VisitOMPInclusiveClause(OMPInclusiveClause *Node) { 2067 if (!Node->varlist_empty()) { 2068 OS << "inclusive"; 2069 VisitOMPClauseList(Node, '('); 2070 OS << ")"; 2071 } 2072 } 2073 2074 void OMPClausePrinter::VisitOMPExclusiveClause(OMPExclusiveClause *Node) { 2075 if (!Node->varlist_empty()) { 2076 OS << "exclusive"; 2077 VisitOMPClauseList(Node, '('); 2078 OS << ")"; 2079 } 2080 } 2081 2082 void OMPClausePrinter::VisitOMPUsesAllocatorsClause( 2083 OMPUsesAllocatorsClause *Node) { 2084 if (Node->getNumberOfAllocators() == 0) 2085 return; 2086 OS << "uses_allocators("; 2087 for (unsigned I = 0, E = Node->getNumberOfAllocators(); I < E; ++I) { 2088 OMPUsesAllocatorsClause::Data Data = Node->getAllocatorData(I); 2089 Data.Allocator->printPretty(OS, nullptr, Policy); 2090 if (Data.AllocatorTraits) { 2091 OS << "("; 2092 Data.AllocatorTraits->printPretty(OS, nullptr, Policy); 2093 OS << ")"; 2094 } 2095 if (I < E - 1) 2096 OS << ","; 2097 } 2098 OS << ")"; 2099 } 2100 2101 void OMPClausePrinter::VisitOMPAffinityClause(OMPAffinityClause *Node) { 2102 if (Node->varlist_empty()) 2103 return; 2104 OS << "affinity"; 2105 char StartSym = '('; 2106 if (Expr *Modifier = Node->getModifier()) { 2107 OS << "("; 2108 Modifier->printPretty(OS, nullptr, Policy); 2109 OS << " :"; 2110 StartSym = ' '; 2111 } 2112 VisitOMPClauseList(Node, StartSym); 2113 OS << ")"; 2114 } 2115 2116 void OMPTraitInfo::getAsVariantMatchInfo(ASTContext &ASTCtx, 2117 VariantMatchInfo &VMI) const { 2118 for (const OMPTraitSet &Set : Sets) { 2119 for (const OMPTraitSelector &Selector : Set.Selectors) { 2120 2121 // User conditions are special as we evaluate the condition here. 2122 if (Selector.Kind == TraitSelector::user_condition) { 2123 assert(Selector.ScoreOrCondition && 2124 "Ill-formed user condition, expected condition expression!"); 2125 assert(Selector.Properties.size() == 1 && 2126 Selector.Properties.front().Kind == 2127 TraitProperty::user_condition_unknown && 2128 "Ill-formed user condition, expected unknown trait property!"); 2129 2130 llvm::APSInt CondVal; 2131 if (Selector.ScoreOrCondition->isIntegerConstantExpr(CondVal, ASTCtx)) 2132 VMI.addTrait(CondVal.isNullValue() 2133 ? TraitProperty::user_condition_false 2134 : TraitProperty::user_condition_true); 2135 else 2136 VMI.addTrait(TraitProperty::user_condition_false); 2137 continue; 2138 } 2139 2140 llvm::APSInt Score; 2141 llvm::APInt *ScorePtr = nullptr; 2142 if (Selector.ScoreOrCondition) { 2143 if (Selector.ScoreOrCondition->isIntegerConstantExpr(Score, ASTCtx)) 2144 ScorePtr = &Score; 2145 else 2146 VMI.addTrait(TraitProperty::user_condition_false); 2147 } 2148 2149 for (const OMPTraitProperty &Property : Selector.Properties) 2150 VMI.addTrait(Set.Kind, Property.Kind, ScorePtr); 2151 2152 if (Set.Kind != TraitSet::construct) 2153 continue; 2154 2155 // TODO: This might not hold once we implement SIMD properly. 2156 assert(Selector.Properties.size() == 1 && 2157 Selector.Properties.front().Kind == 2158 getOpenMPContextTraitPropertyForSelector( 2159 Selector.Kind) && 2160 "Ill-formed construct selector!"); 2161 2162 VMI.ConstructTraits.push_back(Selector.Properties.front().Kind); 2163 } 2164 } 2165 } 2166 2167 void OMPTraitInfo::print(llvm::raw_ostream &OS, 2168 const PrintingPolicy &Policy) const { 2169 bool FirstSet = true; 2170 for (const OMPTraitSet &Set : Sets) { 2171 if (!FirstSet) 2172 OS << ", "; 2173 FirstSet = false; 2174 OS << getOpenMPContextTraitSetName(Set.Kind) << "={"; 2175 2176 bool FirstSelector = true; 2177 for (const OMPTraitSelector &Selector : Set.Selectors) { 2178 if (!FirstSelector) 2179 OS << ", "; 2180 FirstSelector = false; 2181 OS << getOpenMPContextTraitSelectorName(Selector.Kind); 2182 2183 bool AllowsTraitScore = false; 2184 bool RequiresProperty = false; 2185 isValidTraitSelectorForTraitSet( 2186 Selector.Kind, Set.Kind, AllowsTraitScore, RequiresProperty); 2187 2188 if (!RequiresProperty) 2189 continue; 2190 2191 OS << "("; 2192 if (Selector.Kind == TraitSelector::user_condition) { 2193 Selector.ScoreOrCondition->printPretty(OS, nullptr, Policy); 2194 } else { 2195 2196 if (Selector.ScoreOrCondition) { 2197 OS << "score("; 2198 Selector.ScoreOrCondition->printPretty(OS, nullptr, Policy); 2199 OS << "): "; 2200 } 2201 2202 bool FirstProperty = true; 2203 for (const OMPTraitProperty &Property : Selector.Properties) { 2204 if (!FirstProperty) 2205 OS << ", "; 2206 FirstProperty = false; 2207 OS << getOpenMPContextTraitPropertyName(Property.Kind); 2208 } 2209 } 2210 OS << ")"; 2211 } 2212 OS << "}"; 2213 } 2214 } 2215 2216 std::string OMPTraitInfo::getMangledName() const { 2217 std::string MangledName; 2218 llvm::raw_string_ostream OS(MangledName); 2219 for (const OMPTraitSet &Set : Sets) { 2220 OS << '$' << 'S' << unsigned(Set.Kind); 2221 for (const OMPTraitSelector &Selector : Set.Selectors) { 2222 2223 bool AllowsTraitScore = false; 2224 bool RequiresProperty = false; 2225 isValidTraitSelectorForTraitSet( 2226 Selector.Kind, Set.Kind, AllowsTraitScore, RequiresProperty); 2227 OS << '$' << 's' << unsigned(Selector.Kind); 2228 2229 if (!RequiresProperty || 2230 Selector.Kind == TraitSelector::user_condition) 2231 continue; 2232 2233 for (const OMPTraitProperty &Property : Selector.Properties) 2234 OS << '$' << 'P' << getOpenMPContextTraitPropertyName(Property.Kind); 2235 } 2236 } 2237 return OS.str(); 2238 } 2239 2240 OMPTraitInfo::OMPTraitInfo(StringRef MangledName) { 2241 unsigned long U; 2242 do { 2243 if (!MangledName.consume_front("$S")) 2244 break; 2245 if (MangledName.consumeInteger(10, U)) 2246 break; 2247 Sets.push_back(OMPTraitSet()); 2248 OMPTraitSet &Set = Sets.back(); 2249 Set.Kind = TraitSet(U); 2250 do { 2251 if (!MangledName.consume_front("$s")) 2252 break; 2253 if (MangledName.consumeInteger(10, U)) 2254 break; 2255 Set.Selectors.push_back(OMPTraitSelector()); 2256 OMPTraitSelector &Selector = Set.Selectors.back(); 2257 Selector.Kind = TraitSelector(U); 2258 do { 2259 if (!MangledName.consume_front("$P")) 2260 break; 2261 Selector.Properties.push_back(OMPTraitProperty()); 2262 OMPTraitProperty &Property = Selector.Properties.back(); 2263 std::pair<StringRef, StringRef> PropRestPair = MangledName.split('$'); 2264 Property.Kind = 2265 getOpenMPContextTraitPropertyKind(Set.Kind, PropRestPair.first); 2266 MangledName = PropRestPair.second; 2267 } while (true); 2268 } while (true); 2269 } while (true); 2270 } 2271 2272 llvm::raw_ostream &clang::operator<<(llvm::raw_ostream &OS, 2273 const OMPTraitInfo &TI) { 2274 LangOptions LO; 2275 PrintingPolicy Policy(LO); 2276 TI.print(OS, Policy); 2277 return OS; 2278 } 2279 llvm::raw_ostream &clang::operator<<(llvm::raw_ostream &OS, 2280 const OMPTraitInfo *TI) { 2281 return TI ? OS << *TI : OS; 2282 } 2283