Gitiles
Code Review Sign In
gerrit-public.fairphone.software / toolchain / llvm-project / 0a6ed84a0d2f3c7c5aeb9d6b702ac127613d2b1b / . / clang / lib / AST / StmtOpenMP.cpp
blob: b6844edd8ccf43a0fc339bc069fcf2206b857ae4 [file] [log] [blame]
James Y Knightb8bfd962015-10-02 13:41:04 +0000[diff] [blame]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
18using namespace clang;
19
20void 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
26void 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
32void 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
39void 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
45void 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
51void 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
57OMPParallelDirective *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
72OMPParallelDirective *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
82OMPSimdDirective *
83OMPSimdDirective::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
111OMPSimdDirective *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
123OMPForDirective *
124OMPForDirective::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
160OMPForDirective *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
172OMPForSimdDirective *
173OMPForSimdDirective::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
208OMPForSimdDirective *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
220OMPSectionsDirective *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
235OMPSectionsDirective *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
245OMPSectionDirective *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
259OMPSectionDirective *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
267OMPSingleDirective *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
283OMPSingleDirective *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
293OMPMasterDirective *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
305OMPMasterDirective *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
313OMPCriticalDirective *OMPCriticalDirective::Create(
314 const ASTContext &C, const DeclarationNameInfo &Name,
315 SourceLocation StartLoc, SourceLocation EndLoc, Stmt *AssociatedStmt) {
316 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective),
317 llvm::alignOf<Stmt *>());
318 void *Mem = C.Allocate(Size + sizeof(Stmt *));
319 OMPCriticalDirective *Dir =
320 new (Mem) OMPCriticalDirective(Name, StartLoc, EndLoc);
321 Dir->setAssociatedStmt(AssociatedStmt);
322 return Dir;
323}
324
325OMPCriticalDirective *OMPCriticalDirective::CreateEmpty(const ASTContext &C,
326 EmptyShell) {
327 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCriticalDirective),
328 llvm::alignOf<Stmt *>());
329 void *Mem = C.Allocate(Size + sizeof(Stmt *));
330 return new (Mem) OMPCriticalDirective();
331}
332
333OMPParallelForDirective *OMPParallelForDirective::Create(
334 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
335 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
336 const HelperExprs &Exprs, bool HasCancel) {
337 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective),
338 llvm::alignOf<OMPClause *>());
339 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
340 sizeof(Stmt *) *
341 numLoopChildren(CollapsedNum, OMPD_parallel_for));
342 OMPParallelForDirective *Dir = new (Mem)
343 OMPParallelForDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
344 Dir->setClauses(Clauses);
345 Dir->setAssociatedStmt(AssociatedStmt);
346 Dir->setIterationVariable(Exprs.IterationVarRef);
347 Dir->setLastIteration(Exprs.LastIteration);
348 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
349 Dir->setPreCond(Exprs.PreCond);
350 Dir->setCond(Exprs.Cond);
351 Dir->setInit(Exprs.Init);
352 Dir->setInc(Exprs.Inc);
353 Dir->setIsLastIterVariable(Exprs.IL);
354 Dir->setLowerBoundVariable(Exprs.LB);
355 Dir->setUpperBoundVariable(Exprs.UB);
356 Dir->setStrideVariable(Exprs.ST);
357 Dir->setEnsureUpperBound(Exprs.EUB);
358 Dir->setNextLowerBound(Exprs.NLB);
359 Dir->setNextUpperBound(Exprs.NUB);
360 Dir->setCounters(Exprs.Counters);
361 Dir->setPrivateCounters(Exprs.PrivateCounters);
362 Dir->setInits(Exprs.Inits);
363 Dir->setUpdates(Exprs.Updates);
364 Dir->setFinals(Exprs.Finals);
365 Dir->setHasCancel(HasCancel);
366 return Dir;
367}
368
369OMPParallelForDirective *
370OMPParallelForDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
371 unsigned CollapsedNum, EmptyShell) {
372 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForDirective),
373 llvm::alignOf<OMPClause *>());
374 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
375 sizeof(Stmt *) *
376 numLoopChildren(CollapsedNum, OMPD_parallel_for));
377 return new (Mem) OMPParallelForDirective(CollapsedNum, NumClauses);
378}
379
380OMPParallelForSimdDirective *OMPParallelForSimdDirective::Create(
381 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
382 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
383 const HelperExprs &Exprs) {
384 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective),
385 llvm::alignOf<OMPClause *>());
386 void *Mem = C.Allocate(
387 Size + sizeof(OMPClause *) * Clauses.size() +
388 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
389 OMPParallelForSimdDirective *Dir = new (Mem) OMPParallelForSimdDirective(
390 StartLoc, EndLoc, CollapsedNum, Clauses.size());
391 Dir->setClauses(Clauses);
392 Dir->setAssociatedStmt(AssociatedStmt);
393 Dir->setIterationVariable(Exprs.IterationVarRef);
394 Dir->setLastIteration(Exprs.LastIteration);
395 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
396 Dir->setPreCond(Exprs.PreCond);
397 Dir->setCond(Exprs.Cond);
398 Dir->setInit(Exprs.Init);
399 Dir->setInc(Exprs.Inc);
400 Dir->setIsLastIterVariable(Exprs.IL);
401 Dir->setLowerBoundVariable(Exprs.LB);
402 Dir->setUpperBoundVariable(Exprs.UB);
403 Dir->setStrideVariable(Exprs.ST);
404 Dir->setEnsureUpperBound(Exprs.EUB);
405 Dir->setNextLowerBound(Exprs.NLB);
406 Dir->setNextUpperBound(Exprs.NUB);
407 Dir->setCounters(Exprs.Counters);
408 Dir->setPrivateCounters(Exprs.PrivateCounters);
409 Dir->setInits(Exprs.Inits);
410 Dir->setUpdates(Exprs.Updates);
411 Dir->setFinals(Exprs.Finals);
412 return Dir;
413}
414
415OMPParallelForSimdDirective *
416OMPParallelForSimdDirective::CreateEmpty(const ASTContext &C,
417 unsigned NumClauses,
418 unsigned CollapsedNum, EmptyShell) {
419 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelForSimdDirective),
420 llvm::alignOf<OMPClause *>());
421 void *Mem = C.Allocate(
422 Size + sizeof(OMPClause *) * NumClauses +
423 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_parallel_for_simd));
424 return new (Mem) OMPParallelForSimdDirective(CollapsedNum, NumClauses);
425}
426
427OMPParallelSectionsDirective *OMPParallelSectionsDirective::Create(
428 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
429 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, bool HasCancel) {
430 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective),
431 llvm::alignOf<OMPClause *>());
432 void *Mem =
433 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
434 OMPParallelSectionsDirective *Dir =
435 new (Mem) OMPParallelSectionsDirective(StartLoc, EndLoc, Clauses.size());
436 Dir->setClauses(Clauses);
437 Dir->setAssociatedStmt(AssociatedStmt);
438 Dir->setHasCancel(HasCancel);
439 return Dir;
440}
441
442OMPParallelSectionsDirective *
443OMPParallelSectionsDirective::CreateEmpty(const ASTContext &C,
444 unsigned NumClauses, EmptyShell) {
445 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPParallelSectionsDirective),
446 llvm::alignOf<OMPClause *>());
447 void *Mem =
448 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
449 return new (Mem) OMPParallelSectionsDirective(NumClauses);
450}
451
452OMPTaskDirective *
453OMPTaskDirective::Create(const ASTContext &C, SourceLocation StartLoc,
454 SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
455 Stmt *AssociatedStmt, bool HasCancel) {
456 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective),
457 llvm::alignOf<OMPClause *>());
458 void *Mem =
459 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
460 OMPTaskDirective *Dir =
461 new (Mem) OMPTaskDirective(StartLoc, EndLoc, Clauses.size());
462 Dir->setClauses(Clauses);
463 Dir->setAssociatedStmt(AssociatedStmt);
464 Dir->setHasCancel(HasCancel);
465 return Dir;
466}
467
468OMPTaskDirective *OMPTaskDirective::CreateEmpty(const ASTContext &C,
469 unsigned NumClauses,
470 EmptyShell) {
471 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskDirective),
472 llvm::alignOf<OMPClause *>());
473 void *Mem =
474 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
475 return new (Mem) OMPTaskDirective(NumClauses);
476}
477
478OMPTaskyieldDirective *OMPTaskyieldDirective::Create(const ASTContext &C,
479 SourceLocation StartLoc,
480 SourceLocation EndLoc) {
481 void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
482 OMPTaskyieldDirective *Dir =
483 new (Mem) OMPTaskyieldDirective(StartLoc, EndLoc);
484 return Dir;
485}
486
487OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C,
488 EmptyShell) {
489 void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
490 return new (Mem) OMPTaskyieldDirective();
491}
492
493OMPBarrierDirective *OMPBarrierDirective::Create(const ASTContext &C,
494 SourceLocation StartLoc,
495 SourceLocation EndLoc) {
496 void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
497 OMPBarrierDirective *Dir = new (Mem) OMPBarrierDirective(StartLoc, EndLoc);
498 return Dir;
499}
500
501OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C,
502 EmptyShell) {
503 void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
504 return new (Mem) OMPBarrierDirective();
505}
506
507OMPTaskwaitDirective *OMPTaskwaitDirective::Create(const ASTContext &C,
508 SourceLocation StartLoc,
509 SourceLocation EndLoc) {
510 void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
511 OMPTaskwaitDirective *Dir = new (Mem) OMPTaskwaitDirective(StartLoc, EndLoc);
512 return Dir;
513}
514
515OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C,
516 EmptyShell) {
517 void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
518 return new (Mem) OMPTaskwaitDirective();
519}
520
521OMPTaskgroupDirective *OMPTaskgroupDirective::Create(const ASTContext &C,
522 SourceLocation StartLoc,
523 SourceLocation EndLoc,
524 Stmt *AssociatedStmt) {
525 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskgroupDirective),
526 llvm::alignOf<Stmt *>());
527 void *Mem = C.Allocate(Size + sizeof(Stmt *));
528 OMPTaskgroupDirective *Dir =
529 new (Mem) OMPTaskgroupDirective(StartLoc, EndLoc);
530 Dir->setAssociatedStmt(AssociatedStmt);
531 return Dir;
532}
533
534OMPTaskgroupDirective *OMPTaskgroupDirective::CreateEmpty(const ASTContext &C,
535 EmptyShell) {
536 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskgroupDirective),
537 llvm::alignOf<Stmt *>());
538 void *Mem = C.Allocate(Size + sizeof(Stmt *));
539 return new (Mem) OMPTaskgroupDirective();
540}
541
542OMPCancellationPointDirective *OMPCancellationPointDirective::Create(
543 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
544 OpenMPDirectiveKind CancelRegion) {
545 unsigned Size = llvm::RoundUpToAlignment(
546 sizeof(OMPCancellationPointDirective), llvm::alignOf<Stmt *>());
547 void *Mem = C.Allocate(Size);
548 OMPCancellationPointDirective *Dir =
549 new (Mem) OMPCancellationPointDirective(StartLoc, EndLoc);
550 Dir->setCancelRegion(CancelRegion);
551 return Dir;
552}
553
554OMPCancellationPointDirective *
555OMPCancellationPointDirective::CreateEmpty(const ASTContext &C, EmptyShell) {
556 unsigned Size = llvm::RoundUpToAlignment(
557 sizeof(OMPCancellationPointDirective), llvm::alignOf<Stmt *>());
558 void *Mem = C.Allocate(Size);
559 return new (Mem) OMPCancellationPointDirective();
560}
561
562OMPCancelDirective *
563OMPCancelDirective::Create(const ASTContext &C, SourceLocation StartLoc,
564 SourceLocation EndLoc, ArrayRef<OMPClause *> Clauses,
565 OpenMPDirectiveKind CancelRegion) {
566 unsigned Size = llvm::RoundUpToAlignment(
567 sizeof(OMPCancelDirective) + sizeof(OMPClause *) * Clauses.size(),
568 llvm::alignOf<Stmt *>());
569 void *Mem = C.Allocate(Size);
570 OMPCancelDirective *Dir =
571 new (Mem) OMPCancelDirective(StartLoc, EndLoc, Clauses.size());
572 Dir->setClauses(Clauses);
573 Dir->setCancelRegion(CancelRegion);
574 return Dir;
575}
576
577OMPCancelDirective *OMPCancelDirective::CreateEmpty(const ASTContext &C,
578 unsigned NumClauses,
579 EmptyShell) {
580 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPCancelDirective) +
581 sizeof(OMPClause *) * NumClauses,
582 llvm::alignOf<Stmt *>());
583 void *Mem = C.Allocate(Size);
584 return new (Mem) OMPCancelDirective(NumClauses);
585}
586
587OMPFlushDirective *OMPFlushDirective::Create(const ASTContext &C,
588 SourceLocation StartLoc,
589 SourceLocation EndLoc,
590 ArrayRef<OMPClause *> Clauses) {
591 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPFlushDirective),
592 llvm::alignOf<OMPClause *>());
593 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size());
594 OMPFlushDirective *Dir =
595 new (Mem) OMPFlushDirective(StartLoc, EndLoc, Clauses.size());
596 Dir->setClauses(Clauses);
597 return Dir;
598}
599
600OMPFlushDirective *OMPFlushDirective::CreateEmpty(const ASTContext &C,
601 unsigned NumClauses,
602 EmptyShell) {
603 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPFlushDirective),
604 llvm::alignOf<OMPClause *>());
605 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses);
606 return new (Mem) OMPFlushDirective(NumClauses);
607}
608
609OMPOrderedDirective *OMPOrderedDirective::Create(const ASTContext &C,
610 SourceLocation StartLoc,
611 SourceLocation EndLoc,
612 ArrayRef<OMPClause *> Clauses,
613 Stmt *AssociatedStmt) {
614 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective),
615 llvm::alignOf<OMPClause *>());
616 void *Mem =
617 C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * Clauses.size());
618 OMPOrderedDirective *Dir =
619 new (Mem) OMPOrderedDirective(StartLoc, EndLoc, Clauses.size());
620 Dir->setClauses(Clauses);
621 Dir->setAssociatedStmt(AssociatedStmt);
622 return Dir;
623}
624
625OMPOrderedDirective *OMPOrderedDirective::CreateEmpty(const ASTContext &C,
626 unsigned NumClauses,
627 EmptyShell) {
628 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPOrderedDirective),
629 llvm::alignOf<OMPClause *>());
630 void *Mem =
631 C.Allocate(Size + sizeof(Stmt *) + sizeof(OMPClause *) * NumClauses);
632 return new (Mem) OMPOrderedDirective(NumClauses);
633}
634
635OMPAtomicDirective *OMPAtomicDirective::Create(
636 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
637 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt, Expr *X, Expr *V,
638 Expr *E, Expr *UE, bool IsXLHSInRHSPart, bool IsPostfixUpdate) {
639 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective),
640 llvm::alignOf<OMPClause *>());
641 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
642 5 * sizeof(Stmt *));
643 OMPAtomicDirective *Dir =
644 new (Mem) OMPAtomicDirective(StartLoc, EndLoc, Clauses.size());
645 Dir->setClauses(Clauses);
646 Dir->setAssociatedStmt(AssociatedStmt);
647 Dir->setX(X);
648 Dir->setV(V);
649 Dir->setExpr(E);
650 Dir->setUpdateExpr(UE);
651 Dir->IsXLHSInRHSPart = IsXLHSInRHSPart;
652 Dir->IsPostfixUpdate = IsPostfixUpdate;
653 return Dir;
654}
655
656OMPAtomicDirective *OMPAtomicDirective::CreateEmpty(const ASTContext &C,
657 unsigned NumClauses,
658 EmptyShell) {
659 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPAtomicDirective),
660 llvm::alignOf<OMPClause *>());
661 void *Mem =
662 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + 5 * sizeof(Stmt *));
663 return new (Mem) OMPAtomicDirective(NumClauses);
664}
665
666OMPTargetDirective *OMPTargetDirective::Create(const ASTContext &C,
667 SourceLocation StartLoc,
668 SourceLocation EndLoc,
669 ArrayRef<OMPClause *> Clauses,
670 Stmt *AssociatedStmt) {
671 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective),
672 llvm::alignOf<OMPClause *>());
673 void *Mem =
674 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
675 OMPTargetDirective *Dir =
676 new (Mem) OMPTargetDirective(StartLoc, EndLoc, Clauses.size());
677 Dir->setClauses(Clauses);
678 Dir->setAssociatedStmt(AssociatedStmt);
679 return Dir;
680}
681
682OMPTargetDirective *OMPTargetDirective::CreateEmpty(const ASTContext &C,
683 unsigned NumClauses,
684 EmptyShell) {
685 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTargetDirective),
686 llvm::alignOf<OMPClause *>());
687 void *Mem =
688 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
689 return new (Mem) OMPTargetDirective(NumClauses);
690}
691
692OMPTargetDataDirective *OMPTargetDataDirective::Create(
693 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
694 ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt) {
695 void *Mem =
696 C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPTargetDataDirective),
697 llvm::alignOf<OMPClause *>()) +
698 sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
699 OMPTargetDataDirective *Dir =
700 new (Mem) OMPTargetDataDirective(StartLoc, EndLoc, Clauses.size());
701 Dir->setClauses(Clauses);
702 Dir->setAssociatedStmt(AssociatedStmt);
703 return Dir;
704}
705
706OMPTargetDataDirective *OMPTargetDataDirective::CreateEmpty(const ASTContext &C,
707 unsigned N,
708 EmptyShell) {
709 void *Mem =
710 C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPTargetDataDirective),
711 llvm::alignOf<OMPClause *>()) +
712 sizeof(OMPClause *) * N + sizeof(Stmt *));
713 return new (Mem) OMPTargetDataDirective(N);
714}
715
716OMPTeamsDirective *OMPTeamsDirective::Create(const ASTContext &C,
717 SourceLocation StartLoc,
718 SourceLocation EndLoc,
719 ArrayRef<OMPClause *> Clauses,
720 Stmt *AssociatedStmt) {
721 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective),
722 llvm::alignOf<OMPClause *>());
723 void *Mem =
724 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() + sizeof(Stmt *));
725 OMPTeamsDirective *Dir =
726 new (Mem) OMPTeamsDirective(StartLoc, EndLoc, Clauses.size());
727 Dir->setClauses(Clauses);
728 Dir->setAssociatedStmt(AssociatedStmt);
729 return Dir;
730}
731
732OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C,
733 unsigned NumClauses,
734 EmptyShell) {
735 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective),
736 llvm::alignOf<OMPClause *>());
737 void *Mem =
738 C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
739 return new (Mem) OMPTeamsDirective(NumClauses);
740}
Alexey Bataev49f6e782015-12-01 04:18:41 +0000[diff] [blame]741
742OMPTaskLoopDirective *OMPTaskLoopDirective::Create(
743 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
744 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
745 const HelperExprs &Exprs) {
746 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskLoopDirective),
747 llvm::alignOf<OMPClause *>());
748 void *Mem =
749 C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
750 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
751 OMPTaskLoopDirective *Dir = new (Mem)
752 OMPTaskLoopDirective(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->setCounters(Exprs.Counters);
770 Dir->setPrivateCounters(Exprs.PrivateCounters);
771 Dir->setInits(Exprs.Inits);
772 Dir->setUpdates(Exprs.Updates);
773 Dir->setFinals(Exprs.Finals);
774 return Dir;
775}
776
777OMPTaskLoopDirective *OMPTaskLoopDirective::CreateEmpty(const ASTContext &C,
778 unsigned NumClauses,
779 unsigned CollapsedNum,
780 EmptyShell) {
781 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskLoopDirective),
782 llvm::alignOf<OMPClause *>());
783 void *Mem =
784 C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
785 sizeof(Stmt *) * numLoopChildren(CollapsedNum, OMPD_taskloop));
786 return new (Mem) OMPTaskLoopDirective(CollapsedNum, NumClauses);
787}
788
Alexey Bataev0a6ed842015-12-03 09:40:15 +0000[diff] [blame^]789OMPTaskLoopSimdDirective *OMPTaskLoopSimdDirective::Create(
790 const ASTContext &C, SourceLocation StartLoc, SourceLocation EndLoc,
791 unsigned CollapsedNum, ArrayRef<OMPClause *> Clauses, Stmt *AssociatedStmt,
792 const HelperExprs &Exprs) {
793 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskLoopSimdDirective),
794 llvm::alignOf<OMPClause *>());
795 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * Clauses.size() +
796 sizeof(Stmt *) *
797 numLoopChildren(CollapsedNum, OMPD_taskloop_simd));
798 OMPTaskLoopSimdDirective *Dir = new (Mem)
799 OMPTaskLoopSimdDirective(StartLoc, EndLoc, CollapsedNum, Clauses.size());
800 Dir->setClauses(Clauses);
801 Dir->setAssociatedStmt(AssociatedStmt);
802 Dir->setIterationVariable(Exprs.IterationVarRef);
803 Dir->setLastIteration(Exprs.LastIteration);
804 Dir->setCalcLastIteration(Exprs.CalcLastIteration);
805 Dir->setPreCond(Exprs.PreCond);
806 Dir->setCond(Exprs.Cond);
807 Dir->setInit(Exprs.Init);
808 Dir->setInc(Exprs.Inc);
809 Dir->setIsLastIterVariable(Exprs.IL);
810 Dir->setLowerBoundVariable(Exprs.LB);
811 Dir->setUpperBoundVariable(Exprs.UB);
812 Dir->setStrideVariable(Exprs.ST);
813 Dir->setEnsureUpperBound(Exprs.EUB);
814 Dir->setNextLowerBound(Exprs.NLB);
815 Dir->setNextUpperBound(Exprs.NUB);
816 Dir->setCounters(Exprs.Counters);
817 Dir->setPrivateCounters(Exprs.PrivateCounters);
818 Dir->setInits(Exprs.Inits);
819 Dir->setUpdates(Exprs.Updates);
820 Dir->setFinals(Exprs.Finals);
821 return Dir;
822}
823
824OMPTaskLoopSimdDirective *
825OMPTaskLoopSimdDirective::CreateEmpty(const ASTContext &C, unsigned NumClauses,
826 unsigned CollapsedNum, EmptyShell) {
827 unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTaskLoopSimdDirective),
828 llvm::alignOf<OMPClause *>());
829 void *Mem = C.Allocate(Size + sizeof(OMPClause *) * NumClauses +
830 sizeof(Stmt *) *
831 numLoopChildren(CollapsedNum, OMPD_taskloop_simd));
832 return new (Mem) OMPTaskLoopSimdDirective(CollapsedNum, NumClauses);
833}
834