Several canonicalizations of standard ops (add, sub, cast).

[wsmoses]

Summary

Introduce several canonicalizations of standard operations:

1. Canonicalizatinos for sub/add of a constant and another sub/add of a constant
2. Sign Extend folds
3. Not of icmp becomes a signle icmp
4. Branch propagation
5. Index cast of sign extend

[wsmoses]

Address nits

[rriddle]

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

1828

Don't use ConstantOp, use m_Constant to match constants.

[rriddle]

Can you split this up into several focused commits?

[wsmoses]

Remove all canoncalizations exclude the add/sub (factored out into separate diffs)

[ftynse]

I wonder if there is some way of writing these without so much repetition...

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

306–307

This may also swap the operands... It is okay for addi, but should be mentioned in the description.

[jpienaar]

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

302

Note: addi is commutative and commutative operations have their constant operand canonicalized to RHS. So does this need to check for constants both sides?

mlir/include/mlir/Dialect/LLVMIR/LLVMOps.td

def ICmpPredicate : I64EnumAttr<
      ICmpPredicateSGT, ICmpPredicateSGE, ICmpPredicateULT, ICmpPredicateULE,
      ICmpPredicateUGT, ICmpPredicateUGE]> {
   let cppNamespace = "::mlir::LLVM";
 }
 
 // Other integer operations.
 def LLVM_ICmpOp : LLVM_Op<"icmp", [NoSideEffect]> {
   let arguments = (ins ICmpPredicate:$predicate,
-                   LLVM_ScalarOrVectorOf<LLVM_AnyInteger>:$lhs,
-                   LLVM_ScalarOrVectorOf<LLVM_AnyInteger>:$rhs);
+                   AnyTypeOf<[LLVM_ScalarOrVectorOf<LLVM_AnyInteger>, LLVM_ScalarOrVectorOf<LLVM_AnyPointer>]>:$lhs,
+                   AnyTypeOf<[LLVM_ScalarOrVectorOf<LLVM_AnyInteger>, LLVM_ScalarOrVectorOf<LLVM_AnyPointer>]>:$rhs);
   let results = (outs LLVM_ScalarOrVectorOf<I1>:$res);
   let llvmBuilder = [{
     $res = builder.CreateICmp(getLLVMCmpPredicate($predicate), $lhs, $rhs);
   }];
   let builders = [
     OpBuilder<(ins "ICmpPredicate":$predicate, "Value":$lhs, "Value":$rhs),
     [{
       build($_builder, $_state, IntegerType::get(lhs.getType().getContext(), 1),

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

let description = [{
     // SIMD vector element-wise addition, e.g. for Intel SSE.
     %f = addi %g, %h : vector<4xi32>
 
     // Tensor element-wise addition.
     %x = addi %y, %z : tensor<4x?xi8>
     ```
   }];
   let hasFolder = 1;
+  let hasCanonicalizer = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // AndOp
 //===----------------------------------------------------------------------===//
 
 def AndOp : IntBinaryOp<"and", [Commutative]> {
   let summary = "integer binary and";
def IndexCastOp : ArithmeticCastOp<"index_cast">, Arguments<(ins AnyType:$in)> {
   let summary = "cast between index and integer types";
   let description = [{
     Casts between integer scalars and 'index' scalars. Index is an integer of
     platform-specific bit width. If casting to a wider integer, the value is
     sign-extended. If casting to a narrower integer, the value is truncated.
   }];
 
   let hasFolder = 1;
+  let hasCanonicalizer = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // MulFOp
 //===----------------------------------------------------------------------===//
 
 def MulFOp : FloatBinaryOp<"mulf"> {
   let summary = "floating point multiplication operation";
let builders = [
     }]>];
 
   let parser = [{
     return impl::parseCastOp(parser, result);
   }];
   let printer = [{
     return printStandardCastOp(this->getOperation(), p);
   }];
+  let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // SIToFPOp
 //===----------------------------------------------------------------------===//
 
 def SIToFPOp : ArithmeticCastOp<"sitofp">, Arguments<(ins AnyType:$in)> {
   let summary = "cast from integer type to floating-point";

 
 //===----------------------------------------------------------------------===//
 // SubIOp
 //===----------------------------------------------------------------------===//
 
 def SubIOp : IntBinaryOp<"subi"> {
   let summary = "integer subtraction operation";
   let hasFolder = 1;
+  let hasCanonicalizer = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // SubTensorOp
 //===----------------------------------------------------------------------===//
 
 def SubTensorOp : BaseOpWithOffsetSizesAndStrides<
     StandardOps_Dialect, "subtensor", [NoSideEffect, AttrSizedOperandSegments,
let description = [{
     // SIMD vector element-wise bitwise integer xor.
     %f = xor %g, %h : vector<4xi32>
 
     // Tensor element-wise bitwise integer xor.
     %x = xor %y, %z : tensor<4x?xi8>
     ```
   }];
   let hasFolder = 1;
+  let hasCanonicalizer = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // ZeroExtendIOp
 //===----------------------------------------------------------------------===//
 
 def ZeroExtendIOp : Std_Op<"zexti", [NoSideEffect,
     DeclareOpInterfaceMethods<VectorUnrollOpInterface>] #

mlir/lib/Conversion/StandardToLLVM/StandardToLLVM.cpp

for (unsigned i = 0, e = funcOp.getNumArguments(); i < e; ++i) {
       for (size_t j = 0; j < mapping->size; ++j) {
         impl::getArgAttrName(mapping->inputNo + j, name);
         attributes.push_back(rewriter.getNamedAttr(name, attr));
       }
     }
 
     // Create an LLVM function, use external linkage by default until MLIR
     // functions have linkage.
+    LLVM::Linkage linkage = (funcOp.isPublic() || funcOp.isExternal())
+                                ? LLVM::Linkage::External
+                                : LLVM::Linkage::Private;
     auto newFuncOp = rewriter.create<LLVM::LLVMFuncOp>(
-        funcOp.getLoc(), funcOp.getName(), llvmType, LLVM::Linkage::External,
-        attributes);
+        funcOp.getLoc(), funcOp.getName(), llvmType, linkage, attributes);
     rewriter.inlineRegionBefore(funcOp.getBody(), newFuncOp.getBody(),
                                 newFuncOp.end());
     if (failed(rewriter.convertRegionTypes(&newFuncOp.getBody(), *typeConverter,
                                            &result)))
       return nullptr;
 
     return newFuncOp;
   }

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

 /// Extract int64_t values from the assumed ArrayAttr of IntegerAttr.
 static SmallVector<int64_t, 4> extractFromI64ArrayAttr(Attribute attr) {
   return llvm::to_vector<4>(
       llvm::map_range(attr.cast<ArrayAttr>(), [](Attribute a) -> int64_t {
         return a.cast<IntegerAttr>().getInt();
       }));
 }
 
+/// Canonicalize a sum of a constant and (constant - something) to simply be
+/// a sum of constants minus something. This transformation does similar
+/// transformations for additions of a constant with a subtract/add of
+/// a constant.
+struct AddConstantReorder : public OpRewritePattern<AddIOp> {
+  using OpRewritePattern<AddIOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(AddIOp addop,
+                                PatternRewriter &rewriter) const override {
+    for (int i = 0; i < 2; i++) {
+      if (auto origConstOp = addop.getOperand(i).getDefiningOp<ConstantOp>()) {
+
+        if (auto midAddOp = addop.getOperand(1 - i).getDefiningOp<AddIOp>()) {
+          for (int j = 0; j < 2; j++) {
+            if (auto midConstOp =
+                    midAddOp.getOperand(j).getDefiningOp<ConstantOp>()) {
+              auto nextConstant = rewriter.create<ConstantOp>(
+                  addop.getLoc(),
+                  rewriter.getIntegerAttr(
+                      addop.getType(),
+                      origConstOp.getValue().cast<IntegerAttr>().getValue() +
+                          midConstOp.getValue()
+                              .cast<IntegerAttr>()
+                              .getValue()));
+              rewriter.replaceOpWithNewOp<AddIOp>(addop, nextConstant,
+                                                  midAddOp.getOperand(1 - j));
+              return success();
+            }
+          }
+        }
+        if (auto midSubOp = addop.getOperand(1 - i).getDefiningOp<SubIOp>()) {
+          if (auto midConstOp =
+                  midSubOp.getOperand(0).getDefiningOp<ConstantOp>()) {
+            auto nextConstant = rewriter.create<ConstantOp>(
+                addop.getLoc(),
+                rewriter.getIntegerAttr(
+                    addop.getType(),
+                    origConstOp.getValue().cast<IntegerAttr>().getValue() +
+                        midConstOp.getValue().cast<IntegerAttr>().getValue()));
+            rewriter.replaceOpWithNewOp<SubIOp>(addop, nextConstant,
+                                                midSubOp.getOperand(1));
+            return success();
+          }
+          if (auto midConstOp =
+                  midSubOp.getOperand(1).getDefiningOp<ConstantOp>()) {
+            auto nextConstant = rewriter.create<ConstantOp>(
+                addop.getLoc(),
+                rewriter.getIntegerAttr(
+                    addop.getType(),
+                    origConstOp.getValue().cast<IntegerAttr>().getValue() -
+                        midConstOp.getValue().cast<IntegerAttr>().getValue()));
+            rewriter.replaceOpWithNewOp<AddIOp>(addop, nextConstant,
+                                                midSubOp.getOperand(0));
+            return success();
+          }
+        }
+      }
+    }
+    return failure();
+  }
+};
+
+void AddIOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                         MLIRContext *context) {
+  results.insert<AddConstantReorder>(context);
+}
+
 //===----------------------------------------------------------------------===//
 // AndOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult AndOp::fold(ArrayRef<Attribute> operands) {
   /// and(x, 0) -> 0
   if (matchPattern(rhs(), m_Zero()))
     return rhs();
if (currentBlock == predBranch.trueDest())
       rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.trueDest(),
                                             condbr.trueDestOperands());
     else
       rewriter.replaceOpWithNewOp<BranchOp>(condbr, condbr.falseDest(),
                                             condbr.falseDestOperands());
     return success();
   }
 };
