[MLIR] Split arith dialect from the std dialect

[Mogball]

Summary

Create the Arithmetic dialect that contains basic integer and floating
point arithmetic operations. Ops that did not meet this criterion were
moved to the Math dialect.

First of two atomic patches to remove integer and floating point
operations from the standard dialect. Ops will be removed from the
standard dialect in a subsequent patch.

[Mogball]

• fixing build on CMake

[Mogball]

• clang-tidy errors

[bondhugula]

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticBase.td

19

ternery -> ternary

[ftynse]

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticBase.td

25–71

Does it make sense to expose this in user-visible documentation? These are ODS classes and they don't have C++ equivalents AFAIK, so I'd just keep this diagram as comment in the .td file for whoever needs to modify it and avoid having it rendered on mlir.llvm.org.

[nicolasvasilache]

How about moving index -> index ops like arith.affine_apply,
arith.affine_min and arith.affing_max in here too ?
Not in this CL, I am checking the temperature on the idea as it will
simplify the layering of a bunch of stuff.

[mehdi_amini]

In D110200#3014509, @nicolasvasilache wrote:

How about moving index -> index ops like arith.affine_apply,
arith.affine_min and arith.affing_max in here too ?
Not in this CL, I am checking the temperature on the idea as it will
simplify the layering of a bunch of stuff.

Aren't these very "affine" related (as their name indicates)? The fit isn't clear to me here.
I'm interested in understanding the layering aspect though!

[silvas]

did a pass. looks good to me. probably want to wait for a handful of LGTM's given the far-reaching consequences of this change. Ideally both River and Chris could weigh in.

[nicolasvasilache]

Aren't these very "affine" related (as their name indicates)? The fit isn't clear to me here.
I'm interested in understanding the layering aspect though!

They are more generally applied to ops across multiple dialects (e.g. memref and tensor)
They are similar to AffineExpr and AffineMap in that respect.

IIRC layering issues involve properties such as AffineScope type constraints depending on memref/tensor (because of DimOp) which in turn makes it a circular dependence when trying to write logic based on affine.apply/min/max in memref or tensor.

[ftynse]

Scanned through, looks good to me.

[bondhugula]

mlir/include/mlir/Dialect/Arithmetic/IR/Arithmetic.h

40–52

Shouldn't this be in the mlir::arith namespace?

[bondhugula]

mlir/lib/Dialect/Arithmetic/IR/ArithmeticCanonicalization.td

13 ↗

