[clang] [OpenACC] Implement `self` clause for compute constructs (PR #88760)
via cfe-commits
cfe-commits at lists.llvm.org
Mon Apr 15 10:28:44 PDT 2024
llvmbot wrote:
<!--LLVM PR SUMMARY COMMENT-->
@llvm/pr-subscribers-clang-modules
Author: Erich Keane (erichkeane)
<details>
<summary>Changes</summary>
`self` clauses on compute constructs take an optional condition expression. We again limit the implementation to ONLY compute constructs to ensure we get all the rules correct for others. However, this one will be particularly complicated, as it takes a `var-list` for `update`, so when we get to that construct/clause combination, we need to do that as well.
This patch also furthers uses of the `OpenACCClauses.def` as it became useful while implementing this (as well as some other minor refactors as I went through).
Finally, `self` and `if` clauses have an interaction with each other, if an `if` clause evaluates to `true`, the `self` clause has no effect. While this is intended and can be used 'meaningfully', we are warning on this with a very granular warning, so that this edge case will be noticed by newer users, but can be disabled trivially.
---
Patch is 36.52 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/88760.diff
19 Files Affected:
- (modified) clang/include/clang/AST/OpenACCClause.h (+18-47)
- (modified) clang/include/clang/AST/StmtOpenACC.h (+1-3)
- (modified) clang/include/clang/Basic/DiagnosticSemaKinds.td (+4)
- (modified) clang/include/clang/Basic/OpenACCClauses.def (+1)
- (modified) clang/include/clang/Basic/OpenACCKinds.h (+6)
- (modified) clang/include/clang/Sema/SemaOpenACC.h (+15-3)
- (modified) clang/lib/AST/OpenACCClause.cpp (+26)
- (modified) clang/lib/AST/StmtProfile.cpp (+5)
- (modified) clang/lib/AST/TextNodeDumper.cpp (+1)
- (modified) clang/lib/Parse/ParseOpenACC.cpp (+11-4)
- (modified) clang/lib/Sema/SemaOpenACC.cpp (+63-8)
- (modified) clang/lib/Sema/TreeTransform.h (+74-26)
- (modified) clang/lib/Serialization/ASTReader.cpp (+6-1)
- (modified) clang/lib/Serialization/ASTWriter.cpp (+8-1)
- (modified) clang/test/ParserOpenACC/parse-clauses.c (+1-4)
- (modified) clang/test/SemaOpenACC/compute-construct-clause-ast.cpp (+91)
- (added) clang/test/SemaOpenACC/compute-construct-self-clause.c (+82)
- (added) clang/test/SemaOpenACC/compute-construct-self-clause.cpp (+99)
- (modified) clang/tools/libclang/CIndex.cpp (+4)
``````````diff
diff --git a/clang/include/clang/AST/OpenACCClause.h b/clang/include/clang/AST/OpenACCClause.h
index 401b8e904a1b7a..07587849eb1219 100644
--- a/clang/include/clang/AST/OpenACCClause.h
+++ b/clang/include/clang/AST/OpenACCClause.h
@@ -145,6 +145,17 @@ class OpenACCIfClause : public OpenACCClauseWithCondition {
SourceLocation EndLoc);
};
+/// A 'self' clause, which has an optional condition expression.
+class OpenACCSelfClause : public OpenACCClauseWithCondition {
+ OpenACCSelfClause(SourceLocation BeginLoc, SourceLocation LParenLoc,
+ Expr *ConditionExpr, SourceLocation EndLoc);
+
+public:
+ static OpenACCSelfClause *Create(const ASTContext &C, SourceLocation BeginLoc,
+ SourceLocation LParenLoc,
+ Expr *ConditionExpr, SourceLocation EndLoc);
+};
+
template <class Impl> class OpenACCClauseVisitor {
Impl &getDerived() { return static_cast<Impl &>(*this); }
@@ -159,53 +170,13 @@ template <class Impl> class OpenACCClauseVisitor {
return;
switch (C->getClauseKind()) {
- case OpenACCClauseKind::Default:
- VisitDefaultClause(*cast<OpenACCDefaultClause>(C));
- return;
- case OpenACCClauseKind::If:
- VisitIfClause(*cast<OpenACCIfClause>(C));
- return;
- case OpenACCClauseKind::Finalize:
- case OpenACCClauseKind::IfPresent:
- case OpenACCClauseKind::Seq:
- case OpenACCClauseKind::Independent:
- case OpenACCClauseKind::Auto:
- case OpenACCClauseKind::Worker:
- case OpenACCClauseKind::Vector:
- case OpenACCClauseKind::NoHost:
- case OpenACCClauseKind::Self:
- case OpenACCClauseKind::Copy:
- case OpenACCClauseKind::UseDevice:
- case OpenACCClauseKind::Attach:
- case OpenACCClauseKind::Delete:
- case OpenACCClauseKind::Detach:
- case OpenACCClauseKind::Device:
- case OpenACCClauseKind::DevicePtr:
- case OpenACCClauseKind::DeviceResident:
- case OpenACCClauseKind::FirstPrivate:
- case OpenACCClauseKind::Host:
- case OpenACCClauseKind::Link:
- case OpenACCClauseKind::NoCreate:
- case OpenACCClauseKind::Present:
- case OpenACCClauseKind::Private:
- case OpenACCClauseKind::CopyOut:
- case OpenACCClauseKind::CopyIn:
- case OpenACCClauseKind::Create:
- case OpenACCClauseKind::Reduction:
- case OpenACCClauseKind::Collapse:
- case OpenACCClauseKind::Bind:
- case OpenACCClauseKind::VectorLength:
- case OpenACCClauseKind::NumGangs:
- case OpenACCClauseKind::NumWorkers:
- case OpenACCClauseKind::DeviceNum:
- case OpenACCClauseKind::DefaultAsync:
- case OpenACCClauseKind::DeviceType:
- case OpenACCClauseKind::DType:
- case OpenACCClauseKind::Async:
- case OpenACCClauseKind::Tile:
- case OpenACCClauseKind::Gang:
- case OpenACCClauseKind::Wait:
- case OpenACCClauseKind::Invalid:
+#define VISIT_CLAUSE(CLAUSE_NAME) \
+ case OpenACCClauseKind::CLAUSE_NAME: \
+ Visit##CLAUSE_NAME##Clause(*cast<OpenACC##CLAUSE_NAME##Clause>(C)); \
+ return;
+#include "clang/Basic/OpenACCClauses.def"
+
+ default:
llvm_unreachable("Clause visitor not yet implemented");
}
llvm_unreachable("Invalid Clause kind");
diff --git a/clang/include/clang/AST/StmtOpenACC.h b/clang/include/clang/AST/StmtOpenACC.h
index 419cb6cada0bc7..66f8f844e0b29e 100644
--- a/clang/include/clang/AST/StmtOpenACC.h
+++ b/clang/include/clang/AST/StmtOpenACC.h
@@ -142,9 +142,7 @@ class OpenACCComputeConstruct final
Stmt *StructuredBlock)
: OpenACCAssociatedStmtConstruct(OpenACCComputeConstructClass, K, Start,
End, StructuredBlock) {
- assert((K == OpenACCDirectiveKind::Parallel ||
- K == OpenACCDirectiveKind::Serial ||
- K == OpenACCDirectiveKind::Kernels) &&
+ assert(isOpenACCComputeDirectiveKind(K) &&
"Only parallel, serial, and kernels constructs should be "
"represented by this type");
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 5ec0218aedfe86..44f802c0c28e84 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -12274,4 +12274,8 @@ def note_acc_branch_into_compute_construct
: Note<"invalid branch into OpenACC Compute Construct">;
def note_acc_branch_out_of_compute_construct
: Note<"invalid branch out of OpenACC Compute Construct">;
+def warn_acc_if_self_conflict
+ : Warning<"OpenACC construct 'self' has no effect when an 'if' clause "
+ "evaluates to true">,
+ InGroup<DiagGroup<"openacc-self-if-potential-conflict">>;
} // end of sema component.
diff --git a/clang/include/clang/Basic/OpenACCClauses.def b/clang/include/clang/Basic/OpenACCClauses.def
index 7fd2720e02ce22..378495d2c0909a 100644
--- a/clang/include/clang/Basic/OpenACCClauses.def
+++ b/clang/include/clang/Basic/OpenACCClauses.def
@@ -17,5 +17,6 @@
VISIT_CLAUSE(Default)
VISIT_CLAUSE(If)
+VISIT_CLAUSE(Self)
#undef VISIT_CLAUSE
diff --git a/clang/include/clang/Basic/OpenACCKinds.h b/clang/include/clang/Basic/OpenACCKinds.h
index 3414df99991701..e3f74178433285 100644
--- a/clang/include/clang/Basic/OpenACCKinds.h
+++ b/clang/include/clang/Basic/OpenACCKinds.h
@@ -146,6 +146,12 @@ inline llvm::raw_ostream &operator<<(llvm::raw_ostream &Out,
return printOpenACCDirectiveKind(Out, K);
}
+inline bool isOpenACCComputeDirectiveKind(OpenACCDirectiveKind K) {
+ return K == OpenACCDirectiveKind::Parallel ||
+ K == OpenACCDirectiveKind::Serial ||
+ K == OpenACCDirectiveKind::Kernels;
+}
+
enum class OpenACCAtomicKind {
Read,
Write,
diff --git a/clang/include/clang/Sema/SemaOpenACC.h b/clang/include/clang/Sema/SemaOpenACC.h
index c1fe0f5b9c0f6b..329dc3945fa2a6 100644
--- a/clang/include/clang/Sema/SemaOpenACC.h
+++ b/clang/include/clang/Sema/SemaOpenACC.h
@@ -44,7 +44,8 @@ class SemaOpenACC : public SemaBase {
Expr *ConditionExpr;
};
- std::variant<DefaultDetails, ConditionDetails> Details;
+ std::variant<std::monostate, DefaultDetails, ConditionDetails> Details =
+ std::monostate{};
public:
OpenACCParsedClause(OpenACCDirectiveKind DirKind,
@@ -72,8 +73,17 @@ class SemaOpenACC : public SemaBase {
}
Expr *getConditionExpr() {
- assert(ClauseKind == OpenACCClauseKind::If &&
+ assert((ClauseKind == OpenACCClauseKind::If ||
+ (ClauseKind == OpenACCClauseKind::Self &&
+ DirKind != OpenACCDirectiveKind::Update)) &&
"Parsed clause kind does not have a condition expr");
+
+ // 'self' has an optional ConditionExpr, so be tolerant of that. This will
+ // assert in variant otherwise.
+ if (ClauseKind == OpenACCClauseKind::Self &&
+ std::holds_alternative<std::monostate>(Details))
+ return nullptr;
+
return std::get<ConditionDetails>(Details).ConditionExpr;
}
@@ -87,7 +97,9 @@ class SemaOpenACC : public SemaBase {
}
void setConditionDetails(Expr *ConditionExpr) {
- assert(ClauseKind == OpenACCClauseKind::If &&
+ assert((ClauseKind == OpenACCClauseKind::If ||
+ (ClauseKind == OpenACCClauseKind::Self &&
+ DirKind != OpenACCDirectiveKind::Update)) &&
"Parsed clause kind does not have a condition expr");
// In C++ we can count on this being a 'bool', but in C this gets left as
// some sort of scalar that codegen will have to take care of converting.
diff --git a/clang/lib/AST/OpenACCClause.cpp b/clang/lib/AST/OpenACCClause.cpp
index dcb512cb514179..9c259c8f9bd0a1 100644
--- a/clang/lib/AST/OpenACCClause.cpp
+++ b/clang/lib/AST/OpenACCClause.cpp
@@ -48,6 +48,26 @@ OpenACCIfClause::OpenACCIfClause(SourceLocation BeginLoc,
"Condition expression type not scalar/dependent");
}
+OpenACCSelfClause *OpenACCSelfClause::Create(const ASTContext &C,
+ SourceLocation BeginLoc,
+ SourceLocation LParenLoc,
+ Expr *ConditionExpr,
+ SourceLocation EndLoc) {
+ void *Mem = C.Allocate(sizeof(OpenACCIfClause), alignof(OpenACCIfClause));
+ return new (Mem)
+ OpenACCSelfClause(BeginLoc, LParenLoc, ConditionExpr, EndLoc);
+}
+
+OpenACCSelfClause::OpenACCSelfClause(SourceLocation BeginLoc,
+ SourceLocation LParenLoc,
+ Expr *ConditionExpr, SourceLocation EndLoc)
+ : OpenACCClauseWithCondition(OpenACCClauseKind::Self, BeginLoc, LParenLoc,
+ ConditionExpr, EndLoc) {
+ assert((!ConditionExpr || ConditionExpr->isInstantiationDependent() ||
+ ConditionExpr->getType()->isScalarType()) &&
+ "Condition expression type not scalar/dependent");
+}
+
OpenACCClause::child_range OpenACCClause::children() {
switch (getClauseKind()) {
default:
@@ -72,3 +92,9 @@ void OpenACCClausePrinter::VisitDefaultClause(const OpenACCDefaultClause &C) {
void OpenACCClausePrinter::VisitIfClause(const OpenACCIfClause &C) {
OS << "if(" << C.getConditionExpr() << ")";
}
+
+void OpenACCClausePrinter::VisitSelfClause(const OpenACCSelfClause &C) {
+ OS << "self";
+ if (const Expr *CondExpr = C.getConditionExpr())
+ OS << "(" << CondExpr << ")";
+}
diff --git a/clang/lib/AST/StmtProfile.cpp b/clang/lib/AST/StmtProfile.cpp
index d2aac1e640380f..6b9292e1d0da39 100644
--- a/clang/lib/AST/StmtProfile.cpp
+++ b/clang/lib/AST/StmtProfile.cpp
@@ -2473,6 +2473,11 @@ void OpenACCClauseProfiler::VisitIfClause(const OpenACCIfClause &Clause) {
"if clause requires a valid condition expr");
Profiler.VisitStmt(Clause.getConditionExpr());
}
+
+void OpenACCClauseProfiler::VisitSelfClause(const OpenACCSelfClause &Clause) {
+ if (Clause.hasConditionExpr())
+ Profiler.VisitStmt(Clause.getConditionExpr());
+}
} // namespace
void StmtProfiler::VisitOpenACCComputeConstruct(
diff --git a/clang/lib/AST/TextNodeDumper.cpp b/clang/lib/AST/TextNodeDumper.cpp
index 688daa64d61974..ff5b3df2d6dfac 100644
--- a/clang/lib/AST/TextNodeDumper.cpp
+++ b/clang/lib/AST/TextNodeDumper.cpp
@@ -398,6 +398,7 @@ void TextNodeDumper::Visit(const OpenACCClause *C) {
OS << '(' << cast<OpenACCDefaultClause>(C)->getDefaultClauseKind() << ')';
break;
case OpenACCClauseKind::If:
+ case OpenACCClauseKind::Self:
// The condition expression will be printed as a part of the 'children',
// but print 'clause' here so it is clear what is happening from the dump.
OS << " clause";
diff --git a/clang/lib/Parse/ParseOpenACC.cpp b/clang/lib/Parse/ParseOpenACC.cpp
index 91f2b8afcf0c24..da7132b5c4226f 100644
--- a/clang/lib/Parse/ParseOpenACC.cpp
+++ b/clang/lib/Parse/ParseOpenACC.cpp
@@ -835,18 +835,23 @@ Parser::OpenACCClauseParseResult Parser::ParseOpenACCClauseParams(
case OpenACCClauseKind::Default: {
Token DefKindTok = getCurToken();
- if (expectIdentifierOrKeyword(*this))
- break;
+ if (expectIdentifierOrKeyword(*this)) {
+ Parens.skipToEnd();
+ return OpenACCCanContinue();
+ }
ConsumeToken();
OpenACCDefaultClauseKind DefKind =
getOpenACCDefaultClauseKind(DefKindTok);
- if (DefKind == OpenACCDefaultClauseKind::Invalid)
+ if (DefKind == OpenACCDefaultClauseKind::Invalid) {
Diag(DefKindTok, diag::err_acc_invalid_default_clause_kind);
- else
+ Parens.skipToEnd();
+ return OpenACCCanContinue();
+ } else {
ParsedClause.setDefaultDetails(DefKind);
+ }
break;
}
@@ -977,6 +982,8 @@ Parser::OpenACCClauseParseResult Parser::ParseOpenACCClauseParams(
case OpenACCClauseKind::Self: {
assert(DirKind != OpenACCDirectiveKind::Update);
ExprResult CondExpr = ParseOpenACCConditionExpr();
+ ParsedClause.setConditionDetails(CondExpr.isUsable() ? CondExpr.get()
+ : nullptr);
if (CondExpr.isInvalid()) {
Parens.skipToEnd();
diff --git a/clang/lib/Sema/SemaOpenACC.cpp b/clang/lib/Sema/SemaOpenACC.cpp
index 1249136c87650b..04d9925327a8a3 100644
--- a/clang/lib/Sema/SemaOpenACC.cpp
+++ b/clang/lib/Sema/SemaOpenACC.cpp
@@ -76,6 +76,19 @@ bool doesClauseApplyToDirective(OpenACCDirectiveKind DirectiveKind,
default:
return false;
}
+ case OpenACCClauseKind::Self:
+ switch (DirectiveKind) {
+ case OpenACCDirectiveKind::Parallel:
+ case OpenACCDirectiveKind::Serial:
+ case OpenACCDirectiveKind::Kernels:
+ case OpenACCDirectiveKind::Update:
+ case OpenACCDirectiveKind::ParallelLoop:
+ case OpenACCDirectiveKind::SerialLoop:
+ case OpenACCDirectiveKind::KernelsLoop:
+ return true;
+ default:
+ return false;
+ }
default:
// Do nothing so we can go to the 'unimplemented' diagnostic instead.
return true;
@@ -121,9 +134,7 @@ SemaOpenACC::ActOnClause(ArrayRef<const OpenACCClause *> ExistingClauses,
// 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 (Clause.getDirectiveKind() != OpenACCDirectiveKind::Parallel &&
- Clause.getDirectiveKind() != OpenACCDirectiveKind::Serial &&
- Clause.getDirectiveKind() != OpenACCDirectiveKind::Kernels)
+ if (!isOpenACCComputeDirectiveKind(Clause.getDirectiveKind()))
break;
// Don't add an invalid clause to the AST.
@@ -146,9 +157,7 @@ SemaOpenACC::ActOnClause(ArrayRef<const OpenACCClause *> ExistingClauses,
// 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 (Clause.getDirectiveKind() != OpenACCDirectiveKind::Parallel &&
- Clause.getDirectiveKind() != OpenACCDirectiveKind::Serial &&
- Clause.getDirectiveKind() != OpenACCDirectiveKind::Kernels)
+ if (!isOpenACCComputeDirectiveKind(Clause.getDirectiveKind()))
break;
// There is no prose in the standard that says duplicates aren't allowed,
@@ -160,12 +169,58 @@ SemaOpenACC::ActOnClause(ArrayRef<const OpenACCClause *> ExistingClauses,
// The parser has ensured that we have a proper condition expr, so there
// isn't really much to do here.
- // TODO OpenACC: When we implement 'self', this clauses causes us to
- // 'ignore' the self clause, so we should implement a warning here.
+ // If the 'if' clause is true, it makes the 'self' clause have no effect,
+ // diagnose that here.
+ // TODO OpenACC: When we add these two to other constructs, we might not
+ // want to warn on this (for example, 'update').
+ const auto *Itr =
+ llvm::find_if(ExistingClauses, [](const OpenACCClause *C) {
+ return C->getClauseKind() == OpenACCClauseKind::Self;
+ });
+ if (Itr != ExistingClauses.end()) {
+ Diag(Clause.getBeginLoc(), diag::warn_acc_if_self_conflict);
+ Diag((*Itr)->getBeginLoc(), diag::note_acc_previous_clause_here);
+ }
+
return OpenACCIfClause::Create(
getASTContext(), Clause.getBeginLoc(), Clause.getLParenLoc(),
Clause.getConditionExpr(), Clause.getEndLoc());
}
+
+ case OpenACCClauseKind::Self: {
+ // 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;
+
+ // TODO OpenACC: When we implement this for 'update', this takes a
+ // 'var-list' instead of a condition expression, so semantics/handling has
+ // to happen differently here.
+
+ // There is no prose in the standard that says duplicates aren't allowed,
+ // but this diagnostic is present in other compilers, as well as makes
+ // sense.
+ if (checkAlreadyHasClauseOfKind(*this, ExistingClauses, Clause))
+ return nullptr;
+
+ // If the 'if' clause is true, it makes the 'self' clause have no effect,
+ // diagnose that here.
+ // TODO OpenACC: When we add these two to other constructs, we might not
+ // want to warn on this (for example, 'update').
+ const auto *Itr =
+ llvm::find_if(ExistingClauses, [](const OpenACCClause *C) {
+ return C->getClauseKind() == OpenACCClauseKind::If;
+ });
+ if (Itr != ExistingClauses.end()) {
+ Diag(Clause.getBeginLoc(), diag::warn_acc_if_self_conflict);
+ Diag((*Itr)->getBeginLoc(), diag::note_acc_previous_clause_here);
+ }
+
+ return OpenACCSelfClause::Create(
+ getASTContext(), Clause.getBeginLoc(), Clause.getLParenLoc(),
+ Clause.getConditionExpr(), Clause.getEndLoc());
+ }
default:
break;
}
diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h
index fdf84c512c4931..d2ef6b153e4ab3 100644
--- a/clang/lib/Sema/TreeTransform.h
+++ b/clang/lib/Sema/TreeTransform.h
@@ -11080,6 +11080,77 @@ OMPClause *TreeTransform<Derived>::TransformOMPXBareClause(OMPXBareClause *C) {
//===----------------------------------------------------------------------===//
// OpenACC transformation
//===----------------------------------------------------------------------===//
+namespace {
+template <typename Derived>
+class OpenACCClauseTransform final
+ : public OpenACCClauseVisitor<OpenACCClauseTransform<Derived>> {
+ TreeTransform<Derived> &Self;
+ SemaOpenACC::OpenACCParsedClause &ParsedClause;
+ OpenACCClause *NewClause = nullptr;
+
+public:
+ OpenACCClauseTransform(TreeTransform<Derived> &Self,
+ SemaOpenACC::OpenACCParsedClause &PC)
+ : Self(Self), ParsedClause(PC) {}
+
+ OpenACCClause *CreatedClause() const { return NewClause; }
+
+#define VISIT_CLAUSE(CLAUSE_NAME) \
+ void Visit##CLAUSE_NAME##Clause(const OpenACC##CLAUSE_NAME##Clause &Clause);
+#include "clang/Basic/OpenACCClauses.def"
+};
+
+template <typename Derived>
+void OpenACCClauseTransform<Derived>::VisitDefaultClause(
+ const OpenACCDefaultClause &C) {
+ ParsedClause.setDefaultDetails(C.getDefaultClauseKind());
+
+ NewClause = OpenACCDefaultClause::Create(
+ Self.getSema().getASTContext(), ParsedClause.getDefaultClauseKind(),
+ ParsedClause.getBeginLoc(), ParsedClause.getLParenLoc(),
+ ParsedClause.getEndLoc());
+}
+
+template <typename Derived>
+void OpenACCClauseTransform<Derived>::VisitIfClause(const OpenACCIfClause &C) {
+ Expr *Cond = const_cast<Expr *>(C.getConditionExpr());
+ assert(Cond && "If constructed with invalid Condition");
+ Sema::ConditionResult Res = Self.TransformCondition(
+ Cond->getExprLoc(), /*Var=*/nullptr, Cond, Sema::ConditionKind::Boolean);
+
+ if (Res.isInvalid() || !Res.get().second)
+ return;
+
+ ParsedClause.setConditionDetails(Res.get().second);
+
+ NewClause = OpenACCIfClause::Create(
+ Self.getSema().getASTContext(), ParsedClause.getBeginLoc(),
+ ParsedClause.getLParenLoc(), ParsedClause.getConditionExpr(),
+ ParsedClause.getEndLoc());
+}
+
+template <typename Derived>
+void OpenACCClauseTransform<Derived>::VisitSelfClause(
+ const OpenACCSelfClause &C) {
+
+ if (C.hasConditionExpr()) {
+ Expr *Cond = const_cast<Expr *>(C.getConditionExpr());
+ Sema::ConditionResult Res =
+ Self.TransformCondition(Cond->getExprLoc(), /*Var=*/nullptr, Cond,
+ Sema::ConditionKind::Boolean);
+
+ if (Res.isInvalid() || !Res.get().second)
+ return;
+
+ ParsedClause.setConditionDetails(Res.get().second);
+ }
+
+ NewClause = OpenACCSelfClause::Create(
+ Self.getSema().getASTContext(), ParsedClause.getBeginLoc(),
+ ParsedClause.getLParenLoc(), ParsedClause.getConditionExpr(),
+ ParsedClause.getEndLoc());
+}
+} // namespace
template <typename Derived>
OpenACCClause *TreeTransform<Derived>::TransformOpenACCClause(
ArrayRef<con...
[truncated]
``````````
</details>
https://github.com/llvm/llvm-project/pull/88760
More information about the cfe-commits
mailing list