[flang] Adding options to the CfgConversion pass

[Renaud-K]

Summary

Adding options to the CfgConversion pass to selectively convert fir.do_loop, fir.if and and fir.iter_while

[clementval]

LGTM. Looks like pre-check are failing

[Renaud-K]

Added split-file as a tool. Seems, it was necessary for the pre-check tests.

[mehdi_amini]

flang/test/Fir/cfg-options.fir

6 ↗

(On Diff #406116)

Isn't it a bit more maintainable to have separate files instead?

They'll show as separate failure if any is failing, it is easier to reproduce issues, and in general long files are annoying to work with.

[Renaud-K]

Split tests into 4 files. Just can't figure how to get split-file to work with the pre-check tests.
Added constructor with options to CfgConversion

[mehdi_amini]

Instead of options1, options2, options3, ... can you name them more into what they are testing? Like cfg_conversion_no_while.fir, cfg_conversion_no_while_no_if.fir, ...

[mehdi_amini]

Also if the source if purely identical, instead of duplicating in different files, you can have multiple FileCheck prefixes, see for example: flang/test/Fir/convert-to-llvm-target.fir

[Renaud-K]

I had mistakenly removed lit.cfg.py instead of undoing the changes in it.

[Renaud-K]

Renamed test files.

[Renaud-K]

I am not going to submit this patch as I have found out that it is not legal FIR to have branch based CFG operations inside of block based CFG operations (fir.do_loop, fir.if and fir.iterate_while)

flang/test/Fir/cfg-options.fir

6 ↗

(On Diff #406116)

All this does is testing the plumbing of a few options so it seemed a bit over the top to have 4 different tests. But I guess this is moot since I cannot get split-file to work with pre-check build. I may try again at a later time and add reviewers only once I know it works to avoid the noise.

flang/include/flang/Optimizer/Transforms/Passes.h

 //===----------------------------------------------------------------------===//
 // Passes defined in Passes.td
 //===----------------------------------------------------------------------===//
 
 std::unique_ptr<mlir::Pass> createAbstractResultOptPass();
 std::unique_ptr<mlir::Pass> createAffineDemotionPass();
 std::unique_ptr<mlir::Pass> createArrayValueCopyPass();
 std::unique_ptr<mlir::Pass> createFirToCfgPass();
+std::unique_ptr<mlir::Pass> createFirToCfgPass(bool transformDoLoop,
+                                               bool transformIf,
+                                               bool transformIterateWhile);
 std::unique_ptr<mlir::Pass> createCharacterConversionPass();
 std::unique_ptr<mlir::Pass> createExternalNameConversionPass();
 std::unique_ptr<mlir::Pass> createMemDataFlowOptPass();
 std::unique_ptr<mlir::Pass> createPromoteToAffinePass();
 std::unique_ptr<mlir::Pass> createMemoryAllocationPass();
 std::unique_ptr<mlir::Pass>
 createMemoryAllocationPass(bool dynOnHeap, std::size_t maxStackSize);
 
 // declarative passes
 #define GEN_PASS_REGISTRATION
 #include "flang/Optimizer/Transforms/Passes.h.inc"
 
 } // namespace fir
 
 #endif // FORTRAN_OPTIMIZER_TRANSFORMS_PASSES_H

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

def CFGConversion : Pass<"cfg-conversion", "::mlir::FuncOp"> {
   }];
   let constructor = "::fir::createFirToCfgPass()";
   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">
