[flang][NFC] Remove obsolete DoLoopHelper

[clementval]

Summary

During the upstreaming process from fir-dev some
new builder have been introduced in the flang/Optimizer/Builder
directory. This patch removes the obsolete DoLoopHelper still present
in the lowering directories and makes use of the new one where needed.

This patch is part of the upstreaming effort from fir-dev branch.

[kiranchandramohan]

LGTM.

flang/include/flang/Lower/DoLoopHelper.h

-//===-- Lower/DoLoopHelper.h -- gen fir.do_loop ops -------------*- 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
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef FORTRAN_LOWER_DOLOOPHELPER_H
-#define FORTRAN_LOWER_DOLOOPHELPER_H
-
-#include "flang/Optimizer/Builder/FIRBuilder.h"
-
-namespace Fortran::lower {
-
-/// Helper to build fir.do_loop Ops.
-class DoLoopHelper {
-public:
-  explicit DoLoopHelper(fir::FirOpBuilder &builder, mlir::Location loc)
-      : builder(builder), loc(loc) {}
-  DoLoopHelper(const DoLoopHelper &) = delete;
-
-  /// Type of a callback to generate the loop body.
-  using BodyGenerator = std::function<void(fir::FirOpBuilder &, mlir::Value)>;
-
-  /// Build loop [\p lb, \p ub] with step \p step.
-  /// If \p step is an empty value, 1 is used for the step.
-  void createLoop(mlir::Value lb, mlir::Value ub, mlir::Value step,
-                  const BodyGenerator &bodyGenerator);
-
-  /// Build loop [\p lb,  \p ub] with step 1.
-  void createLoop(mlir::Value lb, mlir::Value ub,
-                  const BodyGenerator &bodyGenerator);
-
-  /// Build loop [0, \p count) with step 1.
-  void createLoop(mlir::Value count, const BodyGenerator &bodyGenerator);
-
-private:
-  fir::FirOpBuilder &builder;
-  mlir::Location loc;
-};
-
-} // namespace Fortran::lower
-
-#endif // FORTRAN_LOWER_DOLOOPHELPER_H

