Bug Summary

File:tools/clang/lib/AST/StmtOpenMP.cpp
Warning:line 1710, column 3
Called C++ object pointer is null

Annotated Source Code

Press '?' to see keyboard shortcuts

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