+
+struct CondBranchTruthPropagation : public OpRewritePattern<CondBranchOp> {
+  using OpRewritePattern<CondBranchOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(CondBranchOp condbr,
+                                PatternRewriter &rewriter) const override {
+    // Check that we have a single distinct predecessor.
+    bool replaced = false;
+    mlir::Type ty = rewriter.getI1Type();
+
+    if (condbr.getTrueDest()->getSinglePredecessor()) {
+      for (OpOperand &use :
+           llvm::make_early_inc_range(condbr.condition().getUses())) {
+        if (use.getOwner()->getBlock() == condbr.getTrueDest()) {
+          replaced = true;
+          rewriter.updateRootInPlace(use.getOwner(), [&]() {
+            use.set(rewriter.create<mlir::ConstantOp>(
+                condbr.getLoc(), ty, rewriter.getIntegerAttr(ty, 1)));
+          });
+        }
+      }
+    }
+    if (condbr.getFalseDest()->getSinglePredecessor()) {
+      for (OpOperand &use :
+           llvm::make_early_inc_range(condbr.condition().getUses())) {
+        if (use.getOwner()->getBlock() == condbr.getFalseDest()) {
+          replaced = true;
+          rewriter.updateRootInPlace(use.getOwner(), [&]() {
+            use.set(rewriter.create<mlir::ConstantOp>(
+                condbr.getLoc(), ty, rewriter.getIntegerAttr(ty, 0)));
+          });
+        }
+      }
+    }
+    return replaced ? success() : failure();
+  }
+};
 } // end anonymous namespace
 
 void CondBranchOp::getCanonicalizationPatterns(RewritePatternSet &results,
                                                MLIRContext *context) {
   results.add<SimplifyConstCondBranchPred, SimplifyPassThroughCondBranch,
               SimplifyCondBranchIdenticalSuccessors,
-              SimplifyCondBranchFromCondBranchOnSameCondition>(context);
+              SimplifyCondBranchFromCondBranchOnSameCondition,
+              CondBranchTruthPropagation>(context);
 }
 
 Optional<MutableOperandRange>
 CondBranchOp::getMutableSuccessorOperands(unsigned index) {
   assert(index < getNumSuccessors() && "invalid successor index");
   return index == trueIndex ? trueDestOperandsMutable()
                             : falseDestOperandsMutable();
 }
