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