[CIR][Transforms] Simplify redundant bitcasts (llvm#591)

Fix llvm#479 .

There are three available stages to place the simplification in.

* A straightforward method is to extend `fold` method for CastOp.
But CIR does not use CanonicalizerPass, so it does not work.
* As for somehow equivalent to it, append a pattern to
`MergeCleanupsPass`.
But now it is mainly for CFG-related simplifications like block merging.
I don't know if this is the proper way. Shall we rename it to a broader
definition?
* Add a new pass for this issue.
This is definitely not very reasonable XD. We won't consider it unless
we're really out of options.

This PR includes the second option. What do you think @bcardosolopes ?

Author: seven-mile

clang/lib/CIR/Dialect/IR/CIRDialect.cpp

@@ -502,17 +502,24 @@ LogicalResult CastOp::verify() {
 }
 
 OpFoldResult CastOp::fold(FoldAdaptor adaptor) {
-  if (getKind() != mlir::cir::CastKind::integral)
-    return {};
   if (getSrc().getType() != getResult().getType())
     return {};
-  // TODO: for sign differences, it's possible in certain conditions to
-  // create a new attributes that's capable or representing the source.
-  SmallVector<mlir::OpFoldResult, 1> foldResults;
-  auto foldOrder = getSrc().getDefiningOp()->fold(foldResults);
-  if (foldOrder.succeeded() && foldResults[0].is<mlir::Attribute>())
-    return foldResults[0].get<mlir::Attribute>();
-  return {};
+  switch (getKind()) {
+  case mlir::cir::CastKind::integral: {
+    // TODO: for sign differences, it's possible in certain conditions to
+    // create a new attribute that's capable of representing the source.
+    SmallVector<mlir::OpFoldResult, 1> foldResults;
+    auto foldOrder = getSrc().getDefiningOp()->fold(foldResults);
+    if (foldOrder.succeeded() && foldResults[0].is<mlir::Attribute>())
+      return foldResults[0].get<mlir::Attribute>();
+    return {};
+  }
+  case mlir::cir::CastKind::bitcast: {
+    return getSrc();
+  }
+  default:
+    return {};
+  }
 }
 
 //===----------------------------------------------------------------------===//

clang/lib/CIR/Dialect/Transforms/MergeCleanups.cpp

@@ -34,7 +34,7 @@ namespace {
 /// To:
 ///   ^bb0:
 ///     cir.return
-struct RemoveRedudantBranches : public OpRewritePattern<BrOp> {
+struct RemoveRedundantBranches : public OpRewritePattern<BrOp> {
   using OpRewritePattern<BrOp>::OpRewritePattern;
 
   LogicalResult matchAndRewrite(BrOp op,
@@ -104,7 +104,7 @@ struct MergeCleanupsPass : public MergeCleanupsBase<MergeCleanupsPass> {
 void populateMergeCleanupPatterns(RewritePatternSet &patterns) {
   // clang-format off
   patterns.add<
-    RemoveRedudantBranches,
+    RemoveRedundantBranches,
     RemoveEmptyScope,
     RemoveEmptySwitch
   >(patterns.getContext());
@@ -119,7 +119,9 @@ void MergeCleanupsPass::runOnOperation() {
   // Collect operations to apply patterns.
   SmallVector<Operation *, 16> ops;
   getOperation()->walk([&](Operation *op) {
-    if (isa<BrOp, BrCondOp, ScopeOp, SwitchOp>(op))
+    // CastOp here is to perform a manual `fold` in
+    // applyOpPatternsAndFold
+    if (isa<BrOp, BrCondOp, ScopeOp, SwitchOp, CastOp>(op))
       ops.push_back(op);
   });
 

clang/test/CIR/CodeGen/no-proto-fun-ptr.c

@@ -9,8 +9,7 @@ void check_noproto_ptr() {
 // CHECK:  cir.func no_proto @check_noproto_ptr()
 // CHECK:    [[ALLOC:%.*]] = cir.alloca !cir.ptr<!cir.func<!void ()>>, !cir.ptr<!cir.ptr<!cir.func<!void ()>>>, ["fun", init] {alignment = 8 : i64}
 // CHECK:    [[GGO:%.*]] = cir.get_global @empty : !cir.ptr<!cir.func<!void ()>>
-// CHECK:    [[CAST:%.*]] = cir.cast(bitcast, [[GGO]] : !cir.ptr<!cir.func<!void ()>>), !cir.ptr<!cir.func<!void ()>>
-// CHECK:    cir.store [[CAST]], [[ALLOC]] : !cir.ptr<!cir.func<!void ()>>, !cir.ptr<!cir.ptr<!cir.func<!void ()>>>
+// CHECK:    cir.store [[GGO]], [[ALLOC]] : !cir.ptr<!cir.func<!void ()>>, !cir.ptr<!cir.ptr<!cir.func<!void ()>>>
 // CHECK:    cir.return
 
 void empty(void) {}

clang/test/CIR/CodeGen/no-prototype.c

@@ -36,8 +36,7 @@ int noProto2();
 int test2(int x) {
   return noProto2(x);
   // CHECK:  [[GGO:%.*]] = cir.get_global @noProto2 : !cir.ptr<!cir.func<!s32i (!s32i)>>
-  // CHECK:  [[CAST:%.*]] = cir.cast(bitcast, %3 : !cir.ptr<!cir.func<!s32i (!s32i)>>), !cir.ptr<!cir.func<!s32i (!s32i)>>
-  // CHECK:  {{.*}} = cir.call [[CAST]](%{{[0-9]+}}) : (!cir.ptr<!cir.func<!s32i (!s32i)>>, !s32i) -> !s32i
+  // CHECK:  {{.*}} = cir.call [[GGO]](%{{[0-9]+}}) : (!cir.ptr<!cir.func<!s32i (!s32i)>>, !s32i) -> !s32i
 }
 int noProto2(int x) { return x; }
 // CHECK: cir.func no_proto @noProto2(%arg0: !s32i {{.+}}) -> !s32i

clang/test/CIR/CodeGen/unary.c

@@ -1,26 +1,42 @@
 // RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -Wno-unused-value -emit-cir %s -o %t.cir
 // RUN: FileCheck --input-file=%t.cir %s
 
-void valueNegation(int i, short s, long l, float f, double d) {
-// CHECK: cir.func @valueNegation(
-  !i;
+int valueNegationInt(int i) {
+// CHECK: cir.func @valueNegationInt(
+  return !i;
   // CHECK: %[[#INT:]] = cir.load %{{[0-9]+}} : !cir.ptr<!s32i>, !s32i
   // CHECK: %[[#INT_TO_BOOL:]] = cir.cast(int_to_bool, %[[#INT]] : !s32i), !cir.bool
   // CHECK: = cir.unary(not, %[[#INT_TO_BOOL]]) : !cir.bool, !cir.bool
-  !s;
+}
+
+short valueNegationShort(short s) {
+// CHECK: cir.func @valueNegationShort(
+  return !s;
   // CHECK: %[[#SHORT:]] = cir.load %{{[0-9]+}} : !cir.ptr<!s16i>, !s16i
   // CHECK: %[[#SHORT_TO_BOOL:]] = cir.cast(int_to_bool, %[[#SHORT]] : !s16i), !cir.bool
   // CHECK: = cir.unary(not, %[[#SHORT_TO_BOOL]]) : !cir.bool, !cir.bool
-  !l;
+}
+
+long valueNegationLong(long l) {
+// CHECK: cir.func @valueNegationLong(
+  return !l;
   // CHECK: %[[#LONG:]] = cir.load %{{[0-9]+}} : !cir.ptr<!s64i>, !s64i
   // CHECK: %[[#LONG_TO_BOOL:]] = cir.cast(int_to_bool, %[[#LONG]] : !s64i), !cir.bool
   // CHECK: = cir.unary(not, %[[#LONG_TO_BOOL]]) : !cir.bool, !cir.bool
-  !f;
+}
+
+float valueNegationFloat(float f) {
+// CHECK: cir.func @valueNegationFloat(
+  return !f;
   // CHECK: %[[#FLOAT:]] = cir.load %{{[0-9]+}} : !cir.ptr<!cir.float>, !cir.float
   // CHECK: %[[#FLOAT_TO_BOOL:]] = cir.cast(float_to_bool, %[[#FLOAT]] : !cir.float), !cir.bool
   // CHECK: %[[#FLOAT_NOT:]] = cir.unary(not, %[[#FLOAT_TO_BOOL]]) : !cir.bool, !cir.bool
   // CHECK: = cir.cast(bool_to_int, %[[#FLOAT_NOT]] : !cir.bool), !s32i
-  !d;
+}
+
+double valueNegationDouble(double d) {
+// CHECK: cir.func @valueNegationDouble(
+  return !d;
   // CHECK: %[[#DOUBLE:]] = cir.load %{{[0-9]+}} : !cir.ptr<!cir.double>, !cir.double
   // CHECK: %[[#DOUBLE_TO_BOOL:]] = cir.cast(float_to_bool, %[[#DOUBLE]] : !cir.double), !cir.bool
   // CHECK: %[[#DOUBLE_NOT:]] = cir.unary(not, %[[#DOUBLE_TO_BOOL]]) : !cir.bool, !cir.bool

clang/test/CIR/Transforms/merge-cleanups.cir

@@ -117,4 +117,13 @@ module  {
     // CHECK: cir.return
   }
 
+  // Should remove redundant bitcasts.
+  // CHECK-LABEL: @ptrbitcastfold
+  //       CHECK:  %[[ARG0:.+]]: !cir.ptr<!s32i>
+  //       CHECK:  cir.return %[[ARG0]] : !cir.ptr<!s32i>
+  cir.func @ptrbitcastfold(%arg0: !cir.ptr<!s32i>) -> !cir.ptr<!s32i> {
+    %0 = cir.cast(bitcast, %arg0: !cir.ptr<!s32i>), !cir.ptr<!s32i>
+    cir.return %0 : !cir.ptr<!s32i>
+  }
+
 }