[mlir][arith] Clean up arith canonicalization td rules

[kuhar]

Summary

• Use ConstantLikeMatcher instead of matching Arith_ConstantOp
• Reflow some defs to fit the line limit

Suggested by @jpienaar and @Mogball in https://reviews.llvm.org/D139778.

mlir/lib/Dialect/Arith/IR/ArithCanonicalization.td

 //===----------------------------------------------------------------------===//
 
 // addi is commutative and will be canonicalized to have its constants appear
 // as the second operand.
 
 // addi(addi(x, c0), c1) -> addi(x, c0 + c1)
 def AddIAddConstant :
     Pat<(Arith_AddIOp:$res
-          (Arith_AddIOp $x, (Arith_ConstantOp APIntAttr:$c0)),
-          (Arith_ConstantOp APIntAttr:$c1)),
+          (Arith_AddIOp $x, (ConstantLikeMatcher APIntAttr:$c0)),
+          (ConstantLikeMatcher APIntAttr:$c1)),
         (Arith_AddIOp $x, (Arith_ConstantOp (AddIntAttrs $res, $c0, $c1)))>;
 
 // addi(subi(x, c0), c1) -> addi(x, c1 - c0)
 def AddISubConstantRHS :
     Pat<(Arith_AddIOp:$res
-          (Arith_SubIOp $x, (Arith_ConstantOp APIntAttr:$c0)),
-          (Arith_ConstantOp APIntAttr:$c1)),
+          (Arith_SubIOp $x, (ConstantLikeMatcher APIntAttr:$c0)),
+          (ConstantLikeMatcher APIntAttr:$c1)),
         (Arith_AddIOp $x, (Arith_ConstantOp (SubIntAttrs $res, $c1, $c0)))>;
 
 // addi(subi(c0, x), c1) -> subi(c0 + c1, x)
 def AddISubConstantLHS :
     Pat<(Arith_AddIOp:$res
-          (Arith_SubIOp (Arith_ConstantOp APIntAttr:$c0), $x),
-          (Arith_ConstantOp APIntAttr:$c1)),
+          (Arith_SubIOp (ConstantLikeMatcher APIntAttr:$c0), $x),
+          (ConstantLikeMatcher APIntAttr:$c1)),
         (Arith_SubIOp (Arith_ConstantOp (AddIntAttrs $res, $c0, $c1)), $x)>;
 
 //===----------------------------------------------------------------------===//
 // AddUIExtendedOp
 //===----------------------------------------------------------------------===//
 
 // addui_extended(x, y) -> [addi(x, y), x], when the `overflow` result has no
 // uses. Since the 'overflow' result is unused, any replacement value will do.
 def AddUIExtendedToAddI:
     Pattern<(Arith_AddUIExtendedOp:$res $x, $y),
              [(Arith_AddIOp $x, $y), (replaceWithValue $x)],
              [(Constraint<CPred<"$0.getUses().empty()">> $res__1)]>;
 
 //===----------------------------------------------------------------------===//
 // SubIOp
 //===----------------------------------------------------------------------===//
 
 // subi(addi(x, c0), c1) -> addi(x, c0 - c1)
 def SubIRHSAddConstant :
     Pat<(Arith_SubIOp:$res
-          (Arith_AddIOp $x, (Arith_ConstantOp APIntAttr:$c0)),
-          (Arith_ConstantOp APIntAttr:$c1)),
+          (Arith_AddIOp $x, (ConstantLikeMatcher APIntAttr:$c0)),
+          (ConstantLikeMatcher APIntAttr:$c1)),
         (Arith_AddIOp $x, (Arith_ConstantOp (SubIntAttrs $res, $c0, $c1)))>;
 
 // subi(c1, addi(x, c0)) -> subi(c1 - c0, x)
 def SubILHSAddConstant :
     Pat<(Arith_SubIOp:$res
-          (Arith_ConstantOp APIntAttr:$c1),
-          (Arith_AddIOp $x, (Arith_ConstantOp APIntAttr:$c0))),
+          (ConstantLikeMatcher APIntAttr:$c1),
+          (Arith_AddIOp $x, (ConstantLikeMatcher APIntAttr:$c0))),
         (Arith_SubIOp (Arith_ConstantOp (SubIntAttrs $res, $c1, $c0)), $x)>;
 
 // subi(subi(x, c0), c1) -> subi(x, c0 + c1)
 def SubIRHSSubConstantRHS :
     Pat<(Arith_SubIOp:$res
-          (Arith_SubIOp $x, (Arith_ConstantOp APIntAttr:$c0)),
-          (Arith_ConstantOp APIntAttr:$c1)),
+          (Arith_SubIOp $x, (ConstantLikeMatcher APIntAttr:$c0)),
+          (ConstantLikeMatcher APIntAttr:$c1)),
         (Arith_SubIOp $x, (Arith_ConstantOp (AddIntAttrs $res, $c0, $c1)))>;
 
 // subi(subi(c0, x), c1) -> subi(c0 - c1, x)
 def SubIRHSSubConstantLHS :
     Pat<(Arith_SubIOp:$res
-          (Arith_SubIOp (Arith_ConstantOp APIntAttr:$c0), $x),
-          (Arith_ConstantOp APIntAttr:$c1)),
+          (Arith_SubIOp (ConstantLikeMatcher APIntAttr:$c0), $x),
+          (ConstantLikeMatcher APIntAttr:$c1)),
         (Arith_SubIOp (Arith_ConstantOp (SubIntAttrs $res, $c0, $c1)), $x)>;
 
 // subi(c1, subi(x, c0)) -> subi(c0 + c1, x)
 def SubILHSSubConstantRHS :
     Pat<(Arith_SubIOp:$res
-          (Arith_ConstantOp APIntAttr:$c1),
-          (Arith_SubIOp $x, (Arith_ConstantOp APIntAttr:$c0))),
+          (ConstantLikeMatcher APIntAttr:$c1),
+          (Arith_SubIOp $x, (ConstantLikeMatcher APIntAttr:$c0))),
         (Arith_SubIOp (Arith_ConstantOp (AddIntAttrs $res, $c0, $c1)), $x)>;
 
 // subi(c1, subi(c0, x)) -> addi(x, c1 - c0)
 def SubILHSSubConstantLHS :
     Pat<(Arith_SubIOp:$res
-          (Arith_ConstantOp APIntAttr:$c1),
-          (Arith_SubIOp (Arith_ConstantOp APIntAttr:$c0), $x)),
+          (ConstantLikeMatcher APIntAttr:$c1),
+          (Arith_SubIOp (ConstantLikeMatcher APIntAttr:$c0), $x)),
         (Arith_AddIOp $x, (Arith_ConstantOp (SubIntAttrs $res, $c1, $c0)))>;
 
 // subi(subi(a, b), a) -> subi(0, b)
 def SubISubILHSRHSLHS :
     Pat<(Arith_SubIOp:$res (Arith_SubIOp $x, $y), $x),
         (Arith_SubIOp (Arith_ConstantOp (GetZeroAttr $y)), $y)>;
 
 //===----------------------------------------------------------------------===//

 // xori is commutative and will be canonicalized to have its constants appear
 // as the second operand.
 
 // not(cmpi(pred, a, b)) -> cmpi(~pred, a, b), where not(x) is xori(x, 1)
 def InvertPredicate : NativeCodeCall<"invertPredicate($0)">;
 def XOrINotCmpI :
     Pat<(Arith_XOrIOp
           (Arith_CmpIOp $pred, $a, $b),
-          (Arith_ConstantOp ConstantAttr<I1Attr, "1">)),
+          (ConstantLikeMatcher ConstantAttr<I1Attr, "1">)),
         (Arith_CmpIOp (InvertPredicate $pred), $a, $b)>;
 
 //===----------------------------------------------------------------------===//
 // CmpIOp
 //===----------------------------------------------------------------------===//
 
 // cmpi(== or !=, a ext iNN, b ext iNN) == cmpi(== or !=, a, b)
 def CmpIExtSI :
     Pat<(Arith_CmpIOp $pred,
           (Arith_ExtSIOp $a),
           (Arith_ExtSIOp $b)),
         (Arith_CmpIOp $pred, $a, $b),
         [(Constraint<CPred<"$0.getType() == $1.getType()">> $a, $b),
-         (Constraint<CPred<"$0.getValue() == arith::CmpIPredicate::eq || $0.getValue() == arith::CmpIPredicate::ne">> $pred)]>;
+         (Constraint<
+            CPred<"$0.getValue() == arith::CmpIPredicate::eq || "
+                  "$0.getValue() == arith::CmpIPredicate::ne">> $pred)]>;
 
 // cmpi(== or !=, a ext iNN, b ext iNN) == cmpi(== or !=, a, b)
 def CmpIExtUI :
     Pat<(Arith_CmpIOp $pred,
           (Arith_ExtUIOp $a),
           (Arith_ExtUIOp $b)),
         (Arith_CmpIOp $pred, $a, $b),
         [(Constraint<CPred<"$0.getType() == $1.getType()">> $a, $b),
-         (Constraint<CPred<"$0.getValue() == arith::CmpIPredicate::eq || $0.getValue() == arith::CmpIPredicate::ne">> $pred)]>;
+         (Constraint<
+            CPred<"$0.getValue() == arith::CmpIPredicate::eq || "
+                  "$0.getValue() == arith::CmpIPredicate::ne">> $pred)]>;
 
 //===----------------------------------------------------------------------===//
 // IndexCastOp
 //===----------------------------------------------------------------------===//
 
 // index_cast(index_cast(x)) -> x, if dstType == srcType.
 def IndexCastOfIndexCast :
     Pat<(Arith_IndexCastOp:$res (Arith_IndexCastOp $x)),
