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