[flang][openacc][NFC] Extract device_type parser to its own

[clementval]

Summary

Move the device_type parser to a separate parser AccDeviceTypeExprList. Preparatory work for D106968.

[clementval]

Rebase

[kiranchandramohan]

LG.

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

#include "llvm/Frontend/OpenACC/ACC.inc"
   NODE(parser, AccObjectListWithModifier)
   NODE(parser, AccObjectListWithReduction)
   NODE(parser, AccReductionOperator)
   NODE_ENUM(parser::AccReductionOperator, Operator)
   NODE(parser, AccSizeExpr)
   NODE(parser, AccSizeExprList)
   NODE(parser, AccSelfClause)
   NODE(parser, AccStandaloneDirective)
+  NODE(parser, AccDeviceTypeExpr)
+  NODE(parser, AccDeviceTypeExprList)
   NODE(parser, AccTileExpr)
   NODE(parser, AccTileExprList)
   NODE(parser, AccLoopDirective)
   NODE(parser, AccWaitArgument)
   static std::string GetNodeName(const llvm::acc::Directive &x) {
     return llvm::Twine(
         "llvm::acc::Directive = ", llvm::acc::getOpenACCDirectiveName(x))
         .str();

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

struct AccObjectListWithReduction {
   std::tuple<AccReductionOperator, AccObjectList> t;
 };
 
 struct AccWaitArgument {
   TUPLE_CLASS_BOILERPLATE(AccWaitArgument);
   std::tuple<std::optional<ScalarIntExpr>, std::list<ScalarIntExpr>> t;
 };
 
+struct AccDeviceTypeExpr {
+  TUPLE_CLASS_BOILERPLATE(AccDeviceTypeExpr);
+  CharBlock source;
+  std::tuple<std::optional<ScalarIntExpr>> t; // if null then *
+};
+
+struct AccDeviceTypeExprList {
+  WRAPPER_CLASS_BOILERPLATE(
+      AccDeviceTypeExprList, std::list<AccDeviceTypeExpr>);
+};
+
 struct AccTileExpr {
   TUPLE_CLASS_BOILERPLATE(AccTileExpr);
   CharBlock source;
   std::tuple<std::optional<ScalarIntConstantExpr>> t; // if null then *
 };
 
 struct AccTileExprList {
   WRAPPER_CLASS_BOILERPLATE(AccTileExprList, std::list<AccTileExpr>);

flang/lib/Lower/OpenACC.cpp

for (const auto &clause : accClauseList.v) {
     } else if (const auto *deviceNumClause =
                    std::get_if<Fortran::parser::AccClause::DeviceNum>(
                        &clause.u)) {
       deviceNum = fir::getBase(converter.genExprValue(
           *Fortran::semantics::GetExpr(deviceNumClause->v)));
     } else if (const auto *deviceTypeClause =
                    std::get_if<Fortran::parser::AccClause::DeviceType>(
                        &clause.u)) {
-
-      const auto &deviceTypeValue = deviceTypeClause->v;
-      if (deviceTypeValue) {
-        for (const auto &scalarIntExpr : *deviceTypeValue) {
-          mlir::Value expr = fir::getBase(converter.genExprValue(
-              *Fortran::semantics::GetExpr(scalarIntExpr)));
-          deviceTypeOperands.push_back(expr);
-        }
+      const Fortran::parser::AccDeviceTypeExprList &deviceTypeExprList =
+          deviceTypeClause->v;
+      for (const auto &deviceTypeExpr : deviceTypeExprList.v) {
+        const auto &expr =
+            std::get<std::optional<Fortran::parser::ScalarIntExpr>>(
+                deviceTypeExpr.t);
+        if (expr) {
+          deviceTypeOperands.push_back(fir::getBase(
+              converter.genExprValue(*Fortran::semantics::GetExpr(*expr))));
         } else {
           // * was passed as value and will be represented as a -1 constant
           // integer.
           mlir::Value star = firOpBuilder.createIntegerConstant(
-            currentLocation, firOpBuilder.getIntegerType(32), /* STAR */ -1);
+              currentLocation, firOpBuilder.getIntegerType(32),
+              /* STAR */ -1);
           deviceTypeOperands.push_back(star);
         }
       }
     }
+  }
 
   // Prepare the operand segement size attribute and the operands value range.
   SmallVector<mlir::Value, 6> operands;
   SmallVector<int32_t, 3> operandSegments;
   addOperands(operands, operandSegments, deviceTypeOperands);
   addOperand(operands, operandSegments, deviceNum);
   addOperand(operands, operandSegments, ifCond);
 
if (const auto *ifClause =
           waitDevnum = fir::getBase(converter.genExprValue(
               *Fortran::semantics::GetExpr(*waitDevnumValue)));
       } else {
         addWaitAttr = true;
       }
     } else if (const auto *deviceTypeClause =
                    std::get_if<Fortran::parser::AccClause::DeviceType>(
                        &clause.u)) {
-
-      const auto &deviceTypeValue = deviceTypeClause->v;
-      if (deviceTypeValue) {
-        for (const auto &scalarIntExpr : *deviceTypeValue) {
-          mlir::Value expr = fir::getBase(converter.genExprValue(
-              *Fortran::semantics::GetExpr(scalarIntExpr)));
-          deviceTypeOperands.push_back(expr);
-        }
+      const Fortran::parser::AccDeviceTypeExprList &deviceTypeExprList =
+          deviceTypeClause->v;
+      for (const auto &deviceTypeExpr : deviceTypeExprList.v) {
+        const auto &expr =
+            std::get<std::optional<Fortran::parser::ScalarIntExpr>>(
+                deviceTypeExpr.t);
+        if (expr) {
+          deviceTypeOperands.push_back(fir::getBase(
+              converter.genExprValue(*Fortran::semantics::GetExpr(*expr))));
         } else {
           // * was passed as value and will be represented as a -1 constant
           // integer.
           mlir::Value star = firOpBuilder.createIntegerConstant(
-            currentLocation, firOpBuilder.getIntegerType(32), /* STAR */ -1);
+              currentLocation, firOpBuilder.getIntegerType(32),
+              /* STAR */ -1);
           deviceTypeOperands.push_back(star);
         }
+      }
     } else if (const auto *hostClause =
                    std::get_if<Fortran::parser::AccClause::Host>(&clause.u)) {
       genObjectList(hostClause->v, converter, hostOperands);
     } else if (const auto *deviceClause =
                    std::get_if<Fortran::parser::AccClause::Device>(&clause.u)) {
       genObjectList(deviceClause->v, converter, deviceOperands);
     }
   }