OpFoldResult IndexCastOp::fold(ArrayRef<Attribute> cstOperands) {
   // A little hack because we go through int.  Otherwise, the size
   // of the constant might need to change.
   if (auto value = cstOperands[0].dyn_cast_or_null<IntegerAttr>())
     return IntegerAttr::get(getType(), value.getInt());
 
   return {};
 }
 
+namespace {
+struct IndexCastOfSExt : public OpRewritePattern<IndexCastOp> {
+  using OpRewritePattern<IndexCastOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(IndexCastOp op,
+                                PatternRewriter &rewriter) const override {
+
+    if (auto extop = op.getOperand().getDefiningOp<SignExtendIOp>()) {
+      op.setOperand(extop.getOperand());
+      return success();
+    }
+    return failure();
+  }
+};
+
+} // namespace
+
+void IndexCastOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                              MLIRContext *context) {
+  results.insert<IndexCastOfSExt>(context);
+}
+
 //===----------------------------------------------------------------------===//
 // MulFOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult MulFOp::fold(ArrayRef<Attribute> operands) {
   return constFoldBinaryOp<FloatAttr>(
       operands, [](APFloat a, APFloat b) { return a * b; });
 }
static LogicalResult verify(SignExtendIOp op) {
   if (srcType.cast<IntegerType>().getWidth() >=
       dstType.cast<IntegerType>().getWidth())
     return op.emitError("result type ")
            << dstType << " must be wider than operand type " << srcType;
 
   return success();
 }
 
