Skip to content

Commit 010d011

Browse files
erichkeaneerichkeane
committed
[OpenACC] Create AST nodes for 'data' constructs
These constructs are all very similar and closely related, so this patch creates the AST nodes for them, serialization, printing/etc. Additionally the restrictions are all added as tests/todos in the tests, as those will have to be implemented once we get those clauses implemented.
1 parent 6f8a363 commit 010d011

34 files changed

+1116
-59
lines changed

‎clang/include/clang-c/Index.h

Lines changed: 19 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -2166,9 +2166,27 @@ enum CXCursorKind {
21662166
*/
21672167
CXCursor_OpenACCLoopConstruct = 321,
21682168

2169+
/** OpenACC Combined Constructs.
2170+
*/
21692171
CXCursor_OpenACCCombinedConstruct = 322,
21702172

2171-
CXCursor_LastStmt = CXCursor_OpenACCCombinedConstruct,
2173+
/** OpenACC data Construct.
2174+
*/
2175+
CXCursor_OpenACCDataConstruct = 323,
2176+
2177+
/** OpenACC enter data Construct.
2178+
*/
2179+
CXCursor_OpenACCEnterDataConstruct = 324,
2180+
2181+
/** OpenACC exit data Construct.
2182+
*/
2183+
CXCursor_OpenACCExitDataConstruct = 325,
2184+
2185+
/** OpenACC host_data Construct.
2186+
*/
2187+
CXCursor_OpenACCHostDataConstruct = 326,
2188+
2189+
CXCursor_LastStmt = CXCursor_OpenACCHostDataConstruct,
21722190

21732191
/**
21742192
* Cursor that represents the translation unit itself.

‎clang/include/clang/AST/RecursiveASTVisitor.h

Lines changed: 6 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -4058,6 +4058,12 @@ DEF_TRAVERSE_STMT(OpenACCLoopConstruct,
40584058
{ TRY_TO(TraverseOpenACCAssociatedStmtConstruct(S)); })
40594059
DEF_TRAVERSE_STMT(OpenACCCombinedConstruct,
40604060
{ TRY_TO(TraverseOpenACCAssociatedStmtConstruct(S)); })
4061+
DEF_TRAVERSE_STMT(OpenACCDataConstruct,
4062+
{ TRY_TO(TraverseOpenACCAssociatedStmtConstruct(S)); })
4063+
DEF_TRAVERSE_STMT(OpenACCEnterDataConstruct, {})
4064+
DEF_TRAVERSE_STMT(OpenACCExitDataConstruct, {})
4065+
DEF_TRAVERSE_STMT(OpenACCHostDataConstruct,
4066+
{ TRY_TO(TraverseOpenACCAssociatedStmtConstruct(S)); })
40614067

40624068
// Traverse HLSL: Out argument expression
40634069
DEF_TRAVERSE_STMT(HLSLOutArgExpr, {})

‎clang/include/clang/AST/StmtOpenACC.h

Lines changed: 170 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -292,5 +292,175 @@ class OpenACCCombinedConstruct final
292292
return const_cast<OpenACCCombinedConstruct *>(this)->getLoop();
293293
}
294294
};
295+
296+
// This class represents a 'data' construct, which has an associated statement
297+
// and clauses, but is otherwise pretty simple.
298+
class OpenACCDataConstruct final
299+
: public OpenACCAssociatedStmtConstruct,
300+
public llvm::TrailingObjects<OpenACCCombinedConstruct,
301+
const OpenACCClause *> {
302+
OpenACCDataConstruct(unsigned NumClauses)
303+
: OpenACCAssociatedStmtConstruct(
304+
OpenACCDataConstructClass, OpenACCDirectiveKind::Data,
305+
SourceLocation{}, SourceLocation{}, SourceLocation{},
306+
/*AssociatedStmt=*/nullptr) {
307+
std::uninitialized_value_construct(
308+
getTrailingObjects<const OpenACCClause *>(),
309+
getTrailingObjects<const OpenACCClause *>() + NumClauses);
310+
setClauseList(MutableArrayRef(getTrailingObjects<const OpenACCClause *>(),
311+
NumClauses));
312+
}
313+
314+
OpenACCDataConstruct(SourceLocation Start, SourceLocation DirectiveLoc,
315+
SourceLocation End,
316+
ArrayRef<const OpenACCClause *> Clauses,
317+
Stmt *StructuredBlock)
318+
: OpenACCAssociatedStmtConstruct(OpenACCDataConstructClass,
319+
OpenACCDirectiveKind::Data, Start,
320+
DirectiveLoc, End, StructuredBlock) {
321+
std::uninitialized_copy(Clauses.begin(), Clauses.end(),
322+
getTrailingObjects<const OpenACCClause *>());
323+
setClauseList(MutableArrayRef(getTrailingObjects<const OpenACCClause *>(),
324+
Clauses.size()));
325+
}
326+
void setStructuredBlock(Stmt *S) { setAssociatedStmt(S); }
327+
328+
public:
329+
static bool classof(const Stmt *T) {
330+
return T->getStmtClass() == OpenACCDataConstructClass;
331+
}
332+
333+
static OpenACCDataConstruct *CreateEmpty(const ASTContext &C,
334+
unsigned NumClauses);
335+
static OpenACCDataConstruct *Create(const ASTContext &C, SourceLocation Start,
336+
SourceLocation DirectiveLoc,
337+
SourceLocation End,
338+
ArrayRef<const OpenACCClause *> Clauses,
339+
Stmt *StructuredBlock);
340+
Stmt *getStructuredBlock() { return getAssociatedStmt(); }
341+
const Stmt *getStructuredBlock() const {
342+
return const_cast<OpenACCDataConstruct *>(this)->getStructuredBlock();
343+
}
344+
};
345+
// This class represents a 'enter data' construct, which JUST has clauses.
346+
class OpenACCEnterDataConstruct final
347+
: public OpenACCConstructStmt,
348+
public llvm::TrailingObjects<OpenACCCombinedConstruct,
349+
const OpenACCClause *> {
350+
OpenACCEnterDataConstruct(unsigned NumClauses)
351+
: OpenACCConstructStmt(OpenACCEnterDataConstructClass,
352+
OpenACCDirectiveKind::EnterData, SourceLocation{},
353+
SourceLocation{}, SourceLocation{}) {
354+
std::uninitialized_value_construct(
355+
getTrailingObjects<const OpenACCClause *>(),
356+
getTrailingObjects<const OpenACCClause *>() + NumClauses);
357+
setClauseList(MutableArrayRef(getTrailingObjects<const OpenACCClause *>(),
358+
NumClauses));
359+
}
360+
OpenACCEnterDataConstruct(SourceLocation Start, SourceLocation DirectiveLoc,
361+
SourceLocation End,
362+
ArrayRef<const OpenACCClause *> Clauses)
363+
: OpenACCConstructStmt(OpenACCEnterDataConstructClass,
364+
OpenACCDirectiveKind::EnterData, Start,
365+
DirectiveLoc, End) {
366+
std::uninitialized_copy(Clauses.begin(), Clauses.end(),
367+
getTrailingObjects<const OpenACCClause *>());
368+
setClauseList(MutableArrayRef(getTrailingObjects<const OpenACCClause *>(),
369+
Clauses.size()));
370+
}
371+
372+
public:
373+
static bool classof(const Stmt *T) {
374+
return T->getStmtClass() == OpenACCEnterDataConstructClass;
375+
}
376+
static OpenACCEnterDataConstruct *CreateEmpty(const ASTContext &C,
377+
unsigned NumClauses);
378+
static OpenACCEnterDataConstruct *
379+
Create(const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc,
380+
SourceLocation End, ArrayRef<const OpenACCClause *> Clauses);
381+
};
382+
// This class represents a 'exit data' construct, which JUST has clauses.
383+
class OpenACCExitDataConstruct final
384+
: public OpenACCConstructStmt,
385+
public llvm::TrailingObjects<OpenACCCombinedConstruct,
386+
const OpenACCClause *> {
387+
OpenACCExitDataConstruct(unsigned NumClauses)
388+
: OpenACCConstructStmt(OpenACCExitDataConstructClass,
389+
OpenACCDirectiveKind::ExitData, SourceLocation{},
390+
SourceLocation{}, SourceLocation{}) {
391+
std::uninitialized_value_construct(
392+
getTrailingObjects<const OpenACCClause *>(),
393+
getTrailingObjects<const OpenACCClause *>() + NumClauses);
394+
setClauseList(MutableArrayRef(getTrailingObjects<const OpenACCClause *>(),
395+
NumClauses));
396+
}
397+
OpenACCExitDataConstruct(SourceLocation Start, SourceLocation DirectiveLoc,
398+
SourceLocation End,
399+
ArrayRef<const OpenACCClause *> Clauses)
400+
: OpenACCConstructStmt(OpenACCExitDataConstructClass,
401+
OpenACCDirectiveKind::ExitData, Start,
402+
DirectiveLoc, End) {
403+
std::uninitialized_copy(Clauses.begin(), Clauses.end(),
404+
getTrailingObjects<const OpenACCClause *>());
405+
setClauseList(MutableArrayRef(getTrailingObjects<const OpenACCClause *>(),
406+
Clauses.size()));
407+
}
408+
409+
public:
410+
static bool classof(const Stmt *T) {
411+
return T->getStmtClass() == OpenACCExitDataConstructClass;
412+
}
413+
static OpenACCExitDataConstruct *CreateEmpty(const ASTContext &C,
414+
unsigned NumClauses);
415+
static OpenACCExitDataConstruct *
416+
Create(const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc,
417+
SourceLocation End, ArrayRef<const OpenACCClause *> Clauses);
418+
};
419+
// This class represents a 'host_data' construct, which has an associated
420+
// statement and clauses, but is otherwise pretty simple.
421+
class OpenACCHostDataConstruct final
422+
: public OpenACCAssociatedStmtConstruct,
423+
public llvm::TrailingObjects<OpenACCCombinedConstruct,
424+
const OpenACCClause *> {
425+
OpenACCHostDataConstruct(unsigned NumClauses)
426+
: OpenACCAssociatedStmtConstruct(
427+
OpenACCHostDataConstructClass, OpenACCDirectiveKind::HostData,
428+
SourceLocation{}, SourceLocation{}, SourceLocation{},
429+
/*AssociatedStmt=*/nullptr) {
430+
std::uninitialized_value_construct(
431+
getTrailingObjects<const OpenACCClause *>(),
432+
getTrailingObjects<const OpenACCClause *>() + NumClauses);
433+
setClauseList(MutableArrayRef(getTrailingObjects<const OpenACCClause *>(),
434+
NumClauses));
435+
}
436+
OpenACCHostDataConstruct(SourceLocation Start, SourceLocation DirectiveLoc,
437+
SourceLocation End,
438+
ArrayRef<const OpenACCClause *> Clauses,
439+
Stmt *StructuredBlock)
440+
: OpenACCAssociatedStmtConstruct(OpenACCHostDataConstructClass,
441+
OpenACCDirectiveKind::HostData, Start,
442+
DirectiveLoc, End, StructuredBlock) {
443+
std::uninitialized_copy(Clauses.begin(), Clauses.end(),
444+
getTrailingObjects<const OpenACCClause *>());
445+
setClauseList(MutableArrayRef(getTrailingObjects<const OpenACCClause *>(),
446+
Clauses.size()));
447+
}
448+
void setStructuredBlock(Stmt *S) { setAssociatedStmt(S); }
449+
450+
public:
451+
static bool classof(const Stmt *T) {
452+
return T->getStmtClass() == OpenACCHostDataConstructClass;
453+
}
454+
static OpenACCHostDataConstruct *CreateEmpty(const ASTContext &C,
455+
unsigned NumClauses);
456+
static OpenACCHostDataConstruct *
457+
Create(const ASTContext &C, SourceLocation Start, SourceLocation DirectiveLoc,
458+
SourceLocation End, ArrayRef<const OpenACCClause *> Clauses,
459+
Stmt *StructuredBlock);
460+
Stmt *getStructuredBlock() { return getAssociatedStmt(); }
461+
const Stmt *getStructuredBlock() const {
462+
return const_cast<OpenACCHostDataConstruct *>(this)->getStructuredBlock();
463+
}
464+
};
295465
} // namespace clang
296466
#endif // LLVM_CLANG_AST_STMTOPENACC_H

