StmtOpenMP.cpp revision 327952 
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 =
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
72OMPParallelDirective *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
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::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
111OMPSimdDirective *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
122OMPForDirective *
123OMPForDirective::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
160OMPForDirective *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
171OMPForSimdDirective *
172OMPForSimdDirective::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
209OMPForSimdDirective *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
221OMPSectionsDirective *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
236OMPSectionsDirective *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
246OMPSectionDirective *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
259OMPSectionDirective *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
266OMPSingleDirective *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
282OMPSingleDirective *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
292OMPMasterDirective *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
303OMPMasterDirective *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
310OMPCriticalDirective *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
325OMPCriticalDirective *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
335OMPParallelForDirective *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
373OMPParallelForDirective *
374OMPParallelForDirective::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
384OMPParallelForSimdDirective *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
421OMPParallelForSimdDirective *
422OMPParallelForSimdDirective::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
433OMPParallelSectionsDirective *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
448OMPParallelSectionsDirective *
449OMPParallelSectionsDirective::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
458OMPTaskDirective *
459OMPTaskDirective::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
473OMPTaskDirective *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
482OMPTaskyieldDirective *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
491OMPTaskyieldDirective *OMPTaskyieldDirective::CreateEmpty(const ASTContext &C,
492                                                          EmptyShell) {
493  void *Mem = C.Allocate(sizeof(OMPTaskyieldDirective));
494  return new (Mem) OMPTaskyieldDirective();
495}
496
497OMPBarrierDirective *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
505OMPBarrierDirective *OMPBarrierDirective::CreateEmpty(const ASTContext &C,
506                                                      EmptyShell) {
507  void *Mem = C.Allocate(sizeof(OMPBarrierDirective));
508  return new (Mem) OMPBarrierDirective();
509}
510
511OMPTaskwaitDirective *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
519OMPTaskwaitDirective *OMPTaskwaitDirective::CreateEmpty(const ASTContext &C,
520                                                        EmptyShell) {
521  void *Mem = C.Allocate(sizeof(OMPTaskwaitDirective));
522  return new (Mem) OMPTaskwaitDirective();
523}
524
525OMPTaskgroupDirective *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
540OMPTaskgroupDirective *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
550OMPCancellationPointDirective *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
562OMPCancellationPointDirective *
563OMPCancellationPointDirective::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
570OMPCancelDirective *
571OMPCancelDirective::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
585OMPCancelDirective *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
595OMPFlushDirective *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
608OMPFlushDirective *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
617OMPOrderedDirective *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
633OMPOrderedDirective *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
643OMPAtomicDirective *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
664OMPAtomicDirective *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
674OMPTargetDirective *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
690OMPTargetDirective *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
700OMPTargetParallelDirective *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
714OMPTargetParallelDirective *
715OMPTargetParallelDirective::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
724OMPTargetParallelForDirective *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
762OMPTargetParallelForDirective *
763OMPTargetParallelForDirective::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
774OMPTargetDataDirective *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
787OMPTargetDataDirective *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
796OMPTargetEnterDataDirective *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
809OMPTargetEnterDataDirective *
810OMPTargetEnterDataDirective::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
818OMPTargetExitDataDirective *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
831OMPTargetExitDataDirective *
832OMPTargetExitDataDirective::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
840OMPTeamsDirective *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
856OMPTeamsDirective *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
866OMPTaskLoopDirective *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
903OMPTaskLoopDirective *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
915OMPTaskLoopSimdDirective *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
952OMPTaskLoopSimdDirective *
953OMPTaskLoopSimdDirective::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
963OMPDistributeDirective *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
1000OMPDistributeDirective *
1001OMPDistributeDirective::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
1011OMPTargetUpdateDirective *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
1025OMPTargetUpdateDirective *
1026OMPTargetUpdateDirective::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
1035OMPDistributeParallelForDirective *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
1086OMPDistributeParallelForDirective *
1087OMPDistributeParallelForDirective::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
1100OMPDistributeParallelForSimdDirective *
1101OMPDistributeParallelForSimdDirective::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
1151OMPDistributeParallelForSimdDirective *
1152OMPDistributeParallelForSimdDirective::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
1166OMPDistributeSimdDirective *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
1204OMPDistributeSimdDirective *
1205OMPDistributeSimdDirective::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
1217OMPTargetParallelForSimdDirective *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
1256OMPTargetParallelForSimdDirective *
1257OMPTargetParallelForSimdDirective::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
1270OMPTargetSimdDirective *
1271OMPTargetSimdDirective::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
1300OMPTargetSimdDirective *
1301OMPTargetSimdDirective::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
1311OMPTeamsDistributeDirective *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
1348OMPTeamsDistributeDirective *
1349OMPTeamsDistributeDirective::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
1360OMPTeamsDistributeSimdDirective *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
1399OMPTeamsDistributeSimdDirective *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
1411OMPTeamsDistributeParallelForSimdDirective *
1412OMPTeamsDistributeParallelForSimdDirective::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
1463OMPTeamsDistributeParallelForSimdDirective *
1464OMPTeamsDistributeParallelForSimdDirective::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
1479OMPTeamsDistributeParallelForDirective *
1480OMPTeamsDistributeParallelForDirective::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
1531OMPTeamsDistributeParallelForDirective *
1532OMPTeamsDistributeParallelForDirective::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
1546OMPTargetTeamsDirective *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
1560OMPTargetTeamsDirective *
1561OMPTargetTeamsDirective::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
1570OMPTargetTeamsDistributeDirective *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
1609OMPTargetTeamsDistributeDirective *
1610OMPTargetTeamsDistributeDirective::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
1623OMPTargetTeamsDistributeParallelForDirective *
1624OMPTargetTeamsDistributeParallelForDirective::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
1677OMPTargetTeamsDistributeParallelForDirective *
1678OMPTargetTeamsDistributeParallelForDirective::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
1694OMPTargetTeamsDistributeParallelForSimdDirective *
1695OMPTargetTeamsDistributeParallelForSimdDirective::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
1747OMPTargetTeamsDistributeParallelForSimdDirective *
1748OMPTargetTeamsDistributeParallelForSimdDirective::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
1763OMPTargetTeamsDistributeSimdDirective *
1764OMPTargetTeamsDistributeSimdDirective::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
1803OMPTargetTeamsDistributeSimdDirective *
1804OMPTargetTeamsDistributeSimdDirective::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}
1817