1 //===--- StmtOpenMP.cpp - Classes for OpenMP directives -------------------===// 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 StmtOpenMP.h 10 // 11 //===----------------------------------------------------------------------===// 12 13 #include "clang/AST/ASTContext.h" 14 #include "clang/AST/StmtOpenMP.h" 15 16 using namespace clang; 17 using namespace llvm::omp; 18 19 size_t OMPChildren::size(unsigned NumClauses, bool HasAssociatedStmt, 20 unsigned NumChildren) { 21 return llvm::alignTo( 22 totalSizeToAlloc<OMPClause *, Stmt *>( 23 NumClauses, NumChildren + (HasAssociatedStmt ? 1 : 0)), 24 alignof(OMPChildren)); 25 } 26 27 void OMPChildren::setClauses(ArrayRef<OMPClause *> Clauses) { 28 assert(Clauses.size() == NumClauses && 29 "Number of clauses is not the same as the preallocated buffer"); 30 llvm::copy(Clauses, getTrailingObjects<OMPClause *>()); 31 } 32 33 MutableArrayRef<Stmt *> OMPChildren::getChildren() { 34 return llvm::makeMutableArrayRef(getTrailingObjects<Stmt *>(), NumChildren); 35 } 36 37 OMPChildren *OMPChildren::Create(void *Mem, ArrayRef<OMPClause *> Clauses) { 38 auto *Data = CreateEmpty(Mem, Clauses.size()); 39 Data->setClauses(Clauses); 40 return Data; 41 } 42 43 OMPChildren *OMPChildren::Create(void *Mem, ArrayRef<OMPClause *> Clauses, 44 Stmt *S, unsigned NumChildren) { 45 auto *Data = CreateEmpty(Mem, Clauses.size(), S, NumChildren); 46 Data->setClauses(Clauses); 47 if (S) 48 Data->setAssociatedStmt(S); 49 return Data; 50 } 51 52 OMPChildren *OMPChildren::CreateEmpty(void *Mem, unsigned NumClauses, 53 bool HasAssociatedStmt, 54 unsigned NumChildren) { 55 return new (Mem) OMPChildren(NumClauses, NumChildren, HasAssociatedStmt); 56 } 57 58 bool OMPExecutableDirective::isStandaloneDirective() const { 59 // Special case: 'omp target enter data', 'omp target exit data', 60 // 'omp target update' are stand-alone directives, but for implementation 61 // reasons they have empty synthetic structured block, to simplify codegen. 62 if (isa<OMPTargetEnterDataDirective>(this) || 63 isa<OMPTargetExitDataDirective>(this) || 64 isa<OMPTargetUpdateDirective>(this)) 65 return true; 66 return !hasAssociatedStmt(); 67 } 68 69 Stmt *OMPExecutableDirective::getStructuredBlock() { 70 assert(!isStandaloneDirective() && 71 "Standalone Executable Directives don't have Structured Blocks."); 72 if (auto *LD = dyn_cast<OMPLoopDirective>(this)) 73 return LD->getBody(); 74 return getRawStmt(); 75 } 76 77 Stmt * 78 OMPLoopBasedDirective::tryToFindNextInnerLoop(Stmt *CurStmt, 79 bool TryImperfectlyNestedLoops) { 80 Stmt *OrigStmt = CurStmt; 81 CurStmt = CurStmt->IgnoreContainers(); 82 // Additional work for imperfectly nested loops, introduced in OpenMP 5.0. 83 if (TryImperfectlyNestedLoops) { 84 if (auto *CS = dyn_cast<CompoundStmt>(CurStmt)) { 85 CurStmt = nullptr; 86 SmallVector<CompoundStmt *, 4> Statements(1, CS); 87 SmallVector<CompoundStmt *, 4> NextStatements; 88 while (!Statements.empty()) { 89 CS = Statements.pop_back_val(); 90 if (!CS) 91 continue; 92 for (Stmt *S : CS->body()) { 93 if (!S) 94 continue; 95 if (auto *CanonLoop = dyn_cast<OMPCanonicalLoop>(S)) 96 S = CanonLoop->getLoopStmt(); 97 if (isa<ForStmt>(S) || isa<CXXForRangeStmt>(S) || 98 (isa<OMPLoopBasedDirective>(S) && !isa<OMPLoopDirective>(S))) { 99 // Only single loop construct is allowed. 100 if (CurStmt) { 101 CurStmt = OrigStmt; 102 break; 103 } 104 CurStmt = S; 105 continue; 106 } 107 S = S->IgnoreContainers(); 108 if (auto *InnerCS = dyn_cast_or_null<CompoundStmt>(S)) 109 NextStatements.push_back(InnerCS); 110 } 111 if (Statements.empty()) { 112 // Found single inner loop or multiple loops - exit. 113 if (CurStmt) 114 break; 115 Statements.swap(NextStatements); 116 } 117 } 118 if (!CurStmt) 119 CurStmt = OrigStmt; 120 } 121 } 122 return CurStmt; 123 } 124 125 bool OMPLoopBasedDirective::doForAllLoops( 126 Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops, 127 llvm::function_ref<bool(unsigned, Stmt *)> Callback, 128 llvm::function_ref<void(OMPLoopBasedDirective *)> 129 OnTransformationCallback) { 130 CurStmt = CurStmt->IgnoreContainers(); 131 for (unsigned Cnt = 0; Cnt < NumLoops; ++Cnt) { 132 while (true) { 133 auto *OrigStmt = CurStmt; 134 if (auto *Dir = dyn_cast<OMPTileDirective>(OrigStmt)) { 135 OnTransformationCallback(Dir); 136 CurStmt = Dir->getTransformedStmt(); 137 } else if (auto *Dir = dyn_cast<OMPUnrollDirective>(OrigStmt)) { 138 OnTransformationCallback(Dir); 139 CurStmt = Dir->getTransformedStmt(); 140 } else { 141 break; 142 } 143 144 if (!CurStmt) { 145 // May happen if the loop transformation does not result in a generated 146 // loop (such as full unrolling). 147 CurStmt = OrigStmt; 148 break; 149 } 150 } 151 if (auto *CanonLoop = dyn_cast<OMPCanonicalLoop>(CurStmt)) 152 CurStmt = CanonLoop->getLoopStmt(); 153 if (Callback(Cnt, CurStmt)) 154 return false; 155 // Move on to the next nested for loop, or to the loop body. 156 // OpenMP [2.8.1, simd construct, Restrictions] 157 // All loops associated with the construct must be perfectly nested; that 158 // is, there must be no intervening code nor any OpenMP directive between 159 // any two loops. 160 if (auto *For = dyn_cast<ForStmt>(CurStmt)) { 161 CurStmt = For->getBody(); 162 } else { 163 assert(isa<CXXForRangeStmt>(CurStmt) && 164 "Expected canonical for or range-based for loops."); 165 CurStmt = cast<CXXForRangeStmt>(CurStmt)->getBody(); 166 } 167 CurStmt = OMPLoopBasedDirective::tryToFindNextInnerLoop( 168 CurStmt, TryImperfectlyNestedLoops); 169 } 170 return true; 171 } 172 173 void OMPLoopBasedDirective::doForAllLoopsBodies( 174 Stmt *CurStmt, bool TryImperfectlyNestedLoops, unsigned NumLoops, 175 llvm::function_ref<void(unsigned, Stmt *, Stmt *)> Callback) { 176 bool Res = OMPLoopBasedDirective::doForAllLoops( 177 CurStmt, TryImperfectlyNestedLoops, NumLoops, 178 [Callback](unsigned Cnt, Stmt *Loop) { 179 Stmt *Body = nullptr; 180 if (auto *For = dyn_cast<ForStmt>(Loop)) { 181 Body = For->getBody(); 182 } else { 183 assert(isa<CXXForRangeStmt>(Loop) && 184 "Expected canonical for or range-based for loops."); 185 Body = cast<CXXForRangeStmt>(Loop)->getBody(); 186 } 187 if (auto *CanonLoop = dyn_cast<OMPCanonicalLoop>(Body)) 188 Body = CanonLoop->getLoopStmt(); 189 Callback(Cnt, Loop, Body); 190 return false; 191 }); 192 assert(Res && "Expected only loops"); 193 (void)Res; 194 } 195 196 Stmt *OMPLoopDirective::getBody() { 197 // This relies on the loop form is already checked by Sema. 198 Stmt *Body = nullptr; 199 OMPLoopBasedDirective::doForAllLoopsBodies( 200 Data->getRawStmt(), /*TryImperfectlyNestedLoops=*/true, 201 NumAssociatedLoops, 202 [&Body](unsigned, Stmt *, Stmt *BodyStmt) { Body = BodyStmt; }); 203 return Body; 204 } 205 206 void OMPLoopDirective::setCounters(ArrayRef<Expr *> A) { 207 assert(A.size() == getLoopsNumber() && 208 "Number of loop counters is not the same as the collapsed number"); 209 llvm::copy(A, getCounters().begin()); 210 } 211 212 void OMPLoopDirective::setPrivateCounters(ArrayRef<Expr *> A) { 213 assert(A.size() == getLoopsNumber() && "Number of loop private counters " 214 "is not the same as the collapsed " 215 "number"); 216 llvm::copy(A, getPrivateCounters().begin()); 217 } 218 219 void OMPLoopDirective::setInits(ArrayRef<Expr *> A) { 220 assert(A.size() == getLoopsNumber() && 221 "Number of counter inits is not the same as the collapsed number"); 222 llvm::copy(A, getInits().begin()); 223 } 224 225 void OMPLoopDirective::setUpdates(ArrayRef<Expr *> A) { 226 assert(A.size() == getLoopsNumber() && 227 "Number of counter updates is not the same as the collapsed number"); 228 llvm::copy(A, getUpdates().begin()); 229 } 230 231 void OMPLoopDirective::setFinals(ArrayRef<Expr *> A) { 232 assert(A.size() == getLoopsNumber() && 233 "Number of counter finals is not the same as the collapsed number"); 234 llvm::copy(A, getFinals().begin()); 235 } 236 237 void OMPLoopDirective::setDependentCounters(ArrayRef<Expr *> A) { 238 assert( 239 A.size() == getLoopsNumber() && 240 "Number of dependent counters is not the same as the collapsed number"); 241 llvm::copy(A, getDependentCounters().begin()); 242 } 243 244 void OMPLoopDirective::setDependentInits(ArrayRef<Expr *> A) { 245 assert(A.size() == getLoopsNumber() && 246 "Number of dependent inits is not the same as the collapsed number"); 247 llvm::copy(A, getDependentInits().begin()); 248 } 249 250 void OMPLoopDirective::setFinalsConditions(ArrayRef<Expr *> A) { 251 assert(A.size() == getLoopsNumber() && 252 "Number of finals conditions is not the same as the collapsed number"); 253 llvm::copy(A, getFinalsConditions().begin()); 254 } 255 256 OMPParallelDirective *OMPParallelDirective::Create( 257 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 258 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, 259 bool HasCancel) { 260 auto *Dir = createDirective<OMPParallelDirective>( 261 C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); 262 Dir->setTaskReductionRefExpr(TaskRedRef); 263 Dir->setHasCancel(HasCancel); 264 return Dir; 265 } 266 267 OMPParallelDirective *OMPParallelDirective::CreateEmpty(const ASTContext &C, 268 unsigned NumClauses, 269 EmptyShell) { 270 return createEmptyDirective<OMPParallelDirective>(C, NumClauses, 271 /*HasAssociatedStmt=*/true, 272 /*NumChildren=*/1); 273 } 274 275 OMPSimdDirective * 276 OMPSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc, 277 SourceLocation EndLoc, unsigned CollapsedNum, 278 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 279 const HelperExprs &Exprs) { 280 auto *Dir = createDirective<OMPSimdDirective>( 281 C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_simd), 282 StartLoc, EndLoc, CollapsedNum); 283 Dir->setIterationVariable(Exprs.IterationVarRef); 284 Dir->setLastIteration(Exprs.LastIteration); 285 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 286 Dir->setPreCond(Exprs.PreCond); 287 Dir->setCond(Exprs.Cond); 288 Dir->setInit(Exprs.Init); 289 Dir->setInc(Exprs.Inc); 290 Dir->setCounters(Exprs.Counters); 291 Dir->setPrivateCounters(Exprs.PrivateCounters); 292 Dir->setInits(Exprs.Inits); 293 Dir->setUpdates(Exprs.Updates); 294 Dir->setFinals(Exprs.Finals); 295 Dir->setDependentCounters(Exprs.DependentCounters); 296 Dir->setDependentInits(Exprs.DependentInits); 297 Dir->setFinalsConditions(Exprs.FinalsConditions); 298 Dir->setPreInits(Exprs.PreInits); 299 return Dir; 300 } 301 302 OMPSimdDirective *OMPSimdDirective::CreateEmpty(const ASTContext &C, 303 unsigned NumClauses, 304 unsigned CollapsedNum, 305 EmptyShell) { 306 return createEmptyDirective<OMPSimdDirective>( 307 C, NumClauses, /*HasAssociatedStmt=*/true, 308 numLoopChildren(CollapsedNum, OMPD_simd), CollapsedNum); 309 } 310 311 OMPForDirective *OMPForDirective::Create( 312 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 313 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 314 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { 315 auto *Dir = createDirective<OMPForDirective>( 316 C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for) + 1, 317 StartLoc, EndLoc, CollapsedNum); 318 Dir->setIterationVariable(Exprs.IterationVarRef); 319 Dir->setLastIteration(Exprs.LastIteration); 320 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 321 Dir->setPreCond(Exprs.PreCond); 322 Dir->setCond(Exprs.Cond); 323 Dir->setInit(Exprs.Init); 324 Dir->setInc(Exprs.Inc); 325 Dir->setIsLastIterVariable(Exprs.IL); 326 Dir->setLowerBoundVariable(Exprs.LB); 327 Dir->setUpperBoundVariable(Exprs.UB); 328 Dir->setStrideVariable(Exprs.ST); 329 Dir->setEnsureUpperBound(Exprs.EUB); 330 Dir->setNextLowerBound(Exprs.NLB); 331 Dir->setNextUpperBound(Exprs.NUB); 332 Dir->setNumIterations(Exprs.NumIterations); 333 Dir->setCounters(Exprs.Counters); 334 Dir->setPrivateCounters(Exprs.PrivateCounters); 335 Dir->setInits(Exprs.Inits); 336 Dir->setUpdates(Exprs.Updates); 337 Dir->setFinals(Exprs.Finals); 338 Dir->setDependentCounters(Exprs.DependentCounters); 339 Dir->setDependentInits(Exprs.DependentInits); 340 Dir->setFinalsConditions(Exprs.FinalsConditions); 341 Dir->setPreInits(Exprs.PreInits); 342 Dir->setTaskReductionRefExpr(TaskRedRef); 343 Dir->setHasCancel(HasCancel); 344 return Dir; 345 } 346 347 OMPForDirective *OMPForDirective::CreateEmpty(const ASTContext &C, 348 unsigned NumClauses, 349 unsigned CollapsedNum, 350 EmptyShell) { 351 return createEmptyDirective<OMPForDirective>( 352 C, NumClauses, /*HasAssociatedStmt=*/true, 353 numLoopChildren(CollapsedNum, OMPD_for) + 1, CollapsedNum); 354 } 355 356 OMPTileDirective * 357 OMPTileDirective::Create(const ASTContext &C, SourceLocation StartLoc, 358 SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses, 359 unsigned NumLoops, Stmt *AssociatedStmt, 360 Stmt *TransformedStmt, Stmt *PreInits) { 361 OMPTileDirective *Dir = createDirective<OMPTileDirective>( 362 C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc, 363 NumLoops); 364 Dir->setTransformedStmt(TransformedStmt); 365 Dir->setPreInits(PreInits); 366 return Dir; 367 } 368 369 OMPTileDirective *OMPTileDirective::CreateEmpty(const ASTContext &C, 370 unsigned NumClauses, 371 unsigned NumLoops) { 372 return createEmptyDirective<OMPTileDirective>( 373 C, NumClauses, /*HasAssociatedStmt=*/true, TransformedStmtOffset + 1, 374 SourceLocation(), SourceLocation(), NumLoops); 375 } 376 377 OMPUnrollDirective * 378 OMPUnrollDirective::Create(const ASTContext &C, SourceLocation StartLoc, 379 SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses, 380 Stmt *AssociatedStmt, Stmt *TransformedStmt, 381 Stmt *PreInits) { 382 auto *Dir = createDirective<OMPUnrollDirective>( 383 C, Clauses, AssociatedStmt, TransformedStmtOffset + 1, StartLoc, EndLoc); 384 Dir->setTransformedStmt(TransformedStmt); 385 Dir->setPreInits(PreInits); 386 return Dir; 387 } 388 389 OMPUnrollDirective *OMPUnrollDirective::CreateEmpty(const ASTContext &C, 390 unsigned NumClauses) { 391 return createEmptyDirective<OMPUnrollDirective>( 392 C, NumClauses, /*HasAssociatedStmt=*/true, TransformedStmtOffset + 1, 393 SourceLocation(), SourceLocation()); 394 } 395 396 OMPForSimdDirective * 397 OMPForSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc, 398 SourceLocation EndLoc, unsigned CollapsedNum, 399 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 400 const HelperExprs &Exprs) { 401 auto *Dir = createDirective<OMPForSimdDirective>( 402 C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_for_simd), 403 StartLoc, EndLoc, CollapsedNum); 404 Dir->setIterationVariable(Exprs.IterationVarRef); 405 Dir->setLastIteration(Exprs.LastIteration); 406 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 407 Dir->setPreCond(Exprs.PreCond); 408 Dir->setCond(Exprs.Cond); 409 Dir->setInit(Exprs.Init); 410 Dir->setInc(Exprs.Inc); 411 Dir->setIsLastIterVariable(Exprs.IL); 412 Dir->setLowerBoundVariable(Exprs.LB); 413 Dir->setUpperBoundVariable(Exprs.UB); 414 Dir->setStrideVariable(Exprs.ST); 415 Dir->setEnsureUpperBound(Exprs.EUB); 416 Dir->setNextLowerBound(Exprs.NLB); 417 Dir->setNextUpperBound(Exprs.NUB); 418 Dir->setNumIterations(Exprs.NumIterations); 419 Dir->setCounters(Exprs.Counters); 420 Dir->setPrivateCounters(Exprs.PrivateCounters); 421 Dir->setInits(Exprs.Inits); 422 Dir->setUpdates(Exprs.Updates); 423 Dir->setFinals(Exprs.Finals); 424 Dir->setDependentCounters(Exprs.DependentCounters); 425 Dir->setDependentInits(Exprs.DependentInits); 426 Dir->setFinalsConditions(Exprs.FinalsConditions); 427 Dir->setPreInits(Exprs.PreInits); 428 return Dir; 429 } 430 431 OMPForSimdDirective *OMPForSimdDirective::CreateEmpty(const ASTContext &C, 432 unsigned NumClauses, 433 unsigned CollapsedNum, 434 EmptyShell) { 435 return createEmptyDirective<OMPForSimdDirective>( 436 C, NumClauses, /*HasAssociatedStmt=*/true, 437 numLoopChildren(CollapsedNum, OMPD_for_simd), CollapsedNum); 438 } 439 440 OMPSectionsDirective *OMPSectionsDirective::Create( 441 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 442 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, 443 bool HasCancel) { 444 auto *Dir = createDirective<OMPSectionsDirective>(C, Clauses, AssociatedStmt, 445 /*NumChildren=*/1, StartLoc, 446 EndLoc); 447 Dir->setTaskReductionRefExpr(TaskRedRef); 448 Dir->setHasCancel(HasCancel); 449 return Dir; 450 } 451 452 OMPSectionsDirective *OMPSectionsDirective::CreateEmpty(const ASTContext &C, 453 unsigned NumClauses, 454 EmptyShell) { 455 return createEmptyDirective<OMPSectionsDirective>(C, NumClauses, 456 /*HasAssociatedStmt=*/true, 457 /*NumChildren=*/1); 458 } 459 460 OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C, 461 SourceLocation StartLoc, 462 SourceLocation EndLoc, 463 Stmt *AssociatedStmt, 464 bool HasCancel) { 465 auto *Dir = 466 createDirective<OMPSectionDirective>(C, llvm::None, AssociatedStmt, 467 /*NumChildre=*/0, StartLoc, EndLoc); 468 Dir->setHasCancel(HasCancel); 469 return Dir; 470 } 471 472 OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C, 473 EmptyShell) { 474 return createEmptyDirective<OMPSectionDirective>(C, /*NumClauses=*/0, 475 /*HasAssociatedStmt=*/true); 476 } 477 478 OMPSingleDirective *OMPSingleDirective::Create(const ASTContext &C, 479 SourceLocation StartLoc, 480 SourceLocation EndLoc, 481 ArrayRef<OMPClause *> Clauses, 482 Stmt *AssociatedStmt) { 483 return createDirective<OMPSingleDirective>(C, Clauses, AssociatedStmt, 484 /*NumChildren=*/0, StartLoc, 485 EndLoc); 486 } 487 488 OMPSingleDirective *OMPSingleDirective::CreateEmpty(const ASTContext &C, 489 unsigned NumClauses, 490 EmptyShell) { 491 return createEmptyDirective<OMPSingleDirective>(C, NumClauses, 492 /*HasAssociatedStmt=*/true); 493 } 494 495 OMPMasterDirective *OMPMasterDirective::Create(const ASTContext &C, 496 SourceLocation StartLoc, 497 SourceLocation EndLoc, 498 Stmt *AssociatedStmt) { 499 return createDirective<OMPMasterDirective>(C, llvm::None, AssociatedStmt, 500 /*NumChildren=*/0, StartLoc, 501 EndLoc); 502 } 503 504 OMPMasterDirective *OMPMasterDirective::CreateEmpty(const ASTContext &C, 505 EmptyShell) { 506 return createEmptyDirective<OMPMasterDirective>(C, /*NumClauses=*/0, 507 /*HasAssociatedStmt=*/true); 508 } 509 510 OMPCriticalDirective *OMPCriticalDirective::Create( 511 const ASTContext &C, const DeclarationNameInfo &Name, 512 SourceLocation StartLoc, SourceLocation EndLoc, 513 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) { 514 return createDirective<OMPCriticalDirective>(C, Clauses, AssociatedStmt, 515 /*NumChildren=*/0, Name, 516 StartLoc, EndLoc); 517 } 518 519 OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C, 520 unsigned NumClauses, 521 EmptyShell) { 522 return createEmptyDirective<OMPCriticalDirective>(C, NumClauses, 523 /*HasAssociatedStmt=*/true); 524 } 525 526 OMPParallelForDirective *OMPParallelForDirective::Create( 527 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 528 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 529 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { 530 auto *Dir = createDirective<OMPParallelForDirective>( 531 C, Clauses, AssociatedStmt, 532 numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, StartLoc, EndLoc, 533 CollapsedNum); 534 Dir->setIterationVariable(Exprs.IterationVarRef); 535 Dir->setLastIteration(Exprs.LastIteration); 536 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 537 Dir->setPreCond(Exprs.PreCond); 538 Dir->setCond(Exprs.Cond); 539 Dir->setInit(Exprs.Init); 540 Dir->setInc(Exprs.Inc); 541 Dir->setIsLastIterVariable(Exprs.IL); 542 Dir->setLowerBoundVariable(Exprs.LB); 543 Dir->setUpperBoundVariable(Exprs.UB); 544 Dir->setStrideVariable(Exprs.ST); 545 Dir->setEnsureUpperBound(Exprs.EUB); 546 Dir->setNextLowerBound(Exprs.NLB); 547 Dir->setNextUpperBound(Exprs.NUB); 548 Dir->setNumIterations(Exprs.NumIterations); 549 Dir->setCounters(Exprs.Counters); 550 Dir->setPrivateCounters(Exprs.PrivateCounters); 551 Dir->setInits(Exprs.Inits); 552 Dir->setUpdates(Exprs.Updates); 553 Dir->setFinals(Exprs.Finals); 554 Dir->setDependentCounters(Exprs.DependentCounters); 555 Dir->setDependentInits(Exprs.DependentInits); 556 Dir->setFinalsConditions(Exprs.FinalsConditions); 557 Dir->setPreInits(Exprs.PreInits); 558 Dir->setTaskReductionRefExpr(TaskRedRef); 559 Dir->setHasCancel(HasCancel); 560 return Dir; 561 } 562 563 OMPParallelForDirective * 564 OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, 565 unsigned CollapsedNum, EmptyShell) { 566 return createEmptyDirective<OMPParallelForDirective>( 567 C, NumClauses, /*HasAssociatedStmt=*/true, 568 numLoopChildren(CollapsedNum, OMPD_parallel_for) + 1, CollapsedNum); 569 } 570 571 OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create( 572 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 573 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 574 const HelperExprs &Exprs) { 575 auto *Dir = createDirective<OMPParallelForSimdDirective>( 576 C, Clauses, AssociatedStmt, 577 numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), StartLoc, EndLoc, 578 CollapsedNum); 579 Dir->setIterationVariable(Exprs.IterationVarRef); 580 Dir->setLastIteration(Exprs.LastIteration); 581 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 582 Dir->setPreCond(Exprs.PreCond); 583 Dir->setCond(Exprs.Cond); 584 Dir->setInit(Exprs.Init); 585 Dir->setInc(Exprs.Inc); 586 Dir->setIsLastIterVariable(Exprs.IL); 587 Dir->setLowerBoundVariable(Exprs.LB); 588 Dir->setUpperBoundVariable(Exprs.UB); 589 Dir->setStrideVariable(Exprs.ST); 590 Dir->setEnsureUpperBound(Exprs.EUB); 591 Dir->setNextLowerBound(Exprs.NLB); 592 Dir->setNextUpperBound(Exprs.NUB); 593 Dir->setNumIterations(Exprs.NumIterations); 594 Dir->setCounters(Exprs.Counters); 595 Dir->setPrivateCounters(Exprs.PrivateCounters); 596 Dir->setInits(Exprs.Inits); 597 Dir->setUpdates(Exprs.Updates); 598 Dir->setFinals(Exprs.Finals); 599 Dir->setDependentCounters(Exprs.DependentCounters); 600 Dir->setDependentInits(Exprs.DependentInits); 601 Dir->setFinalsConditions(Exprs.FinalsConditions); 602 Dir->setPreInits(Exprs.PreInits); 603 return Dir; 604 } 605 606 OMPParallelForSimdDirective * 607 OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C, 608 unsigned NumClauses, 609 unsigned CollapsedNum, EmptyShell) { 610 return createEmptyDirective<OMPParallelForSimdDirective>( 611 C, NumClauses, /*HasAssociatedStmt=*/true, 612 numLoopChildren(CollapsedNum, OMPD_parallel_for_simd), CollapsedNum); 613 } 614 615 OMPParallelMasterDirective *OMPParallelMasterDirective::Create( 616 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 617 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef) { 618 auto *Dir = createDirective<OMPParallelMasterDirective>( 619 C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); 620 Dir->setTaskReductionRefExpr(TaskRedRef); 621 return Dir; 622 } 623 624 OMPParallelMasterDirective * 625 OMPParallelMasterDirective::CreateEmpty(const ASTContext &C, 626 unsigned NumClauses, EmptyShell) { 627 return createEmptyDirective<OMPParallelMasterDirective>( 628 C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1); 629 } 630 631 OMPParallelSectionsDirective *OMPParallelSectionsDirective::Create( 632 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 633 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, 634 bool HasCancel) { 635 auto *Dir = createDirective<OMPParallelSectionsDirective>( 636 C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); 637 Dir->setTaskReductionRefExpr(TaskRedRef); 638 Dir->setHasCancel(HasCancel); 639 return Dir; 640 } 641 642 OMPParallelSectionsDirective * 643 OMPParallelSectionsDirective::CreateEmpty(const ASTContext &C, 644 unsigned NumClauses, EmptyShell) { 645 return createEmptyDirective<OMPParallelSectionsDirective>( 646 C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1); 647 } 648 649 OMPTaskDirective * 650 OMPTaskDirective::Create(const ASTContext &C, SourceLocation StartLoc, 651 SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses, 652 Stmt *AssociatedStmt, bool HasCancel) { 653 auto *Dir = createDirective<OMPTaskDirective>( 654 C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); 655 Dir->setHasCancel(HasCancel); 656 return Dir; 657 } 658 659 OMPTaskDirective *OMPTaskDirective::CreateEmpty(const ASTContext &C, 660 unsigned NumClauses, 661 EmptyShell) { 662 return createEmptyDirective<OMPTaskDirective>(C, NumClauses, 663 /*HasAssociatedStmt=*/true); 664 } 665 666 OMPTaskyieldDirective *OMPTaskyieldDirective::Create(const ASTContext &C, 667 SourceLocation StartLoc, 668 SourceLocation EndLoc) { 669 return new (C) OMPTaskyieldDirective(StartLoc, EndLoc); 670 } 671 672 OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C, 673 EmptyShell) { 674 return new (C) OMPTaskyieldDirective(); 675 } 676 677 OMPBarrierDirective *OMPBarrierDirective::Create(const ASTContext &C, 678 SourceLocation StartLoc, 679 SourceLocation EndLoc) { 680 return new (C) OMPBarrierDirective(StartLoc, EndLoc); 681 } 682 683 OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C, 684 EmptyShell) { 685 return new (C) OMPBarrierDirective(); 686 } 687 688 OMPTaskwaitDirective *OMPTaskwaitDirective::Create(const ASTContext &C, 689 SourceLocation StartLoc, 690 SourceLocation EndLoc) { 691 return new (C) OMPTaskwaitDirective(StartLoc, EndLoc); 692 } 693 694 OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C, 695 EmptyShell) { 696 return new (C) OMPTaskwaitDirective(); 697 } 698 699 OMPTaskgroupDirective *OMPTaskgroupDirective::Create( 700 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 701 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *ReductionRef) { 702 auto *Dir = createDirective<OMPTaskgroupDirective>( 703 C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); 704 Dir->setReductionRef(ReductionRef); 705 return Dir; 706 } 707 708 OMPTaskgroupDirective *OMPTaskgroupDirective::CreateEmpty(const ASTContext &C, 709 unsigned NumClauses, 710 EmptyShell) { 711 return createEmptyDirective<OMPTaskgroupDirective>( 712 C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1); 713 } 714 715 OMPCancellationPointDirective *OMPCancellationPointDirective::Create( 716 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 717 OpenMPDirectiveKind CancelRegion) { 718 auto *Dir = new (C) OMPCancellationPointDirective(StartLoc, EndLoc); 719 Dir->setCancelRegion(CancelRegion); 720 return Dir; 721 } 722 723 OMPCancellationPointDirective * 724 OMPCancellationPointDirective::CreateEmpty(const ASTContext &C, EmptyShell) { 725 return new (C) OMPCancellationPointDirective(); 726 } 727 728 OMPCancelDirective * 729 OMPCancelDirective::Create(const ASTContext &C, SourceLocation StartLoc, 730 SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses, 731 OpenMPDirectiveKind CancelRegion) { 732 auto *Dir = createDirective<OMPCancelDirective>( 733 C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc, 734 EndLoc); 735 Dir->setCancelRegion(CancelRegion); 736 return Dir; 737 } 738 739 OMPCancelDirective *OMPCancelDirective::CreateEmpty(const ASTContext &C, 740 unsigned NumClauses, 741 EmptyShell) { 742 return createEmptyDirective<OMPCancelDirective>(C, NumClauses); 743 } 744 745 OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C, 746 SourceLocation StartLoc, 747 SourceLocation EndLoc, 748 ArrayRef<OMPClause *> Clauses) { 749 return createDirective<OMPFlushDirective>( 750 C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc, 751 EndLoc); 752 } 753 754 OMPFlushDirective *OMPFlushDirective::CreateEmpty(const ASTContext &C, 755 unsigned NumClauses, 756 EmptyShell) { 757 return createEmptyDirective<OMPFlushDirective>(C, NumClauses); 758 } 759 760 OMPDepobjDirective *OMPDepobjDirective::Create(const ASTContext &C, 761 SourceLocation StartLoc, 762 SourceLocation EndLoc, 763 ArrayRef<OMPClause *> Clauses) { 764 return createDirective<OMPDepobjDirective>( 765 C, Clauses, /*AssociatedStmt=*/nullptr, 766 /*NumChildren=*/0, StartLoc, EndLoc); 767 } 768 769 OMPDepobjDirective *OMPDepobjDirective::CreateEmpty(const ASTContext &C, 770 unsigned NumClauses, 771 EmptyShell) { 772 return createEmptyDirective<OMPDepobjDirective>(C, NumClauses); 773 } 774 775 OMPScanDirective *OMPScanDirective::Create(const ASTContext &C, 776 SourceLocation StartLoc, 777 SourceLocation EndLoc, 778 ArrayRef<OMPClause *> Clauses) { 779 return createDirective<OMPScanDirective>(C, Clauses, 780 /*AssociatedStmt=*/nullptr, 781 /*NumChildren=*/0, StartLoc, EndLoc); 782 } 783 784 OMPScanDirective *OMPScanDirective::CreateEmpty(const ASTContext &C, 785 unsigned NumClauses, 786 EmptyShell) { 787 return createEmptyDirective<OMPScanDirective>(C, NumClauses); 788 } 789 790 OMPOrderedDirective *OMPOrderedDirective::Create(const ASTContext &C, 791 SourceLocation StartLoc, 792 SourceLocation EndLoc, 793 ArrayRef<OMPClause *> Clauses, 794 Stmt *AssociatedStmt) { 795 return createDirective<OMPOrderedDirective>( 796 C, Clauses, cast_or_null<CapturedStmt>(AssociatedStmt), 797 /*NumChildren=*/0, StartLoc, EndLoc); 798 } 799 800 OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(const ASTContext &C, 801 unsigned NumClauses, 802 bool IsStandalone, 803 EmptyShell) { 804 return createEmptyDirective<OMPOrderedDirective>(C, NumClauses, 805 !IsStandalone); 806 } 807 808 OMPAtomicDirective *OMPAtomicDirective::Create( 809 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 810 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V, 811 Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) { 812 auto *Dir = createDirective<OMPAtomicDirective>( 813 C, Clauses, AssociatedStmt, /*NumChildren=*/4, StartLoc, EndLoc); 814 Dir->setX(X); 815 Dir->setV(V); 816 Dir->setExpr(E); 817 Dir->setUpdateExpr(UE); 818 Dir->IsXLHSInRHSPart = IsXLHSInRHSPart; 819 Dir->IsPostfixUpdate = IsPostfixUpdate; 820 return Dir; 821 } 822 823 OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C, 824 unsigned NumClauses, 825 EmptyShell) { 826 return createEmptyDirective<OMPAtomicDirective>( 827 C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/4); 828 } 829 830 OMPTargetDirective *OMPTargetDirective::Create(const ASTContext &C, 831 SourceLocation StartLoc, 832 SourceLocation EndLoc, 833 ArrayRef<OMPClause *> Clauses, 834 Stmt *AssociatedStmt) { 835 return createDirective<OMPTargetDirective>( 836 C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); 837 } 838 839 OMPTargetDirective *OMPTargetDirective::CreateEmpty(const ASTContext &C, 840 unsigned NumClauses, 841 EmptyShell) { 842 return createEmptyDirective<OMPTargetDirective>(C, NumClauses, 843 /*HasAssociatedStmt=*/true); 844 } 845 846 OMPTargetParallelDirective *OMPTargetParallelDirective::Create( 847 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 848 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *TaskRedRef, 849 bool HasCancel) { 850 auto *Dir = createDirective<OMPTargetParallelDirective>( 851 C, Clauses, AssociatedStmt, /*NumChildren=*/1, StartLoc, EndLoc); 852 Dir->setTaskReductionRefExpr(TaskRedRef); 853 Dir->setHasCancel(HasCancel); 854 return Dir; 855 } 856 857 OMPTargetParallelDirective * 858 OMPTargetParallelDirective::CreateEmpty(const ASTContext &C, 859 unsigned NumClauses, EmptyShell) { 860 return createEmptyDirective<OMPTargetParallelDirective>( 861 C, NumClauses, /*HasAssociatedStmt=*/true, /*NumChildren=*/1); 862 } 863 864 OMPTargetParallelForDirective *OMPTargetParallelForDirective::Create( 865 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 866 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 867 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { 868 auto *Dir = createDirective<OMPTargetParallelForDirective>( 869 C, Clauses, AssociatedStmt, 870 numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1, StartLoc, 871 EndLoc, CollapsedNum); 872 Dir->setIterationVariable(Exprs.IterationVarRef); 873 Dir->setLastIteration(Exprs.LastIteration); 874 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 875 Dir->setPreCond(Exprs.PreCond); 876 Dir->setCond(Exprs.Cond); 877 Dir->setInit(Exprs.Init); 878 Dir->setInc(Exprs.Inc); 879 Dir->setIsLastIterVariable(Exprs.IL); 880 Dir->setLowerBoundVariable(Exprs.LB); 881 Dir->setUpperBoundVariable(Exprs.UB); 882 Dir->setStrideVariable(Exprs.ST); 883 Dir->setEnsureUpperBound(Exprs.EUB); 884 Dir->setNextLowerBound(Exprs.NLB); 885 Dir->setNextUpperBound(Exprs.NUB); 886 Dir->setNumIterations(Exprs.NumIterations); 887 Dir->setCounters(Exprs.Counters); 888 Dir->setPrivateCounters(Exprs.PrivateCounters); 889 Dir->setInits(Exprs.Inits); 890 Dir->setUpdates(Exprs.Updates); 891 Dir->setFinals(Exprs.Finals); 892 Dir->setDependentCounters(Exprs.DependentCounters); 893 Dir->setDependentInits(Exprs.DependentInits); 894 Dir->setFinalsConditions(Exprs.FinalsConditions); 895 Dir->setPreInits(Exprs.PreInits); 896 Dir->setTaskReductionRefExpr(TaskRedRef); 897 Dir->setHasCancel(HasCancel); 898 return Dir; 899 } 900 901 OMPTargetParallelForDirective * 902 OMPTargetParallelForDirective::CreateEmpty(const ASTContext &C, 903 unsigned NumClauses, 904 unsigned CollapsedNum, EmptyShell) { 905 return createEmptyDirective<OMPTargetParallelForDirective>( 906 C, NumClauses, /*HasAssociatedStmt=*/true, 907 numLoopChildren(CollapsedNum, OMPD_target_parallel_for) + 1, 908 CollapsedNum); 909 } 910 911 OMPTargetDataDirective *OMPTargetDataDirective::Create( 912 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 913 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) { 914 return createDirective<OMPTargetDataDirective>( 915 C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); 916 } 917 918 OMPTargetDataDirective *OMPTargetDataDirective::CreateEmpty(const ASTContext &C, 919 unsigned N, 920 EmptyShell) { 921 return createEmptyDirective<OMPTargetDataDirective>( 922 C, N, /*HasAssociatedStmt=*/true); 923 } 924 925 OMPTargetEnterDataDirective *OMPTargetEnterDataDirective::Create( 926 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 927 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) { 928 return createDirective<OMPTargetEnterDataDirective>( 929 C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); 930 } 931 932 OMPTargetEnterDataDirective * 933 OMPTargetEnterDataDirective::CreateEmpty(const ASTContext &C, unsigned N, 934 EmptyShell) { 935 return createEmptyDirective<OMPTargetEnterDataDirective>( 936 C, N, /*HasAssociatedStmt=*/true); 937 } 938 939 OMPTargetExitDataDirective *OMPTargetExitDataDirective::Create( 940 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 941 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) { 942 return createDirective<OMPTargetExitDataDirective>( 943 C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); 944 } 945 946 OMPTargetExitDataDirective * 947 OMPTargetExitDataDirective::CreateEmpty(const ASTContext &C, unsigned N, 948 EmptyShell) { 949 return createEmptyDirective<OMPTargetExitDataDirective>( 950 C, N, /*HasAssociatedStmt=*/true); 951 } 952 953 OMPTeamsDirective *OMPTeamsDirective::Create(const ASTContext &C, 954 SourceLocation StartLoc, 955 SourceLocation EndLoc, 956 ArrayRef<OMPClause *> Clauses, 957 Stmt *AssociatedStmt) { 958 return createDirective<OMPTeamsDirective>( 959 C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); 960 } 961 962 OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C, 963 unsigned NumClauses, 964 EmptyShell) { 965 return createEmptyDirective<OMPTeamsDirective>(C, NumClauses, 966 /*HasAssociatedStmt=*/true); 967 } 968 969 OMPTaskLoopDirective *OMPTaskLoopDirective::Create( 970 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 971 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 972 const HelperExprs &Exprs, bool HasCancel) { 973 auto *Dir = createDirective<OMPTaskLoopDirective>( 974 C, Clauses, AssociatedStmt, numLoopChildren(CollapsedNum, OMPD_taskloop), 975 StartLoc, EndLoc, CollapsedNum); 976 Dir->setIterationVariable(Exprs.IterationVarRef); 977 Dir->setLastIteration(Exprs.LastIteration); 978 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 979 Dir->setPreCond(Exprs.PreCond); 980 Dir->setCond(Exprs.Cond); 981 Dir->setInit(Exprs.Init); 982 Dir->setInc(Exprs.Inc); 983 Dir->setIsLastIterVariable(Exprs.IL); 984 Dir->setLowerBoundVariable(Exprs.LB); 985 Dir->setUpperBoundVariable(Exprs.UB); 986 Dir->setStrideVariable(Exprs.ST); 987 Dir->setEnsureUpperBound(Exprs.EUB); 988 Dir->setNextLowerBound(Exprs.NLB); 989 Dir->setNextUpperBound(Exprs.NUB); 990 Dir->setNumIterations(Exprs.NumIterations); 991 Dir->setCounters(Exprs.Counters); 992 Dir->setPrivateCounters(Exprs.PrivateCounters); 993 Dir->setInits(Exprs.Inits); 994 Dir->setUpdates(Exprs.Updates); 995 Dir->setFinals(Exprs.Finals); 996 Dir->setDependentCounters(Exprs.DependentCounters); 997 Dir->setDependentInits(Exprs.DependentInits); 998 Dir->setFinalsConditions(Exprs.FinalsConditions); 999 Dir->setPreInits(Exprs.PreInits); 1000 Dir->setHasCancel(HasCancel); 1001 return Dir; 1002 } 1003 1004 OMPTaskLoopDirective *OMPTaskLoopDirective::CreateEmpty(const ASTContext &C, 1005 unsigned NumClauses, 1006 unsigned CollapsedNum, 1007 EmptyShell) { 1008 return createEmptyDirective<OMPTaskLoopDirective>( 1009 C, NumClauses, /*HasAssociatedStmt=*/true, 1010 numLoopChildren(CollapsedNum, OMPD_taskloop), CollapsedNum); 1011 } 1012 1013 OMPTaskLoopSimdDirective *OMPTaskLoopSimdDirective::Create( 1014 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1015 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1016 const HelperExprs &Exprs) { 1017 auto *Dir = createDirective<OMPTaskLoopSimdDirective>( 1018 C, Clauses, AssociatedStmt, 1019 numLoopChildren(CollapsedNum, OMPD_taskloop_simd), StartLoc, EndLoc, 1020 CollapsedNum); 1021 Dir->setIterationVariable(Exprs.IterationVarRef); 1022 Dir->setLastIteration(Exprs.LastIteration); 1023 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1024 Dir->setPreCond(Exprs.PreCond); 1025 Dir->setCond(Exprs.Cond); 1026 Dir->setInit(Exprs.Init); 1027 Dir->setInc(Exprs.Inc); 1028 Dir->setIsLastIterVariable(Exprs.IL); 1029 Dir->setLowerBoundVariable(Exprs.LB); 1030 Dir->setUpperBoundVariable(Exprs.UB); 1031 Dir->setStrideVariable(Exprs.ST); 1032 Dir->setEnsureUpperBound(Exprs.EUB); 1033 Dir->setNextLowerBound(Exprs.NLB); 1034 Dir->setNextUpperBound(Exprs.NUB); 1035 Dir->setNumIterations(Exprs.NumIterations); 1036 Dir->setCounters(Exprs.Counters); 1037 Dir->setPrivateCounters(Exprs.PrivateCounters); 1038 Dir->setInits(Exprs.Inits); 1039 Dir->setUpdates(Exprs.Updates); 1040 Dir->setFinals(Exprs.Finals); 1041 Dir->setDependentCounters(Exprs.DependentCounters); 1042 Dir->setDependentInits(Exprs.DependentInits); 1043 Dir->setFinalsConditions(Exprs.FinalsConditions); 1044 Dir->setPreInits(Exprs.PreInits); 1045 return Dir; 1046 } 1047 1048 OMPTaskLoopSimdDirective * 1049 OMPTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, 1050 unsigned CollapsedNum, EmptyShell) { 1051 return createEmptyDirective<OMPTaskLoopSimdDirective>( 1052 C, NumClauses, /*HasAssociatedStmt=*/true, 1053 numLoopChildren(CollapsedNum, OMPD_taskloop_simd), CollapsedNum); 1054 } 1055 1056 OMPMasterTaskLoopDirective *OMPMasterTaskLoopDirective::Create( 1057 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1058 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1059 const HelperExprs &Exprs, bool HasCancel) { 1060 auto *Dir = createDirective<OMPMasterTaskLoopDirective>( 1061 C, Clauses, AssociatedStmt, 1062 numLoopChildren(CollapsedNum, OMPD_master_taskloop), StartLoc, EndLoc, 1063 CollapsedNum); 1064 Dir->setIterationVariable(Exprs.IterationVarRef); 1065 Dir->setLastIteration(Exprs.LastIteration); 1066 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1067 Dir->setPreCond(Exprs.PreCond); 1068 Dir->setCond(Exprs.Cond); 1069 Dir->setInit(Exprs.Init); 1070 Dir->setInc(Exprs.Inc); 1071 Dir->setIsLastIterVariable(Exprs.IL); 1072 Dir->setLowerBoundVariable(Exprs.LB); 1073 Dir->setUpperBoundVariable(Exprs.UB); 1074 Dir->setStrideVariable(Exprs.ST); 1075 Dir->setEnsureUpperBound(Exprs.EUB); 1076 Dir->setNextLowerBound(Exprs.NLB); 1077 Dir->setNextUpperBound(Exprs.NUB); 1078 Dir->setNumIterations(Exprs.NumIterations); 1079 Dir->setCounters(Exprs.Counters); 1080 Dir->setPrivateCounters(Exprs.PrivateCounters); 1081 Dir->setInits(Exprs.Inits); 1082 Dir->setUpdates(Exprs.Updates); 1083 Dir->setFinals(Exprs.Finals); 1084 Dir->setDependentCounters(Exprs.DependentCounters); 1085 Dir->setDependentInits(Exprs.DependentInits); 1086 Dir->setFinalsConditions(Exprs.FinalsConditions); 1087 Dir->setPreInits(Exprs.PreInits); 1088 Dir->setHasCancel(HasCancel); 1089 return Dir; 1090 } 1091 1092 OMPMasterTaskLoopDirective * 1093 OMPMasterTaskLoopDirective::CreateEmpty(const ASTContext &C, 1094 unsigned NumClauses, 1095 unsigned CollapsedNum, EmptyShell) { 1096 return createEmptyDirective<OMPMasterTaskLoopDirective>( 1097 C, NumClauses, /*HasAssociatedStmt=*/true, 1098 numLoopChildren(CollapsedNum, OMPD_master_taskloop), CollapsedNum); 1099 } 1100 1101 OMPMasterTaskLoopSimdDirective *OMPMasterTaskLoopSimdDirective::Create( 1102 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1103 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1104 const HelperExprs &Exprs) { 1105 auto *Dir = createDirective<OMPMasterTaskLoopSimdDirective>( 1106 C, Clauses, AssociatedStmt, 1107 numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), StartLoc, 1108 EndLoc, CollapsedNum); 1109 Dir->setIterationVariable(Exprs.IterationVarRef); 1110 Dir->setLastIteration(Exprs.LastIteration); 1111 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1112 Dir->setPreCond(Exprs.PreCond); 1113 Dir->setCond(Exprs.Cond); 1114 Dir->setInit(Exprs.Init); 1115 Dir->setInc(Exprs.Inc); 1116 Dir->setIsLastIterVariable(Exprs.IL); 1117 Dir->setLowerBoundVariable(Exprs.LB); 1118 Dir->setUpperBoundVariable(Exprs.UB); 1119 Dir->setStrideVariable(Exprs.ST); 1120 Dir->setEnsureUpperBound(Exprs.EUB); 1121 Dir->setNextLowerBound(Exprs.NLB); 1122 Dir->setNextUpperBound(Exprs.NUB); 1123 Dir->setNumIterations(Exprs.NumIterations); 1124 Dir->setCounters(Exprs.Counters); 1125 Dir->setPrivateCounters(Exprs.PrivateCounters); 1126 Dir->setInits(Exprs.Inits); 1127 Dir->setUpdates(Exprs.Updates); 1128 Dir->setFinals(Exprs.Finals); 1129 Dir->setDependentCounters(Exprs.DependentCounters); 1130 Dir->setDependentInits(Exprs.DependentInits); 1131 Dir->setFinalsConditions(Exprs.FinalsConditions); 1132 Dir->setPreInits(Exprs.PreInits); 1133 return Dir; 1134 } 1135 1136 OMPMasterTaskLoopSimdDirective * 1137 OMPMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, 1138 unsigned NumClauses, 1139 unsigned CollapsedNum, EmptyShell) { 1140 return createEmptyDirective<OMPMasterTaskLoopSimdDirective>( 1141 C, NumClauses, /*HasAssociatedStmt=*/true, 1142 numLoopChildren(CollapsedNum, OMPD_master_taskloop_simd), CollapsedNum); 1143 } 1144 1145 OMPParallelMasterTaskLoopDirective *OMPParallelMasterTaskLoopDirective::Create( 1146 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1147 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1148 const HelperExprs &Exprs, bool HasCancel) { 1149 auto *Dir = createDirective<OMPParallelMasterTaskLoopDirective>( 1150 C, Clauses, AssociatedStmt, 1151 numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop), StartLoc, 1152 EndLoc, CollapsedNum); 1153 Dir->setIterationVariable(Exprs.IterationVarRef); 1154 Dir->setLastIteration(Exprs.LastIteration); 1155 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1156 Dir->setPreCond(Exprs.PreCond); 1157 Dir->setCond(Exprs.Cond); 1158 Dir->setInit(Exprs.Init); 1159 Dir->setInc(Exprs.Inc); 1160 Dir->setIsLastIterVariable(Exprs.IL); 1161 Dir->setLowerBoundVariable(Exprs.LB); 1162 Dir->setUpperBoundVariable(Exprs.UB); 1163 Dir->setStrideVariable(Exprs.ST); 1164 Dir->setEnsureUpperBound(Exprs.EUB); 1165 Dir->setNextLowerBound(Exprs.NLB); 1166 Dir->setNextUpperBound(Exprs.NUB); 1167 Dir->setNumIterations(Exprs.NumIterations); 1168 Dir->setCounters(Exprs.Counters); 1169 Dir->setPrivateCounters(Exprs.PrivateCounters); 1170 Dir->setInits(Exprs.Inits); 1171 Dir->setUpdates(Exprs.Updates); 1172 Dir->setFinals(Exprs.Finals); 1173 Dir->setDependentCounters(Exprs.DependentCounters); 1174 Dir->setDependentInits(Exprs.DependentInits); 1175 Dir->setFinalsConditions(Exprs.FinalsConditions); 1176 Dir->setPreInits(Exprs.PreInits); 1177 Dir->setHasCancel(HasCancel); 1178 return Dir; 1179 } 1180 1181 OMPParallelMasterTaskLoopDirective * 1182 OMPParallelMasterTaskLoopDirective::CreateEmpty(const ASTContext &C, 1183 unsigned NumClauses, 1184 unsigned CollapsedNum, 1185 EmptyShell) { 1186 return createEmptyDirective<OMPParallelMasterTaskLoopDirective>( 1187 C, NumClauses, /*HasAssociatedStmt=*/true, 1188 numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop), 1189 CollapsedNum); 1190 } 1191 1192 OMPParallelMasterTaskLoopSimdDirective * 1193 OMPParallelMasterTaskLoopSimdDirective::Create( 1194 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1195 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1196 const HelperExprs &Exprs) { 1197 auto *Dir = createDirective<OMPParallelMasterTaskLoopSimdDirective>( 1198 C, Clauses, AssociatedStmt, 1199 numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd), 1200 StartLoc, EndLoc, CollapsedNum); 1201 Dir->setIterationVariable(Exprs.IterationVarRef); 1202 Dir->setLastIteration(Exprs.LastIteration); 1203 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1204 Dir->setPreCond(Exprs.PreCond); 1205 Dir->setCond(Exprs.Cond); 1206 Dir->setInit(Exprs.Init); 1207 Dir->setInc(Exprs.Inc); 1208 Dir->setIsLastIterVariable(Exprs.IL); 1209 Dir->setLowerBoundVariable(Exprs.LB); 1210 Dir->setUpperBoundVariable(Exprs.UB); 1211 Dir->setStrideVariable(Exprs.ST); 1212 Dir->setEnsureUpperBound(Exprs.EUB); 1213 Dir->setNextLowerBound(Exprs.NLB); 1214 Dir->setNextUpperBound(Exprs.NUB); 1215 Dir->setNumIterations(Exprs.NumIterations); 1216 Dir->setCounters(Exprs.Counters); 1217 Dir->setPrivateCounters(Exprs.PrivateCounters); 1218 Dir->setInits(Exprs.Inits); 1219 Dir->setUpdates(Exprs.Updates); 1220 Dir->setFinals(Exprs.Finals); 1221 Dir->setDependentCounters(Exprs.DependentCounters); 1222 Dir->setDependentInits(Exprs.DependentInits); 1223 Dir->setFinalsConditions(Exprs.FinalsConditions); 1224 Dir->setPreInits(Exprs.PreInits); 1225 return Dir; 1226 } 1227 1228 OMPParallelMasterTaskLoopSimdDirective * 1229 OMPParallelMasterTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, 1230 unsigned NumClauses, 1231 unsigned CollapsedNum, 1232 EmptyShell) { 1233 return createEmptyDirective<OMPParallelMasterTaskLoopSimdDirective>( 1234 C, NumClauses, /*HasAssociatedStmt=*/true, 1235 numLoopChildren(CollapsedNum, OMPD_parallel_master_taskloop_simd), 1236 CollapsedNum); 1237 } 1238 1239 OMPDistributeDirective *OMPDistributeDirective::Create( 1240 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1241 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1242 const HelperExprs &Exprs) { 1243 auto *Dir = createDirective<OMPDistributeDirective>( 1244 C, Clauses, AssociatedStmt, 1245 numLoopChildren(CollapsedNum, OMPD_distribute), StartLoc, EndLoc, 1246 CollapsedNum); 1247 Dir->setIterationVariable(Exprs.IterationVarRef); 1248 Dir->setLastIteration(Exprs.LastIteration); 1249 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1250 Dir->setPreCond(Exprs.PreCond); 1251 Dir->setCond(Exprs.Cond); 1252 Dir->setInit(Exprs.Init); 1253 Dir->setInc(Exprs.Inc); 1254 Dir->setIsLastIterVariable(Exprs.IL); 1255 Dir->setLowerBoundVariable(Exprs.LB); 1256 Dir->setUpperBoundVariable(Exprs.UB); 1257 Dir->setStrideVariable(Exprs.ST); 1258 Dir->setEnsureUpperBound(Exprs.EUB); 1259 Dir->setNextLowerBound(Exprs.NLB); 1260 Dir->setNextUpperBound(Exprs.NUB); 1261 Dir->setNumIterations(Exprs.NumIterations); 1262 Dir->setCounters(Exprs.Counters); 1263 Dir->setPrivateCounters(Exprs.PrivateCounters); 1264 Dir->setInits(Exprs.Inits); 1265 Dir->setUpdates(Exprs.Updates); 1266 Dir->setFinals(Exprs.Finals); 1267 Dir->setDependentCounters(Exprs.DependentCounters); 1268 Dir->setDependentInits(Exprs.DependentInits); 1269 Dir->setFinalsConditions(Exprs.FinalsConditions); 1270 Dir->setPreInits(Exprs.PreInits); 1271 return Dir; 1272 } 1273 1274 OMPDistributeDirective * 1275 OMPDistributeDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, 1276 unsigned CollapsedNum, EmptyShell) { 1277 return createEmptyDirective<OMPDistributeDirective>( 1278 C, NumClauses, /*HasAssociatedStmt=*/true, 1279 numLoopChildren(CollapsedNum, OMPD_distribute), CollapsedNum); 1280 } 1281 1282 OMPTargetUpdateDirective *OMPTargetUpdateDirective::Create( 1283 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1284 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) { 1285 return createDirective<OMPTargetUpdateDirective>(C, Clauses, AssociatedStmt, 1286 /*NumChildren=*/0, StartLoc, 1287 EndLoc); 1288 } 1289 1290 OMPTargetUpdateDirective * 1291 OMPTargetUpdateDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, 1292 EmptyShell) { 1293 return createEmptyDirective<OMPTargetUpdateDirective>( 1294 C, NumClauses, /*HasAssociatedStmt=*/true); 1295 } 1296 1297 OMPDistributeParallelForDirective *OMPDistributeParallelForDirective::Create( 1298 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1299 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1300 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { 1301 auto *Dir = createDirective<OMPDistributeParallelForDirective>( 1302 C, Clauses, AssociatedStmt, 1303 numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1, StartLoc, 1304 EndLoc, CollapsedNum); 1305 Dir->setIterationVariable(Exprs.IterationVarRef); 1306 Dir->setLastIteration(Exprs.LastIteration); 1307 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1308 Dir->setPreCond(Exprs.PreCond); 1309 Dir->setCond(Exprs.Cond); 1310 Dir->setInit(Exprs.Init); 1311 Dir->setInc(Exprs.Inc); 1312 Dir->setIsLastIterVariable(Exprs.IL); 1313 Dir->setLowerBoundVariable(Exprs.LB); 1314 Dir->setUpperBoundVariable(Exprs.UB); 1315 Dir->setStrideVariable(Exprs.ST); 1316 Dir->setEnsureUpperBound(Exprs.EUB); 1317 Dir->setNextLowerBound(Exprs.NLB); 1318 Dir->setNextUpperBound(Exprs.NUB); 1319 Dir->setNumIterations(Exprs.NumIterations); 1320 Dir->setPrevLowerBoundVariable(Exprs.PrevLB); 1321 Dir->setPrevUpperBoundVariable(Exprs.PrevUB); 1322 Dir->setDistInc(Exprs.DistInc); 1323 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB); 1324 Dir->setCounters(Exprs.Counters); 1325 Dir->setPrivateCounters(Exprs.PrivateCounters); 1326 Dir->setInits(Exprs.Inits); 1327 Dir->setUpdates(Exprs.Updates); 1328 Dir->setFinals(Exprs.Finals); 1329 Dir->setDependentCounters(Exprs.DependentCounters); 1330 Dir->setDependentInits(Exprs.DependentInits); 1331 Dir->setFinalsConditions(Exprs.FinalsConditions); 1332 Dir->setPreInits(Exprs.PreInits); 1333 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB); 1334 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB); 1335 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB); 1336 Dir->setCombinedInit(Exprs.DistCombinedFields.Init); 1337 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond); 1338 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB); 1339 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB); 1340 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond); 1341 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond); 1342 Dir->setTaskReductionRefExpr(TaskRedRef); 1343 Dir->HasCancel = HasCancel; 1344 return Dir; 1345 } 1346 1347 OMPDistributeParallelForDirective * 1348 OMPDistributeParallelForDirective::CreateEmpty(const ASTContext &C, 1349 unsigned NumClauses, 1350 unsigned CollapsedNum, 1351 EmptyShell) { 1352 return createEmptyDirective<OMPDistributeParallelForDirective>( 1353 C, NumClauses, /*HasAssociatedStmt=*/true, 1354 numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for) + 1, 1355 CollapsedNum); 1356 } 1357 1358 OMPDistributeParallelForSimdDirective * 1359 OMPDistributeParallelForSimdDirective::Create( 1360 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1361 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1362 const HelperExprs &Exprs) { 1363 auto *Dir = createDirective<OMPDistributeParallelForSimdDirective>( 1364 C, Clauses, AssociatedStmt, 1365 numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd), 1366 StartLoc, EndLoc, CollapsedNum); 1367 Dir->setIterationVariable(Exprs.IterationVarRef); 1368 Dir->setLastIteration(Exprs.LastIteration); 1369 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1370 Dir->setPreCond(Exprs.PreCond); 1371 Dir->setCond(Exprs.Cond); 1372 Dir->setInit(Exprs.Init); 1373 Dir->setInc(Exprs.Inc); 1374 Dir->setIsLastIterVariable(Exprs.IL); 1375 Dir->setLowerBoundVariable(Exprs.LB); 1376 Dir->setUpperBoundVariable(Exprs.UB); 1377 Dir->setStrideVariable(Exprs.ST); 1378 Dir->setEnsureUpperBound(Exprs.EUB); 1379 Dir->setNextLowerBound(Exprs.NLB); 1380 Dir->setNextUpperBound(Exprs.NUB); 1381 Dir->setNumIterations(Exprs.NumIterations); 1382 Dir->setPrevLowerBoundVariable(Exprs.PrevLB); 1383 Dir->setPrevUpperBoundVariable(Exprs.PrevUB); 1384 Dir->setDistInc(Exprs.DistInc); 1385 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB); 1386 Dir->setCounters(Exprs.Counters); 1387 Dir->setPrivateCounters(Exprs.PrivateCounters); 1388 Dir->setInits(Exprs.Inits); 1389 Dir->setUpdates(Exprs.Updates); 1390 Dir->setFinals(Exprs.Finals); 1391 Dir->setDependentCounters(Exprs.DependentCounters); 1392 Dir->setDependentInits(Exprs.DependentInits); 1393 Dir->setFinalsConditions(Exprs.FinalsConditions); 1394 Dir->setPreInits(Exprs.PreInits); 1395 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB); 1396 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB); 1397 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB); 1398 Dir->setCombinedInit(Exprs.DistCombinedFields.Init); 1399 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond); 1400 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB); 1401 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB); 1402 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond); 1403 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond); 1404 return Dir; 1405 } 1406 1407 OMPDistributeParallelForSimdDirective * 1408 OMPDistributeParallelForSimdDirective::CreateEmpty(const ASTContext &C, 1409 unsigned NumClauses, 1410 unsigned CollapsedNum, 1411 EmptyShell) { 1412 return createEmptyDirective<OMPDistributeParallelForSimdDirective>( 1413 C, NumClauses, /*HasAssociatedStmt=*/true, 1414 numLoopChildren(CollapsedNum, OMPD_distribute_parallel_for_simd), 1415 CollapsedNum); 1416 } 1417 1418 OMPDistributeSimdDirective *OMPDistributeSimdDirective::Create( 1419 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1420 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1421 const HelperExprs &Exprs) { 1422 auto *Dir = createDirective<OMPDistributeSimdDirective>( 1423 C, Clauses, AssociatedStmt, 1424 numLoopChildren(CollapsedNum, OMPD_distribute_simd), StartLoc, EndLoc, 1425 CollapsedNum); 1426 Dir->setIterationVariable(Exprs.IterationVarRef); 1427 Dir->setLastIteration(Exprs.LastIteration); 1428 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1429 Dir->setPreCond(Exprs.PreCond); 1430 Dir->setCond(Exprs.Cond); 1431 Dir->setInit(Exprs.Init); 1432 Dir->setInc(Exprs.Inc); 1433 Dir->setIsLastIterVariable(Exprs.IL); 1434 Dir->setLowerBoundVariable(Exprs.LB); 1435 Dir->setUpperBoundVariable(Exprs.UB); 1436 Dir->setStrideVariable(Exprs.ST); 1437 Dir->setEnsureUpperBound(Exprs.EUB); 1438 Dir->setNextLowerBound(Exprs.NLB); 1439 Dir->setNextUpperBound(Exprs.NUB); 1440 Dir->setNumIterations(Exprs.NumIterations); 1441 Dir->setCounters(Exprs.Counters); 1442 Dir->setPrivateCounters(Exprs.PrivateCounters); 1443 Dir->setInits(Exprs.Inits); 1444 Dir->setUpdates(Exprs.Updates); 1445 Dir->setFinals(Exprs.Finals); 1446 Dir->setDependentCounters(Exprs.DependentCounters); 1447 Dir->setDependentInits(Exprs.DependentInits); 1448 Dir->setFinalsConditions(Exprs.FinalsConditions); 1449 Dir->setPreInits(Exprs.PreInits); 1450 return Dir; 1451 } 1452 1453 OMPDistributeSimdDirective * 1454 OMPDistributeSimdDirective::CreateEmpty(const ASTContext &C, 1455 unsigned NumClauses, 1456 unsigned CollapsedNum, EmptyShell) { 1457 return createEmptyDirective<OMPDistributeSimdDirective>( 1458 C, NumClauses, /*HasAssociatedStmt=*/true, 1459 numLoopChildren(CollapsedNum, OMPD_distribute_simd), CollapsedNum); 1460 } 1461 1462 OMPTargetParallelForSimdDirective *OMPTargetParallelForSimdDirective::Create( 1463 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1464 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1465 const HelperExprs &Exprs) { 1466 auto *Dir = createDirective<OMPTargetParallelForSimdDirective>( 1467 C, Clauses, AssociatedStmt, 1468 numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd), StartLoc, 1469 EndLoc, CollapsedNum); 1470 Dir->setIterationVariable(Exprs.IterationVarRef); 1471 Dir->setLastIteration(Exprs.LastIteration); 1472 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1473 Dir->setPreCond(Exprs.PreCond); 1474 Dir->setCond(Exprs.Cond); 1475 Dir->setInit(Exprs.Init); 1476 Dir->setInc(Exprs.Inc); 1477 Dir->setIsLastIterVariable(Exprs.IL); 1478 Dir->setLowerBoundVariable(Exprs.LB); 1479 Dir->setUpperBoundVariable(Exprs.UB); 1480 Dir->setStrideVariable(Exprs.ST); 1481 Dir->setEnsureUpperBound(Exprs.EUB); 1482 Dir->setNextLowerBound(Exprs.NLB); 1483 Dir->setNextUpperBound(Exprs.NUB); 1484 Dir->setNumIterations(Exprs.NumIterations); 1485 Dir->setCounters(Exprs.Counters); 1486 Dir->setPrivateCounters(Exprs.PrivateCounters); 1487 Dir->setInits(Exprs.Inits); 1488 Dir->setUpdates(Exprs.Updates); 1489 Dir->setFinals(Exprs.Finals); 1490 Dir->setDependentCounters(Exprs.DependentCounters); 1491 Dir->setDependentInits(Exprs.DependentInits); 1492 Dir->setFinalsConditions(Exprs.FinalsConditions); 1493 Dir->setPreInits(Exprs.PreInits); 1494 return Dir; 1495 } 1496 1497 OMPTargetParallelForSimdDirective * 1498 OMPTargetParallelForSimdDirective::CreateEmpty(const ASTContext &C, 1499 unsigned NumClauses, 1500 unsigned CollapsedNum, 1501 EmptyShell) { 1502 return createEmptyDirective<OMPTargetParallelForSimdDirective>( 1503 C, NumClauses, /*HasAssociatedStmt=*/true, 1504 numLoopChildren(CollapsedNum, OMPD_target_parallel_for_simd), 1505 CollapsedNum); 1506 } 1507 1508 OMPTargetSimdDirective * 1509 OMPTargetSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc, 1510 SourceLocation EndLoc, unsigned CollapsedNum, 1511 ArrayRef<OMPClause *> Clauses, 1512 Stmt *AssociatedStmt, const HelperExprs &Exprs) { 1513 auto *Dir = createDirective<OMPTargetSimdDirective>( 1514 C, Clauses, AssociatedStmt, 1515 numLoopChildren(CollapsedNum, OMPD_target_simd), StartLoc, EndLoc, 1516 CollapsedNum); 1517 Dir->setIterationVariable(Exprs.IterationVarRef); 1518 Dir->setLastIteration(Exprs.LastIteration); 1519 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1520 Dir->setPreCond(Exprs.PreCond); 1521 Dir->setCond(Exprs.Cond); 1522 Dir->setInit(Exprs.Init); 1523 Dir->setInc(Exprs.Inc); 1524 Dir->setCounters(Exprs.Counters); 1525 Dir->setPrivateCounters(Exprs.PrivateCounters); 1526 Dir->setInits(Exprs.Inits); 1527 Dir->setUpdates(Exprs.Updates); 1528 Dir->setFinals(Exprs.Finals); 1529 Dir->setDependentCounters(Exprs.DependentCounters); 1530 Dir->setDependentInits(Exprs.DependentInits); 1531 Dir->setFinalsConditions(Exprs.FinalsConditions); 1532 Dir->setPreInits(Exprs.PreInits); 1533 return Dir; 1534 } 1535 1536 OMPTargetSimdDirective * 1537 OMPTargetSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, 1538 unsigned CollapsedNum, EmptyShell) { 1539 return createEmptyDirective<OMPTargetSimdDirective>( 1540 C, NumClauses, /*HasAssociatedStmt=*/true, 1541 numLoopChildren(CollapsedNum, OMPD_target_simd), CollapsedNum); 1542 } 1543 1544 OMPTeamsDistributeDirective *OMPTeamsDistributeDirective::Create( 1545 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1546 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1547 const HelperExprs &Exprs) { 1548 auto *Dir = createDirective<OMPTeamsDistributeDirective>( 1549 C, Clauses, AssociatedStmt, 1550 numLoopChildren(CollapsedNum, OMPD_teams_distribute), StartLoc, EndLoc, 1551 CollapsedNum); 1552 Dir->setIterationVariable(Exprs.IterationVarRef); 1553 Dir->setLastIteration(Exprs.LastIteration); 1554 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1555 Dir->setPreCond(Exprs.PreCond); 1556 Dir->setCond(Exprs.Cond); 1557 Dir->setInit(Exprs.Init); 1558 Dir->setInc(Exprs.Inc); 1559 Dir->setIsLastIterVariable(Exprs.IL); 1560 Dir->setLowerBoundVariable(Exprs.LB); 1561 Dir->setUpperBoundVariable(Exprs.UB); 1562 Dir->setStrideVariable(Exprs.ST); 1563 Dir->setEnsureUpperBound(Exprs.EUB); 1564 Dir->setNextLowerBound(Exprs.NLB); 1565 Dir->setNextUpperBound(Exprs.NUB); 1566 Dir->setNumIterations(Exprs.NumIterations); 1567 Dir->setCounters(Exprs.Counters); 1568 Dir->setPrivateCounters(Exprs.PrivateCounters); 1569 Dir->setInits(Exprs.Inits); 1570 Dir->setUpdates(Exprs.Updates); 1571 Dir->setFinals(Exprs.Finals); 1572 Dir->setDependentCounters(Exprs.DependentCounters); 1573 Dir->setDependentInits(Exprs.DependentInits); 1574 Dir->setFinalsConditions(Exprs.FinalsConditions); 1575 Dir->setPreInits(Exprs.PreInits); 1576 return Dir; 1577 } 1578 1579 OMPTeamsDistributeDirective * 1580 OMPTeamsDistributeDirective::CreateEmpty(const ASTContext &C, 1581 unsigned NumClauses, 1582 unsigned CollapsedNum, EmptyShell) { 1583 return createEmptyDirective<OMPTeamsDistributeDirective>( 1584 C, NumClauses, /*HasAssociatedStmt=*/true, 1585 numLoopChildren(CollapsedNum, OMPD_teams_distribute), CollapsedNum); 1586 } 1587 1588 OMPTeamsDistributeSimdDirective *OMPTeamsDistributeSimdDirective::Create( 1589 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1590 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1591 const HelperExprs &Exprs) { 1592 auto *Dir = createDirective<OMPTeamsDistributeSimdDirective>( 1593 C, Clauses, AssociatedStmt, 1594 numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), StartLoc, 1595 EndLoc, CollapsedNum); 1596 Dir->setIterationVariable(Exprs.IterationVarRef); 1597 Dir->setLastIteration(Exprs.LastIteration); 1598 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1599 Dir->setPreCond(Exprs.PreCond); 1600 Dir->setCond(Exprs.Cond); 1601 Dir->setInit(Exprs.Init); 1602 Dir->setInc(Exprs.Inc); 1603 Dir->setIsLastIterVariable(Exprs.IL); 1604 Dir->setLowerBoundVariable(Exprs.LB); 1605 Dir->setUpperBoundVariable(Exprs.UB); 1606 Dir->setStrideVariable(Exprs.ST); 1607 Dir->setEnsureUpperBound(Exprs.EUB); 1608 Dir->setNextLowerBound(Exprs.NLB); 1609 Dir->setNextUpperBound(Exprs.NUB); 1610 Dir->setNumIterations(Exprs.NumIterations); 1611 Dir->setCounters(Exprs.Counters); 1612 Dir->setPrivateCounters(Exprs.PrivateCounters); 1613 Dir->setInits(Exprs.Inits); 1614 Dir->setUpdates(Exprs.Updates); 1615 Dir->setFinals(Exprs.Finals); 1616 Dir->setDependentCounters(Exprs.DependentCounters); 1617 Dir->setDependentInits(Exprs.DependentInits); 1618 Dir->setFinalsConditions(Exprs.FinalsConditions); 1619 Dir->setPreInits(Exprs.PreInits); 1620 return Dir; 1621 } 1622 1623 OMPTeamsDistributeSimdDirective *OMPTeamsDistributeSimdDirective::CreateEmpty( 1624 const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, 1625 EmptyShell) { 1626 return createEmptyDirective<OMPTeamsDistributeSimdDirective>( 1627 C, NumClauses, /*HasAssociatedStmt=*/true, 1628 numLoopChildren(CollapsedNum, OMPD_teams_distribute_simd), CollapsedNum); 1629 } 1630 1631 OMPTeamsDistributeParallelForSimdDirective * 1632 OMPTeamsDistributeParallelForSimdDirective::Create( 1633 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1634 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1635 const HelperExprs &Exprs) { 1636 auto *Dir = createDirective<OMPTeamsDistributeParallelForSimdDirective>( 1637 C, Clauses, AssociatedStmt, 1638 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd), 1639 StartLoc, EndLoc, CollapsedNum); 1640 Dir->setIterationVariable(Exprs.IterationVarRef); 1641 Dir->setLastIteration(Exprs.LastIteration); 1642 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1643 Dir->setPreCond(Exprs.PreCond); 1644 Dir->setCond(Exprs.Cond); 1645 Dir->setInit(Exprs.Init); 1646 Dir->setInc(Exprs.Inc); 1647 Dir->setIsLastIterVariable(Exprs.IL); 1648 Dir->setLowerBoundVariable(Exprs.LB); 1649 Dir->setUpperBoundVariable(Exprs.UB); 1650 Dir->setStrideVariable(Exprs.ST); 1651 Dir->setEnsureUpperBound(Exprs.EUB); 1652 Dir->setNextLowerBound(Exprs.NLB); 1653 Dir->setNextUpperBound(Exprs.NUB); 1654 Dir->setNumIterations(Exprs.NumIterations); 1655 Dir->setPrevLowerBoundVariable(Exprs.PrevLB); 1656 Dir->setPrevUpperBoundVariable(Exprs.PrevUB); 1657 Dir->setDistInc(Exprs.DistInc); 1658 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB); 1659 Dir->setCounters(Exprs.Counters); 1660 Dir->setPrivateCounters(Exprs.PrivateCounters); 1661 Dir->setInits(Exprs.Inits); 1662 Dir->setUpdates(Exprs.Updates); 1663 Dir->setFinals(Exprs.Finals); 1664 Dir->setDependentCounters(Exprs.DependentCounters); 1665 Dir->setDependentInits(Exprs.DependentInits); 1666 Dir->setFinalsConditions(Exprs.FinalsConditions); 1667 Dir->setPreInits(Exprs.PreInits); 1668 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB); 1669 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB); 1670 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB); 1671 Dir->setCombinedInit(Exprs.DistCombinedFields.Init); 1672 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond); 1673 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB); 1674 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB); 1675 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond); 1676 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond); 1677 return Dir; 1678 } 1679 1680 OMPTeamsDistributeParallelForSimdDirective * 1681 OMPTeamsDistributeParallelForSimdDirective::CreateEmpty(const ASTContext &C, 1682 unsigned NumClauses, 1683 unsigned CollapsedNum, 1684 EmptyShell) { 1685 return createEmptyDirective<OMPTeamsDistributeParallelForSimdDirective>( 1686 C, NumClauses, /*HasAssociatedStmt=*/true, 1687 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for_simd), 1688 CollapsedNum); 1689 } 1690 1691 OMPTeamsDistributeParallelForDirective * 1692 OMPTeamsDistributeParallelForDirective::Create( 1693 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1694 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1695 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { 1696 auto *Dir = createDirective<OMPTeamsDistributeParallelForDirective>( 1697 C, Clauses, AssociatedStmt, 1698 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1, 1699 StartLoc, EndLoc, CollapsedNum); 1700 Dir->setIterationVariable(Exprs.IterationVarRef); 1701 Dir->setLastIteration(Exprs.LastIteration); 1702 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1703 Dir->setPreCond(Exprs.PreCond); 1704 Dir->setCond(Exprs.Cond); 1705 Dir->setInit(Exprs.Init); 1706 Dir->setInc(Exprs.Inc); 1707 Dir->setIsLastIterVariable(Exprs.IL); 1708 Dir->setLowerBoundVariable(Exprs.LB); 1709 Dir->setUpperBoundVariable(Exprs.UB); 1710 Dir->setStrideVariable(Exprs.ST); 1711 Dir->setEnsureUpperBound(Exprs.EUB); 1712 Dir->setNextLowerBound(Exprs.NLB); 1713 Dir->setNextUpperBound(Exprs.NUB); 1714 Dir->setNumIterations(Exprs.NumIterations); 1715 Dir->setPrevLowerBoundVariable(Exprs.PrevLB); 1716 Dir->setPrevUpperBoundVariable(Exprs.PrevUB); 1717 Dir->setDistInc(Exprs.DistInc); 1718 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB); 1719 Dir->setCounters(Exprs.Counters); 1720 Dir->setPrivateCounters(Exprs.PrivateCounters); 1721 Dir->setInits(Exprs.Inits); 1722 Dir->setUpdates(Exprs.Updates); 1723 Dir->setFinals(Exprs.Finals); 1724 Dir->setDependentCounters(Exprs.DependentCounters); 1725 Dir->setDependentInits(Exprs.DependentInits); 1726 Dir->setFinalsConditions(Exprs.FinalsConditions); 1727 Dir->setPreInits(Exprs.PreInits); 1728 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB); 1729 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB); 1730 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB); 1731 Dir->setCombinedInit(Exprs.DistCombinedFields.Init); 1732 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond); 1733 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB); 1734 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB); 1735 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond); 1736 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond); 1737 Dir->setTaskReductionRefExpr(TaskRedRef); 1738 Dir->HasCancel = HasCancel; 1739 return Dir; 1740 } 1741 1742 OMPTeamsDistributeParallelForDirective * 1743 OMPTeamsDistributeParallelForDirective::CreateEmpty(const ASTContext &C, 1744 unsigned NumClauses, 1745 unsigned CollapsedNum, 1746 EmptyShell) { 1747 return createEmptyDirective<OMPTeamsDistributeParallelForDirective>( 1748 C, NumClauses, /*HasAssociatedStmt=*/true, 1749 numLoopChildren(CollapsedNum, OMPD_teams_distribute_parallel_for) + 1, 1750 CollapsedNum); 1751 } 1752 1753 OMPTargetTeamsDirective *OMPTargetTeamsDirective::Create( 1754 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1755 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) { 1756 return createDirective<OMPTargetTeamsDirective>(C, Clauses, AssociatedStmt, 1757 /*NumChildren=*/0, StartLoc, 1758 EndLoc); 1759 } 1760 1761 OMPTargetTeamsDirective * 1762 OMPTargetTeamsDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, 1763 EmptyShell) { 1764 return createEmptyDirective<OMPTargetTeamsDirective>( 1765 C, NumClauses, /*HasAssociatedStmt=*/true); 1766 } 1767 1768 OMPTargetTeamsDistributeDirective *OMPTargetTeamsDistributeDirective::Create( 1769 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1770 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1771 const HelperExprs &Exprs) { 1772 auto *Dir = createDirective<OMPTargetTeamsDistributeDirective>( 1773 C, Clauses, AssociatedStmt, 1774 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute), StartLoc, 1775 EndLoc, CollapsedNum); 1776 Dir->setIterationVariable(Exprs.IterationVarRef); 1777 Dir->setLastIteration(Exprs.LastIteration); 1778 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1779 Dir->setPreCond(Exprs.PreCond); 1780 Dir->setCond(Exprs.Cond); 1781 Dir->setInit(Exprs.Init); 1782 Dir->setInc(Exprs.Inc); 1783 Dir->setIsLastIterVariable(Exprs.IL); 1784 Dir->setLowerBoundVariable(Exprs.LB); 1785 Dir->setUpperBoundVariable(Exprs.UB); 1786 Dir->setStrideVariable(Exprs.ST); 1787 Dir->setEnsureUpperBound(Exprs.EUB); 1788 Dir->setNextLowerBound(Exprs.NLB); 1789 Dir->setNextUpperBound(Exprs.NUB); 1790 Dir->setNumIterations(Exprs.NumIterations); 1791 Dir->setCounters(Exprs.Counters); 1792 Dir->setPrivateCounters(Exprs.PrivateCounters); 1793 Dir->setInits(Exprs.Inits); 1794 Dir->setUpdates(Exprs.Updates); 1795 Dir->setFinals(Exprs.Finals); 1796 Dir->setDependentCounters(Exprs.DependentCounters); 1797 Dir->setDependentInits(Exprs.DependentInits); 1798 Dir->setFinalsConditions(Exprs.FinalsConditions); 1799 Dir->setPreInits(Exprs.PreInits); 1800 return Dir; 1801 } 1802 1803 OMPTargetTeamsDistributeDirective * 1804 OMPTargetTeamsDistributeDirective::CreateEmpty(const ASTContext &C, 1805 unsigned NumClauses, 1806 unsigned CollapsedNum, 1807 EmptyShell) { 1808 return createEmptyDirective<OMPTargetTeamsDistributeDirective>( 1809 C, NumClauses, /*HasAssociatedStmt=*/true, 1810 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute), 1811 CollapsedNum); 1812 } 1813 1814 OMPTargetTeamsDistributeParallelForDirective * 1815 OMPTargetTeamsDistributeParallelForDirective::Create( 1816 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1817 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1818 const HelperExprs &Exprs, Expr *TaskRedRef, bool HasCancel) { 1819 auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForDirective>( 1820 C, Clauses, AssociatedStmt, 1821 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) + 1822 1, 1823 StartLoc, EndLoc, CollapsedNum); 1824 Dir->setIterationVariable(Exprs.IterationVarRef); 1825 Dir->setLastIteration(Exprs.LastIteration); 1826 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1827 Dir->setPreCond(Exprs.PreCond); 1828 Dir->setCond(Exprs.Cond); 1829 Dir->setInit(Exprs.Init); 1830 Dir->setInc(Exprs.Inc); 1831 Dir->setIsLastIterVariable(Exprs.IL); 1832 Dir->setLowerBoundVariable(Exprs.LB); 1833 Dir->setUpperBoundVariable(Exprs.UB); 1834 Dir->setStrideVariable(Exprs.ST); 1835 Dir->setEnsureUpperBound(Exprs.EUB); 1836 Dir->setNextLowerBound(Exprs.NLB); 1837 Dir->setNextUpperBound(Exprs.NUB); 1838 Dir->setNumIterations(Exprs.NumIterations); 1839 Dir->setPrevLowerBoundVariable(Exprs.PrevLB); 1840 Dir->setPrevUpperBoundVariable(Exprs.PrevUB); 1841 Dir->setDistInc(Exprs.DistInc); 1842 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB); 1843 Dir->setCounters(Exprs.Counters); 1844 Dir->setPrivateCounters(Exprs.PrivateCounters); 1845 Dir->setInits(Exprs.Inits); 1846 Dir->setUpdates(Exprs.Updates); 1847 Dir->setFinals(Exprs.Finals); 1848 Dir->setDependentCounters(Exprs.DependentCounters); 1849 Dir->setDependentInits(Exprs.DependentInits); 1850 Dir->setFinalsConditions(Exprs.FinalsConditions); 1851 Dir->setPreInits(Exprs.PreInits); 1852 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB); 1853 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB); 1854 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB); 1855 Dir->setCombinedInit(Exprs.DistCombinedFields.Init); 1856 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond); 1857 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB); 1858 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB); 1859 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond); 1860 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond); 1861 Dir->setTaskReductionRefExpr(TaskRedRef); 1862 Dir->HasCancel = HasCancel; 1863 return Dir; 1864 } 1865 1866 OMPTargetTeamsDistributeParallelForDirective * 1867 OMPTargetTeamsDistributeParallelForDirective::CreateEmpty(const ASTContext &C, 1868 unsigned NumClauses, 1869 unsigned CollapsedNum, 1870 EmptyShell) { 1871 return createEmptyDirective<OMPTargetTeamsDistributeParallelForDirective>( 1872 C, NumClauses, /*HasAssociatedStmt=*/true, 1873 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_parallel_for) + 1874 1, 1875 CollapsedNum); 1876 } 1877 1878 OMPTargetTeamsDistributeParallelForSimdDirective * 1879 OMPTargetTeamsDistributeParallelForSimdDirective::Create( 1880 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1881 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1882 const HelperExprs &Exprs) { 1883 auto *Dir = createDirective<OMPTargetTeamsDistributeParallelForSimdDirective>( 1884 C, Clauses, AssociatedStmt, 1885 numLoopChildren(CollapsedNum, 1886 OMPD_target_teams_distribute_parallel_for_simd), 1887 StartLoc, EndLoc, CollapsedNum); 1888 Dir->setIterationVariable(Exprs.IterationVarRef); 1889 Dir->setLastIteration(Exprs.LastIteration); 1890 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1891 Dir->setPreCond(Exprs.PreCond); 1892 Dir->setCond(Exprs.Cond); 1893 Dir->setInit(Exprs.Init); 1894 Dir->setInc(Exprs.Inc); 1895 Dir->setIsLastIterVariable(Exprs.IL); 1896 Dir->setLowerBoundVariable(Exprs.LB); 1897 Dir->setUpperBoundVariable(Exprs.UB); 1898 Dir->setStrideVariable(Exprs.ST); 1899 Dir->setEnsureUpperBound(Exprs.EUB); 1900 Dir->setNextLowerBound(Exprs.NLB); 1901 Dir->setNextUpperBound(Exprs.NUB); 1902 Dir->setNumIterations(Exprs.NumIterations); 1903 Dir->setPrevLowerBoundVariable(Exprs.PrevLB); 1904 Dir->setPrevUpperBoundVariable(Exprs.PrevUB); 1905 Dir->setDistInc(Exprs.DistInc); 1906 Dir->setPrevEnsureUpperBound(Exprs.PrevEUB); 1907 Dir->setCounters(Exprs.Counters); 1908 Dir->setPrivateCounters(Exprs.PrivateCounters); 1909 Dir->setInits(Exprs.Inits); 1910 Dir->setUpdates(Exprs.Updates); 1911 Dir->setFinals(Exprs.Finals); 1912 Dir->setDependentCounters(Exprs.DependentCounters); 1913 Dir->setDependentInits(Exprs.DependentInits); 1914 Dir->setFinalsConditions(Exprs.FinalsConditions); 1915 Dir->setPreInits(Exprs.PreInits); 1916 Dir->setCombinedLowerBoundVariable(Exprs.DistCombinedFields.LB); 1917 Dir->setCombinedUpperBoundVariable(Exprs.DistCombinedFields.UB); 1918 Dir->setCombinedEnsureUpperBound(Exprs.DistCombinedFields.EUB); 1919 Dir->setCombinedInit(Exprs.DistCombinedFields.Init); 1920 Dir->setCombinedCond(Exprs.DistCombinedFields.Cond); 1921 Dir->setCombinedNextLowerBound(Exprs.DistCombinedFields.NLB); 1922 Dir->setCombinedNextUpperBound(Exprs.DistCombinedFields.NUB); 1923 Dir->setCombinedDistCond(Exprs.DistCombinedFields.DistCond); 1924 Dir->setCombinedParForInDistCond(Exprs.DistCombinedFields.ParForInDistCond); 1925 return Dir; 1926 } 1927 1928 OMPTargetTeamsDistributeParallelForSimdDirective * 1929 OMPTargetTeamsDistributeParallelForSimdDirective::CreateEmpty( 1930 const ASTContext &C, unsigned NumClauses, unsigned CollapsedNum, 1931 EmptyShell) { 1932 return createEmptyDirective<OMPTargetTeamsDistributeParallelForSimdDirective>( 1933 C, NumClauses, /*HasAssociatedStmt=*/true, 1934 numLoopChildren(CollapsedNum, 1935 OMPD_target_teams_distribute_parallel_for_simd), 1936 CollapsedNum); 1937 } 1938 1939 OMPTargetTeamsDistributeSimdDirective * 1940 OMPTargetTeamsDistributeSimdDirective::Create( 1941 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 1942 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 1943 const HelperExprs &Exprs) { 1944 auto *Dir = createDirective<OMPTargetTeamsDistributeSimdDirective>( 1945 C, Clauses, AssociatedStmt, 1946 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd), 1947 StartLoc, EndLoc, CollapsedNum); 1948 Dir->setIterationVariable(Exprs.IterationVarRef); 1949 Dir->setLastIteration(Exprs.LastIteration); 1950 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 1951 Dir->setPreCond(Exprs.PreCond); 1952 Dir->setCond(Exprs.Cond); 1953 Dir->setInit(Exprs.Init); 1954 Dir->setInc(Exprs.Inc); 1955 Dir->setIsLastIterVariable(Exprs.IL); 1956 Dir->setLowerBoundVariable(Exprs.LB); 1957 Dir->setUpperBoundVariable(Exprs.UB); 1958 Dir->setStrideVariable(Exprs.ST); 1959 Dir->setEnsureUpperBound(Exprs.EUB); 1960 Dir->setNextLowerBound(Exprs.NLB); 1961 Dir->setNextUpperBound(Exprs.NUB); 1962 Dir->setNumIterations(Exprs.NumIterations); 1963 Dir->setCounters(Exprs.Counters); 1964 Dir->setPrivateCounters(Exprs.PrivateCounters); 1965 Dir->setInits(Exprs.Inits); 1966 Dir->setUpdates(Exprs.Updates); 1967 Dir->setFinals(Exprs.Finals); 1968 Dir->setDependentCounters(Exprs.DependentCounters); 1969 Dir->setDependentInits(Exprs.DependentInits); 1970 Dir->setFinalsConditions(Exprs.FinalsConditions); 1971 Dir->setPreInits(Exprs.PreInits); 1972 return Dir; 1973 } 1974 1975 OMPTargetTeamsDistributeSimdDirective * 1976 OMPTargetTeamsDistributeSimdDirective::CreateEmpty(const ASTContext &C, 1977 unsigned NumClauses, 1978 unsigned CollapsedNum, 1979 EmptyShell) { 1980 return createEmptyDirective<OMPTargetTeamsDistributeSimdDirective>( 1981 C, NumClauses, /*HasAssociatedStmt=*/true, 1982 numLoopChildren(CollapsedNum, OMPD_target_teams_distribute_simd), 1983 CollapsedNum); 1984 } 1985 1986 OMPInteropDirective * 1987 OMPInteropDirective::Create(const ASTContext &C, SourceLocation StartLoc, 1988 SourceLocation EndLoc, 1989 ArrayRef<OMPClause *> Clauses) { 1990 return createDirective<OMPInteropDirective>( 1991 C, Clauses, /*AssociatedStmt=*/nullptr, /*NumChildren=*/0, StartLoc, 1992 EndLoc); 1993 } 1994 1995 OMPInteropDirective *OMPInteropDirective::CreateEmpty(const ASTContext &C, 1996 unsigned NumClauses, 1997 EmptyShell) { 1998 return createEmptyDirective<OMPInteropDirective>(C, NumClauses); 1999 } 2000 2001 OMPDispatchDirective *OMPDispatchDirective::Create( 2002 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 2003 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 2004 SourceLocation TargetCallLoc) { 2005 auto *Dir = createDirective<OMPDispatchDirective>( 2006 C, Clauses, AssociatedStmt, /*NumChildren=*/0, StartLoc, EndLoc); 2007 Dir->setTargetCallLoc(TargetCallLoc); 2008 return Dir; 2009 } 2010 2011 OMPDispatchDirective *OMPDispatchDirective::CreateEmpty(const ASTContext &C, 2012 unsigned NumClauses, 2013 EmptyShell) { 2014 return createEmptyDirective<OMPDispatchDirective>(C, NumClauses, 2015 /*HasAssociatedStmt=*/true, 2016 /*NumChildren=*/0); 2017 } 2018 2019 OMPMaskedDirective *OMPMaskedDirective::Create(const ASTContext &C, 2020 SourceLocation StartLoc, 2021 SourceLocation EndLoc, 2022 ArrayRef<OMPClause *> Clauses, 2023 Stmt *AssociatedStmt) { 2024 return createDirective<OMPMaskedDirective>(C, Clauses, AssociatedStmt, 2025 /*NumChildren=*/0, StartLoc, 2026 EndLoc); 2027 } 2028 2029 OMPMaskedDirective *OMPMaskedDirective::CreateEmpty(const ASTContext &C, 2030 unsigned NumClauses, 2031 EmptyShell) { 2032 return createEmptyDirective<OMPMaskedDirective>(C, NumClauses, 2033 /*HasAssociatedStmt=*/true); 2034 } 2035