flang/lib/Lower/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 
 add_flang_library(FortranLower
   CharacterExpr.cpp
   CharacterRuntime.cpp
   Coarray.cpp
   ComplexExpr.cpp
   ConvertType.cpp
-  DoLoopHelper.cpp
   IntrinsicCall.cpp
   IO.cpp
   Mangler.cpp
   OpenACC.cpp
   OpenMP.cpp
   PFTBuilder.cpp
 
   DEPENDS

flang/lib/Lower/CharacterExpr.cpp

 //===-- CharacterExpr.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Lower/CharacterExpr.h"
 #include "flang/Lower/ConvertType.h"
-#include "flang/Lower/DoLoopHelper.h"
 #include "flang/Lower/IntrinsicCall.h"
+#include "flang/Optimizer/Builder/DoLoopHelper.h"
 
 //===----------------------------------------------------------------------===//
 // CharacterExprHelper implementation
 //===----------------------------------------------------------------------===//
 
 /// Get fir.char<kind> type with the same kind as inside str.
 static fir::CharacterType getCharacterType(mlir::Type type) {
   if (auto boxType = type.dyn_cast<fir::BoxCharType>())
void Fortran::lower::CharacterExprHelper::createStoreCharAt(
   auto addr = builder.create<fir::CoordinateOp>(loc, getReferenceType(str),
                                                 str.getBuffer(), index);
   builder.create<fir::StoreOp>(loc, c, addr);
 }
 
 void Fortran::lower::CharacterExprHelper::createCopy(
     const fir::CharBoxValue &dest, const fir::CharBoxValue &src,
     mlir::Value count) {
-  Fortran::lower::DoLoopHelper{builder, loc}.createLoop(
+  fir::factory::DoLoopHelper{builder, loc}.createLoop(
       count, [&](fir::FirOpBuilder &, mlir::Value index) {
         auto charVal = createLoadCharAt(src, index);
         createStoreCharAt(dest, index, charVal);
       });
 }
 
 void Fortran::lower::CharacterExprHelper::createPadding(
     const fir::CharBoxValue &str, mlir::Value lower, mlir::Value upper) {
   auto blank = createBlankConstant(getCharacterType(str));
   // Always create the loop, if upper < lower, no iteration will be
   // executed.
-  Fortran::lower::DoLoopHelper{builder, loc}.createLoop(
+  fir::factory::DoLoopHelper{builder, loc}.createLoop(
       lower, upper, [&](fir::FirOpBuilder &, mlir::Value index) {
         createStoreCharAt(str, index, blank);
       });
 }
 
 fir::CharBoxValue
 Fortran::lower::CharacterExprHelper::createTemp(mlir::Type type,
                                                 mlir::Value len) {
fir::CharBoxValue Fortran::lower::CharacterExprHelper::createConcatenate(
   mlir::Value len =
       builder.create<mlir::arith::AddIOp>(loc, lhs.getLen(), rhs.getLen());
   auto temp = createTemp(getCharacterType(rhs), len);
   createCopy(temp, lhs, lhs.getLen());
   auto one = builder.createIntegerConstant(loc, len.getType(), 1);
   auto upperBound = builder.create<mlir::arith::SubIOp>(loc, len, one);
   auto lhsLen =
       builder.createConvert(loc, builder.getIndexType(), lhs.getLen());
-  Fortran::lower::DoLoopHelper{builder, loc}.createLoop(
+  fir::factory::DoLoopHelper{builder, loc}.createLoop(
       lhs.getLen(), upperBound, one,
       [&](fir::FirOpBuilder &bldr, mlir::Value index) {
         auto rhsIndex = bldr.create<mlir::arith::SubIOp>(loc, index, lhsLen);
         auto charVal = createLoadCharAt(rhs, rhsIndex);
         createStoreCharAt(temp, index, charVal);
       });
   return temp;
 }

flang/lib/Lower/DoLoopHelper.cpp

-//===-- DoLoopHelper.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
-//
-//===----------------------------------------------------------------------===//
-
-#include "flang/Lower/DoLoopHelper.h"
-
-//===----------------------------------------------------------------------===//
-// DoLoopHelper implementation
-//===----------------------------------------------------------------------===//
-
-void Fortran::lower::DoLoopHelper::createLoop(
-    mlir::Value lb, mlir::Value ub, mlir::Value step,
-    const BodyGenerator &bodyGenerator) {
-  auto lbi = builder.convertToIndexType(loc, lb);
-  auto ubi = builder.convertToIndexType(loc, ub);
-  assert(step && "step must be an actual Value");
-  auto inc = builder.convertToIndexType(loc, step);
-  auto loop = builder.create<fir::DoLoopOp>(loc, lbi, ubi, inc);
-  auto insertPt = builder.saveInsertionPoint();
-  builder.setInsertionPointToStart(loop.getBody());
-  auto index = loop.getInductionVar();
-  bodyGenerator(builder, index);
-  builder.restoreInsertionPoint(insertPt);
-}
-
-void Fortran::lower::DoLoopHelper::createLoop(
-    mlir::Value lb, mlir::Value ub, const BodyGenerator &bodyGenerator) {
-  createLoop(lb, ub,
-             builder.createIntegerConstant(loc, builder.getIndexType(), 1),
-             bodyGenerator);
-}
-
-void Fortran::lower::DoLoopHelper::createLoop(
-    mlir::Value count, const BodyGenerator &bodyGenerator) {
-  auto indexType = builder.getIndexType();
-  auto zero = builder.createIntegerConstant(loc, indexType, 0);
-  auto one = builder.createIntegerConstant(loc, count.getType(), 1);
-  auto up = builder.create<mlir::arith::SubIOp>(loc, count, one);
-  createLoop(zero, up, one, bodyGenerator);
-}