+OpFoldResult SignExtendIOp::fold(ArrayRef<Attribute> operands) {
+  assert(operands.size() == 1 && "unary operation takes one operands");
+
+  if (!operands[0])
+    return {};
+
+  if (operands[0].isa<IntegerAttr>()) {
+    auto lhs = operands[0].cast<IntegerAttr>();
+
+    return IntegerAttr::get(
+        getType(), lhs.getValue().sext(getType().getIntOrFloatBitWidth()));
+  }
+
+  return {};
+}
+
 //===----------------------------------------------------------------------===//
 // SignedDivIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult SignedDivIOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "binary operation takes two operands");
 
   // Don't fold if it would overflow or if it requires a division by zero.
OpFoldResult SubIOp::fold(ArrayRef<Attribute> operands) {
   // subi(x,0) -> x
   if (matchPattern(rhs(), m_Zero()))
     return lhs();
 
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](APInt a, APInt b) { return a - b; });
 }
 
+/// Canonicalize a sub of a constant and (constant +/- something) to simply be
+/// a single operation that merges the two constants.
+struct SubConstantReorder : public OpRewritePattern<SubIOp> {
+  using OpRewritePattern<SubIOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(SubIOp subOp,
+                                PatternRewriter &rewriter) const override {
+    if (auto origConstOp = subOp.getOperand(0).getDefiningOp<ConstantOp>()) {
+
+      if (auto midAddOp = subOp.getOperand(1).getDefiningOp<AddIOp>()) {
+        // c1 - (c2 + something) == (c1 - c2) - something
+        for (int j = 0; j < 2; j++) {
+          if (auto midConstOp =
+                  midAddOp.getOperand(j).getDefiningOp<ConstantOp>()) {
+            auto nextConstant = rewriter.create<ConstantOp>(
+                subOp.getLoc(),
+                rewriter.getIntegerAttr(
+                    subOp.getType(),
+                    origConstOp.getValue().cast<IntegerAttr>().getValue() -
+                        midConstOp.getValue().cast<IntegerAttr>().getValue()));
+            rewriter.replaceOpWithNewOp<SubIOp>(subOp, nextConstant,
+                                                midAddOp.getOperand(1 - j));
+            return success();
+          }
+        }
+      }
+
+      if (auto midSubOp = subOp.getOperand(0).getDefiningOp<SubIOp>()) {
+        if (auto midConstOp =
+                midSubOp.getOperand(0).getDefiningOp<ConstantOp>()) {
+          // (c2 - something) - c1 == (c2 - c1) - something
+          auto nextConstant = rewriter.create<ConstantOp>(
+              subOp.getLoc(),
+              rewriter.getIntegerAttr(
+                  subOp.getType(),
+                  midConstOp.getValue().cast<IntegerAttr>().getValue() -
+                      origConstOp.getValue().cast<IntegerAttr>().getValue()));
+          rewriter.replaceOpWithNewOp<SubIOp>(subOp, nextConstant,
+                                              midSubOp.getOperand(1));
+          return success();
+        }
+        if (auto midConstOp =
+                midSubOp.getOperand(1).getDefiningOp<ConstantOp>()) {
+          // (something - c2) - c1 == something - (c1 + c2)
+          auto nextConstant = rewriter.create<ConstantOp>(
+              subOp.getLoc(),
+              rewriter.getIntegerAttr(
+                  subOp.getType(),
+                  origConstOp.getValue().cast<IntegerAttr>().getValue() +
+                      midConstOp.getValue().cast<IntegerAttr>().getValue()));
+          rewriter.replaceOpWithNewOp<SubIOp>(subOp, midSubOp.getOperand(0),
+                                              nextConstant);
+          return success();
+        }
+      }
+
+      if (auto midSubOp = subOp.getOperand(1).getDefiningOp<SubIOp>()) {
+        if (auto midConstOp =
+                midSubOp.getOperand(0).getDefiningOp<ConstantOp>()) {
+          // c1 - (c2 - something) == (c1 - c2) + something
+          auto nextConstant = rewriter.create<ConstantOp>(
+              subOp.getLoc(),
+              rewriter.getIntegerAttr(
+                  subOp.getType(),
+                  origConstOp.getValue().cast<IntegerAttr>().getValue() -
+                      midConstOp.getValue().cast<IntegerAttr>().getValue()));
+          rewriter.replaceOpWithNewOp<AddIOp>(subOp, nextConstant,
+                                              midSubOp.getOperand(1));
+          return success();
+        }
+        if (auto midConstOp =
+                midSubOp.getOperand(1).getDefiningOp<ConstantOp>()) {
+          // c1 - (something - c2) == (c1 + c2) - something
+          auto nextConstant = rewriter.create<ConstantOp>(
+              subOp.getLoc(),
+              rewriter.getIntegerAttr(
+                  subOp.getType(),
+                  origConstOp.getValue().cast<IntegerAttr>().getValue() +
+                      midConstOp.getValue().cast<IntegerAttr>().getValue()));
+          rewriter.replaceOpWithNewOp<SubIOp>(subOp, nextConstant,
+                                              midSubOp.getOperand(0));
+          return success();
+        }
+      }
+    }
+    if (auto origConstOp = subOp.getOperand(1).getDefiningOp<ConstantOp>()) {
+
+      if (auto midAddOp = subOp.getOperand(0).getDefiningOp<AddIOp>()) {
+        // (c2 + something) - c1 == (c2 - c1) + something
+        for (int j = 0; j < 2; j++) {
+          if (auto midConstOp =
+                  midAddOp.getOperand(j).getDefiningOp<ConstantOp>()) {
+            auto nextConstant = rewriter.create<ConstantOp>(
+                subOp.getLoc(),
+                rewriter.getIntegerAttr(
+                    subOp.getType(),
+                    midConstOp.getValue().cast<IntegerAttr>().getValue() -
+                        origConstOp.getValue().cast<IntegerAttr>().getValue()));
+            rewriter.replaceOpWithNewOp<AddIOp>(subOp, nextConstant,
+                                                midAddOp.getOperand(1 - j));
+            return success();
+          }
+        }
+      }
+
+      if (auto midSubOp = subOp.getOperand(0).getDefiningOp<SubIOp>()) {
+        if (auto midConstOp =
+                midSubOp.getOperand(0).getDefiningOp<ConstantOp>()) {
+          // (c2 - something) - c1 == (c2 - c1) - something
+          auto nextConstant = rewriter.create<ConstantOp>(
+              subOp.getLoc(),
+              rewriter.getIntegerAttr(
+                  subOp.getType(),
+                  midConstOp.getValue().cast<IntegerAttr>().getValue() -
+                      origConstOp.getValue().cast<IntegerAttr>().getValue()));
+          rewriter.replaceOpWithNewOp<SubIOp>(subOp, nextConstant,
+                                              midSubOp.getOperand(1));
+          return success();
+        }
+        if (auto midConstOp =
+                midSubOp.getOperand(1).getDefiningOp<ConstantOp>()) {
+          // (something - c2) - c1 == something - (c2 + c1)
+          auto nextConstant = rewriter.create<ConstantOp>(
+              subOp.getLoc(),
+              rewriter.getIntegerAttr(
+                  subOp.getType(),
+                  origConstOp.getValue().cast<IntegerAttr>().getValue() +
+                      midConstOp.getValue().cast<IntegerAttr>().getValue()));
+          rewriter.replaceOpWithNewOp<SubIOp>(subOp, midSubOp.getOperand(0),
+                                              nextConstant);
+          return success();
+        }
+      }
+
+      if (auto midSubOp = subOp.getOperand(1).getDefiningOp<SubIOp>()) {
+        if (auto midConstOp =
+                midSubOp.getOperand(0).getDefiningOp<ConstantOp>()) {
+          // c1 - (c2 - something) == (c1 - c2) + something
+          auto nextConstant = rewriter.create<ConstantOp>(
+              subOp.getLoc(),
+              rewriter.getIntegerAttr(
+                  subOp.getType(),
+                  origConstOp.getValue().cast<IntegerAttr>().getValue() -
+                      midConstOp.getValue().cast<IntegerAttr>().getValue()));
+          rewriter.replaceOpWithNewOp<AddIOp>(subOp, nextConstant,
+                                              midSubOp.getOperand(1));
+          return success();
+        }
+        if (auto midConstOp =
+                midSubOp.getOperand(1).getDefiningOp<ConstantOp>()) {
+          // c1 - (something - c2) == (c1 - c2) - something
+          auto nextConstant = rewriter.create<ConstantOp>(
+              subOp.getLoc(),
+              rewriter.getIntegerAttr(
+                  subOp.getType(),
+                  origConstOp.getValue().cast<IntegerAttr>().getValue() -
+                      midConstOp.getValue().cast<IntegerAttr>().getValue()));
+          rewriter.replaceOpWithNewOp<SubIOp>(subOp, nextConstant,
+                                              midSubOp.getOperand(0));
+          return success();
+        }
+      }
+    }
+    return failure();
+  }
+};
+
+void SubIOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                         MLIRContext *context) {
+  results.insert<SubConstantReorder>(context);
+}
+
 //===----------------------------------------------------------------------===//
 // UIToFPOp
 //===----------------------------------------------------------------------===//
 
 // uitofp is applicable from integer types to float types.
 bool UIToFPOp::areCastCompatible(TypeRange inputs, TypeRange outputs) {
   if (inputs.size() != 1 || outputs.size() != 1)
     return false;

 
 OpFoldResult TruncateIOp::fold(ArrayRef<Attribute> operands) {
   // trunci(zexti(a)) -> a
   // trunci(sexti(a)) -> a
   if (matchPattern(getOperand(), m_Op<ZeroExtendIOp>()) ||
       matchPattern(getOperand(), m_Op<SignExtendIOp>()))
     return getOperand().getDefiningOp()->getOperand(0);
 
-  return nullptr;
+  assert(operands.size() == 1 && "unary operation takes one operand");
+
+  if (!operands[0])
+    return {};
+
+  if (operands[0].isa<IntegerAttr>()) {
+    auto lhs = operands[0].cast<IntegerAttr>();
+
+    return IntegerAttr::get(
+        getType(), lhs.getValue().trunc(getType().getIntOrFloatBitWidth()));
+  }
+
+  return {};
 }
 
 //===----------------------------------------------------------------------===//
 // UnsignedDivIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult UnsignedDivIOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "binary operation takes two operands");
OpFoldResult XOrOp::fold(ArrayRef<Attribute> operands) {
   /// xor(x,x) -> 0
   if (lhs() == rhs())
     return Builder(getContext()).getZeroAttr(getType());
 
   return constFoldBinaryOp<IntegerAttr>(operands,
                                         [](APInt a, APInt b) { return a ^ b; });
 }
 
+struct NotICmp : public OpRewritePattern<XOrOp> {
+  using OpRewritePattern<XOrOp>::OpRewritePattern;
+
+  LogicalResult matchAndRewrite(XOrOp op,
+                                PatternRewriter &rewriter) const override {
+    auto c1 = op.rhs().getDefiningOp<ConstantOp>();
+    if (!c1)
+      return failure();
+    if (c1.getValue().cast<IntegerAttr>().getValue() != 1)
+      return failure();
+    auto prev = op.lhs().getDefiningOp<CmpIOp>();
+    if (!prev)
+      return failure();
+    switch (prev.predicate()) {
+    case mlir::CmpIPredicate::eq:
+      rewriter.replaceOpWithNewOp<CmpIOp>(op, mlir::CmpIPredicate::ne,
+                                          prev.lhs(), prev.rhs());
+      return success();
+    case mlir::CmpIPredicate::ne:
+      rewriter.replaceOpWithNewOp<CmpIOp>(op, mlir::CmpIPredicate::eq,
+                                          prev.lhs(), prev.rhs());
+      return success();
+
+    case mlir::CmpIPredicate::slt:
+      rewriter.replaceOpWithNewOp<CmpIOp>(op, mlir::CmpIPredicate::sge,
+                                          prev.lhs(), prev.rhs());
+      return success();
+    case mlir::CmpIPredicate::sle:
+      rewriter.replaceOpWithNewOp<CmpIOp>(op, mlir::CmpIPredicate::sgt,
+                                          prev.lhs(), prev.rhs());
+      return success();
+    case mlir::CmpIPredicate::sgt:
+      rewriter.replaceOpWithNewOp<CmpIOp>(op, mlir::CmpIPredicate::sle,
+                                          prev.lhs(), prev.rhs());
+      return success();
+    case mlir::CmpIPredicate::sge:
+      rewriter.replaceOpWithNewOp<CmpIOp>(op, mlir::CmpIPredicate::slt,
+                                          prev.lhs(), prev.rhs());
+      return success();
+
+    case mlir::CmpIPredicate::ult:
+      rewriter.replaceOpWithNewOp<CmpIOp>(op, mlir::CmpIPredicate::uge,
+                                          prev.lhs(), prev.rhs());
+      return success();
+    case mlir::CmpIPredicate::ule:
+      rewriter.replaceOpWithNewOp<CmpIOp>(op, mlir::CmpIPredicate::ugt,
+                                          prev.lhs(), prev.rhs());
+      return success();
+    case mlir::CmpIPredicate::ugt:
+      rewriter.replaceOpWithNewOp<CmpIOp>(op, mlir::CmpIPredicate::ule,
+                                          prev.lhs(), prev.rhs());
+      return success();
+    case mlir::CmpIPredicate::uge:
+      rewriter.replaceOpWithNewOp<CmpIOp>(op, mlir::CmpIPredicate::ult,
+                                          prev.lhs(), prev.rhs());
+      return success();
+    }
+    return failure();
+  }
+};
+
+void XOrOp::getCanonicalizationPatterns(OwningRewritePatternList &results,
+                                        MLIRContext *context) {
+  results.insert<NotICmp>(context);
+}
+
 //===----------------------------------------------------------------------===//
 // ZeroExtendIOp
 //===----------------------------------------------------------------------===//
 
 static LogicalResult verify(ZeroExtendIOp op) {
   auto srcType = getElementTypeOrSelf(op.getOperand().getType());
   auto dstType = getElementTypeOrSelf(op.getType());
 

mlir/test/Conversion/StandardToLLVM/convert-to-llvmir.mlir

// CHECK-NEXT: = llvm.fptrunc {{.*}} : vector<2xf64> to vector<2xf16>
   %1 = fptrunc %arg1: vector<2xf64> to vector<2xf16>
 // CHECK-NEXT: = llvm.fptrunc {{.*}} : vector<2xf64> to vector<2xf32>
   %2 = fptrunc %arg1: vector<2xf64> to vector<2xf32>
   return
 }
 
 // Check sign and zero extension and truncation of integers.
 // CHECK-LABEL: @integer_extension_and_truncation
-func @integer_extension_and_truncation() {
-// CHECK-NEXT:  %0 = llvm.mlir.constant(-3 : i3) : i3
-  %0 = constant 5 : i3
-// CHECK-NEXT: = llvm.sext %0 : i3 to i6
-  %1 = sexti %0 : i3 to i6
-// CHECK-NEXT: = llvm.zext %0 : i3 to i6
-  %2 = zexti %0 : i3 to i6
-// CHECK-NEXT: = llvm.trunc %0 : i3 to i2
-   %3 = trunci %0 : i3 to i2
+func @integer_extension_and_truncation(%arg0 : i3) {
+// CHECK-NEXT: = llvm.sext %arg0 : i3 to i6
+  %0 = sexti %arg0 : i3 to i6
+// CHECK-NEXT: = llvm.zext %arg0 : i3 to i6
+  %1 = zexti %arg0 : i3 to i6
+// CHECK-NEXT: = llvm.trunc %arg0 : i3 to i2
+   %2 = trunci %arg0 : i3 to i2
   return
 }
 
 // CHECK-LABEL: @dfs_block_order
 func @dfs_block_order(%arg0: i32) -> (i32) {
 // CHECK-NEXT:  %[[CST:.*]] = llvm.mlir.constant(42 : i32) : i32
   %0 = constant 42 : i32
 // CHECK-NEXT:  llvm.br ^bb2

mlir/test/Dialect/Standard/canonicalize.mlir

 
 // CHECK-LABEL: @select_cmp_ne_select
 //       CHECK:   return %arg0
 func @select_cmp_ne_select(%arg0: i64, %arg1: i64) -> i64 {
   %0 = cmpi ne, %arg0, %arg1 : i64
   %1 = select %0, %arg0, %arg1 : i64
   return %1 : i64
 }
+
+
+// -----
+
+// CHECK-LABEL: @tripleAddAdd
+//       CHECK:   %[[cres:.+]] = constant 59 : index 
+//       CHECK:   %[[add:.+]] = addi %arg0, %[[cres]] : index 
+//       CHECK:   return %[[add]]
+func @tripleAddAdd(%arg0: index) -> index {
+  %c17 = constant 17 : index
+  %c42 = constant 42 : index
+  %add1 = addi %c17, %arg0 : index
+  %add2 = addi %c42, %add1 : index
+  return %add2 : index
+}
+
+// CHECK-LABEL: @tripleAddSub0
+//       CHECK:   %[[cres:.+]] = constant 59 : index 
+//       CHECK:   %[[add:.+]] = subi %[[cres]], %arg0 : index 
+//       CHECK:   return %[[add]]
+func @tripleAddSub0(%arg0: index) -> index {
+  %c17 = constant 17 : index
+  %c42 = constant 42 : index
+  %add1 = subi %c17, %arg0 : index
+  %add2 = addi %c42, %add1 : index
+  return %add2 : index
+}
+
+// CHECK-LABEL: @tripleAddSub1
+//       CHECK:   %[[cres:.+]] = constant 25 : index 
+//       CHECK:   %[[add:.+]] = addi %arg0, %[[cres]] : index 
+//       CHECK:   return %[[add]]
+func @tripleAddSub1(%arg0: index) -> index {
+  %c17 = constant 17 : index
+  %c42 = constant 42 : index
+  %add1 = subi %arg0, %c17 : index
+  %add2 = addi %c42, %add1 : index
+  return %add2 : index
+}
+
+// CHECK-LABEL: @tripleSubAdd0
+//       CHECK:   %[[cres:.+]] = constant 25 : index 
+//       CHECK:   %[[add:.+]] = subi %[[cres]], %arg0 : index 
+//       CHECK:   return %[[add]]
+func @tripleSubAdd0(%arg0: index) -> index {
+  %c17 = constant 17 : index
+  %c42 = constant 42 : index
+  %add1 = addi %c17, %arg0 : index
+  %add2 = subi %c42, %add1 : index
+  return %add2 : index
+}
+
+// CHECK-LABEL: @tripleSubAdd1
+//       CHECK:   %[[cres:.+]] = constant -25 : index 
+//       CHECK:   %[[add:.+]] = addi %arg0, %[[cres]] : index 
+//       CHECK:   return %[[add]]
+func @tripleSubAdd1(%arg0: index) -> index {
+  %c17 = constant 17 : index
+  %c42 = constant 42 : index
+  %add1 = addi %c17, %arg0 : index
+  %add2 = subi %add1, %c42 : index
+  return %add2 : index
+}
+
+// CHECK-LABEL: @tripleSubSub0
+//       CHECK:   %[[cres:.+]] = constant 25 : index 
+//       CHECK:   %[[add:.+]] = addi %arg0, %[[cres]] : index 
+//       CHECK:   return %[[add]]
+func @tripleSubSub0(%arg0: index) -> index {
+  %c17 = constant 17 : index
+  %c42 = constant 42 : index
+  %add1 = subi %c17, %arg0 : index
+  %add2 = subi %c42, %add1 : index
+  return %add2 : index
+}
+
+// CHECK-LABEL: @tripleSubSub1
+//       CHECK:   %[[cres:.+]] = constant -25 : index 
+//       CHECK:   %[[add:.+]] = subi %[[cres]], %arg0 : index 
+//       CHECK:   return %[[add]]
+func @tripleSubSub1(%arg0: index) -> index {
+  %c17 = constant 17 : index
+  %c42 = constant 42 : index
+  %add1 = subi %c17, %arg0 : index
+  %add2 = subi %add1, %c42 : index
+  return %add2 : index
+}
+
+// CHECK-LABEL: @tripleSubSub2
+//       CHECK:   %[[cres:.+]] = constant 59 : index 
+//       CHECK:   %[[add:.+]] = subi %[[cres]], %arg0 : index 
+//       CHECK:   return %[[add]]
+func @tripleSubSub2(%arg0: index) -> index {
+  %c17 = constant 17 : index
+  %c42 = constant 42 : index
+  %add1 = subi %arg0, %c17 : index
+  %add2 = subi %c42, %add1 : index
+  return %add2 : index
+}
+
+// CHECK-LABEL: @tripleSubSub3
+//       CHECK:   %[[cres:.+]] = constant 59 : index 
+//       CHECK:   %[[add:.+]] = subi %arg0, %[[cres]] : index 
+//       CHECK:   return %[[add]]
+func @tripleSubSub3(%arg0: index) -> index {
+  %c17 = constant 17 : index
+  %c42 = constant 42 : index
+  %add1 = subi %arg0, %c17 : index
+  %add2 = subi %add1, %c42 : index
+  return %add2 : index
+}
+
+// -----
+
+// CHECK-LABEL: @branchCondProp
+//       CHECK:       %true = constant true
+//       CHECK:       %false = constant false
+//       CHECK:       cond_br %arg0, ^bb1, ^bb2
+//       CHECK:     ^bb1:  // pred: ^bb0
+//       CHECK:       "test.consumer1"(%true) : (i1) -> ()
+//       CHECK:       br ^bb3
+//       CHECK:     ^bb2:  // pred: ^bb0
+//       CHECK:       "test.consumer2"(%false) : (i1) -> ()
+//       CHECK:       br ^bb3
+//       CHECK:     ^bb3:  // 2 preds: ^bb1, ^bb2
+//       CHECK:       return
+func @branchCondProp(%arg0: i1) {
+  cond_br %arg0, ^trueB, ^falseB
+
+^trueB:
+  "test.consumer1"(%arg0) : (i1) -> ()
+  br ^exit  
+
+^falseB:
+  "test.consumer2"(%arg0) : (i1) -> ()
+  br ^exit
+
+^exit:
+  return
+}
+
+// -----
+
+// CHECK-LABEL: @indexCastOfSignExtend
+//       CHECK:   %[[res:.+]] = index_cast %arg0 : i8 to index
+//       CHECK:   return %[[res]]
+func @indexCastOfSignExtend(%arg0: i8) -> index {
+  %ext = sexti %arg0 : i8 to i16
+  %idx = index_cast %ext : i16 to index
+  return %idx : index
+}
+
+// CHECK-LABEL: @signExtendConstant
+//       CHECK:   %[[cres:.+]] = constant -2 : i16
+//       CHECK:   return %[[cres]]
+func @signExtendConstant(%arg0: i8) -> i16 {
+  %c-2 = constant -2 : i8
+  %ext = sexti %c-2 : i8 to i16
+  return %ext : i16
+}
+
+// -----
+
+// CHECK-LABEL: @notCmp
+//       CHECK:   %[[cres:.+]] = cmpi ne, %arg0, %arg1 : i8
+//       CHECK:   return %[[cres]]
+func @notCmp(%arg0: i8, %arg1: i8) -> i1 {
+  %true = constant true
+  %cmp = cmpi "eq", %arg0, %arg1 : i8
+  %ncmp = xor %cmp, %true : i1
+  return %ncmp : i1
+}
 No newline at end of file