Use greedy rewriter.

Author: vzakhari

flang/lib/Optimizer/Transforms/SimplifyFIROperations.cpp

@@ -13,25 +13,13 @@
 /// can legally use SCF dialect and generate Fortran runtime calls.
 //===----------------------------------------------------------------------===//
 
-#include "flang/Optimizer/Builder/BoxValue.h"
-#include "flang/Optimizer/Builder/CUFCommon.h"
 #include "flang/Optimizer/Builder/FIRBuilder.h"
-#include "flang/Optimizer/Builder/LowLevelIntrinsics.h"
+#include "flang/Optimizer/Builder/Runtime/Inquiry.h"
 #include "flang/Optimizer/Builder/Todo.h"
 #include "flang/Optimizer/Dialect/FIROps.h"
-#include "flang/Optimizer/Dialect/FIRType.h"
-#include "flang/Optimizer/Dialect/Support/FIRContext.h"
-#include "flang/Optimizer/HLFIR/HLFIRDialect.h"
 #include "flang/Optimizer/Transforms/Passes.h"
-#include "flang/Optimizer/Transforms/Utils.h"
-#include "flang/Runtime/entry-names.h"
-#include "flang/Support/Fortran.h"
-#include "mlir/IR/Matchers.h"
-#include "mlir/IR/Operation.h"
 #include "mlir/Pass/Pass.h"
-#include "mlir/Transforms/DialectConversion.h"
-
-#include "flang/Optimizer/Builder/Runtime/Inquiry.h"
+#include "mlir/Transforms/GreedyPatternRewriteDriver.h"
 
 namespace fir {
 #define GEN_PASS_DEF_SIMPLIFYFIROPERATIONS
@@ -105,7 +93,7 @@ mlir::LogicalResult IsContiguousBoxCoversion::matchAndRewrite(
 
   // Generate inline implementation.
   TODO(loc, "inline IsContiguousBoxOp");
-  return mlir::success();
+  return mlir::failure();
 }
 
 /// Generate a call to Size runtime function or an inline
@@ -131,20 +119,20 @@ mlir::LogicalResult BoxTotalElementsConversion::matchAndRewrite(
 
   // Generate inline implementation.
   TODO(loc, "inline BoxTotalElementsOp");
-  return mlir::success();
+  return mlir::failure();
 }
 
 void SimplifyFIROperationsPass::runOnOperation() {
   mlir::ModuleOp module = getOperation();
   mlir::MLIRContext &context = getContext();
-  mlir::ConversionTarget target(context);
-  target.addIllegalOp<fir::IsContiguousBoxOp>();
-  target.addIllegalOp<fir::BoxTotalElementsOp>();
   mlir::RewritePatternSet patterns(&context);
   fir::populateSimplifyFIROperationsPatterns(patterns,
                                              preferInlineImplementation);
+  mlir::GreedyRewriteConfig config;
+  config.enableRegionSimplification = mlir::GreedySimplifyRegionLevel::Disabled;
+
   if (mlir::failed(
-          mlir::applyPartialConversion(module, target, std::move(patterns)))) {
+          mlir::applyPatternsGreedily(module, std::move(patterns), config))) {
     mlir::emitError(module.getLoc(), DEBUG_TYPE " pass failed");
     signalPassFailure();
   }

flang/test/Transforms/simplify-fir-operations.fir

@@ -87,9 +87,8 @@ func.func @test_none(%arg0: !fir.box<none>) -> i16 {
 }
 // CHECK-LABEL:   func.func @test_none(
 // CHECK-SAME:                         %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<none>) -> i16 {
-// CHECK:           %[[VAL_1:.*]] = fir.address_of(@{{.*}}) : !fir.ref<!fir.char<1,{{.*}}>>
-// CHECK:           %[[VAL_2:.*]] = arith.constant {{.*}} : index
 // CHECK:           %[[VAL_3:.*]] = arith.constant {{.*}} : i32
+// CHECK:           %[[VAL_1:.*]] = fir.address_of(@{{.*}}) : !fir.ref<!fir.char<1,{{.*}}>>
 // CHECK:           %[[VAL_4:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
 // CHECK:           %[[VAL_5:.*]] = fir.call @_FortranASize(%[[VAL_0]], %[[VAL_4]], %[[VAL_3]]) : (!fir.box<none>, !fir.ref<i8>, i32) -> i64
 // CHECK:           %[[VAL_6:.*]] = fir.convert %[[VAL_5]] : (i64) -> i16
@@ -104,9 +103,8 @@ func.func @test_array(%arg0: !fir.box<!fir.array<?x?xf32>>) -> i32 {
 }
 // CHECK-LABEL:   func.func @test_array(
 // CHECK-SAME:                          %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<?x?xf32>>) -> i32 {
-// CHECK:           %[[VAL_1:.*]] = fir.address_of({{.*}}) : !fir.ref<!fir.char<1,{{.*}}>>
-// CHECK:           %[[VAL_2:.*]] = arith.constant {{.*}} : index
 // CHECK:           %[[VAL_3:.*]] = arith.constant {{.*}} : i32
+// CHECK:           %[[VAL_1:.*]] = fir.address_of({{.*}}) : !fir.ref<!fir.char<1,{{.*}}>>
 // CHECK:           %[[VAL_4:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<?x?xf32>>) -> !fir.box<none>
 // CHECK:           %[[VAL_5:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
 // CHECK:           %[[VAL_6:.*]] = fir.call @_FortranASize(%[[VAL_4]], %[[VAL_5]], %[[VAL_3]]) : (!fir.box<none>, !fir.ref<i8>, i32) -> i64
@@ -122,9 +120,8 @@ func.func @test_assumed_rank(%arg0: !fir.box<!fir.array<*:f32>>) -> index {
 }
 // CHECK-LABEL:   func.func @test_assumed_rank(
 // CHECK-SAME:                                 %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<*:f32>>) -> index {
-// CHECK:           %[[VAL_1:.*]] = fir.address_of({{.*}}) : !fir.ref<!fir.char<1,{{.*}}>>
-// CHECK:           %[[VAL_2:.*]] = arith.constant {{.*}} : index
 // CHECK:           %[[VAL_3:.*]] = arith.constant {{.*}} : i32
+// CHECK:           %[[VAL_1:.*]] = fir.address_of({{.*}}) : !fir.ref<!fir.char<1,{{.*}}>>
 // CHECK:           %[[VAL_4:.*]] = fir.convert %[[VAL_0]] : (!fir.box<!fir.array<*:f32>>) -> !fir.box<none>
 // CHECK:           %[[VAL_5:.*]] = fir.convert %[[VAL_1]] : (!fir.ref<!fir.char<1,{{.*}}>>) -> !fir.ref<i8>
 // CHECK:           %[[VAL_6:.*]] = fir.call @_FortranASize(%[[VAL_4]], %[[VAL_5]], %[[VAL_3]]) : (!fir.box<none>, !fir.ref<i8>, i32) -> i64