[fir] Add fir.convert canonicalization patterns

[clementval]

Summary

Add rewrite patterns for fir.convert op canonicalization.

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

Co-authored-by: Eric Schweitz <[e-mail]>

[kiranchandramohan]

flang/include/flang/Optimizer/Transforms/RewritePatterns.td

29

Do these patterns check that there are no other users? Or is that not a problem here?

flang/test/Fir/convert-fold.fir

34

constant -> constant 10 ?

[clementval]

Fix test

[clementval]

flang/include/flang/Optimizer/Transforms/RewritePatterns.td

29

These patterns are not removing the ops completely but rather simplifying some patterns. So the users get updated with the new value as well.

flang/test/Fir/convert-fold.fir

34

Good catch! Thanks.

[kiranchandramohan]

LGTM.

flang/include/flang/Optimizer/Transforms/CMakeLists.txt

 
+set(LLVM_TARGET_DEFINITIONS RewritePatterns.td)
+mlir_tablegen(RewritePatterns.inc -gen-rewriters)
+add_public_tablegen_target(RewritePatternsIncGen)
+
 set(LLVM_TARGET_DEFINITIONS Passes.td)
 mlir_tablegen(Passes.h.inc -gen-pass-decls -name OptTransform)
 add_public_tablegen_target(FIROptTransformsPassIncGen)
-

flang/include/flang/Optimizer/Transforms/RewritePatterns.td

+//===-- RewritePatterns.td - FIR Rewrite Patterns -----------*- tablegen -*-===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+///
+/// \file
+/// Defines pattern rewrites for fir optimizations
+///
+//===----------------------------------------------------------------------===//
+
+#ifndef FORTRAN_FIR_REWRITE_PATTERNS
+#define FORTRAN_FIR_REWRITE_PATTERNS
+
+include "mlir/IR/OpBase.td"
+include "mlir/Dialect/StandardOps/IR/Ops.td"
+include "flang/Optimizer/Dialect/FIROps.td"
+
+def IdenticalTypePred : Constraint<CPred<"$0.getType() == $1.getType()">>;
+def IntegerTypePred : Constraint<CPred<"fir::isa_integer($0.getType())">>;
+def IndexTypePred : Constraint<CPred<"$0.getType().isa<mlir::IndexType>()">>;
+
+def SmallerWidthPred
+    : Constraint<CPred<"$0.getType().getIntOrFloatBitWidth() "
+                       "<= $1.getType().getIntOrFloatBitWidth()">>;
+
+def ConvertConvertOptPattern
+    : Pat<(fir_ConvertOp (fir_ConvertOp $arg)),
+          (fir_ConvertOp $arg),
+          [(IntegerTypePred $arg)]>;
+
+def RedundantConvertOptPattern
+    : Pat<(fir_ConvertOp:$res $arg),
+          (replaceWithValue $arg),
+          [(IdenticalTypePred $res, $arg)
+          ,(IntegerTypePred $arg)]>;
+
+def CombineConvertOptPattern
+    : Pat<(fir_ConvertOp:$res(fir_ConvertOp:$irm $arg)),
+          (replaceWithValue $arg),
+          [(IdenticalTypePred $res, $arg)
+          ,(IntegerTypePred $arg)
+          ,(IntegerTypePred $irm)
+          ,(SmallerWidthPred $arg, $irm)]>;
+
+def createConstantOp
+    : NativeCodeCall<"$_builder.create<mlir::ConstantOp>"
+                     "($_loc, $_builder.getIndexType(), "
+                     "rewriter.getIndexAttr($1.dyn_cast<IntegerAttr>().getInt()))">;
+
+def ForwardConstantConvertPattern
+    : Pat<(fir_ConvertOp:$res (ConstantOp:$cnt $attr)),
+          (createConstantOp $res, $attr),
+          [(IndexTypePred $res)
+          ,(IntegerTypePred $cnt)]>;
+
+#endif // FORTRAN_FIR_REWRITE_PATTERNS

