[flang][NFCI] Relpace `LoopOp` Op with `DoLoopOp` Op in FIR Dialect

[SouraVX]

Summary

Part of upstreaming effort,
PR: https://github.com/flang-compiler/f18-llvm-project/pull/296

[SouraVX]

Built and tested locally.

[schweitz]

In D95950#2539183, @SouraVX wrote:

Built and tested locally.

I think the fir-ops.fir test might need to be updated. (Actually, it looks like that part was already upstreamed.)

Thanks for the renaming merge!

[SouraVX]

In D95950#2539385, @schweitz wrote:

In D95950#2539183, @SouraVX wrote:

Built and tested locally.

I think the fir-ops.fir test might need to be updated.

Thanks for the renaming merge!

I noticed following snippet in fir-ops.fir, Suggesting some changes are already there ?

// CHECK-LABEL: func @loop() {
func @loop() {
...

// CHECK: fir.do_loop [[VAL_65:%.*]] = [[VAL_62]] to [[VAL_63]] step [[VAL_62]] {
...
    }
  }
  fir.unreachable
}

[SouraVX]

@schweitz, fir-ops.fir is marked as Unsupported. Seems like tco is not ready ?

// RUN: tco -emit-fir %s | tco -emit-fir | FileCheck %s
// UNSUPPORTED: !fir

[SouraVX]

