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