refactor

Author: SusanTan

flang/include/flang/Lower/OpenACC.h

@@ -122,8 +122,10 @@ void genOpenACCTerminator(fir::FirOpBuilder &, mlir::Operation *,
 /// clause.
 uint64_t getLoopCountForCollapseAndTile(const Fortran::parser::AccClauseList &);
 
-/// Returns only the collapse(N) depth (defaults to 1 when absent).
-uint64_t getLoopCountForCollapse(const Fortran::parser::AccClauseList &);
+/// Parse collapse clause and return {size, force}. If absent, returns
+/// {1,false}.
+std::pair<uint64_t, bool>
+getCollapseSizeAndForce(const Fortran::parser::AccClauseList &);
 
 /// Checks whether the current insertion point is inside OpenACC loop.
 bool isInOpenACCLoop(fir::FirOpBuilder &);

flang/lib/Lower/Bridge.cpp

@@ -3194,26 +3194,6 @@ class FirConverter : public Fortran::lower::AbstractConverter {
     bool collapseForce = false;
     uint64_t collapseDepth = 1;
     uint64_t loopCount = 1;
-    auto parseCollapse = [&](const Fortran::parser::AccClauseList &cl)
-        -> std::pair<bool, uint64_t> {
-      bool force = false;
-      uint64_t depth = 1;
-      for (const Fortran::parser::AccClause &clause : cl.v) {
-        if (const auto *collapseClause =
-                std::get_if<Fortran::parser::AccClause::Collapse>(&clause.u)) {
-          const Fortran::parser::AccCollapseArg &arg = collapseClause->v;
-          force = std::get<bool>(arg.t);
-          const auto &intExpr =
-              std::get<Fortran::parser::ScalarIntConstantExpr>(arg.t);
-          if (const auto *expr = Fortran::semantics::GetExpr(intExpr)) {
-            if (auto v = Fortran::evaluate::ToInt64(*expr))
-              depth = *v;
-          }
-          break;
-        }
-      }
-      return {force, depth};
-    };
 
     if (accLoop || accCombined) {
       if (accLoop) {
@@ -3222,17 +3202,17 @@ class FirConverter : public Fortran::lower::AbstractConverter {
         const Fortran::parser::AccClauseList &clauseList =
             std::get<Fortran::parser::AccClauseList>(beginLoopDir.t);
         loopCount = Fortran::lower::getLoopCountForCollapseAndTile(clauseList);
-        collapseDepth = Fortran::lower::getLoopCountForCollapse(clauseList);
-        std::tie(collapseForce, std::ignore) = parseCollapse(clauseList);
+        std::tie(collapseDepth, collapseForce) =
+            Fortran::lower::getCollapseSizeAndForce(clauseList);
       } else if (accCombined) {
         const Fortran::parser::AccBeginCombinedDirective &beginCombinedDir =
             std::get<Fortran::parser::AccBeginCombinedDirective>(
                 accCombined->t);
         const Fortran::parser::AccClauseList &clauseList =
             std::get<Fortran::parser::AccClauseList>(beginCombinedDir.t);
         loopCount = Fortran::lower::getLoopCountForCollapseAndTile(clauseList);
-        collapseDepth = Fortran::lower::getLoopCountForCollapse(clauseList);
-        std::tie(collapseForce, std::ignore) = parseCollapse(clauseList);
+        std::tie(collapseDepth, collapseForce) =
+            Fortran::lower::getCollapseSizeAndForce(clauseList);
       }
 
       if (curEval->lowerAsStructured()) {

flang/lib/Lower/OpenACC.cpp

@@ -4869,7 +4869,7 @@ void Fortran::lower::genEarlyReturnInOpenACCLoop(fir::FirOpBuilder &builder,
 
 uint64_t Fortran::lower::getLoopCountForCollapseAndTile(
     const Fortran::parser::AccClauseList &clauseList) {
-  uint64_t collapseLoopCount = getLoopCountForCollapse(clauseList);
+  uint64_t collapseLoopCount = getCollapseSizeAndForce(clauseList).first;
   uint64_t tileLoopCount = 1;
   for (const Fortran::parser::AccClause &clause : clauseList.v) {
     if (const auto *tileClause =
@@ -4881,18 +4881,22 @@ uint64_t Fortran::lower::getLoopCountForCollapseAndTile(
   return tileLoopCount > collapseLoopCount ? tileLoopCount : collapseLoopCount;
 }
 
-uint64_t Fortran::lower::getLoopCountForCollapse(
+std::pair<uint64_t, bool> Fortran::lower::getCollapseSizeAndForce(
     const Fortran::parser::AccClauseList &clauseList) {
+  uint64_t size = 1;
+  bool force = false;
   for (const Fortran::parser::AccClause &clause : clauseList.v) {
     if (const auto *collapseClause =
             std::get_if<Fortran::parser::AccClause::Collapse>(&clause.u)) {
       const Fortran::parser::AccCollapseArg &arg = collapseClause->v;
+      force = std::get<bool>(arg.t);
       const auto &collapseValue =
           std::get<Fortran::parser::ScalarIntConstantExpr>(arg.t);
-      return *Fortran::semantics::GetIntValue(collapseValue);
+      size = *Fortran::semantics::GetIntValue(collapseValue);
+      break;
     }
   }
-  return 1;
+  return {size, force};
 }
 
 /// Create an ACC loop operation for a DO construct when inside ACC compute