+           "force the body of a loop to execute at least once">,
+    Option<"transformDoLoop", "transform-do-loop", "bool",
+           /*default=*/"true",
+           "apply the transformation the do loops">,
+    Option<"transformIf", "transform-if", "bool",
+           /*default=*/"true",
+           "apply transformation on if statments">,
+    Option<"transformIterateWhile", "transform-iterate-while", "bool",
+           /*default=*/"true",
+           "apply transformation on iterate while">
   ];
 }
 
 def ExternalNameConversion : Pass<"external-name-interop", "mlir::ModuleOp"> {
   let summary = "Convert name for external interoperability";
   let description = [{
     Demangle FIR internal name and mangle them for external interoperability.
   }];

flang/include/flang/Tools/CLOptions.inc

 static void defaultFlangInlinerOptPipeline(mlir::OpPassManager &pm) {
   mlir::GreedyRewriteConfig config;
   config.enableRegionSimplification = false;
   pm.addPass(mlir::createCanonicalizerPass(config));
 }
 
 inline void addCfgConversionPass(mlir::PassManager &pm) {
   addNestedPassConditionally<mlir::FuncOp>(
-      pm, disableCfgConversion, fir::createFirToCfgPass);
+      pm, disableCfgConversion, []() {return fir::createFirToCfgPass();});
 }
 
 inline void addAVC(mlir::PassManager &pm) {
   addNestedPassConditionally<mlir::FuncOp>(
       pm, disableFirAvc, fir::createArrayValueCopyPass);
 }
 
 inline void addMemoryAllocationOpt(mlir::PassManager &pm) {

flang/lib/Optimizer/Transforms/RewriteLoop.cpp

matchAndRewrite(fir::IterWhileOp whileOp,
     rewriter.replaceOp(whileOp, args);
     return success();
   }
 };
 
 /// Convert FIR structured control flow ops to CFG ops.
 class CfgConversion : public CFGConversionBase<CfgConversion> {
 public:
+  CfgConversion() = default;
+  CfgConversion(bool transformDoLoop, bool transformIf,
+                bool transformIterateWhile) {
+    this->transformDoLoop = transformDoLoop;
+    this->transformIf = transformIf;
+    this->transformIterateWhile = transformIterateWhile;
+  }
+
   void runOnOperation() override {
     auto *context = &getContext();
     mlir::RewritePatternSet patterns(context);
-    patterns.insert<CfgLoopConv, CfgIfConv, CfgIterWhileConv>(
-        context, forceLoopToExecuteOnce);
     mlir::ConversionTarget target(*context);
     target.addLegalDialect<mlir::AffineDialect, FIROpsDialect,
                            mlir::StandardOpsDialect>();
 
     // apply the patterns
-    target.addIllegalOp<ResultOp, DoLoopOp, IfOp, IterWhileOp>();
+    if (transformIterateWhile) {
+      patterns.insert<CfgIterWhileConv>(context, forceLoopToExecuteOnce);
+      target.addIllegalOp<IterWhileOp>();
+    }
+    if (transformDoLoop) {
+      patterns.insert<CfgLoopConv>(context, forceLoopToExecuteOnce);
+      target.addIllegalOp<DoLoopOp>();
+    }
+    if (transformIf) {
+      patterns.insert<CfgIfConv>(context, forceLoopToExecuteOnce);
+      target.addIllegalOp<IfOp>();
+    }
+    bool transformAll = transformIterateWhile && transformDoLoop && transformIf;
+    if (transformAll) {
+      target.addIllegalOp<ResultOp>();
+    }
     target.markUnknownOpDynamicallyLegal([](Operation *) { return true; });
     if (mlir::failed(mlir::applyPartialConversion(getOperation(), target,
                                                   std::move(patterns)))) {
       mlir::emitError(mlir::UnknownLoc::get(context),
                       "error in converting to CFG\n");
       signalPassFailure();
     }
   }
 };
 } // namespace
 
 /// Convert FIR's structured control flow ops to CFG ops.  This
 /// conversion enables the `createLowerToCFGPass` to transform these to CFG
 /// form.
+std::unique_ptr<mlir::Pass>
+fir::createFirToCfgPass(bool transformDoLoop, bool transformIf,
+                        bool transformIterateWhile) {
+  return std::make_unique<CfgConversion>(transformDoLoop, transformIf,
+                                         transformIterateWhile);
+}
+/// Overload utilizing pass options for initialization.
 std::unique_ptr<mlir::Pass> fir::createFirToCfgPass() {
   return std::make_unique<CfgConversion>();
 }

flang/test/Fir/cfg-conversion-all-transforms.fir

