Author: erichkeane Date: 2025-01-06T11:03:18-08:00 New Revision: ff24e9a19e3db330dd6412aac9d1d6c0b416697f
URL: https://github.com/llvm/llvm-project/commit/ff24e9a19e3db330dd6412aac9d1d6c0b416697f DIFF: https://github.com/llvm/llvm-project/commit/ff24e9a19e3db330dd6412aac9d1d6c0b416697f.diff LOG: [OpenACC] Implement 'default_async' sema A fairly simple one, only valid on the 'set' construct, this clause takes an int expression. Most of the work was already done as a part of parsing, so this patch ends up being a lot of infrastructure. Added: Modified: clang/include/clang/AST/OpenACCClause.h clang/include/clang/Basic/OpenACCClauses.def 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-set-construct.cpp clang/test/ParserOpenACC/parse-clauses.c clang/test/SemaOpenACC/combined-construct-auto_seq_independent-clauses.c clang/test/SemaOpenACC/combined-construct-device_type-clause.c clang/test/SemaOpenACC/compute-construct-device_type-clause.c clang/test/SemaOpenACC/loop-construct-auto_seq_independent-clauses.c clang/test/SemaOpenACC/loop-construct-device_type-clause.c clang/test/SemaOpenACC/set-construct-ast.cpp clang/test/SemaOpenACC/set-construct.cpp clang/tools/libclang/CIndex.cpp Removed: ################################################################################ diff --git a/clang/include/clang/AST/OpenACCClause.h b/clang/include/clang/AST/OpenACCClause.h index b4747c68a1dfd8..adc5e48583d003 100644 --- a/clang/include/clang/AST/OpenACCClause.h +++ b/clang/include/clang/AST/OpenACCClause.h @@ -633,6 +633,19 @@ class OpenACCDeviceNumClause : public OpenACCClauseWithSingleIntExpr { SourceLocation EndLoc); }; +class OpenACCDefaultAsyncClause : public OpenACCClauseWithSingleIntExpr { + OpenACCDefaultAsyncClause(SourceLocation BeginLoc, SourceLocation LParenLoc, + Expr *IntExpr, SourceLocation EndLoc); + +public: + static bool classof(const OpenACCClause *C) { + return C->getClauseKind() == OpenACCClauseKind::DefaultAsync; + } + static OpenACCDefaultAsyncClause * + Create(const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, + Expr *IntExpr, SourceLocation EndLoc); +}; + /// Represents a 'collapse' clause on a 'loop' construct. This clause takes an /// integer constant expression 'N' that represents how deep to collapse the /// construct. It also takes an optional 'force' tag that permits intervening diff --git a/clang/include/clang/Basic/OpenACCClauses.def b/clang/include/clang/Basic/OpenACCClauses.def index 1b619bc0dfd4c1..d6fb015c64913a 100644 --- a/clang/include/clang/Basic/OpenACCClauses.def +++ b/clang/include/clang/Basic/OpenACCClauses.def @@ -38,6 +38,7 @@ VISIT_CLAUSE(Create) CLAUSE_ALIAS(PCreate, Create, true) CLAUSE_ALIAS(PresentOrCreate, Create, true) VISIT_CLAUSE(Default) +VISIT_CLAUSE(DefaultAsync) VISIT_CLAUSE(Delete) VISIT_CLAUSE(Detach) VISIT_CLAUSE(DeviceNum) diff --git a/clang/include/clang/Sema/SemaOpenACC.h b/clang/include/clang/Sema/SemaOpenACC.h index addc33bf3c76bd..03abf4ab2cec87 100644 --- a/clang/include/clang/Sema/SemaOpenACC.h +++ b/clang/include/clang/Sema/SemaOpenACC.h @@ -297,6 +297,7 @@ class SemaOpenACC : public SemaBase { ClauseKind == OpenACCClauseKind::NumWorkers || ClauseKind == OpenACCClauseKind::Async || ClauseKind == OpenACCClauseKind::DeviceNum || + ClauseKind == OpenACCClauseKind::DefaultAsync || ClauseKind == OpenACCClauseKind::Tile || ClauseKind == OpenACCClauseKind::Worker || ClauseKind == OpenACCClauseKind::Vector || @@ -349,6 +350,7 @@ class SemaOpenACC : public SemaBase { ClauseKind == OpenACCClauseKind::NumWorkers || ClauseKind == OpenACCClauseKind::Async || ClauseKind == OpenACCClauseKind::DeviceNum || + ClauseKind == OpenACCClauseKind::DefaultAsync || ClauseKind == OpenACCClauseKind::Tile || ClauseKind == OpenACCClauseKind::Gang || ClauseKind == OpenACCClauseKind::Worker || @@ -486,6 +488,7 @@ class SemaOpenACC : public SemaBase { ClauseKind == OpenACCClauseKind::NumWorkers || ClauseKind == OpenACCClauseKind::Async || ClauseKind == OpenACCClauseKind::DeviceNum || + ClauseKind == OpenACCClauseKind::DefaultAsync || ClauseKind == OpenACCClauseKind::Tile || ClauseKind == OpenACCClauseKind::Worker || ClauseKind == OpenACCClauseKind::Vector || @@ -498,6 +501,7 @@ class SemaOpenACC : public SemaBase { ClauseKind == OpenACCClauseKind::NumWorkers || ClauseKind == OpenACCClauseKind::Async || ClauseKind == OpenACCClauseKind::DeviceNum || + ClauseKind == OpenACCClauseKind::DefaultAsync || ClauseKind == OpenACCClauseKind::Tile || ClauseKind == OpenACCClauseKind::Worker || ClauseKind == OpenACCClauseKind::Vector || diff --git a/clang/lib/AST/OpenACCClause.cpp b/clang/lib/AST/OpenACCClause.cpp index d69fab5cc413cf..76fea1fd47d217 100644 --- a/clang/lib/AST/OpenACCClause.cpp +++ b/clang/lib/AST/OpenACCClause.cpp @@ -47,6 +47,7 @@ bool OpenACCClauseWithSingleIntExpr::classof(const OpenACCClause *C) { return OpenACCNumWorkersClause::classof(C) || OpenACCVectorLengthClause::classof(C) || OpenACCDeviceNumClause::classof(C) || + OpenACCDefaultAsyncClause::classof(C) || OpenACCVectorClause::classof(C) || OpenACCWorkerClause::classof(C) || OpenACCCollapseClause::classof(C) || OpenACCAsyncClause::classof(C); } @@ -239,6 +240,27 @@ OpenACCDeviceNumClause *OpenACCDeviceNumClause::Create(const ASTContext &C, return new (Mem) OpenACCDeviceNumClause(BeginLoc, LParenLoc, IntExpr, EndLoc); } +OpenACCDefaultAsyncClause::OpenACCDefaultAsyncClause(SourceLocation BeginLoc, + SourceLocation LParenLoc, + Expr *IntExpr, + SourceLocation EndLoc) + : OpenACCClauseWithSingleIntExpr(OpenACCClauseKind::DefaultAsync, BeginLoc, + LParenLoc, IntExpr, EndLoc) { + assert((IntExpr->isInstantiationDependent() || + IntExpr->getType()->isIntegerType()) && + "default_async expression type not scalar/dependent"); +} + +OpenACCDefaultAsyncClause * +OpenACCDefaultAsyncClause::Create(const ASTContext &C, SourceLocation BeginLoc, + SourceLocation LParenLoc, Expr *IntExpr, + SourceLocation EndLoc) { + void *Mem = C.Allocate(sizeof(OpenACCDefaultAsyncClause), + alignof(OpenACCDefaultAsyncClause)); + return new (Mem) + OpenACCDefaultAsyncClause(BeginLoc, LParenLoc, IntExpr, EndLoc); +} + OpenACCWaitClause *OpenACCWaitClause::Create( const ASTContext &C, SourceLocation BeginLoc, SourceLocation LParenLoc, Expr *DevNumExpr, SourceLocation QueuesLoc, ArrayRef<Expr *> QueueIdExprs, @@ -575,6 +597,13 @@ void OpenACCClausePrinter::VisitDeviceNumClause( OS << ")"; } +void OpenACCClausePrinter::VisitDefaultAsyncClause( + const OpenACCDefaultAsyncClause &C) { + OS << "default_async("; + printExpr(C.getIntExpr()); + OS << ")"; +} + void OpenACCClausePrinter::VisitAsyncClause(const OpenACCAsyncClause &C) { OS << "async"; if (C.hasIntExpr()) { diff --git a/clang/lib/AST/StmtProfile.cpp b/clang/lib/AST/StmtProfile.cpp index f516e67e4b8614..150b92ef6a1abd 100644 --- a/clang/lib/AST/StmtProfile.cpp +++ b/clang/lib/AST/StmtProfile.cpp @@ -2650,6 +2650,11 @@ void OpenACCClauseProfiler::VisitDeviceNumClause( Profiler.VisitStmt(Clause.getIntExpr()); } +void OpenACCClauseProfiler::VisitDefaultAsyncClause( + const OpenACCDefaultAsyncClause &Clause) { + Profiler.VisitStmt(Clause.getIntExpr()); +} + void OpenACCClauseProfiler::VisitWorkerClause( const OpenACCWorkerClause &Clause) { if (Clause.hasIntExpr()) diff --git a/clang/lib/AST/TextNodeDumper.cpp b/clang/lib/AST/TextNodeDumper.cpp index d74020048060de..00e3af3e811259 100644 --- a/clang/lib/AST/TextNodeDumper.cpp +++ b/clang/lib/AST/TextNodeDumper.cpp @@ -414,6 +414,7 @@ void TextNodeDumper::Visit(const OpenACCClause *C) { case OpenACCClauseKind::Detach: case OpenACCClauseKind::Delete: case OpenACCClauseKind::DeviceNum: + case OpenACCClauseKind::DefaultAsync: case OpenACCClauseKind::DevicePtr: case OpenACCClauseKind::Finalize: case OpenACCClauseKind::FirstPrivate: diff --git a/clang/lib/Parse/ParseOpenACC.cpp b/clang/lib/Parse/ParseOpenACC.cpp index ede409096548c2..a9deae74cf27c6 100644 --- a/clang/lib/Parse/ParseOpenACC.cpp +++ b/clang/lib/Parse/ParseOpenACC.cpp @@ -1082,13 +1082,7 @@ Parser::OpenACCClauseParseResult Parser::ParseOpenACCClauseParams( return OpenACCCanContinue(); } - // TODO OpenACC: as we implement the 'rest' of the above, this 'if' should - // be removed leaving just the 'setIntExprDetails'. - if (ClauseKind == OpenACCClauseKind::NumWorkers || - ClauseKind == OpenACCClauseKind::DeviceNum || - ClauseKind == OpenACCClauseKind::VectorLength) - ParsedClause.setIntExprDetails(IntExpr.get()); - + ParsedClause.setIntExprDetails(IntExpr.get()); break; } case OpenACCClauseKind::DType: diff --git a/clang/lib/Sema/SemaOpenACC.cpp b/clang/lib/Sema/SemaOpenACC.cpp index a23bdcf001c506..846b1966e765a9 100644 --- a/clang/lib/Sema/SemaOpenACC.cpp +++ b/clang/lib/Sema/SemaOpenACC.cpp @@ -463,6 +463,14 @@ bool doesClauseApplyToDirective(OpenACCDirectiveKind DirectiveKind, return false; } } + case OpenACCClauseKind::DefaultAsync: { + switch (DirectiveKind) { + case OpenACCDirectiveKind::Set: + return true; + default: + return false; + } + } } default: @@ -977,6 +985,20 @@ OpenACCClause *SemaOpenACCClauseVisitor::VisitDeviceNumClause( Clause.getEndLoc()); } +OpenACCClause *SemaOpenACCClauseVisitor::VisitDefaultAsyncClause( + SemaOpenACC::OpenACCParsedClause &Clause) { + // OpenACC 3.3 2.14.3: Two instances of the same clause may not appear on the + // same directive. + if (checkAlreadyHasClauseOfKind(SemaRef, ExistingClauses, Clause)) + return nullptr; + + assert(Clause.getNumIntExprs() == 1 && + "Invalid number of expressions for default_async"); + return OpenACCDefaultAsyncClause::Create( + Ctx, Clause.getBeginLoc(), Clause.getLParenLoc(), Clause.getIntExprs()[0], + Clause.getEndLoc()); +} + OpenACCClause *SemaOpenACCClauseVisitor::VisitPrivateClause( SemaOpenACC::OpenACCParsedClause &Clause) { // ActOnVar ensured that everything is a valid variable reference, so there @@ -3681,12 +3703,9 @@ bool SemaOpenACC::ActOnStartStmtDirective( if (K == OpenACCDirectiveKind::Set && llvm::find_if( Clauses, - llvm::IsaPred</*OpenACCDefaultAsyncClause,*/ // TODO: ERICH Need to - // implement. - // DefaultAsyncClause - // then enable this. - OpenACCDeviceNumClause, OpenACCDeviceTypeClause, - OpenACCIfClause>) == Clauses.end()) + llvm::IsaPred<OpenACCDefaultAsyncClause, OpenACCDeviceNumClause, + OpenACCDeviceTypeClause, OpenACCIfClause>) == + Clauses.end()) return Diag(StartLoc, diag::err_acc_construct_one_clause_of) << K << GetListOfClauses({OpenACCClauseKind::DefaultAsync, diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h index 1d25efb1d45c92..c40ff8b0d20111 100644 --- a/clang/lib/Sema/TreeTransform.h +++ b/clang/lib/Sema/TreeTransform.h @@ -11909,6 +11909,29 @@ void OpenACCClauseTransform<Derived>::VisitDeviceNumClause ( ParsedClause.getEndLoc()); } +template <typename Derived> +void OpenACCClauseTransform<Derived>::VisitDefaultAsyncClause( + const OpenACCDefaultAsyncClause &C) { + Expr *IntExpr = const_cast<Expr *>(C.getIntExpr()); + assert(IntExpr && "default_async clause constructed with invalid int expr"); + + ExprResult Res = Self.TransformExpr(IntExpr); + if (!Res.isUsable()) + return; + + Res = Self.getSema().OpenACC().ActOnIntExpr(OpenACCDirectiveKind::Invalid, + C.getClauseKind(), + C.getBeginLoc(), Res.get()); + if (!Res.isUsable()) + return; + + ParsedClause.setIntExprDetails(Res.get()); + NewClause = OpenACCDefaultAsyncClause::Create( + Self.getSema().getASTContext(), ParsedClause.getBeginLoc(), + ParsedClause.getLParenLoc(), ParsedClause.getIntExprs()[0], + ParsedClause.getEndLoc()); +} + template <typename Derived> void OpenACCClauseTransform<Derived>::VisitVectorLengthClause( const OpenACCVectorLengthClause &C) { diff --git a/clang/lib/Serialization/ASTReader.cpp b/clang/lib/Serialization/ASTReader.cpp index fccd79bf745203..0c82e540047f8d 100644 --- a/clang/lib/Serialization/ASTReader.cpp +++ b/clang/lib/Serialization/ASTReader.cpp @@ -12412,6 +12412,12 @@ OpenACCClause *ASTRecordReader::readOpenACCClause() { return OpenACCDeviceNumClause::Create(getContext(), BeginLoc, LParenLoc, IntExpr, EndLoc); } + case OpenACCClauseKind::DefaultAsync: { + SourceLocation LParenLoc = readSourceLocation(); + Expr *IntExpr = readSubExpr(); + return OpenACCDefaultAsyncClause::Create(getContext(), BeginLoc, LParenLoc, + IntExpr, EndLoc); + } case OpenACCClauseKind::VectorLength: { SourceLocation LParenLoc = readSourceLocation(); Expr *IntExpr = readSubExpr(); @@ -12601,7 +12607,6 @@ OpenACCClause *ASTRecordReader::readOpenACCClause() { case OpenACCClauseKind::Host: case OpenACCClauseKind::Link: case OpenACCClauseKind::Bind: - case OpenACCClauseKind::DefaultAsync: case OpenACCClauseKind::Invalid: llvm_unreachable("Clause serialization not yet implemented"); } diff --git a/clang/lib/Serialization/ASTWriter.cpp b/clang/lib/Serialization/ASTWriter.cpp index 7fa9322e7551f7..39f8b0fd5ba0f9 100644 --- a/clang/lib/Serialization/ASTWriter.cpp +++ b/clang/lib/Serialization/ASTWriter.cpp @@ -8340,6 +8340,12 @@ void ASTRecordWriter::writeOpenACCClause(const OpenACCClause *C) { AddStmt(const_cast<Expr*>(DNC->getIntExpr())); return; } + case OpenACCClauseKind::DefaultAsync: { + const auto *DAC = cast<OpenACCDefaultAsyncClause>(C); + writeSourceLocation(DAC->getLParenLoc()); + AddStmt(const_cast<Expr *>(DAC->getIntExpr())); + return; + } case OpenACCClauseKind::NumWorkers: { const auto *NWC = cast<OpenACCNumWorkersClause>(C); writeSourceLocation(NWC->getLParenLoc()); @@ -8536,7 +8542,6 @@ void ASTRecordWriter::writeOpenACCClause(const OpenACCClause *C) { case OpenACCClauseKind::Host: case OpenACCClauseKind::Link: case OpenACCClauseKind::Bind: - case OpenACCClauseKind::DefaultAsync: case OpenACCClauseKind::Invalid: llvm_unreachable("Clause serialization not yet implemented"); } diff --git a/clang/test/AST/ast-print-openacc-set-construct.cpp b/clang/test/AST/ast-print-openacc-set-construct.cpp index 11e17bd274ea15..a801ae16739e4b 100644 --- a/clang/test/AST/ast-print-openacc-set-construct.cpp +++ b/clang/test/AST/ast-print-openacc-set-construct.cpp @@ -3,19 +3,18 @@ unsigned Int; void uses() { -// CHECK: #pragma acc set if(Int == 5) device_type(I) device_num(Int) +// CHECK: #pragma acc set default_async(Int) if(Int == 5) device_type(I) device_num(Int) #pragma acc set default_async(Int) if (Int == 5) device_type(I) device_num(Int) -// CHECK: #pragma acc set device_type(I) device_num(Int) +// CHECK: #pragma acc set default_async(Int) device_type(I) device_num(Int) #pragma acc set default_async(Int) device_type(I) device_num(Int) -// CHECK: #pragma acc set if(Int == 5) device_num(Int) +// CHECK: #pragma acc set default_async(Int) if(Int == 5) device_num(Int) #pragma acc set default_async(Int) if (Int == 5) device_num(Int) -// CHECK: #pragma acc set if(Int == 5) device_type(I) +// CHECK: #pragma acc set default_async(Int) if(Int == 5) device_type(I) #pragma acc set default_async(Int) if (Int == 5) device_type(I) // CHECK: #pragma acc set if(Int == 5) device_type(I) device_num(Int) #pragma acc set if (Int == 5) device_type(I) device_num(Int) -// CHECK-NOT: default_async(Int) -// TODO: OpenACC: Enable this when we have default_async implemented. -// #pragma acc set default_async(Int) +// CHECK: #pragma acc set default_async(Int) +#pragma acc set default_async(Int) // CHECK: #pragma acc set if(Int == 5) #pragma acc set if (Int == 5) // CHECK: #pragma acc set device_type(I) diff --git a/clang/test/ParserOpenACC/parse-clauses.c b/clang/test/ParserOpenACC/parse-clauses.c index 748931072bbf03..27970615c95811 100644 --- a/clang/test/ParserOpenACC/parse-clauses.c +++ b/clang/test/ParserOpenACC/parse-clauses.c @@ -837,12 +837,8 @@ void IntExprParsing() { // expected-error@+1{{OpenACC 'set' construct must have at least one 'default_async', 'device_num', 'device_type' or 'if' clause}} #pragma acc set default_async(5, 4) - // expected-error@+2{{OpenACC 'set' construct must have at least one 'default_async', 'device_num', 'device_type' or 'if' clause}} - // expected-warning@+1{{OpenACC clause 'default_async' not yet implemented, clause ignored}} #pragma acc set default_async(5) - // expected-error@+2{{OpenACC 'set' construct must have at least one 'default_async', 'device_num', 'device_type' or 'if' clause}} - // expected-warning@+1{{OpenACC clause 'default_async' not yet implemented, clause ignored}} #pragma acc set default_async(returns_int()) diff --git a/clang/test/SemaOpenACC/combined-construct-auto_seq_independent-clauses.c b/clang/test/SemaOpenACC/combined-construct-auto_seq_independent-clauses.c index f37c1d7e729280..9a98f5e1659b8d 100644 --- a/clang/test/SemaOpenACC/combined-construct-auto_seq_independent-clauses.c +++ b/clang/test/SemaOpenACC/combined-construct-auto_seq_independent-clauses.c @@ -137,7 +137,7 @@ void uses() { // expected-error@+1{{OpenACC 'device_num' clause is not valid on 'parallel loop' directive}} #pragma acc parallel loop auto device_num(1) for(unsigned i = 0; i < 5; ++i); - // expected-warning@+1{{OpenACC clause 'default_async' not yet implemented}} + // expected-error@+1{{OpenACC 'default_async' clause is not valid on 'parallel loop' directive}} #pragma acc parallel loop auto default_async(1) for(unsigned i = 0; i < 5; ++i); #pragma acc parallel loop auto device_type(*) @@ -254,7 +254,7 @@ void uses() { // expected-error@+1{{OpenACC 'device_num' clause is not valid on 'parallel loop' directive}} #pragma acc parallel loop device_num(1) auto for(unsigned i = 0; i < 5; ++i); - // expected-warning@+1{{OpenACC clause 'default_async' not yet implemented}} + // expected-error@+1{{OpenACC 'default_async' clause is not valid on 'parallel loop' directive}} #pragma acc parallel loop default_async(1) auto for(unsigned i = 0; i < 5; ++i); #pragma acc parallel loop device_type(*) auto @@ -372,7 +372,7 @@ void uses() { // expected-error@+1{{OpenACC 'device_num' clause is not valid on 'parallel loop' directive}} #pragma acc parallel loop independent device_num(1) for(unsigned i = 0; i < 5; ++i); - // expected-warning@+1{{OpenACC clause 'default_async' not yet implemented}} + // expected-error@+1{{OpenACC 'default_async' clause is not valid on 'parallel loop' directive}} #pragma acc parallel loop independent default_async(1) for(unsigned i = 0; i < 5; ++i); #pragma acc parallel loop independent device_type(*) @@ -489,7 +489,7 @@ void uses() { // expected-error@+1{{OpenACC 'device_num' clause is not valid on 'parallel loop' directive}} #pragma acc parallel loop device_num(1) independent for(unsigned i = 0; i < 5; ++i); - // expected-warning@+1{{OpenACC clause 'default_async' not yet implemented}} + // expected-error@+1{{OpenACC 'default_async' clause is not valid on 'parallel loop' directive}} #pragma acc parallel loop default_async(1) independent for(unsigned i = 0; i < 5; ++i); #pragma acc parallel loop device_type(*) independent @@ -615,7 +615,7 @@ void uses() { // expected-error@+1{{OpenACC 'device_num' clause is not valid on 'parallel loop' directive}} #pragma acc parallel loop seq device_num(1) for(unsigned i = 0; i < 5; ++i); - // expected-warning@+1{{OpenACC clause 'default_async' not yet implemented}} + // expected-error@+1{{OpenACC 'default_async' clause is not valid on 'parallel loop' directive}} #pragma acc parallel loop seq default_async(1) for(unsigned i = 0; i < 5; ++i); #pragma acc parallel loop seq device_type(*) @@ -738,7 +738,7 @@ void uses() { // expected-error@+1{{OpenACC 'device_num' clause is not valid on 'parallel loop' directive}} #pragma acc parallel loop device_num(1) seq for(unsigned i = 0; i < 5; ++i); - // expected-warning@+1{{OpenACC clause 'default_async' not yet implemented}} + // expected-error@+1{{OpenACC 'default_async' clause is not valid on 'parallel loop' directive}} #pragma acc parallel loop default_async(1) seq for(unsigned i = 0; i < 5; ++i); #pragma acc parallel loop device_type(*) seq diff --git a/clang/test/SemaOpenACC/combined-construct-device_type-clause.c b/clang/test/SemaOpenACC/combined-construct-device_type-clause.c index 50612c2a4685e5..8072ae7de4ffc0 100644 --- a/clang/test/SemaOpenACC/combined-construct-device_type-clause.c +++ b/clang/test/SemaOpenACC/combined-construct-device_type-clause.c @@ -193,8 +193,7 @@ void uses() { // expected-error@+1{{OpenACC 'device_num' clause is not valid on 'serial loop' directive}} #pragma acc serial loop device_type(*) device_num(1) for(int i = 0; i < 5; ++i); - // expected-error@+2{{OpenACC clause 'default_async' may not follow a 'device_type' clause in a 'serial loop' construct}} - // expected-note@+1{{previous clause is here}} + // expected-error@+1{{OpenACC 'default_async' clause is not valid on 'serial loop' directive}} #pragma acc serial loop device_type(*) default_async(1) for(int i = 0; i < 5; ++i); #pragma acc parallel loop device_type(*) async diff --git a/clang/test/SemaOpenACC/compute-construct-device_type-clause.c b/clang/test/SemaOpenACC/compute-construct-device_type-clause.c index bbad68c425f3eb..33f433ce4c519f 100644 --- a/clang/test/SemaOpenACC/compute-construct-device_type-clause.c +++ b/clang/test/SemaOpenACC/compute-construct-device_type-clause.c @@ -198,8 +198,7 @@ void uses() { // expected-error@+1{{OpenACC 'device_num' clause is not valid on 'kernels' directive}} #pragma acc kernels device_type(*) device_num(1) while(1); - // expected-error@+2{{OpenACC clause 'default_async' may not follow a 'device_type' clause in a 'kernels' construct}} - // expected-note@+1{{previous clause is here}} + // expected-error@+1{{OpenACC 'default_async' clause is not valid on 'kernels' directive}} #pragma acc kernels device_type(*) default_async(1) while(1); #pragma acc kernels device_type(*) async diff --git a/clang/test/SemaOpenACC/loop-construct-auto_seq_independent-clauses.c b/clang/test/SemaOpenACC/loop-construct-auto_seq_independent-clauses.c index d75d6abb99f6f8..d9a4c61a81c7d7 100644 --- a/clang/test/SemaOpenACC/loop-construct-auto_seq_independent-clauses.c +++ b/clang/test/SemaOpenACC/loop-construct-auto_seq_independent-clauses.c @@ -152,7 +152,7 @@ void uses() { // expected-error@+1{{OpenACC 'device_num' clause is not valid on 'loop' directive}} #pragma acc loop auto device_num(1) for(unsigned i = 0; i < 5; ++i); - // expected-warning@+1{{OpenACC clause 'default_async' not yet implemented}} + // expected-error@+1{{OpenACC 'default_async' clause is not valid on 'loop' directive}} #pragma acc loop auto default_async(1) for(unsigned i = 0; i < 5; ++i); #pragma acc loop auto device_type(*) @@ -286,7 +286,7 @@ void uses() { // expected-error@+1{{OpenACC 'device_num' clause is not valid on 'loop' directive}} #pragma acc loop device_num(1) auto for(unsigned i = 0; i < 5; ++i); - // expected-warning@+1{{OpenACC clause 'default_async' not yet implemented}} + // expected-error@+1{{OpenACC 'default_async' clause is not valid on 'loop' directive}} #pragma acc loop default_async(1) auto for(unsigned i = 0; i < 5; ++i); #pragma acc loop device_type(*) auto @@ -421,7 +421,7 @@ void uses() { // expected-error@+1{{OpenACC 'device_num' clause is not valid on 'loop' directive}} #pragma acc loop independent device_num(1) for(unsigned i = 0; i < 5; ++i); - // expected-warning@+1{{OpenACC clause 'default_async' not yet implemented}} + // expected-error@+1{{OpenACC 'default_async' clause is not valid on 'loop' directive}} #pragma acc loop independent default_async(1) for(unsigned i = 0; i < 5; ++i); #pragma acc loop independent device_type(*) @@ -555,7 +555,7 @@ void uses() { // expected-error@+1{{OpenACC 'device_num' clause is not valid on 'loop' directive}} #pragma acc loop device_num(1) independent for(unsigned i = 0; i < 5; ++i); - // expected-warning@+1{{OpenACC clause 'default_async' not yet implemented}} + // expected-error@+1{{OpenACC 'default_async' clause is not valid on 'loop' directive}} #pragma acc loop default_async(1) independent for(unsigned i = 0; i < 5; ++i); #pragma acc loop device_type(*) independent @@ -698,7 +698,7 @@ void uses() { // expected-error@+1{{OpenACC 'device_num' clause is not valid on 'loop' directive}} #pragma acc loop seq device_num(1) for(unsigned i = 0; i < 5; ++i); - // expected-warning@+1{{OpenACC clause 'default_async' not yet implemented}} + // expected-error@+1{{OpenACC 'default_async' clause is not valid on 'loop' directive}} #pragma acc loop seq default_async(1) for(unsigned i = 0; i < 5; ++i); #pragma acc loop seq device_type(*) @@ -838,7 +838,7 @@ void uses() { // expected-error@+1{{OpenACC 'device_num' clause is not valid on 'loop' directive}} #pragma acc loop device_num(1) seq for(unsigned i = 0; i < 5; ++i); - // expected-warning@+1{{OpenACC clause 'default_async' not yet implemented}} + // expected-error@+1{{OpenACC 'default_async' clause is not valid on 'loop' directive}} #pragma acc loop default_async(1) seq for(unsigned i = 0; i < 5; ++i); #pragma acc loop device_type(*) seq diff --git a/clang/test/SemaOpenACC/loop-construct-device_type-clause.c b/clang/test/SemaOpenACC/loop-construct-device_type-clause.c index bf2a2499c34363..f16f17f5d68108 100644 --- a/clang/test/SemaOpenACC/loop-construct-device_type-clause.c +++ b/clang/test/SemaOpenACC/loop-construct-device_type-clause.c @@ -173,8 +173,7 @@ void uses() { // expected-error@+1{{OpenACC 'device_num' clause is not valid on 'loop' directive}} #pragma acc loop device_type(*) device_num(1) for(int i = 0; i < 5; ++i); - // expected-error@+2{{OpenACC clause 'default_async' may not follow a 'device_type' clause in a 'loop' construct}} - // expected-note@+1{{previous clause is here}} + // expected-error@+1{{OpenACC 'default_async' clause is not valid on 'loop' directive}} #pragma acc loop device_type(*) default_async(1) for(int i = 0; i < 5; ++i); // expected-error@+1{{OpenACC 'async' clause is not valid on 'loop' directive}} diff --git a/clang/test/SemaOpenACC/set-construct-ast.cpp b/clang/test/SemaOpenACC/set-construct-ast.cpp index 2553378c51283d..c5eed944ada771 100644 --- a/clang/test/SemaOpenACC/set-construct-ast.cpp +++ b/clang/test/SemaOpenACC/set-construct-ast.cpp @@ -15,6 +15,10 @@ void NormalFunc() { #pragma acc set default_async(some_int()) device_num(some_long()) device_type(DT) if (some_int() < some_long()) // CHECK-NEXT: OpenACCSetConstruct{{.*}}set + // CHECK-NEXT: default_async clause + // CHECK-NEXT: CallExpr{{.*}}'int' + // CHECK-NEXT: ImplicitCastExpr + // CHECK-NEXT: DeclRefExpr{{.*}}'some_int' 'int ()' // CHECK-NEXT: device_num clause // CHECK-NEXT: CallExpr{{.*}} 'long' // CHECK-NEXT: ImplicitCastExpr @@ -41,6 +45,9 @@ void TemplFunc(T t) { #pragma acc set default_async(T::value) device_num(t) device_type(DT) if (T::value < t) // CHECK-NEXT: OpenACCSetConstruct{{.*}}set + // CHECK-NEXT: default_async clause + // CHECK-NEXT: DependentScopeDeclRefExpr{{.*}} '<dependent type>' + // CHECK-NEXT: NestedNameSpecifier TypeSpec 'T' // CHECK-NEXT: device_num clause // CHECK-NEXT: DeclRefExpr{{.*}}'t' 'T' // CHECK-NEXT: device_type(DT) @@ -59,6 +66,10 @@ void TemplFunc(T t) { // CHECK-NEXT: CompoundStmt // CHECK-NEXT: OpenACCSetConstruct{{.*}}set + // CHECK-NEXT: default_async clause + // CHECK-NEXT: ImplicitCastExpr {{.*}}'unsigned int' + // CHECK-NEXT: DeclRefExpr{{.*}}'value' 'const unsigned int' + // CHECK-NEXT: NestedNameSpecifier TypeSpec 'SomeStruct' // CHECK-NEXT: device_num clause // CHECK-NEXT: ImplicitCastExpr {{.*}}'unsigned int' // CHECK-NEXT: CXXMemberCallExpr{{.*}}'unsigned int' diff --git a/clang/test/SemaOpenACC/set-construct.cpp b/clang/test/SemaOpenACC/set-construct.cpp index 196bbdbc1d0481..23816dbab29119 100644 --- a/clang/test/SemaOpenACC/set-construct.cpp +++ b/clang/test/SemaOpenACC/set-construct.cpp @@ -15,8 +15,6 @@ struct ExplicitConvertOnly { } Explicit; void uses() { - // expected-warning@+2{{OpenACC clause 'default_async' not yet implemented, clause ignored}} - // expected-error@+1{{OpenACC 'set' construct must have at least one 'default_async', 'device_num', 'device_type' or 'if' clause}} #pragma acc set default_async(getI()) #pragma acc set device_num(getI()) #pragma acc set device_type(getI) @@ -45,10 +43,8 @@ void uses() { // expected-note@#AMBIG_SHORT{{conversion to integral type 'short'}} // expected-error@+1{{OpenACC 'set' construct must have at least one 'default_async', 'device_num', 'device_type' or 'if' clause}} #pragma acc set default_async(Ambiguous) - // expected-error@+4{{OpenACC integer expression requires explicit conversion from 'struct ExplicitConvertOnly' to 'int'}} + // expected-error@+2{{OpenACC integer expression requires explicit conversion from 'struct ExplicitConvertOnly' to 'int'}} // expected-note@#EXPL_CONV{{conversion to integral type 'int'}} - // expected-error@+2{{OpenACC 'set' construct must have at least one 'default_async', 'device_num', 'device_type' or 'if' clause}} - // expected-warning@+1{{OpenACC clause 'default_async' not yet implemented, clause ignored}} #pragma acc set default_async(Explicit) // expected-error@+1{{OpenACC 'set' construct must have at least one 'default_async', 'device_num', 'device_type' or 'if' clause}} @@ -56,9 +52,8 @@ void uses() { #pragma acc set if (true) - // expected-error@+3{{OpenACC 'set' construct must have at least one 'default_async', 'device_num', 'device_type' or 'if' clause}} - // expected-warning@+2{{OpenACC clause 'default_async' not yet implemented, clause ignored}} - // expected-warning@+1{{OpenACC clause 'default_async' not yet implemented, clause ignored}} + // expected-error@+2{{'default_async' clause cannot appear more than once on a 'set' directive}} + // expected-note@+1{{previous clause is here}} #pragma acc set default_async(getI()) default_async(getI()) // expected-error@+2{{'device_num' clause cannot appear more than once on a 'set' directive}} diff --git a/clang/tools/libclang/CIndex.cpp b/clang/tools/libclang/CIndex.cpp index ce83014a6e9eee..3e761024392cb2 100644 --- a/clang/tools/libclang/CIndex.cpp +++ b/clang/tools/libclang/CIndex.cpp @@ -2850,6 +2850,10 @@ void OpenACCClauseEnqueue::VisitDeviceNumClause( const OpenACCDeviceNumClause &C) { Visitor.AddStmt(C.getIntExpr()); } +void OpenACCClauseEnqueue::VisitDefaultAsyncClause( + const OpenACCDefaultAsyncClause &C) { + Visitor.AddStmt(C.getIntExpr()); +} void OpenACCClauseEnqueue::VisitVectorLengthClause( const OpenACCVectorLengthClause &C) { Visitor.AddStmt(C.getIntExpr()); _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
