1 //===--- StmtOpenMP.cpp - Classes for OpenMP directives -------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file implements the subclesses of Stmt class declared in StmtOpenMP.h
12 //===----------------------------------------------------------------------===//
14 #include "clang/AST/StmtOpenMP.h"
16 #include "clang/AST/ASTContext.h"
18 using namespace clang;
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());
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());
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 "
36 std::copy(A.begin(), A.end(), getPrivateCounters().begin());
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());
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());
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());
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 *>());
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);
72 OMPParallelDirective *OMPParallelDirective::CreateEmpty(const ASTContext &C,
75 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelDirective),
76 llvm::alignOf<OMPClause *>());
78 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
79 return new (Mem) OMPParallelDirective(NumClauses);
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 *>());
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);
111 OMPSimdDirective *OMPSimdDirective::CreateEmpty(const ASTContext &C,
113 unsigned CollapsedNum,
115 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSimdDirective),
116 llvm::alignOf<OMPClause *>());
118 C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
119 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_simd));
120 return new (Mem) OMPSimdDirective(CollapsedNum, NumClauses);
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 *>());
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);
160 OMPForDirective *OMPForDirective::CreateEmpty(const ASTContext &C,
162 unsigned CollapsedNum,
164 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForDirective),
165 llvm::alignOf<OMPClause *>());
167 C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
168 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for));
169 return new (Mem) OMPForDirective(CollapsedNum, NumClauses);
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 *>());
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);
208 OMPForSimdDirective *OMPForSimdDirective::CreateEmpty(const ASTContext &C,
210 unsigned CollapsedNum,
212 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPForSimdDirective),
213 llvm::alignOf<OMPClause *>());
215 C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
216 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_for_simd));
217 return new (Mem) OMPForSimdDirective(CollapsedNum, NumClauses);
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 *>());
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);
235 OMPSectionsDirective *OMPSectionsDirective::CreateEmpty(const ASTContext &C,
238 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionsDirective),
239 llvm::alignOf<OMPClause *>());
241 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
242 return new (Mem) OMPSectionsDirective(NumClauses);
245 OMPSectionDirective *OMPSectionDirective::Create(const ASTContext &C,
246 SourceLocation StartLoc,
247 SourceLocation EndLoc,
248 Stmt *AssociatedStmt,
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);
259 OMPSectionDirective *OMPSectionDirective::CreateEmpty(const ASTContext &C,
261 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSectionDirective),
262 llvm::alignOf<Stmt *>());
263 void *Mem = C.Allocate(Size + sizeof(Stmt *));
264 return new (Mem) OMPSectionDirective();
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 *>());
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);
283 OMPSingleDirective *OMPSingleDirective::CreateEmpty(const ASTContext &C,
286 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPSingleDirective),
287 llvm::alignOf<OMPClause *>());
289 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
290 return new (Mem) OMPSingleDirective(NumClauses);
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);
305 OMPMasterDirective *OMPMasterDirective::CreateEmpty(const ASTContext &C,
307 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPMasterDirective),
308 llvm::alignOf<Stmt *>());
309 void *Mem = C.Allocate(Size + sizeof(Stmt *));
310 return new (Mem) OMPMasterDirective();
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 *>());
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);
328 OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C,
331 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective),
332 llvm::alignOf<OMPClause *>());
334 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
335 return new (Mem) OMPCriticalDirective(NumClauses);
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() +
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);
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 +
381 numLoopChildren(CollapsedNum, OMPD_parallel_for));
382 return new (Mem) OMPParallelForDirective(CollapsedNum, NumClauses);
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);
420 OMPParallelForSimdDirective *
421 OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C,
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);
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 *>());
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);
447 OMPParallelSectionsDirective *
448 OMPParallelSectionsDirective::CreateEmpty(const ASTContext &C,
449 unsigned NumClauses, EmptyShell) {
450 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective),
451 llvm::alignOf<OMPClause *>());
453 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
454 return new (Mem) OMPParallelSectionsDirective(NumClauses);
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 *>());
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);
473 OMPTaskDirective *OMPTaskDirective::CreateEmpty(const ASTContext &C,
476 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective),
477 llvm::alignOf<OMPClause *>());
479 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
480 return new (Mem) OMPTaskDirective(NumClauses);
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);
492 OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C,
494 void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
495 return new (Mem) OMPTaskyieldDirective();
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);
506 OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C,
508 void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
509 return new (Mem) OMPBarrierDirective();
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);
520 OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C,
522 void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
523 return new (Mem) OMPTaskwaitDirective();
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);
539 OMPTaskgroupDirective *OMPTaskgroupDirective::CreateEmpty(const ASTContext &C,
541 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskgroupDirective),
542 llvm::alignOf<Stmt *>());
543 void *Mem = C.Allocate(Size + sizeof(Stmt *));
544 return new (Mem) OMPTaskgroupDirective();
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);
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();
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);
582 OMPCancelDirective *OMPCancelDirective::CreateEmpty(const ASTContext &C,
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);
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);
605 OMPFlushDirective *OMPFlushDirective::CreateEmpty(const ASTContext &C,
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);
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 *>());
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);
630 OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(const ASTContext &C,
633 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective),
634 llvm::alignOf<OMPClause *>());
636 C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * NumClauses);
637 return new (Mem) OMPOrderedDirective(NumClauses);
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() +
648 OMPAtomicDirective *Dir =
649 new (Mem) OMPAtomicDirective(StartLoc, EndLoc, Clauses.size());
650 Dir->setClauses(Clauses);
651 Dir->setAssociatedStmt(AssociatedStmt);
655 Dir->setUpdateExpr(UE);
656 Dir->IsXLHSInRHSPart = IsXLHSInRHSPart;
657 Dir->IsPostfixUpdate = IsPostfixUpdate;
661 OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C,
664 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective),
665 llvm::alignOf<OMPClause *>());
667 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 5 * sizeof(Stmt *));
668 return new (Mem) OMPAtomicDirective(NumClauses);
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 *>());
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);
687 OMPTargetDirective *OMPTargetDirective::CreateEmpty(const ASTContext &C,
690 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective),
691 llvm::alignOf<OMPClause *>());
693 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
694 return new (Mem) OMPTargetDirective(NumClauses);
697 OMPTargetDataDirective *OMPTargetDataDirective::Create(
698 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
699 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
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);
711 OMPTargetDataDirective *OMPTargetDataDirective::CreateEmpty(const ASTContext &C,
715 C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPTargetDataDirective),
716 llvm::alignOf<OMPClause *>()) +
717 sizeof(OMPClause *) * N + sizeof(Stmt *));
718 return new (Mem) OMPTargetDataDirective(N);
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 *>());
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);
737 OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C,
740 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective),
741 llvm::alignOf<OMPClause *>());
743 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
744 return new (Mem) OMPTeamsDirective(NumClauses);
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 *>());
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);
782 OMPTaskLoopDirective *OMPTaskLoopDirective::CreateEmpty(const ASTContext &C,
784 unsigned CollapsedNum,
786 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskLoopDirective),
787 llvm::alignOf<OMPClause *>());
789 C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
790 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
791 return new (Mem) OMPTaskLoopDirective(CollapsedNum, NumClauses);
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() +
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);
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 +
836 numLoopChildren(CollapsedNum, OMPD_taskloop_simd));
837 return new (Mem) OMPTaskLoopSimdDirective(CollapsedNum, NumClauses);
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() +
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);
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 +
882 numLoopChildren(CollapsedNum, OMPD_distribute));
883 return new (Mem) OMPDistributeDirective(CollapsedNum, NumClauses);