[openacc][NFC] Bump parser support number to OpenACC 3.3

[clementval]

Summary

Parser support reached OpenACC 3.3 specification.
Bump the numbers to reflect the latest specs.

[awarzynski]

LGTM

Dump the numbers to reflect the latest specs.

Bump? ;-)

[clementval]

In D154249#4464962, @awarzynski wrote:

LGTM

Dump the numbers to reflect the latest specs.

Bump? ;-)

Good catch! :-)

[razvanlupusoru]

Awesome work. Thank you!

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

struct OpenMPConstruct {
   std::variant<OpenMPStandaloneConstruct, OpenMPSectionsConstruct,
       OpenMPSectionConstruct, OpenMPLoopConstruct, OpenMPBlockConstruct,
       OpenMPAtomicConstruct, OpenMPDeclarativeAllocate,
       OpenMPExecutableAllocate, OpenMPAllocatorsConstruct,
       OpenMPCriticalConstruct>
       u;
 };
 
-// Parse tree nodes for OpenACC 3.1 directives and clauses
+// Parse tree nodes for OpenACC 3.3 directives and clauses
 
 struct AccObject {
   UNION_CLASS_BOILERPLATE(AccObject);
   std::variant<Designator, /*common block*/ Name> u;
 };
 
 WRAPPER_CLASS(AccObjectList, std::list<AccObject>);
 
struct AccDataModifier {
   CharBlock source;
 };
 
 struct AccObjectListWithModifier {
   TUPLE_CLASS_BOILERPLATE(AccObjectListWithModifier);
   std::tuple<std::optional<AccDataModifier>, AccObjectList> t;
 };
 
