[MLIR][Standard] Erase redundant assertions `std.assert`

[frgossen]

Summary

Depends On D83117

[herhut]

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

453

You could use matchPattern here (see a couple lines above).

mlir/test/Dialect/Standard/canonicalize-cf.mlir

149

:)

[frgossen]

Address suggestions

[herhut]

Nice. Thanks.

[frgossen]

Rebase

mlir/include/mlir/Dialect/StandardOps/IR/Ops.td

def AssertOp : Std_Op<"assert"> {
   }];
 
   let arguments = (ins I1:$arg, StrAttr:$msg);
 
   let assemblyFormat = "$arg `,` $msg attr-dict";
 
   // AssertOp is fully verified by its traits.
   let verifier = ?;
+
+  let hasCanonicalizer = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AssumeAlignmentOp
 //===----------------------------------------------------------------------===//
 
 def AssumeAlignmentOp : Std_Op<"assume_alignment"> {
   let summary =

mlir/lib/Dialect/StandardOps/IR/Ops.cpp

OpFoldResult AndOp::fold(ArrayRef<Attribute> operands) {
   if (lhs() == rhs())
     return rhs();
 
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](APInt a, APInt b) { return a & b; });
 }
 
 //===----------------------------------------------------------------------===//
+// AssertOp
+//===----------------------------------------------------------------------===//
+
+namespace {
+struct EraseRedundantAssertions : public OpRewritePattern<AssertOp> {
+  using OpRewritePattern<AssertOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(AssertOp op,
+                                PatternRewriter &rewriter) const override {
+    // Erase assertion if argument is constant true.
+    if (matchPattern(op.arg(), m_One())) {
+      rewriter.eraseOp(op);
+      return success();
+    }
+    return failure();
+  }
+};
+} // namespace
+
+void AssertOp::getCanonicalizationPatterns(OwningRewritePatternList &patterns,
+                                           MLIRContext *context) {
+  patterns.insert<EraseRedundantAssertions>(context);
+}
+
+//===----------------------------------------------------------------------===//
 // AssumeAlignmentOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(AssumeAlignmentOp op) {
   unsigned alignment = op.alignment().getZExtValue();
   if (!llvm::isPowerOf2_32(alignment))
     return op.emitOpError("alignment must be power of 2");
   return success();

mlir/test/Dialect/Standard/canonicalize-cf.mlir

^bb1:
 
   // Successors can't be collapsed if they contain other operations.
   "foo.op"() : () -> ()
   br ^bb2
 
 ^bb2:
   return
 }
+
+// -----
+
+// Erase assertion if condition is known to be true at compile time.
+// CHECK-LABEL: @assert_true
+func @assert_true() {
+  // CHECK-NOT: assert
+  %true = constant true
+  assert %true, "Computer says no"
+  return
+}
+
+// -----
+
+// Keep assertion if condition unknown at compile time.
+// CHECK-LABEL: @assert
+// CHECK-SAME:  (%[[ARG:.*]]: i1)
+func @assert(%arg : i1) {
+  // CHECK: assert %[[ARG]], "Computer says no"
+  assert %arg, "Computer says no"
+  return
+}
+