flang/lib/Parser/openacc-parsers.cpp

TYPE_PARSER("AUTO" >> construct<AccClause>(construct<AccClause::Auto>()) ||
     "DEVICEPTR" >> construct<AccClause>(construct<AccClause::Deviceptr>(
                        parenthesized(Parser<AccObjectList>{}))) ||
     "DEVICE_NUM" >> construct<AccClause>(construct<AccClause::DeviceNum>(
                         parenthesized(scalarIntExpr))) ||
     "DEVICE_RESIDENT" >>
         construct<AccClause>(construct<AccClause::DeviceResident>(
             parenthesized(Parser<AccObjectList>{}))) ||
     ("DEVICE_TYPE"_tok || "DTYPE"_tok) >>
-        construct<AccClause>(construct<AccClause::DeviceType>(parenthesized(
-            "*" >> construct<std::optional<std::list<ScalarIntExpr>>>()))) ||
-    ("DEVICE_TYPE"_tok || "DTYPE"_tok) >>
         construct<AccClause>(construct<AccClause::DeviceType>(
-            parenthesized(maybe(nonemptyList(scalarIntExpr))))) ||
+            parenthesized(Parser<AccDeviceTypeExprList>{}))) ||
     "FINALIZE" >> construct<AccClause>(construct<AccClause::Finalize>()) ||
     "FIRSTPRIVATE" >> construct<AccClause>(construct<AccClause::Firstprivate>(
                           parenthesized(Parser<AccObjectList>{}))) ||
     "GANG" >> construct<AccClause>(construct<AccClause::Gang>(
                   maybe(parenthesized(Parser<AccGangArgument>{})))) ||
     "HOST" >> construct<AccClause>(construct<AccClause::Host>(
                   parenthesized(Parser<AccObjectList>{}))) ||
     "IF" >> construct<AccClause>(

 
 // 2.9 (1609) 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>{})))
 

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

 
 // 2.13.1
 def ACCC_DeviceResident : Clause<"device_resident"> {
   let flangClass = "AccObjectList";
 }
 
 // 2.4
 def ACCC_DeviceType : Clause<"device_type"> {
-  let flangClass = "ScalarIntExpr";
+  let flangClass = "AccDeviceTypeExprList";
   let defaultValue = "*";
-  let isValueOptional = true;
-  let isValueList = true;
 }
 
 // 2.6.6
 def ACCC_Finalize : Clause<"finalize"> {}
 
 // 2.5.13
 def ACCC_FirstPrivate : Clause<"firstprivate"> {
   let flangClass = "AccObjectList";