1 //===---- OpenACCClause.cpp - Classes for OpenACC Clauses ----------------===//
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 subclasses of the OpenACCClause class declared in
10 // OpenACCClause.h
11 //
12 //===----------------------------------------------------------------------===//
13
14 #include "clang/AST/OpenACCClause.h"
15 #include "clang/AST/ASTContext.h"
16 #include "clang/AST/Expr.h"
17
18 using namespace clang;
19
classof(const OpenACCClause * C)20 bool OpenACCClauseWithParams::classof(const OpenACCClause *C) {
21 return OpenACCDeviceTypeClause::classof(C) ||
22 OpenACCClauseWithCondition::classof(C) ||
23 OpenACCBindClause::classof(C) || OpenACCClauseWithExprs::classof(C) ||
24 OpenACCSelfClause::classof(C);
25 }
classof(const OpenACCClause * C)26 bool OpenACCClauseWithExprs::classof(const OpenACCClause *C) {
27 return OpenACCWaitClause::classof(C) || OpenACCNumGangsClause::classof(C) ||
28 OpenACCTileClause::classof(C) ||
29 OpenACCClauseWithSingleIntExpr::classof(C) ||
30 OpenACCGangClause::classof(C) || OpenACCClauseWithVarList::classof(C);
31 }
classof(const OpenACCClause * C)32 bool OpenACCClauseWithVarList::classof(const OpenACCClause *C) {
33 return OpenACCPrivateClause::classof(C) ||
34 OpenACCFirstPrivateClause::classof(C) ||
35 OpenACCDevicePtrClause::classof(C) ||
36 OpenACCDeleteClause::classof(C) ||
37 OpenACCUseDeviceClause::classof(C) ||
38 OpenACCDetachClause::classof(C) || OpenACCAttachClause::classof(C) ||
39 OpenACCNoCreateClause::classof(C) ||
40 OpenACCPresentClause::classof(C) || OpenACCCopyClause::classof(C) ||
41 OpenACCCopyInClause::classof(C) || OpenACCCopyOutClause::classof(C) ||
42 OpenACCReductionClause::classof(C) ||
43 OpenACCCreateClause::classof(C) || OpenACCDeviceClause::classof(C) ||
44 OpenACCLinkClause::classof(C) ||
45 OpenACCDeviceResidentClause::classof(C) ||
46 OpenACCHostClause::classof(C);
47 }
classof(const OpenACCClause * C)48 bool OpenACCClauseWithCondition::classof(const OpenACCClause *C) {
49 return OpenACCIfClause::classof(C);
50 }
classof(const OpenACCClause * C)51 bool OpenACCClauseWithSingleIntExpr::classof(const OpenACCClause *C) {
52 return OpenACCNumWorkersClause::classof(C) ||
53 OpenACCVectorLengthClause::classof(C) ||
54 OpenACCDeviceNumClause::classof(C) ||
55 OpenACCDefaultAsyncClause::classof(C) ||
56 OpenACCVectorClause::classof(C) || OpenACCWorkerClause::classof(C) ||
57 OpenACCCollapseClause::classof(C) || OpenACCAsyncClause::classof(C);
58 }
Create(const ASTContext & C,OpenACCDefaultClauseKind K,SourceLocation BeginLoc,SourceLocation LParenLoc,SourceLocation EndLoc)59 OpenACCDefaultClause *OpenACCDefaultClause::Create(const ASTContext &C,
60 OpenACCDefaultClauseKind K,
61 SourceLocation BeginLoc,
62 SourceLocation LParenLoc,
63 SourceLocation EndLoc) {
64 void *Mem =
65 C.Allocate(sizeof(OpenACCDefaultClause), alignof(OpenACCDefaultClause));
66
67 return new (Mem) OpenACCDefaultClause(K, BeginLoc, LParenLoc, EndLoc);
68 }
69
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * ConditionExpr,SourceLocation EndLoc)70 OpenACCIfClause *OpenACCIfClause::Create(const ASTContext &C,
71 SourceLocation BeginLoc,
72 SourceLocation LParenLoc,
73 Expr *ConditionExpr,
74 SourceLocation EndLoc) {
75 void *Mem = C.Allocate(sizeof(OpenACCIfClause), alignof(OpenACCIfClause));
76 return new (Mem) OpenACCIfClause(BeginLoc, LParenLoc, ConditionExpr, EndLoc);
77 }
78
OpenACCIfClause(SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * ConditionExpr,SourceLocation EndLoc)79 OpenACCIfClause::OpenACCIfClause(SourceLocation BeginLoc,
80 SourceLocation LParenLoc, Expr *ConditionExpr,
81 SourceLocation EndLoc)
82 : OpenACCClauseWithCondition(OpenACCClauseKind::If, BeginLoc, LParenLoc,
83 ConditionExpr, EndLoc) {
84 assert(ConditionExpr && "if clause requires condition expr");
85 assert((ConditionExpr->isInstantiationDependent() ||
86 ConditionExpr->getType()->isScalarType()) &&
87 "Condition expression type not scalar/dependent");
88 }
89
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * ConditionExpr,SourceLocation EndLoc)90 OpenACCSelfClause *OpenACCSelfClause::Create(const ASTContext &C,
91 SourceLocation BeginLoc,
92 SourceLocation LParenLoc,
93 Expr *ConditionExpr,
94 SourceLocation EndLoc) {
95 void *Mem = C.Allocate(OpenACCSelfClause::totalSizeToAlloc<Expr *>(1));
96 return new (Mem)
97 OpenACCSelfClause(BeginLoc, LParenLoc, ConditionExpr, EndLoc);
98 }
99
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<Expr * > VarList,SourceLocation EndLoc)100 OpenACCSelfClause *OpenACCSelfClause::Create(const ASTContext &C,
101 SourceLocation BeginLoc,
102 SourceLocation LParenLoc,
103 ArrayRef<Expr *> VarList,
104 SourceLocation EndLoc) {
105 void *Mem =
106 C.Allocate(OpenACCSelfClause::totalSizeToAlloc<Expr *>(VarList.size()));
107 return new (Mem) OpenACCSelfClause(BeginLoc, LParenLoc, VarList, EndLoc);
108 }
109
OpenACCSelfClause(SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<Expr * > VarList,SourceLocation EndLoc)110 OpenACCSelfClause::OpenACCSelfClause(SourceLocation BeginLoc,
111 SourceLocation LParenLoc,
112 ArrayRef<Expr *> VarList,
113 SourceLocation EndLoc)
114 : OpenACCClauseWithParams(OpenACCClauseKind::Self, BeginLoc, LParenLoc,
115 EndLoc),
116 HasConditionExpr(std::nullopt), NumExprs(VarList.size()) {
117 llvm::uninitialized_copy(VarList, getTrailingObjects());
118 }
119
OpenACCSelfClause(SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * ConditionExpr,SourceLocation EndLoc)120 OpenACCSelfClause::OpenACCSelfClause(SourceLocation BeginLoc,
121 SourceLocation LParenLoc,
122 Expr *ConditionExpr, SourceLocation EndLoc)
123 : OpenACCClauseWithParams(OpenACCClauseKind::Self, BeginLoc, LParenLoc,
124 EndLoc),
125 HasConditionExpr(ConditionExpr != nullptr), NumExprs(1) {
126 assert((!ConditionExpr || ConditionExpr->isInstantiationDependent() ||
127 ConditionExpr->getType()->isScalarType()) &&
128 "Condition expression type not scalar/dependent");
129 llvm::uninitialized_copy(ArrayRef(ConditionExpr), getTrailingObjects());
130 }
131
children()132 OpenACCClause::child_range OpenACCClause::children() {
133 switch (getClauseKind()) {
134 default:
135 assert(false && "Clause children function not implemented");
136 break;
137 #define VISIT_CLAUSE(CLAUSE_NAME) \
138 case OpenACCClauseKind::CLAUSE_NAME: \
139 return cast<OpenACC##CLAUSE_NAME##Clause>(this)->children();
140 #define CLAUSE_ALIAS(ALIAS_NAME, CLAUSE_NAME, DEPRECATED) \
141 case OpenACCClauseKind::ALIAS_NAME: \
142 return cast<OpenACC##CLAUSE_NAME##Clause>(this)->children();
143
144 #include "clang/Basic/OpenACCClauses.def"
145 }
146 return child_range(child_iterator(), child_iterator());
147 }
148
OpenACCNumWorkersClause(SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * IntExpr,SourceLocation EndLoc)149 OpenACCNumWorkersClause::OpenACCNumWorkersClause(SourceLocation BeginLoc,
150 SourceLocation LParenLoc,
151 Expr *IntExpr,
152 SourceLocation EndLoc)
153 : OpenACCClauseWithSingleIntExpr(OpenACCClauseKind::NumWorkers, BeginLoc,
154 LParenLoc, IntExpr, EndLoc) {
155 assert((!IntExpr || IntExpr->isInstantiationDependent() ||
156 IntExpr->getType()->isIntegerType()) &&
157 "Condition expression type not scalar/dependent");
158 }
159
OpenACCGangClause(SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<OpenACCGangKind> GangKinds,ArrayRef<Expr * > IntExprs,SourceLocation EndLoc)160 OpenACCGangClause::OpenACCGangClause(SourceLocation BeginLoc,
161 SourceLocation LParenLoc,
162 ArrayRef<OpenACCGangKind> GangKinds,
163 ArrayRef<Expr *> IntExprs,
164 SourceLocation EndLoc)
165 : OpenACCClauseWithExprs(OpenACCClauseKind::Gang, BeginLoc, LParenLoc,
166 EndLoc) {
167 assert(GangKinds.size() == IntExprs.size() && "Mismatch exprs/kind?");
168 setExprs(getTrailingObjects<Expr *>(IntExprs.size()), IntExprs);
169 llvm::uninitialized_copy(GangKinds, getTrailingObjects<OpenACCGangKind>());
170 }
171
172 OpenACCNumWorkersClause *
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * IntExpr,SourceLocation EndLoc)173 OpenACCNumWorkersClause::Create(const ASTContext &C, SourceLocation BeginLoc,
174 SourceLocation LParenLoc, Expr *IntExpr,
175 SourceLocation EndLoc) {
176 void *Mem = C.Allocate(sizeof(OpenACCNumWorkersClause),
177 alignof(OpenACCNumWorkersClause));
178 return new (Mem)
179 OpenACCNumWorkersClause(BeginLoc, LParenLoc, IntExpr, EndLoc);
180 }
181
OpenACCCollapseClause(SourceLocation BeginLoc,SourceLocation LParenLoc,bool HasForce,Expr * LoopCount,SourceLocation EndLoc)182 OpenACCCollapseClause::OpenACCCollapseClause(SourceLocation BeginLoc,
183 SourceLocation LParenLoc,
184 bool HasForce, Expr *LoopCount,
185 SourceLocation EndLoc)
186 : OpenACCClauseWithSingleIntExpr(OpenACCClauseKind::Collapse, BeginLoc,
187 LParenLoc, LoopCount, EndLoc),
188 HasForce(HasForce) {}
189
190 OpenACCCollapseClause *
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,bool HasForce,Expr * LoopCount,SourceLocation EndLoc)191 OpenACCCollapseClause::Create(const ASTContext &C, SourceLocation BeginLoc,
192 SourceLocation LParenLoc, bool HasForce,
193 Expr *LoopCount, SourceLocation EndLoc) {
194 assert((!LoopCount || (LoopCount->isInstantiationDependent() ||
195 isa<ConstantExpr>(LoopCount))) &&
196 "Loop count not constant expression");
197 void *Mem =
198 C.Allocate(sizeof(OpenACCCollapseClause), alignof(OpenACCCollapseClause));
199 return new (Mem)
200 OpenACCCollapseClause(BeginLoc, LParenLoc, HasForce, LoopCount, EndLoc);
201 }
202
OpenACCVectorLengthClause(SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * IntExpr,SourceLocation EndLoc)203 OpenACCVectorLengthClause::OpenACCVectorLengthClause(SourceLocation BeginLoc,
204 SourceLocation LParenLoc,
205 Expr *IntExpr,
206 SourceLocation EndLoc)
207 : OpenACCClauseWithSingleIntExpr(OpenACCClauseKind::VectorLength, BeginLoc,
208 LParenLoc, IntExpr, EndLoc) {
209 assert((!IntExpr || IntExpr->isInstantiationDependent() ||
210 IntExpr->getType()->isIntegerType()) &&
211 "Condition expression type not scalar/dependent");
212 }
213
214 OpenACCVectorLengthClause *
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * IntExpr,SourceLocation EndLoc)215 OpenACCVectorLengthClause::Create(const ASTContext &C, SourceLocation BeginLoc,
216 SourceLocation LParenLoc, Expr *IntExpr,
217 SourceLocation EndLoc) {
218 void *Mem = C.Allocate(sizeof(OpenACCVectorLengthClause),
219 alignof(OpenACCVectorLengthClause));
220 return new (Mem)
221 OpenACCVectorLengthClause(BeginLoc, LParenLoc, IntExpr, EndLoc);
222 }
223
OpenACCAsyncClause(SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * IntExpr,SourceLocation EndLoc)224 OpenACCAsyncClause::OpenACCAsyncClause(SourceLocation BeginLoc,
225 SourceLocation LParenLoc, Expr *IntExpr,
226 SourceLocation EndLoc)
227 : OpenACCClauseWithSingleIntExpr(OpenACCClauseKind::Async, BeginLoc,
228 LParenLoc, IntExpr, EndLoc) {
229 assert((!IntExpr || IntExpr->isInstantiationDependent() ||
230 IntExpr->getType()->isIntegerType()) &&
231 "Condition expression type not scalar/dependent");
232 }
233
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * IntExpr,SourceLocation EndLoc)234 OpenACCAsyncClause *OpenACCAsyncClause::Create(const ASTContext &C,
235 SourceLocation BeginLoc,
236 SourceLocation LParenLoc,
237 Expr *IntExpr,
238 SourceLocation EndLoc) {
239 void *Mem =
240 C.Allocate(sizeof(OpenACCAsyncClause), alignof(OpenACCAsyncClause));
241 return new (Mem) OpenACCAsyncClause(BeginLoc, LParenLoc, IntExpr, EndLoc);
242 }
243
OpenACCDeviceNumClause(SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * IntExpr,SourceLocation EndLoc)244 OpenACCDeviceNumClause::OpenACCDeviceNumClause(SourceLocation BeginLoc,
245 SourceLocation LParenLoc, Expr *IntExpr,
246 SourceLocation EndLoc)
247 : OpenACCClauseWithSingleIntExpr(OpenACCClauseKind::DeviceNum, BeginLoc,
248 LParenLoc, IntExpr, EndLoc) {
249 assert((IntExpr->isInstantiationDependent() ||
250 IntExpr->getType()->isIntegerType()) &&
251 "device_num expression type not scalar/dependent");
252 }
253
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * IntExpr,SourceLocation EndLoc)254 OpenACCDeviceNumClause *OpenACCDeviceNumClause::Create(const ASTContext &C,
255 SourceLocation BeginLoc,
256 SourceLocation LParenLoc,
257 Expr *IntExpr,
258 SourceLocation EndLoc) {
259 void *Mem =
260 C.Allocate(sizeof(OpenACCDeviceNumClause), alignof(OpenACCDeviceNumClause));
261 return new (Mem) OpenACCDeviceNumClause(BeginLoc, LParenLoc, IntExpr, EndLoc);
262 }
263
OpenACCDefaultAsyncClause(SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * IntExpr,SourceLocation EndLoc)264 OpenACCDefaultAsyncClause::OpenACCDefaultAsyncClause(SourceLocation BeginLoc,
265 SourceLocation LParenLoc,
266 Expr *IntExpr,
267 SourceLocation EndLoc)
268 : OpenACCClauseWithSingleIntExpr(OpenACCClauseKind::DefaultAsync, BeginLoc,
269 LParenLoc, IntExpr, EndLoc) {
270 assert((IntExpr->isInstantiationDependent() ||
271 IntExpr->getType()->isIntegerType()) &&
272 "default_async expression type not scalar/dependent");
273 }
274
275 OpenACCDefaultAsyncClause *
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * IntExpr,SourceLocation EndLoc)276 OpenACCDefaultAsyncClause::Create(const ASTContext &C, SourceLocation BeginLoc,
277 SourceLocation LParenLoc, Expr *IntExpr,
278 SourceLocation EndLoc) {
279 void *Mem = C.Allocate(sizeof(OpenACCDefaultAsyncClause),
280 alignof(OpenACCDefaultAsyncClause));
281 return new (Mem)
282 OpenACCDefaultAsyncClause(BeginLoc, LParenLoc, IntExpr, EndLoc);
283 }
284
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * DevNumExpr,SourceLocation QueuesLoc,ArrayRef<Expr * > QueueIdExprs,SourceLocation EndLoc)285 OpenACCWaitClause *OpenACCWaitClause::Create(
286 const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc,
287 Expr *DevNumExpr, SourceLocation QueuesLoc, ArrayRef<Expr *> QueueIdExprs,
288 SourceLocation EndLoc) {
289 // Allocates enough room in trailing storage for all the int-exprs, plus a
290 // placeholder for the devnum.
291 void *Mem = C.Allocate(
292 OpenACCWaitClause::totalSizeToAlloc<Expr *>(QueueIdExprs.size() + 1));
293 return new (Mem) OpenACCWaitClause(BeginLoc, LParenLoc, DevNumExpr, QueuesLoc,
294 QueueIdExprs, EndLoc);
295 }
296
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<Expr * > IntExprs,SourceLocation EndLoc)297 OpenACCNumGangsClause *OpenACCNumGangsClause::Create(const ASTContext &C,
298 SourceLocation BeginLoc,
299 SourceLocation LParenLoc,
300 ArrayRef<Expr *> IntExprs,
301 SourceLocation EndLoc) {
302 void *Mem = C.Allocate(
303 OpenACCNumGangsClause::totalSizeToAlloc<Expr *>(IntExprs.size()));
304 return new (Mem) OpenACCNumGangsClause(BeginLoc, LParenLoc, IntExprs, EndLoc);
305 }
306
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<Expr * > SizeExprs,SourceLocation EndLoc)307 OpenACCTileClause *OpenACCTileClause::Create(const ASTContext &C,
308 SourceLocation BeginLoc,
309 SourceLocation LParenLoc,
310 ArrayRef<Expr *> SizeExprs,
311 SourceLocation EndLoc) {
312 void *Mem =
313 C.Allocate(OpenACCTileClause::totalSizeToAlloc<Expr *>(SizeExprs.size()));
314 return new (Mem) OpenACCTileClause(BeginLoc, LParenLoc, SizeExprs, EndLoc);
315 }
316
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<Expr * > VarList,SourceLocation EndLoc)317 OpenACCPrivateClause *OpenACCPrivateClause::Create(const ASTContext &C,
318 SourceLocation BeginLoc,
319 SourceLocation LParenLoc,
320 ArrayRef<Expr *> VarList,
321 SourceLocation EndLoc) {
322 void *Mem = C.Allocate(
323 OpenACCPrivateClause::totalSizeToAlloc<Expr *>(VarList.size()));
324 return new (Mem) OpenACCPrivateClause(BeginLoc, LParenLoc, VarList, EndLoc);
325 }
326
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<Expr * > VarList,SourceLocation EndLoc)327 OpenACCFirstPrivateClause *OpenACCFirstPrivateClause::Create(
328 const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc,
329 ArrayRef<Expr *> VarList, SourceLocation EndLoc) {
330 void *Mem = C.Allocate(
331 OpenACCFirstPrivateClause::totalSizeToAlloc<Expr *>(VarList.size()));
332 return new (Mem)
333 OpenACCFirstPrivateClause(BeginLoc, LParenLoc, VarList, EndLoc);
334 }
335
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<Expr * > VarList,SourceLocation EndLoc)336 OpenACCAttachClause *OpenACCAttachClause::Create(const ASTContext &C,
337 SourceLocation BeginLoc,
338 SourceLocation LParenLoc,
339 ArrayRef<Expr *> VarList,
340 SourceLocation EndLoc) {
341 void *Mem =
342 C.Allocate(OpenACCAttachClause::totalSizeToAlloc<Expr *>(VarList.size()));
343 return new (Mem) OpenACCAttachClause(BeginLoc, LParenLoc, VarList, EndLoc);
344 }
345
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<Expr * > VarList,SourceLocation EndLoc)346 OpenACCDetachClause *OpenACCDetachClause::Create(const ASTContext &C,
347 SourceLocation BeginLoc,
348 SourceLocation LParenLoc,
349 ArrayRef<Expr *> VarList,
350 SourceLocation EndLoc) {
351 void *Mem =
352 C.Allocate(OpenACCDetachClause::totalSizeToAlloc<Expr *>(VarList.size()));
353 return new (Mem) OpenACCDetachClause(BeginLoc, LParenLoc, VarList, EndLoc);
354 }
355
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<Expr * > VarList,SourceLocation EndLoc)356 OpenACCDeleteClause *OpenACCDeleteClause::Create(const ASTContext &C,
357 SourceLocation BeginLoc,
358 SourceLocation LParenLoc,
359 ArrayRef<Expr *> VarList,
360 SourceLocation EndLoc) {
361 void *Mem =
362 C.Allocate(OpenACCDeleteClause::totalSizeToAlloc<Expr *>(VarList.size()));
363 return new (Mem) OpenACCDeleteClause(BeginLoc, LParenLoc, VarList, EndLoc);
364 }
365
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<Expr * > VarList,SourceLocation EndLoc)366 OpenACCUseDeviceClause *OpenACCUseDeviceClause::Create(const ASTContext &C,
367 SourceLocation BeginLoc,
368 SourceLocation LParenLoc,
369 ArrayRef<Expr *> VarList,
370 SourceLocation EndLoc) {
371 void *Mem = C.Allocate(
372 OpenACCUseDeviceClause::totalSizeToAlloc<Expr *>(VarList.size()));
373 return new (Mem) OpenACCUseDeviceClause(BeginLoc, LParenLoc, VarList, EndLoc);
374 }
375
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<Expr * > VarList,SourceLocation EndLoc)376 OpenACCDevicePtrClause *OpenACCDevicePtrClause::Create(const ASTContext &C,
377 SourceLocation BeginLoc,
378 SourceLocation LParenLoc,
379 ArrayRef<Expr *> VarList,
380 SourceLocation EndLoc) {
381 void *Mem = C.Allocate(
382 OpenACCDevicePtrClause::totalSizeToAlloc<Expr *>(VarList.size()));
383 return new (Mem) OpenACCDevicePtrClause(BeginLoc, LParenLoc, VarList, EndLoc);
384 }
385
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<Expr * > VarList,SourceLocation EndLoc)386 OpenACCNoCreateClause *OpenACCNoCreateClause::Create(const ASTContext &C,
387 SourceLocation BeginLoc,
388 SourceLocation LParenLoc,
389 ArrayRef<Expr *> VarList,
390 SourceLocation EndLoc) {
391 void *Mem = C.Allocate(
392 OpenACCNoCreateClause::totalSizeToAlloc<Expr *>(VarList.size()));
393 return new (Mem) OpenACCNoCreateClause(BeginLoc, LParenLoc, VarList, EndLoc);
394 }
395
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<Expr * > VarList,SourceLocation EndLoc)396 OpenACCPresentClause *OpenACCPresentClause::Create(const ASTContext &C,
397 SourceLocation BeginLoc,
398 SourceLocation LParenLoc,
399 ArrayRef<Expr *> VarList,
400 SourceLocation EndLoc) {
401 void *Mem = C.Allocate(
402 OpenACCPresentClause::totalSizeToAlloc<Expr *>(VarList.size()));
403 return new (Mem) OpenACCPresentClause(BeginLoc, LParenLoc, VarList, EndLoc);
404 }
405
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<Expr * > VarList,SourceLocation EndLoc)406 OpenACCHostClause *OpenACCHostClause::Create(const ASTContext &C,
407 SourceLocation BeginLoc,
408 SourceLocation LParenLoc,
409 ArrayRef<Expr *> VarList,
410 SourceLocation EndLoc) {
411 void *Mem =
412 C.Allocate(OpenACCHostClause::totalSizeToAlloc<Expr *>(VarList.size()));
413 return new (Mem) OpenACCHostClause(BeginLoc, LParenLoc, VarList, EndLoc);
414 }
415
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<Expr * > VarList,SourceLocation EndLoc)416 OpenACCDeviceClause *OpenACCDeviceClause::Create(const ASTContext &C,
417 SourceLocation BeginLoc,
418 SourceLocation LParenLoc,
419 ArrayRef<Expr *> VarList,
420 SourceLocation EndLoc) {
421 void *Mem =
422 C.Allocate(OpenACCDeviceClause::totalSizeToAlloc<Expr *>(VarList.size()));
423 return new (Mem) OpenACCDeviceClause(BeginLoc, LParenLoc, VarList, EndLoc);
424 }
425
426 OpenACCCopyClause *
Create(const ASTContext & C,OpenACCClauseKind Spelling,SourceLocation BeginLoc,SourceLocation LParenLoc,OpenACCModifierKind Mods,ArrayRef<Expr * > VarList,SourceLocation EndLoc)427 OpenACCCopyClause::Create(const ASTContext &C, OpenACCClauseKind Spelling,
428 SourceLocation BeginLoc, SourceLocation LParenLoc,
429 OpenACCModifierKind Mods, ArrayRef<Expr *> VarList,
430 SourceLocation EndLoc) {
431 void *Mem =
432 C.Allocate(OpenACCCopyClause::totalSizeToAlloc<Expr *>(VarList.size()));
433 return new (Mem)
434 OpenACCCopyClause(Spelling, BeginLoc, LParenLoc, Mods, VarList, EndLoc);
435 }
436
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<Expr * > VarList,SourceLocation EndLoc)437 OpenACCLinkClause *OpenACCLinkClause::Create(const ASTContext &C,
438 SourceLocation BeginLoc,
439 SourceLocation LParenLoc,
440 ArrayRef<Expr *> VarList,
441 SourceLocation EndLoc) {
442 void *Mem =
443 C.Allocate(OpenACCLinkClause::totalSizeToAlloc<Expr *>(VarList.size()));
444 return new (Mem) OpenACCLinkClause(BeginLoc, LParenLoc, VarList, EndLoc);
445 }
446
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<Expr * > VarList,SourceLocation EndLoc)447 OpenACCDeviceResidentClause *OpenACCDeviceResidentClause::Create(
448 const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc,
449 ArrayRef<Expr *> VarList, SourceLocation EndLoc) {
450 void *Mem = C.Allocate(
451 OpenACCDeviceResidentClause::totalSizeToAlloc<Expr *>(VarList.size()));
452 return new (Mem)
453 OpenACCDeviceResidentClause(BeginLoc, LParenLoc, VarList, EndLoc);
454 }
455
456 OpenACCCopyInClause *
Create(const ASTContext & C,OpenACCClauseKind Spelling,SourceLocation BeginLoc,SourceLocation LParenLoc,OpenACCModifierKind Mods,ArrayRef<Expr * > VarList,SourceLocation EndLoc)457 OpenACCCopyInClause::Create(const ASTContext &C, OpenACCClauseKind Spelling,
458 SourceLocation BeginLoc, SourceLocation LParenLoc,
459 OpenACCModifierKind Mods, ArrayRef<Expr *> VarList,
460 SourceLocation EndLoc) {
461 void *Mem =
462 C.Allocate(OpenACCCopyInClause::totalSizeToAlloc<Expr *>(VarList.size()));
463 return new (Mem)
464 OpenACCCopyInClause(Spelling, BeginLoc, LParenLoc, Mods, VarList, EndLoc);
465 }
466
467 OpenACCCopyOutClause *
Create(const ASTContext & C,OpenACCClauseKind Spelling,SourceLocation BeginLoc,SourceLocation LParenLoc,OpenACCModifierKind Mods,ArrayRef<Expr * > VarList,SourceLocation EndLoc)468 OpenACCCopyOutClause::Create(const ASTContext &C, OpenACCClauseKind Spelling,
469 SourceLocation BeginLoc, SourceLocation LParenLoc,
470 OpenACCModifierKind Mods, ArrayRef<Expr *> VarList,
471 SourceLocation EndLoc) {
472 void *Mem = C.Allocate(
473 OpenACCCopyOutClause::totalSizeToAlloc<Expr *>(VarList.size()));
474 return new (Mem) OpenACCCopyOutClause(Spelling, BeginLoc, LParenLoc, Mods,
475 VarList, EndLoc);
476 }
477
478 OpenACCCreateClause *
Create(const ASTContext & C,OpenACCClauseKind Spelling,SourceLocation BeginLoc,SourceLocation LParenLoc,OpenACCModifierKind Mods,ArrayRef<Expr * > VarList,SourceLocation EndLoc)479 OpenACCCreateClause::Create(const ASTContext &C, OpenACCClauseKind Spelling,
480 SourceLocation BeginLoc, SourceLocation LParenLoc,
481 OpenACCModifierKind Mods, ArrayRef<Expr *> VarList,
482 SourceLocation EndLoc) {
483 void *Mem =
484 C.Allocate(OpenACCCreateClause::totalSizeToAlloc<Expr *>(VarList.size()));
485 return new (Mem)
486 OpenACCCreateClause(Spelling, BeginLoc, LParenLoc, Mods, VarList, EndLoc);
487 }
488
Create(const ASTContext & C,OpenACCClauseKind K,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<DeviceTypeArgument> Archs,SourceLocation EndLoc)489 OpenACCDeviceTypeClause *OpenACCDeviceTypeClause::Create(
490 const ASTContext &C, OpenACCClauseKind K, SourceLocation BeginLoc,
491 SourceLocation LParenLoc, ArrayRef<DeviceTypeArgument> Archs,
492 SourceLocation EndLoc) {
493 void *Mem =
494 C.Allocate(OpenACCDeviceTypeClause::totalSizeToAlloc<DeviceTypeArgument>(
495 Archs.size()));
496 return new (Mem)
497 OpenACCDeviceTypeClause(K, BeginLoc, LParenLoc, Archs, EndLoc);
498 }
499
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,OpenACCReductionOperator Operator,ArrayRef<Expr * > VarList,SourceLocation EndLoc)500 OpenACCReductionClause *OpenACCReductionClause::Create(
501 const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc,
502 OpenACCReductionOperator Operator, ArrayRef<Expr *> VarList,
503 SourceLocation EndLoc) {
504 void *Mem = C.Allocate(
505 OpenACCReductionClause::totalSizeToAlloc<Expr *>(VarList.size()));
506 return new (Mem)
507 OpenACCReductionClause(BeginLoc, LParenLoc, Operator, VarList, EndLoc);
508 }
509
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation EndLoc)510 OpenACCAutoClause *OpenACCAutoClause::Create(const ASTContext &C,
511 SourceLocation BeginLoc,
512 SourceLocation EndLoc) {
513 void *Mem = C.Allocate(sizeof(OpenACCAutoClause));
514 return new (Mem) OpenACCAutoClause(BeginLoc, EndLoc);
515 }
516
517 OpenACCIndependentClause *
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation EndLoc)518 OpenACCIndependentClause::Create(const ASTContext &C, SourceLocation BeginLoc,
519 SourceLocation EndLoc) {
520 void *Mem = C.Allocate(sizeof(OpenACCIndependentClause));
521 return new (Mem) OpenACCIndependentClause(BeginLoc, EndLoc);
522 }
523
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation EndLoc)524 OpenACCSeqClause *OpenACCSeqClause::Create(const ASTContext &C,
525 SourceLocation BeginLoc,
526 SourceLocation EndLoc) {
527 void *Mem = C.Allocate(sizeof(OpenACCSeqClause));
528 return new (Mem) OpenACCSeqClause(BeginLoc, EndLoc);
529 }
530
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation EndLoc)531 OpenACCNoHostClause *OpenACCNoHostClause::Create(const ASTContext &C,
532 SourceLocation BeginLoc,
533 SourceLocation EndLoc) {
534 void *Mem = C.Allocate(sizeof(OpenACCNoHostClause));
535 return new (Mem) OpenACCNoHostClause(BeginLoc, EndLoc);
536 }
537
538 OpenACCGangClause *
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,ArrayRef<OpenACCGangKind> GangKinds,ArrayRef<Expr * > IntExprs,SourceLocation EndLoc)539 OpenACCGangClause::Create(const ASTContext &C, SourceLocation BeginLoc,
540 SourceLocation LParenLoc,
541 ArrayRef<OpenACCGangKind> GangKinds,
542 ArrayRef<Expr *> IntExprs, SourceLocation EndLoc) {
543 void *Mem =
544 C.Allocate(OpenACCGangClause::totalSizeToAlloc<Expr *, OpenACCGangKind>(
545 IntExprs.size(), GangKinds.size()));
546 return new (Mem)
547 OpenACCGangClause(BeginLoc, LParenLoc, GangKinds, IntExprs, EndLoc);
548 }
549
OpenACCWorkerClause(SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * IntExpr,SourceLocation EndLoc)550 OpenACCWorkerClause::OpenACCWorkerClause(SourceLocation BeginLoc,
551 SourceLocation LParenLoc,
552 Expr *IntExpr, SourceLocation EndLoc)
553 : OpenACCClauseWithSingleIntExpr(OpenACCClauseKind::Worker, BeginLoc,
554 LParenLoc, IntExpr, EndLoc) {
555 assert((!IntExpr || IntExpr->isInstantiationDependent() ||
556 IntExpr->getType()->isIntegerType()) &&
557 "Int expression type not scalar/dependent");
558 }
559
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * IntExpr,SourceLocation EndLoc)560 OpenACCWorkerClause *OpenACCWorkerClause::Create(const ASTContext &C,
561 SourceLocation BeginLoc,
562 SourceLocation LParenLoc,
563 Expr *IntExpr,
564 SourceLocation EndLoc) {
565 void *Mem =
566 C.Allocate(sizeof(OpenACCWorkerClause), alignof(OpenACCWorkerClause));
567 return new (Mem) OpenACCWorkerClause(BeginLoc, LParenLoc, IntExpr, EndLoc);
568 }
569
OpenACCVectorClause(SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * IntExpr,SourceLocation EndLoc)570 OpenACCVectorClause::OpenACCVectorClause(SourceLocation BeginLoc,
571 SourceLocation LParenLoc,
572 Expr *IntExpr, SourceLocation EndLoc)
573 : OpenACCClauseWithSingleIntExpr(OpenACCClauseKind::Vector, BeginLoc,
574 LParenLoc, IntExpr, EndLoc) {
575 assert((!IntExpr || IntExpr->isInstantiationDependent() ||
576 IntExpr->getType()->isIntegerType()) &&
577 "Int expression type not scalar/dependent");
578 }
579
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,Expr * IntExpr,SourceLocation EndLoc)580 OpenACCVectorClause *OpenACCVectorClause::Create(const ASTContext &C,
581 SourceLocation BeginLoc,
582 SourceLocation LParenLoc,
583 Expr *IntExpr,
584 SourceLocation EndLoc) {
585 void *Mem =
586 C.Allocate(sizeof(OpenACCVectorClause), alignof(OpenACCVectorClause));
587 return new (Mem) OpenACCVectorClause(BeginLoc, LParenLoc, IntExpr, EndLoc);
588 }
589
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation EndLoc)590 OpenACCFinalizeClause *OpenACCFinalizeClause::Create(const ASTContext &C,
591 SourceLocation BeginLoc,
592 SourceLocation EndLoc) {
593 void *Mem =
594 C.Allocate(sizeof(OpenACCFinalizeClause), alignof(OpenACCFinalizeClause));
595 return new (Mem) OpenACCFinalizeClause(BeginLoc, EndLoc);
596 }
597
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation EndLoc)598 OpenACCIfPresentClause *OpenACCIfPresentClause::Create(const ASTContext &C,
599 SourceLocation BeginLoc,
600 SourceLocation EndLoc) {
601 void *Mem = C.Allocate(sizeof(OpenACCIfPresentClause),
602 alignof(OpenACCIfPresentClause));
603 return new (Mem) OpenACCIfPresentClause(BeginLoc, EndLoc);
604 }
605
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,const StringLiteral * SL,SourceLocation EndLoc)606 OpenACCBindClause *OpenACCBindClause::Create(const ASTContext &C,
607 SourceLocation BeginLoc,
608 SourceLocation LParenLoc,
609 const StringLiteral *SL,
610 SourceLocation EndLoc) {
611 void *Mem = C.Allocate(sizeof(OpenACCBindClause), alignof(OpenACCBindClause));
612 return new (Mem) OpenACCBindClause(BeginLoc, LParenLoc, SL, EndLoc);
613 }
614
Create(const ASTContext & C,SourceLocation BeginLoc,SourceLocation LParenLoc,const IdentifierInfo * ID,SourceLocation EndLoc)615 OpenACCBindClause *OpenACCBindClause::Create(const ASTContext &C,
616 SourceLocation BeginLoc,
617 SourceLocation LParenLoc,
618 const IdentifierInfo *ID,
619 SourceLocation EndLoc) {
620 void *Mem = C.Allocate(sizeof(OpenACCBindClause), alignof(OpenACCBindClause));
621 return new (Mem) OpenACCBindClause(BeginLoc, LParenLoc, ID, EndLoc);
622 }
623
operator ==(const OpenACCBindClause & LHS,const OpenACCBindClause & RHS)624 bool clang::operator==(const OpenACCBindClause &LHS,
625 const OpenACCBindClause &RHS) {
626 if (LHS.isStringArgument() != RHS.isStringArgument())
627 return false;
628
629 if (LHS.isStringArgument())
630 return LHS.getStringArgument()->getString() ==
631 RHS.getStringArgument()->getString();
632 return LHS.getIdentifierArgument()->getName() ==
633 RHS.getIdentifierArgument()->getName();
634 }
635
636 //===----------------------------------------------------------------------===//
637 // OpenACC clauses printing methods
638 //===----------------------------------------------------------------------===//
639
printExpr(const Expr * E)640 void OpenACCClausePrinter::printExpr(const Expr *E) {
641 E->printPretty(OS, nullptr, Policy, 0);
642 }
643
VisitDefaultClause(const OpenACCDefaultClause & C)644 void OpenACCClausePrinter::VisitDefaultClause(const OpenACCDefaultClause &C) {
645 OS << "default(" << C.getDefaultClauseKind() << ")";
646 }
647
VisitIfClause(const OpenACCIfClause & C)648 void OpenACCClausePrinter::VisitIfClause(const OpenACCIfClause &C) {
649 OS << "if(";
650 printExpr(C.getConditionExpr());
651 OS << ")";
652 }
653
VisitSelfClause(const OpenACCSelfClause & C)654 void OpenACCClausePrinter::VisitSelfClause(const OpenACCSelfClause &C) {
655 OS << "self";
656
657 if (C.isConditionExprClause()) {
658 if (const Expr *CondExpr = C.getConditionExpr()) {
659 OS << "(";
660 printExpr(CondExpr);
661 OS << ")";
662 }
663 } else {
664 OS << "(";
665 llvm::interleaveComma(C.getVarList(), OS,
666 [&](const Expr *E) { printExpr(E); });
667 OS << ")";
668 }
669 }
670
VisitNumGangsClause(const OpenACCNumGangsClause & C)671 void OpenACCClausePrinter::VisitNumGangsClause(const OpenACCNumGangsClause &C) {
672 OS << "num_gangs(";
673 llvm::interleaveComma(C.getIntExprs(), OS,
674 [&](const Expr *E) { printExpr(E); });
675 OS << ")";
676 }
677
VisitTileClause(const OpenACCTileClause & C)678 void OpenACCClausePrinter::VisitTileClause(const OpenACCTileClause &C) {
679 OS << "tile(";
680 llvm::interleaveComma(C.getSizeExprs(), OS,
681 [&](const Expr *E) { printExpr(E); });
682 OS << ")";
683 }
684
VisitNumWorkersClause(const OpenACCNumWorkersClause & C)685 void OpenACCClausePrinter::VisitNumWorkersClause(
686 const OpenACCNumWorkersClause &C) {
687 OS << "num_workers(";
688 printExpr(C.getIntExpr());
689 OS << ")";
690 }
691
VisitVectorLengthClause(const OpenACCVectorLengthClause & C)692 void OpenACCClausePrinter::VisitVectorLengthClause(
693 const OpenACCVectorLengthClause &C) {
694 OS << "vector_length(";
695 printExpr(C.getIntExpr());
696 OS << ")";
697 }
698
VisitDeviceNumClause(const OpenACCDeviceNumClause & C)699 void OpenACCClausePrinter::VisitDeviceNumClause(
700 const OpenACCDeviceNumClause &C) {
701 OS << "device_num(";
702 printExpr(C.getIntExpr());
703 OS << ")";
704 }
705
VisitDefaultAsyncClause(const OpenACCDefaultAsyncClause & C)706 void OpenACCClausePrinter::VisitDefaultAsyncClause(
707 const OpenACCDefaultAsyncClause &C) {
708 OS << "default_async(";
709 printExpr(C.getIntExpr());
710 OS << ")";
711 }
712
VisitAsyncClause(const OpenACCAsyncClause & C)713 void OpenACCClausePrinter::VisitAsyncClause(const OpenACCAsyncClause &C) {
714 OS << "async";
715 if (C.hasIntExpr()) {
716 OS << "(";
717 printExpr(C.getIntExpr());
718 OS << ")";
719 }
720 }
721
VisitPrivateClause(const OpenACCPrivateClause & C)722 void OpenACCClausePrinter::VisitPrivateClause(const OpenACCPrivateClause &C) {
723 OS << "private(";
724 llvm::interleaveComma(C.getVarList(), OS,
725 [&](const Expr *E) { printExpr(E); });
726 OS << ")";
727 }
728
VisitFirstPrivateClause(const OpenACCFirstPrivateClause & C)729 void OpenACCClausePrinter::VisitFirstPrivateClause(
730 const OpenACCFirstPrivateClause &C) {
731 OS << "firstprivate(";
732 llvm::interleaveComma(C.getVarList(), OS,
733 [&](const Expr *E) { printExpr(E); });
734 OS << ")";
735 }
736
VisitAttachClause(const OpenACCAttachClause & C)737 void OpenACCClausePrinter::VisitAttachClause(const OpenACCAttachClause &C) {
738 OS << "attach(";
739 llvm::interleaveComma(C.getVarList(), OS,
740 [&](const Expr *E) { printExpr(E); });
741 OS << ")";
742 }
743
VisitDetachClause(const OpenACCDetachClause & C)744 void OpenACCClausePrinter::VisitDetachClause(const OpenACCDetachClause &C) {
745 OS << "detach(";
746 llvm::interleaveComma(C.getVarList(), OS,
747 [&](const Expr *E) { printExpr(E); });
748 OS << ")";
749 }
750
VisitDeleteClause(const OpenACCDeleteClause & C)751 void OpenACCClausePrinter::VisitDeleteClause(const OpenACCDeleteClause &C) {
752 OS << "delete(";
753 llvm::interleaveComma(C.getVarList(), OS,
754 [&](const Expr *E) { printExpr(E); });
755 OS << ")";
756 }
757
VisitUseDeviceClause(const OpenACCUseDeviceClause & C)758 void OpenACCClausePrinter::VisitUseDeviceClause(
759 const OpenACCUseDeviceClause &C) {
760 OS << "use_device(";
761 llvm::interleaveComma(C.getVarList(), OS,
762 [&](const Expr *E) { printExpr(E); });
763 OS << ")";
764 }
765
VisitDevicePtrClause(const OpenACCDevicePtrClause & C)766 void OpenACCClausePrinter::VisitDevicePtrClause(
767 const OpenACCDevicePtrClause &C) {
768 OS << "deviceptr(";
769 llvm::interleaveComma(C.getVarList(), OS,
770 [&](const Expr *E) { printExpr(E); });
771 OS << ")";
772 }
773
VisitNoCreateClause(const OpenACCNoCreateClause & C)774 void OpenACCClausePrinter::VisitNoCreateClause(const OpenACCNoCreateClause &C) {
775 OS << "no_create(";
776 llvm::interleaveComma(C.getVarList(), OS,
777 [&](const Expr *E) { printExpr(E); });
778 OS << ")";
779 }
780
VisitPresentClause(const OpenACCPresentClause & C)781 void OpenACCClausePrinter::VisitPresentClause(const OpenACCPresentClause &C) {
782 OS << "present(";
783 llvm::interleaveComma(C.getVarList(), OS,
784 [&](const Expr *E) { printExpr(E); });
785 OS << ")";
786 }
787
VisitHostClause(const OpenACCHostClause & C)788 void OpenACCClausePrinter::VisitHostClause(const OpenACCHostClause &C) {
789 OS << "host(";
790 llvm::interleaveComma(C.getVarList(), OS,
791 [&](const Expr *E) { printExpr(E); });
792 OS << ")";
793 }
794
VisitDeviceClause(const OpenACCDeviceClause & C)795 void OpenACCClausePrinter::VisitDeviceClause(const OpenACCDeviceClause &C) {
796 OS << "device(";
797 llvm::interleaveComma(C.getVarList(), OS,
798 [&](const Expr *E) { printExpr(E); });
799 OS << ")";
800 }
801
VisitCopyClause(const OpenACCCopyClause & C)802 void OpenACCClausePrinter::VisitCopyClause(const OpenACCCopyClause &C) {
803 OS << C.getClauseKind() << '(';
804 if (C.getModifierList() != OpenACCModifierKind::Invalid)
805 OS << C.getModifierList() << ": ";
806 llvm::interleaveComma(C.getVarList(), OS,
807 [&](const Expr *E) { printExpr(E); });
808 OS << ")";
809 }
810
VisitLinkClause(const OpenACCLinkClause & C)811 void OpenACCClausePrinter::VisitLinkClause(const OpenACCLinkClause &C) {
812 OS << "link(";
813 llvm::interleaveComma(C.getVarList(), OS,
814 [&](const Expr *E) { printExpr(E); });
815 OS << ")";
816 }
817
VisitDeviceResidentClause(const OpenACCDeviceResidentClause & C)818 void OpenACCClausePrinter::VisitDeviceResidentClause(
819 const OpenACCDeviceResidentClause &C) {
820 OS << "device_resident(";
821 llvm::interleaveComma(C.getVarList(), OS,
822 [&](const Expr *E) { printExpr(E); });
823 OS << ")";
824 }
825
VisitCopyInClause(const OpenACCCopyInClause & C)826 void OpenACCClausePrinter::VisitCopyInClause(const OpenACCCopyInClause &C) {
827 OS << C.getClauseKind() << '(';
828 if (C.getModifierList() != OpenACCModifierKind::Invalid)
829 OS << C.getModifierList() << ": ";
830 llvm::interleaveComma(C.getVarList(), OS,
831 [&](const Expr *E) { printExpr(E); });
832 OS << ")";
833 }
834
VisitCopyOutClause(const OpenACCCopyOutClause & C)835 void OpenACCClausePrinter::VisitCopyOutClause(const OpenACCCopyOutClause &C) {
836 OS << C.getClauseKind() << '(';
837 if (C.getModifierList() != OpenACCModifierKind::Invalid)
838 OS << C.getModifierList() << ": ";
839 llvm::interleaveComma(C.getVarList(), OS,
840 [&](const Expr *E) { printExpr(E); });
841 OS << ")";
842 }
843
VisitCreateClause(const OpenACCCreateClause & C)844 void OpenACCClausePrinter::VisitCreateClause(const OpenACCCreateClause &C) {
845 OS << C.getClauseKind() << '(';
846 if (C.getModifierList() != OpenACCModifierKind::Invalid)
847 OS << C.getModifierList() << ": ";
848 llvm::interleaveComma(C.getVarList(), OS,
849 [&](const Expr *E) { printExpr(E); });
850 OS << ")";
851 }
852
VisitReductionClause(const OpenACCReductionClause & C)853 void OpenACCClausePrinter::VisitReductionClause(
854 const OpenACCReductionClause &C) {
855 OS << "reduction(" << C.getReductionOp() << ": ";
856 llvm::interleaveComma(C.getVarList(), OS,
857 [&](const Expr *E) { printExpr(E); });
858 OS << ")";
859 }
860
VisitWaitClause(const OpenACCWaitClause & C)861 void OpenACCClausePrinter::VisitWaitClause(const OpenACCWaitClause &C) {
862 OS << "wait";
863 if (C.hasExprs()) {
864 OS << "(";
865 if (C.hasDevNumExpr()) {
866 OS << "devnum: ";
867 printExpr(C.getDevNumExpr());
868 OS << " : ";
869 }
870
871 if (C.hasQueuesTag())
872 OS << "queues: ";
873
874 llvm::interleaveComma(C.getQueueIdExprs(), OS,
875 [&](const Expr *E) { printExpr(E); });
876 OS << ")";
877 }
878 }
879
VisitDeviceTypeClause(const OpenACCDeviceTypeClause & C)880 void OpenACCClausePrinter::VisitDeviceTypeClause(
881 const OpenACCDeviceTypeClause &C) {
882 OS << C.getClauseKind();
883 OS << "(";
884 llvm::interleaveComma(C.getArchitectures(), OS,
885 [&](const DeviceTypeArgument &Arch) {
886 if (Arch.getIdentifierInfo() == nullptr)
887 OS << "*";
888 else
889 OS << Arch.getIdentifierInfo()->getName();
890 });
891 OS << ")";
892 }
893
VisitAutoClause(const OpenACCAutoClause & C)894 void OpenACCClausePrinter::VisitAutoClause(const OpenACCAutoClause &C) {
895 OS << "auto";
896 }
897
VisitIndependentClause(const OpenACCIndependentClause & C)898 void OpenACCClausePrinter::VisitIndependentClause(
899 const OpenACCIndependentClause &C) {
900 OS << "independent";
901 }
902
VisitSeqClause(const OpenACCSeqClause & C)903 void OpenACCClausePrinter::VisitSeqClause(const OpenACCSeqClause &C) {
904 OS << "seq";
905 }
906
VisitNoHostClause(const OpenACCNoHostClause & C)907 void OpenACCClausePrinter::VisitNoHostClause(const OpenACCNoHostClause &C) {
908 OS << "nohost";
909 }
910
VisitCollapseClause(const OpenACCCollapseClause & C)911 void OpenACCClausePrinter::VisitCollapseClause(const OpenACCCollapseClause &C) {
912 OS << "collapse(";
913 if (C.hasForce())
914 OS << "force:";
915 printExpr(C.getLoopCount());
916 OS << ")";
917 }
918
VisitGangClause(const OpenACCGangClause & C)919 void OpenACCClausePrinter::VisitGangClause(const OpenACCGangClause &C) {
920 OS << "gang";
921
922 if (C.getNumExprs() > 0) {
923 OS << "(";
924 bool first = true;
925 for (unsigned I = 0; I < C.getNumExprs(); ++I) {
926 if (!first)
927 OS << ", ";
928 first = false;
929
930 OS << C.getExpr(I).first << ": ";
931 printExpr(C.getExpr(I).second);
932 }
933 OS << ")";
934 }
935 }
936
VisitWorkerClause(const OpenACCWorkerClause & C)937 void OpenACCClausePrinter::VisitWorkerClause(const OpenACCWorkerClause &C) {
938 OS << "worker";
939
940 if (C.hasIntExpr()) {
941 OS << "(num: ";
942 printExpr(C.getIntExpr());
943 OS << ")";
944 }
945 }
946
VisitVectorClause(const OpenACCVectorClause & C)947 void OpenACCClausePrinter::VisitVectorClause(const OpenACCVectorClause &C) {
948 OS << "vector";
949
950 if (C.hasIntExpr()) {
951 OS << "(length: ";
952 printExpr(C.getIntExpr());
953 OS << ")";
954 }
955 }
956
VisitFinalizeClause(const OpenACCFinalizeClause & C)957 void OpenACCClausePrinter::VisitFinalizeClause(const OpenACCFinalizeClause &C) {
958 OS << "finalize";
959 }
960
VisitIfPresentClause(const OpenACCIfPresentClause & C)961 void OpenACCClausePrinter::VisitIfPresentClause(
962 const OpenACCIfPresentClause &C) {
963 OS << "if_present";
964 }
965
VisitBindClause(const OpenACCBindClause & C)966 void OpenACCClausePrinter::VisitBindClause(const OpenACCBindClause &C) {
967 OS << "bind(";
968 if (C.isStringArgument())
969 OS << '"' << C.getStringArgument()->getString() << '"';
970 else
971 OS << C.getIdentifierArgument()->getName();
972 OS << ")";
973 }
974