Enabled tests for this in: https://reviews.llvm.org/D95958
Builds clean.
@mehdi_amini Apologies, I totally forgot and landed without your approval :(, if you have any concerns please share I'll try to address as a post commit thing or if you want I can revert it.

flang/include/flang/Optimizer/Dialect/FIROps.h

 #include "mlir/Interfaces/LoopLikeInterface.h"
 #include "mlir/Interfaces/SideEffectInterfaces.h"
 
 using namespace mlir;
 
 namespace fir {
 
 class FirEndOp;
-class LoopOp;
+class DoLoopOp;
 class RealAttr;
 
 void buildCmpFOp(mlir::OpBuilder &builder, mlir::OperationState &result,
                  mlir::CmpFPredicate predicate, mlir::Value lhs,
                  mlir::Value rhs);
 void buildCmpCOp(mlir::OpBuilder &builder, mlir::OperationState &result,
                  mlir::CmpFPredicate predicate, mlir::Value lhs,
                  mlir::Value rhs);
 unsigned getCaseArgumentOffset(llvm::ArrayRef<mlir::Attribute> cases,
                                unsigned dest);
-LoopOp getForInductionVarOwner(mlir::Value val);
+DoLoopOp getForInductionVarOwner(mlir::Value val);
 bool isReferenceLike(mlir::Type type);
 mlir::ParseResult isValidCaseAttr(mlir::Attribute attr);
 mlir::ParseResult parseCmpfOp(mlir::OpAsmParser &parser,
                               mlir::OperationState &result);
 mlir::ParseResult parseCmpcOp(mlir::OpAsmParser &parser,
                               mlir::OperationState &result);
 mlir::ParseResult parseSelector(mlir::OpAsmParser &parser,
                                 mlir::OperationState &result,

flang/include/flang/Optimizer/Dialect/FIROps.td

 }
 
 //===----------------------------------------------------------------------===//
 // Fortran loops
 //===----------------------------------------------------------------------===//
 
 def fir_ResultOp : fir_Op<"result",
     [NoSideEffect, ReturnLike, Terminator,
-     ParentOneOf<["WhereOp", "LoopOp", "IterWhileOp"]>]> {
+     ParentOneOf<["WhereOp", "DoLoopOp", "IterWhileOp"]>]> {
   let summary = "special terminator for use in fir region operations";
 
   let description = [{
     Result takes a list of ssa-values produced in the block and forwards them
     as a result to the operation that owns the region of the block. The
     operation can retain the values or return them to its parent block
     depending upon its semantics.
   }];

 class region_Op<string mnemonic, list<OpTrait> traits = []> :
     fir_Op<mnemonic,
     !listconcat(traits, [FirRegionTerminator, RecursiveSideEffects])> {
   let printer = [{ return ::print(p, *this); }];
   let verifier = [{ return ::verify(*this); }];
   let parser = [{ return ::parse$cppClass(parser, result); }];
 }
 
-def fir_LoopOp : region_Op<"do_loop",
+def fir_DoLoopOp : region_Op<"do_loop",
     [DeclareOpInterfaceMethods<LoopLikeOpInterface>]> {
   let summary = "generalized loop operation";
   let description = [{
     Generalized high-level looping construct. This operation is similar to
     MLIR's `loop.for`.
 
     ```mlir
       %l = constant 0 : index
def fir_WhereOp : region_Op<"if", [NoRegionArguments]> {
   }];
 }
 
 def fir_IterWhileOp : region_Op<"iterate_while",
     [DeclareOpInterfaceMethods<LoopLikeOpInterface>]> {
   let summary = "DO loop with early exit condition";
   let description = [{
     This construct is useful for lowering implied-DO loops. It is very similar
-    to `fir::LoopOp` with the addition that it requires a single loop-carried
+    to `fir::DoLoopOp` with the addition that it requires a single loop-carried
     bool value that signals an early exit condition to the operation. A `true`
     disposition means the next loop iteration should proceed. A `false`
     indicates that the `fir.iterate_while` operation should terminate and
     return its iteration arguments.
   }];
 
   let arguments = (ins
     Index:$lowerBound,

flang/include/flang/Optimizer/Transforms/Passes.td

 //===----------------------------------------------------------------------===//
 
 #ifndef FLANG_OPTIMIZER_TRANSFORMS_PASSES
 #define FLANG_OPTIMIZER_TRANSFORMS_PASSES
 
 include "mlir/Pass/PassBase.td"
 
 def AffineDialectPromotion : FunctionPass<"promote-to-affine"> {
-  let summary = "Promotes fir.loop and fir.where to affine.for and affine.if where possible";
+  let summary = "Promotes fir.do_loop and fir.where to affine.for and affine.if where possible";
   let description = [{
     TODO
   }];
   let constructor = "fir::createPromoteToAffinePass()";
 }
 
 def BasicCSE : FunctionPass<"basic-cse"> {
   let summary = "Basic common sub-expression elimination";

flang/lib/Lower/DoLoopHelper.cpp

 
 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::LoopOp>(loc, lbi, ubi, inc);
+  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(

flang/lib/Lower/IO.cpp

if constexpr (std::is_same_v<D, Fortran::parser::InputImpliedDo>)
                        true);
     else
       genOutputItemList(converter, cookie, itemList, insertPt, checkResult, ok,
                         true);
   };
   if (!checkResult) {
     // No I/O call result checks - the loop is a fir.do_loop op.
     auto loopOp =
-        builder.create<fir::LoopOp>(loc, lowerValue, upperValue, stepValue);
+        builder.create<fir::DoLoopOp>(loc, lowerValue, upperValue, stepValue);
     builder.setInsertionPointToStart(loopOp.getBody());
     auto lcv = builder.createConvert(loc, converter.genType(loopSym),
                                      loopOp.getInductionVar());
     builder.create<fir::StoreOp>(loc, lcv, loopVar);
     insertPt = builder.saveInsertionPoint();
     genItemList(ioImpliedDo, false);
     builder.restoreInsertionPoint(parentInsertPt);
     return;

flang/lib/Optimizer/Dialect/FIROps.cpp

 
 mlir::ParseResult fir::LoadOp::getElementOf(mlir::Type &ele, mlir::Type ref) {
   if ((ele = elementTypeOf(ref)))
     return mlir::success();
   return mlir::failure();
 }
 
 //===----------------------------------------------------------------------===//
-// LoopOp
+// DoLoopOp
 //===----------------------------------------------------------------------===//
 
-void fir::LoopOp::build(mlir::OpBuilder &builder, mlir::OperationState &result,
-                        mlir::Value lb, mlir::Value ub, mlir::Value step,
-                        bool unordered, mlir::ValueRange iterArgs,
+void fir::DoLoopOp::build(mlir::OpBuilder &builder,
+                          mlir::OperationState &result, mlir::Value lb,
+                          mlir::Value ub, mlir::Value step, bool unordered,
+                          mlir::ValueRange iterArgs,
                           llvm::ArrayRef<mlir::NamedAttribute> attributes) {
   result.addOperands({lb, ub, step});
   result.addOperands(iterArgs);
   for (auto v : iterArgs)
     result.addTypes(v.getType());
   mlir::Region *bodyRegion = result.addRegion();
   bodyRegion->push_back(new Block{});
   if (iterArgs.empty())
-    LoopOp::ensureTerminator(*bodyRegion, builder, result.location);
+    DoLoopOp::ensureTerminator(*bodyRegion, builder, result.location);
   bodyRegion->front().addArgument(builder.getIndexType());
   bodyRegion->front().addArguments(iterArgs.getTypes());
   if (unordered)
     result.addAttribute(unorderedAttrName(), builder.getUnitAttr());
   result.addAttributes(attributes);
 }
 
-static mlir::ParseResult parseLoopOp(mlir::OpAsmParser &parser,
+static mlir::ParseResult parseDoLoopOp(mlir::OpAsmParser &parser,
                                        mlir::OperationState &result) {
   auto &builder = parser.getBuilder();
   mlir::OpAsmParser::OperandType inductionVariable, lb, ub, step;
   // Parse the induction variable followed by '='.
   if (parser.parseRegionArgument(inductionVariable) || parser.parseEqual())
     return mlir::failure();
 
   // Parse loop bounds.
   auto indexType = builder.getIndexType();
   if (parser.parseOperand(lb) ||
       parser.resolveOperand(lb, indexType, result.operands) ||
       parser.parseKeyword("to") || parser.parseOperand(ub) ||
       parser.resolveOperand(ub, indexType, result.operands) ||
       parser.parseKeyword("step") || parser.parseOperand(step) ||
       parser.resolveOperand(step, indexType, result.operands))
     return failure();
 
   if (mlir::succeeded(parser.parseOptionalKeyword("unordered")))
-    result.addAttribute(fir::LoopOp::unorderedAttrName(),
+    result.addAttribute(fir::DoLoopOp::unorderedAttrName(),
                         builder.getUnitAttr());
 
   // Parse the optional initial iteration arguments.
   llvm::SmallVector<mlir::OpAsmParser::OperandType, 4> regionArgs, operands;
   llvm::SmallVector<mlir::Type, 4> argTypes;
   regionArgs.push_back(inductionVariable);
 
   if (succeeded(parser.parseOptionalKeyword("iter_args"))) {
static mlir::ParseResult parseDoLoopOp(mlir::OpAsmParser &parser,
   if (regionArgs.size() != argTypes.size())
     return parser.emitError(
         parser.getNameLoc(),
         "mismatch in number of loop-carried values and defined values");
 
   if (parser.parseRegion(*body, regionArgs, argTypes))
     return failure();
 
-  fir::LoopOp::ensureTerminator(*body, builder, result.location);
+  fir::DoLoopOp::ensureTerminator(*body, builder, result.location);
 
   return mlir::success();
 }
 
-fir::LoopOp fir::getForInductionVarOwner(mlir::Value val) {
+fir::DoLoopOp fir::getForInductionVarOwner(mlir::Value val) {
   auto ivArg = val.dyn_cast<mlir::BlockArgument>();
   if (!ivArg)
     return {};
   assert(ivArg.getOwner() && "unlinked block argument");
   auto *containingInst = ivArg.getOwner()->getParentOp();
-  return dyn_cast_or_null<fir::LoopOp>(containingInst);
+  return dyn_cast_or_null<fir::DoLoopOp>(containingInst);
 }
 
 // Lifted from loop.loop
-static mlir::LogicalResult verify(fir::LoopOp op) {
+static mlir::LogicalResult verify(fir::DoLoopOp op) {
   if (auto cst = dyn_cast_or_null<ConstantIndexOp>(op.step().getDefiningOp()))
     if (cst.getValue() <= 0)
       return op.emitOpError("constant step operand must be positive");
 
   // Check that the body defines as single block argument for the induction
   // variable.
   auto *body = op.getBody();
   if (!body->getArgument(0).getType().isIndex())
if (std::get<1>(e).getType() != std::get<2>(e).getType())
       return op.emitOpError() << "types mismatch between " << i
                               << "th iter region arg and defined value";
 
     i++;
   }
   return success();
 }
 
-static void print(mlir::OpAsmPrinter &p, fir::LoopOp op) {
+static void print(mlir::OpAsmPrinter &p, fir::DoLoopOp op) {
   bool printBlockTerminators = false;
-  p << fir::LoopOp::getOperationName() << ' ' << op.getInductionVar() << " = "
+  p << fir::DoLoopOp::getOperationName() << ' ' << op.getInductionVar() << " = "
     << op.lowerBound() << " to " << op.upperBound() << " step " << op.step();
   if (op.unordered())
     p << " unordered";
   if (op.hasIterOperands()) {
     p << " iter_args(";
     auto regionArgs = op.getRegionIterArgs();
     auto operands = op.getIterOperands();
     llvm::interleaveComma(llvm::zip(regionArgs, operands), p, [&](auto it) {
       p << std::get<0>(it) << " = " << std::get<1>(it);
     });
     p << ") -> (" << op.getResultTypes() << ')';
     printBlockTerminators = true;
   }
   p.printOptionalAttrDictWithKeyword(op->getAttrs(),
-                                     {fir::LoopOp::unorderedAttrName()});
+                                     {fir::DoLoopOp::unorderedAttrName()});
   p.printRegion(op.region(), /*printEntryBlockArgs=*/false,
                 printBlockTerminators);
 }
 
-mlir::Region &fir::LoopOp::getLoopBody() { return region(); }
+mlir::Region &fir::DoLoopOp::getLoopBody() { return region(); }
 
-bool fir::LoopOp::isDefinedOutsideOfLoop(mlir::Value value) {
+bool fir::DoLoopOp::isDefinedOutsideOfLoop(mlir::Value value) {
   return !region().isAncestor(value.getParentRegion());
 }
 
 mlir::LogicalResult
-fir::LoopOp::moveOutOfLoop(llvm::ArrayRef<mlir::Operation *> ops) {
+fir::DoLoopOp::moveOutOfLoop(llvm::ArrayRef<mlir::Operation *> ops) {
   for (auto op : ops)
     op->moveBefore(*this);
   return success();
 }
 
 //===----------------------------------------------------------------------===//
 // MulfOp
 //===----------------------------------------------------------------------===//