[flang][openacc] Update reference to OpenACC 3.1 specification

[clementval]

Summary

Update all reference from the specification to the new OpenACC 3.1
document.

[SouraVX]

flang/lib/Semantics/check-acc-structure.cpp

149

Please help me understand this:
This is a code change right ? Just curious, are there any test case modifications supporting this ?
Or is it just code refactoring ?

[SouraVX]

flang/lib/Semantics/check-acc-structure.cpp

81

No strong opinion here(on line number part), however in openmp semantics they mention section number and some description https://github.com/llvm/llvm-project/blob/main/flang/lib/Semantics/check-omp-structure.cpp#L74 having said that, that is also confusing since it doesn't mention that sections belongs to openmp4.5 or openmp5.0 or openmp5.1?
Here atleast that part is clear all line number reference here refer to openacc3.1

[clementval]

flang/lib/Semantics/check-acc-structure.cpp

81

I agree that I would prefer that standards add a unique numbering to the restriction like the Fortran standard does. In the mean time, since there is no way in Flang (at the moment) to differentiate two standards or to force to use one standard over another I guess this is the best I can do.

149

From 3.1 the serial construct takes the same restriction as the parallel and kernels for the supported clauses after device_type. There was already couple of tests in this sense but I can surely add some more.

[clementval]

Rebase

[clementval]

flang/lib/Semantics/check-acc-structure.cpp

149

In fact the test are there already. The restriction has been simplified in 3.1 so it can be checked the same way for parallel, serial and kernels.

flang/include/flang/Parser/parse-tree.h

 struct OpenMPConstruct {
   UNION_CLASS_BOILERPLATE(OpenMPConstruct);
   std::variant<OpenMPStandaloneConstruct, OpenMPSectionsConstruct,
       OpenMPLoopConstruct, OpenMPBlockConstruct, OpenMPAtomicConstruct,
       OpenMPCriticalConstruct>
       u;
 };
 
-// Parse tree nodes for OpenACC 3.0 directives and clauses
+// Parse tree nodes for OpenACC 3.1 directives and clauses
 
 struct AccObject {
   UNION_CLASS_BOILERPLATE(AccObject);
   std::variant<Designator, /*common block*/ Name> u;
 };
 
 WRAPPER_CLASS(AccObjectList, std::list<AccObject>);
 

flang/lib/Parser/openacc-parsers.cpp

 //===-- lib/Parser/openacc-parsers.cpp ------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
-// Top-level grammar specification for OpenACC 3.0.
+// Top-level grammar specification for OpenACC 3.1.
 
 #include "basic-parsers.h"
 #include "expr-parsers.h"
 #include "misc-parsers.h"
 #include "stmt-parser.h"
 #include "token-parsers.h"
 #include "type-parser-implementation.h"
 #include "flang/Parser/parse-tree.h"

flang/lib/Semantics/check-acc-structure.h

 //===-- lib/Semantics/check-acc-structure.h ---------------------*- C++ -*-===//
 //
 // 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
 //
-// OpenACC structure validity check list
+// OpenACC 3.1 structure validity check list
 //    1. invalid clauses on directive
 //    2. invalid repeated clauses on directive
 //    3. invalid nesting of regions
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef FORTRAN_SEMANTICS_CHECK_ACC_STRUCTURE_H_
 #define FORTRAN_SEMANTICS_CHECK_ACC_STRUCTURE_H_

flang/lib/Semantics/check-acc-structure.cpp

