[CIR] Introduce CIR simplification (#696)

This PR introduce cir simplification pass. The idea is to have a pass
for the redundant operations removal/update.

Right now two pattern implemented, both related to the redundant `bool`
operations.
First pattern removes redundant casts from `bool` to `int` and back that
for some reasons appear in the code.
Second pattern removes sequential unary not operations (`!!`) .

For example, the code from the test is expanded from the simple check
that is common for C code:

```
#define CHECK_PTR(ptr)  \
  do {                   \
    if (__builtin_expect((!!((ptr) == 0)), 0))\
      return -42; \
  } while(0)
```

I mark this PR as a draft for the following reasons:
1) I have no idea if it's useful for the community
2) There is a test fail - unfortunately current pattern rewriter run DCE
underneath the hood and looks like we can't workaround it.
It's enough just to add an operation to the list - in this case
`UnaryOp` - and call `applyOpPatternsAndFold`. I could rewrite a test a
little in order to make everything non dead or implement a simple fix
point algorithm for the particular task (I would do the former).

Author: gitoleg

clang/include/clang/CIR/Dialect/IR/CIROps.td

@@ -991,6 +991,7 @@ def UnaryOp : CIR_Op<"unary", [Pure, SameOperandsAndResultType]> {
   }];
 
   let hasVerifier = 1;
+  let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//

clang/include/clang/CIR/Dialect/Passes.h

@@ -26,7 +26,7 @@ std::unique_ptr<Pass> createLifetimeCheckPass(ArrayRef<StringRef> remark,
                                               ArrayRef<StringRef> hist,
                                               unsigned hist_limit,
                                               clang::ASTContext *astCtx);
-std::unique_ptr<Pass> createMergeCleanupsPass();
+std::unique_ptr<Pass> createCIRSimplifyPass();
 std::unique_ptr<Pass> createDropASTPass();
 std::unique_ptr<Pass> createSCFPreparePass();
 std::unique_ptr<Pass> createLoweringPreparePass();

clang/include/clang/CIR/Dialect/Passes.td

@@ -11,14 +11,24 @@
 
 include "mlir/Pass/PassBase.td"
 
