xref: /llvm-project/clang/lib/AST/StmtOpenACC.cpp (revision db81e8c42e121e62a00587b12d2b972dfcfb98c0) 
1 //===--- StmtOpenACC.cpp - Classes for OpenACC Constructs -----------------===//
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 Stmt class declared in StmtOpenACC.h
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "clang/AST/StmtOpenACC.h"
14 #include "clang/AST/ASTContext.h"
15 #include "clang/AST/StmtCXX.h"
16 using namespace clang;
17 
18 OpenACCComputeConstruct *
19 OpenACCComputeConstruct::CreateEmpty(const ASTContext &C, unsigned NumClauses) {
20   void *Mem = C.Allocate(
21       OpenACCComputeConstruct::totalSizeToAlloc<const OpenACCClause *>(
22           NumClauses));
23   auto *Inst = new (Mem) OpenACCComputeConstruct(NumClauses);
24   return Inst;
25 }
26 
27 OpenACCComputeConstruct *OpenACCComputeConstruct::Create(
28     const ASTContext &C, OpenACCDirectiveKind K, SourceLocation BeginLoc,
29     SourceLocation DirLoc, SourceLocation EndLoc,
30     ArrayRef<const OpenACCClause *> Clauses, Stmt *StructuredBlock) {
31   void *Mem = C.Allocate(
32       OpenACCComputeConstruct::totalSizeToAlloc<const OpenACCClause *>(
33           Clauses.size()));
34   auto *Inst = new (Mem) OpenACCComputeConstruct(K, BeginLoc, DirLoc, EndLoc,
35                                                  Clauses, StructuredBlock);
36   return Inst;
37 }
38 
39 OpenACCLoopConstruct::OpenACCLoopConstruct(unsigned NumClauses)
40     : OpenACCAssociatedStmtConstruct(
41           OpenACCLoopConstructClass, OpenACCDirectiveKind::Loop,
42           SourceLocation{}, SourceLocation{}, SourceLocation{},
43           /*AssociatedStmt=*/nullptr) {
44   std::uninitialized_value_construct(
45       getTrailingObjects<const OpenACCClause *>(),
46       getTrailingObjects<const OpenACCClause *>() + NumClauses);
47   setClauseList(
48       MutableArrayRef(getTrailingObjects<const OpenACCClause *>(), NumClauses));
49 }
50 
51 OpenACCLoopConstruct::OpenACCLoopConstruct(
52     OpenACCDirectiveKind ParentKind, SourceLocation Start,
53     SourceLocation DirLoc, SourceLocation End,
54     ArrayRef<const OpenACCClause *> Clauses, Stmt *Loop)
55     : OpenACCAssociatedStmtConstruct(OpenACCLoopConstructClass,
56                                      OpenACCDirectiveKind::Loop, Start, DirLoc,
57                                      End, Loop),
58       ParentComputeConstructKind(ParentKind) {
59   // accept 'nullptr' for the loop. This is diagnosed somewhere, but this gives
60   // us some level of AST fidelity in the error case.
61   assert((Loop == nullptr || isa<ForStmt, CXXForRangeStmt>(Loop)) &&
62          "Associated Loop not a for loop?");
63   // Initialize the trailing storage.
64   std::uninitialized_copy(Clauses.begin(), Clauses.end(),
65                           getTrailingObjects<const OpenACCClause *>());
66 
67   setClauseList(MutableArrayRef(getTrailingObjects<const OpenACCClause *>(),
68                                 Clauses.size()));
69 }
70 
71 OpenACCLoopConstruct *OpenACCLoopConstruct::CreateEmpty(const ASTContext &C,
72                                                         unsigned NumClauses) {
73   void *Mem =
74       C.Allocate(OpenACCLoopConstruct::totalSizeToAlloc<const OpenACCClause *>(
75           NumClauses));
76   auto *Inst = new (Mem) OpenACCLoopConstruct(NumClauses);
77   return Inst;
78 }
79 
80 OpenACCLoopConstruct *OpenACCLoopConstruct::Create(
81     const ASTContext &C, OpenACCDirectiveKind ParentKind,
82     SourceLocation BeginLoc, SourceLocation DirLoc, SourceLocation EndLoc,
83     ArrayRef<const OpenACCClause *> Clauses, Stmt *Loop) {
84   void *Mem =
85       C.Allocate(OpenACCLoopConstruct::totalSizeToAlloc<const OpenACCClause *>(
86           Clauses.size()));
87   auto *Inst = new (Mem)
88       OpenACCLoopConstruct(ParentKind, BeginLoc, DirLoc, EndLoc, Clauses, Loop);
89   return Inst;
90 }
91 
92 OpenACCCombinedConstruct *
93 OpenACCCombinedConstruct::CreateEmpty(const ASTContext &C,
94                                       unsigned NumClauses) {
95   void *Mem = C.Allocate(
96       OpenACCCombinedConstruct::totalSizeToAlloc<const OpenACCClause *>(
97           NumClauses));
98   auto *Inst = new (Mem) OpenACCCombinedConstruct(NumClauses);
99   return Inst;
100 }
101 
102 OpenACCCombinedConstruct *OpenACCCombinedConstruct::Create(
103     const ASTContext &C, OpenACCDirectiveKind DK, SourceLocation BeginLoc,
104     SourceLocation DirLoc, SourceLocation EndLoc,
105     ArrayRef<const OpenACCClause *> Clauses, Stmt *Loop) {
106   void *Mem = C.Allocate(
107       OpenACCCombinedConstruct::totalSizeToAlloc<const OpenACCClause *>(
108           Clauses.size()));
109   auto *Inst = new (Mem)
110       OpenACCCombinedConstruct(DK, BeginLoc, DirLoc, EndLoc, Clauses, Loop);
111   return Inst;
112 }
113 
114 OpenACCDataConstruct *OpenACCDataConstruct::CreateEmpty(const ASTContext &C,
115                                                         unsigned NumClauses) {
116   void *Mem =
117       C.Allocate(OpenACCDataConstruct::totalSizeToAlloc<const OpenACCClause *>(
118           NumClauses));
119   auto *Inst = new (Mem) OpenACCDataConstruct(NumClauses);
120   return Inst;
121 }
122 
123 OpenACCDataConstruct *
124 OpenACCDataConstruct::Create(const ASTContext &C, SourceLocation Start,
125                              SourceLocation DirectiveLoc, SourceLocation End,
126                              ArrayRef<const OpenACCClause *> Clauses,
127                              Stmt *StructuredBlock) {
128   void *Mem =
129       C.Allocate(OpenACCDataConstruct::totalSizeToAlloc<const OpenACCClause *>(
130           Clauses.size()));
131   auto *Inst = new (Mem)
132       OpenACCDataConstruct(Start, DirectiveLoc, End, Clauses, StructuredBlock);
133   return Inst;
134 }
135 
136 OpenACCEnterDataConstruct *
137 OpenACCEnterDataConstruct::CreateEmpty(const ASTContext &C,
138                                        unsigned NumClauses) {
139   void *Mem = C.Allocate(
140       OpenACCEnterDataConstruct::totalSizeToAlloc<const OpenACCClause *>(
141           NumClauses));
142   auto *Inst = new (Mem) OpenACCEnterDataConstruct(NumClauses);
143   return Inst;
144 }
145 
146 OpenACCEnterDataConstruct *OpenACCEnterDataConstruct::Create(
147     const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc,
148     SourceLocation End, ArrayRef<const OpenACCClause *> Clauses) {
149   void *Mem = C.Allocate(
150       OpenACCEnterDataConstruct::totalSizeToAlloc<const OpenACCClause *>(
151           Clauses.size()));
152   auto *Inst =
153       new (Mem) OpenACCEnterDataConstruct(Start, DirectiveLoc, End, Clauses);
154   return Inst;
155 }
156 
157 OpenACCExitDataConstruct *
158 OpenACCExitDataConstruct::CreateEmpty(const ASTContext &C,
159                                       unsigned NumClauses) {
160   void *Mem = C.Allocate(
161       OpenACCExitDataConstruct::totalSizeToAlloc<const OpenACCClause *>(
162           NumClauses));
163   auto *Inst = new (Mem) OpenACCExitDataConstruct(NumClauses);
164   return Inst;
165 }
166 
167 OpenACCExitDataConstruct *OpenACCExitDataConstruct::Create(
168     const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc,
169     SourceLocation End, ArrayRef<const OpenACCClause *> Clauses) {
170   void *Mem = C.Allocate(
171       OpenACCExitDataConstruct::totalSizeToAlloc<const OpenACCClause *>(
172           Clauses.size()));
173   auto *Inst =
174       new (Mem) OpenACCExitDataConstruct(Start, DirectiveLoc, End, Clauses);
175   return Inst;
176 }
177 
178 OpenACCHostDataConstruct *
179 OpenACCHostDataConstruct::CreateEmpty(const ASTContext &C,
180                                       unsigned NumClauses) {
181   void *Mem = C.Allocate(
182       OpenACCHostDataConstruct::totalSizeToAlloc<const OpenACCClause *>(
183           NumClauses));
184   auto *Inst = new (Mem) OpenACCHostDataConstruct(NumClauses);
185   return Inst;
186 }
187 
188 OpenACCHostDataConstruct *OpenACCHostDataConstruct::Create(
189     const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc,
190     SourceLocation End, ArrayRef<const OpenACCClause *> Clauses,
191     Stmt *StructuredBlock) {
192   void *Mem = C.Allocate(
193       OpenACCHostDataConstruct::totalSizeToAlloc<const OpenACCClause *>(
194           Clauses.size()));
195   auto *Inst = new (Mem) OpenACCHostDataConstruct(Start, DirectiveLoc, End,
196                                                   Clauses, StructuredBlock);
197   return Inst;
198 }
199 
200 OpenACCWaitConstruct *OpenACCWaitConstruct::CreateEmpty(const ASTContext &C,
201                                                         unsigned NumExprs,
202                                                         unsigned NumClauses) {
203   void *Mem = C.Allocate(
204       OpenACCWaitConstruct::totalSizeToAlloc<Expr *, OpenACCClause *>(
205           NumExprs, NumClauses));
206 
207   auto *Inst = new (Mem) OpenACCWaitConstruct(NumExprs, NumClauses);
208   return Inst;
209 }
210 
211 OpenACCWaitConstruct *OpenACCWaitConstruct::Create(
212     const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc,
213     SourceLocation LParenLoc, Expr *DevNumExpr, SourceLocation QueuesLoc,
214     ArrayRef<Expr *> QueueIdExprs, SourceLocation RParenLoc, SourceLocation End,
215     ArrayRef<const OpenACCClause *> Clauses) {
216 
217   assert(llvm::all_of(QueueIdExprs, [](Expr *E) { return E != nullptr; }));
218 
219   void *Mem = C.Allocate(
220       OpenACCWaitConstruct::totalSizeToAlloc<Expr *, OpenACCClause *>(
221           QueueIdExprs.size() + 1, Clauses.size()));
222 
223   auto *Inst = new (Mem)
224       OpenACCWaitConstruct(Start, DirectiveLoc, LParenLoc, DevNumExpr,
225                            QueuesLoc, QueueIdExprs, RParenLoc, End, Clauses);
226   return Inst;
227 }
228 OpenACCInitConstruct *OpenACCInitConstruct::CreateEmpty(const ASTContext &C,
229                                                         unsigned NumClauses) {
230   void *Mem =
231       C.Allocate(OpenACCInitConstruct::totalSizeToAlloc<const OpenACCClause *>(
232           NumClauses));
233   auto *Inst = new (Mem) OpenACCInitConstruct(NumClauses);
234   return Inst;
235 }
236 
237 OpenACCInitConstruct *
238 OpenACCInitConstruct::Create(const ASTContext &C, SourceLocation Start,
239                              SourceLocation DirectiveLoc, SourceLocation End,
240                              ArrayRef<const OpenACCClause *> Clauses) {
241   void *Mem =
242       C.Allocate(OpenACCInitConstruct::totalSizeToAlloc<const OpenACCClause *>(
243           Clauses.size()));
244   auto *Inst =
245       new (Mem) OpenACCInitConstruct(Start, DirectiveLoc, End, Clauses);
246   return Inst;
247 }
248 OpenACCShutdownConstruct *
249 OpenACCShutdownConstruct::CreateEmpty(const ASTContext &C,
250                                       unsigned NumClauses) {
251   void *Mem = C.Allocate(
252       OpenACCShutdownConstruct::totalSizeToAlloc<const OpenACCClause *>(
253           NumClauses));
254   auto *Inst = new (Mem) OpenACCShutdownConstruct(NumClauses);
255   return Inst;
256 }
257 
258 OpenACCShutdownConstruct *OpenACCShutdownConstruct::Create(
259     const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc,
260     SourceLocation End, ArrayRef<const OpenACCClause *> Clauses) {
261   void *Mem = C.Allocate(
262       OpenACCShutdownConstruct::totalSizeToAlloc<const OpenACCClause *>(
263           Clauses.size()));
264   auto *Inst =
265       new (Mem) OpenACCShutdownConstruct(Start, DirectiveLoc, End, Clauses);
266   return Inst;
267 }
268 
269 OpenACCSetConstruct *OpenACCSetConstruct::CreateEmpty(const ASTContext &C,
270                                                       unsigned NumClauses) {
271   void *Mem = C.Allocate(
272       OpenACCSetConstruct::totalSizeToAlloc<const OpenACCClause *>(NumClauses));
273   auto *Inst = new (Mem) OpenACCSetConstruct(NumClauses);
274   return Inst;
275 }
276 
277 OpenACCSetConstruct *
278 OpenACCSetConstruct::Create(const ASTContext &C, SourceLocation Start,
279                             SourceLocation DirectiveLoc, SourceLocation End,
280                             ArrayRef<const OpenACCClause *> Clauses) {
281   void *Mem =
282       C.Allocate(OpenACCSetConstruct::totalSizeToAlloc<const OpenACCClause *>(
283           Clauses.size()));
284   auto *Inst = new (Mem) OpenACCSetConstruct(Start, DirectiveLoc, End, Clauses);
285   return Inst;
286 }
287 
288 OpenACCUpdateConstruct *
289 OpenACCUpdateConstruct::CreateEmpty(const ASTContext &C, unsigned NumClauses) {
290   void *Mem = C.Allocate(
291       OpenACCUpdateConstruct::totalSizeToAlloc<const OpenACCClause *>(
292           NumClauses));
293   auto *Inst = new (Mem) OpenACCUpdateConstruct(NumClauses);
294   return Inst;
295 }
296 
297 OpenACCUpdateConstruct *
298 OpenACCUpdateConstruct::Create(const ASTContext &C, SourceLocation Start,
299                                SourceLocation DirectiveLoc, SourceLocation End,
300                                ArrayRef<const OpenACCClause *> Clauses) {
301   void *Mem = C.Allocate(
302       OpenACCUpdateConstruct::totalSizeToAlloc<const OpenACCClause *>(
303           Clauses.size()));
304   auto *Inst =
305       new (Mem) OpenACCUpdateConstruct(Start, DirectiveLoc, End, Clauses);
306   return Inst;
307 }
308