#define CHECK_REQ_SCALAR_INT_CONSTANT_CLAUSE(X, Y) \
   void AccStructureChecker::Enter(const parser::AccClause::X &c) { \
     CheckAllowed(llvm::acc::Clause::Y); \
     RequiresConstantPositiveParameter(llvm::acc::Clause::Y, c.v); \
   }
 
 namespace Fortran::semantics {
 
 static constexpr inline AccClauseSet
-    parallelAndKernelsOnlyAllowedAfterDeviceTypeClauses{
+    computeConstructOnlyAllowedAfterDeviceTypeClauses{
         llvm::acc::Clause::ACCC_async, llvm::acc::Clause::ACCC_wait,
         llvm::acc::Clause::ACCC_num_gangs, llvm::acc::Clause::ACCC_num_workers,
         llvm::acc::Clause::ACCC_vector_length};
 
-static constexpr inline AccClauseSet serialOnlyAllowedAfterDeviceTypeClauses{
-    llvm::acc::Clause::ACCC_async, llvm::acc::Clause::ACCC_wait};
-
 static constexpr inline AccClauseSet loopOnlyAllowedAfterDeviceTypeClauses{
     llvm::acc::Clause::ACCC_auto, llvm::acc::Clause::ACCC_collapse,
     llvm::acc::Clause::ACCC_independent, llvm::acc::Clause::ACCC_gang,
     llvm::acc::Clause::ACCC_seq, llvm::acc::Clause::ACCC_tile,
     llvm::acc::Clause::ACCC_vector, llvm::acc::Clause::ACCC_worker};
 
 static constexpr inline AccClauseSet updateOnlyAllowedAfterDeviceTypeClauses{
     llvm::acc::Clause::ACCC_async, llvm::acc::Clause::ACCC_wait};

 
 void AccStructureChecker::Leave(const parser::OpenACCBlockConstruct &x) {
   const auto &beginBlockDir{std::get<parser::AccBeginBlockDirective>(x.t)};
   const auto &blockDir{std::get<parser::AccBlockDirective>(beginBlockDir.t)};
   const parser::Block &block{std::get<parser::Block>(x.t)};
   switch (blockDir.v) {
   case llvm::acc::Directive::ACCD_kernels:
   case llvm::acc::Directive::ACCD_parallel:
-    // Restriction - 880-881 (KERNELS)
-    // Restriction - 843-844 (PARALLEL)
-    CheckOnlyAllowedAfter(llvm::acc::Clause::ACCC_device_type,
-        parallelAndKernelsOnlyAllowedAfterDeviceTypeClauses);
-    // Restriction - 877 (KERNELS)
-    // Restriction - 840 (PARALLEL)
-    CheckNoBranching(block, GetContext().directive, blockDir.source);
-    break;
   case llvm::acc::Directive::ACCD_serial:
-    // Restriction - 919
+    // Restriction - line 1004-1005
     CheckOnlyAllowedAfter(llvm::acc::Clause::ACCC_device_type,
-        serialOnlyAllowedAfterDeviceTypeClauses);
-    // Restriction - 916
-    CheckNoBranching(block, llvm::acc::Directive::ACCD_serial, blockDir.source);
+        computeConstructOnlyAllowedAfterDeviceTypeClauses);
+    // Restriction - line 1001
+    CheckNoBranching(block, GetContext().directive, blockDir.source);
     break;
   case llvm::acc::Directive::ACCD_data:
-    // Restriction - 1117-1118
+    // Restriction - line 1249-1250
     CheckRequireAtLeastOneOf();
     break;
   case llvm::acc::Directive::ACCD_host_data:
-    // Restriction - 1578
+    // Restriction - line 1746
     CheckRequireAtLeastOneOf();
     break;
   default:
     break;
   }
   dirContext_.pop_back();
 }
 
 void AccStructureChecker::Enter(
     const parser::OpenACCStandaloneDeclarativeConstruct &x) {
   const auto &declarativeDir{std::get<parser::AccDeclarativeDirective>(x.t)};
   PushContextAndClauseSets(declarativeDir.source, declarativeDir.v);
 }
 
 void AccStructureChecker::Leave(
     const parser::OpenACCStandaloneDeclarativeConstruct &) {
-  // Restriction - 2075
+  // Restriction - line 2409
   CheckAtLeastOneClause();
   dirContext_.pop_back();
 }
 
 void AccStructureChecker::Enter(const parser::OpenACCCombinedConstruct &x) {
   const auto &beginCombinedDir{
       std::get<parser::AccBeginCombinedDirective>(x.t)};
   const auto &combinedDir{

 
 void AccStructureChecker::Leave(const parser::OpenACCCombinedConstruct &x) {
   const auto &beginBlockDir{std::get<parser::AccBeginCombinedDirective>(x.t)};
   const auto &combinedDir{
       std::get<parser::AccCombinedDirective>(beginBlockDir.t)};
   switch (combinedDir.v) {
   case llvm::acc::Directive::ACCD_kernels_loop:
   case llvm::acc::Directive::ACCD_parallel_loop:
-    // Restriction - 1962 -> (880-881) (KERNELS LOOP)
-    // Restriction - 1962 -> (843-844) (PARALLEL LOOP)
-    CheckOnlyAllowedAfter(llvm::acc::Clause::ACCC_device_type,
-        {llvm::acc::Clause::ACCC_async, llvm::acc::Clause::ACCC_wait,
-            llvm::acc::Clause::ACCC_num_gangs,
-            llvm::acc::Clause::ACCC_num_workers,
-            llvm::acc::Clause::ACCC_vector_length});
-    break;
   case llvm::acc::Directive::ACCD_serial_loop:
-    // Restriction - 1962 -> (919) (SERIAL LOOP)
+    // Restriction - line 1004-1005
     CheckOnlyAllowedAfter(llvm::acc::Clause::ACCC_device_type,
-        {llvm::acc::Clause::ACCC_async, llvm::acc::Clause::ACCC_wait});
+        computeConstructOnlyAllowedAfterDeviceTypeClauses);
     break;
   default:
     break;
   }
   dirContext_.pop_back();
 }
 
 void AccStructureChecker::Enter(const parser::OpenACCLoopConstruct &x) {
   const auto &beginDir{std::get<parser::AccBeginLoopDirective>(x.t)};
   const auto &loopDir{std::get<parser::AccLoopDirective>(beginDir.t)};
   PushContextAndClauseSets(loopDir.source, loopDir.v);
 }
 
 void AccStructureChecker::Leave(const parser::OpenACCLoopConstruct &x) {
   const auto &beginDir{std::get<parser::AccBeginLoopDirective>(x.t)};
   const auto &loopDir{std::get<parser::AccLoopDirective>(beginDir.t)};
   if (loopDir.v == llvm::acc::Directive::ACCD_loop) {
-    // Restriction - 1615-1616
+    // Restriction - line 1818-1819
     CheckOnlyAllowedAfter(llvm::acc::Clause::ACCC_device_type,
         loopOnlyAllowedAfterDeviceTypeClauses);
-    // Restriction - 1622
+    // Restriction - line 1834
     CheckNotAllowedIfClause(llvm::acc::Clause::ACCC_seq,
         {llvm::acc::Clause::ACCC_gang, llvm::acc::Clause::ACCC_vector,
             llvm::acc::Clause::ACCC_worker});
   }
   dirContext_.pop_back();
 }
 
 void AccStructureChecker::Enter(const parser::OpenACCStandaloneConstruct &x) {
   const auto &standaloneDir{std::get<parser::AccStandaloneDirective>(x.t)};
   PushContextAndClauseSets(standaloneDir.source, standaloneDir.v);
 }
 
 void AccStructureChecker::Leave(const parser::OpenACCStandaloneConstruct &x) {
   const auto &standaloneDir{std::get<parser::AccStandaloneDirective>(x.t)};
   switch (standaloneDir.v) {
   case llvm::acc::Directive::ACCD_enter_data:
   case llvm::acc::Directive::ACCD_exit_data:
   case llvm::acc::Directive::ACCD_set:
-    // Restriction - 1117-1118 (ENTER DATA)
-    // Restriction - 1161-1162 (EXIT DATA)
-    // Restriction - 2254 (SET)
+    // Restriction - line 1310-1311 (ENTER DATA)
+    // Restriction - line 1312-1313 (EXIT DATA)
+    // Restriction - line 2610 (SET)
     CheckRequireAtLeastOneOf();
     break;
   case llvm::acc::Directive::ACCD_update:
-    // Restriction - 2301
+    // Restriction - line 2636 (UPDATE)
     CheckOnlyAllowedAfter(llvm::acc::Clause::ACCC_device_type,
         updateOnlyAllowedAfterDeviceTypeClauses);
     break;
   default:
     break;
   }
   dirContext_.pop_back();
 }
 
 void AccStructureChecker::Enter(const parser::OpenACCRoutineConstruct &x) {
   PushContextAndClauseSets(x.source, llvm::acc::Directive::ACCD_routine);
 }
 void AccStructureChecker::Leave(const parser::OpenACCRoutineConstruct &) {
-  // Restriction - 2409
+  // Restriction - line 2790
   CheckRequireAtLeastOneOf();
-  // Restriction - 2407-2408
+  // Restriction - line 2788-2789
   CheckOnlyAllowedAfter(llvm::acc::Clause::ACCC_device_type,
       routineOnlyAllowedAfterDeviceTypeClauses);
   dirContext_.pop_back();
 }
 
 void AccStructureChecker::Enter(const parser::OpenACCWaitConstruct &x) {
   const auto &verbatim{std::get<parser::Verbatim>(x.t)};
   PushContextAndClauseSets(verbatim.source, llvm::acc::Directive::ACCD_wait);

flang/tools/f18/f18.cpp

while (!args.empty()) {
     } else if (arg == "-Mnobackslash") {
       options.features.Enable(
           Fortran::common::LanguageFeature::BackslashEscapes, true);
     } else if (arg == "-Mstandard" || arg == "-std=f95" ||
         arg == "-std=f2003" || arg == "-std=f2008" || arg == "-std=legacy") {
       driver.warnOnNonstandardUsage = true;
     } else if (arg == "-fopenacc") {
       options.features.Enable(Fortran::common::LanguageFeature::OpenACC);
-      options.predefinitions.emplace_back("_OPENACC", "201911");
+      options.predefinitions.emplace_back("_OPENACC", "202011");
     } else if (arg == "-fopenmp") {
       options.features.Enable(Fortran::common::LanguageFeature::OpenMP);
       options.predefinitions.emplace_back("_OPENMP", "201511");
     } else if (arg == "-Werror") {
       driver.warningsAreErrors = true;
     } else if (arg == "-ed") {
       options.features.Enable(Fortran::common::LanguageFeature::OldDebugLines);
     } else if (arg == "-E") {

llvm/include/llvm/Frontend/OpenACC/ACC.td

 //===-- ACC.td - OpenACC directive definition file ---------*- tablegen -*-===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
-// This is the definition file for OpenACC directives and clauses.
+// This is the definition file for OpenACC 3.1 directives and clauses.
 //
 //===----------------------------------------------------------------------===//
 
 include "llvm/Frontend/Directive/DirectiveBase.td"
 
 //===----------------------------------------------------------------------===//
 // Definition of general OpenACC information
 //===----------------------------------------------------------------------===//

 //===----------------------------------------------------------------------===//
 
 // 2.16.1
 def ACCC_Async : Clause<"async"> {
   let flangClassValue = "ScalarIntExpr";
   let isValueOptional = true;
 }
 
-// 2.9.6
+// 2.9.7
 def ACCC_Auto : Clause<"auto"> {}
 
-// 2.7.11
+// 2.7.12
 def ACCC_Attach : Clause<"attach"> {
   let flangClassValue = "AccObjectList";
 }
 
 // 2.15.1
 def ACCC_Bind : Clause<"bind"> {
   let flangClassValue = "Name";
 }
 
 // 2.12
 def ACCC_Capture : Clause<"capture"> {
 }
 
 // 2.9.1
 def ACCC_Collapse : Clause<"collapse"> {
   let flangClassValue = "ScalarIntConstantExpr";
 }
 
-// 2.7.5
+// 2.7.6
 def ACCC_Copy : Clause<"copy"> {
   let flangClassValue = "AccObjectList";
 }
-// 2.7.6
+// 2.7.7
 def ACCC_Copyin : Clause<"copyin"> {
   let flangClassValue = "AccObjectListWithModifier";
 }
 
-// 2.7.7
+// 2.7.8
 def ACCC_Copyout : Clause<"copyout"> {
   let flangClassValue = "AccObjectListWithModifier";
 }
 
-// 2.7.8
+// 2.7.9
 def ACCC_Create : Clause<"create"> {
   let flangClassValue = "AccObjectListWithModifier";
 }
 
-// 2.5.14
+// 2.5.15
 def ACCC_Default : Clause<"default"> {
   let flangClassValue = "AccDefaultClause";
 }
 
-// 2.4.12
+// 2.14.3
 def ACCC_DefaultAsync : Clause<"default_async"> {
   let flangClassValue = "ScalarIntExpr";
 }
 
-// 2.7.10
+// 2.7.11
 def ACCC_Delete : Clause<"delete"> {
   let flangClassValue = "AccObjectList";
 }
 
-// 2.7.12
+// 2.7.13
 def ACCC_Detach : Clause<"detach"> {
   let flangClassValue = "AccObjectList";
 }
 
 // 2.14.4
 def ACCC_Device : Clause<"device"> {
   let flangClassValue = "AccObjectList";
 }
 
-// 2.14.1
+// 2.14.1 - 2.14.2
 def ACCC_DeviceNum : Clause<"device_num">  {
   let flangClassValue = "ScalarIntExpr";
 }
 
-// 2.7.3
+// 2.7.4
 def ACCC_DevicePtr : Clause<"deviceptr"> {
   let flangClassValue = "AccObjectList";
 }
 
-// 2.13
+// 2.13.1
 def ACCC_DeviceResident : Clause<"device_resident"> {
   let flangClassValue = "AccObjectList";
 }
 
 // 2.4
 def ACCC_DeviceType : Clause<"device_type"> {
   let flangClassValue = "ScalarIntExpr";
   let defaultValue = "*";
   let isValueOptional = true;
   let isValueList = true;
 }
 
 // 2.6.6
 def ACCC_Finalize : Clause<"finalize"> {}
 
-// 2.5.12
+// 2.5.13
 def ACCC_FirstPrivate : Clause<"firstprivate"> {
   let flangClassValue = "AccObjectList";
 }
 
 // 2.9.2
 def ACCC_Gang : Clause<"gang"> {
   let flangClassValue = "AccGangArgument";
   let isValueOptional = true;
 }
 
 // 2.14.4
 def ACCC_Host : Clause<"host"> {
   let flangClassValue = "AccObjectList";
 }
 
-// 2.5.4
+// 2.5.5
 def ACCC_If : Clause <"if"> {
   let flangClassValue = "ScalarLogicalExpr";
 }
 
 // 2.14.4
 def ACCC_IfPresent : Clause<"if_present"> {}
 
-// 2.9.9
+// 2.9.6
 def ACCC_Independent : Clause<"independent"> {}
 
-// 2.13
+// 2.13.3
 def ACCC_Link : Clause<"link"> {
   let flangClassValue = "AccObjectList";
 }
 
-// 2.7.9
+// 2.7.10
 def ACCC_NoCreate : Clause<"no_create"> {
   let flangClassValue = "AccObjectList";
 }
 
 // 2.15.1
 def ACCC_NoHost : Clause<"nohost"> {}
 
-// 2.5.8
+// 2.5.9
 def ACCC_NumGangs : Clause<"num_gangs"> {
   let flangClassValue = "ScalarIntExpr";
 }
 
-// 2.5.9
+// 2.5.10
 def ACCC_NumWorkers : Clause<"num_workers"> {
   let flangClassValue = "ScalarIntExpr";
 }
 
-// 2.7.4
+// 2.7.5
 def ACCC_Present : Clause<"present"> {
   let flangClassValue = "AccObjectList";
 }
 
-// 2.5.11
+// 2.5.12
 def ACCC_Private : Clause<"private"> {
   let flangClassValue = "AccObjectList";
 }
 
-// 2.9.7
+// 2.9.8
 def ACCC_Tile : Clause <"tile"> {
   let flangClassValue = "AccTileExprList";
 }
 
 // 2.8.1
 def ACCC_UseDevice : Clause <"use_device"> {
   let flangClassValue = "AccObjectList";
 }
 
 // 2.12
 def ACCC_Read : Clause<"read"> {}
 
-// 2.5.13
+// 2.5.14
 def ACCC_Reduction : Clause<"reduction"> {
   let flangClassValue = "AccObjectListWithReduction";
 }
 
-// 2.5.5
+// 2.5.6
 def ACCC_Self : Clause<"self"> {
   let flangClassValue = "ScalarLogicalExpr";
   let isValueOptional = true;
 }
 
 // 2.9.5
 def ACCC_Seq : Clause<"seq"> {}
 
 // 2.9.4
 def ACCC_Vector : Clause<"vector"> {
   let flangClassValue = "ScalarIntExpr";
   let isValueOptional = true;
 }
 
-// 2.5.10
+// 2.5.11
 def ACCC_VectorLength : Clause<"vector_length"> {
   let flangClassValue = "ScalarIntExpr";
 }
 
 // 2.16.2
 def ACCC_Wait : Clause<"wait"> {
   let flangClassValue = "AccWaitArgument";
   let isValueOptional = true;
let allowedClauses = [
     VersionedClause<ACCC_Create>,
     VersionedClause<ACCC_Present>,
     VersionedClause<ACCC_DevicePtr>,
     VersionedClause<ACCC_DeviceResident>,
     VersionedClause<ACCC_Link>
   ];
 }
 
-// 2.5.2
+// 2.5.3
 def ACC_Kernels : Directive<"kernels"> {
   let allowedClauses = [
     VersionedClause<ACCC_Attach>,
     VersionedClause<ACCC_Copy>,
     VersionedClause<ACCC_Copyin>,
     VersionedClause<ACCC_Copyout>,
     VersionedClause<ACCC_Create>,
     VersionedClause<ACCC_DeviceType>,
let allowedOnceClauses = [
     VersionedClause<ACCC_NumGangs>,
     VersionedClause<ACCC_NumWorkers>,
     VersionedClause<ACCC_Reduction>,
     VersionedClause<ACCC_Self>,
     VersionedClause<ACCC_VectorLength>
   ];
 }
 
-// 2.5.3
+// 2.5.2
 def ACC_Serial : Directive<"serial"> {
   let allowedClauses = [
     VersionedClause<ACCC_Attach>,
     VersionedClause<ACCC_Copy>,
     VersionedClause<ACCC_Copyin>,
     VersionedClause<ACCC_Copyout>,
     VersionedClause<ACCC_Create>,
     VersionedClause<ACCC_DevicePtr>,
let allowedClauses = [
     VersionedClause<ACCC_Finalize>
   ];
   let requiredClauses = [
     VersionedClause<ACCC_Copyout>,
     VersionedClause<ACCC_Delete>,
     VersionedClause<ACCC_Detach>
   ];
 }
+
+// 2.8
 def ACC_HostData : Directive<"host_data"> {
   let allowedClauses = [
     VersionedClause<ACCC_If>,
     VersionedClause<ACCC_IfPresent>
   ];
   let requiredClauses = [
     VersionedClause<ACCC_UseDevice>
   ];

mlir/include/mlir/Dialect/OpenACC/OpenACC.h

 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/OpenACC/OpenACCOps.h.inc"
 
 namespace mlir {
 namespace acc {
 
 /// Enumeration used to encode the execution mapping on a loop construct.
-/// They refer directly to the OpenACC 3.0 standard:
+/// They refer directly to the OpenACC 3.1 standard:
 /// 2.9.2. gang
 /// 2.9.3. worker
 /// 2.9.4. vector
 ///
 /// Value can be combined bitwise to reflect the mapping applied to the
 /// construct. e.g. `acc.loop gang vector`, the `gang` and `vector` could be
 /// combined and the final mapping value would be 5 (4 | 1).
 enum OpenACCExecMapping { NONE = 0, VECTOR = 1, WORKER = 2, GANG = 4 };
 
 } // end namespace acc
 } // end namespace mlir
 
 #endif // MLIR_DIALECT_OPENACC_OPENACC_H_

mlir/include/mlir/Dialect/OpenACC/OpenACCOps.td

 include "mlir/IR/OpBase.td"
 
 def OpenACC_Dialect : Dialect {
   let name = "acc";
 
   let summary = "An OpenACC dialect for MLIR.";
 
   let description = [{
-    This dialect models the construct from the OpenACC 3.0 directive language.
+    This dialect models the construct from the OpenACC 3.1 directive language.
   }];
 
   let cppNamespace = "::mlir::acc";
 }
 
 // Base class for OpenACC dialect ops.
 class OpenACC_Op<string mnemonic, list<OpTrait> traits = []> :
   Op<OpenACC_Dialect, mnemonic, traits> {