-def MergeCleanups : Pass<"cir-merge-cleanups"> {
-  let summary = "Remove unnecessary branches to cleanup blocks";
+def CIRSimplify : Pass<"cir-simplify"> {
+  let summary = "Performs CIR simplification";
   let description = [{
-    Canonicalize pass is too aggressive for CIR when the pipeline is
-    used for C/C++ analysis. This pass runs some rewrites for scopes,
-    merging some blocks and eliminating unnecessary control-flow.
+    The pass rewrites CIR and removes some redundant operations.    
+    
+    For example, due to canonicalize pass is too aggressive for CIR when
+    the pipeline is used for C/C++ analysis, this pass runs some rewrites
+    for scopes, merging some blocks and eliminating unnecessary control-flow.
+
+    Also, the pass removes redundant and/or unneccessary cast and unary not 
+    operation e.g.
+    ```mlir
+      %1 = cir.cast(bool_to_int, %0 : !cir.bool), !s32i
+      %2 = cir.cast(int_to_bool, %1 : !s32i), !cir.bool
+    ```
+
   }];
-  let constructor = "mlir::createMergeCleanupsPass()";
+  let constructor = "mlir::createCIRSimplifyPass()";
   let dependentDialects = ["cir::CIRDialect"];
 }
 

clang/lib/CIR/CodeGen/CIRPasses.cpp

@@ -19,8 +19,6 @@
 #include "mlir/Support/LogicalResult.h"
 #include "mlir/Transforms/Passes.h"
 
-#include <iostream>
-
 namespace cir {
 mlir::LogicalResult runCIRToCIRPasses(
     mlir::ModuleOp theModule, mlir::MLIRContext *mlirCtx,
@@ -32,7 +30,7 @@ mlir::LogicalResult runCIRToCIRPasses(
     bool enableMem2Reg) {
 
   mlir::PassManager pm(mlirCtx);
-  pm.addPass(mlir::createMergeCleanupsPass());
+  pm.addPass(mlir::createCIRSimplifyPass());
 
   // TODO(CIR): Make this actually propagate errors correctly. This is stubbed
   // in to get rebases going.

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

@@ -528,26 +528,86 @@ LogicalResult CastOp::verify() {
   llvm_unreachable("Unknown CastOp kind?");
 }
 
-OpFoldResult CastOp::fold(FoldAdaptor adaptor) {
-  if (getSrc().getType() != getResult().getType())
-    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:
-  case mlir::cir::CastKind::address_space: {
-    return getSrc();
+bool isIntOrBoolCast(mlir::cir::CastOp op) {
+  auto kind = op.getKind();
+  return kind == mlir::cir::CastKind::bool_to_int ||
+         kind == mlir::cir::CastKind::int_to_bool ||
+         kind == mlir::cir::CastKind::integral;
+}
+
+Value tryFoldCastChain(CastOp op) {
+  CastOp head = op, tail = op;  
+
+  while(op) {
+    if (!isIntOrBoolCast(op))  
+      break;
+    head = op;
+    op = dyn_cast_or_null<CastOp>(head.getSrc().getDefiningOp());
   }
-  default:
+
+  if (head == tail)
     return {};
+
+  // if bool_to_int -> ...  -> int_to_bool: take the bool
+  // as we had it was before all casts
+  if (head.getKind() == mlir::cir::CastKind::bool_to_int &&
+      tail.getKind() == mlir::cir::CastKind::int_to_bool)
+    return head.getSrc();
+
+  // if int_to_bool -> ...  -> int_to_bool: take the result
+  // of the first one, as no other casts (and ext casts as well)
+  // don't change the first result
+  if (head.getKind() == mlir::cir::CastKind::int_to_bool &&
+      tail.getKind() == mlir::cir::CastKind::int_to_bool)
+    return head.getResult();
+
+  return {};
+}
+
+OpFoldResult CastOp::fold(FoldAdaptor adaptor) {  
+  if (getSrc().getType() == getResult().getType()) {
+    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:
+    case mlir::cir::CastKind::address_space: {
+      return getSrc();
+    }  
+    default:
+      return {};
+    }
   }
+  return tryFoldCastChain(*this);
+}
+
+static bool isBoolNot(mlir::cir::UnaryOp op) {
+  return isa<BoolType>(op.getInput().getType()) &&
+         op.getKind() == mlir::cir::UnaryOpKind::Not;
+}
+
+/*  This folder simplifies the sequential boolean not operations.
+    For instance, the next two unary operations will be eliminated:
+    
+    ```mlir
+    %1 = cir.unary(not, %0) : !cir.bool, !cir.bool
+    %2 = cir.unary(not, %1) : !cir.bool, !cir.bool
+    ```
+    
+    and the argument of the first one (%0) will be used instead. */
+OpFoldResult UnaryOp::fold(FoldAdaptor adaptor) {
+  if (isBoolNot(*this))
+    if (auto previous = dyn_cast_or_null<UnaryOp>(getInput().getDefiningOp()))
+      if (isBoolNot(previous))
+        return previous.getInput();
+
+  return {};
 }
 
 //===----------------------------------------------------------------------===//

clang/lib/CIR/Dialect/Transforms/MergeCleanups.cpp renamed to clang/lib/CIR/Dialect/Transforms/CIRSimplify.cpp

@@ -1,4 +1,4 @@
-//===- MergeCleanups.cpp - merge simple return/yield blocks ---------------===//
+//===- CIRSimplify.cpp - performs CIR simplification ----------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
@@ -108,11 +108,11 @@ struct RemoveTrivialTry : public OpRewritePattern<TryOp> {
 };
 
 //===----------------------------------------------------------------------===//
-// MergeCleanupsPass
+// CIRSimplifyPass
 //===----------------------------------------------------------------------===//
 
-struct MergeCleanupsPass : public MergeCleanupsBase<MergeCleanupsPass> {
-  using MergeCleanupsBase::MergeCleanupsBase;
+struct CIRSimplifyPass : public CIRSimplifyBase<CIRSimplifyPass> {
+  using CIRSimplifyBase::CIRSimplifyBase;
 
   // The same operation rewriting done here could have been performed
   // by CanonicalizerPass (adding hasCanonicalizer for target Ops and
@@ -136,7 +136,7 @@ void populateMergeCleanupPatterns(RewritePatternSet &patterns) {
   // clang-format on
 }
 
-void MergeCleanupsPass::runOnOperation() {
+void CIRSimplifyPass::runOnOperation() {
   // Collect rewrite patterns.
   RewritePatternSet patterns(&getContext());
   populateMergeCleanupPatterns(patterns);
@@ -146,7 +146,7 @@ void MergeCleanupsPass::runOnOperation() {
   getOperation()->walk([&](Operation *op) {
     // CastOp here is to perform a manual `fold` in
     // applyOpPatternsAndFold
-    if (isa<BrOp, BrCondOp, ScopeOp, SwitchOp, CastOp, TryOp>(op))
+    if (isa<BrOp, BrCondOp, ScopeOp, SwitchOp, CastOp, TryOp, UnaryOp>(op))
       ops.push_back(op);
   });
 
@@ -157,6 +157,6 @@ void MergeCleanupsPass::runOnOperation() {
 
 } // namespace
 
-std::unique_ptr<Pass> mlir::createMergeCleanupsPass() {
-  return std::make_unique<MergeCleanupsPass>();
+std::unique_ptr<Pass> mlir::createCIRSimplifyPass() {
+  return std::make_unique<CIRSimplifyPass>();
 }

clang/lib/CIR/Dialect/Transforms/CMakeLists.txt

@@ -3,7 +3,7 @@ add_subdirectory(TargetLowering)
 add_clang_library(MLIRCIRTransforms
   LifetimeCheck.cpp
   LoweringPrepare.cpp
-  MergeCleanups.cpp
+  CIRSimplify.cpp
   DropAST.cpp
   IdiomRecognizer.cpp
   LibOpt.cpp

clang/test/CIR/CodeGen/unary.cpp

@@ -155,28 +155,28 @@ int *inc_p(int *i) {
 
 void floats(float f) {
 // CHECK: cir.func @{{.+}}floats{{.+}}
-  +f; // CHECK: %{{[0-9]+}} = cir.unary(plus, %{{[0-9]+}}) : !cir.float, !cir.float
-  -f; // CHECK: %{{[0-9]+}} = cir.unary(minus, %{{[0-9]+}}) : !cir.float, !cir.float
+  f = +f; // CHECK: %{{[0-9]+}} = cir.unary(plus, %{{[0-9]+}}) : !cir.float, !cir.float
+  f = -f; // CHECK: %{{[0-9]+}} = cir.unary(minus, %{{[0-9]+}}) : !cir.float, !cir.float
   ++f; // CHECK: = cir.unary(inc, %{{[0-9]+}}) : !cir.float, !cir.float
   --f; // CHECK: = cir.unary(dec, %{{[0-9]+}}) : !cir.float, !cir.float
   f++; // CHECK: = cir.unary(inc, %{{[0-9]+}}) : !cir.float, !cir.float
   f--; // CHECK: = cir.unary(dec, %{{[0-9]+}}) : !cir.float, !cir.float
 
-  !f;
+  f = !f;
   // CHECK: %[[#F_BOOL:]] = cir.cast(float_to_bool, %{{[0-9]+}} : !cir.float), !cir.bool
   // CHECK: = cir.unary(not, %[[#F_BOOL]]) : !cir.bool, !cir.bool
 }
 
 void doubles(double d) {
 // CHECK: cir.func @{{.+}}doubles{{.+}}
-  +d; // CHECK: %{{[0-9]+}} = cir.unary(plus, %{{[0-9]+}}) : !cir.double, !cir.double
-  -d; // CHECK: %{{[0-9]+}} = cir.unary(minus, %{{[0-9]+}}) : !cir.double, !cir.double
+  d = +d; // CHECK: %{{[0-9]+}} = cir.unary(plus, %{{[0-9]+}}) : !cir.double, !cir.double
+  d = -d; // CHECK: %{{[0-9]+}} = cir.unary(minus, %{{[0-9]+}}) : !cir.double, !cir.double
   ++d; // CHECK: = cir.unary(inc, %{{[0-9]+}}) : !cir.double, !cir.double
   --d; // CHECK: = cir.unary(dec, %{{[0-9]+}}) : !cir.double, !cir.double
   d++; // CHECK: = cir.unary(inc, %{{[0-9]+}}) : !cir.double, !cir.double
   d--; // CHECK: = cir.unary(dec, %{{[0-9]+}}) : !cir.double, !cir.double
 
-  !d;
+  d = !d;
   // CHECK: %[[#D_BOOL:]] = cir.cast(float_to_bool, %{{[0-9]+}} : !cir.double), !cir.bool
   // CHECK: = cir.unary(not, %[[#D_BOOL]]) : !cir.bool, !cir.bool
 }
@@ -185,7 +185,7 @@ void pointers(int *p) {
 // CHECK: cir.func @{{[^ ]+}}pointers
   // CHECK: %[[#P:]] = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
 
-  +p;
+  p = +p;
   // CHECK: cir.unary(plus, %{{.+}}) : !cir.ptr<!s32i>, !cir.ptr<!s32i>
 
   ++p;
@@ -205,28 +205,28 @@ void pointers(int *p) {
   // CHECK:  %[[#RES:]] = cir.ptr_stride(%{{.+}} : !cir.ptr<!s32i>, %[[#DEC]] : !s32i), !cir.ptr<!s32i>
   // CHECK:  cir.store %[[#RES]], %[[#P]] : !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>
 
-  !p;
+  bool p1 = !p;
   // %[[BOOLPTR:]] = cir.cast(ptr_to_bool, %15 : !cir.ptr<!s32i>), !cir.bool
   // cir.unary(not, %[[BOOLPTR]]) : !cir.bool, !cir.bool
 }
 
 void chars(char c) {
 // CHECK: cir.func @{{.+}}chars{{.+}}
 
-  +c;
+  int c1 = +c;
   // CHECK: %[[#PROMO:]] = cir.cast(integral, %{{.+}} : !s8i), !s32i
   // CHECK: cir.unary(plus, %[[#PROMO]]) : !s32i, !s32i
-  -c;
+  int c2 = -c;
   // CHECK: %[[#PROMO:]] = cir.cast(integral, %{{.+}} : !s8i), !s32i
   // CHECK: cir.unary(minus, %[[#PROMO]]) : !s32i, !s32i
 
   // Chars can go through some integer promotion codegen paths even when not promoted.
-  ++c; // CHECK: cir.unary(inc, %7) : !s8i, !s8i
-  --c; // CHECK: cir.unary(dec, %9) : !s8i, !s8i
-  c++; // CHECK: cir.unary(inc, %11) : !s8i, !s8i
-  c--; // CHECK: cir.unary(dec, %13) : !s8i, !s8i
+  ++c; // CHECK: cir.unary(inc, %10) : !s8i, !s8i
+  --c; // CHECK: cir.unary(dec, %12) : !s8i, !s8i
+  c++; // CHECK: cir.unary(inc, %14) : !s8i, !s8i
+  c--; // CHECK: cir.unary(dec, %16) : !s8i, !s8i
 
-  !c;
+  bool c3 = !c;
   // CHECK: %[[#C_BOOL:]] = cir.cast(int_to_bool, %{{[0-9]+}} : !s8i), !cir.bool
   // CHECK: cir.unary(not, %[[#C_BOOL]]) : !cir.bool, !cir.bool
 }

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

@@ -1,4 +1,4 @@
-// RUN: cir-opt %s -cir-merge-cleanups -o %t.out.cir
+// RUN: cir-opt %s -cir-simplify -o %t.out.cir
 // RUN: FileCheck --input-file=%t.out.cir %s
 
 #false = #cir.bool<false> : !cir.bool

clang/test/CIR/Transforms/simpl.c

@@ -0,0 +1,38 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir -mmlir --mlir-print-ir-before=cir-simplify %s -o %t1.cir 2>&1 | FileCheck -check-prefix=BEFORE %s
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir -mmlir --mlir-print-ir-after=cir-simplify %s -o %t2.cir 2>&1 | FileCheck -check-prefix=AFTER %s
+
+
+#define CHECK_PTR(ptr)  \
+  do {                   \
+    if (__builtin_expect((!!((ptr) == 0)), 0))\
+      return -42; \
+  } while(0)
+
+int foo(int* ptr) {  
+  CHECK_PTR(ptr);
+
+  (*ptr)++;
+  return 0;
+}
+
+// BEFORE:  cir.func {{.*@foo}}
+// BEFORE:  [[X0:%.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// BEFORE:  [[X1:%.*]] = cir.const #cir.ptr<null> : !cir.ptr<!s32i>
+// BEFORE:  [[X2:%.*]] = cir.cmp(eq, [[X0]], [[X1]]) : !cir.ptr<!s32i>, !s32i
+// BEFORE:  [[X3:%.*]] = cir.cast(int_to_bool, [[X2]] : !s32i), !cir.bool
+// BEFORE:  [[X4:%.*]] = cir.unary(not, [[X3]]) : !cir.bool, !cir.bool
+// BEFORE:  [[X5:%.*]] = cir.cast(bool_to_int, [[X4]] : !cir.bool), !s32i
+// BEFORE:  [[X6:%.*]] = cir.cast(int_to_bool, [[X5]] : !s32i), !cir.bool
+// BEFORE:  [[X7:%.*]] = cir.unary(not, [[X6]]) : !cir.bool, !cir.bool
+// BEFORE:  [[X8:%.*]] = cir.cast(bool_to_int, [[X7]] : !cir.bool), !s32i
+// BEFORE:  [[X9:%.*]] = cir.cast(integral, [[X8]] : !s32i), !s64i
+// BEFORE:  [[X10:%.*]] = cir.const #cir.int<0> : !s32i
+// BEFORE:  [[X11:%.*]] = cir.cast(integral, [[X10]] : !s32i), !s64i
+// BEFORE:  [[X12:%.*]] = cir.cast(int_to_bool, [[X9]] : !s64i), !cir.bool
+// BEFORE:  cir.if [[X12]] 
+
+// AFTER:   [[X0:%.*]] = cir.load {{.*}} : !cir.ptr<!cir.ptr<!s32i>>, !cir.ptr<!s32i>
+// AFTER:   [[X1:%.*]] = cir.const #cir.ptr<null> : !cir.ptr<!s32i>
+// AFTER:   [[X2:%.*]] = cir.cmp(eq, [[X0]], [[X1]]) : !cir.ptr<!s32i>, !s32i
+// AFTER:   [[X3:%.*]] = cir.cast(int_to_bool, [[X2]] : !s32i), !cir.bool
+// AFTER:   cir.if [[X3]]