1 //===--- StmtOpenMP.cpp - Classes for OpenMP directives -------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file is distributed under the University of Illinois Open Source 6 // License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements the subclesses of Stmt class declared in StmtOpenMP.h 11 // 12 //===----------------------------------------------------------------------===// 13 14 #include "clang/AST/StmtOpenMP.h" 15 16 #include "clang/AST/ASTContext.h" 17 18 using namespace clang; 19 20 void OMPExecutableDirective::setClauses(ArrayRef<OMPClause *> Clauses) { 21 assert(Clauses.size() == getNumClauses() && 22 "Number of clauses is not the same as the preallocated buffer"); 23 std::copy(Clauses.begin(), Clauses.end(), getClauses().begin()); 24 } 25 26 void OMPLoopDirective::setCounters(ArrayRef<Expr *> A) { 27 assert(A.size() == getCollapsedNumber() && 28 "Number of loop counters is not the same as the collapsed number"); 29 std::copy(A.begin(), A.end(), getCounters().begin()); 30 } 31 32 void OMPLoopDirective::setPrivateCounters(ArrayRef<Expr *> A) { 33 assert(A.size() == getCollapsedNumber() && "Number of loop private counters " 34 "is not the same as the collapsed " 35 "number"); 36 std::copy(A.begin(), A.end(), getPrivateCounters().begin()); 37 } 38 39 void OMPLoopDirective::setInits(ArrayRef<Expr *> A) { 40 assert(A.size() == getCollapsedNumber() && 41 "Number of counter inits is not the same as the collapsed number"); 42 std::copy(A.begin(), A.end(), getInits().begin()); 43 } 44 45 void OMPLoopDirective::setUpdates(ArrayRef<Expr *> A) { 46 assert(A.size() == getCollapsedNumber() && 47 "Number of counter updates is not the same as the collapsed number"); 48 std::copy(A.begin(), A.end(), getUpdates().begin()); 49 } 50 51 void OMPLoopDirective::setFinals(ArrayRef<Expr *> A) { 52 assert(A.size() == getCollapsedNumber() && 53 "Number of counter finals is not the same as the collapsed number"); 54 std::copy(A.begin(), A.end(), getFinals().begin()); 55 } 56 57 OMPParallelDirective *OMPParallelDirective::Create( 58 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 59 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) { 60 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelDirective), 61 llvm::alignOf<OMPClause *>()); 62 void *Mem = 63 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); 64 OMPParallelDirective *Dir = 65 new (Mem) OMPParallelDirective(StartLoc, EndLoc, Clauses.size()); 66 Dir->setClauses(Clauses); 67 Dir->setAssociatedStmt(AssociatedStmt); 68 Dir->setHasCancel(HasCancel); 69 return Dir; 70 } 71 72 OMPParallelDirective *OMPParallelDirective::CreateEmpty(const ASTContext &C, 73 unsigned NumClauses, 74 EmptyShell) { 75 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelDirective), 76 llvm::alignOf<OMPClause *>()); 77 void *Mem = 78 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); 79 return new (Mem) OMPParallelDirective(NumClauses); 80 } 81 82 OMPSimdDirective * 83 OMPSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc, 84 SourceLocation EndLoc, unsigned CollapsedNum, 85 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 86 const HelperExprs &Exprs) { 87 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective), 88 llvm::alignOf<OMPClause *>()); 89 void *Mem = 90 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + 91 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd)); 92 OMPSimdDirective *Dir = new (Mem) 93 OMPSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); 94 Dir->setClauses(Clauses); 95 Dir->setAssociatedStmt(AssociatedStmt); 96 Dir->setIterationVariable(Exprs.IterationVarRef); 97 Dir->setLastIteration(Exprs.LastIteration); 98 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 99 Dir->setPreCond(Exprs.PreCond); 100 Dir->setCond(Exprs.Cond); 101 Dir->setInit(Exprs.Init); 102 Dir->setInc(Exprs.Inc); 103 Dir->setCounters(Exprs.Counters); 104 Dir->setPrivateCounters(Exprs.PrivateCounters); 105 Dir->setInits(Exprs.Inits); 106 Dir->setUpdates(Exprs.Updates); 107 Dir->setFinals(Exprs.Finals); 108 return Dir; 109 } 110 111 OMPSimdDirective *OMPSimdDirective::CreateEmpty(const ASTContext &C, 112 unsigned NumClauses, 113 unsigned CollapsedNum, 114 EmptyShell) { 115 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective), 116 llvm::alignOf<OMPClause *>()); 117 void *Mem = 118 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 119 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd)); 120 return new (Mem) OMPSimdDirective(CollapsedNum, NumClauses); 121 } 122 123 OMPForDirective * 124 OMPForDirective::Create(const ASTContext &C, SourceLocation StartLoc, 125 SourceLocation EndLoc, unsigned CollapsedNum, 126 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 127 const HelperExprs &Exprs, bool HasCancel) { 128 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForDirective), 129 llvm::alignOf<OMPClause *>()); 130 void *Mem = 131 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + 132 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for)); 133 OMPForDirective *Dir = 134 new (Mem) OMPForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); 135 Dir->setClauses(Clauses); 136 Dir->setAssociatedStmt(AssociatedStmt); 137 Dir->setIterationVariable(Exprs.IterationVarRef); 138 Dir->setLastIteration(Exprs.LastIteration); 139 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 140 Dir->setPreCond(Exprs.PreCond); 141 Dir->setCond(Exprs.Cond); 142 Dir->setInit(Exprs.Init); 143 Dir->setInc(Exprs.Inc); 144 Dir->setIsLastIterVariable(Exprs.IL); 145 Dir->setLowerBoundVariable(Exprs.LB); 146 Dir->setUpperBoundVariable(Exprs.UB); 147 Dir->setStrideVariable(Exprs.ST); 148 Dir->setEnsureUpperBound(Exprs.EUB); 149 Dir->setNextLowerBound(Exprs.NLB); 150 Dir->setNextUpperBound(Exprs.NUB); 151 Dir->setCounters(Exprs.Counters); 152 Dir->setPrivateCounters(Exprs.PrivateCounters); 153 Dir->setInits(Exprs.Inits); 154 Dir->setUpdates(Exprs.Updates); 155 Dir->setFinals(Exprs.Finals); 156 Dir->setHasCancel(HasCancel); 157 return Dir; 158 } 159 160 OMPForDirective *OMPForDirective::CreateEmpty(const ASTContext &C, 161 unsigned NumClauses, 162 unsigned CollapsedNum, 163 EmptyShell) { 164 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForDirective), 165 llvm::alignOf<OMPClause *>()); 166 void *Mem = 167 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 168 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for)); 169 return new (Mem) OMPForDirective(CollapsedNum, NumClauses); 170 } 171 172 OMPForSimdDirective * 173 OMPForSimdDirective::Create(const ASTContext &C, SourceLocation StartLoc, 174 SourceLocation EndLoc, unsigned CollapsedNum, 175 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 176 const HelperExprs &Exprs) { 177 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForSimdDirective), 178 llvm::alignOf<OMPClause *>()); 179 void *Mem = 180 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + 181 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd)); 182 OMPForSimdDirective *Dir = new (Mem) 183 OMPForSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); 184 Dir->setClauses(Clauses); 185 Dir->setAssociatedStmt(AssociatedStmt); 186 Dir->setIterationVariable(Exprs.IterationVarRef); 187 Dir->setLastIteration(Exprs.LastIteration); 188 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 189 Dir->setPreCond(Exprs.PreCond); 190 Dir->setCond(Exprs.Cond); 191 Dir->setInit(Exprs.Init); 192 Dir->setInc(Exprs.Inc); 193 Dir->setIsLastIterVariable(Exprs.IL); 194 Dir->setLowerBoundVariable(Exprs.LB); 195 Dir->setUpperBoundVariable(Exprs.UB); 196 Dir->setStrideVariable(Exprs.ST); 197 Dir->setEnsureUpperBound(Exprs.EUB); 198 Dir->setNextLowerBound(Exprs.NLB); 199 Dir->setNextUpperBound(Exprs.NUB); 200 Dir->setCounters(Exprs.Counters); 201 Dir->setPrivateCounters(Exprs.PrivateCounters); 202 Dir->setInits(Exprs.Inits); 203 Dir->setUpdates(Exprs.Updates); 204 Dir->setFinals(Exprs.Finals); 205 return Dir; 206 } 207 208 OMPForSimdDirective *OMPForSimdDirective::CreateEmpty(const ASTContext &C, 209 unsigned NumClauses, 210 unsigned CollapsedNum, 211 EmptyShell) { 212 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForSimdDirective), 213 llvm::alignOf<OMPClause *>()); 214 void *Mem = 215 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 216 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd)); 217 return new (Mem) OMPForSimdDirective(CollapsedNum, NumClauses); 218 } 219 220 OMPSectionsDirective *OMPSectionsDirective::Create( 221 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 222 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) { 223 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective), 224 llvm::alignOf<OMPClause *>()); 225 void *Mem = 226 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); 227 OMPSectionsDirective *Dir = 228 new (Mem) OMPSectionsDirective(StartLoc, EndLoc, Clauses.size()); 229 Dir->setClauses(Clauses); 230 Dir->setAssociatedStmt(AssociatedStmt); 231 Dir->setHasCancel(HasCancel); 232 return Dir; 233 } 234 235 OMPSectionsDirective *OMPSectionsDirective::CreateEmpty(const ASTContext &C, 236 unsigned NumClauses, 237 EmptyShell) { 238 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective), 239 llvm::alignOf<OMPClause *>()); 240 void *Mem = 241 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); 242 return new (Mem) OMPSectionsDirective(NumClauses); 243 } 244 245 OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C, 246 SourceLocation StartLoc, 247 SourceLocation EndLoc, 248 Stmt *AssociatedStmt, 249 bool HasCancel) { 250 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionDirective), 251 llvm::alignOf<Stmt *>()); 252 void *Mem = C.Allocate(Size + sizeof(Stmt *)); 253 OMPSectionDirective *Dir = new (Mem) OMPSectionDirective(StartLoc, EndLoc); 254 Dir->setAssociatedStmt(AssociatedStmt); 255 Dir->setHasCancel(HasCancel); 256 return Dir; 257 } 258 259 OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C, 260 EmptyShell) { 261 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionDirective), 262 llvm::alignOf<Stmt *>()); 263 void *Mem = C.Allocate(Size + sizeof(Stmt *)); 264 return new (Mem) OMPSectionDirective(); 265 } 266 267 OMPSingleDirective *OMPSingleDirective::Create(const ASTContext &C, 268 SourceLocation StartLoc, 269 SourceLocation EndLoc, 270 ArrayRef<OMPClause *> Clauses, 271 Stmt *AssociatedStmt) { 272 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSingleDirective), 273 llvm::alignOf<OMPClause *>()); 274 void *Mem = 275 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); 276 OMPSingleDirective *Dir = 277 new (Mem) OMPSingleDirective(StartLoc, EndLoc, Clauses.size()); 278 Dir->setClauses(Clauses); 279 Dir->setAssociatedStmt(AssociatedStmt); 280 return Dir; 281 } 282 283 OMPSingleDirective *OMPSingleDirective::CreateEmpty(const ASTContext &C, 284 unsigned NumClauses, 285 EmptyShell) { 286 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSingleDirective), 287 llvm::alignOf<OMPClause *>()); 288 void *Mem = 289 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); 290 return new (Mem) OMPSingleDirective(NumClauses); 291 } 292 293 OMPMasterDirective *OMPMasterDirective::Create(const ASTContext &C, 294 SourceLocation StartLoc, 295 SourceLocation EndLoc, 296 Stmt *AssociatedStmt) { 297 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPMasterDirective), 298 llvm::alignOf<Stmt *>()); 299 void *Mem = C.Allocate(Size + sizeof(Stmt *)); 300 OMPMasterDirective *Dir = new (Mem) OMPMasterDirective(StartLoc, EndLoc); 301 Dir->setAssociatedStmt(AssociatedStmt); 302 return Dir; 303 } 304 305 OMPMasterDirective *OMPMasterDirective::CreateEmpty(const ASTContext &C, 306 EmptyShell) { 307 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPMasterDirective), 308 llvm::alignOf<Stmt *>()); 309 void *Mem = C.Allocate(Size + sizeof(Stmt *)); 310 return new (Mem) OMPMasterDirective(); 311 } 312 313 OMPCriticalDirective *OMPCriticalDirective::Create( 314 const ASTContext &C, const DeclarationNameInfo &Name, 315 SourceLocation StartLoc, SourceLocation EndLoc, 316 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) { 317 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective), 318 llvm::alignOf<OMPClause *>()); 319 void *Mem = 320 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); 321 OMPCriticalDirective *Dir = 322 new (Mem) OMPCriticalDirective(Name, StartLoc, EndLoc, Clauses.size()); 323 Dir->setClauses(Clauses); 324 Dir->setAssociatedStmt(AssociatedStmt); 325 return Dir; 326 } 327 328 OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C, 329 unsigned NumClauses, 330 EmptyShell) { 331 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective), 332 llvm::alignOf<OMPClause *>()); 333 void *Mem = 334 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); 335 return new (Mem) OMPCriticalDirective(NumClauses); 336 } 337 338 OMPParallelForDirective *OMPParallelForDirective::Create( 339 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 340 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 341 const HelperExprs &Exprs, bool HasCancel) { 342 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective), 343 llvm::alignOf<OMPClause *>()); 344 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + 345 sizeof(Stmt *) * 346 numLoopChildren(CollapsedNum, OMPD_parallel_for)); 347 OMPParallelForDirective *Dir = new (Mem) 348 OMPParallelForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); 349 Dir->setClauses(Clauses); 350 Dir->setAssociatedStmt(AssociatedStmt); 351 Dir->setIterationVariable(Exprs.IterationVarRef); 352 Dir->setLastIteration(Exprs.LastIteration); 353 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 354 Dir->setPreCond(Exprs.PreCond); 355 Dir->setCond(Exprs.Cond); 356 Dir->setInit(Exprs.Init); 357 Dir->setInc(Exprs.Inc); 358 Dir->setIsLastIterVariable(Exprs.IL); 359 Dir->setLowerBoundVariable(Exprs.LB); 360 Dir->setUpperBoundVariable(Exprs.UB); 361 Dir->setStrideVariable(Exprs.ST); 362 Dir->setEnsureUpperBound(Exprs.EUB); 363 Dir->setNextLowerBound(Exprs.NLB); 364 Dir->setNextUpperBound(Exprs.NUB); 365 Dir->setCounters(Exprs.Counters); 366 Dir->setPrivateCounters(Exprs.PrivateCounters); 367 Dir->setInits(Exprs.Inits); 368 Dir->setUpdates(Exprs.Updates); 369 Dir->setFinals(Exprs.Finals); 370 Dir->setHasCancel(HasCancel); 371 return Dir; 372 } 373 374 OMPParallelForDirective * 375 OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, 376 unsigned CollapsedNum, EmptyShell) { 377 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective), 378 llvm::alignOf<OMPClause *>()); 379 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 380 sizeof(Stmt *) * 381 numLoopChildren(CollapsedNum, OMPD_parallel_for)); 382 return new (Mem) OMPParallelForDirective(CollapsedNum, NumClauses); 383 } 384 385 OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create( 386 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 387 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 388 const HelperExprs &Exprs) { 389 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective), 390 llvm::alignOf<OMPClause *>()); 391 void *Mem = C.Allocate( 392 Size + sizeof(OMPClause *) * Clauses.size() + 393 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd)); 394 OMPParallelForSimdDirective *Dir = new (Mem) OMPParallelForSimdDirective( 395 StartLoc, EndLoc, CollapsedNum, Clauses.size()); 396 Dir->setClauses(Clauses); 397 Dir->setAssociatedStmt(AssociatedStmt); 398 Dir->setIterationVariable(Exprs.IterationVarRef); 399 Dir->setLastIteration(Exprs.LastIteration); 400 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 401 Dir->setPreCond(Exprs.PreCond); 402 Dir->setCond(Exprs.Cond); 403 Dir->setInit(Exprs.Init); 404 Dir->setInc(Exprs.Inc); 405 Dir->setIsLastIterVariable(Exprs.IL); 406 Dir->setLowerBoundVariable(Exprs.LB); 407 Dir->setUpperBoundVariable(Exprs.UB); 408 Dir->setStrideVariable(Exprs.ST); 409 Dir->setEnsureUpperBound(Exprs.EUB); 410 Dir->setNextLowerBound(Exprs.NLB); 411 Dir->setNextUpperBound(Exprs.NUB); 412 Dir->setCounters(Exprs.Counters); 413 Dir->setPrivateCounters(Exprs.PrivateCounters); 414 Dir->setInits(Exprs.Inits); 415 Dir->setUpdates(Exprs.Updates); 416 Dir->setFinals(Exprs.Finals); 417 return Dir; 418 } 419 420 OMPParallelForSimdDirective * 421 OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C, 422 unsigned NumClauses, 423 unsigned CollapsedNum, EmptyShell) { 424 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective), 425 llvm::alignOf<OMPClause *>()); 426 void *Mem = C.Allocate( 427 Size + sizeof(OMPClause *) * NumClauses + 428 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd)); 429 return new (Mem) OMPParallelForSimdDirective(CollapsedNum, NumClauses); 430 } 431 432 OMPParallelSectionsDirective *OMPParallelSectionsDirective::Create( 433 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 434 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) { 435 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective), 436 llvm::alignOf<OMPClause *>()); 437 void *Mem = 438 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); 439 OMPParallelSectionsDirective *Dir = 440 new (Mem) OMPParallelSectionsDirective(StartLoc, EndLoc, Clauses.size()); 441 Dir->setClauses(Clauses); 442 Dir->setAssociatedStmt(AssociatedStmt); 443 Dir->setHasCancel(HasCancel); 444 return Dir; 445 } 446 447 OMPParallelSectionsDirective * 448 OMPParallelSectionsDirective::CreateEmpty(const ASTContext &C, 449 unsigned NumClauses, EmptyShell) { 450 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective), 451 llvm::alignOf<OMPClause *>()); 452 void *Mem = 453 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); 454 return new (Mem) OMPParallelSectionsDirective(NumClauses); 455 } 456 457 OMPTaskDirective * 458 OMPTaskDirective::Create(const ASTContext &C, SourceLocation StartLoc, 459 SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses, 460 Stmt *AssociatedStmt, bool HasCancel) { 461 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective), 462 llvm::alignOf<OMPClause *>()); 463 void *Mem = 464 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); 465 OMPTaskDirective *Dir = 466 new (Mem) OMPTaskDirective(StartLoc, EndLoc, Clauses.size()); 467 Dir->setClauses(Clauses); 468 Dir->setAssociatedStmt(AssociatedStmt); 469 Dir->setHasCancel(HasCancel); 470 return Dir; 471 } 472 473 OMPTaskDirective *OMPTaskDirective::CreateEmpty(const ASTContext &C, 474 unsigned NumClauses, 475 EmptyShell) { 476 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective), 477 llvm::alignOf<OMPClause *>()); 478 void *Mem = 479 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); 480 return new (Mem) OMPTaskDirective(NumClauses); 481 } 482 483 OMPTaskyieldDirective *OMPTaskyieldDirective::Create(const ASTContext &C, 484 SourceLocation StartLoc, 485 SourceLocation EndLoc) { 486 void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective)); 487 OMPTaskyieldDirective *Dir = 488 new (Mem) OMPTaskyieldDirective(StartLoc, EndLoc); 489 return Dir; 490 } 491 492 OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C, 493 EmptyShell) { 494 void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective)); 495 return new (Mem) OMPTaskyieldDirective(); 496 } 497 498 OMPBarrierDirective *OMPBarrierDirective::Create(const ASTContext &C, 499 SourceLocation StartLoc, 500 SourceLocation EndLoc) { 501 void *Mem = C.Allocate(sizeof(OMPBarrierDirective)); 502 OMPBarrierDirective *Dir = new (Mem) OMPBarrierDirective(StartLoc, EndLoc); 503 return Dir; 504 } 505 506 OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C, 507 EmptyShell) { 508 void *Mem = C.Allocate(sizeof(OMPBarrierDirective)); 509 return new (Mem) OMPBarrierDirective(); 510 } 511 512 OMPTaskwaitDirective *OMPTaskwaitDirective::Create(const ASTContext &C, 513 SourceLocation StartLoc, 514 SourceLocation EndLoc) { 515 void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective)); 516 OMPTaskwaitDirective *Dir = new (Mem) OMPTaskwaitDirective(StartLoc, EndLoc); 517 return Dir; 518 } 519 520 OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C, 521 EmptyShell) { 522 void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective)); 523 return new (Mem) OMPTaskwaitDirective(); 524 } 525 526 OMPTaskgroupDirective *OMPTaskgroupDirective::Create(const ASTContext &C, 527 SourceLocation StartLoc, 528 SourceLocation EndLoc, 529 Stmt *AssociatedStmt) { 530 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskgroupDirective), 531 llvm::alignOf<Stmt *>()); 532 void *Mem = C.Allocate(Size + sizeof(Stmt *)); 533 OMPTaskgroupDirective *Dir = 534 new (Mem) OMPTaskgroupDirective(StartLoc, EndLoc); 535 Dir->setAssociatedStmt(AssociatedStmt); 536 return Dir; 537 } 538 539 OMPTaskgroupDirective *OMPTaskgroupDirective::CreateEmpty(const ASTContext &C, 540 EmptyShell) { 541 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskgroupDirective), 542 llvm::alignOf<Stmt *>()); 543 void *Mem = C.Allocate(Size + sizeof(Stmt *)); 544 return new (Mem) OMPTaskgroupDirective(); 545 } 546 547 OMPCancellationPointDirective *OMPCancellationPointDirective::Create( 548 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 549 OpenMPDirectiveKind CancelRegion) { 550 unsigned Size = llvm::RoundUpToAlignment( 551 sizeof(OMPCancellationPointDirective), llvm::alignOf<Stmt *>()); 552 void *Mem = C.Allocate(Size); 553 OMPCancellationPointDirective *Dir = 554 new (Mem) OMPCancellationPointDirective(StartLoc, EndLoc); 555 Dir->setCancelRegion(CancelRegion); 556 return Dir; 557 } 558 559 OMPCancellationPointDirective * 560 OMPCancellationPointDirective::CreateEmpty(const ASTContext &C, EmptyShell) { 561 unsigned Size = llvm::RoundUpToAlignment( 562 sizeof(OMPCancellationPointDirective), llvm::alignOf<Stmt *>()); 563 void *Mem = C.Allocate(Size); 564 return new (Mem) OMPCancellationPointDirective(); 565 } 566 567 OMPCancelDirective * 568 OMPCancelDirective::Create(const ASTContext &C, SourceLocation StartLoc, 569 SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses, 570 OpenMPDirectiveKind CancelRegion) { 571 unsigned Size = llvm::RoundUpToAlignment( 572 sizeof(OMPCancelDirective) + sizeof(OMPClause *) * Clauses.size(), 573 llvm::alignOf<Stmt *>()); 574 void *Mem = C.Allocate(Size); 575 OMPCancelDirective *Dir = 576 new (Mem) OMPCancelDirective(StartLoc, EndLoc, Clauses.size()); 577 Dir->setClauses(Clauses); 578 Dir->setCancelRegion(CancelRegion); 579 return Dir; 580 } 581 582 OMPCancelDirective *OMPCancelDirective::CreateEmpty(const ASTContext &C, 583 unsigned NumClauses, 584 EmptyShell) { 585 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCancelDirective) + 586 sizeof(OMPClause *) * NumClauses, 587 llvm::alignOf<Stmt *>()); 588 void *Mem = C.Allocate(Size); 589 return new (Mem) OMPCancelDirective(NumClauses); 590 } 591 592 OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C, 593 SourceLocation StartLoc, 594 SourceLocation EndLoc, 595 ArrayRef<OMPClause *> Clauses) { 596 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPFlushDirective), 597 llvm::alignOf<OMPClause *>()); 598 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size()); 599 OMPFlushDirective *Dir = 600 new (Mem) OMPFlushDirective(StartLoc, EndLoc, Clauses.size()); 601 Dir->setClauses(Clauses); 602 return Dir; 603 } 604 605 OMPFlushDirective *OMPFlushDirective::CreateEmpty(const ASTContext &C, 606 unsigned NumClauses, 607 EmptyShell) { 608 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPFlushDirective), 609 llvm::alignOf<OMPClause *>()); 610 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses); 611 return new (Mem) OMPFlushDirective(NumClauses); 612 } 613 614 OMPOrderedDirective *OMPOrderedDirective::Create(const ASTContext &C, 615 SourceLocation StartLoc, 616 SourceLocation EndLoc, 617 ArrayRef<OMPClause *> Clauses, 618 Stmt *AssociatedStmt) { 619 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective), 620 llvm::alignOf<OMPClause *>()); 621 void *Mem = 622 C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * Clauses.size()); 623 OMPOrderedDirective *Dir = 624 new (Mem) OMPOrderedDirective(StartLoc, EndLoc, Clauses.size()); 625 Dir->setClauses(Clauses); 626 Dir->setAssociatedStmt(AssociatedStmt); 627 return Dir; 628 } 629 630 OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(const ASTContext &C, 631 unsigned NumClauses, 632 EmptyShell) { 633 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective), 634 llvm::alignOf<OMPClause *>()); 635 void *Mem = 636 C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * NumClauses); 637 return new (Mem) OMPOrderedDirective(NumClauses); 638 } 639 640 OMPAtomicDirective *OMPAtomicDirective::Create( 641 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 642 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V, 643 Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) { 644 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective), 645 llvm::alignOf<OMPClause *>()); 646 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + 647 5 * sizeof(Stmt *)); 648 OMPAtomicDirective *Dir = 649 new (Mem) OMPAtomicDirective(StartLoc, EndLoc, Clauses.size()); 650 Dir->setClauses(Clauses); 651 Dir->setAssociatedStmt(AssociatedStmt); 652 Dir->setX(X); 653 Dir->setV(V); 654 Dir->setExpr(E); 655 Dir->setUpdateExpr(UE); 656 Dir->IsXLHSInRHSPart = IsXLHSInRHSPart; 657 Dir->IsPostfixUpdate = IsPostfixUpdate; 658 return Dir; 659 } 660 661 OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C, 662 unsigned NumClauses, 663 EmptyShell) { 664 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective), 665 llvm::alignOf<OMPClause *>()); 666 void *Mem = 667 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 5 * sizeof(Stmt *)); 668 return new (Mem) OMPAtomicDirective(NumClauses); 669 } 670 671 OMPTargetDirective *OMPTargetDirective::Create(const ASTContext &C, 672 SourceLocation StartLoc, 673 SourceLocation EndLoc, 674 ArrayRef<OMPClause *> Clauses, 675 Stmt *AssociatedStmt) { 676 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective), 677 llvm::alignOf<OMPClause *>()); 678 void *Mem = 679 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); 680 OMPTargetDirective *Dir = 681 new (Mem) OMPTargetDirective(StartLoc, EndLoc, Clauses.size()); 682 Dir->setClauses(Clauses); 683 Dir->setAssociatedStmt(AssociatedStmt); 684 return Dir; 685 } 686 687 OMPTargetDirective *OMPTargetDirective::CreateEmpty(const ASTContext &C, 688 unsigned NumClauses, 689 EmptyShell) { 690 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective), 691 llvm::alignOf<OMPClause *>()); 692 void *Mem = 693 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); 694 return new (Mem) OMPTargetDirective(NumClauses); 695 } 696 697 OMPTargetDataDirective *OMPTargetDataDirective::Create( 698 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 699 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) { 700 void *Mem = 701 C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPTargetDataDirective), 702 llvm::alignOf<OMPClause *>()) + 703 sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); 704 OMPTargetDataDirective *Dir = 705 new (Mem) OMPTargetDataDirective(StartLoc, EndLoc, Clauses.size()); 706 Dir->setClauses(Clauses); 707 Dir->setAssociatedStmt(AssociatedStmt); 708 return Dir; 709 } 710 711 OMPTargetDataDirective *OMPTargetDataDirective::CreateEmpty(const ASTContext &C, 712 unsigned N, 713 EmptyShell) { 714 void *Mem = 715 C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPTargetDataDirective), 716 llvm::alignOf<OMPClause *>()) + 717 sizeof(OMPClause *) * N + sizeof(Stmt *)); 718 return new (Mem) OMPTargetDataDirective(N); 719 } 720 721 OMPTeamsDirective *OMPTeamsDirective::Create(const ASTContext &C, 722 SourceLocation StartLoc, 723 SourceLocation EndLoc, 724 ArrayRef<OMPClause *> Clauses, 725 Stmt *AssociatedStmt) { 726 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective), 727 llvm::alignOf<OMPClause *>()); 728 void *Mem = 729 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *)); 730 OMPTeamsDirective *Dir = 731 new (Mem) OMPTeamsDirective(StartLoc, EndLoc, Clauses.size()); 732 Dir->setClauses(Clauses); 733 Dir->setAssociatedStmt(AssociatedStmt); 734 return Dir; 735 } 736 737 OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C, 738 unsigned NumClauses, 739 EmptyShell) { 740 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective), 741 llvm::alignOf<OMPClause *>()); 742 void *Mem = 743 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *)); 744 return new (Mem) OMPTeamsDirective(NumClauses); 745 } 746 747 OMPTaskLoopDirective *OMPTaskLoopDirective::Create( 748 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 749 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 750 const HelperExprs &Exprs) { 751 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskLoopDirective), 752 llvm::alignOf<OMPClause *>()); 753 void *Mem = 754 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + 755 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop)); 756 OMPTaskLoopDirective *Dir = new (Mem) 757 OMPTaskLoopDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); 758 Dir->setClauses(Clauses); 759 Dir->setAssociatedStmt(AssociatedStmt); 760 Dir->setIterationVariable(Exprs.IterationVarRef); 761 Dir->setLastIteration(Exprs.LastIteration); 762 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 763 Dir->setPreCond(Exprs.PreCond); 764 Dir->setCond(Exprs.Cond); 765 Dir->setInit(Exprs.Init); 766 Dir->setInc(Exprs.Inc); 767 Dir->setIsLastIterVariable(Exprs.IL); 768 Dir->setLowerBoundVariable(Exprs.LB); 769 Dir->setUpperBoundVariable(Exprs.UB); 770 Dir->setStrideVariable(Exprs.ST); 771 Dir->setEnsureUpperBound(Exprs.EUB); 772 Dir->setNextLowerBound(Exprs.NLB); 773 Dir->setNextUpperBound(Exprs.NUB); 774 Dir->setCounters(Exprs.Counters); 775 Dir->setPrivateCounters(Exprs.PrivateCounters); 776 Dir->setInits(Exprs.Inits); 777 Dir->setUpdates(Exprs.Updates); 778 Dir->setFinals(Exprs.Finals); 779 return Dir; 780 } 781 782 OMPTaskLoopDirective *OMPTaskLoopDirective::CreateEmpty(const ASTContext &C, 783 unsigned NumClauses, 784 unsigned CollapsedNum, 785 EmptyShell) { 786 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskLoopDirective), 787 llvm::alignOf<OMPClause *>()); 788 void *Mem = 789 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 790 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop)); 791 return new (Mem) OMPTaskLoopDirective(CollapsedNum, NumClauses); 792 } 793 794 OMPTaskLoopSimdDirective *OMPTaskLoopSimdDirective::Create( 795 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 796 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 797 const HelperExprs &Exprs) { 798 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskLoopSimdDirective), 799 llvm::alignOf<OMPClause *>()); 800 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + 801 sizeof(Stmt *) * 802 numLoopChildren(CollapsedNum, OMPD_taskloop_simd)); 803 OMPTaskLoopSimdDirective *Dir = new (Mem) 804 OMPTaskLoopSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); 805 Dir->setClauses(Clauses); 806 Dir->setAssociatedStmt(AssociatedStmt); 807 Dir->setIterationVariable(Exprs.IterationVarRef); 808 Dir->setLastIteration(Exprs.LastIteration); 809 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 810 Dir->setPreCond(Exprs.PreCond); 811 Dir->setCond(Exprs.Cond); 812 Dir->setInit(Exprs.Init); 813 Dir->setInc(Exprs.Inc); 814 Dir->setIsLastIterVariable(Exprs.IL); 815 Dir->setLowerBoundVariable(Exprs.LB); 816 Dir->setUpperBoundVariable(Exprs.UB); 817 Dir->setStrideVariable(Exprs.ST); 818 Dir->setEnsureUpperBound(Exprs.EUB); 819 Dir->setNextLowerBound(Exprs.NLB); 820 Dir->setNextUpperBound(Exprs.NUB); 821 Dir->setCounters(Exprs.Counters); 822 Dir->setPrivateCounters(Exprs.PrivateCounters); 823 Dir->setInits(Exprs.Inits); 824 Dir->setUpdates(Exprs.Updates); 825 Dir->setFinals(Exprs.Finals); 826 return Dir; 827 } 828 829 OMPTaskLoopSimdDirective * 830 OMPTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, 831 unsigned CollapsedNum, EmptyShell) { 832 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskLoopSimdDirective), 833 llvm::alignOf<OMPClause *>()); 834 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 835 sizeof(Stmt *) * 836 numLoopChildren(CollapsedNum, OMPD_taskloop_simd)); 837 return new (Mem) OMPTaskLoopSimdDirective(CollapsedNum, NumClauses); 838 } 839 840 OMPDistributeDirective *OMPDistributeDirective::Create( 841 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc, 842 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, 843 const HelperExprs &Exprs) { 844 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPDistributeDirective), 845 llvm::alignOf<OMPClause *>()); 846 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + 847 sizeof(Stmt *) * 848 numLoopChildren(CollapsedNum, OMPD_distribute)); 849 OMPDistributeDirective *Dir = new (Mem) 850 OMPDistributeDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size()); 851 Dir->setClauses(Clauses); 852 Dir->setAssociatedStmt(AssociatedStmt); 853 Dir->setIterationVariable(Exprs.IterationVarRef); 854 Dir->setLastIteration(Exprs.LastIteration); 855 Dir->setCalcLastIteration(Exprs.CalcLastIteration); 856 Dir->setPreCond(Exprs.PreCond); 857 Dir->setCond(Exprs.Cond); 858 Dir->setInit(Exprs.Init); 859 Dir->setInc(Exprs.Inc); 860 Dir->setIsLastIterVariable(Exprs.IL); 861 Dir->setLowerBoundVariable(Exprs.LB); 862 Dir->setUpperBoundVariable(Exprs.UB); 863 Dir->setStrideVariable(Exprs.ST); 864 Dir->setEnsureUpperBound(Exprs.EUB); 865 Dir->setNextLowerBound(Exprs.NLB); 866 Dir->setNextUpperBound(Exprs.NUB); 867 Dir->setCounters(Exprs.Counters); 868 Dir->setPrivateCounters(Exprs.PrivateCounters); 869 Dir->setInits(Exprs.Inits); 870 Dir->setUpdates(Exprs.Updates); 871 Dir->setFinals(Exprs.Finals); 872 return Dir; 873 } 874 875 OMPDistributeDirective * 876 OMPDistributeDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses, 877 unsigned CollapsedNum, EmptyShell) { 878 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPDistributeDirective), 879 llvm::alignOf<OMPClause *>()); 880 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 881 sizeof(Stmt *) * 882 numLoopChildren(CollapsedNum, OMPD_distribute)); 883 return new (Mem) OMPDistributeDirective(CollapsedNum, NumClauses); 884 } 885
