[fir] Sync cfg-conversion pass after upstreaming change

Author: clementval

flang/include/flang/Lower/Bridge.h

@@ -17,6 +17,7 @@
 #include "flang/Lower/AbstractConverter.h"
 #include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/IR/BuiltinOps.h"
+#include "llvm/Support/CommandLine.h"
 
 namespace Fortran {
 namespace common {

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

@@ -120,6 +120,11 @@ def CFGConversion : FunctionPass<"cfg-conversion"> {
   let dependentDialects = [
     "fir::FIROpsDialect", "mlir::StandardOpsDialect"
   ];
+  let options = [
+    Option<"forceLoopToExecuteOnce", "always-execute-loop-body", "bool",
+           /*default=*/"false",
+           "force the body of a loop to execute at least once">
+  ];
 }
 
 def ArrayValueCopy : FunctionPass<"array-value-copy"> {

flang/include/flang/Tools/CLOptions.inc

@@ -17,6 +17,7 @@
 namespace {
 // Optimizer Passes
 DisableOption(FirCse, "fir-cse", "CSE for FIR dialect");
+DisableOption(CfgConversion, "cfg-conversion", "disable FIR to CFG pass");
 
 // CodeGen Passes
 #if !defined(FLANG_EXCLUDE_CODEGEN)
@@ -45,6 +46,11 @@ void addNestedPassConditionally(
 
 namespace fir {
 
+inline void addCfgConversionPass(mlir::PassManager &pm) {
+  addNestedPassConditionally<mlir::FuncOp>(
+      pm, disableCfgConversion, fir::createFirToCfgPass);
+}
+
 inline void addCSE(mlir::PassManager &pm) {
   addNestedPassConditionally<mlir::FuncOp>(
       pm, disableFirCse, fir::createCSEPass);

flang/lib/Lower/Bridge.cpp

@@ -58,6 +58,10 @@ static llvm::cl::opt<bool> dumpBeforeFir(
     "fdebug-dump-pre-fir", llvm::cl::init(false),
     llvm::cl::desc("dump the Pre-FIR tree prior to FIR generation"));
 
+static llvm::cl::opt<bool> forceLoopToExecuteOnce(
+    "always-execute-loop-body", llvm::cl::init(false),
+    llvm::cl::desc("force the body of a loop to execute at least once"));
+
 namespace {
 /// Information for generating a structured or unstructured increment loop.
 struct IncrementLoopInfo {
@@ -1012,7 +1016,7 @@ class FirConverter : public Fortran::lower::AbstractConverter {
         tripCount =
             builder->create<mlir::SignedDivIOp>(loc, diff2, info.stepValue);
       }
-      if (fir::isAlwaysExecuteLoopBody()) { // minimum tripCount is 1
+      if (forceLoopToExecuteOnce) { // minimum tripCount is 1
         auto one = builder->createIntegerConstant(loc, controlType, 1);
         auto cond = builder->create<mlir::CmpIOp>(loc, CmpIPredicate::slt,
                                                   tripCount, one);

flang/lib/Optimizer/Transforms/RewriteLoop.cpp

@@ -16,18 +16,6 @@
 #include "mlir/Transforms/DialectConversion.h"
 #include "llvm/Support/CommandLine.h"
 
-/// disable FIR to scf dialect conversion
-static llvm::cl::opt<bool>
-    disableCfgConversion("disable-cfg-conversion",
-                         llvm::cl::desc("disable FIR to CFG pass"),
-                         llvm::cl::init(false));
-
-/// minimum trip count is 1, not 0
-static llvm::cl::opt<bool> forceLoopToExecuteOnce(
-    "always-execute-loop-body",
-    llvm::cl::desc("force the body of a loop to execute at least once"),
-    llvm::cl::init(false));
-
 using namespace fir;
 
 namespace {
@@ -40,7 +28,11 @@ namespace {
 /// Convert `fir.do_loop` to CFG
 class CfgLoopConv : public mlir::OpRewritePattern<fir::DoLoopOp> {
 public:
-  using OpRewritePattern::OpRewritePattern;
+using OpRewritePattern::OpRewritePattern;
+
+  CfgLoopConv(mlir::MLIRContext *ctx, bool forceLoopToExecuteOnce)
+      : mlir::OpRewritePattern<fir::DoLoopOp>(ctx),
+        forceLoopToExecuteOnce(forceLoopToExecuteOnce) {}
 
   mlir::LogicalResult
   matchAndRewrite(DoLoopOp loop,
@@ -133,13 +125,19 @@ class CfgLoopConv : public mlir::OpRewritePattern<fir::DoLoopOp> {
     rewriter.replaceOp(loop, args.drop_back());
     return success();
   }
+
+private:
+  bool forceLoopToExecuteOnce;
 };
 
 /// Convert `fir.if` to control-flow
 class CfgIfConv : public mlir::OpRewritePattern<fir::IfOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
+  CfgIfConv(mlir::MLIRContext *ctx, bool forceLoopToExecuteOnce)
+      : mlir::OpRewritePattern<fir::IfOp>(ctx) {}
+
   mlir::LogicalResult
   matchAndRewrite(IfOp ifOp, mlir::PatternRewriter &rewriter) const override {
     auto loc = ifOp.getLoc();
@@ -200,6 +198,9 @@ class CfgIterWhileConv : public mlir::OpRewritePattern<fir::IterWhileOp> {
 public:
   using OpRewritePattern::OpRewritePattern;
 
+  CfgIterWhileConv(mlir::MLIRContext *ctx, bool forceLoopToExecuteOnce)
+      : mlir::OpRewritePattern<fir::IterWhileOp>(ctx) {}
+
   mlir::LogicalResult
   matchAndRewrite(fir::IterWhileOp whileOp,
                   mlir::PatternRewriter &rewriter) const override {
@@ -292,12 +293,10 @@ class CfgIterWhileConv : public mlir::OpRewritePattern<fir::IterWhileOp> {
 class CfgConversion : public CFGConversionBase<CfgConversion> {
 public:
   void runOnFunction() override {
-    if (disableCfgConversion)
-      return;
-
     auto *context = &getContext();
     mlir::OwningRewritePatternList patterns(context);
-    patterns.insert<CfgLoopConv, CfgIfConv, CfgIterWhileConv>(context);
+    patterns.insert<CfgLoopConv, CfgIfConv, CfgIterWhileConv>(
+        context, forceLoopToExecuteOnce);
     mlir::ConversionTarget target(*context);
     target.addLegalDialect<mlir::AffineDialect, FIROpsDialect,
                            mlir::StandardOpsDialect>();
@@ -315,7 +314,6 @@ class CfgConversion : public CFGConversionBase<CfgConversion> {
 };
 } // namespace
 
-bool fir::isAlwaysExecuteLoopBody() { return forceLoopToExecuteOnce; }
 /// Convert FIR's structured control flow ops to CFG ops.  This
 /// conversion enables the `createLowerToCFGPass` to transform these to CFG
 /// form.