flang/lib/Optimizer/Dialect/FIROps.cpp

 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "mlir/IR/Diagnostics.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/PatternMatch.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/ADT/TypeSwitch.h"
 
+namespace {
+#include "flang/Optimizer/Transforms/RewritePatterns.inc"
+} // namespace
 using namespace fir;
 
 /// Return true if a sequence type is of some incomplete size or a record type
 /// is malformed or contains an incomplete sequence type. An incomplete sequence
 /// type is one with more unknown extents in the type than have been provided
 /// via `dynamicExtents`. Sequence types with an unknown rank are incomplete by
 /// definition.
 static bool verifyInType(mlir::Type inType,
static mlir::LogicalResult verify(fir::ConstcOp &op) {
   return mlir::success();
 }
 
 //===----------------------------------------------------------------------===//
 // ConvertOp
 //===----------------------------------------------------------------------===//
 
 void fir::ConvertOp::getCanonicalizationPatterns(
-    OwningRewritePatternList &results, MLIRContext *context) {}
+    OwningRewritePatternList &results, MLIRContext *context) {
+  results.insert<ConvertConvertOptPattern, RedundantConvertOptPattern,
+                 CombineConvertOptPattern, ForwardConstantConvertPattern>(
+      context);
+}
 
 mlir::OpFoldResult fir::ConvertOp::fold(llvm::ArrayRef<mlir::Attribute> opnds) {
   if (value().getType() == getType())
     return value();
   if (matchPattern(value(), m_Op<fir::ConvertOp>())) {
     auto inner = cast<fir::ConvertOp>(value().getDefiningOp());
     // (convert (convert 'a : logical -> i1) : i1 -> logical) ==> forward 'a
     if (auto toTy = getType().dyn_cast<fir::LogicalType>())

flang/lib/Optimizer/Transforms/CMakeLists.txt

 add_flang_library(FIRTransforms
   AffinePromotion.cpp
   AffineDemotion.cpp
   CharacterConversion.cpp
   Inliner.cpp
   ExternalNameConversion.cpp
 
   DEPENDS
   FIRDialect
   FIRSupport
   FIROptTransformsPassIncGen
+  RewritePatternsIncGen
 
   LINK_LIBS
   FIRDialect
   MLIRAffineToStandard
   MLIRLLVMIR
   MLIROpenACC
   MLIROpenMP
   FIRSupport
 )

flang/test/Fir/convert-fold.fir

+// RUN: fir-opt --canonicalize %s | FileCheck %s
+
+// CHECK-LABEL: @ftest
+func @ftest(%x : i1) -> i1 {
+  // this pair of converts should be folded and DCEd
+  %1 = fir.convert %x : (i1) -> !fir.logical<1>
+  %2 = fir.convert %1 : (!fir.logical<1>) -> i1
+  // CHECK-NEXT: return %{{.*}} : i1
+  return %2 : i1
+}
+
+// CHECK-LABEL: @gtest
+func @gtest(%x : !fir.logical<2>) -> !fir.logical<2> {
+  // this pair of converts should be folded and DCEd
+  %1 = fir.convert %x : (!fir.logical<2>) -> i1
+  %2 = fir.convert %1 : (i1) -> !fir.logical<2>
+  // CHECK-NEXT: return %{{.*}} : !fir.logical<2>
+  return %2 : !fir.logical<2>
+}
+
+// CHECK-LABEL: @htest
+func @htest(%x : !fir.int<4>) -> !fir.int<4> {
+  // these converts are NOPs and should be folded away
+  %1 = fir.convert %x : (!fir.int<4>) -> !fir.int<4>
+  %2 = fir.convert %1 : (!fir.int<4>) -> !fir.int<4>
+  // CHECK-NEXT: return %{{.*}} : !fir.int<4>
+  return %2 : !fir.int<4>
+}
+
+// CHECK-LABEL: @ctest
+func @ctest() -> index {
+  %1 = constant 10 : i32
+  %2 = fir.convert %1 : (i32) -> index
+  // CHECK-NEXT: %{{.*}} = constant : index
+  // CHECK-NEXT: return %{{.*}} : index
+  return %2 : index
+}