-// 2.5.13: + | * | max | min | iand | ior | ieor | .and. | .or. | .eqv. | .neqv.
+// 2.5.15: + | * | max | min | iand | ior | ieor | .and. | .or. | .eqv. | .neqv.
 struct AccReductionOperator {
   ENUM_CLASS(
       Operator, Plus, Multiply, Max, Min, Iand, Ior, Ieor, And, Or, Eqv, Neqv)
   WRAPPER_CLASS_BOILERPLATE(AccReductionOperator, Operator);
   CharBlock source;
 };
 
 struct AccObjectListWithReduction {

flang/lib/Frontend/CompilerInvocation.cpp

void CompilerInvocation::setDefaultPredefinitions() {
   fortranOptions.predefinitions.emplace_back("__flang_minor__",
                                              FLANG_VERSION_MINOR_STRING);
   fortranOptions.predefinitions.emplace_back("__flang_patchlevel__",
                                              FLANG_VERSION_PATCHLEVEL_STRING);
 
   // Add predefinitions based on extensions enabled
   if (frontendOptions.features.IsEnabled(
           Fortran::common::LanguageFeature::OpenACC)) {
-    fortranOptions.predefinitions.emplace_back("_OPENACC", "202011");
+    fortranOptions.predefinitions.emplace_back("_OPENACC", "202211");
   }
   if (frontendOptions.features.IsEnabled(
           Fortran::common::LanguageFeature::OpenMP)) {
     Fortran::common::setOpenMPMacro(getLangOpts().OpenMPVersion,
                                     fortranOptions.predefinitions);
   }
   llvm::Triple targetTriple{llvm::Triple(this->targetOpts.triple)};
   if (targetTriple.getArch() == llvm::Triple::ArchType::x86_64) {

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.1.
+// Top-level grammar specification for OpenACC 3.3.
 
 #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"

 TYPE_PARSER(construct<AccObjectList>(nonemptyList(Parser<AccObject>{})))
 
 TYPE_PARSER(construct<AccObjectListWithModifier>(
     maybe(Parser<AccDataModifier>{}), Parser<AccObjectList>{}))
 
 TYPE_PARSER(construct<AccObjectListWithReduction>(
     Parser<AccReductionOperator>{} / ":", Parser<AccObjectList>{}))
 
-// 2.16.3 (2485) wait-argument is:
+// 2.16 (3249) wait-argument is:
 //   [devnum : int-expr :] [queues :] int-expr-list
 TYPE_PARSER(construct<AccWaitArgument>(maybe("DEVNUM:" >> scalarIntExpr / ":"),
     "QUEUES:" >> nonemptyList(scalarIntExpr) || nonemptyList(scalarIntExpr)))
 
-// 2.9 (1609) size-expr is one of:
+// 2.9 (1984-1986) size-expr is one of:
 //   * (represented as an empty std::optional<ScalarIntExpr>)
 //   int-expr
 TYPE_PARSER(construct<AccSizeExpr>(scalarIntExpr) ||
     construct<AccSizeExpr>("*" >> construct<std::optional<ScalarIntExpr>>()))
 TYPE_PARSER(construct<AccSizeExprList>(nonemptyList(Parser<AccSizeExpr>{})))
 
 TYPE_PARSER(construct<AccDeviceTypeExpr>(scalarIntExpr) ||
     construct<AccDeviceTypeExpr>(
         "*" >> construct<std::optional<ScalarIntExpr>>()))
 TYPE_PARSER(
     construct<AccDeviceTypeExprList>(nonemptyList(Parser<AccDeviceTypeExpr>{})))
 
 // tile size is one of:
 //   * (represented as an empty std::optional<ScalarIntExpr>)
 //   constant-int-expr
 TYPE_PARSER(construct<AccTileExpr>(scalarIntConstantExpr) ||
     construct<AccTileExpr>(
         "*" >> construct<std::optional<ScalarIntConstantExpr>>()))
 TYPE_PARSER(construct<AccTileExprList>(nonemptyList(Parser<AccTileExpr>{})))
 
-// 2.9 gang-arg is one of :
+// 2.9 (1979-1982) gang-arg is one of :
 //   [num:]int-expr
 //   dim:int-expr
 //   static:size-expr
 TYPE_PARSER(construct<AccGangArg>(construct<AccGangArg::Static>(
                 "STATIC: " >> Parser<AccSizeExpr>{})) ||
     construct<AccGangArg>(
         construct<AccGangArg::Dim>("DIM: " >> scalarIntExpr)) ||
     construct<AccGangArg>(
         construct<AccGangArg::Num>(maybe("NUM: "_tok) >> scalarIntExpr)))
 
 // 2.9 gang-arg-list
 TYPE_PARSER(
     construct<AccGangArgList>(many(maybe(","_tok) >> Parser<AccGangArg>{})))
 
 // 2.9.1 collapse
 TYPE_PARSER(construct<AccCollapseArg>(
     "FORCE:"_tok >> pure(true) || pure(false), scalarIntConstantExpr))
 
-// 2.5.13 Reduction
+// 2.5.15 Reduction
 // Operator for reduction
 TYPE_PARSER(sourced(construct<AccReductionOperator>(
     first("+" >> pure(AccReductionOperator::Operator::Plus),
         "*" >> pure(AccReductionOperator::Operator::Multiply),
         "MAX" >> pure(AccReductionOperator::Operator::Max),
         "MIN" >> pure(AccReductionOperator::Operator::Min),
         "IAND" >> pure(AccReductionOperator::Operator::Iand),
         "IOR" >> pure(AccReductionOperator::Operator::Ior),
         "IEOR" >> pure(AccReductionOperator::Operator::Ieor),
         ".AND." >> pure(AccReductionOperator::Operator::And),
         ".OR." >> pure(AccReductionOperator::Operator::Or),
         ".EQV." >> pure(AccReductionOperator::Operator::Eqv),
         ".NEQV." >> pure(AccReductionOperator::Operator::Neqv)))))
 
 // 2.15.1 Bind clause
 TYPE_PARSER(sourced(construct<AccBindClause>(name)) ||
     sourced(construct<AccBindClause>(scalarDefaultCharExpr)))
 
-// 2.5.14 Default clause
+// 2.5.16 Default clause
 TYPE_PARSER(construct<AccDefaultClause>(
     first("NONE" >> pure(llvm::acc::DefaultValue::ACC_Default_none),
         "PRESENT" >> pure(llvm::acc::DefaultValue::ACC_Default_present))))
 
 // SELF clause is either a simple optional condition for compute construct
 // or a synonym of the HOST clause for the update directive 2.14.4 holding
 // an object list.
 TYPE_PARSER(construct<AccSelfClause>(Parser<AccObjectList>{}) ||

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 3.1 structure validity check list
+// OpenACC 3.3 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/tools/bbc/bbc.cpp

int main(int argc, char **argv) {
   if (enableOpenMP) {
     options.features.Enable(Fortran::common::LanguageFeature::OpenMP);
     Fortran::common::setOpenMPMacro(setOpenMPVersion, options.predefinitions);
   }
 
   // enable parsing of OpenACC
   if (enableOpenACC) {
     options.features.Enable(Fortran::common::LanguageFeature::OpenACC);
-    options.predefinitions.emplace_back("_OPENACC", "202011");
+    options.predefinitions.emplace_back("_OPENACC", "202211");
   }
 
   Fortran::common::IntrinsicTypeDefaultKinds defaultKinds;
   Fortran::parser::AllSources allSources;
   Fortran::parser::AllCookedSources allCookedSources(allSources);
   Fortran::semantics::SemanticsContext semanticsContext{
       defaultKinds, options.features, allCookedSources};
   semanticsContext.set_moduleDirectory(moduleDir)

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 3.1 directives and clauses.
+// This is the definition file for OpenACC 3.3 directives and clauses.
 //
 //===----------------------------------------------------------------------===//
 
 include "llvm/Frontend/Directive/DirectiveBase.td"
 
 //===----------------------------------------------------------------------===//
 // Definition of general OpenACC information
 //===----------------------------------------------------------------------===//
def ACCC_Collapse : Clause<"collapse"> {
   let flangClass = "AccCollapseArg";
 }
 
 // 2.7.6
 def ACCC_Copy : Clause<"copy"> {
   let flangClass = "AccObjectList";
   let aliases = ["present_or_copy", "pcopy"];
 }
+
 // 2.7.7
 def ACCC_Copyin : Clause<"copyin"> {
   let flangClass = "AccObjectListWithModifier";
   let aliases = ["present_or_copyin", "pcopyin"];
 }
 
 // 2.7.8
 def ACCC_Copyout : Clause<"copyout"> {
   let flangClass = "AccObjectListWithModifier";
   let aliases = ["present_or_copyout", "pcopyout"];
 }
 
 // 2.7.9
 def ACCC_Create : Clause<"create"> {
   let flangClass = "AccObjectListWithModifier";
   let aliases = ["present_or_create", "pcreate"];
 }
 
-// 2.5.15
+// 2.5.16
 def ACC_Default_none : ClauseVal<"none", 1, 1> { let isDefault = 1; }
 def ACC_Default_present : ClauseVal<"present", 0, 1> {}
 
 def ACCC_Default : Clause<"default"> {
   let flangClass = "AccDefaultClause";
   let enumClauseValue = "DefaultValue";
   let allowedClauseValues = [
     ACC_Default_present,
def ACCC_DeviceType : Clause<"device_type"> {
   let flangClass = "AccDeviceTypeExprList";
   let defaultValue = "*";
   let aliases = ["dtype"];
 }
 
 // 2.6.6
 def ACCC_Finalize : Clause<"finalize"> {}
 
-// 2.5.13
+// 2.5.14
 def ACCC_FirstPrivate : Clause<"firstprivate"> {
   let flangClass = "AccObjectList";
 }
 
 // 2.9.2
 def ACCC_Gang : Clause<"gang"> {
   let flangClass = "AccGangArgList";
   let isValueOptional = true;
 }
 
 // 2.14.4
 def ACCC_Host : Clause<"host"> {
   let flangClass = "AccObjectList";
 }
 
-// 2.5.5
+// 2.5.6
 def ACCC_If : Clause <"if"> {
   let flangClass = "ScalarLogicalExpr";
 }
 
 // 2.14.4
 def ACCC_IfPresent : Clause<"if_present"> {}
 
 // 2.9.6
 def ACCC_Independent : Clause<"independent"> {}
 
 // 2.13.3
 def ACCC_Link : Clause<"link"> {
   let flangClass = "AccObjectList";
 }
 
 // 2.7.10
 def ACCC_NoCreate : Clause<"no_create"> {
   let flangClass = "AccObjectList";
 }
 
 // 2.15.1
 def ACCC_NoHost : Clause<"nohost"> {}
 
-// 2.5.9
+// 2.5.10
 def ACCC_NumGangs : Clause<"num_gangs"> {
   let flangClass = "ScalarIntExpr";
   let isValueList = 1;
 }
 
-// 2.5.10
+// 2.5.11
 def ACCC_NumWorkers : Clause<"num_workers"> {
   let flangClass = "ScalarIntExpr";
 }
 
 // 2.7.5
 def ACCC_Present : Clause<"present"> {
   let flangClass = "AccObjectList";
 }
 
-// 2.5.12
+// 2.5.13
 def ACCC_Private : Clause<"private"> {
   let flangClass = "AccObjectList";
 }
 
 // 2.9.8
 def ACCC_Tile : Clause <"tile"> {
   let flangClass = "AccTileExprList";
 }
 
 // 2.8.1
 def ACCC_UseDevice : Clause <"use_device"> {
   let flangClass = "AccObjectList";
 }
 
 // 2.12
 def ACCC_Read : Clause<"read"> {}
 
-// 2.5.14
+// 2.5.15
 def ACCC_Reduction : Clause<"reduction"> {
   let flangClass = "AccObjectListWithReduction";
 }
 
-// 2.5.6
+// 2.5.7
 def ACCC_Self : Clause<"self"> {
   let flangClass = "AccSelfClause";
   let isValueOptional = true;
 }
 
 // 2.9.5
 def ACCC_Seq : Clause<"seq"> {}
 
 // 2.9.4
 def ACCC_Vector : Clause<"vector"> {
   let flangClass = "ScalarIntExpr";
   let isValueOptional = true;
   let prefix = "length";
 }
 
-// 2.5.11
+// 2.5.12
 def ACCC_VectorLength : Clause<"vector_length"> {
   let flangClass = "ScalarIntExpr";
 }
 
 // 2.16.2
 def ACCC_Wait : Clause<"wait"> {
   let flangClass = "AccWaitArgument";
   let isValueOptional = true;

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.1 standard:
+/// They refer directly to the OpenACC 3.3 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 };
 
 } // namespace acc
 } // namespace mlir
 
 #endif // MLIR_DIALECT_OPENACC_OPENACC_H_

mlir/include/mlir/Dialect/OpenACC/OpenACCBase.td

 include "mlir/IR/AttrTypeBase.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.1 directive language.
+    This dialect models the construct from the OpenACC 3.3 directive language.
   }];
 
   let useDefaultAttributePrinterParser = 1;
   let useDefaultTypePrinterParser = 1;
   let usePropertiesForAttributes = 1;
   let cppNamespace = "::mlir::acc";
   let dependentDialects = ["::mlir::memref::MemRefDialect","::mlir::LLVM::LLVMDialect"];
 }
 
 #endif // OPENACC_BASE