‎clang/include/clang/AST/TextNodeDumper.h

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -411,6 +411,10 @@ class TextNodeDumper
411411
void VisitOpenACCConstructStmt(const OpenACCConstructStmt *S);
412412
void VisitOpenACCLoopConstruct(const OpenACCLoopConstruct *S);
413413
void VisitOpenACCCombinedConstruct(const OpenACCCombinedConstruct *S);
414+
void VisitOpenACCDataConstruct(const OpenACCDataConstruct *S);
415+
void VisitOpenACCEnterDataConstruct(const OpenACCEnterDataConstruct *S);
416+
void VisitOpenACCExitDataConstruct(const OpenACCExitDataConstruct *S);
417+
void VisitOpenACCHostDataConstruct(const OpenACCHostDataConstruct *S);
414418
void VisitOpenACCAsteriskSizeExpr(const OpenACCAsteriskSizeExpr *S);
415419
void VisitEmbedExpr(const EmbedExpr *S);
416420
void VisitAtomicExpr(const AtomicExpr *AE);

‎clang/include/clang/Basic/StmtNodes.td

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -308,6 +308,10 @@ def OpenACCAssociatedStmtConstruct
308308
def OpenACCComputeConstruct : StmtNode<OpenACCAssociatedStmtConstruct>;
309309
def OpenACCLoopConstruct : StmtNode<OpenACCAssociatedStmtConstruct>;
310310
def OpenACCCombinedConstruct : StmtNode<OpenACCAssociatedStmtConstruct>;
311+
def OpenACCDataConstruct : StmtNode<OpenACCAssociatedStmtConstruct>;
312+
def OpenACCEnterDataConstruct : StmtNode<OpenACCConstructStmt>;
313+
def OpenACCExitDataConstruct : StmtNode<OpenACCConstructStmt>;
314+
def OpenACCHostDataConstruct : StmtNode<OpenACCAssociatedStmtConstruct>;
311315