(On Diff #374065)

ArithOps td defs depend on StandardOps? Can we pull what's need from there or move to OpBase.td?

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

11

Likewise. (ArithOps depends on StandardOps?)

[Mogball]

mlir/lib/Dialect/Arithmetic/IR/ArithmeticCanonicalization.td

13 ↗

(On Diff #374065)

The only dependency is ConstantOp. As it turns out, I will need to create arith.const after all, because otherwise std and arith will have a circular dependency...

[rriddle]

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticBase.td

25–71

+1.

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.td

146–151

These syntax blocks aren't as useful if the op uses the assemblyFormat field, given that the assembly format will be added to the op documentation. I'd just drop them.

mlir/lib/Dialect/Arithmetic/IR/ArithmeticCanonicalization.td

13 ↗

(On Diff #374065)

Yeah, I would suggest avoiding a dependency on standard as much as you possibly can.

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

27–36

Only classes should really be in anonymous namespaces, functions should be marked static and at the top level,

[Mogball]

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.td

146–151

Sounds good. Should I drop/trim some of the really verbose comments too? E.g. "This op requires three operands and one result which must be of the same type. This type can be an integer, a vector whose element type is integer, or a tensor of integers. The custom assembly format of these ops is: ..." etc.

I copied them from Ops.td.

[rriddle]

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.td

146–151

I'd be fine with dropping anything that is superfluous/a duplication of the documentation that is auto-generated. A lot of this documentation is ancient and predates many automation efforts.

[Mogball]

• fixing build on CMake
• clang-tidy errors
• Fix comments, static functions
• add arith.const op

[Mogball]

Fix diff

[Mogball]

• add arith.const op

[Mogball]

Arcanist is a struggle for me... but I now have the correct diffs shown.

[bondhugula]

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.td

121

We've so far had llvm.constant, std.constant, mhlo.constant, etc. Prefer naming this constant instead of const for consistency. The op is creating a constant.

128

Nit: floating-point constant

128–129

Nit: uses to form -> forms

[Mogball]

rename arith.const -> arith.constant

[c-rhodes]

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.td

95–103

should traits be passed to Arith_CastOp? I noticed some unused warnings for this parameter when providing an update on D109359.

[Mogball]

Arcanist is a struggle for me... but I now have the correct diffs shown.

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.td

95–103

Yes, it should. Thanks for catching this. Submitting a fix right now.

mlir/include/mlir/Dialect/Arithmetic/IR/Arithmetic.h

 
 #define GET_OP_CLASSES
 #include "mlir/Dialect/Arithmetic/IR/ArithmeticOps.h.inc"
 
 //===----------------------------------------------------------------------===//
 // Utility Functions
 //===----------------------------------------------------------------------===//
 
 namespace mlir {
+namespace arith {
 
 /// Compute `lhs` `pred` `rhs`, where `pred` is one of the known integer
 /// comparison predicates.
 bool applyCmpPredicate(arith::CmpIPredicate predicate, const APInt &lhs,
                        const APInt &rhs);
 
 /// Compute `lhs` `pred` `rhs`, where `pred` is one of the known floating point
 /// comparison predicates.
 bool applyCmpPredicate(arith::CmpFPredicate predicate, const APFloat &lhs,
                        const APFloat &rhs);
 
+} // end namespace arith
 } // end namespace mlir
 
 #endif // MLIR_DIALECT_ARITHMETIC_IR_ARITHMETIC_H_

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticBase.td

 
 include "mlir/IR/OpBase.td"
 
 def Arithmetic_Dialect : Dialect {
   let name = "arith";
   let cppNamespace = "::mlir::arith";
   let description = [{
     The arithmetic dialect is intended to hold basic integer and floating point
-    mathematical operations. This includes unary, binary, and ternery arithmetic
+    mathematical operations. This includes unary, binary, and ternary arithmetic
     ops, bitwise and shift ops, cast ops, and compare ops. Operations in this
     dialect also accept vectors and tensors of integers or floats.
-
-    Operation index:
-
-    ```
-    ArithmeticOp
-    |
-    |-> IntBinaryOp
-    |     addi
-    |     subi
-    |     muli
-    |     divui
-    |     divsi
-    |     ceildivsi
-    |     floordivsi
-    |     remui
-    |     remsi
-    |     andi
-    |     ori
-    |     xori
-    |     shli
-    |     shrui
-    |     shrsi
-    |
-    |-> FloatUnaryOp
-    |     negf
-    |
-    \-> FloatBinaryOp
-          addf
-          subf
-          mulf
-          divf
-          remf
-
-    ArithmeticCastOp
-      extui
-      extsi
-      extf
-      trunci
-      truncf
-      uitofp
-      sitofp
-      fptoui
-      fptosi
-      index_cast
-      bitcast
-
-    ArithmeticCompareOp
-      cmpi
-      cmpf
-    ```
   }];
 }
 
 // The predicate indicates the type of the comparison to perform:
 // (un)orderedness, (in)equality and less/greater than (or equal to) as
 // well as predicates that are always true or false.
 def Arith_CmpFPredicateAttr : I64EnumAttr<
     "CmpFPredicate", "",
     [
       I64EnumAttrCase<"AlwaysFalse", 0, "false">,
       I64EnumAttrCase<"OEQ", 1, "oeq">,
       I64EnumAttrCase<"OGT", 2, "ogt">,
       I64EnumAttrCase<"OGE", 3, "oge">,
       I64EnumAttrCase<"OLT", 4, "olt">,
       I64EnumAttrCase<"OLE", 5, "ole">,
       I64EnumAttrCase<"ONE", 6, "one">,
       I64EnumAttrCase<"ORD", 7, "ord">,
       I64EnumAttrCase<"UEQ", 8, "ueq">,
       I64EnumAttrCase<"UGT", 9, "ugt">,
       I64EnumAttrCase<"UGE", 10, "uge">,
       I64EnumAttrCase<"ULT", 11, "ult">,
       I64EnumAttrCase<"ULE", 12, "ule">,
       I64EnumAttrCase<"UNE", 13, "une">,
       I64EnumAttrCase<"UNO", 14, "uno">,
       I64EnumAttrCase<"AlwaysTrue", 15, "true">,
     ]> {
   let cppNamespace = "::mlir::arith";
 }
 
 def Arith_CmpIPredicateAttr : I64EnumAttr<
     "CmpIPredicate", "",
     [
       I64EnumAttrCase<"eq", 0>,
       I64EnumAttrCase<"ne", 1>,
       I64EnumAttrCase<"slt", 2>,
       I64EnumAttrCase<"sle", 3>,
       I64EnumAttrCase<"sgt", 4>,
       I64EnumAttrCase<"sge", 5>,
       I64EnumAttrCase<"ult", 6>,
       I64EnumAttrCase<"ule", 7>,
       I64EnumAttrCase<"ugt", 8>,
       I64EnumAttrCase<"uge", 9>,
     ]> {
   let cppNamespace = "::mlir::arith";
 }
 
 #endif // ARITHMETIC_BASE

mlir/include/mlir/Dialect/Arithmetic/IR/ArithmeticOps.td

 
 // Base class for Arithmetic dialect ops. Ops in this dialect have no side
 // effects and can be applied element-wise to vectors and tensors.
 class Arith_Op<string mnemonic, list<OpTrait> traits = []> :
     Op<Arithmetic_Dialect, mnemonic, traits # [NoSideEffect,
     DeclareOpInterfaceMethods<VectorUnrollOpInterface>] #
     ElementwiseMappable.traits>;
 
-// Base class for integer and floating point arithmetic ops. Has one result.
-// Requires operands and result to be of the same type.
+// Base class for integer and floating point arithmetic ops. All ops have one
+// result, require operands and results to be of the same type, and can accept
+// tensors or vectors of integers or floats.
 class Arith_ArithmeticOp<string mnemonic, list<OpTrait> traits = []> :
     Arith_Op<mnemonic, traits # [SameOperandsAndResultType]>;
 
-// Base class for unary arithmetic operations, which have one operand.
+// Base class for unary arithmetic operations.
 class Arith_UnaryOp<string mnemonic, list<OpTrait> traits = []> :
     Arith_ArithmeticOp<mnemonic, traits> {
   let assemblyFormat = "$operand attr-dict `:` type($result)";
 }
 
-// Base class for binary arithmetic operations, which have two operands.
+// Base class for binary arithmetic operations.
 class Arith_BinaryOp<string mnemonic, list<OpTrait> traits = []> :
     Arith_ArithmeticOp<mnemonic, traits> {
   let assemblyFormat = "$lhs `,` $rhs attr-dict `:` type($result)";
 }
 
-// Base class for ternary arithmetic operations, which have three operands.
+// Base class for ternary arithmetic operations.
 class Arith_TernaryOp<string mnemonic, list<OpTrait> traits = []> :
     Arith_ArithmeticOp<mnemonic, traits> {
   let assemblyFormat = "$a `,` $b `,` $c attr-dict `:` type($result)";
 }
 
-// Base class for integer arithmetic operations. These operations accept two
-// operands and return one result of the same type. This type may be an integer
-// scalar type, a vector whose element type is an integer type, or an integer
-// tensor. The custom assembly format of these operations is:
-//
-//     <op>i %0, %1 : i32
-//
+// Base class for integer binary operations.
 class Arith_IntBinaryOp<string mnemonic, list<OpTrait> traits = []> :
     Arith_BinaryOp<mnemonic, traits>,
     Arguments<(ins SignlessIntegerLike:$lhs, SignlessIntegerLike:$rhs)>,
     Results<(outs SignlessIntegerLike:$result)>;
 
-// Base class for float point unary operations. These operations accept one
-// operand and return one result of the same type. This type may be a floating
-// point scalar type, a vector whose element type is a floating point type, or a
-// floating point tensor. The custom assembly form of these operations is:
-//
-//     <op>f %0 : f32
-//
+// Base class for floating point unary operations.
 class Arith_FloatUnaryOp<string mnemonic, list<OpTrait> traits = []> :
     Arith_UnaryOp<mnemonic, traits>,
     Arguments<(ins FloatLike:$operand)>,
     Results<(outs FloatLike:$result)>;
 
-// Base class for floating point binary operations. These operations accept two
-// operands and return one result of the same type. This type may be a floating
-// point scalar type, a vector whose element type is a floating point type, or a
-// floating point tensor. The custom asesmbly form of these operations is:
-//
-//     <op>f %0, %1 : f32
-//
+// Base class for floating point binary operations.
 class Arith_FloatBinaryOp<string mnemonic, list<OpTrait> traits = []> :
     Arith_BinaryOp<mnemonic, traits>,
     Arguments<(ins FloatLike:$lhs, FloatLike:$rhs)>,
     Results<(outs FloatLike:$result)>;
 
-// Base class for arithmetic cast operations. Requires a single operand and a
-// single result, but does not constrain them to any specific types. If either
-// operand or result is a vector or tensor of types, the other must be one of
-// the same shape. The custom assembly format of these operations is:
-//
-//     <op> %0 : <type1> to <type2>
-//
+// Base class for arithmetic cast operations. Requires a single operand and
+// result. If either is a shaped type, then the other must be of the same shape.
 class Arith_CastOp<string mnemonic, TypeConstraint From, TypeConstraint To,
                    list<OpTrait> traits = []> :
     Arith_Op<mnemonic, traits # [SameOperandsAndResultShape,
     DeclareOpInterfaceMethods<CastOpInterface>]>,
     Arguments<(ins From:$in)>,
     Results<(outs To:$out)> {
   let builders = [
     OpBuilder<(ins "Value":$source, "Type":$destType), [{
def SignlessFixedWidthIntegerLike : TypeConstraint<Or<[
         VectorOf<[AnySignlessInteger]>.predicate,
         TensorOf<[AnySignlessInteger]>.predicate]>,
     "signless-fixed-width-integer-like">;
 
 // Cast from an integer type to another integer type.
 class Arith_IToICastOp<string mnemonic, list<OpTrait> traits = []> :
     Arith_CastOp<mnemonic, SignlessFixedWidthIntegerLike,
                            SignlessFixedWidthIntegerLike>;
 // Cast from an integer type to a floating point type.
 class Arith_IToFCastOp<string mnemonic, list<OpTrait> traits = []> :
     Arith_CastOp<mnemonic, SignlessFixedWidthIntegerLike, FloatLike>;
 // Cast from a floating point type to an integer type.
 class Arith_FToICastOp<string mnemonic, list<OpTrait> traits = []> :
     Arith_CastOp<mnemonic, FloatLike, SignlessFixedWidthIntegerLike>;
 // Cast from a floating point type to another floating point type.
 class Arith_FToFCastOp<string mnemonic, list<OpTrait> traits = []> :
     Arith_CastOp<mnemonic, FloatLike, FloatLike>;
 
 // Base class for compare operations. Requires two operands of the same type
 // and returns a single `BoolLike` result. If the operand type is a vector or
 // tensor, then the result will be one of `i1` of the same shape.
 class Arith_CompareOp<string mnemonic, list<OpTrait> traits = []> :
     Arith_Op<mnemonic, traits # [SameTypeOperands, TypesMatchWith<
     "result type has i1 element type and same shape as operands",
     "lhs", "result", "::getI1SameShape($_self)">]> {
   let results = (outs BoolLike:$result);
 
   let assemblyFormat = "$predicate `,` $lhs `,` $rhs attr-dict `:` type($lhs)";
 }
 
 //===----------------------------------------------------------------------===//
-// AddIOp
+// ConstantOp
 //===----------------------------------------------------------------------===//
 
-def Arith_AddIOp : Arith_IntBinaryOp<"addi", [Commutative]> {
-  let summary = "integer addition operation";
+def Arith_ConstantOp : Op<Arithmetic_Dialect, "const",
+    [ConstantLike, NoSideEffect, TypesMatchWith<
+    "result type has same type as the attribute value",
+    "value", "result", "$_self">]> {
+  let summary = "integer or floating point constant";
   let description = [{
     Syntax:
 
     ```
-    operation ::= ssa-id `=` `arith.addi` ssa-use `,` ssa-use `:` type
+    operation ::= ssa-id `=` `arith.const` attribute-value `:` type
     ```
 
+    The `const` operation produces an SSA value equal to some integer or
+    floating point constant specified by an attribute. This is the way MLIR uses
+    to form simple integer and floating point constants.
+
+    Example:
+
+    ```
+    // Integer constant
+    %1 = constant 42 : i32
+
+    // Equivalent generic form
+    %1 = "std.constant"() {value = 42 : i32} : () -> i32
+    ```
+  }];
+
+  let arguments = (ins AnyAttr:$value);
+  let results = (outs SignlessIntegerOrFloatLike:$result);
+
+  let builders = [
+    OpBuilder<(ins "Attribute":$value),
+    [{ build($_builder, $_state, value.getType(), value); }]>,
+    OpBuilder<(ins "Attribute":$value, "Type":$type),
+    [{ build($_builder, $_state, type, value); }]>,
+  ];
+
+  let hasFolder = 1;
+  let verifier = [{ return ::verify(*this); }];
+  let assemblyFormat = "attr-dict $value";
+}
+
+//===----------------------------------------------------------------------===//
+// AddIOp
+//===----------------------------------------------------------------------===//
+
+def Arith_AddIOp : Arith_IntBinaryOp<"addi", [Commutative]> {
+  let summary = "integer addition operation";
+  let description = [{
     The `addi` operation takes two operands and returns one result, each of
     these is required to be the same type. This type may be an integer scalar
     type, a vector whose element type is integer, or a tensor of integers. It
     has no standard attributes.
 
     Example:
 
     ```mlir

 
 //===----------------------------------------------------------------------===//
 // DivUIOp
 //===----------------------------------------------------------------------===//
 
 def Arith_DivUIOp : Arith_IntBinaryOp<"divui"> {
   let summary = "unsigned integer division operation";
   let description = [{
-    Syntax:
-    ```
-    operation ::= ssa-id `=` `arith.divui` ssa-use `,` ssa-use `:` type
-    ```
-
     Unsigned integer division. Rounds towards zero. Treats the leading bit as
     the most significant, i.e. for `i16` given two's complement representation,
     `6 / -2 = 6 / (2^16 - 2) = 0`.
 
     Note: the semantics of division by zero is TBD; do NOT assume any specific
     behavior.
 
     Example:

 
 //===----------------------------------------------------------------------===//
 // DivSIOp
 //===----------------------------------------------------------------------===//
 
 def Arith_DivSIOp : Arith_IntBinaryOp<"divsi"> {
   let summary = "signed integer division operation";
   let description = [{
-    Syntax:
-
-    ```
-    operation ::= ssa-id `=` `arith.divsi` ssa-use `,` ssa-use `:` type
-    ```
-
     Signed integer division. Rounds towards zero. Treats the leading bit as
     sign, i.e. `6 / -2 = -3`.
 
     Note: the semantics of division by zero or signed division overflow (minimum
     value divided by -1) is TBD; do NOT assume any specific behavior.
 
     Example:
 

 
 //===----------------------------------------------------------------------===//
 // CeilDivSIOp
 //===----------------------------------------------------------------------===//
 
 def Arith_CeilDivSIOp : Arith_IntBinaryOp<"ceildivsi"> {
   let summary = "signed ceil integer division operation";
   let description = [{
-    Syntax:
-
-    ```
-    operation ::= ssa-id `=` `arith.ceildivsi` ssa-use `,` ssa-use `:` type
-    ```
-
     Signed integer division. Rounds towards positive infinity, i.e. `7 / -2 = -3`.
 
     Note: the semantics of division by zero or signed division overflow (minimum
     value divided by -1) is TBD; do NOT assume any specific behavior.
 
     Example:
 
     ```mlir
     // Scalar signed integer division.
     %a = arith.ceildivsi %b, %c : i64
     ```
   }];
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // FloorDivSIOp
 //===----------------------------------------------------------------------===//
 
 def Arith_FloorDivSIOp : Arith_IntBinaryOp<"floordivsi"> {
   let summary = "signed floor integer division operation";
   let description = [{
-    Syntax:
-
-    ```
-    operation ::= ssa-id `=` `arith.floordivsi` ssa-use `,` ssa-use `:` type
-    ```
-
     Signed integer division. Rounds towards negative infinity, i.e. `5 / -2 = -3`.
 
     Note: the semantics of division by zero or signed division overflow (minimum
     value divided by -1) is TBD; do NOT assume any specific behavior.
 
     Example:
 
     ```mlir
     // Scalar signed integer division.
     %a = arith.floordivsi %b, %c : i64
 
     ```
   }];
   let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
 // RemUIOp
 //===----------------------------------------------------------------------===//
 
 def Arith_RemUIOp : Arith_IntBinaryOp<"remui"> {
   let summary = "unsigned integer division remainder operation";
   let description = [{
-    Syntax:
-
-    ```
-    operation ::= ssa-id `=` `arith.remui` ssa-use `,` ssa-use `:` type
-    ```
-
     Unsigned integer division remainder. Treats the leading bit as the most
     significant, i.e. for `i16`, `6 % -2 = 6 % (2^16 - 2) = 6`.
 
     Note: the semantics of division by zero is TBD; do NOT assume any specific
     behavior.
 
     Example:
 

 
 //===----------------------------------------------------------------------===//
 // RemSIOp
 //===----------------------------------------------------------------------===//
 
 def Arith_RemSIOp : Arith_IntBinaryOp<"remsi"> {
   let summary = "signed integer division remainder operation";
   let description = [{
-    Syntax:
-
-    ```
-    operation ::= ssa-id `=` `arith.remsi` ssa-use `,` ssa-use `:` type
-    ```
-
     Signed integer division remainder. Treats the leading bit as sign, i.e. `6 %
     -2 = 0`.
 
     Note: the semantics of division by zero is TBD; do NOT assume any specific
     behavior.
 
     Example:
 

 
 //===----------------------------------------------------------------------===//
 // AndIOp
 //===----------------------------------------------------------------------===//
 
 def Arith_AndIOp : Arith_IntBinaryOp<"andi", [Commutative]> {
   let summary = "integer binary and";
   let description = [{
-    Syntax:
-
-    ```
-    operation ::= ssa-id `=` `arith.andi` ssa-use `,` ssa-use `:` type
-    ```
-
     The `andi` operation takes two operands and returns one result, each of
     these is required to be the same type. This type may be an integer scalar
     type, a vector whose element type is integer, or a tensor of integers. It
     has no standard attributes.
 
     Example:
 
     ```mlir

 
 //===----------------------------------------------------------------------===//
 // OrIOp
 //===----------------------------------------------------------------------===//
 
 def Arith_OrIOp : Arith_IntBinaryOp<"ori", [Commutative]> {
   let summary = "integer binary or";
   let description = [{
-    Syntax:
-
-    ```
-    operation ::= ssa-id `=` `arith.ori` ssa-use `,` ssa-use `:` type
-    ```
-
     The `ori` operation takes two operands and returns one result, each of these
     is required to be the same type. This type may be an integer scalar type, a
     vector whose element type is integer, or a tensor of integers. It has no
     standard attributes.
 
     Example:
 
     ```mlir

 
 //===----------------------------------------------------------------------===//
 // NegFOp
 //===----------------------------------------------------------------------===//
 
 def Arith_NegFOp : Arith_FloatUnaryOp<"negf"> {
   let summary = "floating point negation";
   let description = [{
-    Syntax:
-
-    ```
-    operation ::= ssa-id `=` `arith.negf` ssa-use `:` type
-    ```
-
     The `negf` operation computes the negation of a given value. It takes one
     operand and returns one result of the same type. This type may be a float
     scalar type, a vector whose element type is float, or a tensor of floats.
     It has no standard attributes.
 
     Example:
 
     ```mlir

 
 //===----------------------------------------------------------------------===//
 // AddFOp
 //===----------------------------------------------------------------------===//
 
 def Arith_AddFOp : Arith_FloatBinaryOp<"addf"> {
   let summary = "floating point addition operation";
   let description = [{
-    Syntax:
-
-    ```
-    operation ::= ssa-id `=` `arith.addf` ssa-use `,` ssa-use `:` type
-    ```
-
     The `addf` operation takes two operands and returns one result, each of
     these is required to be the same type. This type may be a floating point
     scalar type, a vector whose element type is a floating point type, or a
     floating point tensor.
 
     Example:
 
     ```mlir

 
 //===----------------------------------------------------------------------===//
 // MulFOp
 //===----------------------------------------------------------------------===//
 
 def Arith_MulFOp : Arith_FloatBinaryOp<"mulf"> {
   let summary = "floating point multiplication operation";
   let description = [{
-    Syntax:
-
-    ```
-    operation ::= ssa-id `=` `arith.mulf` ssa-use `,` ssa-use `:` type
-    ```
-
     The `mulf` operation takes two operands and returns one result, each of
     these is required to be the same type. This type may be a floating point
     scalar type, a vector whose element type is a floating point type, or a
     floating point tensor.
 
     Example:
 
     ```mlir

mlir/include/mlir/Dialect/Arithmetic/IR/CMakeLists.txt

+set(LLVM_TARGET_DEFINITIONS ArithmeticOps.td)
+mlir_tablegen(ArithmeticOpsEnums.h.inc -gen-enum-decls)
+mlir_tablegen(ArithmeticOpsEnums.cpp.inc -gen-enum-defs)
 add_mlir_dialect(ArithmeticOps arith)
 add_mlir_doc(ArithmeticOps ArithmeticOps Dialects/ -gen-dialect-doc)

mlir/lib/Dialect/Arithmetic/IR/ArithmeticOps.cpp

 //===- ArithmeticOps.cpp - MLIR Arithmetic dialect ops implementation -----===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "mlir/Dialect/Arithmetic/IR/Arithmetic.h"
 #include "mlir/Dialect/CommonFolders.h"
 #include "mlir/Dialect/StandardOps/IR/Ops.h"
 #include "mlir/IR/Builders.h"
 #include "mlir/IR/Matchers.h"
 #include "mlir/IR/OpImplementation.h"
 #include "mlir/IR/PatternMatch.h"
 #include "mlir/IR/TypeUtilities.h"
 
 using namespace mlir;
 using namespace mlir::arith;
 
-namespace {
-
 //===----------------------------------------------------------------------===//
 // Pattern helpers
 //===----------------------------------------------------------------------===//
 
-IntegerAttr addIntegerAttrs(PatternRewriter &builder, Value res, Attribute lhs,
-                            Attribute rhs) {
+static IntegerAttr addIntegerAttrs(PatternRewriter &builder, Value res,
+                                   Attribute lhs, Attribute rhs) {
   return builder.getIntegerAttr(res.getType(),
                                 lhs.cast<IntegerAttr>().getInt() +
                                     rhs.cast<IntegerAttr>().getInt());
 }
 
-IntegerAttr subIntegerAttrs(PatternRewriter &builder, Value res, Attribute lhs,
-                            Attribute rhs) {
+static IntegerAttr subIntegerAttrs(PatternRewriter &builder, Value res,
+                                   Attribute lhs, Attribute rhs) {
   return builder.getIntegerAttr(res.getType(),
                                 lhs.cast<IntegerAttr>().getInt() -
                                     rhs.cast<IntegerAttr>().getInt());
 }
 
 /// Invert an integer comparison predicate.
-arith::CmpIPredicate invertPredicate(arith::CmpIPredicate pred) {
+static arith::CmpIPredicate invertPredicate(arith::CmpIPredicate pred) {
   switch (pred) {
   case arith::CmpIPredicate::eq:
     return arith::CmpIPredicate::ne;
   case arith::CmpIPredicate::ne:
     return arith::CmpIPredicate::eq;
   case arith::CmpIPredicate::slt:
     return arith::CmpIPredicate::sge;
   case arith::CmpIPredicate::sle:
     return arith::CmpIPredicate::sgt;
   case arith::CmpIPredicate::sgt:
     return arith::CmpIPredicate::sle;
   case arith::CmpIPredicate::sge:
     return arith::CmpIPredicate::slt;
   case arith::CmpIPredicate::ult:
     return arith::CmpIPredicate::uge;
   case arith::CmpIPredicate::ule:
     return arith::CmpIPredicate::ugt;
   case arith::CmpIPredicate::ugt:
     return arith::CmpIPredicate::ule;
   case arith::CmpIPredicate::uge:
     return arith::CmpIPredicate::ult;
   }
+  llvm_unreachable("unknown cmpi predicate kind");
 }
 
-arith::CmpIPredicateAttr invertPredicate(arith::CmpIPredicateAttr pred) {
+static arith::CmpIPredicateAttr invertPredicate(arith::CmpIPredicateAttr pred) {
   return arith::CmpIPredicateAttr::get(pred.getContext(),
                                        invertPredicate(pred.getValue()));
 }
 
 //===----------------------------------------------------------------------===//
 // TableGen'd canonicalization patterns
 //===----------------------------------------------------------------------===//
 
+namespace {
 #include "ArithmeticCanonicalization.inc"
-
 } // end anonymous namespace
 
 //===----------------------------------------------------------------------===//
 // AddIOp
 //===----------------------------------------------------------------------===//
 
 OpFoldResult arith::AddIOp::fold(ArrayRef<Attribute> operands) {
   // addi(x, 0) -> x
if (overflowOrDiv0 || !b) {
       overflowOrDiv0 = true;
       return a;
     }
     unsigned bits = a.getBitWidth();
     APInt zero = APInt::getZero(bits);
     if (a.sgt(zero) && b.sgt(zero)) {
       // Both positive, return ceil(a, b).
       return signedCeilNonnegInputs(a, b, overflowOrDiv0);
-    } else if (a.slt(zero) && b.slt(zero)) {
+    }
+    if (a.slt(zero) && b.slt(zero)) {
       // Both negative, return ceil(-a, -b).
       APInt posA = zero.ssub_ov(a, overflowOrDiv0);
       APInt posB = zero.ssub_ov(b, overflowOrDiv0);
       return signedCeilNonnegInputs(posA, posB, overflowOrDiv0);
-    } else if (a.slt(zero) && b.sgt(zero)) {
+    }
+    if (a.slt(zero) && b.sgt(zero)) {
       // A is negative, b is positive, return - ( -a / b).
       APInt posA = zero.ssub_ov(a, overflowOrDiv0);
       APInt div = posA.sdiv_ov(b, overflowOrDiv0);
       return zero.ssub_ov(div, overflowOrDiv0);
-    } else {
-      // A is positive (or zero), b is negative, return - (a / -b).
-      APInt posB = zero.ssub_ov(b, overflowOrDiv0);
-      APInt div = a.sdiv_ov(posB, overflowOrDiv0);
-      return zero.ssub_ov(div, overflowOrDiv0);
-    }
+    }
   });
 
   // Fold out floor division by one. Assumes all tensors of all ones are
   // splats.
   if (auto rhs = operands[1].dyn_cast_or_null<IntegerAttr>()) {
     if (rhs.getValue() == 1)
       return lhs();
   } else if (auto rhs = operands[1].dyn_cast_or_null<SplatElementsAttr>()) {
if (overflowOrDiv0 || !b) {
       overflowOrDiv0 = true;
       return a;
     }
     unsigned bits = a.getBitWidth();
     APInt zero = APInt::getZero(bits);
     if (a.sge(zero) && b.sgt(zero)) {
       // Both positive (or a is zero), return a / b.
       return a.sdiv_ov(b, overflowOrDiv0);
-    } else if (a.sle(zero) && b.slt(zero)) {
+    }
+    if (a.sle(zero) && b.slt(zero)) {
       // Both negative (or a is zero), return -a / -b.
       APInt posA = zero.ssub_ov(a, overflowOrDiv0);
       APInt posB = zero.ssub_ov(b, overflowOrDiv0);
       return posA.sdiv_ov(posB, overflowOrDiv0);
-    } else if (a.slt(zero) && b.sgt(zero)) {
+    }
+    if (a.slt(zero) && b.sgt(zero)) {
       // A is negative, b is positive, return - ceil(-a, b).
       APInt posA = zero.ssub_ov(a, overflowOrDiv0);
       APInt ceil = signedCeilNonnegInputs(posA, b, overflowOrDiv0);
       return zero.ssub_ov(ceil, overflowOrDiv0);
-    } else {
-      // A is positive, b is negative, return - ceil(a, -b).
-      APInt posB = zero.ssub_ov(b, overflowOrDiv0);
-      APInt ceil = signedCeilNonnegInputs(a, posB, overflowOrDiv0);
-      return zero.ssub_ov(ceil, overflowOrDiv0);
-    }
+    }
   });
 
   // Fold out floor division by one. Assumes all tensors of all ones are
   // splats.
   if (auto rhs = operands[1].dyn_cast_or_null<IntegerAttr>()) {
     if (rhs.getValue() == 1)
       return lhs();
   } else if (auto rhs = operands[1].dyn_cast_or_null<SplatElementsAttr>()) {

 }
 
 //===----------------------------------------------------------------------===//
 // CmpIOp
 //===----------------------------------------------------------------------===//
 
 /// Compute `lhs` `pred` `rhs`, where `pred` is one of the known integer
 /// comparison predicates.
-bool mlir::applyCmpPredicate(arith::CmpIPredicate predicate, const APInt &lhs,
-                             const APInt &rhs) {
+bool mlir::arith::applyCmpPredicate(arith::CmpIPredicate predicate,
+                                    const APInt &lhs, const APInt &rhs) {
   switch (predicate) {
   case arith::CmpIPredicate::eq:
     return lhs.eq(rhs);
   case arith::CmpIPredicate::ne:
     return lhs.ne(rhs);
   case arith::CmpIPredicate::slt:
     return lhs.slt(rhs);
   case arith::CmpIPredicate::sle:
     return lhs.sle(rhs);
   case arith::CmpIPredicate::sgt:
     return lhs.sgt(rhs);
   case arith::CmpIPredicate::sge:
     return lhs.sge(rhs);
   case arith::CmpIPredicate::ult:
     return lhs.ult(rhs);
   case arith::CmpIPredicate::ule:
     return lhs.ule(rhs);
   case arith::CmpIPredicate::ugt:
     return lhs.ugt(rhs);
   case arith::CmpIPredicate::uge:
     return lhs.uge(rhs);
   }
+  llvm_unreachable("unknown cmpi predicate kind");
 }
 
 /// Returns true if the predicate is true for two equal operands.
 static bool applyCmpPredicateToEqualOperands(arith::CmpIPredicate predicate) {
   switch (predicate) {
   case arith::CmpIPredicate::eq:
   case arith::CmpIPredicate::sle:
   case arith::CmpIPredicate::sge:
   case arith::CmpIPredicate::ule:
   case arith::CmpIPredicate::uge:
     return true;
   case arith::CmpIPredicate::ne:
   case arith::CmpIPredicate::slt:
   case arith::CmpIPredicate::sgt:
   case arith::CmpIPredicate::ult:
   case arith::CmpIPredicate::ugt:
     return false;
   }
+  llvm_unreachable("unknown cmpi predicate kind");
 }
 
 OpFoldResult arith::CmpIOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "cmpi takes two operands");
 
   // cmpi(pred, x, x)
   if (lhs() == rhs()) {
     auto val = applyCmpPredicateToEqualOperands(getPredicate());

 }
 
 //===----------------------------------------------------------------------===//
 // CmpFOp
 //===----------------------------------------------------------------------===//
 
 /// Compute `lhs` `pred` `rhs`, where `pred` is one of the known floating point
 /// comparison predicates.
-bool mlir::applyCmpPredicate(arith::CmpFPredicate predicate, const APFloat &lhs,
-                             const APFloat &rhs) {
+bool mlir::arith::applyCmpPredicate(arith::CmpFPredicate predicate,
+                                    const APFloat &lhs, const APFloat &rhs) {
   auto cmpResult = lhs.compare(rhs);
   switch (predicate) {
   case arith::CmpFPredicate::AlwaysFalse:
     return false;
   case arith::CmpFPredicate::OEQ:
     return cmpResult == APFloat::cmpEqual;
   case arith::CmpFPredicate::OGT:
     return cmpResult == APFloat::cmpGreaterThan;
return cmpResult == APFloat::cmpUnordered ||
            cmpResult == APFloat::cmpLessThan || cmpResult == APFloat::cmpEqual;
   case arith::CmpFPredicate::UNE:
     return cmpResult != APFloat::cmpEqual;
   case arith::CmpFPredicate::UNO:
     return cmpResult == APFloat::cmpUnordered;
   case arith::CmpFPredicate::AlwaysTrue:
     return true;
   }
+  llvm_unreachable("unknown cmpf predicate kind");
 }
 
 OpFoldResult arith::CmpFOp::fold(ArrayRef<Attribute> operands) {
   assert(operands.size() == 2 && "cmpf takes two operands");
 
   auto lhs = operands.front().dyn_cast_or_null<FloatAttr>();
   auto rhs = operands.back().dyn_cast_or_null<FloatAttr>();