[clang] 01e91a2 - [OpenACC] Implement copyin, copyout, create clauses for compute construct
via cfe-commits
cfe-commits at lists.llvm.org
Fri May 3 07:51:31 PDT 2024
Author: erichkeane
Date: 2024-05-03T07:51:25-07:00
New Revision: 01e91a2dde497b71b0b85d5ec0f101a21e9c892c
URL: https://github.com/llvm/llvm-project/commit/01e91a2dde497b71b0b85d5ec0f101a21e9c892c
DIFF: https://github.com/llvm/llvm-project/commit/01e91a2dde497b71b0b85d5ec0f101a21e9c892c.diff
LOG: [OpenACC] Implement copyin, copyout, create clauses for compute construct
Like 'copy', these also have alternate names, so this implements that as
well. Additionally, these have an optional tag of either 'readonly' or
'zero' depending on the clause.
Otherwise, this is a pretty rote implementation of the clause, as there
aren't any special rules for it.
Added:
clang/test/SemaOpenACC/compute-construct-copyin-clause.c
clang/test/SemaOpenACC/compute-construct-copyin-clause.cpp
clang/test/SemaOpenACC/compute-construct-copyout-clause.c
clang/test/SemaOpenACC/compute-construct-copyout-clause.cpp
clang/test/SemaOpenACC/compute-construct-create-clause.c
clang/test/SemaOpenACC/compute-construct-create-clause.cpp
Modified:
clang/include/clang/AST/OpenACCClause.h
clang/include/clang/Basic/OpenACCClauses.def
clang/include/clang/Basic/OpenACCKinds.h
clang/include/clang/Sema/SemaOpenACC.h
clang/lib/AST/OpenACCClause.cpp
clang/lib/AST/StmtProfile.cpp
clang/lib/AST/TextNodeDumper.cpp
clang/lib/Parse/ParseOpenACC.cpp
clang/lib/Sema/SemaOpenACC.cpp
clang/lib/Sema/TreeTransform.h
clang/lib/Serialization/ASTReader.cpp
clang/lib/Serialization/ASTWriter.cpp
clang/test/AST/ast-print-openacc-compute-construct.cpp
clang/test/ParserOpenACC/parse-clauses.c
clang/test/SemaOpenACC/compute-construct-varlist-ast.cpp
clang/tools/libclang/CIndex.cpp
Removed:
################################################################################
diff --git a/clang/include/clang/AST/OpenACCClause.h b/clang/include/clang/AST/OpenACCClause.h
index ba20b2c811a8d8..abbd7c3989bcca 100644
--- a/clang/include/clang/AST/OpenACCClause.h
+++ b/clang/include/clang/AST/OpenACCClause.h
@@ -375,6 +375,87 @@ class OpenACCCopyClause final
ArrayRef<Expr *> VarList, SourceLocation EndLoc);
};
+class OpenACCCopyInClause final
+ : public OpenACCClauseWithVarList,
+ public llvm::TrailingObjects<OpenACCCopyInClause, Expr *> {
+ bool IsReadOnly;
+
+ OpenACCCopyInClause(OpenACCClauseKind Spelling, SourceLocation BeginLoc,
+ SourceLocation LParenLoc, bool IsReadOnly,
+ ArrayRef<Expr *> VarList, SourceLocation EndLoc)
+ : OpenACCClauseWithVarList(Spelling, BeginLoc, LParenLoc, EndLoc),
+ IsReadOnly(IsReadOnly) {
+ assert((Spelling == OpenACCClauseKind::CopyIn ||
+ Spelling == OpenACCClauseKind::PCopyIn ||
+ Spelling == OpenACCClauseKind::PresentOrCopyIn) &&
+ "Invalid clause kind for copyin-clause");
+ std::uninitialized_copy(VarList.begin(), VarList.end(),
+ getTrailingObjects<Expr *>());
+ setExprs(MutableArrayRef(getTrailingObjects<Expr *>(), VarList.size()));
+ }
+
+public:
+ bool isReadOnly() const { return IsReadOnly; }
+ static OpenACCCopyInClause *
+ Create(const ASTContext &C, OpenACCClauseKind Spelling,
+ SourceLocation BeginLoc, SourceLocation LParenLoc, bool IsReadOnly,
+ ArrayRef<Expr *> VarList, SourceLocation EndLoc);
+};
+
+class OpenACCCopyOutClause final
+ : public OpenACCClauseWithVarList,
+ public llvm::TrailingObjects<OpenACCCopyOutClause, Expr *> {
+ bool IsZero;
+
+ OpenACCCopyOutClause(OpenACCClauseKind Spelling, SourceLocation BeginLoc,
+ SourceLocation LParenLoc, bool IsZero,
+ ArrayRef<Expr *> VarList, SourceLocation EndLoc)
+ : OpenACCClauseWithVarList(Spelling, BeginLoc, LParenLoc, EndLoc),
+ IsZero(IsZero) {
+ assert((Spelling == OpenACCClauseKind::CopyOut ||
+ Spelling == OpenACCClauseKind::PCopyOut ||
+ Spelling == OpenACCClauseKind::PresentOrCopyOut) &&
+ "Invalid clause kind for copyout-clause");
+ std::uninitialized_copy(VarList.begin(), VarList.end(),
+ getTrailingObjects<Expr *>());
+ setExprs(MutableArrayRef(getTrailingObjects<Expr *>(), VarList.size()));
+ }
+
+public:
+ bool isZero() const { return IsZero; }
+ static OpenACCCopyOutClause *
+ Create(const ASTContext &C, OpenACCClauseKind Spelling,
+ SourceLocation BeginLoc, SourceLocation LParenLoc, bool IsZero,
+ ArrayRef<Expr *> VarList, SourceLocation EndLoc);
+};
+
+class OpenACCCreateClause final
+ : public OpenACCClauseWithVarList,
+ public llvm::TrailingObjects<OpenACCCreateClause, Expr *> {
+ bool IsZero;
+
+ OpenACCCreateClause(OpenACCClauseKind Spelling, SourceLocation BeginLoc,
+ SourceLocation LParenLoc, bool IsZero,
+ ArrayRef<Expr *> VarList, SourceLocation EndLoc)
+ : OpenACCClauseWithVarList(Spelling, BeginLoc, LParenLoc, EndLoc),
+ IsZero(IsZero) {
+ assert((Spelling == OpenACCClauseKind::Create ||
+ Spelling == OpenACCClauseKind::PCreate ||
+ Spelling == OpenACCClauseKind::PresentOrCreate) &&
+ "Invalid clause kind for create-clause");
+ std::uninitialized_copy(VarList.begin(), VarList.end(),
+ getTrailingObjects<Expr *>());
+ setExprs(MutableArrayRef(getTrailingObjects<Expr *>(), VarList.size()));
+ }
+
+public:
+ bool isZero() const { return IsZero; }
+ static OpenACCCreateClause *
+ Create(const ASTContext &C, OpenACCClauseKind Spelling,
+ SourceLocation BeginLoc, SourceLocation LParenLoc, bool IsZero,
+ ArrayRef<Expr *> VarList, SourceLocation EndLoc);
+};
+
template <class Impl> class OpenACCClauseVisitor {
Impl &getDerived() { return static_cast<Impl &>(*this); }
diff --git a/clang/include/clang/Basic/OpenACCClauses.def b/clang/include/clang/Basic/OpenACCClauses.def
index 5cb421975c95a5..06c7a379b22261 100644
--- a/clang/include/clang/Basic/OpenACCClauses.def
+++ b/clang/include/clang/Basic/OpenACCClauses.def
@@ -24,6 +24,15 @@
VISIT_CLAUSE(Copy)
CLAUSE_ALIAS(PCopy, Copy)
CLAUSE_ALIAS(PresentOrCopy, Copy)
+VISIT_CLAUSE(CopyIn)
+CLAUSE_ALIAS(PCopyIn, CopyIn)
+CLAUSE_ALIAS(PresentOrCopyIn, CopyIn)
+VISIT_CLAUSE(CopyOut)
+CLAUSE_ALIAS(PCopyOut, CopyOut)
+CLAUSE_ALIAS(PresentOrCopyOut, CopyOut)
+VISIT_CLAUSE(Create)
+CLAUSE_ALIAS(PCreate, Create)
+CLAUSE_ALIAS(PresentOrCreate, Create)
VISIT_CLAUSE(Default)
VISIT_CLAUSE(FirstPrivate)
VISIT_CLAUSE(If)
diff --git a/clang/include/clang/Basic/OpenACCKinds.h b/clang/include/clang/Basic/OpenACCKinds.h
index e39f9e876d549c..0e38a04e7164bb 100644
--- a/clang/include/clang/Basic/OpenACCKinds.h
+++ b/clang/include/clang/Basic/OpenACCKinds.h
@@ -228,12 +228,27 @@ enum class OpenACCClauseKind {
/// 'copyout' clause, allowed on Compute and Combined constructs, plus 'data',
/// 'exit data', and 'declare'.
CopyOut,
+ /// 'copyout' clause alias 'pcopyout'. Preserved for diagnostic purposes.
+ PCopyOut,
+ /// 'copyout' clause alias 'present_or_copyout'. Preserved for diagnostic
+ /// purposes.
+ PresentOrCopyOut,
/// 'copyin' clause, allowed on Compute and Combined constructs, plus 'data',
/// 'enter data', and 'declare'.
CopyIn,
- /// 'copyin' clause, allowed on Compute and Combined constructs, plus 'data',
+ /// 'copyin' clause alias 'pcopyin'. Preserved for diagnostic purposes.
+ PCopyIn,
+ /// 'copyin' clause alias 'present_or_copyin'. Preserved for diagnostic
+ /// purposes.
+ PresentOrCopyIn,
+ /// 'create' clause, allowed on Compute and Combined constructs, plus 'data',
/// 'enter data', and 'declare'.
Create,
+ /// 'create' clause alias 'pcreate'. Preserved for diagnostic purposes.
+ PCreate,
+ /// 'create' clause alias 'present_or_create'. Preserved for diagnostic
+ /// purposes.
+ PresentOrCreate,
/// 'reduction' clause, allowed on Parallel, Serial, Loop, and the combined
/// constructs.
Reduction,
@@ -362,12 +377,30 @@ inline StreamTy &printOpenACCClauseKind(StreamTy &Out, OpenACCClauseKind K) {
case OpenACCClauseKind::CopyOut:
return Out << "copyout";
+ case OpenACCClauseKind::PCopyOut:
+ return Out << "pcopyout";
+
+ case OpenACCClauseKind::PresentOrCopyOut:
+ return Out << "present_or_copyout";
+
case OpenACCClauseKind::CopyIn:
return Out << "copyin";
+ case OpenACCClauseKind::PCopyIn:
+ return Out << "pcopyin";
+
+ case OpenACCClauseKind::PresentOrCopyIn:
+ return Out << "present_or_copyin";
+
case OpenACCClauseKind::Create:
return Out << "create";
+ case OpenACCClauseKind::PCreate:
+ return Out << "pcreate";
+
+ case OpenACCClauseKind::PresentOrCreate:
+ return Out << "present_or_create";
+
case OpenACCClauseKind::Reduction:
return Out << "reduction";
diff --git a/clang/include/clang/Sema/SemaOpenACC.h b/clang/include/clang/Sema/SemaOpenACC.h
index 1c5127e79a6699..5f77ec90d0b650 100644
--- a/clang/include/clang/Sema/SemaOpenACC.h
+++ b/clang/include/clang/Sema/SemaOpenACC.h
@@ -50,6 +50,8 @@ class SemaOpenACC : public SemaBase {
struct VarListDetails {
SmallVector<Expr *> VarList;
+ bool IsReadOnly;
+ bool IsZero;
};
std::variant<std::monostate, DefaultDetails, ConditionDetails,
@@ -123,6 +125,15 @@ class SemaOpenACC : public SemaBase {
ClauseKind == OpenACCClauseKind::Copy ||
ClauseKind == OpenACCClauseKind::PCopy ||
ClauseKind == OpenACCClauseKind::PresentOrCopy ||
+ ClauseKind == OpenACCClauseKind::CopyIn ||
+ ClauseKind == OpenACCClauseKind::PCopyIn ||
+ ClauseKind == OpenACCClauseKind::PresentOrCopyIn ||
+ ClauseKind == OpenACCClauseKind::CopyOut ||
+ ClauseKind == OpenACCClauseKind::PCopyOut ||
+ ClauseKind == OpenACCClauseKind::PresentOrCopyOut ||
+ ClauseKind == OpenACCClauseKind::Create ||
+ ClauseKind == OpenACCClauseKind::PCreate ||
+ ClauseKind == OpenACCClauseKind::PresentOrCreate ||
ClauseKind == OpenACCClauseKind::FirstPrivate) &&
"Parsed clause kind does not have a var-list");
return std::get<VarListDetails>(Details).VarList;
@@ -132,6 +143,25 @@ class SemaOpenACC : public SemaBase {
return const_cast<OpenACCParsedClause *>(this)->getVarList();
}
+ bool isReadOnly() const {
+ assert((ClauseKind == OpenACCClauseKind::CopyIn ||
+ ClauseKind == OpenACCClauseKind::PCopyIn ||
+ ClauseKind == OpenACCClauseKind::PresentOrCopyIn) &&
+ "Only copyin accepts 'readonly:' tag");
+ return std::get<VarListDetails>(Details).IsReadOnly;
+ }
+
+ bool isZero() const {
+ assert((ClauseKind == OpenACCClauseKind::CopyOut ||
+ ClauseKind == OpenACCClauseKind::PCopyOut ||
+ ClauseKind == OpenACCClauseKind::PresentOrCopyOut ||
+ ClauseKind == OpenACCClauseKind::Create ||
+ ClauseKind == OpenACCClauseKind::PCreate ||
+ ClauseKind == OpenACCClauseKind::PresentOrCreate) &&
+ "Only copyout/create accepts 'zero' tag");
+ return std::get<VarListDetails>(Details).IsZero;
+ }
+
void setLParenLoc(SourceLocation EndLoc) { LParenLoc = EndLoc; }
void setEndLoc(SourceLocation EndLoc) { ClauseRange.setEnd(EndLoc); }
@@ -170,28 +200,71 @@ class SemaOpenACC : public SemaBase {
Details = IntExprDetails{std::move(IntExprs)};
}
- void setVarListDetails(ArrayRef<Expr *> VarList) {
+ void setVarListDetails(ArrayRef<Expr *> VarList, bool IsReadOnly,
+ bool IsZero) {
assert((ClauseKind == OpenACCClauseKind::Private ||
ClauseKind == OpenACCClauseKind::NoCreate ||
ClauseKind == OpenACCClauseKind::Present ||
ClauseKind == OpenACCClauseKind::Copy ||
ClauseKind == OpenACCClauseKind::PCopy ||
ClauseKind == OpenACCClauseKind::PresentOrCopy ||
+ ClauseKind == OpenACCClauseKind::CopyIn ||
+ ClauseKind == OpenACCClauseKind::PCopyIn ||
+ ClauseKind == OpenACCClauseKind::PresentOrCopyIn ||
+ ClauseKind == OpenACCClauseKind::CopyOut ||
+ ClauseKind == OpenACCClauseKind::PCopyOut ||
+ ClauseKind == OpenACCClauseKind::PresentOrCopyOut ||
+ ClauseKind == OpenACCClauseKind::Create ||
+ ClauseKind == OpenACCClauseKind::PCreate ||
+ ClauseKind == OpenACCClauseKind::PresentOrCreate ||
ClauseKind == OpenACCClauseKind::FirstPrivate) &&
"Parsed clause kind does not have a var-list");
- Details = VarListDetails{{VarList.begin(), VarList.end()}};
+ assert((!IsReadOnly || ClauseKind == OpenACCClauseKind::CopyIn ||
+ ClauseKind == OpenACCClauseKind::PCopyIn ||
+ ClauseKind == OpenACCClauseKind::PresentOrCopyIn) &&
+ "readonly: tag only valid on copyin");
+ assert((!IsZero || ClauseKind == OpenACCClauseKind::CopyOut ||
+ ClauseKind == OpenACCClauseKind::PCopyOut ||
+ ClauseKind == OpenACCClauseKind::PresentOrCopyOut ||
+ ClauseKind == OpenACCClauseKind::Create ||
+ ClauseKind == OpenACCClauseKind::PCreate ||
+ ClauseKind == OpenACCClauseKind::PresentOrCreate) &&
+ "zero: tag only valid on copyout/create");
+ Details =
+ VarListDetails{{VarList.begin(), VarList.end()}, IsReadOnly, IsZero};
}
- void setVarListDetails(llvm::SmallVector<Expr *> &&VarList) {
+ void setVarListDetails(llvm::SmallVector<Expr *> &&VarList, bool IsReadOnly,
+ bool IsZero) {
assert((ClauseKind == OpenACCClauseKind::Private ||
ClauseKind == OpenACCClauseKind::NoCreate ||
ClauseKind == OpenACCClauseKind::Present ||
ClauseKind == OpenACCClauseKind::Copy ||
ClauseKind == OpenACCClauseKind::PCopy ||
ClauseKind == OpenACCClauseKind::PresentOrCopy ||
+ ClauseKind == OpenACCClauseKind::CopyIn ||
+ ClauseKind == OpenACCClauseKind::PCopyIn ||
+ ClauseKind == OpenACCClauseKind::PresentOrCopyIn ||
+ ClauseKind == OpenACCClauseKind::CopyOut ||
+ ClauseKind == OpenACCClauseKind::PCopyOut ||
+ ClauseKind == OpenACCClauseKind::PresentOrCopyOut ||
+ ClauseKind == OpenACCClauseKind::Create ||
+ ClauseKind == OpenACCClauseKind::PCreate ||
+ ClauseKind == OpenACCClauseKind::PresentOrCreate ||
ClauseKind == OpenACCClauseKind::FirstPrivate) &&
"Parsed clause kind does not have a var-list");
- Details = VarListDetails{std::move(VarList)};
+ assert((!IsReadOnly || ClauseKind == OpenACCClauseKind::CopyIn ||
+ ClauseKind == OpenACCClauseKind::PCopyIn ||
+ ClauseKind == OpenACCClauseKind::PresentOrCopyIn) &&
+ "readonly: tag only valid on copyin");
+ assert((!IsZero || ClauseKind == OpenACCClauseKind::CopyOut ||
+ ClauseKind == OpenACCClauseKind::PCopyOut ||
+ ClauseKind == OpenACCClauseKind::PresentOrCopyOut ||
+ ClauseKind == OpenACCClauseKind::Create ||
+ ClauseKind == OpenACCClauseKind::PCreate ||
+ ClauseKind == OpenACCClauseKind::PresentOrCreate) &&
+ "zero: tag only valid on copyout/create");
+ Details = VarListDetails{std::move(VarList), IsReadOnly, IsZero};
}
};
diff --git a/clang/lib/AST/OpenACCClause.cpp b/clang/lib/AST/OpenACCClause.cpp
index 2a12a74899cdd5..f682100e35d37b 100644
--- a/clang/lib/AST/OpenACCClause.cpp
+++ b/clang/lib/AST/OpenACCClause.cpp
@@ -186,6 +186,39 @@ OpenACCCopyClause::Create(const ASTContext &C, OpenACCClauseKind Spelling,
OpenACCCopyClause(Spelling, BeginLoc, LParenLoc, VarList, EndLoc);
}
+OpenACCCopyInClause *
+OpenACCCopyInClause::Create(const ASTContext &C, OpenACCClauseKind Spelling,
+ SourceLocation BeginLoc, SourceLocation LParenLoc,
+ bool IsReadOnly, ArrayRef<Expr *> VarList,
+ SourceLocation EndLoc) {
+ void *Mem =
+ C.Allocate(OpenACCCopyInClause::totalSizeToAlloc<Expr *>(VarList.size()));
+ return new (Mem) OpenACCCopyInClause(Spelling, BeginLoc, LParenLoc,
+ IsReadOnly, VarList, EndLoc);
+}
+
+OpenACCCopyOutClause *
+OpenACCCopyOutClause::Create(const ASTContext &C, OpenACCClauseKind Spelling,
+ SourceLocation BeginLoc, SourceLocation LParenLoc,
+ bool IsZero, ArrayRef<Expr *> VarList,
+ SourceLocation EndLoc) {
+ void *Mem = C.Allocate(
+ OpenACCCopyOutClause::totalSizeToAlloc<Expr *>(VarList.size()));
+ return new (Mem) OpenACCCopyOutClause(Spelling, BeginLoc, LParenLoc, IsZero,
+ VarList, EndLoc);
+}
+
+OpenACCCreateClause *
+OpenACCCreateClause::Create(const ASTContext &C, OpenACCClauseKind Spelling,
+ SourceLocation BeginLoc, SourceLocation LParenLoc,
+ bool IsZero, ArrayRef<Expr *> VarList,
+ SourceLocation EndLoc) {
+ void *Mem =
+ C.Allocate(OpenACCCreateClause::totalSizeToAlloc<Expr *>(VarList.size()));
+ return new (Mem) OpenACCCreateClause(Spelling, BeginLoc, LParenLoc, IsZero,
+ VarList, EndLoc);
+}
+
//===----------------------------------------------------------------------===//
// OpenACC clauses printing methods
//===----------------------------------------------------------------------===//
@@ -269,3 +302,30 @@ void OpenACCClausePrinter::VisitCopyClause(const OpenACCCopyClause &C) {
[&](const Expr *E) { printExpr(E); });
OS << ")";
}
+
+void OpenACCClausePrinter::VisitCopyInClause(const OpenACCCopyInClause &C) {
+ OS << C.getClauseKind() << '(';
+ if (C.isReadOnly())
+ OS << "readonly: ";
+ llvm::interleaveComma(C.getVarList(), OS,
+ [&](const Expr *E) { printExpr(E); });
+ OS << ")";
+}
+
+void OpenACCClausePrinter::VisitCopyOutClause(const OpenACCCopyOutClause &C) {
+ OS << C.getClauseKind() << '(';
+ if (C.isZero())
+ OS << "zero: ";
+ llvm::interleaveComma(C.getVarList(), OS,
+ [&](const Expr *E) { printExpr(E); });
+ OS << ")";
+}
+
+void OpenACCClausePrinter::VisitCreateClause(const OpenACCCreateClause &C) {
+ OS << C.getClauseKind() << '(';
+ if (C.isZero())
+ OS << "zero: ";
+ llvm::interleaveComma(C.getVarList(), OS,
+ [&](const Expr *E) { printExpr(E); });
+ OS << ")";
+}
diff --git a/clang/lib/AST/StmtProfile.cpp b/clang/lib/AST/StmtProfile.cpp
index 6fe4f673a59d11..b97c351f83dbf4 100644
--- a/clang/lib/AST/StmtProfile.cpp
+++ b/clang/lib/AST/StmtProfile.cpp
@@ -2496,6 +2496,23 @@ void OpenACCClauseProfiler::VisitCopyClause(const OpenACCCopyClause &Clause) {
for (auto *E : Clause.getVarList())
Profiler.VisitStmt(E);
}
+void OpenACCClauseProfiler::VisitCopyInClause(
+ const OpenACCCopyInClause &Clause) {
+ for (auto *E : Clause.getVarList())
+ Profiler.VisitStmt(E);
+}
+
+void OpenACCClauseProfiler::VisitCopyOutClause(
+ const OpenACCCopyOutClause &Clause) {
+ for (auto *E : Clause.getVarList())
+ Profiler.VisitStmt(E);
+}
+
+void OpenACCClauseProfiler::VisitCreateClause(
+ const OpenACCCreateClause &Clause) {
+ for (auto *E : Clause.getVarList())
+ Profiler.VisitStmt(E);
+}
void OpenACCClauseProfiler::VisitSelfClause(const OpenACCSelfClause &Clause) {
if (Clause.hasConditionExpr())
diff --git a/clang/lib/AST/TextNodeDumper.cpp b/clang/lib/AST/TextNodeDumper.cpp
index d383d9fe170423..5aeeb80e8fe710 100644
--- a/clang/lib/AST/TextNodeDumper.cpp
+++ b/clang/lib/AST/TextNodeDumper.cpp
@@ -413,6 +413,27 @@ void TextNodeDumper::Visit(const OpenACCClause *C) {
// but print 'clause' here so it is clear what is happening from the dump.
OS << " clause";
break;
+ case OpenACCClauseKind::CopyIn:
+ case OpenACCClauseKind::PCopyIn:
+ case OpenACCClauseKind::PresentOrCopyIn:
+ OS << " clause";
+ if (cast<OpenACCCopyInClause>(C)->isReadOnly())
+ OS << " : readonly";
+ break;
+ case OpenACCClauseKind::CopyOut:
+ case OpenACCClauseKind::PCopyOut:
+ case OpenACCClauseKind::PresentOrCopyOut:
+ OS << " clause";
+ if (cast<OpenACCCopyOutClause>(C)->isZero())
+ OS << " : zero";
+ break;
+ case OpenACCClauseKind::Create:
+ case OpenACCClauseKind::PCreate:
+ case OpenACCClauseKind::PresentOrCreate:
+ OS << " clause";
+ if (cast<OpenACCCreateClause>(C)->isZero())
+ OS << " : zero";
+ break;
default:
// Nothing to do here.
break;
diff --git a/clang/lib/Parse/ParseOpenACC.cpp b/clang/lib/Parse/ParseOpenACC.cpp
index bc785fa7136aaa..c90ae8806f0868 100644
--- a/clang/lib/Parse/ParseOpenACC.cpp
+++ b/clang/lib/Parse/ParseOpenACC.cpp
@@ -100,12 +100,18 @@ OpenACCClauseKind getOpenACCClauseKind(Token Tok) {
.Case("auto", OpenACCClauseKind::Auto)
.Case("bind", OpenACCClauseKind::Bind)
.Case("create", OpenACCClauseKind::Create)
+ .Case("pcreate", OpenACCClauseKind::PCreate)
+ .Case("present_or_create", OpenACCClauseKind::PresentOrCreate)
.Case("collapse", OpenACCClauseKind::Collapse)
.Case("copy", OpenACCClauseKind::Copy)
.Case("pcopy", OpenACCClauseKind::PCopy)
.Case("present_or_copy", OpenACCClauseKind::PresentOrCopy)
.Case("copyin", OpenACCClauseKind::CopyIn)
+ .Case("pcopyin", OpenACCClauseKind::PCopyIn)
+ .Case("present_or_copyin", OpenACCClauseKind::PresentOrCopyIn)
.Case("copyout", OpenACCClauseKind::CopyOut)
+ .Case("pcopyout", OpenACCClauseKind::PCopyOut)
+ .Case("present_or_copyout", OpenACCClauseKind::PresentOrCopyOut)
.Case("default", OpenACCClauseKind::Default)
.Case("default_async", OpenACCClauseKind::DefaultAsync)
.Case("delete", OpenACCClauseKind::Delete)
@@ -490,11 +496,17 @@ ClauseParensKind getClauseParensKind(OpenACCDirectiveKind DirKind,
case OpenACCClauseKind::Default:
case OpenACCClauseKind::If:
case OpenACCClauseKind::Create:
+ case OpenACCClauseKind::PCreate:
+ case OpenACCClauseKind::PresentOrCreate:
case OpenACCClauseKind::Copy:
case OpenACCClauseKind::PCopy:
case OpenACCClauseKind::PresentOrCopy:
case OpenACCClauseKind::CopyIn:
+ case OpenACCClauseKind::PCopyIn:
+ case OpenACCClauseKind::PresentOrCopyIn:
case OpenACCClauseKind::CopyOut:
+ case OpenACCClauseKind::PCopyOut:
+ case OpenACCClauseKind::PresentOrCopyOut:
case OpenACCClauseKind::UseDevice:
case OpenACCClauseKind::NoCreate:
case OpenACCClauseKind::Present:
@@ -901,16 +913,26 @@ Parser::OpenACCClauseParseResult Parser::ParseOpenACCClauseParams(
break;
}
case OpenACCClauseKind::CopyIn:
- tryParseAndConsumeSpecialTokenKind(
+ case OpenACCClauseKind::PCopyIn:
+ case OpenACCClauseKind::PresentOrCopyIn: {
+ bool IsReadOnly = tryParseAndConsumeSpecialTokenKind(
*this, OpenACCSpecialTokenKind::ReadOnly, ClauseKind);
- ParseOpenACCVarList();
+ ParsedClause.setVarListDetails(ParseOpenACCVarList(), IsReadOnly,
+ /*IsZero=*/false);
break;
+ }
case OpenACCClauseKind::Create:
+ case OpenACCClauseKind::PCreate:
+ case OpenACCClauseKind::PresentOrCreate:
case OpenACCClauseKind::CopyOut:
- tryParseAndConsumeSpecialTokenKind(*this, OpenACCSpecialTokenKind::Zero,
- ClauseKind);
- ParseOpenACCVarList();
+ case OpenACCClauseKind::PCopyOut:
+ case OpenACCClauseKind::PresentOrCopyOut: {
+ bool IsZero = tryParseAndConsumeSpecialTokenKind(
+ *this, OpenACCSpecialTokenKind::Zero, ClauseKind);
+ ParsedClause.setVarListDetails(ParseOpenACCVarList(),
+ /*IsReadOnly=*/false, IsZero);
break;
+ }
case OpenACCClauseKind::Reduction:
// If we're missing a clause-kind (or it is invalid), see if we can parse
// the var-list anyway.
@@ -941,7 +963,8 @@ Parser::OpenACCClauseParseResult Parser::ParseOpenACCClauseParams(
case OpenACCClauseKind::NoCreate:
case OpenACCClauseKind::Present:
case OpenACCClauseKind::Private:
- ParsedClause.setVarListDetails(ParseOpenACCVarList());
+ ParsedClause.setVarListDetails(ParseOpenACCVarList(),
+ /*IsReadOnly=*/false, /*IsZero=*/false);
break;
case OpenACCClauseKind::Collapse: {
tryParseAndConsumeSpecialTokenKind(*this, OpenACCSpecialTokenKind::Force,
diff --git a/clang/lib/Sema/SemaOpenACC.cpp b/clang/lib/Sema/SemaOpenACC.cpp
index ee73447067b1ab..4e1a8c1277c5f0 100644
--- a/clang/lib/Sema/SemaOpenACC.cpp
+++ b/clang/lib/Sema/SemaOpenACC.cpp
@@ -450,6 +450,69 @@ SemaOpenACC::ActOnClause(ArrayRef<const OpenACCClause *> ExistingClauses,
getASTContext(), Clause.getClauseKind(), Clause.getBeginLoc(),
Clause.getLParenLoc(), Clause.getVarList(), Clause.getEndLoc());
}
+ case OpenACCClauseKind::PresentOrCopyIn:
+ case OpenACCClauseKind::PCopyIn:
+ Diag(Clause.getBeginLoc(), diag::warn_acc_deprecated_alias_name)
+ << Clause.getClauseKind() << OpenACCClauseKind::CopyIn;
+ LLVM_FALLTHROUGH;
+ case OpenACCClauseKind::CopyIn: {
+ // Restrictions only properly implemented on 'compute' constructs, and
+ // 'compute' constructs are the only construct that can do anything with
+ // this yet, so skip/treat as unimplemented in this case.
+ if (!isOpenACCComputeDirectiveKind(Clause.getDirectiveKind()))
+ break;
+
+ // ActOnVar ensured that everything is a valid variable reference, so there
+ // really isn't anything to do here. GCC does some duplicate-finding, though
+ // it isn't apparent in the standard where this is justified.
+
+ return OpenACCCopyInClause::Create(
+ getASTContext(), Clause.getClauseKind(), Clause.getBeginLoc(),
+ Clause.getLParenLoc(), Clause.isReadOnly(), Clause.getVarList(),
+ Clause.getEndLoc());
+ }
+ case OpenACCClauseKind::PresentOrCopyOut:
+ case OpenACCClauseKind::PCopyOut:
+ Diag(Clause.getBeginLoc(), diag::warn_acc_deprecated_alias_name)
+ << Clause.getClauseKind() << OpenACCClauseKind::CopyOut;
+ LLVM_FALLTHROUGH;
+ case OpenACCClauseKind::CopyOut: {
+ // Restrictions only properly implemented on 'compute' constructs, and
+ // 'compute' constructs are the only construct that can do anything with
+ // this yet, so skip/treat as unimplemented in this case.
+ if (!isOpenACCComputeDirectiveKind(Clause.getDirectiveKind()))
+ break;
+
+ // ActOnVar ensured that everything is a valid variable reference, so there
+ // really isn't anything to do here. GCC does some duplicate-finding, though
+ // it isn't apparent in the standard where this is justified.
+
+ return OpenACCCopyOutClause::Create(
+ getASTContext(), Clause.getClauseKind(), Clause.getBeginLoc(),
+ Clause.getLParenLoc(), Clause.isZero(), Clause.getVarList(),
+ Clause.getEndLoc());
+ }
+ case OpenACCClauseKind::PresentOrCreate:
+ case OpenACCClauseKind::PCreate:
+ Diag(Clause.getBeginLoc(), diag::warn_acc_deprecated_alias_name)
+ << Clause.getClauseKind() << OpenACCClauseKind::Create;
+ LLVM_FALLTHROUGH;
+ case OpenACCClauseKind::Create: {
+ // Restrictions only properly implemented on 'compute' constructs, and
+ // 'compute' constructs are the only construct that can do anything with
+ // this yet, so skip/treat as unimplemented in this case.
+ if (!isOpenACCComputeDirectiveKind(Clause.getDirectiveKind()))
+ break;
+
+ // ActOnVar ensured that everything is a valid variable reference, so there
+ // really isn't anything to do here. GCC does some duplicate-finding, though
+ // it isn't apparent in the standard where this is justified.
+
+ return OpenACCCreateClause::Create(getASTContext(), Clause.getClauseKind(),
+ Clause.getBeginLoc(),
+ Clause.getLParenLoc(), Clause.isZero(),
+ Clause.getVarList(), Clause.getEndLoc());
+ }
default:
break;
}
diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h
index 810247f8700f68..edf55703874688 100644
--- a/clang/lib/Sema/TreeTransform.h
+++ b/clang/lib/Sema/TreeTransform.h
@@ -11223,7 +11223,8 @@ void OpenACCClauseTransform<Derived>::VisitNumGangsClause(
template <typename Derived>
void OpenACCClauseTransform<Derived>::VisitPrivateClause(
const OpenACCPrivateClause &C) {
- ParsedClause.setVarListDetails(VisitVarList(C.getVarList()));
+ ParsedClause.setVarListDetails(VisitVarList(C.getVarList()),
+ /*IsReadOnly=*/false, /*IsZero=*/false);
NewClause = OpenACCPrivateClause::Create(
Self.getSema().getASTContext(), ParsedClause.getBeginLoc(),
@@ -11234,7 +11235,8 @@ void OpenACCClauseTransform<Derived>::VisitPrivateClause(
template <typename Derived>
void OpenACCClauseTransform<Derived>::VisitFirstPrivateClause(
const OpenACCFirstPrivateClause &C) {
- ParsedClause.setVarListDetails(VisitVarList(C.getVarList()));
+ ParsedClause.setVarListDetails(VisitVarList(C.getVarList()),
+ /*IsReadOnly=*/false, /*IsZero=*/false);
NewClause = OpenACCFirstPrivateClause::Create(
Self.getSema().getASTContext(), ParsedClause.getBeginLoc(),
@@ -11245,7 +11247,8 @@ void OpenACCClauseTransform<Derived>::VisitFirstPrivateClause(
template <typename Derived>
void OpenACCClauseTransform<Derived>::VisitNoCreateClause(
const OpenACCNoCreateClause &C) {
- ParsedClause.setVarListDetails(VisitVarList(C.getVarList()));
+ ParsedClause.setVarListDetails(VisitVarList(C.getVarList()),
+ /*IsReadOnly=*/false, /*IsZero=*/false);
NewClause = OpenACCNoCreateClause::Create(
Self.getSema().getASTContext(), ParsedClause.getBeginLoc(),
@@ -11256,7 +11259,8 @@ void OpenACCClauseTransform<Derived>::VisitNoCreateClause(
template <typename Derived>
void OpenACCClauseTransform<Derived>::VisitPresentClause(
const OpenACCPresentClause &C) {
- ParsedClause.setVarListDetails(VisitVarList(C.getVarList()));
+ ParsedClause.setVarListDetails(VisitVarList(C.getVarList()),
+ /*IsReadOnly=*/false, /*IsZero=*/false);
NewClause = OpenACCPresentClause::Create(
Self.getSema().getASTContext(), ParsedClause.getBeginLoc(),
@@ -11267,7 +11271,8 @@ void OpenACCClauseTransform<Derived>::VisitPresentClause(
template <typename Derived>
void OpenACCClauseTransform<Derived>::VisitCopyClause(
const OpenACCCopyClause &C) {
- ParsedClause.setVarListDetails(VisitVarList(C.getVarList()));
+ ParsedClause.setVarListDetails(VisitVarList(C.getVarList()),
+ /*IsReadOnly=*/false, /*IsZero=*/false);
NewClause = OpenACCCopyClause::Create(
Self.getSema().getASTContext(), ParsedClause.getClauseKind(),
@@ -11275,6 +11280,45 @@ void OpenACCClauseTransform<Derived>::VisitCopyClause(
ParsedClause.getVarList(), ParsedClause.getEndLoc());
}
+template <typename Derived>
+void OpenACCClauseTransform<Derived>::VisitCopyInClause(
+ const OpenACCCopyInClause &C) {
+ ParsedClause.setVarListDetails(VisitVarList(C.getVarList()), C.isReadOnly(),
+ /*IsZero=*/false);
+
+ NewClause = OpenACCCopyInClause::Create(
+ Self.getSema().getASTContext(), ParsedClause.getClauseKind(),
+ ParsedClause.getBeginLoc(), ParsedClause.getLParenLoc(),
+ ParsedClause.isReadOnly(), ParsedClause.getVarList(),
+ ParsedClause.getEndLoc());
+}
+
+template <typename Derived>
+void OpenACCClauseTransform<Derived>::VisitCopyOutClause(
+ const OpenACCCopyOutClause &C) {
+ ParsedClause.setVarListDetails(VisitVarList(C.getVarList()),
+ /*IsReadOnly=*/false, C.isZero());
+
+ NewClause = OpenACCCopyOutClause::Create(
+ Self.getSema().getASTContext(), ParsedClause.getClauseKind(),
+ ParsedClause.getBeginLoc(), ParsedClause.getLParenLoc(),
+ ParsedClause.isZero(), ParsedClause.getVarList(),
+ ParsedClause.getEndLoc());
+}
+
+template <typename Derived>
+void OpenACCClauseTransform<Derived>::VisitCreateClause(
+ const OpenACCCreateClause &C) {
+ ParsedClause.setVarListDetails(VisitVarList(C.getVarList()),
+ /*IsReadOnly=*/false, C.isZero());
+
+ NewClause = OpenACCCreateClause::Create(
+ Self.getSema().getASTContext(), ParsedClause.getClauseKind(),
+ ParsedClause.getBeginLoc(), ParsedClause.getLParenLoc(),
+ ParsedClause.isZero(), ParsedClause.getVarList(),
+ ParsedClause.getEndLoc());
+}
+
template <typename Derived>
void OpenACCClauseTransform<Derived>::VisitNumWorkersClause(
const OpenACCNumWorkersClause &C) {
diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp
index 9f4397906b8ce7..6d121f4ab80e84 100644
--- a/clang/lib/Serialization/ASTReader.cpp
+++ b/clang/lib/Serialization/ASTReader.cpp
@@ -11861,6 +11861,34 @@ OpenACCClause *ASTRecordReader::readOpenACCClause() {
return OpenACCCopyClause::Create(getContext(), ClauseKind, BeginLoc,
LParenLoc, VarList, EndLoc);
}
+ case OpenACCClauseKind::CopyIn:
+ case OpenACCClauseKind::PCopyIn:
+ case OpenACCClauseKind::PresentOrCopyIn: {
+ SourceLocation LParenLoc = readSourceLocation();
+ bool IsReadOnly = readBool();
+ llvm::SmallVector<Expr *> VarList = readOpenACCVarList();
+ return OpenACCCopyInClause::Create(getContext(), ClauseKind, BeginLoc,
+ LParenLoc, IsReadOnly, VarList, EndLoc);
+ }
+ case OpenACCClauseKind::CopyOut:
+ case OpenACCClauseKind::PCopyOut:
+ case OpenACCClauseKind::PresentOrCopyOut: {
+ SourceLocation LParenLoc = readSourceLocation();
+ bool IsZero = readBool();
+ llvm::SmallVector<Expr *> VarList = readOpenACCVarList();
+ return OpenACCCopyOutClause::Create(getContext(), ClauseKind, BeginLoc,
+ LParenLoc, IsZero, VarList, EndLoc);
+ }
+ case OpenACCClauseKind::Create:
+ case OpenACCClauseKind::PCreate:
+ case OpenACCClauseKind::PresentOrCreate: {
+ SourceLocation LParenLoc = readSourceLocation();
+ bool IsZero = readBool();
+ llvm::SmallVector<Expr *> VarList = readOpenACCVarList();
+ return OpenACCCreateClause::Create(getContext(), ClauseKind, BeginLoc,
+ LParenLoc, IsZero, VarList, EndLoc);
+ }
+
case OpenACCClauseKind::Finalize:
case OpenACCClauseKind::IfPresent:
case OpenACCClauseKind::Seq:
@@ -11878,9 +11906,6 @@ OpenACCClause *ASTRecordReader::readOpenACCClause() {
case OpenACCClauseKind::DeviceResident:
case OpenACCClauseKind::Host:
case OpenACCClauseKind::Link:
- case OpenACCClauseKind::CopyOut:
- case OpenACCClauseKind::CopyIn:
- case OpenACCClauseKind::Create:
case OpenACCClauseKind::Reduction:
case OpenACCClauseKind::Collapse:
case OpenACCClauseKind::Bind:
diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp
index 118e4395d971af..9712ed6e839180 100644
--- a/clang/lib/Serialization/ASTWriter.cpp
+++ b/clang/lib/Serialization/ASTWriter.cpp
@@ -7813,6 +7813,33 @@ void ASTRecordWriter::writeOpenACCClause(const OpenACCClause *C) {
writeOpenACCVarList(CC);
return;
}
+ case OpenACCClauseKind::CopyIn:
+ case OpenACCClauseKind::PCopyIn:
+ case OpenACCClauseKind::PresentOrCopyIn: {
+ const auto *CIC = cast<OpenACCCopyInClause>(C);
+ writeSourceLocation(CIC->getLParenLoc());
+ writeBool(CIC->isReadOnly());
+ writeOpenACCVarList(CIC);
+ return;
+ }
+ case OpenACCClauseKind::CopyOut:
+ case OpenACCClauseKind::PCopyOut:
+ case OpenACCClauseKind::PresentOrCopyOut: {
+ const auto *COC = cast<OpenACCCopyOutClause>(C);
+ writeSourceLocation(COC->getLParenLoc());
+ writeBool(COC->isZero());
+ writeOpenACCVarList(COC);
+ return;
+ }
+ case OpenACCClauseKind::Create:
+ case OpenACCClauseKind::PCreate:
+ case OpenACCClauseKind::PresentOrCreate: {
+ const auto *CC = cast<OpenACCCreateClause>(C);
+ writeSourceLocation(CC->getLParenLoc());
+ writeBool(CC->isZero());
+ writeOpenACCVarList(CC);
+ return;
+ }
case OpenACCClauseKind::Finalize:
case OpenACCClauseKind::IfPresent:
@@ -7831,9 +7858,6 @@ void ASTRecordWriter::writeOpenACCClause(const OpenACCClause *C) {
case OpenACCClauseKind::DeviceResident:
case OpenACCClauseKind::Host:
case OpenACCClauseKind::Link:
- case OpenACCClauseKind::CopyOut:
- case OpenACCClauseKind::CopyIn:
- case OpenACCClauseKind::Create:
case OpenACCClauseKind::Reduction:
case OpenACCClauseKind::Collapse:
case OpenACCClauseKind::Bind:
diff --git a/clang/test/AST/ast-print-openacc-compute-construct.cpp b/clang/test/AST/ast-print-openacc-compute-construct.cpp
index 895660ae1641cf..112f328f5cb9ce 100644
--- a/clang/test/AST/ast-print-openacc-compute-construct.cpp
+++ b/clang/test/AST/ast-print-openacc-compute-construct.cpp
@@ -1,4 +1,4 @@
-// RUN: %clang_cc1 -fopenacc -ast-print %s -o - | FileCheck %s
+// RUN: %clang_cc1 -fopenacc -Wno-openacc-deprecated-clause-alias -ast-print %s -o - | FileCheck %s
void foo() {
int i;
@@ -53,5 +53,17 @@ void foo() {
// CHECK: #pragma acc parallel no_create(i, array[1], array, array[1:2]) present(i, array[1], array, array[1:2])
#pragma acc parallel no_create(i, array[1], array, array[1:2]) present(i, array[1], array, array[1:2])
while(true);
+
+// CHECK: #pragma acc parallel copyin(i, array[1], array, array[1:2]) pcopyin(readonly: i, array[1], array, array[1:2]) present_or_copyin(i, array[1], array, array[1:2])
+#pragma acc parallel copyin(i, array[1], array, array[1:2]) pcopyin(readonly:i, array[1], array, array[1:2]) present_or_copyin(i, array[1], array, array[1:2])
+ while(true);
+
+// CHECK: #pragma acc parallel copyout(i, array[1], array, array[1:2]) pcopyout(zero: i, array[1], array, array[1:2]) present_or_copyout(i, array[1], array, array[1:2])
+#pragma acc parallel copyout(i, array[1], array, array[1:2]) pcopyout(zero: i, array[1], array, array[1:2]) present_or_copyout(i, array[1], array, array[1:2])
+ while(true);
+
+// CHECK: #pragma acc parallel create(i, array[1], array, array[1:2]) pcreate(zero: i, array[1], array, array[1:2]) present_or_create(i, array[1], array, array[1:2])
+#pragma acc parallel create(i, array[1], array, array[1:2]) pcreate(zero: i, array[1], array, array[1:2]) present_or_create(i, array[1], array, array[1:2])
+ while(true);
}
diff --git a/clang/test/ParserOpenACC/parse-clauses.c b/clang/test/ParserOpenACC/parse-clauses.c
index c1287c329bc86d..65247e4db63efa 100644
--- a/clang/test/ParserOpenACC/parse-clauses.c
+++ b/clang/test/ParserOpenACC/parse-clauses.c
@@ -665,161 +665,158 @@ void VarListClauses() {
#pragma acc serial device(s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +3{{expected ','}}
- // expected-warning at +2{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+ // expected-error at +2{{expected ','}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyout(s.array[s.value] s.array[s.value :5] ), seq
for(;;){}
- // expected-warning at +2{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyout(s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-warning at +2{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyout(zero:s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-warning at +2{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC clause name 'pcopyout' is a deprecated clause name and is now an alias for 'copyout'}}
+#pragma acc serial pcopyout(s.array[s.value : 5], s.value)
+ for(;;){}
+
+ // expected-warning at +1{{OpenACC clause name 'present_or_copyout' is a deprecated clause name and is now an alias for 'copyout'}}
+#pragma acc serial present_or_copyout(zero:s.array[s.value : 5], s.value)
+ for(;;){}
+
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyout(zero : s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +4{{use of undeclared identifier 'zero'}}
- // expected-error at +3{{expected ','}}
- // expected-warning at +2{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+ // expected-error at +3{{use of undeclared identifier 'zero'}}
+ // expected-error at +2{{expected ','}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyout(zero s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +3{{invalid tag 'readonly' on 'copyout' clause}}
- // expected-warning at +2{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+ // expected-error at +2{{invalid tag 'readonly' on 'copyout' clause}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyout(readonly:s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +3{{invalid tag 'invalid' on 'copyout' clause}}
- // expected-warning at +2{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+ // expected-error at +2{{invalid tag 'invalid' on 'copyout' clause}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyout(invalid:s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +3{{invalid tag 'invalid' on 'copyout' clause}}
- // expected-warning at +2{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+ // expected-error at +2{{invalid tag 'invalid' on 'copyout' clause}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyout(invalid:s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +4{{use of undeclared identifier 'invalid'}}
- // expected-error at +3{{expected ','}}
- // expected-warning at +2{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+ // expected-error at +3{{use of undeclared identifier 'invalid'}}
+ // expected-error at +2{{expected ','}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyout(invalid s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +3{{expected ','}}
- // expected-warning at +2{{OpenACC clause 'create' not yet implemented, clause ignored}}
+ // expected-error at +2{{expected ','}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial create(s.array[s.value] s.array[s.value :5] ), seq
for(;;){}
- // expected-warning at +2{{OpenACC clause 'create' not yet implemented, clause ignored}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial create(s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-warning at +2{{OpenACC clause 'create' not yet implemented, clause ignored}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial create(zero:s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-warning at +2{{OpenACC clause 'create' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC clause name 'pcreate' is a deprecated clause name and is now an alias for 'create'}}
+#pragma acc serial pcreate(s.array[s.value : 5], s.value)
+ for(;;){}
+
+ // expected-warning at +1{{OpenACC clause name 'present_or_create' is a deprecated clause name and is now an alias for 'create'}}
+#pragma acc serial present_or_create(zero:s.array[s.value : 5], s.value)
+ for(;;){}
+
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial create(zero : s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +4{{use of undeclared identifier 'zero'}}
- // expected-error at +3{{expected ','}}
- // expected-warning at +2{{OpenACC clause 'create' not yet implemented, clause ignored}}
+ // expected-error at +3{{use of undeclared identifier 'zero'}}
+ // expected-error at +2{{expected ','}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial create(zero s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +3{{invalid tag 'readonly' on 'create' clause}}
- // expected-warning at +2{{OpenACC clause 'create' not yet implemented, clause ignored}}
+ // expected-error at +2{{invalid tag 'readonly' on 'create' clause}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial create(readonly:s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +3{{invalid tag 'invalid' on 'create' clause}}
- // expected-warning at +2{{OpenACC clause 'create' not yet implemented, clause ignored}}
+ // expected-error at +2{{invalid tag 'invalid' on 'create' clause}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial create(invalid:s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +3{{invalid tag 'invalid' on 'create' clause}}
- // expected-warning at +2{{OpenACC clause 'create' not yet implemented, clause ignored}}
+ // expected-error at +2{{invalid tag 'invalid' on 'create' clause}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial create(invalid:s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +4{{use of undeclared identifier 'invalid'}}
- // expected-error at +3{{expected ','}}
- // expected-warning at +2{{OpenACC clause 'create' not yet implemented, clause ignored}}
+ // expected-error at +3{{use of undeclared identifier 'invalid'}}
+ // expected-error at +2{{expected ','}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial create(invalid s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +3{{expected ','}}
- // expected-warning at +2{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+ // expected-error at +2{{expected ','}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyin(s.array[s.value] s.array[s.value :5] ), seq
for(;;){}
- // expected-warning at +2{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyin(s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-warning at +2{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyin(readonly:s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-warning at +2{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC clause name 'pcopyin' is a deprecated clause name and is now an alias for 'copyin'}}
+#pragma acc serial pcopyin(s.array[s.value : 5], s.value)
+ for(;;){}
+
+ // expected-warning at +1{{OpenACC clause name 'present_or_copyin' is a deprecated clause name and is now an alias for 'copyin'}}
+#pragma acc serial present_or_copyin(readonly:s.array[s.value : 5], s.value)
+ for(;;){}
+
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyin(readonly : s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +4{{use of undeclared identifier 'readonly'}}
- // expected-error at +3{{expected ','}}
- // expected-warning at +2{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+ // expected-error at +3{{use of undeclared identifier 'readonly'}}
+ // expected-error at +2{{expected ','}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyin(readonly s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +3{{invalid tag 'zero' on 'copyin' clause}}
- // expected-warning at +2{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+ // expected-error at +2{{invalid tag 'zero' on 'copyin' clause}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyin(zero :s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +3{{invalid tag 'invalid' on 'copyin' clause}}
- // expected-warning at +2{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+ // expected-error at +2{{invalid tag 'invalid' on 'copyin' clause}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyin(invalid:s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +3{{invalid tag 'invalid' on 'copyin' clause}}
- // expected-warning at +2{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+ // expected-error at +2{{invalid tag 'invalid' on 'copyin' clause}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyin(invalid:s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-error at +4{{use of undeclared identifier 'invalid'}}
- // expected-error at +3{{expected ','}}
- // expected-warning at +2{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+ // expected-error at +3{{use of undeclared identifier 'invalid'}}
+ // expected-error at +2{{expected ','}}
// expected-warning at +1{{OpenACC clause 'seq' not yet implemented, clause ignored}}
#pragma acc serial copyin(invalid s.array[s.value : 5], s.value), seq
for(;;){}
diff --git a/clang/test/SemaOpenACC/compute-construct-copyin-clause.c b/clang/test/SemaOpenACC/compute-construct-copyin-clause.c
new file mode 100644
index 00000000000000..6f200b357f52b2
--- /dev/null
+++ b/clang/test/SemaOpenACC/compute-construct-copyin-clause.c
@@ -0,0 +1,68 @@
+// RUN: %clang_cc1 %s -fopenacc -verify
+
+typedef struct IsComplete {
+ struct S { int A; } CompositeMember;
+ int ScalarMember;
+ float ArrayMember[5];
+ void *PointerMember;
+} Complete;
+void uses(int IntParam, short *PointerParam, float ArrayParam[5], Complete CompositeParam) {
+ int LocalInt;
+ short *LocalPointer;
+ float LocalArray[5];
+ Complete LocalComposite;
+ // Check Appertainment:
+#pragma acc parallel copyin(LocalInt)
+ while(1);
+#pragma acc serial copyin(LocalInt)
+ while(1);
+#pragma acc kernels copyin(LocalInt)
+ while(1);
+
+ // expected-warning at +1{{OpenACC clause name 'pcopyin' is a deprecated clause name and is now an alias for 'copyin'}}
+#pragma acc parallel pcopyin(LocalInt)
+ while(1);
+
+ // expected-warning at +1{{OpenACC clause name 'present_or_copyin' is a deprecated clause name and is now an alias for 'copyin'}}
+#pragma acc parallel present_or_copyin(LocalInt)
+ while(1);
+
+ // Valid cases:
+#pragma acc parallel copyin(LocalInt, LocalPointer, LocalArray)
+ while(1);
+#pragma acc parallel copyin(LocalArray[2:1])
+ while(1);
+#pragma acc parallel copyin(readonly:LocalArray[2:1])
+ while(1);
+
+#pragma acc parallel copyin(LocalComposite.ScalarMember, LocalComposite.ScalarMember)
+ while(1);
+
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyin(1 + IntParam)
+ while(1);
+
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyin(+IntParam)
+ while(1);
+
+ // expected-error at +1{{OpenACC sub-array length is unspecified and cannot be inferred because the subscripted value is not an array}}
+#pragma acc parallel copyin(PointerParam[2:])
+ while(1);
+
+ // expected-error at +1{{OpenACC sub-array specified range [2:5] would be out of the range of the subscripted array size of 5}}
+#pragma acc parallel copyin(ArrayParam[2:5])
+ while(1);
+
+ // expected-error at +2{{OpenACC sub-array specified range [2:5] would be out of the range of the subscripted array size of 5}}
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyin((float*)ArrayParam[2:5])
+ while(1);
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyin((float)ArrayParam[2])
+ while(1);
+ // expected-error at +2{{invalid tag 'invalid' on 'copyin' clause}}
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyin(invalid:(float)ArrayParam[2])
+ while(1);
+}
diff --git a/clang/test/SemaOpenACC/compute-construct-copyin-clause.cpp b/clang/test/SemaOpenACC/compute-construct-copyin-clause.cpp
new file mode 100644
index 00000000000000..79275e701161b3
--- /dev/null
+++ b/clang/test/SemaOpenACC/compute-construct-copyin-clause.cpp
@@ -0,0 +1,112 @@
+// RUN: %clang_cc1 %s -fopenacc -verify
+
+enum SomeE{};
+typedef struct IsComplete {
+ struct S { int A; } CompositeMember;
+ int ScalarMember;
+ float ArrayMember[5];
+ SomeE EnumMember;
+ char *PointerMember;
+} Complete;
+
+void uses(int IntParam, char *PointerParam, float ArrayParam[5], Complete CompositeParam, int &IntParamRef) {
+ int LocalInt;
+ char *LocalPointer;
+ float LocalArray[5];
+ // Check Appertainment:
+#pragma acc parallel copyin(LocalInt)
+ while(1);
+#pragma acc serial copyin(LocalInt)
+ while(1);
+#pragma acc kernels copyin(LocalInt)
+ while(1);
+
+ // Valid cases:
+#pragma acc parallel copyin(LocalInt, LocalPointer, LocalArray)
+ while(1);
+#pragma acc parallel copyin(LocalArray[2:1])
+ while(1);
+
+ Complete LocalComposite2;
+#pragma acc parallel copyin(LocalComposite2.ScalarMember, LocalComposite2.ScalarMember)
+ while(1);
+
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyin(1 + IntParam)
+ while(1);
+
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyin(+IntParam)
+ while(1);
+
+ // expected-error at +1{{OpenACC sub-array length is unspecified and cannot be inferred because the subscripted value is not an array}}
+#pragma acc parallel copyin(PointerParam[2:])
+ while(1);
+
+ // expected-error at +1{{OpenACC sub-array specified range [2:5] would be out of the range of the subscripted array size of 5}}
+#pragma acc parallel copyin(ArrayParam[2:5])
+ while(1);
+
+ // expected-error at +2{{OpenACC sub-array specified range [2:5] would be out of the range of the subscripted array size of 5}}
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyin((float*)ArrayParam[2:5])
+ while(1);
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyin((float)ArrayParam[2])
+ while(1);
+}
+
+template<typename T, unsigned I, typename V>
+void TemplUses(T t, T (&arrayT)[I], V TemplComp) {
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyin(+t)
+ while(true);
+
+ // NTTP's are only valid if it is a reference to something.
+ // expected-error at +2{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+ // expected-note@#TEMPL_USES_INST{{in instantiation of}}
+#pragma acc parallel copyin(I)
+ while(true);
+
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyin(t, I)
+ while(true);
+
+#pragma acc parallel copyin(arrayT)
+ while(true);
+
+#pragma acc parallel copyin(TemplComp)
+ while(true);
+
+#pragma acc parallel copyin(TemplComp.PointerMember[5])
+ while(true);
+ int *Pointer;
+#pragma acc parallel copyin(Pointer[:I])
+ while(true);
+#pragma acc parallel copyin(Pointer[:t])
+ while(true);
+ // expected-error at +1{{OpenACC sub-array length is unspecified and cannot be inferred because the subscripted value is not an array}}
+#pragma acc parallel copyin(Pointer[1:])
+ while(true);
+}
+
+template<unsigned I, auto &NTTP_REF>
+void NTTP() {
+ // NTTP's are only valid if it is a reference to something.
+ // expected-error at +2{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+ // expected-note@#NTTP_INST{{in instantiation of}}
+#pragma acc parallel copyin(I)
+ while(true);
+
+#pragma acc parallel copyin(NTTP_REF)
+ while(true);
+}
+
+void Inst() {
+ static constexpr int NTTP_REFed = 1;
+ int i;
+ int Arr[5];
+ Complete C;
+ TemplUses(i, Arr, C); // #TEMPL_USES_INST
+ NTTP<5, NTTP_REFed>(); // #NTTP_INST
+}
diff --git a/clang/test/SemaOpenACC/compute-construct-copyout-clause.c b/clang/test/SemaOpenACC/compute-construct-copyout-clause.c
new file mode 100644
index 00000000000000..38a50f8373e8d0
--- /dev/null
+++ b/clang/test/SemaOpenACC/compute-construct-copyout-clause.c
@@ -0,0 +1,68 @@
+// RUN: %clang_cc1 %s -fopenacc -verify
+
+typedef struct IsComplete {
+ struct S { int A; } CompositeMember;
+ int ScalarMember;
+ float ArrayMember[5];
+ void *PointerMember;
+} Complete;
+void uses(int IntParam, short *PointerParam, float ArrayParam[5], Complete CompositeParam) {
+ int LocalInt;
+ short *LocalPointer;
+ float LocalArray[5];
+ Complete LocalComposite;
+ // Check Appertainment:
+#pragma acc parallel copyout(LocalInt)
+ while(1);
+#pragma acc serial copyout(LocalInt)
+ while(1);
+#pragma acc kernels copyout(LocalInt)
+ while(1);
+
+ // expected-warning at +1{{OpenACC clause name 'pcopyout' is a deprecated clause name and is now an alias for 'copyout'}}
+#pragma acc parallel pcopyout(LocalInt)
+ while(1);
+
+ // expected-warning at +1{{OpenACC clause name 'present_or_copyout' is a deprecated clause name and is now an alias for 'copyout'}}
+#pragma acc parallel present_or_copyout(LocalInt)
+ while(1);
+
+ // Valid cases:
+#pragma acc parallel copyout(LocalInt, LocalPointer, LocalArray)
+ while(1);
+#pragma acc parallel copyout(LocalArray[2:1])
+ while(1);
+#pragma acc parallel copyout(zero:LocalArray[2:1])
+ while(1);
+
+#pragma acc parallel copyout(LocalComposite.ScalarMember, LocalComposite.ScalarMember)
+ while(1);
+
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyout(1 + IntParam)
+ while(1);
+
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyout(+IntParam)
+ while(1);
+
+ // expected-error at +1{{OpenACC sub-array length is unspecified and cannot be inferred because the subscripted value is not an array}}
+#pragma acc parallel copyout(PointerParam[2:])
+ while(1);
+
+ // expected-error at +1{{OpenACC sub-array specified range [2:5] would be out of the range of the subscripted array size of 5}}
+#pragma acc parallel copyout(ArrayParam[2:5])
+ while(1);
+
+ // expected-error at +2{{OpenACC sub-array specified range [2:5] would be out of the range of the subscripted array size of 5}}
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyout((float*)ArrayParam[2:5])
+ while(1);
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyout((float)ArrayParam[2])
+ while(1);
+ // expected-error at +2{{invalid tag 'invalid' on 'copyout' clause}}
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyout(invalid:(float)ArrayParam[2])
+ while(1);
+}
diff --git a/clang/test/SemaOpenACC/compute-construct-copyout-clause.cpp b/clang/test/SemaOpenACC/compute-construct-copyout-clause.cpp
new file mode 100644
index 00000000000000..3d05a5670092e1
--- /dev/null
+++ b/clang/test/SemaOpenACC/compute-construct-copyout-clause.cpp
@@ -0,0 +1,112 @@
+// RUN: %clang_cc1 %s -fopenacc -verify
+
+enum SomeE{};
+typedef struct IsComplete {
+ struct S { int A; } CompositeMember;
+ int ScalarMember;
+ float ArrayMember[5];
+ SomeE EnumMember;
+ char *PointerMember;
+} Complete;
+
+void uses(int IntParam, char *PointerParam, float ArrayParam[5], Complete CompositeParam, int &IntParamRef) {
+ int LocalInt;
+ char *LocalPointer;
+ float LocalArray[5];
+ // Check Appertainment:
+#pragma acc parallel copyout(LocalInt)
+ while(1);
+#pragma acc serial copyout(LocalInt)
+ while(1);
+#pragma acc kernels copyout(LocalInt)
+ while(1);
+
+ // Valid cases:
+#pragma acc parallel copyout(LocalInt, LocalPointer, LocalArray)
+ while(1);
+#pragma acc parallel copyout(LocalArray[2:1])
+ while(1);
+
+ Complete LocalComposite2;
+#pragma acc parallel copyout(LocalComposite2.ScalarMember, LocalComposite2.ScalarMember)
+ while(1);
+
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyout(1 + IntParam)
+ while(1);
+
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyout(+IntParam)
+ while(1);
+
+ // expected-error at +1{{OpenACC sub-array length is unspecified and cannot be inferred because the subscripted value is not an array}}
+#pragma acc parallel copyout(PointerParam[2:])
+ while(1);
+
+ // expected-error at +1{{OpenACC sub-array specified range [2:5] would be out of the range of the subscripted array size of 5}}
+#pragma acc parallel copyout(ArrayParam[2:5])
+ while(1);
+
+ // expected-error at +2{{OpenACC sub-array specified range [2:5] would be out of the range of the subscripted array size of 5}}
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyout((float*)ArrayParam[2:5])
+ while(1);
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyout((float)ArrayParam[2])
+ while(1);
+}
+
+template<typename T, unsigned I, typename V>
+void TemplUses(T t, T (&arrayT)[I], V TemplComp) {
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyout(+t)
+ while(true);
+
+ // NTTP's are only valid if it is a reference to something.
+ // expected-error at +2{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+ // expected-note@#TEMPL_USES_INST{{in instantiation of}}
+#pragma acc parallel copyout(I)
+ while(true);
+
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel copyout(t, I)
+ while(true);
+
+#pragma acc parallel copyout(arrayT)
+ while(true);
+
+#pragma acc parallel copyout(TemplComp)
+ while(true);
+
+#pragma acc parallel copyout(TemplComp.PointerMember[5])
+ while(true);
+ int *Pointer;
+#pragma acc parallel copyout(Pointer[:I])
+ while(true);
+#pragma acc parallel copyout(Pointer[:t])
+ while(true);
+ // expected-error at +1{{OpenACC sub-array length is unspecified and cannot be inferred because the subscripted value is not an array}}
+#pragma acc parallel copyout(Pointer[1:])
+ while(true);
+}
+
+template<unsigned I, auto &NTTP_REF>
+void NTTP() {
+ // NTTP's are only valid if it is a reference to something.
+ // expected-error at +2{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+ // expected-note@#NTTP_INST{{in instantiation of}}
+#pragma acc parallel copyout(I)
+ while(true);
+
+#pragma acc parallel copyout(NTTP_REF)
+ while(true);
+}
+
+void Inst() {
+ static constexpr int NTTP_REFed = 1;
+ int i;
+ int Arr[5];
+ Complete C;
+ TemplUses(i, Arr, C); // #TEMPL_USES_INST
+ NTTP<5, NTTP_REFed>(); // #NTTP_INST
+}
diff --git a/clang/test/SemaOpenACC/compute-construct-create-clause.c b/clang/test/SemaOpenACC/compute-construct-create-clause.c
new file mode 100644
index 00000000000000..9c94e3a1a40739
--- /dev/null
+++ b/clang/test/SemaOpenACC/compute-construct-create-clause.c
@@ -0,0 +1,69 @@
+
+// RUN: %clang_cc1 %s -fopenacc -verify
+
+typedef struct IsComplete {
+ struct S { int A; } CompositeMember;
+ int ScalarMember;
+ float ArrayMember[5];
+ void *PointerMember;
+} Complete;
+void uses(int IntParam, short *PointerParam, float ArrayParam[5], Complete CompositeParam) {
+ int LocalInt;
+ short *LocalPointer;
+ float LocalArray[5];
+ Complete LocalComposite;
+ // Check Appertainment:
+#pragma acc parallel create(LocalInt)
+ while(1);
+#pragma acc serial create(LocalInt)
+ while(1);
+#pragma acc kernels create(LocalInt)
+ while(1);
+
+ // expected-warning at +1{{OpenACC clause name 'pcreate' is a deprecated clause name and is now an alias for 'create'}}
+#pragma acc parallel pcreate(LocalInt)
+ while(1);
+
+ // expected-warning at +1{{OpenACC clause name 'present_or_create' is a deprecated clause name and is now an alias for 'create'}}
+#pragma acc parallel present_or_create(LocalInt)
+ while(1);
+
+ // Valid cases:
+#pragma acc parallel create(LocalInt, LocalPointer, LocalArray)
+ while(1);
+#pragma acc parallel create(LocalArray[2:1])
+ while(1);
+#pragma acc parallel create(zero:LocalArray[2:1])
+ while(1);
+
+#pragma acc parallel create(LocalComposite.ScalarMember, LocalComposite.ScalarMember)
+ while(1);
+
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel create(1 + IntParam)
+ while(1);
+
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel create(+IntParam)
+ while(1);
+
+ // expected-error at +1{{OpenACC sub-array length is unspecified and cannot be inferred because the subscripted value is not an array}}
+#pragma acc parallel create(PointerParam[2:])
+ while(1);
+
+ // expected-error at +1{{OpenACC sub-array specified range [2:5] would be out of the range of the subscripted array size of 5}}
+#pragma acc parallel create(ArrayParam[2:5])
+ while(1);
+
+ // expected-error at +2{{OpenACC sub-array specified range [2:5] would be out of the range of the subscripted array size of 5}}
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel create((float*)ArrayParam[2:5])
+ while(1);
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel create((float)ArrayParam[2])
+ while(1);
+ // expected-error at +2{{invalid tag 'invalid' on 'create' clause}}
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel create(invalid:(float)ArrayParam[2])
+ while(1);
+}
diff --git a/clang/test/SemaOpenACC/compute-construct-create-clause.cpp b/clang/test/SemaOpenACC/compute-construct-create-clause.cpp
new file mode 100644
index 00000000000000..d0323620b8f70d
--- /dev/null
+++ b/clang/test/SemaOpenACC/compute-construct-create-clause.cpp
@@ -0,0 +1,112 @@
+// RUN: %clang_cc1 %s -fopenacc -verify
+
+enum SomeE{};
+typedef struct IsComplete {
+ struct S { int A; } CompositeMember;
+ int ScalarMember;
+ float ArrayMember[5];
+ SomeE EnumMember;
+ char *PointerMember;
+} Complete;
+
+void uses(int IntParam, char *PointerParam, float ArrayParam[5], Complete CompositeParam, int &IntParamRef) {
+ int LocalInt;
+ char *LocalPointer;
+ float LocalArray[5];
+ // Check Appertainment:
+#pragma acc parallel create(LocalInt)
+ while(1);
+#pragma acc serial create(LocalInt)
+ while(1);
+#pragma acc kernels create(LocalInt)
+ while(1);
+
+ // Valid cases:
+#pragma acc parallel create(LocalInt, LocalPointer, LocalArray)
+ while(1);
+#pragma acc parallel create(LocalArray[2:1])
+ while(1);
+
+ Complete LocalComposite2;
+#pragma acc parallel create(LocalComposite2.ScalarMember, LocalComposite2.ScalarMember)
+ while(1);
+
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel create(1 + IntParam)
+ while(1);
+
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel create(+IntParam)
+ while(1);
+
+ // expected-error at +1{{OpenACC sub-array length is unspecified and cannot be inferred because the subscripted value is not an array}}
+#pragma acc parallel create(PointerParam[2:])
+ while(1);
+
+ // expected-error at +1{{OpenACC sub-array specified range [2:5] would be out of the range of the subscripted array size of 5}}
+#pragma acc parallel create(ArrayParam[2:5])
+ while(1);
+
+ // expected-error at +2{{OpenACC sub-array specified range [2:5] would be out of the range of the subscripted array size of 5}}
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel create((float*)ArrayParam[2:5])
+ while(1);
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel create((float)ArrayParam[2])
+ while(1);
+}
+
+template<typename T, unsigned I, typename V>
+void TemplUses(T t, T (&arrayT)[I], V TemplComp) {
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel create(+t)
+ while(true);
+
+ // NTTP's are only valid if it is a reference to something.
+ // expected-error at +2{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+ // expected-note@#TEMPL_USES_INST{{in instantiation of}}
+#pragma acc parallel create(I)
+ while(true);
+
+ // expected-error at +1{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+#pragma acc parallel create(t, I)
+ while(true);
+
+#pragma acc parallel create(arrayT)
+ while(true);
+
+#pragma acc parallel create(TemplComp)
+ while(true);
+
+#pragma acc parallel create(TemplComp.PointerMember[5])
+ while(true);
+ int *Pointer;
+#pragma acc parallel create(Pointer[:I])
+ while(true);
+#pragma acc parallel create(Pointer[:t])
+ while(true);
+ // expected-error at +1{{OpenACC sub-array length is unspecified and cannot be inferred because the subscripted value is not an array}}
+#pragma acc parallel create(Pointer[1:])
+ while(true);
+}
+
+template<unsigned I, auto &NTTP_REF>
+void NTTP() {
+ // NTTP's are only valid if it is a reference to something.
+ // expected-error at +2{{OpenACC variable is not a valid variable name, sub-array, array element, or composite variable member}}
+ // expected-note@#NTTP_INST{{in instantiation of}}
+#pragma acc parallel create(I)
+ while(true);
+
+#pragma acc parallel create(NTTP_REF)
+ while(true);
+}
+
+void Inst() {
+ static constexpr int NTTP_REFed = 1;
+ int i;
+ int Arr[5];
+ Complete C;
+ TemplUses(i, Arr, C); // #TEMPL_USES_INST
+ NTTP<5, NTTP_REFed>(); // #NTTP_INST
+}
diff --git a/clang/test/SemaOpenACC/compute-construct-varlist-ast.cpp b/clang/test/SemaOpenACC/compute-construct-varlist-ast.cpp
index d3de9f146d8db4..d35f62adfe0794 100644
--- a/clang/test/SemaOpenACC/compute-construct-varlist-ast.cpp
+++ b/clang/test/SemaOpenACC/compute-construct-varlist-ast.cpp
@@ -109,6 +109,57 @@ void NormalUses(float *PointerParam) {
// CHECK-NEXT: CXXBoolLiteralExpr
// CHECK-NEXT: NullStmt
+#pragma acc parallel copyin(GlobalArray) pcopyin(readonly: PointerParam[Global]) present_or_copyin(Global)
+ while(true);
+ // CHECK-NEXT: OpenACCComputeConstruct{{.*}} parallel
+ // CHECK-NEXT: copyin clause
+ // CHECK-NEXT: DeclRefExpr{{.*}}'short[5]' lvalue Var{{.*}}'GlobalArray' 'short[5]'
+ // CHECK-NEXT: pcopyin clause : readonly
+ // CHECK-NEXT: ArraySubscriptExpr{{.*}}'float' lvalue
+ // CHECK-NEXT: ImplicitCastExpr{{.*}} 'float *' <LValueToRValue>
+ // CHECK-NEXT: DeclRefExpr{{.*}}'float *' lvalue ParmVar{{.*}}'PointerParam' 'float *'
+ // CHECK-NEXT: ImplicitCastExpr{{.*}} 'int' <LValueToRValue>
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int' lvalue Var{{.*}}'Global' 'int'
+ // CHECK-NEXT: present_or_copyin clause
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int' lvalue Var{{.*}}'Global' 'int'
+ // CHECK-NEXT: WhileStmt
+ // CHECK-NEXT: CXXBoolLiteralExpr
+ // CHECK-NEXT: NullStmt
+
+#pragma acc parallel copyout(GlobalArray) pcopyout(zero:PointerParam[Global]) present_or_copyout(Global)
+ while(true);
+ // CHECK-NEXT: OpenACCComputeConstruct{{.*}} parallel
+ // CHECK-NEXT: copyout clause
+ // CHECK-NEXT: DeclRefExpr{{.*}}'short[5]' lvalue Var{{.*}}'GlobalArray' 'short[5]'
+ // CHECK-NEXT: pcopyout clause : zero
+ // CHECK-NEXT: ArraySubscriptExpr{{.*}}'float' lvalue
+ // CHECK-NEXT: ImplicitCastExpr{{.*}} 'float *' <LValueToRValue>
+ // CHECK-NEXT: DeclRefExpr{{.*}}'float *' lvalue ParmVar{{.*}}'PointerParam' 'float *'
+ // CHECK-NEXT: ImplicitCastExpr{{.*}} 'int' <LValueToRValue>
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int' lvalue Var{{.*}}'Global' 'int'
+ // CHECK-NEXT: present_or_copyout clause
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int' lvalue Var{{.*}}'Global' 'int'
+ // CHECK-NEXT: WhileStmt
+ // CHECK-NEXT: CXXBoolLiteralExpr
+ // CHECK-NEXT: NullStmt
+
+#pragma acc parallel create(GlobalArray) pcreate(zero:PointerParam[Global]) present_or_create(Global)
+ while(true);
+ // CHECK-NEXT: OpenACCComputeConstruct{{.*}} parallel
+ // CHECK-NEXT: create clause
+ // CHECK-NEXT: DeclRefExpr{{.*}}'short[5]' lvalue Var{{.*}}'GlobalArray' 'short[5]'
+ // CHECK-NEXT: pcreate clause : zero
+ // CHECK-NEXT: ArraySubscriptExpr{{.*}}'float' lvalue
+ // CHECK-NEXT: ImplicitCastExpr{{.*}} 'float *' <LValueToRValue>
+ // CHECK-NEXT: DeclRefExpr{{.*}}'float *' lvalue ParmVar{{.*}}'PointerParam' 'float *'
+ // CHECK-NEXT: ImplicitCastExpr{{.*}} 'int' <LValueToRValue>
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int' lvalue Var{{.*}}'Global' 'int'
+ // CHECK-NEXT: present_or_create clause
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int' lvalue Var{{.*}}'Global' 'int'
+ // CHECK-NEXT: WhileStmt
+ // CHECK-NEXT: CXXBoolLiteralExpr
+ // CHECK-NEXT: NullStmt
+
#pragma acc parallel private(GlobalArray, PointerParam[Global : Global])
while(true);
// CHECK-NEXT: OpenACCComputeConstruct{{.*}} parallel
@@ -277,6 +328,57 @@ void TemplUses(T t, U u, T*PointerParam) {
// CHECK-NEXT: CXXBoolLiteralExpr
// CHECK-NEXT: NullStmt
+#pragma acc parallel copyin(t) pcopyin(readonly:NTTP, u) present_or_copyin(u[0:t])
+ while(true);
+ // CHECK-NEXT: OpenACCComputeConstruct{{.*}} parallel
+ // CHECK-NEXT: copyin clause
+ // CHECK-NEXT: DeclRefExpr{{.*}}'T' lvalue ParmVar{{.*}} 't' 'T'
+ // CHECK-NEXT: pcopyin clause : readonly
+ // CHECK-NEXT: DeclRefExpr{{.*}}'auto' lvalue NonTypeTemplateParm{{.*}} 'NTTP' 'auto &'
+ // CHECK-NEXT: DeclRefExpr{{.*}}'U' lvalue ParmVar{{.*}} 'u' 'U'
+ // CHECK-NEXT: present_or_copyin clause
+ // CHECK-NEXT: ArraySectionExpr
+ // CHECK-NEXT: DeclRefExpr{{.*}}'U' lvalue ParmVar{{.*}} 'u' 'U'
+ // CHECK-NEXT: IntegerLiteral{{.*}} 'int' 0
+ // CHECK-NEXT: DeclRefExpr{{.*}}'T' lvalue ParmVar{{.*}} 't' 'T'
+ // CHECK-NEXT: WhileStmt
+ // CHECK-NEXT: CXXBoolLiteralExpr
+ // CHECK-NEXT: NullStmt
+
+#pragma acc parallel copyout(t) pcopyout(zero:NTTP, u) present_or_copyout(u[0:t])
+ while(true);
+ // CHECK-NEXT: OpenACCComputeConstruct{{.*}} parallel
+ // CHECK-NEXT: copyout clause
+ // CHECK-NEXT: DeclRefExpr{{.*}}'T' lvalue ParmVar{{.*}} 't' 'T'
+ // CHECK-NEXT: pcopyout clause : zero
+ // CHECK-NEXT: DeclRefExpr{{.*}}'auto' lvalue NonTypeTemplateParm{{.*}} 'NTTP' 'auto &'
+ // CHECK-NEXT: DeclRefExpr{{.*}}'U' lvalue ParmVar{{.*}} 'u' 'U'
+ // CHECK-NEXT: present_or_copyout clause
+ // CHECK-NEXT: ArraySectionExpr
+ // CHECK-NEXT: DeclRefExpr{{.*}}'U' lvalue ParmVar{{.*}} 'u' 'U'
+ // CHECK-NEXT: IntegerLiteral{{.*}} 'int' 0
+ // CHECK-NEXT: DeclRefExpr{{.*}}'T' lvalue ParmVar{{.*}} 't' 'T'
+ // CHECK-NEXT: WhileStmt
+ // CHECK-NEXT: CXXBoolLiteralExpr
+ // CHECK-NEXT: NullStmt
+
+#pragma acc parallel create(t) pcreate(zero: NTTP, u) present_or_create(u[0:t])
+ while(true);
+ // CHECK-NEXT: OpenACCComputeConstruct{{.*}} parallel
+ // CHECK-NEXT: create clause
+ // CHECK-NEXT: DeclRefExpr{{.*}}'T' lvalue ParmVar{{.*}} 't' 'T'
+ // CHECK-NEXT: pcreate clause : zero
+ // CHECK-NEXT: DeclRefExpr{{.*}}'auto' lvalue NonTypeTemplateParm{{.*}} 'NTTP' 'auto &'
+ // CHECK-NEXT: DeclRefExpr{{.*}}'U' lvalue ParmVar{{.*}} 'u' 'U'
+ // CHECK-NEXT: present_or_create clause
+ // CHECK-NEXT: ArraySectionExpr
+ // CHECK-NEXT: DeclRefExpr{{.*}}'U' lvalue ParmVar{{.*}} 'u' 'U'
+ // CHECK-NEXT: IntegerLiteral{{.*}} 'int' 0
+ // CHECK-NEXT: DeclRefExpr{{.*}}'T' lvalue ParmVar{{.*}} 't' 'T'
+ // CHECK-NEXT: WhileStmt
+ // CHECK-NEXT: CXXBoolLiteralExpr
+ // CHECK-NEXT: NullStmt
+
#pragma acc parallel private(u[0])
while(true);
// CHECK-NEXT: OpenACCComputeConstruct{{.*}} parallel
@@ -418,6 +520,66 @@ void TemplUses(T t, U u, T*PointerParam) {
// CHECK-NEXT: CXXBoolLiteralExpr
// CHECK-NEXT: NullStmt
+//#pragma acc parallel copyin(t) pcopyin(readonly:NTTP, u) present_or_copyin(u[0:t])
+ // CHECK-NEXT: OpenACCComputeConstruct{{.*}} parallel
+ // CHECK-NEXT: copyin clause
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int' lvalue ParmVar{{.*}} 't' 'int'
+ // CHECK-NEXT: pcopyin clause : readonly
+ // CHECK-NEXT: SubstNonTypeTemplateParmExpr{{.*}}'const unsigned int' lvalue
+ // CHECK-NEXT: NonTypeTemplateParmDecl{{.*}} referenced 'auto &' depth 0 index 0 NTTP
+ // CHECK-NEXT: DeclRefExpr{{.*}}'const unsigned int' lvalue Var{{.*}} 'CEVar' 'const unsigned int'
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int *' lvalue ParmVar{{.*}} 'u' 'int *'
+ // CHECK-NEXT: present_or_copyin clause
+ // CHECK-NEXT: ArraySectionExpr
+ // CHECK-NEXT: ImplicitCastExpr{{.*}} 'int *' <LValueToRValue>
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int *' lvalue ParmVar{{.*}} 'u' 'int *'
+ // CHECK-NEXT: IntegerLiteral{{.*}} 'int' 0
+ // CHECK-NEXT: ImplicitCastExpr{{.*}} 'int' <LValueToRValue>
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int' lvalue ParmVar{{.*}} 't' 'int'
+ // CHECK-NEXT: WhileStmt
+ // CHECK-NEXT: CXXBoolLiteralExpr
+ // CHECK-NEXT: NullStmt
+
+//#pragma acc parallel copyout(t) pcopyout(zero:NTTP, u) present_or_copyout(u[0:t])
+ // CHECK-NEXT: OpenACCComputeConstruct{{.*}} parallel
+ // CHECK-NEXT: copyout clause
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int' lvalue ParmVar{{.*}} 't' 'int'
+ // CHECK-NEXT: pcopyout clause : zero
+ // CHECK-NEXT: SubstNonTypeTemplateParmExpr{{.*}}'const unsigned int' lvalue
+ // CHECK-NEXT: NonTypeTemplateParmDecl{{.*}} referenced 'auto &' depth 0 index 0 NTTP
+ // CHECK-NEXT: DeclRefExpr{{.*}}'const unsigned int' lvalue Var{{.*}} 'CEVar' 'const unsigned int'
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int *' lvalue ParmVar{{.*}} 'u' 'int *'
+ // CHECK-NEXT: present_or_copyout clause
+ // CHECK-NEXT: ArraySectionExpr
+ // CHECK-NEXT: ImplicitCastExpr{{.*}} 'int *' <LValueToRValue>
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int *' lvalue ParmVar{{.*}} 'u' 'int *'
+ // CHECK-NEXT: IntegerLiteral{{.*}} 'int' 0
+ // CHECK-NEXT: ImplicitCastExpr{{.*}} 'int' <LValueToRValue>
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int' lvalue ParmVar{{.*}} 't' 'int'
+ // CHECK-NEXT: WhileStmt
+ // CHECK-NEXT: CXXBoolLiteralExpr
+ // CHECK-NEXT: NullStmt
+
+//#pragma acc parallel create(t) pcreate(zero: NTTP, u) present_or_create(u[0:t])
+ // CHECK-NEXT: OpenACCComputeConstruct{{.*}} parallel
+ // CHECK-NEXT: create clause
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int' lvalue ParmVar{{.*}} 't' 'int'
+ // CHECK-NEXT: pcreate clause : zero
+ // CHECK-NEXT: SubstNonTypeTemplateParmExpr{{.*}}'const unsigned int' lvalue
+ // CHECK-NEXT: NonTypeTemplateParmDecl{{.*}} referenced 'auto &' depth 0 index 0 NTTP
+ // CHECK-NEXT: DeclRefExpr{{.*}}'const unsigned int' lvalue Var{{.*}} 'CEVar' 'const unsigned int'
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int *' lvalue ParmVar{{.*}} 'u' 'int *'
+ // CHECK-NEXT: present_or_create clause
+ // CHECK-NEXT: ArraySectionExpr
+ // CHECK-NEXT: ImplicitCastExpr{{.*}} 'int *' <LValueToRValue>
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int *' lvalue ParmVar{{.*}} 'u' 'int *'
+ // CHECK-NEXT: IntegerLiteral{{.*}} 'int' 0
+ // CHECK-NEXT: ImplicitCastExpr{{.*}} 'int' <LValueToRValue>
+ // CHECK-NEXT: DeclRefExpr{{.*}}'int' lvalue ParmVar{{.*}} 't' 'int'
+ // CHECK-NEXT: WhileStmt
+ // CHECK-NEXT: CXXBoolLiteralExpr
+ // CHECK-NEXT: NullStmt
+
// #pragma acc parallel private(u[0])
// CHECK-NEXT: OpenACCComputeConstruct{{.*}} parallel
// CHECK-NEXT: private clause
diff --git a/clang/tools/libclang/CIndex.cpp b/clang/tools/libclang/CIndex.cpp
index c02545f76ed2ec..487f5785957685 100644
--- a/clang/tools/libclang/CIndex.cpp
+++ b/clang/tools/libclang/CIndex.cpp
@@ -2831,6 +2831,15 @@ void OpenACCClauseEnqueue::VisitNoCreateClause(const OpenACCNoCreateClause &C) {
void OpenACCClauseEnqueue::VisitCopyClause(const OpenACCCopyClause &C) {
VisitVarList(C);
}
+void OpenACCClauseEnqueue::VisitCopyInClause(const OpenACCCopyInClause &C) {
+ VisitVarList(C);
+}
+void OpenACCClauseEnqueue::VisitCopyOutClause(const OpenACCCopyOutClause &C) {
+ VisitVarList(C);
+}
+void OpenACCClauseEnqueue::VisitCreateClause(const OpenACCCreateClause &C) {
+ VisitVarList(C);
+}
} // namespace
void EnqueueVisitor::EnqueueChildren(const OpenACCClause *C) {
More information about the cfe-commits
mailing list