def ExtSIOfExtUI :
     Pat<(Arith_ExtSIOp (Arith_ExtUIOp $x)), (Arith_ExtUIOp $x)>;
 
 //===----------------------------------------------------------------------===//
 // AndIOp
 //===----------------------------------------------------------------------===//
 
 // and extui(x), extui(y) -> extui(and(x,y))
 def AndOfExtUI :
-    Pat<(Arith_AndIOp (Arith_ExtUIOp $x), (Arith_ExtUIOp $y)), (Arith_ExtUIOp (Arith_AndIOp $x, $y)),
+    Pat<(Arith_AndIOp (Arith_ExtUIOp $x), (Arith_ExtUIOp $y)),
+        (Arith_ExtUIOp (Arith_AndIOp $x, $y)),
         [(Constraint<CPred<"$0.getType() == $1.getType()">> $x, $y)]>;
 
 // and extsi(x), extsi(y) -> extsi(and(x,y))
 def AndOfExtSI :
-    Pat<(Arith_AndIOp (Arith_ExtSIOp $x), (Arith_ExtSIOp $y)), (Arith_ExtSIOp (Arith_AndIOp $x, $y)),
+    Pat<(Arith_AndIOp (Arith_ExtSIOp $x), (Arith_ExtSIOp $y)),
+        (Arith_ExtSIOp (Arith_AndIOp $x, $y)),
         [(Constraint<CPred<"$0.getType() == $1.getType()">> $x, $y)]>;
 
 //===----------------------------------------------------------------------===//
 // OrIOp
 //===----------------------------------------------------------------------===//
 
 // or extui(x), extui(y) -> extui(or(x,y))
 def OrOfExtUI :
