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