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