-    Pat<(Arith_OrIOp (Arith_ExtUIOp $x), (Arith_ExtUIOp $y)), (Arith_ExtUIOp (Arith_OrIOp $x, $y)),
+    Pat<(Arith_OrIOp (Arith_ExtUIOp $x), (Arith_ExtUIOp $y)),
+        (Arith_ExtUIOp (Arith_OrIOp $x, $y)),
         [(Constraint<CPred<"$0.getType() == $1.getType()">> $x, $y)]>;
 
 // or extsi(x), extsi(y) -> extsi(or(x,y))
 def OrOfExtSI :
-    Pat<(Arith_OrIOp (Arith_ExtSIOp $x), (Arith_ExtSIOp $y)), (Arith_ExtSIOp (Arith_OrIOp $x, $y)),
+    Pat<(Arith_OrIOp (Arith_ExtSIOp $x), (Arith_ExtSIOp $y)),
+        (Arith_ExtSIOp (Arith_OrIOp $x, $y)),
         [(Constraint<CPred<"$0.getType() == $1.getType()">> $x, $y)]>;
 
 //===----------------------------------------------------------------------===//
 // MulFOp
 //===----------------------------------------------------------------------===//
 
 // mulf(negf(x), negf(y)) -> mulf(x,y)
 // (retain fastmath flags of original mulf)
 def MulFOfNegF :