1 //===--- OpenMPClause.cpp - Classes for OpenMP clauses --------------------===//
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 OpenMPClause.h
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/AST/OpenMPClause.h"
15
16 #include "clang/AST/ASTContext.h"
17
18 using namespace clang;
19
children()20 OMPClause::child_range OMPClause::children() {
21 switch (getClauseKind()) {
22 default:
23 break;
24 #define OPENMP_CLAUSE(Name, Class) \
25 case OMPC_##Name: \
26 return static_cast<Class *>(this)->children();
27 #include "clang/Basic/OpenMPKinds.def"
28 }
29 llvm_unreachable("unknown OMPClause");
30 }
31
setPrivateCopies(ArrayRef<Expr * > VL)32 void OMPPrivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
33 assert(VL.size() == varlist_size() &&
34 "Number of private copies is not the same as the preallocated buffer");
35 std::copy(VL.begin(), VL.end(), varlist_end());
36 }
37
38 OMPPrivateClause *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > PrivateVL)39 OMPPrivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
40 SourceLocation LParenLoc, SourceLocation EndLoc,
41 ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL) {
42 // Allocate space for private variables and initializer expressions.
43 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPPrivateClause),
44 llvm::alignOf<Expr *>()) +
45 2 * sizeof(Expr *) * VL.size());
46 OMPPrivateClause *Clause =
47 new (Mem) OMPPrivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
48 Clause->setVarRefs(VL);
49 Clause->setPrivateCopies(PrivateVL);
50 return Clause;
51 }
52
CreateEmpty(const ASTContext & C,unsigned N)53 OMPPrivateClause *OMPPrivateClause::CreateEmpty(const ASTContext &C,
54 unsigned N) {
55 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPPrivateClause),
56 llvm::alignOf<Expr *>()) +
57 2 * sizeof(Expr *) * N);
58 return new (Mem) OMPPrivateClause(N);
59 }
60
setPrivateCopies(ArrayRef<Expr * > VL)61 void OMPFirstprivateClause::setPrivateCopies(ArrayRef<Expr *> VL) {
62 assert(VL.size() == varlist_size() &&
63 "Number of private copies is not the same as the preallocated buffer");
64 std::copy(VL.begin(), VL.end(), varlist_end());
65 }
66
setInits(ArrayRef<Expr * > VL)67 void OMPFirstprivateClause::setInits(ArrayRef<Expr *> VL) {
68 assert(VL.size() == varlist_size() &&
69 "Number of inits is not the same as the preallocated buffer");
70 std::copy(VL.begin(), VL.end(), getPrivateCopies().end());
71 }
72
73 OMPFirstprivateClause *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > PrivateVL,ArrayRef<Expr * > InitVL)74 OMPFirstprivateClause::Create(const ASTContext &C, SourceLocation StartLoc,
75 SourceLocation LParenLoc, SourceLocation EndLoc,
76 ArrayRef<Expr *> VL, ArrayRef<Expr *> PrivateVL,
77 ArrayRef<Expr *> InitVL) {
78 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFirstprivateClause),
79 llvm::alignOf<Expr *>()) +
80 3 * sizeof(Expr *) * VL.size());
81 OMPFirstprivateClause *Clause =
82 new (Mem) OMPFirstprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
83 Clause->setVarRefs(VL);
84 Clause->setPrivateCopies(PrivateVL);
85 Clause->setInits(InitVL);
86 return Clause;
87 }
88
CreateEmpty(const ASTContext & C,unsigned N)89 OMPFirstprivateClause *OMPFirstprivateClause::CreateEmpty(const ASTContext &C,
90 unsigned N) {
91 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFirstprivateClause),
92 llvm::alignOf<Expr *>()) +
93 3 * sizeof(Expr *) * N);
94 return new (Mem) OMPFirstprivateClause(N);
95 }
96
setPrivateCopies(ArrayRef<Expr * > PrivateCopies)97 void OMPLastprivateClause::setPrivateCopies(ArrayRef<Expr *> PrivateCopies) {
98 assert(PrivateCopies.size() == varlist_size() &&
99 "Number of private copies is not the same as the preallocated buffer");
100 std::copy(PrivateCopies.begin(), PrivateCopies.end(), varlist_end());
101 }
102
setSourceExprs(ArrayRef<Expr * > SrcExprs)103 void OMPLastprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
104 assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
105 "not the same as the "
106 "preallocated buffer");
107 std::copy(SrcExprs.begin(), SrcExprs.end(), getPrivateCopies().end());
108 }
109
setDestinationExprs(ArrayRef<Expr * > DstExprs)110 void OMPLastprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
111 assert(DstExprs.size() == varlist_size() && "Number of destination "
112 "expressions is not the same as "
113 "the preallocated buffer");
114 std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
115 }
116
setAssignmentOps(ArrayRef<Expr * > AssignmentOps)117 void OMPLastprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
118 assert(AssignmentOps.size() == varlist_size() &&
119 "Number of assignment expressions is not the same as the preallocated "
120 "buffer");
121 std::copy(AssignmentOps.begin(), AssignmentOps.end(),
122 getDestinationExprs().end());
123 }
124
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > SrcExprs,ArrayRef<Expr * > DstExprs,ArrayRef<Expr * > AssignmentOps)125 OMPLastprivateClause *OMPLastprivateClause::Create(
126 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
127 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
128 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
129 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause),
130 llvm::alignOf<Expr *>()) +
131 5 * sizeof(Expr *) * VL.size());
132 OMPLastprivateClause *Clause =
133 new (Mem) OMPLastprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
134 Clause->setVarRefs(VL);
135 Clause->setSourceExprs(SrcExprs);
136 Clause->setDestinationExprs(DstExprs);
137 Clause->setAssignmentOps(AssignmentOps);
138 return Clause;
139 }
140
CreateEmpty(const ASTContext & C,unsigned N)141 OMPLastprivateClause *OMPLastprivateClause::CreateEmpty(const ASTContext &C,
142 unsigned N) {
143 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLastprivateClause),
144 llvm::alignOf<Expr *>()) +
145 5 * sizeof(Expr *) * N);
146 return new (Mem) OMPLastprivateClause(N);
147 }
148
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL)149 OMPSharedClause *OMPSharedClause::Create(const ASTContext &C,
150 SourceLocation StartLoc,
151 SourceLocation LParenLoc,
152 SourceLocation EndLoc,
153 ArrayRef<Expr *> VL) {
154 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPSharedClause),
155 llvm::alignOf<Expr *>()) +
156 sizeof(Expr *) * VL.size());
157 OMPSharedClause *Clause =
158 new (Mem) OMPSharedClause(StartLoc, LParenLoc, EndLoc, VL.size());
159 Clause->setVarRefs(VL);
160 return Clause;
161 }
162
CreateEmpty(const ASTContext & C,unsigned N)163 OMPSharedClause *OMPSharedClause::CreateEmpty(const ASTContext &C, unsigned N) {
164 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPSharedClause),
165 llvm::alignOf<Expr *>()) +
166 sizeof(Expr *) * N);
167 return new (Mem) OMPSharedClause(N);
168 }
169
setPrivates(ArrayRef<Expr * > PL)170 void OMPLinearClause::setPrivates(ArrayRef<Expr *> PL) {
171 assert(PL.size() == varlist_size() &&
172 "Number of privates is not the same as the preallocated buffer");
173 std::copy(PL.begin(), PL.end(), varlist_end());
174 }
175
setInits(ArrayRef<Expr * > IL)176 void OMPLinearClause::setInits(ArrayRef<Expr *> IL) {
177 assert(IL.size() == varlist_size() &&
178 "Number of inits is not the same as the preallocated buffer");
179 std::copy(IL.begin(), IL.end(), getPrivates().end());
180 }
181
setUpdates(ArrayRef<Expr * > UL)182 void OMPLinearClause::setUpdates(ArrayRef<Expr *> UL) {
183 assert(UL.size() == varlist_size() &&
184 "Number of updates is not the same as the preallocated buffer");
185 std::copy(UL.begin(), UL.end(), getInits().end());
186 }
187
setFinals(ArrayRef<Expr * > FL)188 void OMPLinearClause::setFinals(ArrayRef<Expr *> FL) {
189 assert(FL.size() == varlist_size() &&
190 "Number of final updates is not the same as the preallocated buffer");
191 std::copy(FL.begin(), FL.end(), getUpdates().end());
192 }
193
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,OpenMPLinearClauseKind Modifier,SourceLocation ModifierLoc,SourceLocation ColonLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > PL,ArrayRef<Expr * > IL,Expr * Step,Expr * CalcStep)194 OMPLinearClause *OMPLinearClause::Create(
195 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
196 OpenMPLinearClauseKind Modifier, SourceLocation ModifierLoc,
197 SourceLocation ColonLoc, SourceLocation EndLoc, ArrayRef<Expr *> VL,
198 ArrayRef<Expr *> PL, ArrayRef<Expr *> IL, Expr *Step, Expr *CalcStep) {
199 // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
200 // (Step and CalcStep).
201 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLinearClause),
202 llvm::alignOf<Expr *>()) +
203 (5 * VL.size() + 2) * sizeof(Expr *));
204 OMPLinearClause *Clause = new (Mem) OMPLinearClause(
205 StartLoc, LParenLoc, Modifier, ModifierLoc, ColonLoc, EndLoc, VL.size());
206 Clause->setVarRefs(VL);
207 Clause->setPrivates(PL);
208 Clause->setInits(IL);
209 // Fill update and final expressions with zeroes, they are provided later,
210 // after the directive construction.
211 std::fill(Clause->getInits().end(), Clause->getInits().end() + VL.size(),
212 nullptr);
213 std::fill(Clause->getUpdates().end(), Clause->getUpdates().end() + VL.size(),
214 nullptr);
215 Clause->setStep(Step);
216 Clause->setCalcStep(CalcStep);
217 return Clause;
218 }
219
CreateEmpty(const ASTContext & C,unsigned NumVars)220 OMPLinearClause *OMPLinearClause::CreateEmpty(const ASTContext &C,
221 unsigned NumVars) {
222 // Allocate space for 4 lists (Vars, Inits, Updates, Finals) and 2 expressions
223 // (Step and CalcStep).
224 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPLinearClause),
225 llvm::alignOf<Expr *>()) +
226 (5 * NumVars + 2) * sizeof(Expr *));
227 return new (Mem) OMPLinearClause(NumVars);
228 }
229
230 OMPAlignedClause *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation ColonLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,Expr * A)231 OMPAlignedClause::Create(const ASTContext &C, SourceLocation StartLoc,
232 SourceLocation LParenLoc, SourceLocation ColonLoc,
233 SourceLocation EndLoc, ArrayRef<Expr *> VL, Expr *A) {
234 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPAlignedClause),
235 llvm::alignOf<Expr *>()) +
236 sizeof(Expr *) * (VL.size() + 1));
237 OMPAlignedClause *Clause = new (Mem)
238 OMPAlignedClause(StartLoc, LParenLoc, ColonLoc, EndLoc, VL.size());
239 Clause->setVarRefs(VL);
240 Clause->setAlignment(A);
241 return Clause;
242 }
243
CreateEmpty(const ASTContext & C,unsigned NumVars)244 OMPAlignedClause *OMPAlignedClause::CreateEmpty(const ASTContext &C,
245 unsigned NumVars) {
246 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPAlignedClause),
247 llvm::alignOf<Expr *>()) +
248 sizeof(Expr *) * (NumVars + 1));
249 return new (Mem) OMPAlignedClause(NumVars);
250 }
251
setSourceExprs(ArrayRef<Expr * > SrcExprs)252 void OMPCopyinClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
253 assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
254 "not the same as the "
255 "preallocated buffer");
256 std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
257 }
258
setDestinationExprs(ArrayRef<Expr * > DstExprs)259 void OMPCopyinClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
260 assert(DstExprs.size() == varlist_size() && "Number of destination "
261 "expressions is not the same as "
262 "the preallocated buffer");
263 std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
264 }
265
setAssignmentOps(ArrayRef<Expr * > AssignmentOps)266 void OMPCopyinClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
267 assert(AssignmentOps.size() == varlist_size() &&
268 "Number of assignment expressions is not the same as the preallocated "
269 "buffer");
270 std::copy(AssignmentOps.begin(), AssignmentOps.end(),
271 getDestinationExprs().end());
272 }
273
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > SrcExprs,ArrayRef<Expr * > DstExprs,ArrayRef<Expr * > AssignmentOps)274 OMPCopyinClause *OMPCopyinClause::Create(
275 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
276 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
277 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
278 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyinClause),
279 llvm::alignOf<Expr *>()) +
280 4 * sizeof(Expr *) * VL.size());
281 OMPCopyinClause *Clause =
282 new (Mem) OMPCopyinClause(StartLoc, LParenLoc, EndLoc, VL.size());
283 Clause->setVarRefs(VL);
284 Clause->setSourceExprs(SrcExprs);
285 Clause->setDestinationExprs(DstExprs);
286 Clause->setAssignmentOps(AssignmentOps);
287 return Clause;
288 }
289
CreateEmpty(const ASTContext & C,unsigned N)290 OMPCopyinClause *OMPCopyinClause::CreateEmpty(const ASTContext &C, unsigned N) {
291 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyinClause),
292 llvm::alignOf<Expr *>()) +
293 4 * sizeof(Expr *) * N);
294 return new (Mem) OMPCopyinClause(N);
295 }
296
setSourceExprs(ArrayRef<Expr * > SrcExprs)297 void OMPCopyprivateClause::setSourceExprs(ArrayRef<Expr *> SrcExprs) {
298 assert(SrcExprs.size() == varlist_size() && "Number of source expressions is "
299 "not the same as the "
300 "preallocated buffer");
301 std::copy(SrcExprs.begin(), SrcExprs.end(), varlist_end());
302 }
303
setDestinationExprs(ArrayRef<Expr * > DstExprs)304 void OMPCopyprivateClause::setDestinationExprs(ArrayRef<Expr *> DstExprs) {
305 assert(DstExprs.size() == varlist_size() && "Number of destination "
306 "expressions is not the same as "
307 "the preallocated buffer");
308 std::copy(DstExprs.begin(), DstExprs.end(), getSourceExprs().end());
309 }
310
setAssignmentOps(ArrayRef<Expr * > AssignmentOps)311 void OMPCopyprivateClause::setAssignmentOps(ArrayRef<Expr *> AssignmentOps) {
312 assert(AssignmentOps.size() == varlist_size() &&
313 "Number of assignment expressions is not the same as the preallocated "
314 "buffer");
315 std::copy(AssignmentOps.begin(), AssignmentOps.end(),
316 getDestinationExprs().end());
317 }
318
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,ArrayRef<Expr * > SrcExprs,ArrayRef<Expr * > DstExprs,ArrayRef<Expr * > AssignmentOps)319 OMPCopyprivateClause *OMPCopyprivateClause::Create(
320 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
321 SourceLocation EndLoc, ArrayRef<Expr *> VL, ArrayRef<Expr *> SrcExprs,
322 ArrayRef<Expr *> DstExprs, ArrayRef<Expr *> AssignmentOps) {
323 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyprivateClause),
324 llvm::alignOf<Expr *>()) +
325 4 * sizeof(Expr *) * VL.size());
326 OMPCopyprivateClause *Clause =
327 new (Mem) OMPCopyprivateClause(StartLoc, LParenLoc, EndLoc, VL.size());
328 Clause->setVarRefs(VL);
329 Clause->setSourceExprs(SrcExprs);
330 Clause->setDestinationExprs(DstExprs);
331 Clause->setAssignmentOps(AssignmentOps);
332 return Clause;
333 }
334
CreateEmpty(const ASTContext & C,unsigned N)335 OMPCopyprivateClause *OMPCopyprivateClause::CreateEmpty(const ASTContext &C,
336 unsigned N) {
337 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPCopyprivateClause),
338 llvm::alignOf<Expr *>()) +
339 4 * sizeof(Expr *) * N);
340 return new (Mem) OMPCopyprivateClause(N);
341 }
342
setPrivates(ArrayRef<Expr * > Privates)343 void OMPReductionClause::setPrivates(ArrayRef<Expr *> Privates) {
344 assert(Privates.size() == varlist_size() &&
345 "Number of private copies is not the same as the preallocated buffer");
346 std::copy(Privates.begin(), Privates.end(), varlist_end());
347 }
348
setLHSExprs(ArrayRef<Expr * > LHSExprs)349 void OMPReductionClause::setLHSExprs(ArrayRef<Expr *> LHSExprs) {
350 assert(
351 LHSExprs.size() == varlist_size() &&
352 "Number of LHS expressions is not the same as the preallocated buffer");
353 std::copy(LHSExprs.begin(), LHSExprs.end(), getPrivates().end());
354 }
355
setRHSExprs(ArrayRef<Expr * > RHSExprs)356 void OMPReductionClause::setRHSExprs(ArrayRef<Expr *> RHSExprs) {
357 assert(
358 RHSExprs.size() == varlist_size() &&
359 "Number of RHS expressions is not the same as the preallocated buffer");
360 std::copy(RHSExprs.begin(), RHSExprs.end(), getLHSExprs().end());
361 }
362
setReductionOps(ArrayRef<Expr * > ReductionOps)363 void OMPReductionClause::setReductionOps(ArrayRef<Expr *> ReductionOps) {
364 assert(ReductionOps.size() == varlist_size() && "Number of reduction "
365 "expressions is not the same "
366 "as the preallocated buffer");
367 std::copy(ReductionOps.begin(), ReductionOps.end(), getRHSExprs().end());
368 }
369
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,SourceLocation ColonLoc,ArrayRef<Expr * > VL,NestedNameSpecifierLoc QualifierLoc,const DeclarationNameInfo & NameInfo,ArrayRef<Expr * > Privates,ArrayRef<Expr * > LHSExprs,ArrayRef<Expr * > RHSExprs,ArrayRef<Expr * > ReductionOps)370 OMPReductionClause *OMPReductionClause::Create(
371 const ASTContext &C, SourceLocation StartLoc, SourceLocation LParenLoc,
372 SourceLocation EndLoc, SourceLocation ColonLoc, ArrayRef<Expr *> VL,
373 NestedNameSpecifierLoc QualifierLoc, const DeclarationNameInfo &NameInfo,
374 ArrayRef<Expr *> Privates, ArrayRef<Expr *> LHSExprs,
375 ArrayRef<Expr *> RHSExprs, ArrayRef<Expr *> ReductionOps) {
376 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPReductionClause),
377 llvm::alignOf<Expr *>()) +
378 5 * sizeof(Expr *) * VL.size());
379 OMPReductionClause *Clause = new (Mem) OMPReductionClause(
380 StartLoc, LParenLoc, EndLoc, ColonLoc, VL.size(), QualifierLoc, NameInfo);
381 Clause->setVarRefs(VL);
382 Clause->setPrivates(Privates);
383 Clause->setLHSExprs(LHSExprs);
384 Clause->setRHSExprs(RHSExprs);
385 Clause->setReductionOps(ReductionOps);
386 return Clause;
387 }
388
CreateEmpty(const ASTContext & C,unsigned N)389 OMPReductionClause *OMPReductionClause::CreateEmpty(const ASTContext &C,
390 unsigned N) {
391 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPReductionClause),
392 llvm::alignOf<Expr *>()) +
393 5 * sizeof(Expr *) * N);
394 return new (Mem) OMPReductionClause(N);
395 }
396
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL)397 OMPFlushClause *OMPFlushClause::Create(const ASTContext &C,
398 SourceLocation StartLoc,
399 SourceLocation LParenLoc,
400 SourceLocation EndLoc,
401 ArrayRef<Expr *> VL) {
402 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFlushClause),
403 llvm::alignOf<Expr *>()) +
404 sizeof(Expr *) * VL.size());
405 OMPFlushClause *Clause =
406 new (Mem) OMPFlushClause(StartLoc, LParenLoc, EndLoc, VL.size());
407 Clause->setVarRefs(VL);
408 return Clause;
409 }
410
CreateEmpty(const ASTContext & C,unsigned N)411 OMPFlushClause *OMPFlushClause::CreateEmpty(const ASTContext &C, unsigned N) {
412 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPFlushClause),
413 llvm::alignOf<Expr *>()) +
414 sizeof(Expr *) * N);
415 return new (Mem) OMPFlushClause(N);
416 }
417
418 OMPDependClause *
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,OpenMPDependClauseKind DepKind,SourceLocation DepLoc,SourceLocation ColonLoc,ArrayRef<Expr * > VL)419 OMPDependClause::Create(const ASTContext &C, SourceLocation StartLoc,
420 SourceLocation LParenLoc, SourceLocation EndLoc,
421 OpenMPDependClauseKind DepKind, SourceLocation DepLoc,
422 SourceLocation ColonLoc, ArrayRef<Expr *> VL) {
423 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPDependClause),
424 llvm::alignOf<Expr *>()) +
425 sizeof(Expr *) * VL.size());
426 OMPDependClause *Clause =
427 new (Mem) OMPDependClause(StartLoc, LParenLoc, EndLoc, VL.size());
428 Clause->setVarRefs(VL);
429 Clause->setDependencyKind(DepKind);
430 Clause->setDependencyLoc(DepLoc);
431 Clause->setColonLoc(ColonLoc);
432 return Clause;
433 }
434
CreateEmpty(const ASTContext & C,unsigned N)435 OMPDependClause *OMPDependClause::CreateEmpty(const ASTContext &C, unsigned N) {
436 void *Mem = C.Allocate(llvm::RoundUpToAlignment(sizeof(OMPDependClause),
437 llvm::alignOf<Expr *>()) +
438 sizeof(Expr *) * N);
439 return new (Mem) OMPDependClause(N);
440 }
441
Create(const ASTContext & C,SourceLocation StartLoc,SourceLocation LParenLoc,SourceLocation EndLoc,ArrayRef<Expr * > VL,OpenMPMapClauseKind TypeModifier,OpenMPMapClauseKind Type,SourceLocation TypeLoc)442 OMPMapClause *OMPMapClause::Create(const ASTContext &C, SourceLocation StartLoc,
443 SourceLocation LParenLoc,
444 SourceLocation EndLoc, ArrayRef<Expr *> VL,
445 OpenMPMapClauseKind TypeModifier,
446 OpenMPMapClauseKind Type,
447 SourceLocation TypeLoc) {
448 void *Mem = C.Allocate(
449 llvm::RoundUpToAlignment(sizeof(OMPMapClause), llvm::alignOf<Expr *>()) +
450 sizeof(Expr *) * VL.size());
451 OMPMapClause *Clause = new (Mem) OMPMapClause(
452 TypeModifier, Type, TypeLoc, StartLoc, LParenLoc, EndLoc, VL.size());
453 Clause->setVarRefs(VL);
454 Clause->setMapTypeModifier(TypeModifier);
455 Clause->setMapType(Type);
456 Clause->setMapLoc(TypeLoc);
457 return Clause;
458 }
459
CreateEmpty(const ASTContext & C,unsigned N)460 OMPMapClause *OMPMapClause::CreateEmpty(const ASTContext &C, unsigned N) {
461 void *Mem = C.Allocate(
462 llvm::RoundUpToAlignment(sizeof(OMPMapClause), llvm::alignOf<Expr *>()) +
463 sizeof(Expr *) * N);
464 return new (Mem) OMPMapClause(N);
465 }
466