312316
// OpenACC Additional Expressions.
313317
def OpenACCAsteriskSizeExpr : StmtNode<Expr>;

‎clang/include/clang/Serialization/ASTBitCodes.h

Lines changed: 4 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -2019,6 +2019,10 @@ enum StmtCode {
20192019
STMT_OPENACC_LOOP_CONSTRUCT,
20202020
STMT_OPENACC_COMBINED_CONSTRUCT,
20212021
EXPR_OPENACC_ASTERISK_SIZE,
2022+
STMT_OPENACC_DATA_CONSTRUCT,
2023+
STMT_OPENACC_ENTER_DATA_CONSTRUCT,
2024+
STMT_OPENACC_EXIT_DATA_CONSTRUCT,
2025+
STMT_OPENACC_HOST_DATA_CONSTRUCT,
20222026

20232027
// HLSL Constructs
20242028
EXPR_HLSL_OUT_ARG,

‎clang/lib/AST/StmtOpenACC.cpp

Lines changed: 86 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -110,3 +110,89 @@ OpenACCCombinedConstruct *OpenACCCombinedConstruct::Create(
110110
OpenACCCombinedConstruct(DK, BeginLoc, DirLoc, EndLoc, Clauses, Loop);
111111
return Inst;
112112
}
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+
}

