[clang] [OpenACC] Implement beginning parts of the 'parallel' Sema impl (PR #81659)
Erich Keane via cfe-commits
cfe-commits at lists.llvm.org
Fri Feb 16 06:36:36 PST 2024
https://github.com/erichkeane updated https://github.com/llvm/llvm-project/pull/81659
>From f0b80e5d8aa8981b14f5afac623d450744d5301d Mon Sep 17 00:00:00 2001
From: erichkeane <ekeane at nvidia.com>
Date: Tue, 13 Feb 2024 07:15:11 -0800
Subject: [PATCH 1/2] [OpenACC] Implement beginning parts of the 'parallel'
Sema impl
This patch Implements AST node creation and appertainment enforcement
for 'parallel', as well as changes the 'not implemented' messages to be
more specific. It does not deal with clauses/clause legality, nor a few
of the other rules from the standard, but this gets us most of the way
for a framework for future cosntruct implementation.
---
clang/include/clang/AST/ASTContext.h | 2 +
.../clang/Basic/DiagnosticSemaKinds.td | 11 +
clang/include/clang/Parse/Parser.h | 16 +-
clang/include/clang/Sema/Sema.h | 45 +
clang/lib/AST/ASTContext.cpp | 6 +
clang/lib/Parse/ParseOpenACC.cpp | 44 +-
clang/lib/Sema/CMakeLists.txt | 1 +
clang/lib/Sema/SemaOpenACC.cpp | 132 ++
clang/lib/Sema/TreeTransform.h | 16 +-
.../ParserOpenACC/parse-cache-construct.c | 58 +-
.../ParserOpenACC/parse-cache-construct.cpp | 32 +-
clang/test/ParserOpenACC/parse-clauses.c | 1492 +++++++++++------
clang/test/ParserOpenACC/parse-clauses.cpp | 64 +-
clang/test/ParserOpenACC/parse-constructs.c | 123 +-
clang/test/ParserOpenACC/parse-constructs.cpp | 28 +-
clang/test/ParserOpenACC/parse-wait-clause.c | 108 +-
.../test/ParserOpenACC/parse-wait-construct.c | 72 +-
clang/test/ParserOpenACC/unimplemented.c | 15 +-
clang/test/ParserOpenACC/unimplemented.cpp | 15 +-
.../SemaOpenACC/compute-construct-ast.cpp | 56 +
.../SemaOpenACC/parallel-assoc-stmt-inst.cpp | 18 +
.../test/SemaOpenACC/parallel-loc-and-stmt.c | 46 +
.../SemaOpenACC/parallel-loc-and-stmt.cpp | 61 +
.../SemaOpenACC/unimplemented-construct.c | 39 +
24 files changed, 1713 insertions(+), 787 deletions(-)
create mode 100644 clang/lib/Sema/SemaOpenACC.cpp
create mode 100644 clang/test/SemaOpenACC/compute-construct-ast.cpp
create mode 100644 clang/test/SemaOpenACC/parallel-assoc-stmt-inst.cpp
create mode 100644 clang/test/SemaOpenACC/parallel-loc-and-stmt.c
create mode 100644 clang/test/SemaOpenACC/parallel-loc-and-stmt.cpp
create mode 100644 clang/test/SemaOpenACC/unimplemented-construct.c
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
index 12ce9af1e53f63..b8bdb74cfbb865 100644
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -3381,6 +3381,8 @@ OPT_LIST(V)
StringRef getCUIDHash() const;
+ void setOpenACCStructuredBlock(OpenACCComputeConstruct *C, Stmt *S);
+
private:
/// All OMPTraitInfo objects live in this collection, one per
/// `pragma omp [begin] declare variant` directive.
diff --git a/clang/include/clang/Basic/DiagnosticSemaKinds.td b/clang/include/clang/Basic/DiagnosticSemaKinds.td
index 754733a6c5fffd..622dd78936878c 100644
--- a/clang/include/clang/Basic/DiagnosticSemaKinds.td
+++ b/clang/include/clang/Basic/DiagnosticSemaKinds.td
@@ -12184,4 +12184,15 @@ def err_wasm_builtin_arg_must_match_table_element_type : Error <
"%ordinal0 argument must match the element type of the WebAssembly table in the %ordinal1 argument">;
def err_wasm_builtin_arg_must_be_integer_type : Error <
"%ordinal0 argument must be an integer">;
+
+// OpenACC diagnostics.
+def warn_acc_construct_unimplemented
+ : Warning<"OpenACC construct '%0' not yet implemented, pragma ignored">,
+ InGroup<SourceUsesOpenACC>;
+def warn_acc_clause_unimplemented
+ : Warning<"OpenACC clause '%0' not yet implemented, clause ignored">,
+ InGroup<SourceUsesOpenACC>;
+def err_acc_construct_appertainment
+ : Error<"OpenACC construct '%0' cannot be used here; it can only "
+ "be used in a statement context">;
} // end of sema component.
diff --git a/clang/include/clang/Parse/Parser.h b/clang/include/clang/Parse/Parser.h
index da18cf88edcc92..69b9e837fe8bef 100644
--- a/clang/include/clang/Parse/Parser.h
+++ b/clang/include/clang/Parse/Parser.h
@@ -3572,7 +3572,21 @@ class Parser : public CodeCompletionHandler {
StmtResult ParseOpenACCDirectiveStmt();
private:
- void ParseOpenACCDirective();
+ /// A struct to hold the information that got parsed by ParseOpenACCDirective,
+ /// so that the callers of it can use that to construct the appropriate AST
+ /// nodes.
+ struct OpenACCDirectiveParseInfo {
+ OpenACCDirectiveKind DirKind;
+ SourceLocation StartLoc;
+ SourceLocation EndLoc;
+ // TODO OpenACC: Add Clause list here once we have a type for that.
+ // TODO OpenACC: As we implement support for the Atomic, Routine, Cache, and
+ // Wait constructs, we likely want to put that information in here as well.
+ };
+
+ /// Parses the OpenACC directive (the entire pragma) including the clause
+ /// list, but does not produce the main AST node.
+ OpenACCDirectiveParseInfo ParseOpenACCDirective();
/// Helper that parses an ID Expression based on the language options.
ExprResult ParseOpenACCIDExpression();
/// Parses the variable list for the `cache` construct.
diff --git a/clang/include/clang/Sema/Sema.h b/clang/include/clang/Sema/Sema.h
index ed933f27f8df6b..0bb1484e9b0e96 100644
--- a/clang/include/clang/Sema/Sema.h
+++ b/clang/include/clang/Sema/Sema.h
@@ -33,6 +33,7 @@
#include "clang/AST/NSAPI.h"
#include "clang/AST/PrettyPrinter.h"
#include "clang/AST/StmtCXX.h"
+#include "clang/AST/StmtOpenACC.h"
#include "clang/AST/StmtOpenMP.h"
#include "clang/AST/TypeLoc.h"
#include "clang/AST/TypeOrdering.h"
@@ -41,6 +42,7 @@
#include "clang/Basic/DarwinSDKInfo.h"
#include "clang/Basic/ExpressionTraits.h"
#include "clang/Basic/Module.h"
+#include "clang/Basic/OpenACCKinds.h"
#include "clang/Basic/OpenCLOptions.h"
#include "clang/Basic/OpenMPKinds.h"
#include "clang/Basic/PragmaKinds.h"
@@ -12704,6 +12706,49 @@ class Sema final {
OMPClause *ActOnOpenMPXBareClause(SourceLocation StartLoc,
SourceLocation EndLoc);
+ //===--------------------------------------------------------------------===//
+ // OpenACC directives and clauses.
+
+ /// Called after parsing an OpenACC Clause so that it can be checked.
+ bool ActOnOpenACCClause(OpenACCClauseKind ClauseKind,
+ SourceLocation StartLoc);
+
+ /// Called after the construct has been parsed, but clauses haven't been
+ /// parsed. This allows us to diagnose not-implemented, as well as set up any
+ /// state required for parsing the clauses.
+ void ActOnOpenACCConstruct(OpenACCDirectiveKind K, SourceLocation StartLoc);
+
+ /// Called after the directive, including its clauses, have been parsed and
+ /// parsing has consumed the 'annot_pragma_openacc_end' token, so we are safe
+ /// to allocate all trailing storage. This DOES happen before any associated
+ /// declarations or statements have been parsed. This function is only called
+ /// when we are parsing a 'statement' context.
+ StmtResult ActOnStartOpenACCStmtDirective(OpenACCDirectiveKind K,
+ SourceLocation StartLoc,
+ SourceLocation EndLoc);
+
+ /// Called after the directive, including its clauses, have been parsed and
+ /// parsing has consumed the 'annot_pragma_openacc_end' token, so we are safe
+ /// to allocate all trailing storage. This DOES happen before any associated
+ /// declarations or statements have been parsed. This function is only called
+ /// when we are parsing a 'Decl' context.
+ void ActOnStartOpenACCDeclDirective(OpenACCDirectiveKind K,
+ SourceLocation StartLoc,
+ SourceLocation EndLoc);
+ /// Called when we encounter an associated statement for our construct, this
+ /// should check legality of the statement as it appertains to this Construct,
+ /// and returns the modified Construct.
+ StmtResult
+ ActOnOpenACCAssociatedStmt(OpenACCAssociatedStmtConstruct *Construct,
+ Stmt *AssocStmt);
+
+ /// Called after the directive has been completely parsed, including the
+ /// declaration group or associated statement.
+ void ActOnEndOpenACCStmtDirective(StmtResult Construct);
+ /// Called after the directive has been completely parsed, including the
+ /// declaration group or associated statement.
+ void ActOnEndOpenACCDeclDirective();
+
/// The kind of conversion being performed.
enum CheckedConversionKind {
/// An implicit conversion.
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index 78a04b4c694267..e0ec956564b006 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -41,6 +41,7 @@
#include "clang/AST/RawCommentList.h"
#include "clang/AST/RecordLayout.h"
#include "clang/AST/Stmt.h"
+#include "clang/AST/StmtOpenACC.h"
#include "clang/AST/TemplateBase.h"
#include "clang/AST/TemplateName.h"
#include "clang/AST/Type.h"
@@ -13662,3 +13663,8 @@ StringRef ASTContext::getCUIDHash() const {
CUIDHash = llvm::utohexstr(llvm::MD5Hash(LangOpts.CUID), /*LowerCase=*/true);
return CUIDHash;
}
+
+void ASTContext::setOpenACCStructuredBlock(OpenACCComputeConstruct *C,
+ Stmt *S) {
+ C->setStructuredBlock(S);
+}
diff --git a/clang/lib/Parse/ParseOpenACC.cpp b/clang/lib/Parse/ParseOpenACC.cpp
index e099d077198d09..f71c8570897901 100644
--- a/clang/lib/Parse/ParseOpenACC.cpp
+++ b/clang/lib/Parse/ParseOpenACC.cpp
@@ -745,9 +745,14 @@ bool Parser::ParseOpenACCClause(OpenACCDirectiveKind DirKind) {
<< getCurToken().getIdentifierInfo();
// Consume the clause name.
- ConsumeToken();
+ SourceLocation ClauseLoc = ConsumeToken();
+
+ bool ParamsResult = ParseOpenACCClauseParams(DirKind, Kind);
- return ParseOpenACCClauseParams(DirKind, Kind);
+ // TODO OpenACC: this whole function should return a 'clause' type optional
+ // instead of bool, so we likely want to return the clause here.
+ getActions().ActOnOpenACCClause(Kind, ClauseLoc);
+ return ParamsResult;
}
bool Parser::ParseOpenACCClauseParams(OpenACCDirectiveKind DirKind,
@@ -1116,9 +1121,12 @@ void Parser::ParseOpenACCCacheVarList() {
}
}
-void Parser::ParseOpenACCDirective() {
+Parser::OpenACCDirectiveParseInfo Parser::ParseOpenACCDirective() {
+ SourceLocation StartLoc = getCurToken().getLocation();
OpenACCDirectiveKind DirKind = ParseOpenACCDirectiveKind(*this);
+ getActions().ActOnOpenACCConstruct(DirKind, StartLoc);
+
// Once we've parsed the construct/directive name, some have additional
// specifiers that need to be taken care of. Atomic has an 'atomic-clause'
// that needs to be parsed.
@@ -1172,10 +1180,11 @@ void Parser::ParseOpenACCDirective() {
// Parses the list of clauses, if present.
ParseOpenACCClauseList(DirKind);
- Diag(getCurToken(), diag::warn_pragma_acc_unimplemented);
assert(Tok.is(tok::annot_pragma_openacc_end) &&
"Didn't parse all OpenACC Clauses");
- ConsumeAnnotationToken();
+ SourceLocation EndLoc = ConsumeAnnotationToken();
+ assert(EndLoc.isValid());
+ return OpenACCDirectiveParseInfo{DirKind, StartLoc, EndLoc};
}
// Parse OpenACC directive on a declaration.
@@ -1185,7 +1194,11 @@ Parser::DeclGroupPtrTy Parser::ParseOpenACCDirectiveDecl() {
ParsingOpenACCDirectiveRAII DirScope(*this);
ConsumeAnnotationToken();
- ParseOpenACCDirective();
+ OpenACCDirectiveParseInfo DirInfo = ParseOpenACCDirective();
+ getActions().ActOnStartOpenACCDeclDirective(DirInfo.DirKind, DirInfo.StartLoc,
+ DirInfo.EndLoc);
+ // TODO OpenACC: Handle the declaration here.
+ getActions().ActOnEndOpenACCDeclDirective();
return nullptr;
}
@@ -1197,7 +1210,22 @@ StmtResult Parser::ParseOpenACCDirectiveStmt() {
ParsingOpenACCDirectiveRAII DirScope(*this);
ConsumeAnnotationToken();
- ParseOpenACCDirective();
+ OpenACCDirectiveParseInfo DirInfo = ParseOpenACCDirective();
+ StmtResult Result = getActions().ActOnStartOpenACCStmtDirective(
+ DirInfo.DirKind, DirInfo.StartLoc, DirInfo.EndLoc);
+
+ // Parse associated statements if we are parsing a construct that takes a
+ // statement.
+ if (Result.isUsable()) {
+ if (auto *ASC = dyn_cast<OpenACCAssociatedStmtConstruct>(Result.get())) {
+ ParsingOpenACCDirectiveRAII DirScope(*this, /*Value=*/false);
+ StmtResult AssocStmt = ParseStatement();
+
+ if (AssocStmt.isUsable())
+ Result = getActions().ActOnOpenACCAssociatedStmt(ASC, AssocStmt.get());
+ }
+ }
+ getActions().ActOnEndOpenACCStmtDirective(Result);
- return StmtEmpty();
+ return Result;
}
diff --git a/clang/lib/Sema/CMakeLists.txt b/clang/lib/Sema/CMakeLists.txt
index 1856a88e9a3271..862f9d4ffb825d 100644
--- a/clang/lib/Sema/CMakeLists.txt
+++ b/clang/lib/Sema/CMakeLists.txt
@@ -52,6 +52,7 @@ add_clang_library(clangSema
SemaLookup.cpp
SemaModule.cpp
SemaObjCProperty.cpp
+ SemaOpenACC.cpp
SemaOpenMP.cpp
SemaOverload.cpp
SemaPseudoObject.cpp
diff --git a/clang/lib/Sema/SemaOpenACC.cpp b/clang/lib/Sema/SemaOpenACC.cpp
new file mode 100644
index 00000000000000..2e4853ea80dda2
--- /dev/null
+++ b/clang/lib/Sema/SemaOpenACC.cpp
@@ -0,0 +1,132 @@
+//===--- SemaOpenACC.cpp - Semantic Analysis for OpenACC constructs -------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+/// \file
+/// This file implements semantic analysis for OpenACC constructs and
+/// clauses.
+///
+//===----------------------------------------------------------------------===//
+
+#include "clang/Basic/DiagnosticSema.h"
+#include "clang/Basic/OpenACCKinds.h"
+#include "clang/Sema/Sema.h"
+
+using namespace clang;
+
+namespace {
+bool DiagnoseConstructAppertainment(Sema &S, OpenACCDirectiveKind K,
+ SourceLocation StartLoc, bool IsStmt) {
+ switch (K) {
+ default:
+ case OpenACCDirectiveKind::Invalid:
+ // Nothing to do here, both invalid and unimplemented don't really need to
+ // do anything.
+ break;
+ case OpenACCDirectiveKind::Parallel:
+ if (!IsStmt)
+ return S.Diag(StartLoc, diag::err_acc_construct_appertainment) << K;
+ break;
+ }
+ return false;
+}
+} // namespace
+
+bool Sema::ActOnOpenACCClause(OpenACCClauseKind ClauseKind,
+ SourceLocation StartLoc) {
+ // TODO OpenACC: this will probably want to take the Directive Kind as well to
+ // help with legalization.
+ if (ClauseKind == OpenACCClauseKind::Invalid)
+ return false;
+ // For now just diagnose that it is unsupported and leave the parsing to do
+ // whatever it can do. This function will eventually need to start returning
+ // some sort of Clause AST type, but for now just return true/false based on
+ // success.
+ return Diag(StartLoc, diag::warn_acc_clause_unimplemented) << ClauseKind;
+}
+
+void Sema::ActOnOpenACCConstruct(OpenACCDirectiveKind K,
+ SourceLocation StartLoc) {
+ switch (K) {
+ case OpenACCDirectiveKind::Invalid:
+ // Nothing to do here, an invalid kind has nothing we can check here. We
+ // want to continue parsing clauses as far as we can, so we will just
+ // ensure that we can still work and don't check any construct-specific
+ // rules anywhere.
+ break;
+ case OpenACCDirectiveKind::Parallel:
+ // Nothing to do here, there is no real legalization that needs to happen
+ // here as these constructs do not take any arguments.
+ break;
+ default:
+ Diag(StartLoc, diag::warn_acc_construct_unimplemented) << K;
+ break;
+ }
+}
+
+void Sema::ActOnStartOpenACCDeclDirective(OpenACCDirectiveKind K,
+ SourceLocation StartLoc,
+ SourceLocation EndLoc) {
+ // TODO OpenACC: This should likely return something with the modified
+ // declaration. At the moment, only handle appertainment.
+ DiagnoseConstructAppertainment(*this, K, StartLoc, /*IsStmt=*/false);
+}
+
+void Sema::ActOnEndOpenACCDeclDirective() {
+ // TODO OpenACC: Should diagnose anything having to do with the associated
+ // statement, or any clause diagnostics that can only be done at the 'end' of
+ // the directive. We should also close any 'block' marking now that the decl
+ // parsing is complete.
+}
+
+StmtResult Sema::ActOnStartOpenACCStmtDirective(OpenACCDirectiveKind K,
+ SourceLocation StartLoc,
+ SourceLocation EndLoc) {
+ if (DiagnoseConstructAppertainment(*this, K, StartLoc, /*IsStmt=*/true))
+ return StmtError();
+ switch (K) {
+ case OpenACCDirectiveKind::Invalid:
+ return StmtError();
+ default:
+ return StmtEmpty();
+ case OpenACCDirectiveKind::Parallel:
+ return OpenACCComputeConstruct::Create(getASTContext(), K, StartLoc,
+ EndLoc);
+ }
+ llvm_unreachable("Unhandled case in directive handling?");
+}
+
+StmtResult
+Sema::ActOnOpenACCAssociatedStmt(OpenACCAssociatedStmtConstruct *Construct,
+ Stmt *AssocStmt) {
+ assert(Construct && AssocStmt && "Invalid construct or statement");
+ switch (Construct->getDirectiveKind()) {
+ case OpenACCDirectiveKind::Parallel:
+ // There really isn't any checking here that could happen. As long as we
+ // have a statement to associate, this should be fine.
+ // OpenACC 3.3 Section 6:
+ // Structured Block: in C or C++, an executable statement, possibly
+ // compound, with a single entry at the top and a single exit at the
+ // bottom.
+ // FIXME: Should we reject DeclStmt's here? The standard isn't clear, and
+ // an interpretation of it is to allow this and treat the initializer as
+ // the 'structured block'.
+ Context.setOpenACCStructuredBlock(cast<OpenACCComputeConstruct>(Construct),
+ AssocStmt);
+ break;
+ default:
+ llvm_unreachable("Unimplemented associated statement application");
+ }
+ // TODO: ERICH: Implement.
+ return Construct;
+}
+
+void Sema::ActOnEndOpenACCStmtDirective(StmtResult Stmt) {
+ // TODO OpenACC: Should diagnose anything having to do with the associated
+ // statement, or any clause diagnostics that can only be done at the 'end' of
+ // the directive. We should also close any 'block' marking now that the
+ // statement parsing is complete.
+}
diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h
index 6e5ae123a6ba2c..f27fa8d171b173 100644
--- a/clang/lib/Sema/TreeTransform.h
+++ b/clang/lib/Sema/TreeTransform.h
@@ -4000,7 +4000,21 @@ class TreeTransform {
SourceLocation BeginLoc,
SourceLocation EndLoc,
StmtResult StrBlock) {
- llvm_unreachable("Not yet implemented!");
+ getSema().ActOnOpenACCConstruct(K, BeginLoc);
+ // TODO OpenACC: Include clauses.
+ StmtResult Construct =
+ getSema().ActOnStartOpenACCStmtDirective(K, BeginLoc, EndLoc);
+
+ if (!Construct.isUsable())
+ return Construct;
+
+ if (StrBlock.isUsable()) {
+ Construct = getSema().ActOnOpenACCAssociatedStmt(
+ cast<OpenACCComputeConstruct>(Construct.get()), StrBlock.get());
+ }
+
+ getSema().ActOnEndOpenACCStmtDirective(Construct);
+ return Construct;
}
private:
diff --git a/clang/test/ParserOpenACC/parse-cache-construct.c b/clang/test/ParserOpenACC/parse-cache-construct.c
index 093587f37df4fc..fd161c03c09f75 100644
--- a/clang/test/ParserOpenACC/parse-cache-construct.c
+++ b/clang/test/ParserOpenACC/parse-cache-construct.c
@@ -13,32 +13,32 @@ void func() {
for (int i = 0; i < 10; ++i) {
// expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache
}
for (int i = 0; i < 10; ++i) {
// expected-error at +3{{expected '('}}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache clause list
}
for (int i = 0; i < 10; ++i) {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache()
}
for (int i = 0; i < 10; ++i) {
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache() clause-list
}
for (int i = 0; i < 10; ++i) {
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(
}
@@ -46,25 +46,25 @@ void func() {
// expected-error at +4{{use of undeclared identifier 'invalid'}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(invalid
}
for (int i = 0; i < 10; ++i) {
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(ArrayPtr
}
for (int i = 0; i < 10; ++i) {
// expected-error at +2{{use of undeclared identifier 'invalid'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(invalid)
}
for (int i = 0; i < 10; ++i) {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(ArrayPtr)
}
@@ -74,7 +74,7 @@ void func() {
// expected-note at +4{{to match this '['}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(ArrayPtr[
}
@@ -82,7 +82,7 @@ void func() {
// expected-error at +4{{expected expression}}
// expected-error at +3{{expected ']'}}
// expected-note at +2{{to match this '['}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(ArrayPtr[, 5)
}
@@ -90,12 +90,12 @@ void func() {
// expected-error at +4{{expected expression}}
// expected-error at +3{{expected ']'}}
// expected-note at +2{{to match this '['}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(Array[)
}
for (int i = 0; i < 10; ++i) {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(Array[*readonly])
}
@@ -105,55 +105,55 @@ void func() {
// expected-note at +4{{to match this '['}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(Array[*readonly:
}
for (int i = 0; i < 10; ++i) {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(readonly)
}
for (int i = 0; i < 10; ++i) {
// expected-error at +2{{invalid tag 'devnum' on 'cache' directive}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(devnum:ArrayPtr)
}
for (int i = 0; i < 10; ++i) {
// expected-error at +2{{invalid tag 'invalid' on 'cache' directive}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(invalid:ArrayPtr)
}
for (int i = 0; i < 10; ++i) {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(readonly:ArrayPtr)
}
for (int i = 0; i < 10; ++i) {
// expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(readonly:ArrayPtr[5:])
}
for (int i = 0; i < 10; ++i) {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(readonly:ArrayPtr[5:*readonly])
}
for (int i = 0; i < 10; ++i) {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(readonly:ArrayPtr[5:*readonly], Array)
}
for (int i = 0; i < 10; ++i) {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(readonly:ArrayPtr[5:*readonly], Array[*readonly:3])
}
for (int i = 0; i < 10; ++i) {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(readonly:ArrayPtr[5 + i:*readonly], Array[*readonly + i:3])
}
@@ -161,36 +161,36 @@ void func() {
// expected-error at +4{{expected expression}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(readonly:ArrayPtr[5:*readonly],
}
for (int i = 0; i < 10; ++i) {
// expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(readonly:ArrayPtr[5:*readonly],)
}
for (int i = 0; i < 10; ++i) {
// expected-warning at +2{{left operand of comma operator has no effect}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(readonly:ArrayPtr[5,6:*readonly])
}
for (int i = 0; i < 10; ++i) {
// expected-warning at +2{{left operand of comma operator has no effect}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(readonly:ArrayPtr[5:3, *readonly], ArrayPtr[0])
}
for (int i = 0; i < 10; ++i) {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(readonly:s.foo)
}
for (int i = 0; i < 10; ++i) {
// expected-warning at +2{{left operand of comma operator has no effect}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(readonly:s.Array[1,2])
}
}
diff --git a/clang/test/ParserOpenACC/parse-cache-construct.cpp b/clang/test/ParserOpenACC/parse-cache-construct.cpp
index affe43d4b0f0ba..f0a35824696d8c 100644
--- a/clang/test/ParserOpenACC/parse-cache-construct.cpp
+++ b/clang/test/ParserOpenACC/parse-cache-construct.cpp
@@ -9,34 +9,34 @@ template<typename T, int I>
void func() {
char *ArrayPtr = getArrayPtr();
for (int i = 0; i < 10; ++i) {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(ArrayPtr[T::value + I:I + 5], T::array[(i + T::value, 5): 6])
}
for (int i = 0; i < 10; ++i) {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(NS::NSArray[NS::NSInt])
}
for (int i = 0; i < 10; ++i) {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(NS::NSArray[NS::NSInt : NS::NSInt])
}
for (int i = 0; i < 10; ++i) {
// expected-error at +2{{use of undeclared identifier 'NSArray'; did you mean 'NS::NSArray'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(NSArray[NS::NSInt : NS::NSInt])
}
for (int i = 0; i < 10; ++i) {
// expected-error at +2{{use of undeclared identifier 'NSInt'; did you mean 'NS::NSInt'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(NS::NSArray[NSInt : NS::NSInt])
}
for (int i = 0; i < 10; ++i) {
// expected-error at +2{{use of undeclared identifier 'NSInt'; did you mean 'NS::NSInt'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(NS::NSArray[NS::NSInt : NSInt])
}
}
@@ -59,56 +59,56 @@ void use() {
Members s;
for (int i = 0; i < 10; ++i) {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(s.array[s.value])
}
HasMembersArray Arrs;
for (int i = 0; i < 10; ++i) {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(Arrs.MemArr[3].array[4])
}
for (int i = 0; i < 10; ++i) {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(Arrs.MemArr[3].array[1:4])
}
for (int i = 0; i < 10; ++i) {
// FIXME: Once we have a new array-section type to represent OpenACC as
// well, change this error message.
// expected-error at +2{{OpenMP array section is not allowed here}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(Arrs.MemArr[3:4].array[1:4])
}
for (int i = 0; i < 10; ++i) {
// expected-error at +2{{OpenMP array section is not allowed here}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(Arrs.MemArr[3:4].array[4])
}
for (int i = 0; i < 10; ++i) {
// expected-error at +3{{expected ']'}}
// expected-note at +2{{to match this '['}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(Arrs.MemArr[3:4:].array[4])
}
for (int i = 0; i < 10; ++i) {
// expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(Arrs.MemArr[:].array[4])
}
for (int i = 0; i < 10; ++i) {
// expected-error at +2{{expected unqualified-id}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(Arrs.MemArr[::].array[4])
}
for (int i = 0; i < 10; ++i) {
// expected-error at +4{{expected expression}}
// expected-error at +3{{expected ']'}}
// expected-note at +2{{to match this '['}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(Arrs.MemArr[: :].array[4])
}
for (int i = 0; i < 10; ++i) {
// expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'cache' not yet implemented, pragma ignored}}
#pragma acc cache(Arrs.MemArr[3:].array[4])
}
func<S, 5>();
diff --git a/clang/test/ParserOpenACC/parse-clauses.c b/clang/test/ParserOpenACC/parse-clauses.c
index 18eb0fc996cceb..fb2f51890d7d7f 100644
--- a/clang/test/ParserOpenACC/parse-clauses.c
+++ b/clang/test/ParserOpenACC/parse-clauses.c
@@ -4,371 +4,467 @@
void func() {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'finalize' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'enter data' not yet implemented, pragma ignored}}
#pragma acc enter data finalize
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'finalize' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'finalize' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'enter data' not yet implemented, pragma ignored}}
#pragma acc enter data finalize finalize
+ // expected-warning at +3{{OpenACC clause 'finalize' not yet implemented, clause ignored}}
// expected-error at +2{{invalid OpenACC clause 'invalid'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'enter data' not yet implemented, pragma ignored}}
#pragma acc enter data finalize invalid
+ // expected-warning at +3{{OpenACC clause 'finalize' not yet implemented, clause ignored}}
// expected-error at +2{{invalid OpenACC clause 'invalid'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'enter data' not yet implemented, pragma ignored}}
#pragma acc enter data finalize invalid invalid finalize
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'finalize' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'enter data' not yet implemented, pragma ignored}}
#pragma acc enter data seq finalize
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'if_present' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'host_data' not yet implemented, pragma ignored}}
#pragma acc host_data if_present
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'if_present' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'if_present' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'host_data' not yet implemented, pragma ignored}}
#pragma acc host_data if_present, if_present
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +4{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +3{{OpenACC clause 'independent' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'auto' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop seq independent auto
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +4{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +3{{OpenACC clause 'independent' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'auto' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop seq, independent auto
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +4{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +3{{OpenACC clause 'independent' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'auto' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop seq independent, auto
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +4{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +3{{OpenACC clause 'independent' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'auto' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'kernels loop' not yet implemented, pragma ignored}}
#pragma acc kernels loop seq independent auto
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +4{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +3{{OpenACC clause 'independent' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'auto' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
#pragma acc serial loop seq, independent auto
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +4{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +3{{OpenACC clause 'independent' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'auto' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'parallel loop' not yet implemented, pragma ignored}}
#pragma acc parallel loop seq independent, auto
+ {}
// expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop , seq
- // expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected identifier}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop seq,
- // expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected '('}}
+ // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop collapse
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop collapse()
for(;;){}
- // expected-error at +3{{invalid tag 'unknown' on 'collapse' clause}}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{invalid tag 'unknown' on 'collapse' clause}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop collapse(unknown:)
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop collapse(force:)
for(;;){}
- // expected-error at +2{{invalid tag 'unknown' on 'collapse' clause}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{invalid tag 'unknown' on 'collapse' clause}}
+ // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop collapse(unknown:5)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop collapse(force:5)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop collapse(5)
for(;;){}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop collapse(5, 6)
for(;;){}
}
void DefaultClause() {
- // expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected '('}}
+ // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
#pragma acc serial loop default
for(;;){}
- // expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected '('}}
+ // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial default seq
for(;;){}
- // expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected '('}}
+ // expected-warning at +3{{OpenACC clause 'default' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial default, seq
for(;;){}
- // expected-error at +4{{expected identifier}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{expected identifier}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial default(
for(;;){}
- // expected-error at +4{{invalid value for 'default' clause; expected 'present' or 'none'}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{invalid value for 'default' clause; expected 'present' or 'none'}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial default( seq
for(;;){}
- // expected-error at +4{{expected identifier}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{expected identifier}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial default(, seq
for(;;){}
- // expected-error at +3{{expected '('}}
- // expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected '('}}
+ // expected-error at +3{{expected identifier}}
+ // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial default)
for(;;){}
- // expected-error at +3{{expected '('}}
- // expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
-#pragma acc serial default) seq
- for(;;){}
-
- // expected-error at +3{{expected '('}}
- // expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected '('}}
+ // expected-error at +3{{expected identifier}}
+ // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial default), seq
for(;;){}
- // expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected identifier}}
+ // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial default()
for(;;){}
- // expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected identifier}}
+ // expected-warning at +3{{OpenACC clause 'default' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial default() seq
for(;;){}
- // expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected identifier}}
+ // expected-warning at +3{{OpenACC clause 'default' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial default(), seq
for(;;){}
- // expected-error at +2{{invalid value for 'default' clause; expected 'present' or 'none'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{invalid value for 'default' clause; expected 'present' or 'none'}}
+ // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial default(invalid)
for(;;){}
- // expected-error at +2{{invalid value for 'default' clause; expected 'present' or 'none'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{invalid value for 'default' clause; expected 'present' or 'none'}}
+ // expected-warning at +3{{OpenACC clause 'default' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial default(auto) seq
for(;;){}
- // expected-error at +2{{invalid value for 'default' clause; expected 'present' or 'none'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{invalid value for 'default' clause; expected 'present' or 'none'}}
+ // expected-warning at +3{{OpenACC clause 'default' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial default(invalid), seq
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'default' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial default(none)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'default' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial default(present), seq
for(;;){}
}
void IfClause() {
- // expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected '('}}
+ // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
#pragma acc serial loop if
for(;;){}
- // expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected '('}}
+ // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial if seq
for(;;){}
- // expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected '('}}
+ // expected-warning at +3{{OpenACC clause 'if' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial if, seq
for(;;){}
- // expected-error at +4{{expected expression}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{expected expression}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial if(
for(;;){}
- // expected-error at +4{{use of undeclared identifier 'seq'}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{use of undeclared identifier 'seq'}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial if( seq
for(;;){}
- // expected-error at +5{{expected expression}}
- // expected-error at +4{{use of undeclared identifier 'seq'}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +6{{expected expression}}
+ // expected-error at +5{{use of undeclared identifier 'seq'}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial if(, seq
for(;;){}
- // expected-error at +3{{expected '('}}
- // expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected '('}}
+ // expected-error at +3{{expected identifier}}
+ // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial if)
for(;;){}
- // expected-error at +3{{expected '('}}
- // expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected '('}}
+ // expected-error at +3{{expected identifier}}
+ // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial if) seq
for(;;){}
- // expected-error at +3{{expected '('}}
- // expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected '('}}
+ // expected-error at +3{{expected identifier}}
+ // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial if), seq
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial if()
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected expression}}
+ // expected-warning at +3{{OpenACC clause 'if' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial if() seq
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected expression}}
+ // expected-warning at +3{{OpenACC clause 'if' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial if(), seq
for(;;){}
- // expected-error at +2{{use of undeclared identifier 'invalid_expr'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{use of undeclared identifier 'invalid_expr'}}
+ // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial if(invalid_expr)
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected expression}}
+ // expected-warning at +3{{OpenACC clause 'if' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial if() seq
for(;;){}
int i, j;
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'if' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial if(i > j)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'if' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial if(1+5>3), seq
for(;;){}
}
-void SyncClause() {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+void SelfClause() {
+ // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
#pragma acc serial loop self
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
#pragma acc serial loop self, seq
for(;;){}
- // expected-error at +4{{expected expression}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{expected expression}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
#pragma acc serial loop self(
for(;;){}
- // expected-error at +4{{use of undeclared identifier 'seq'}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{use of undeclared identifier 'seq'}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
#pragma acc serial loop self( seq
for(;;){}
- // expected-error at +5{{expected expression}}
- // expected-error at +4{{use of undeclared identifier 'seq'}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +6{{expected expression}}
+ // expected-error at +5{{use of undeclared identifier 'seq'}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
#pragma acc serial loop self(, seq
for(;;){}
- // expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected identifier}}
+ // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
#pragma acc serial loop self)
for(;;){}
- // expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected identifier}}
+ // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
#pragma acc serial loop self) seq
for(;;){}
- // expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected identifier}}
+ // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
#pragma acc serial loop self), seq
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected expression}}
+ // expected-warning at +3{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
#pragma acc serial loop self(), seq
for(;;){}
- // expected-error at +3{{expected expression}}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{expected expression}}
+ // expected-error at +4{{expected expression}}
+ // expected-warning at +3{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
#pragma acc serial loop self(,), seq
for(;;){}
- // expected-error at +2{{use of undeclared identifier 'invalid_expr'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{use of undeclared identifier 'invalid_expr'}}
+ // expected-warning at +3{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
#pragma acc serial loop self(invalid_expr), seq
for(;;){}
int i, j;
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial self(i > j
for(;;){}
- // expected-error at +4{{use of undeclared identifier 'seq'}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{use of undeclared identifier 'seq'}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial self(i > j, seq
for(;;){}
- // expected-warning at +2{{left operand of comma operator has no effect}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{left operand of comma operator has no effect}}
+ // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial self(i, j)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial self(i > j)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial self(1+5>3), seq
for(;;){}
}
@@ -385,336 +481,498 @@ struct HasMembersArray {
void SelfUpdate() {
struct Members s;
- // expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected '('}}
+ // expected-warning at +2{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'update' not yet implemented, pragma ignored}}
#pragma acc update self
for(;;){}
- // expected-error at +2{{use of undeclared identifier 'zero'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{use of undeclared identifier 'zero'}}
+ // expected-warning at +3{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'update' not yet implemented, pragma ignored}}
#pragma acc update self(zero : s.array[s.value : 5], s.value), seq
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'self' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'update' not yet implemented, pragma ignored}}
#pragma acc update self(s.array[s.value : 5], s.value), seq
for(;;){}
}
void VarListClauses() {
- // expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected '('}}
+ // expected-warning at +2{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy
- // expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected '('}}
+ // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy, seq
- // expected-error at +3{{expected '('}}
- // expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected '('}}
+ // expected-error at +3{{expected identifier}}
+ // expected-warning at +2{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy)
- // expected-error at +3{{expected '('}}
- // expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected '('}}
+ // expected-error at +3{{expected identifier}}
+ // expected-warning at +2{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy), seq
- // expected-error at +4{{expected expression}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{expected expression}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy(
- // expected-error at +4{{expected expression}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{expected expression}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy(, seq
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy()
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected expression}}
+ // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy(), seq
struct Members s;
struct HasMembersArray HasMem;
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy(s.array[s.value]), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy(s.array[s.value], s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy(HasMem.MemArr[3].array[1]), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy(HasMem.MemArr[3].array[1:4]), seq
- // expected-error at +2{{OpenMP array section is not allowed here}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{OpenMP array section is not allowed here}}
+ // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy(HasMem.MemArr[1:3].array[1]), seq
- // expected-error at +2{{OpenMP array section is not allowed here}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{OpenMP array section is not allowed here}}
+ // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy(HasMem.MemArr[1:3].array[1:2]), seq
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected expression}}
+ // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy(HasMem.MemArr[:]), seq
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected expression}}
+ // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy(HasMem.MemArr[::]), seq
- // expected-error at +4{{expected expression}}
- // expected-error at +3{{expected ']'}}
- // expected-note at +2{{to match this '['}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +6{{expected expression}}
+ // expected-error at +5{{expected ']'}}
+ // expected-note at +4{{to match this '['}}
+ // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy(HasMem.MemArr[: :]), seq
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected expression}}
+ // expected-warning at +3{{OpenACC clause 'copy' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copy(HasMem.MemArr[3:]), seq
- // expected-error at +2{{expected ','}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ','}}
+ // expected-warning at +3{{OpenACC clause 'use_device' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial use_device(s.array[s.value] s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'use_device' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial use_device(s.array[s.value : 5]), seq
- // expected-error at +2{{expected ','}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ','}}
+ // expected-warning at +3{{OpenACC clause 'no_create' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial no_create(s.array[s.value] s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'no_create' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial no_create(s.array[s.value : 5], s.value), seq
- // expected-error at +2{{expected ','}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ','}}
+ // expected-warning at +3{{OpenACC clause 'present' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial present(s.array[s.value] s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'present' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial present(s.array[s.value : 5], s.value), seq
- // expected-error at +2{{expected ','}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ','}}
+ // expected-warning at +3{{OpenACC clause 'deviceptr' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial deviceptr(s.array[s.value] s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'deviceptr' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial deviceptr(s.array[s.value : 5], s.value), seq
- // expected-error at +2{{expected ','}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ','}}
+ // expected-warning at +3{{OpenACC clause 'attach' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial attach(s.array[s.value] s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'attach' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial attach(s.array[s.value : 5], s.value), seq
- // expected-error at +2{{expected ','}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ','}}
+ // expected-warning at +3{{OpenACC clause 'detach' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial detach(s.array[s.value] s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'detach' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial detach(s.array[s.value : 5], s.value), seq
- // expected-error at +2{{expected ','}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ','}}
+ // expected-warning at +3{{OpenACC clause 'private' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial private(s.array[s.value] s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'private' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial private(s.array[s.value : 5], s.value), seq
- // expected-error at +2{{expected ','}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ','}}
+ // expected-warning at +3{{OpenACC clause 'firstprivate' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial firstprivate(s.array[s.value] s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'firstprivate' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial firstprivate(s.array[s.value : 5], s.value), seq
- // expected-error at +2{{expected ','}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ','}}
+ // expected-warning at +3{{OpenACC clause 'delete' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial delete(s.array[s.value] s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'delete' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial delete(s.array[s.value : 5], s.value), seq
- // expected-error at +2{{expected ','}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ','}}
+ // expected-warning at +3{{OpenACC clause 'use_device' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial use_device(s.array[s.value] s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'use_device' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial use_device(s.array[s.value : 5], s.value), seq
- // expected-error at +2{{expected ','}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ','}}
+ // expected-warning at +3{{OpenACC clause 'device_resident' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial device_resident(s.array[s.value] s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'device_resident' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial device_resident(s.array[s.value : 5], s.value), seq
- // expected-error at +2{{expected ','}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ','}}
+ // expected-warning at +3{{OpenACC clause 'link' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial link(s.array[s.value] s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'link' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial link(s.array[s.value : 5], s.value), seq
- // expected-error at +2{{expected ','}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ','}}
+ // expected-warning at +3{{OpenACC clause 'host' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial host(s.array[s.value] s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'host' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial host(s.array[s.value : 5], s.value), seq
- // expected-error at +2{{expected ','}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ','}}
+ // expected-warning at +3{{OpenACC clause 'device' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial device(s.array[s.value] s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'device' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial device(s.array[s.value : 5], s.value), seq
- // expected-error at +2{{expected ','}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ','}}
+ // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyout(s.array[s.value] s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyout(s.array[s.value : 5], s.value), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyout(zero:s.array[s.value : 5], s.value), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyout(zero : s.array[s.value : 5], s.value), seq
- // expected-error at +2{{use of undeclared identifier 'zero'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{use of undeclared identifier 'zero'}}
+ // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyout(zero s.array[s.value : 5], s.value), seq
- // expected-error at +2{{invalid tag 'readonly' on 'copyout' clause}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{invalid tag 'readonly' on 'copyout' clause}}
+ // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyout(readonly:s.array[s.value : 5], s.value), seq
- // expected-error at +2{{invalid tag 'invalid' on 'copyout' clause}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{invalid tag 'invalid' on 'copyout' clause}}
+ // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyout(invalid:s.array[s.value : 5], s.value), seq
- // expected-error at +2{{invalid tag 'invalid' on 'copyout' clause}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{invalid tag 'invalid' on 'copyout' clause}}
+ // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyout(invalid:s.array[s.value : 5], s.value), seq
- // expected-error at +2{{use of undeclared identifier 'invalid'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{use of undeclared identifier 'invalid'}}
+ // expected-warning at +3{{OpenACC clause 'copyout' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyout(invalid s.array[s.value : 5], s.value), seq
- // expected-error at +2{{expected ','}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ','}}
+ // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial create(s.array[s.value] s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial create(s.array[s.value : 5], s.value), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial create(zero:s.array[s.value : 5], s.value), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial create(zero : s.array[s.value : 5], s.value), seq
- // expected-error at +2{{use of undeclared identifier 'zero'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{use of undeclared identifier 'zero'}}
+ // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial create(zero s.array[s.value : 5], s.value), seq
- // expected-error at +2{{invalid tag 'readonly' on 'create' clause}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{invalid tag 'readonly' on 'create' clause}}
+ // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial create(readonly:s.array[s.value : 5], s.value), seq
- // expected-error at +2{{invalid tag 'invalid' on 'create' clause}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{invalid tag 'invalid' on 'create' clause}}
+ // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial create(invalid:s.array[s.value : 5], s.value), seq
- // expected-error at +2{{invalid tag 'invalid' on 'create' clause}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{invalid tag 'invalid' on 'create' clause}}
+ // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial create(invalid:s.array[s.value : 5], s.value), seq
- // expected-error at +2{{use of undeclared identifier 'invalid'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{use of undeclared identifier 'invalid'}}
+ // expected-warning at +3{{OpenACC clause 'create' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial create(invalid s.array[s.value : 5], s.value), seq
- // expected-error at +2{{expected ','}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ','}}
+ // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyin(s.array[s.value] s.array[s.value :5] ), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyin(s.array[s.value : 5], s.value), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyin(readonly:s.array[s.value : 5], s.value), seq
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyin(readonly : s.array[s.value : 5], s.value), seq
- // expected-error at +2{{use of undeclared identifier 'readonly'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{use of undeclared identifier 'readonly'}}
+ // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyin(readonly s.array[s.value : 5], s.value), seq
- // expected-error at +2{{invalid tag 'zero' on 'copyin' clause}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{invalid tag 'zero' on 'copyin' clause}}
+ // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyin(zero :s.array[s.value : 5], s.value), seq
- // expected-error at +2{{invalid tag 'invalid' on 'copyin' clause}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{invalid tag 'invalid' on 'copyin' clause}}
+ // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyin(invalid:s.array[s.value : 5], s.value), seq
- // expected-error at +2{{invalid tag 'invalid' on 'copyin' clause}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{invalid tag 'invalid' on 'copyin' clause}}
+ // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyin(invalid:s.array[s.value : 5], s.value), seq
- // expected-error at +2{{use of undeclared identifier 'invalid'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{use of undeclared identifier 'invalid'}}
+ // expected-warning at +3{{OpenACC clause 'copyin' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial copyin(invalid s.array[s.value : 5], s.value), seq
}
void ReductionClauseParsing() {
char *Begin, *End;
- // expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected '('}}
+ // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial reduction
- // expected-error at +3{{missing reduction operator, expected '+', '*', 'max', 'min', '&', '|', '^', '&&', or '||', follwed by a ':'}}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{missing reduction operator, expected '+', '*', 'max', 'min', '&', '|', '^', '&&', or '||', follwed by a ':'}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial reduction()
- // expected-error at +2{{missing reduction operator, expected '+', '*', 'max', 'min', '&', '|', '^', '&&', or '||', follwed by a ':'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{missing reduction operator, expected '+', '*', 'max', 'min', '&', '|', '^', '&&', or '||', follwed by a ':'}}
+ // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial reduction(Begin)
- // expected-error at +2{{missing reduction operator, expected '+', '*', 'max', 'min', '&', '|', '^', '&&', or '||', follwed by a ':'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{missing reduction operator, expected '+', '*', 'max', 'min', '&', '|', '^', '&&', or '||', follwed by a ':'}}
+ // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial reduction(Begin, End)
- // expected-error at +2{{missing reduction operator, expected '+', '*', 'max', 'min', '&', '|', '^', '&&', or '||', follwed by a ':'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{missing reduction operator, expected '+', '*', 'max', 'min', '&', '|', '^', '&&', or '||', follwed by a ':'}}
+ // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial reduction(Begin, End)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial reduction(+:Begin)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial reduction(+:Begin, End)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial reduction(*: Begin, End)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial reduction(max : Begin, End)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial reduction(min: Begin, End)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial reduction(&: Begin, End)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial reduction(|: Begin, End)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial reduction(^: Begin, End)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial seq, reduction(&&: Begin, End)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{OpenACC clause 'reduction' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial reduction(||: Begin, End), seq
}
@@ -722,589 +980,737 @@ int returns_int();
void IntExprParsing() {
// expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'vector_length' not yet implemented, clause ignored}}
#pragma acc parallel vector_length
+ {}
// expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'vector_length' not yet implemented, clause ignored}}
#pragma acc parallel vector_length()
+ {}
// expected-error at +2{{use of undeclared identifier 'invalid'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'vector_length' not yet implemented, clause ignored}}
#pragma acc parallel vector_length(invalid)
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'vector_length' not yet implemented, clause ignored}}
#pragma acc parallel vector_length(5, 4)
+ {}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'vector_length' not yet implemented, clause ignored}}
#pragma acc parallel vector_length(5)
+ {}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'vector_length' not yet implemented, clause ignored}}
#pragma acc parallel vector_length(returns_int())
+ {}
// expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'num_gangs' not yet implemented, clause ignored}}
#pragma acc parallel num_gangs
+ {}
// expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'num_gangs' not yet implemented, clause ignored}}
#pragma acc parallel num_gangs()
+ {}
// expected-error at +2{{use of undeclared identifier 'invalid'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'num_gangs' not yet implemented, clause ignored}}
#pragma acc parallel num_gangs(invalid)
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'num_gangs' not yet implemented, clause ignored}}
#pragma acc parallel num_gangs(5, 4)
+ {}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'num_gangs' not yet implemented, clause ignored}}
#pragma acc parallel num_gangs(5)
+ {}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'num_gangs' not yet implemented, clause ignored}}
#pragma acc parallel num_gangs(returns_int())
+ {}
// expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'num_workers' not yet implemented, clause ignored}}
#pragma acc parallel num_workers
+ {}
// expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'num_workers' not yet implemented, clause ignored}}
#pragma acc parallel num_workers()
+ {}
// expected-error at +2{{use of undeclared identifier 'invalid'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'num_workers' not yet implemented, clause ignored}}
#pragma acc parallel num_workers(invalid)
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'num_workers' not yet implemented, clause ignored}}
#pragma acc parallel num_workers(5, 4)
+ {}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'num_workers' not yet implemented, clause ignored}}
#pragma acc parallel num_workers(5)
+ {}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'num_workers' not yet implemented, clause ignored}}
#pragma acc parallel num_workers(returns_int())
+ {}
- // expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected '('}}
+ // expected-warning at +2{{OpenACC clause 'device_num' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'init' not yet implemented, pragma ignored}}
#pragma acc init device_num
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'device_num' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'init' not yet implemented, pragma ignored}}
#pragma acc init device_num()
- // expected-error at +2{{use of undeclared identifier 'invalid'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{use of undeclared identifier 'invalid'}}
+ // expected-warning at +2{{OpenACC clause 'device_num' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'init' not yet implemented, pragma ignored}}
#pragma acc init device_num(invalid)
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'device_num' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'init' not yet implemented, pragma ignored}}
#pragma acc init device_num(5, 4)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'device_num' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'init' not yet implemented, pragma ignored}}
#pragma acc init device_num(5)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'device_num' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'init' not yet implemented, pragma ignored}}
#pragma acc init device_num(returns_int())
- // expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected '('}}
+ // expected-warning at +2{{OpenACC clause 'default_async' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'set' not yet implemented, pragma ignored}}
#pragma acc set default_async
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'default_async' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'set' not yet implemented, pragma ignored}}
#pragma acc set default_async()
- // expected-error at +2{{use of undeclared identifier 'invalid'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{use of undeclared identifier 'invalid'}}
+ // expected-warning at +2{{OpenACC clause 'default_async' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'set' not yet implemented, pragma ignored}}
#pragma acc set default_async(invalid)
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'default_async' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'set' not yet implemented, pragma ignored}}
#pragma acc set default_async(5, 4)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'default_async' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'set' not yet implemented, pragma ignored}}
#pragma acc set default_async(5)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'default_async' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'set' not yet implemented, pragma ignored}}
#pragma acc set default_async(returns_int())
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop vector
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop vector()
- // expected-error at +3{{invalid tag 'invalid' on 'vector' clause}}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{invalid tag 'invalid' on 'vector' clause}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop vector(invalid:)
- // expected-error at +2{{invalid tag 'invalid' on 'vector' clause}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{invalid tag 'invalid' on 'vector' clause}}
+ // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop vector(invalid:5)
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop vector(length:)
- // expected-error at +3{{invalid tag 'num' on 'vector' clause}}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{invalid tag 'num' on 'vector' clause}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop vector(num:)
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop vector(5, 4)
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop vector(length:6,4)
- // expected-error at +4{{invalid tag 'num' on 'vector' clause}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{invalid tag 'num' on 'vector' clause}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop vector(num:6,4)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop vector(5)
- // expected-error at +2{{invalid tag 'num' on 'vector' clause}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{invalid tag 'num' on 'vector' clause}}
+ // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop vector(num:5)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop vector(length:5)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop vector(returns_int())
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop vector(length:returns_int())
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop worker
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop worker()
- // expected-error at +3{{invalid tag 'invalid' on 'worker' clause}}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{invalid tag 'invalid' on 'worker' clause}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop worker(invalid:)
- // expected-error at +2{{invalid tag 'invalid' on 'worker' clause}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{invalid tag 'invalid' on 'worker' clause}}
+ // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop worker(invalid:5)
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop worker(num:)
- // expected-error at +3{{invalid tag 'length' on 'worker' clause}}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{invalid tag 'length' on 'worker' clause}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop worker(length:)
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop worker(5, 4)
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop worker(num:6,4)
- // expected-error at +4{{invalid tag 'length' on 'worker' clause}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{invalid tag 'length' on 'worker' clause}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop worker(length:6,4)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop worker(5)
- // expected-error at +2{{invalid tag 'length' on 'worker' clause}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{invalid tag 'length' on 'worker' clause}}
+ // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop worker(length:5)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop worker(num:5)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop worker(returns_int())
- // expected-error at +2{{invalid tag 'length' on 'worker' clause}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{invalid tag 'length' on 'worker' clause}}
+ // expected-warning at +2{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop worker(length:returns_int())
}
void device_type() {
// expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
#pragma acc parallel device_type
+ {}
// expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
#pragma acc parallel dtype
+ {}
// expected-error at +4{{expected identifier}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
#pragma acc parallel device_type(
+ {}
// expected-error at +4{{expected identifier}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
#pragma acc parallel dtype(
+ {}
// expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
#pragma acc parallel device_type()
+ {}
// expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
#pragma acc parallel dtype()
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
#pragma acc parallel device_type(*
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
#pragma acc parallel dtype(*
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
#pragma acc parallel device_type(ident
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
#pragma acc parallel dtype(ident
+ {}
// expected-error at +4{{expected ','}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
#pragma acc parallel device_type(ident ident2
+ {}
// expected-error at +4{{expected ','}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
#pragma acc parallel dtype(ident ident2
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
#pragma acc parallel device_type(ident, ident2
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
#pragma acc parallel dtype(ident, ident2
+ {}
// expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
#pragma acc parallel device_type(ident, ident2,)
+ {}
// expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
#pragma acc parallel dtype(ident, ident2,)
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
#pragma acc parallel device_type(*,)
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
#pragma acc parallel dtype(*,)
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
#pragma acc parallel device_type(*,ident)
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
#pragma acc parallel dtype(*,ident)
+ {}
// expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
#pragma acc parallel device_type(ident, *)
+ {}
// expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
#pragma acc parallel dtype(ident, *)
+ {}
// expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
#pragma acc parallel device_type("foo", 54)
+ {}
// expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
#pragma acc parallel dtype(31, "bar")
+ {}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
#pragma acc parallel device_type(ident, auto, int, float)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ {}
+ // expected-warning at +1{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
#pragma acc parallel dtype(ident, auto, int, float)
+ {}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'device_type' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC clause 'dtype' not yet implemented, clause ignored}}
#pragma acc parallel device_type(ident, auto, int, float) dtype(ident, auto, int, float)
+ {}
}
#define acc_async_sync -1
void AsyncArgument() {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'async' not yet implemented, clause ignored}}
#pragma acc parallel async
+ {}
// expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'async' not yet implemented, clause ignored}}
#pragma acc parallel async()
+ {}
// expected-error at +2{{use of undeclared identifier 'invalid'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'async' not yet implemented, clause ignored}}
#pragma acc parallel async(invalid)
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'async' not yet implemented, clause ignored}}
#pragma acc parallel async(4, 3)
+ {}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'async' not yet implemented, clause ignored}}
#pragma acc parallel async(returns_int())
+ {}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'async' not yet implemented, clause ignored}}
#pragma acc parallel async(5)
+ {}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'async' not yet implemented, clause ignored}}
#pragma acc parallel async(acc_async_sync)
+ {}
}
void Tile() {
int* Foo;
- // expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected '('}}
+ // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop tile
for(;;){}
- // expected-error at +4{{expected expression}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{expected expression}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop tile(
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop tile()
for(;;){}
- // expected-error at +4{{expected expression}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{expected expression}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop tile(,
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop tile(,)
for(;;){}
- // expected-error at +2{{use of undeclared identifier 'invalid'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{use of undeclared identifier 'invalid'}}
+ // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop tile(returns_int(), *, invalid, *)
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop tile(returns_int() *, Foo, *)
for(;;){}
- // expected-error at +2{{indirection requires pointer operand ('int' invalid)}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{indirection requires pointer operand ('int' invalid)}}
+ // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop tile(* returns_int() , *)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop tile(*)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop tile(*Foo, *Foo)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop tile(5)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop tile(*, 5)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop tile(5, *)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'tile' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop tile(5, *, 3, *)
for(;;){}
}
void Gang() {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang
for(;;){}
- // expected-error at +4{{expected expression}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{expected expression}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang()
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(5, *)
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(*)
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(5, num:*)
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(num:5, *)
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(num:5, num:*)
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(num:*)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(dim:5)
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(dim:5, dim:*)
for(;;){}
- // expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected expression}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(dim:*)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(static:*)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(static:*, static:5)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(static:*, 5)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(static:45, 5)
for(;;){}
- // expected-error at +4{{expected expression}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{expected expression}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(static:45,
for(;;){}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(static:45
for(;;){}
- // expected-error at +4{{expected expression}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{expected expression}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(static:*,
for(;;){}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(static:*
for(;;){}
- // expected-error at +4{{expected expression}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{expected expression}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(45,
for(;;){}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(45
for(;;){}
- // expected-error at +4{{expected expression}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{expected expression}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(num:45,
for(;;){}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(num:45
for(;;){}
- // expected-error at +4{{expected expression}}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +5{{expected expression}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(dim:45,
for(;;){}
- // expected-error at +3{{expected ')'}}
- // expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +4{{expected ')'}}
+ // expected-note at +3{{to match this '('}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(dim:45
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(static:*, dim:returns_int(), 5)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'gang' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop gang(num: 32, static:*, dim:returns_int(), 5)
for(;;){}
}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +5{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+ // expected-warning at +4{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+ // expected-warning at +3{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'nohost' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine worker, vector, seq, nohost
void bar();
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +5{{OpenACC clause 'worker' not yet implemented, clause ignored}}
+ // expected-warning at +4{{OpenACC clause 'vector' not yet implemented, clause ignored}}
+ // expected-warning at +3{{OpenACC clause 'seq' not yet implemented, clause ignored}}
+ // expected-warning at +2{{OpenACC clause 'nohost' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(bar) worker, vector, seq, nohost
// Bind Clause Parsing.
- // expected-error at +2{{expected '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected '('}}
+ // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine bind
void BCP1();
- // expected-error at +2{{expected identifier or string literal}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{expected identifier or string literal}}
+ // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(BCP1) bind()
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine bind("ReductionClauseParsing")
void BCP2();
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(BCP1) bind(BCP2)
- // expected-error at +2{{use of undeclared identifier 'unknown_thing'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{use of undeclared identifier 'unknown_thing'}}
+ // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(BCP1) bind(unknown_thing)
diff --git a/clang/test/ParserOpenACC/parse-clauses.cpp b/clang/test/ParserOpenACC/parse-clauses.cpp
index 322080c3c35bcc..497b1c7bcd0da4 100644
--- a/clang/test/ParserOpenACC/parse-clauses.cpp
+++ b/clang/test/ParserOpenACC/parse-clauses.cpp
@@ -2,27 +2,29 @@
template<unsigned I, typename T>
void templ() {
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop collapse(I)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'collapse' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop collapse(T::value)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'vector_length' not yet implemented, clause ignored}}
#pragma acc parallel vector_length(T::value)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'vector_length' not yet implemented, clause ignored}}
#pragma acc parallel vector_length(I)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'async' not yet implemented, clause ignored}}
#pragma acc parallel async(T::value)
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'async' not yet implemented, clause ignored}}
#pragma acc parallel async(I)
for(;;){}
}
@@ -51,39 +53,51 @@ void function();
}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(use) bind(NS::NSFunc)
- // expected-error at +3{{'RecordTy' does not refer to a value}}
+ // expected-error at +4{{'RecordTy' does not refer to a value}}
// expected-note@#RecTy{{declared here}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(use) bind(NS::RecordTy)
- // expected-error at +3{{'Value' is a private member of 'NS::RecordTy'}}
+ // expected-error at +4{{'Value' is a private member of 'NS::RecordTy'}}
// expected-note@#VAL{{implicitly declared private here}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(use) bind(NS::RecordTy::Value)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(use) bind(NS::RecordTy::ValuePub)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(use) bind(NS::TemplTy<int>)
- // expected-error at +2{{no member named 'unknown' in namespace 'NS'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{no member named 'unknown' in namespace 'NS'}}
+ // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(use) bind(NS::unknown<int>)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(use) bind(NS::function)
- // expected-error at +3{{'priv_mem_function' is a private member of 'NS::RecordTy'}}
+ // expected-error at +4{{'priv_mem_function' is a private member of 'NS::RecordTy'}}
// expected-note@#PrivMemFun{{implicitly declared private here}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(use) bind(NS::RecordTy::priv_mem_function)
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(use) bind(NS::RecordTy::mem_function)
- // expected-error at +2{{string literal with user-defined suffix cannot be used here}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +3{{string literal with user-defined suffix cannot be used here}}
+ // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(use) bind("unknown udl"_UDL)
- // expected-warning at +2{{encoding prefix 'u' on an unevaluated string literal has no effect}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{encoding prefix 'u' on an unevaluated string literal has no effect}}
+ // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(use) bind(u"16 bits")
- // expected-warning at +2{{encoding prefix 'U' on an unevaluated string literal has no effect}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +3{{encoding prefix 'U' on an unevaluated string literal has no effect}}
+ // expected-warning at +2{{OpenACC clause 'bind' not yet implemented, clause ignored}}
+ // expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(use) bind(U"32 bits")
diff --git a/clang/test/ParserOpenACC/parse-constructs.c b/clang/test/ParserOpenACC/parse-constructs.c
index 0bb33269bbe98f..e561d38a79a98d 100644
--- a/clang/test/ParserOpenACC/parse-constructs.c
+++ b/clang/test/ParserOpenACC/parse-constructs.c
@@ -2,194 +2,197 @@
void func() {
- // expected-error at +2{{expected OpenACC directive}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +1{{expected OpenACC directive}}
#pragma acc
for(;;){}
- // expected-error at +3{{expected OpenACC directive}}
- // expected-error at +2{{invalid OpenACC clause 'whatever'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +2{{expected OpenACC directive}}
+ // expected-error at +1{{invalid OpenACC clause 'whatever'}}
#pragma acc(whatever) routine
- // expected-error at +3{{expected OpenACC directive}}
- // expected-error at +2{{invalid OpenACC clause 'routine'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +2{{expected OpenACC directive}}
+ // expected-error at +1{{invalid OpenACC clause 'routine'}}
#pragma acc) routine
- // expected-error at +2{{invalid OpenACC directive 'invalid'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +1{{invalid OpenACC directive 'invalid'}}
#pragma acc invalid
for(;;){}
- // expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +1{{invalid OpenACC clause 'clause'}}
#pragma acc parallel clause list
+ for(;;){}
+ // expected-error at +2{{expected clause-list or newline in OpenACC directive}}
+ // expected-error at +1{{invalid OpenACC clause 'clause'}}
+#pragma acc parallel() clause list
+ for(;;){}
+ // expected-error at +3{{expected clause-list or newline in OpenACC directive}}
+ // expected-error at +2{{expected ')'}}
+ // expected-note at +1{{to match this '('}}
+#pragma acc parallel( clause list
for(;;){}
// expected-error at +3{{expected clause-list or newline in OpenACC directive}}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
-#pragma acc parallel() clause list
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
+#pragma acc serial() clause list
for(;;){}
// expected-error at +4{{expected clause-list or newline in OpenACC directive}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
-#pragma acc parallel( clause list
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
+#pragma acc serial( clause list
for(;;){}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
#pragma acc serial clause list
for(;;){}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'kernels' not yet implemented, pragma ignored}}
#pragma acc kernels clause list
for(;;){}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'data' not yet implemented, pragma ignored}}
#pragma acc data clause list
for(;;){}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'enter data' not yet implemented, pragma ignored}}
#pragma acc enter data clause list
for(;;){}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'exit data' not yet implemented, pragma ignored}}
#pragma acc exit data clause list
for(;;){}
- // expected-error at +2{{invalid OpenACC directive 'enter invalid'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +1{{invalid OpenACC directive 'enter invalid'}}
#pragma acc enter invalid
for(;;){}
- // expected-error at +2{{invalid OpenACC directive 'exit invalid'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +1{{invalid OpenACC directive 'exit invalid'}}
#pragma acc exit invalid
for(;;){}
- // expected-error at +2{{invalid OpenACC directive 'enter'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +1{{invalid OpenACC directive 'enter'}}
#pragma acc enter
for(;;){}
- // expected-error at +2{{expected identifier}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +1{{expected identifier}}
#pragma acc exit }
for(;;){}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'host_data' not yet implemented, pragma ignored}}
#pragma acc host_data clause list
for(;;){}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'loop' not yet implemented, pragma ignored}}
#pragma acc loop clause list
for(;;){}
- // expected-error at +2{{invalid OpenACC clause 'invalid'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-error at +1{{invalid OpenACC clause 'invalid'}}
#pragma acc parallel invalid clause list
+ for(;;){}
+ // expected-error at +2{{invalid OpenACC clause 'invalid'}}
+ // expected-warning at +1{{OpenACC construct 'serial' not yet implemented, pragma ignored}}
+#pragma acc serial invalid clause list
for(;;){}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'parallel loop' not yet implemented, pragma ignored}}
#pragma acc parallel loop clause list
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'parallel loop' not yet implemented, pragma ignored}}
#pragma acc parallel loop
for(;;){}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
#pragma acc serial loop clause list
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'serial loop' not yet implemented, pragma ignored}}
#pragma acc serial loop
for(;;){}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'kernels loop' not yet implemented, pragma ignored}}
#pragma acc kernels loop clause list
for(;;){}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'kernels loop' not yet implemented, pragma ignored}}
#pragma acc kernels loop
for(;;){}
int i = 0, j = 0, k = 0;
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'atomic' not yet implemented, pragma ignored}}
#pragma acc atomic
i = j;
// expected-error at +2{{invalid OpenACC clause 'garbage'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'atomic' not yet implemented, pragma ignored}}
#pragma acc atomic garbage
i = j;
// expected-error at +2{{invalid OpenACC clause 'garbage'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'atomic' not yet implemented, pragma ignored}}
#pragma acc atomic garbage clause list
i = j;
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'atomic' not yet implemented, pragma ignored}}
#pragma acc atomic read
i = j;
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'atomic' not yet implemented, pragma ignored}}
#pragma acc atomic write clause list
i = i + j;
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'atomic' not yet implemented, pragma ignored}}
#pragma acc atomic update clause list
i++;
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'atomic' not yet implemented, pragma ignored}}
#pragma acc atomic capture clause list
i = j++;
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'declare' not yet implemented, pragma ignored}}
#pragma acc declare clause list
for(;;){}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'init' not yet implemented, pragma ignored}}
#pragma acc init clause list
for(;;){}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'shutdown' not yet implemented, pragma ignored}}
#pragma acc shutdown clause list
for(;;){}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'set' not yet implemented, pragma ignored}}
#pragma acc set clause list
for(;;){}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'update' not yet implemented, pragma ignored}}
#pragma acc update clause list
for(;;){}
}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine
void routine_func();
// expected-error at +2{{invalid OpenACC clause 'clause'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine clause list
void routine_func();
// expected-error at +2{{use of undeclared identifier 'func_name'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine (func_name)
// expected-error at +3{{use of undeclared identifier 'func_name'}}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine (func_name) clause list
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine (routine_func)
// expected-error at +2{{invalid OpenACC clause 'clause'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine (routine_func) clause list
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine (routine_func())
// expected-error at +2{{expected identifier}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine()
// expected-error at +2{{expected identifier}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(int)
diff --git a/clang/test/ParserOpenACC/parse-constructs.cpp b/clang/test/ParserOpenACC/parse-constructs.cpp
index abeddd357619e0..42fd09d6977ddc 100644
--- a/clang/test/ParserOpenACC/parse-constructs.cpp
+++ b/clang/test/ParserOpenACC/parse-constructs.cpp
@@ -14,50 +14,50 @@ namespace NS {
}
// expected-error at +2{{use of undeclared identifier 'foo'; did you mean 'NS::foo'?}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(foo)
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(NS::foo)
// expected-error at +2{{use of undeclared identifier 'templ'; did you mean 'NS::templ'?}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(templ)
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(NS::templ)
// expected-error at +2{{use of undeclared identifier 'templ'; did you mean 'NS::templ'?}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(templ<int>)
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(NS::templ<int>)
// expected-error at +2{{use of undeclared identifier 'T'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(templ<T>)
// expected-error at +2{{use of undeclared identifier 'T'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(NS::templ<T>)
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine (NS::foo())
// expected-error at +2 {{expected unqualified-id}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine()
// expected-error at +2 {{expected unqualified-id}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine(int)
// expected-error at +3{{'C' does not refer to a value}}
// expected-note@#CDef{{declared here}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine (NS::C)
// expected-error at +3{{'private_mem_func' is a private member of 'NS::C'}}
// expected-note@#PrivateMemFunc{{implicitly declared private here}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine (NS::C::private_mem_func)
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
#pragma acc routine (NS::C::public_mem_func)
diff --git a/clang/test/ParserOpenACC/parse-wait-clause.c b/clang/test/ParserOpenACC/parse-wait-clause.c
index 7639e6242ea671..cce050d5da9841 100644
--- a/clang/test/ParserOpenACC/parse-wait-clause.c
+++ b/clang/test/ParserOpenACC/parse-wait-clause.c
@@ -3,155 +3,191 @@
void func() {
int i, j;
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait
+ {}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait clause-list
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait (
+ {}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait ()
+ {}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait () clause-list
+ {}
// expected-error at +4{{expected expression}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait (devnum:
+ {}
// expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait (devnum:)
+ {}
// expected-error at +3{{expected expression}}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait (devnum:) clause-list
+ {}
// expected-error at +4{{expected ':'}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait (devnum: i + j
+ {}
// expected-error at +2{{expected ':'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait (devnum: i + j)
+ {}
// expected-error at +3{{expected ':'}}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait (devnum: i + j) clause-list
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait (queues:
+ {}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait (queues:)
+ {}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait (queues:) clause-list
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait (devnum: i + j:queues:
+ {}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait (devnum: i + j:queues:)
+ {}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait (devnum: i + j:queues:) clause-list
+ {}
// expected-error at +4{{use of undeclared identifier 'devnum'}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait (queues:devnum: i + j
+ {}
// expected-error at +2{{use of undeclared identifier 'devnum'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait (queues:devnum: i + j)
+ {}
// expected-error at +3{{use of undeclared identifier 'devnum'}}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait (queues:devnum: i + j) clause-list
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait(i, j, 1+1, 3.3
+ {}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait(i, j, 1+1, 3.3)
+ {}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait(i, j, 1+1, 3.3) clause-list
+ {}
// expected-error at +4{{expected expression}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait(,
+ {}
// expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait(,)
+ {}
// expected-error at +3{{expected expression}}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait(,) clause-list
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait(queues:i, j, 1+1, 3.3
+ {}
// expected-error at +4{{expected expression}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait(queues:i, j, 1+1, 3.3,
+ {}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait(queues:i, j, 1+1, 3.3)
+ {}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait(queues:i, j, 1+1, 3.3) clause-list
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait(devnum:3:i, j, 1+1, 3.3
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ {}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait(devnum:3:i, j, 1+1, 3.3)
+ {}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait(devnum:3:i, j, 1+1, 3.3) clause-list
+ {}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait(devnum:3:queues:i, j, 1+1, 3.3
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ {}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait(devnum:3:queues:i, j, 1+1, 3.3)
+ {}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC clause 'wait' not yet implemented, clause ignored}}
#pragma acc parallel wait(devnum:3:queues:i, j, 1+1, 3.3) clause-list
+ {}
}
diff --git a/clang/test/ParserOpenACC/parse-wait-construct.c b/clang/test/ParserOpenACC/parse-wait-construct.c
index 8f99f4aa8f67b1..30a9fc8c12a474 100644
--- a/clang/test/ParserOpenACC/parse-wait-construct.c
+++ b/clang/test/ParserOpenACC/parse-wait-construct.c
@@ -3,155 +3,155 @@
void func() {
int i, j;
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait clause-list
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait (
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait ()
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait () clause-list
// expected-error at +4{{expected expression}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait (devnum:
// expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait (devnum:)
// expected-error at +3{{expected expression}}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait (devnum:) clause-list
// expected-error at +4{{expected ':'}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait (devnum: i + j
// expected-error at +2{{expected ':'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait (devnum: i + j)
// expected-error at +3{{expected ':'}}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait (devnum: i + j) clause-list
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait (queues:
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait (queues:)
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait (queues:) clause-list
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait (devnum: i + j:queues:
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait (devnum: i + j:queues:)
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait (devnum: i + j:queues:) clause-list
// expected-error at +4{{use of undeclared identifier 'devnum'}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait (queues:devnum: i + j
// expected-error at +2{{use of undeclared identifier 'devnum'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait (queues:devnum: i + j)
// expected-error at +3{{use of undeclared identifier 'devnum'}}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait (queues:devnum: i + j) clause-list
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait(i, j, 1+1, 3.3
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait(i, j, 1+1, 3.3)
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait(i, j, 1+1, 3.3) clause-list
// expected-error at +4{{expected expression}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait(,
// expected-error at +2{{expected expression}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait(,)
// expected-error at +3{{expected expression}}
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait(,) clause-list
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait(queues:i, j, 1+1, 3.3
// expected-error at +4{{expected expression}}
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait(queues:i, j, 1+1, 3.3,
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait(queues:i, j, 1+1, 3.3)
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait(queues:i, j, 1+1, 3.3) clause-list
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait(devnum:3:i, j, 1+1, 3.3
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait(devnum:3:i, j, 1+1, 3.3)
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait(devnum:3:i, j, 1+1, 3.3) clause-list
// expected-error at +3{{expected ')'}}
// expected-note at +2{{to match this '('}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait(devnum:3:queues:i, j, 1+1, 3.3
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait(devnum:3:queues:i, j, 1+1, 3.3)
// expected-error at +2{{invalid OpenACC clause 'clause'}}
- // expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+ // expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
#pragma acc wait(devnum:3:queues:i, j, 1+1, 3.3) clause-list
}
diff --git a/clang/test/ParserOpenACC/unimplemented.c b/clang/test/ParserOpenACC/unimplemented.c
index be8e62b5811789..7426e028c0252c 100644
--- a/clang/test/ParserOpenACC/unimplemented.c
+++ b/clang/test/ParserOpenACC/unimplemented.c
@@ -1,26 +1,23 @@
// RUN: %clang_cc1 %s -verify -fopenacc
// Parser::ParseExternalDeclaration
-// expected-error at +3{{invalid OpenACC directive 'havent'}}
-// expected-error at +2{{invalid OpenACC clause 'implemented'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-error at +2{{invalid OpenACC directive 'havent'}}
+// expected-error at +1{{invalid OpenACC clause 'implemented'}}
#pragma acc havent implemented
int foo;
struct S {
// Parser::ParseStructUnionBody
-// expected-error at +3{{invalid OpenACC directive 'havent'}}
-// expected-error at +2{{invalid OpenACC clause 'implemented'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-error at +2{{invalid OpenACC directive 'havent'}}
+// expected-error at +1{{invalid OpenACC clause 'implemented'}}
#pragma acc havent implemented
int foo;
};
void func() {
// Parser::ParseStmtOrDeclarationAfterAttributes
-// expected-error at +3{{invalid OpenACC directive 'havent'}}
-// expected-error at +2{{invalid OpenACC clause 'implemented'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-error at +2{{invalid OpenACC directive 'havent'}}
+// expected-error at +1{{invalid OpenACC clause 'implemented'}}
#pragma acc havent implemented
while(0) {}
}
diff --git a/clang/test/ParserOpenACC/unimplemented.cpp b/clang/test/ParserOpenACC/unimplemented.cpp
index 6ffc84a3bc09d3..0acd69a7ae0876 100644
--- a/clang/test/ParserOpenACC/unimplemented.cpp
+++ b/clang/test/ParserOpenACC/unimplemented.cpp
@@ -1,26 +1,23 @@
// RUN: %clang_cc1 %s -verify -fopenacc
// Parser::ParseExternalDeclaration
-// expected-error at +3{{invalid OpenACC directive 'havent'}}
-// expected-error at +2{{invalid OpenACC clause 'implemented'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-error at +2{{invalid OpenACC directive 'havent'}}
+// expected-error at +1{{invalid OpenACC clause 'implemented'}}
#pragma acc havent implemented
int foo;
struct S {
// Parser::ParseCXXClassMemberDeclarationWithPragmas
-// expected-error at +3{{invalid OpenACC directive 'havent'}}
-// expected-error at +2{{invalid OpenACC clause 'implemented'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-error at +2{{invalid OpenACC directive 'havent'}}
+// expected-error at +1{{invalid OpenACC clause 'implemented'}}
#pragma acc havent implemented
int foo;
};
void func() {
// Parser::ParseStmtOrDeclarationAfterAttributes
-// expected-error at +3{{invalid OpenACC directive 'havent'}}
-// expected-error at +2{{invalid OpenACC clause 'implemented'}}
-// expected-warning at +1{{OpenACC directives not yet implemented, pragma ignored}}
+// expected-error at +2{{invalid OpenACC directive 'havent'}}
+// expected-error at +1{{invalid OpenACC clause 'implemented'}}
#pragma acc havent implemented
while(false) {}
}
diff --git a/clang/test/SemaOpenACC/compute-construct-ast.cpp b/clang/test/SemaOpenACC/compute-construct-ast.cpp
new file mode 100644
index 00000000000000..351fd1c3e0ee56
--- /dev/null
+++ b/clang/test/SemaOpenACC/compute-construct-ast.cpp
@@ -0,0 +1,56 @@
+// RUN: %clang_cc1 %s -fopenacc -ast-dump | FileCheck %s
+
+void NormalFunc() {
+ // FIXME: Add a test once we have clauses for this.
+ // CHECK-LABEL: NormalFunc
+ // CHECK-NEXT: CompoundStmt
+ // CHECK-NEXT: OpenACCComputeConstruct {{.*}}parallel
+ // CHECK-NEXT: CompoundStmt
+#pragma acc parallel
+ {
+#pragma acc parallel
+ // CHECK-NEXT: OpenACCComputeConstruct {{.*}}parallel
+ // CHECK-NEXT: OpenACCComputeConstruct {{.*}}parallel
+ // CHECK-NEXT: CompoundStmt
+#pragma acc parallel
+ {}
+ }
+}
+
+template<typename T>
+void TemplFunc() {
+#pragma acc parallel
+ {
+ typename T::type I;
+ }
+
+ // CHECK-LABEL: FunctionTemplateDecl {{.*}}TemplFunc
+ // CHECK-NEXT: TemplateTypeParmDecl
+
+ // Template Pattern:
+ // CHECK-NEXT: FunctionDecl
+ // CHECK-NEXT: CompoundStmt
+ // CHECK-NEXT: OpenACCComputeConstruct {{.*}}parallel
+ // CHECK-NEXT: CompoundStmt
+ // CHECK-NEXT: DeclStmt
+ // CHECK-NEXT: VarDecl{{.*}} I 'typename T::type'
+
+ // Check instantiation.
+ // CHECK-LABEL: FunctionDecl{{.*}} used TemplFunc 'void ()' implicit_instantiation
+ // CHECK-NEXT: TemplateArgument type 'S'
+ // CHECK-NEXT: RecordType
+ // CHECK-NEXT: CXXRecord
+ // CHECK-NEXT: CompoundStmt
+ // CHECK-NEXT: OpenACCComputeConstruct {{.*}}parallel
+ // CHECK-NEXT: CompoundStmt
+ // CHECK-NEXT: DeclStmt
+ // CHECK-NEXT: VarDecl{{.*}} I 'typename S::type':'int'
+}
+
+struct S {
+ using type = int;
+};
+
+void use() {
+ TemplFunc<S>();
+}
diff --git a/clang/test/SemaOpenACC/parallel-assoc-stmt-inst.cpp b/clang/test/SemaOpenACC/parallel-assoc-stmt-inst.cpp
new file mode 100644
index 00000000000000..0464e164a754e6
--- /dev/null
+++ b/clang/test/SemaOpenACC/parallel-assoc-stmt-inst.cpp
@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 %s -verify -fopenacc
+
+template<typename T>
+void Func() {
+#pragma acc parallel
+ typename T::type I; //#ILOC
+}
+
+struct S {
+ using type = int;
+};
+
+void use() {
+ Func<S>();
+ // expected-error@#ILOC{{type 'int' cannot be used prior to '::' because it has no members}}
+ // expected-note at +1{{in instantiation of function template specialization 'Func<int>' requested here}}
+ Func<int>();
+}
diff --git a/clang/test/SemaOpenACC/parallel-loc-and-stmt.c b/clang/test/SemaOpenACC/parallel-loc-and-stmt.c
new file mode 100644
index 00000000000000..5189a6aa44f042
--- /dev/null
+++ b/clang/test/SemaOpenACC/parallel-loc-and-stmt.c
@@ -0,0 +1,46 @@
+// RUN: %clang_cc1 %s -verify -fopenacc
+
+// expected-error at +1{{OpenACC construct 'parallel' cannot be used here; it can only be used in a statement context}}
+#pragma acc parallel
+
+// expected-error at +1{{OpenACC construct 'parallel' cannot be used here; it can only be used in a statement context}}
+#pragma acc parallel
+int foo;
+
+struct S {
+// expected-error at +1{{OpenACC construct 'parallel' cannot be used here; it can only be used in a statement context}}
+#pragma acc parallel
+int foo;
+};
+
+void func() {
+ // FIXME: Should we disallow this on declarations, or consider this to be on
+ // the initialization?
+#pragma acc parallel
+ int foo;
+
+#pragma acc parallel
+ {
+#pragma acc parallel
+ {
+ }
+ }
+
+ {
+// expected-error at +2{{expected statement}}
+#pragma acc parallel
+ }
+
+#pragma acc parallel
+ while(0){}
+
+#pragma acc parallel
+ for(;;){}
+
+#pragma acc parallel
+#pragma acc parallel
+ for(;;){}
+
+// expected-error at +2{{expected statement}}
+#pragma acc parallel
+};
diff --git a/clang/test/SemaOpenACC/parallel-loc-and-stmt.cpp b/clang/test/SemaOpenACC/parallel-loc-and-stmt.cpp
new file mode 100644
index 00000000000000..02ea2678f0361b
--- /dev/null
+++ b/clang/test/SemaOpenACC/parallel-loc-and-stmt.cpp
@@ -0,0 +1,61 @@
+// RUN: %clang_cc1 %s -verify -fopenacc
+
+// expected-error at +1{{OpenACC construct 'parallel' cannot be used here; it can only be used in a statement context}}
+#pragma acc parallel
+
+// expected-error at +1{{OpenACC construct 'parallel' cannot be used here; it can only be used in a statement context}}
+#pragma acc parallel
+int foo;
+
+struct S {
+// expected-error at +1{{OpenACC construct 'parallel' cannot be used here; it can only be used in a statement context}}
+#pragma acc parallel
+int foo;
+
+void mem_func() {
+ // FIXME: Should we disallow this on declarations, or consider this to be on
+ // the initialization?
+#pragma acc parallel
+ int foo;
+
+#pragma acc parallel
+ {
+ }
+
+#pragma acc parallel
+ while(0){}
+
+#pragma acc parallel
+ for(;;){}
+
+// expected-error at +2{{expected statement}}
+#pragma acc parallel
+}
+
+};
+
+template<typename T>
+void func() {
+ // FIXME: Should we disallow this on declarations, and consider this to be on
+ // the initialization?
+#pragma acc parallel
+ int foo;
+
+#pragma acc parallel
+ {
+ }
+
+#pragma acc parallel
+ while(0){}
+
+#pragma acc parallel
+ for(;;){}
+
+#pragma acc parallel
+#pragma acc parallel
+ for(;;){}
+
+// expected-error at +2{{expected statement}}
+#pragma acc parallel
+};
+
diff --git a/clang/test/SemaOpenACC/unimplemented-construct.c b/clang/test/SemaOpenACC/unimplemented-construct.c
new file mode 100644
index 00000000000000..3f4bc375cff800
--- /dev/null
+++ b/clang/test/SemaOpenACC/unimplemented-construct.c
@@ -0,0 +1,39 @@
+// RUN: %clang_cc1 %s -verify -fopenacc
+
+// expected-warning at +1{{OpenACC construct 'routine' not yet implemented, pragma ignored}}
+#pragma acc routine
+
+struct S {
+// expected-warning at +1{{OpenACC construct 'wait' not yet implemented, pragma ignored}}
+#pragma acc wait
+int foo;
+};
+
+void func() {
+// expected-warning at +1{{OpenACC construct 'declare' not yet implemented, pragma ignored}}
+#pragma acc declare
+ int foo;
+
+// expected-warning at +1{{OpenACC construct 'declare' not yet implemented, pragma ignored}}
+#pragma acc declare
+ {
+// expected-warning at +1{{OpenACC construct 'declare' not yet implemented, pragma ignored}}
+#pragma acc declare
+ {
+// expected-warning at +1{{OpenACC construct 'declare' not yet implemented, pragma ignored}}
+#pragma acc declare
+ }
+ }
+
+// expected-warning at +1{{OpenACC construct 'declare' not yet implemented, pragma ignored}}
+#pragma acc declare
+ while(0){}
+
+// expected-warning at +1{{OpenACC construct 'declare' not yet implemented, pragma ignored}}
+#pragma acc declare
+ for(;;){}
+
+// expected-warning at +1{{OpenACC construct 'declare' not yet implemented, pragma ignored}}
+#pragma acc declare
+};
+
>From cf3ac4cd3bff222ff8a78368b91675b547d86833 Mon Sep 17 00:00:00 2001
From: erichkeane <ekeane at nvidia.com>
Date: Fri, 16 Feb 2024 06:15:06 -0800
Subject: [PATCH 2/2] Do review comment updates/get stuff compiling
---
clang/include/clang/AST/ASTContext.h | 2 --
clang/include/clang/AST/StmtOpenACC.h | 22 ++++++++++-----------
clang/lib/AST/ASTContext.cpp | 5 -----
clang/lib/AST/StmtOpenACC.cpp | 7 ++++---
clang/lib/Parse/ParseOpenACC.cpp | 11 ++++++++---
clang/lib/Sema/SemaOpenACC.cpp | 10 ++++++----
clang/lib/Sema/TreeTransform.h | 17 ++++++----------
clang/test/ParserOpenACC/parse-constructs.c | 1 -
8 files changed, 35 insertions(+), 40 deletions(-)
diff --git a/clang/include/clang/AST/ASTContext.h b/clang/include/clang/AST/ASTContext.h
index b8bdb74cfbb865..12ce9af1e53f63 100644
--- a/clang/include/clang/AST/ASTContext.h
+++ b/clang/include/clang/AST/ASTContext.h
@@ -3381,8 +3381,6 @@ OPT_LIST(V)
StringRef getCUIDHash() const;
- void setOpenACCStructuredBlock(OpenACCComputeConstruct *C, Stmt *S);
-
private:
/// All OMPTraitInfo objects live in this collection, one per
/// `pragma omp [begin] declare variant` directive.
diff --git a/clang/include/clang/AST/StmtOpenACC.h b/clang/include/clang/AST/StmtOpenACC.h
index 9424f4f0807858..19da66832c7374 100644
--- a/clang/include/clang/AST/StmtOpenACC.h
+++ b/clang/include/clang/AST/StmtOpenACC.h
@@ -68,8 +68,9 @@ class OpenACCAssociatedStmtConstruct : public OpenACCConstructStmt {
protected:
OpenACCAssociatedStmtConstruct(StmtClass SC, OpenACCDirectiveKind K,
- SourceLocation Start, SourceLocation End)
- : OpenACCConstructStmt(SC, K, Start, End) {}
+ SourceLocation Start, SourceLocation End,
+ Stmt *AssocStmt)
+ : OpenACCConstructStmt(SC, K, Start, End), AssociatedStmt(AssocStmt) {}
void setAssociatedStmt(Stmt *S) { AssociatedStmt = S; }
Stmt *getAssociatedStmt() { return AssociatedStmt; }
@@ -105,14 +106,14 @@ class OpenACCComputeConstruct : public OpenACCAssociatedStmtConstruct {
friend class ASTStmtReader;
friend class ASTContext;
OpenACCComputeConstruct()
- : OpenACCAssociatedStmtConstruct(OpenACCComputeConstructClass,
- OpenACCDirectiveKind::Invalid,
- SourceLocation{}, SourceLocation{}) {}
+ : OpenACCAssociatedStmtConstruct(
+ OpenACCComputeConstructClass, OpenACCDirectiveKind::Invalid,
+ SourceLocation{}, SourceLocation{}, /*AssociatedStmt=*/nullptr) {}
OpenACCComputeConstruct(OpenACCDirectiveKind K, SourceLocation Start,
- SourceLocation End)
+ SourceLocation End, Stmt *StructuredBlock)
: OpenACCAssociatedStmtConstruct(OpenACCComputeConstructClass, K, Start,
- End) {
+ End, StructuredBlock) {
assert((K == OpenACCDirectiveKind::Parallel ||
K == OpenACCDirectiveKind::Serial ||
K == OpenACCDirectiveKind::Kernels) &&
@@ -128,10 +129,9 @@ class OpenACCComputeConstruct : public OpenACCAssociatedStmtConstruct {
}
static OpenACCComputeConstruct *CreateEmpty(const ASTContext &C, EmptyShell);
- static OpenACCComputeConstruct *Create(const ASTContext &C,
- OpenACCDirectiveKind K,
- SourceLocation BeginLoc,
- SourceLocation EndLoc);
+ static OpenACCComputeConstruct *
+ Create(const ASTContext &C, OpenACCDirectiveKind K, SourceLocation BeginLoc,
+ SourceLocation EndLoc, Stmt *StructuredBlock);
Stmt *getStructuredBlock() { return getAssociatedStmt(); }
const Stmt *getStructuredBlock() const {
diff --git a/clang/lib/AST/ASTContext.cpp b/clang/lib/AST/ASTContext.cpp
index e0ec956564b006..c475c841233c59 100644
--- a/clang/lib/AST/ASTContext.cpp
+++ b/clang/lib/AST/ASTContext.cpp
@@ -13663,8 +13663,3 @@ StringRef ASTContext::getCUIDHash() const {
CUIDHash = llvm::utohexstr(llvm::MD5Hash(LangOpts.CUID), /*LowerCase=*/true);
return CUIDHash;
}
-
-void ASTContext::setOpenACCStructuredBlock(OpenACCComputeConstruct *C,
- Stmt *S) {
- C->setStructuredBlock(S);
-}
diff --git a/clang/lib/AST/StmtOpenACC.cpp b/clang/lib/AST/StmtOpenACC.cpp
index 1a99c246381839..f74a777cd695ba 100644
--- a/clang/lib/AST/StmtOpenACC.cpp
+++ b/clang/lib/AST/StmtOpenACC.cpp
@@ -24,10 +24,11 @@ OpenACCComputeConstruct::CreateEmpty(const ASTContext &C, EmptyShell) {
OpenACCComputeConstruct *
OpenACCComputeConstruct::Create(const ASTContext &C, OpenACCDirectiveKind K,
- SourceLocation BeginLoc,
- SourceLocation EndLoc) {
+ SourceLocation BeginLoc, SourceLocation EndLoc,
+ Stmt *StructuredBlock) {
void *Mem = C.Allocate(sizeof(OpenACCComputeConstruct),
alignof(OpenACCComputeConstruct));
- auto *Inst = new (Mem) OpenACCComputeConstruct(K, BeginLoc, EndLoc);
+ auto *Inst =
+ new (Mem) OpenACCComputeConstruct(K, BeginLoc, EndLoc, StructuredBlock);
return Inst;
}
diff --git a/clang/lib/Parse/ParseOpenACC.cpp b/clang/lib/Parse/ParseOpenACC.cpp
index 10bdd8e9f7448e..50e78e8687aea1 100644
--- a/clang/lib/Parse/ParseOpenACC.cpp
+++ b/clang/lib/Parse/ParseOpenACC.cpp
@@ -551,8 +551,13 @@ void SkipUntilEndOfDirective(Parser &P) {
}
bool doesDirectiveHaveAssociatedStmt(OpenACCDirectiveKind DirKind) {
- // TODO OpenACC: Implement.
- return false;
+ switch (DirKind) {
+ default:
+ return false;
+ case OpenACCDirectiveKind::Parallel:
+ return true;
+ }
+ llvm_unreachable("Unhandled directive->assoc stmt");
}
} // namespace
@@ -1215,7 +1220,7 @@ StmtResult Parser::ParseOpenACCDirectiveStmt() {
ConsumeAnnotationToken();
OpenACCDirectiveParseInfo DirInfo = ParseOpenACCDirective();
- if (getActions().ActOnStartOpenACCDeclDirective(DirInfo.DirKind,
+ if (getActions().ActOnStartOpenACCStmtDirective(DirInfo.DirKind,
DirInfo.StartLoc))
return StmtError();
diff --git a/clang/lib/Sema/SemaOpenACC.cpp b/clang/lib/Sema/SemaOpenACC.cpp
index 74b1b9d62ab529..de6f1bac21566e 100644
--- a/clang/lib/Sema/SemaOpenACC.cpp
+++ b/clang/lib/Sema/SemaOpenACC.cpp
@@ -66,7 +66,7 @@ void Sema::ActOnOpenACCConstruct(OpenACCDirectiveKind K,
bool Sema::ActOnStartOpenACCStmtDirective(OpenACCDirectiveKind K,
SourceLocation StartLoc) {
- return diagnoseConstructAppertainment(&this, K, StartLoc, /*IsStmt=*/true);
+ return diagnoseConstructAppertainment(*this, K, StartLoc, /*IsStmt=*/true);
}
StmtResult Sema::ActOnEndOpenACCStmtDirective(OpenACCDirectiveKind K,
@@ -79,14 +79,16 @@ StmtResult Sema::ActOnEndOpenACCStmtDirective(OpenACCDirectiveKind K,
case OpenACCDirectiveKind::Invalid:
return StmtError();
case OpenACCDirectiveKind::Parallel:
- return OpenACCComputeConstruct::Create(getASTContext(), K, StartLoc, EndLoc, AssocStmt);
+ return OpenACCComputeConstruct::Create(
+ getASTContext(), K, StartLoc, EndLoc,
+ AssocStmt.isUsable() ? AssocStmt.get() : nullptr);
}
llvm_unreachable("Unhandled case in directive handling?");
}
StmtResult Sema::ActOnOpenACCAssociatedStmt(OpenACCDirectiveKind K,
StmtResult AssocStmt) {
- switch (Construct->getDirectiveKind()) {
+ switch (K) {
default:
llvm_unreachable("Unimplemented associated statement application");
case OpenACCDirectiveKind::Parallel:
@@ -106,7 +108,7 @@ StmtResult Sema::ActOnOpenACCAssociatedStmt(OpenACCDirectiveKind K,
bool Sema::ActOnStartOpenACCDeclDirective(OpenACCDirectiveKind K,
SourceLocation StartLoc) {
- return diagnoseConstructAppertainment(&this, K, StartLoc, /*IsStmt=*/false);
+ return diagnoseConstructAppertainment(*this, K, StartLoc, /*IsStmt=*/false);
}
DeclGroupRef Sema::ActOnEndOpenACCDeclDirective() { return DeclGroupRef{}; }
diff --git a/clang/lib/Sema/TreeTransform.h b/clang/lib/Sema/TreeTransform.h
index f27fa8d171b173..a32a585531873a 100644
--- a/clang/lib/Sema/TreeTransform.h
+++ b/clang/lib/Sema/TreeTransform.h
@@ -4001,20 +4001,15 @@ class TreeTransform {
SourceLocation EndLoc,
StmtResult StrBlock) {
getSema().ActOnOpenACCConstruct(K, BeginLoc);
- // TODO OpenACC: Include clauses.
- StmtResult Construct =
- getSema().ActOnStartOpenACCStmtDirective(K, BeginLoc, EndLoc);
- if (!Construct.isUsable())
- return Construct;
+ // TODO OpenACC: Include clauses.
+ if (getSema().ActOnStartOpenACCStmtDirective(K, BeginLoc))
+ return StmtError();
- if (StrBlock.isUsable()) {
- Construct = getSema().ActOnOpenACCAssociatedStmt(
- cast<OpenACCComputeConstruct>(Construct.get()), StrBlock.get());
- }
+ StrBlock = getSema().ActOnOpenACCAssociatedStmt(K, StrBlock);
- getSema().ActOnEndOpenACCStmtDirective(Construct);
- return Construct;
+ return getSema().ActOnEndOpenACCStmtDirective(K, BeginLoc, EndLoc,
+ StrBlock);
}
private:
diff --git a/clang/test/ParserOpenACC/parse-constructs.c b/clang/test/ParserOpenACC/parse-constructs.c
index 70bd8ac5e10cb3..adb5e3c7c75527 100644
--- a/clang/test/ParserOpenACC/parse-constructs.c
+++ b/clang/test/ParserOpenACC/parse-constructs.c
@@ -37,7 +37,6 @@ void func() {
// expected-error at +3{{expected clause-list or newline in OpenACC directive}}
// expected-error at +2{{expected ')'}}
// expected-note at +1{{to match this '('}}
- // expected-warning at +1{{OpenACC construct 'parallel' not yet implemented, pragma ignored}}
#pragma acc parallel( clause list
for(;;){}
// expected-error at +3{{expected clause-list or newline in OpenACC directive}}
More information about the cfe-commits
mailing list