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