‎clang/lib/AST/StmtPrinter.cpp

Lines changed: 45 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1193,6 +1193,51 @@ void StmtPrinter::VisitOpenACCCombinedConstruct(OpenACCCombinedConstruct *S) {
11931193
PrintStmt(S->getLoop());
11941194
}
11951195

1196+
void StmtPrinter::VisitOpenACCDataConstruct(OpenACCDataConstruct *S) {
1197+
Indent() << "#pragma acc data";
1198+
1199+
if (!S->clauses().empty()) {
1200+
OS << ' ';
1201+
OpenACCClausePrinter Printer(OS, Policy);
1202+
Printer.VisitClauseList(S->clauses());
1203+
}
1204+
OS << '\n';
1205+
1206+
PrintStmt(S->getStructuredBlock());
1207+
}
1208+
void StmtPrinter::VisitOpenACCEnterDataConstruct(OpenACCEnterDataConstruct *S) {
1209+
Indent() << "#pragma acc enter data";
1210+
1211+
if (!S->clauses().empty()) {
1212+
OS << ' ';
1213+
OpenACCClausePrinter Printer(OS, Policy);
1214+
Printer.VisitClauseList(S->clauses());
1215+
}
1216+
OS << '\n';
1217+
}
1218+
void StmtPrinter::VisitOpenACCExitDataConstruct(OpenACCExitDataConstruct *S) {
1219+
Indent() << "#pragma acc exit data";
1220+
1221+
if (!S->clauses().empty()) {
1222+
OS << ' ';
1223+
OpenACCClausePrinter Printer(OS, Policy);
1224+
Printer.VisitClauseList(S->clauses());
1225+
}
1226+
OS << '\n';
1227+
}
1228+
void StmtPrinter::VisitOpenACCHostDataConstruct(OpenACCHostDataConstruct *S) {
1229+
Indent() << "#pragma acc host_data";
1230+
1231+
if (!S->clauses().empty()) {
1232+
OS << ' ';
1233+
OpenACCClausePrinter Printer(OS, Policy);
1234+
Printer.VisitClauseList(S->clauses());
1235+
}
1236+
OS << '\n';
1237+
1238+
PrintStmt(S->getStructuredBlock());
1239+
}
1240+
11961241
//===----------------------------------------------------------------------===//
11971242
// Expr printing methods.
11981243
//===----------------------------------------------------------------------===//

0 commit comments

Comments
 (0)