+// RUN: fir-opt %s --cfg-conversion | FileCheck %s
+
+// CHECK-LABEL: @x
+// CHECK-NOT: fir.if
+// CHECK-NOT: fir.do_loop
+func @x(%lb : index, %ub : index, %step : index, %b : i1, %addr : !fir.ref<index>) {
+  fir.do_loop %iv = %lb to %ub step %step unordered {
+    fir.if %b {
+      fir.store %iv to %addr : !fir.ref<index>
+    } else {
+      %zero = arith.constant 0 : index
+      fir.store %zero to %addr : !fir.ref<index>
+    }
+  }
+  return
+}
+
+// CHECK-LABEL: @x2
+// CHECK-NOT: fir.iterate_while
+func @x2(%lo : index, %up : index, %ok : i1) {
+  %c1 = arith.constant 1 : index
+  %unused = fir.iterate_while (%i = %lo to %up step %c1) and (%ok1 = %ok) {
+    %ok2 = fir.call @f2() : () -> i1
+    fir.result %ok2 : i1
+  }
+  return
+}

flang/test/Fir/cfg-conversion-no-do-loop-no-if.fir

+// RUN: fir-opt %s --cfg-conversion="transform-do-loop=0 transform-if=0" | FileCheck %s
+
+// CHECK-LABEL: @x
+// CHECK: fir.do_loop
+// CHECK: fir.if
+func @x(%lb : index, %ub : index, %step : index, %b : i1, %addr : !fir.ref<index>) {
+  fir.do_loop %iv = %lb to %ub step %step unordered {
+    fir.if %b {
+      fir.store %iv to %addr : !fir.ref<index>
+    } else {
+      %zero = arith.constant 0 : index
+      fir.store %zero to %addr : !fir.ref<index>
+    }
+  }
+  return
+}
+
+// CHECK-LABEL: @x2
+// CHECK-NOT: fir.iterate_while
+func @x2(%lo : index, %up : index, %ok : i1) {
+  %c1 = arith.constant 1 : index
+  %unused = fir.iterate_while (%i = %lo to %up step %c1) and (%ok1 = %ok) {
+    %ok2 = fir.call @f2() : () -> i1
+    fir.result %ok2 : i1
+  }
+  return
+}

flang/test/Fir/cfg-conversion-no-if-no-while.fir

+// RUN: fir-opt %s --cfg-conversion="transform-if=0 transform-iterate-while=0" | FileCheck %s
+
+// CHECK-LABEL: @x
+// CHECK: fir.if
+// CHECK-NOT: fir.do_loop
+func @x(%lb : index, %ub : index, %step : index, %b : i1, %addr : !fir.ref<index>) {
+  fir.do_loop %iv = %lb to %ub step %step unordered {
+    fir.if %b {
+      fir.store %iv to %addr : !fir.ref<index>
+    } else {
+      %zero = arith.constant 0 : index
+      fir.store %zero to %addr : !fir.ref<index>
+    }
+  }
+  return
+}
+
+// CHECK-LABEL: @x2
+// CHECK: fir.iterate_while
+func @x2(%lo : index, %up : index, %ok : i1) {
+  %c1 = arith.constant 1 : index
+  %unused = fir.iterate_while (%i = %lo to %up step %c1) and (%ok1 = %ok) {
+    %ok2 = fir.call @f2() : () -> i1
+    fir.result %ok2 : i1
+  }
+  return
+}

flang/test/Fir/cfg-conversion-no-while.fir

+// RUN: fir-opt %s --cfg-conversion="transform-iterate-while=0" | FileCheck %s
+
+
+// CHECK-LABEL: @x
+// CHECK-NOT: fir.if
+// CHECK-NOT: fir.do_loop
+func @x(%lb : index, %ub : index, %step : index, %b : i1, %addr : !fir.ref<index>) {
+  fir.do_loop %iv = %lb to %ub step %step unordered {
+    fir.if %b {
+      fir.store %iv to %addr : !fir.ref<index>
+    } else {
+      %zero = arith.constant 0 : index
+      fir.store %zero to %addr : !fir.ref<index>
+    }
+  }
+  return
+}
+
+// CHECK-LABEL: @x2
+// CHECK: fir.iterate_while
+func @x2(%lo : index, %up : index, %ok : i1) {
+  %c1 = arith.constant 1 : index
+  %unused = fir.iterate_while (%i = %lo to %up step %c1) and (%ok1 = %ok) {
+    %ok2 = fir.call @f2() : () -> i1
+    fir.result %ok2 : i1
+  }
+  return
+}