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