[clang] 4de69f7 - [OpenACC] Implement ignoring of extension clauses

[via cfe-commits]

Author: erichkeane
Date: 2025-05-29T11:41:02-07:00
New Revision: 4de69f786e207f3b5269c37df888d23eace674f7

URL: https://github.com/llvm/llvm-project/commit/4de69f786e207f3b5269c37df888d23eace674f7
DIFF: https://github.com/llvm/llvm-project/commit/4de69f786e207f3b5269c37df888d23eace674f7.diff

LOG: [OpenACC] Implement ignoring of extension clauses

OpenACC 3.4 will permit extension clauses, which are clauses that start
with '__', and contain an optional balanced-paren-token-sequence inside
of parens.

This patch ensures we consume these, and emit a warning instead of an
error for unsupported clauses.

Added: 
    clang/test/ParserOpenACC/extensions.c

Modified: 
    clang/include/clang/Basic/DiagnosticParseKinds.td
    clang/lib/Parse/ParseOpenACC.cpp

Removed: 
    


################################################################################
diff  --git a/clang/include/clang/Basic/DiagnosticParseKinds.td b/clang/include/clang/Basic/DiagnosticParseKinds.td
index 554d70de86902..3aa36ad59d0b9 100644
--- a/clang/include/clang/Basic/DiagnosticParseKinds.td
+++ b/clang/include/clang/Basic/DiagnosticParseKinds.td
@@ -1456,6 +1456,9 @@ def err_acc_unexpected_directive
 def err_acc_invalid_directive
     : Error<"invalid OpenACC directive %select{%1|'%1 %2'}0">;
 def err_acc_invalid_clause : Error<"invalid OpenACC clause %0">;
+def warn_acc_unsupported_extension_clause
+    : Warning<"unsupported OpenACC extension clause %0">,
+      InGroup<DiagGroup<"unknown-acc-extension-clause">>;
 def err_acc_missing_directive : Error<"expected OpenACC directive">;
 def err_acc_invalid_open_paren
     : Error<"expected clause-list or newline in OpenACC directive">;

diff  --git a/clang/lib/Parse/ParseOpenACC.cpp b/clang/lib/Parse/ParseOpenACC.cpp
index e2c2463200892..3539278c7ff65 100644
--- a/clang/lib/Parse/ParseOpenACC.cpp
+++ b/clang/lib/Parse/ParseOpenACC.cpp
@@ -939,6 +939,15 @@ bool Parser::ParseOpenACCGangArgList(
   return false;
 }
 
+namespace {
+bool isUnsupportedExtensionClause(Token Tok) {
+  if (!Tok.is(tok::identifier))
+    return false;
+
+  return Tok.getIdentifierInfo()->getName().starts_with("__");
+}
+} // namespace
+
 Parser::OpenACCClauseParseResult
 Parser::ParseOpenACCClause(ArrayRef<const OpenACCClause *> ExistingClauses,
                            OpenACCDirectiveKind DirKind) {
@@ -949,7 +958,21 @@ Parser::ParseOpenACCClause(ArrayRef<const OpenACCClause *> ExistingClauses,
 
   OpenACCClauseKind Kind = getOpenACCClauseKind(getCurToken());
 
-  if (Kind == OpenACCClauseKind::Invalid) {
+  if (isUnsupportedExtensionClause(getCurToken())) {
+    Diag(getCurToken(), diag::warn_acc_unsupported_extension_clause)
+        << getCurToken().getIdentifierInfo();
+
+    // Extension methods optionally contain balanced token sequences, so we are
+    // going to parse this.
+    ConsumeToken(); // Consume the clause name.
+    BalancedDelimiterTracker Parens(*this, tok::l_paren,
+                                    tok::annot_pragma_openacc_end);
+    // Consume the optional parens and tokens inside of them.
+    if (!Parens.consumeOpen())
+      Parens.skipToEnd();
+
+    return OpenACCCanContinue();
+  } else if (Kind == OpenACCClauseKind::Invalid) {
     Diag(getCurToken(), diag::err_acc_invalid_clause)
         << getCurToken().getIdentifierInfo();
     return OpenACCCannotContinue();

diff  --git a/clang/test/ParserOpenACC/extensions.c b/clang/test/ParserOpenACC/extensions.c
new file mode 100644
index 0000000000000..1cfb3f88fce12
--- /dev/null
+++ b/clang/test/ParserOpenACC/extensions.c
@@ -0,0 +1,66 @@
+// RUN: %clang_cc1 %s -verify -fopenacc
+// RUN: not %clang_cc1 %s -fopenacc -ast-dump | FileCheck %s
+
+void foo(int Var) {
+  // expected-warning at +1{{unsupported OpenACC extension clause '__extension'}}
+#pragma acc parallel copy(Var) __extension copyin(Var)
+  ;
+  // CHECK: OpenACCComputeConstruct
+  // CHECK-NEXT: copy clause
+  // CHECK-NEXT: DeclRefExpr
+  // CHECK-NEXT: copyin clause
+  // CHECK-NEXT: DeclRefExpr
+  // CHECK-NEXT: NullStmt
+
+  // expected-warning at +1{{unsupported OpenACC extension clause '__extension'}}
+#pragma acc parallel copy(Var) __extension(stuff) copyin(Var)
+  ;
+  // CHECK: OpenACCComputeConstruct
+  // CHECK-NEXT: copy clause
+  // CHECK-NEXT: DeclRefExpr
+  // CHECK-NEXT: copyin clause
+  // CHECK-NEXT: DeclRefExpr
+  // CHECK-NEXT: NullStmt
+
+  // expected-warning at +1{{unsupported OpenACC extension clause '__extension'}}
+#pragma acc parallel copy(Var) __extension(")") copyin(Var)
+  ;
+  // CHECK: OpenACCComputeConstruct
+  // CHECK-NEXT: copy clause
+  // CHECK-NEXT: DeclRefExpr
+  // CHECK-NEXT: copyin clause
+  // CHECK-NEXT: DeclRefExpr
+  // CHECK-NEXT: NullStmt
+
+  // expected-warning at +1{{unsupported OpenACC extension clause '__extension'}}
+#pragma acc parallel copy(Var) __extension(()) copyin(Var)
+  ;
+  // CHECK: OpenACCComputeConstruct
+  // CHECK-NEXT: copy clause
+  // CHECK-NEXT: DeclRefExpr
+  // CHECK-NEXT: copyin clause
+  // CHECK-NEXT: DeclRefExpr
+  // CHECK-NEXT: NullStmt
+
+  // expected-warning at +2{{unsupported OpenACC extension clause '__extension'}}
+  // expected-error at +1{{expected identifier}}
+#pragma acc parallel copy(Var) __extension()) copyin(Var)
+  ;
+  // CHECK: OpenACCComputeConstruct
+  // CHECK-NEXT: copy clause
+  // CHECK-NEXT: DeclRefExpr
+  // Cannot recover from a bad paren, so we give up here.
+  // CHECK-NEXT: NullStmt
+
+  // expected-warning at +3{{unsupported OpenACC extension clause '__extension'}}
+  // expected-error at +2{{expected ')'}}
+  // expected-note at +1{{to match this '('}}
+#pragma acc parallel copy(Var) __extension(() copyin(Var)
+  ;
+  // CHECK: OpenACCComputeConstruct
+  // CHECK-NEXT: copy clause
+  // CHECK-NEXT: DeclRefExpr
+  // Cannot recover from a bad paren, so we give up here.
+  // CHECK-NEXT: NullStmt
+
+}