MLIR

Multi-Level IR Compiler Framework

'arith' Dialect

The arithmetic dialect is intended to hold basic integer and floating point 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 definition 

arith.addf (::mlir::arith::AddFOp) 

floating point addition operation

Syntax:

operation ::= `arith.addf` $lhs `,` $rhs attr-dict `:` type($result)

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:

// Scalar addition.
%a = arith.addf %b, %c : f64

// SIMD vector addition, e.g. for Intel SSE.
%f = arith.addf %g, %h : vector<4xf32>

// Tensor addition.
%x = arith.addf %y, %z : tensor<4x?xbf16>

TODO: In the distant future, this will accept optional attributes for fast math, contraction, rounding mode, and other controls.

Operands: 

OperandDescription
lhsfloating-point-like
rhsfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

arith.addi (::mlir::arith::AddIOp) 

integer addition operation

Syntax:

operation ::= `arith.addi` $lhs `,` $rhs attr-dict `:` type($result)

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:

// Scalar addition.
%a = arith.addi %b, %c : i64

// SIMD vector element-wise addition, e.g. for Intel SSE.
%f = arith.addi %g, %h : vector<4xi32>

// Tensor element-wise addition.
%x = arith.addi %y, %z : tensor<4x?xi8>

Operands: 

OperandDescription
lhssignless-integer-like
rhssignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

arith.andi (::mlir::arith::AndIOp) 

integer binary and

Syntax:

operation ::= `arith.andi` $lhs `,` $rhs attr-dict `:` type($result)

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:

// Scalar integer bitwise and.
%a = arith.andi %b, %c : i64

// SIMD vector element-wise bitwise integer and.
%f = arith.andi %g, %h : vector<4xi32>

// Tensor element-wise bitwise integer and.
%x = arith.andi %y, %z : tensor<4x?xi8>

Operands: 

OperandDescription
lhssignless-integer-like
rhssignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

arith.bitcast (::mlir::arith::BitcastOp) 

bitcast between values of equal bit width

Syntax:

operation ::= `arith.bitcast` $in attr-dict `:` type($in) `to` type($out)

Bitcast an integer or floating point value to an integer or floating point value of equal bit width. When operating on vectors, casts elementwise.

Note that this implements a logical bitcast independent of target endianness. This allows constant folding without target information and is consitent with the bitcast constant folders in LLVM (see https://github.com/llvm/llvm-project/blob/18c19414eb/llvm/lib/IR/ConstantFold.cpp#L168) For targets where the source and target type have the same endianness (which is the standard), this cast will also change no bits at runtime, but it may still require an operation, for example if the machine has different floating point and integer register files. For targets that have a different endianness for the source and target types (e.g. float is big-endian and integer is little-endian) a proper lowering would add operations to swap the order of words in addition to the bitcast.

Operands: 

OperandDescription
insignless-integer-or-float-like or memref of signless-integer or float

Results: 

ResultDescription
outsignless-integer-or-float-like or memref of signless-integer or float

arith.ceildivsi (::mlir::arith::CeilDivSIOp) 

signed ceil integer division operation

Syntax:

operation ::= `arith.ceildivsi` $lhs `,` $rhs attr-dict `:` type($result)

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:

// Scalar signed integer division.
%a = arith.ceildivsi %b, %c : i64

Operands: 

OperandDescription
lhssignless-integer-like
rhssignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

arith.cmpf (::mlir::arith::CmpFOp) 

floating-point comparison operation

Syntax:

operation ::= `arith.cmpf` $predicate `,` $lhs `,` $rhs attr-dict `:` type($lhs)

The cmpf operation compares its two operands according to the float comparison rules and the predicate specified by the respective attribute. The predicate defines the type of comparison: (un)orderedness, (in)equality and signed less/greater than (or equal to) as well as predicates that are always true or false. The operands must have the same type, and this type must be a float type, or a vector or tensor thereof. The result is an i1, or a vector/tensor thereof having the same shape as the inputs. Unlike cmpi, the operands are always treated as signed. The u prefix indicates unordered comparison, not unsigned comparison, so “une” means unordered or not equal. For the sake of readability by humans, custom assembly form for the operation uses a string-typed attribute for the predicate. The value of this attribute corresponds to lower-cased name of the predicate constant, e.g., “one” means “ordered not equal”. The string representation of the attribute is merely a syntactic sugar and is converted to an integer attribute by the parser.

Example:

%r1 = arith.cmpf "oeq" %0, %1 : f32
%r2 = arith.cmpf "ult" %0, %1 : tensor<42x42xf64>
%r3 = "arith.cmpf"(%0, %1) {predicate: 0} : (f8, f8) -> i1

Attributes: 

AttributeMLIR TypeDescription
predicate::mlir::arith::CmpFPredicateAttrallowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15

Operands: 

OperandDescription
lhsfloating-point-like
rhsfloating-point-like

Results: 

ResultDescription
resultbool-like

arith.cmpi (::mlir::arith::CmpIOp) 

integer comparison operation

Syntax:

operation ::= `arith.cmpi` $predicate `,` $lhs `,` $rhs attr-dict `:` type($lhs)

The cmpi operation is a generic comparison for integer-like types. Its two arguments can be integers, vectors or tensors thereof as long as their types match. The operation produces an i1 for the former case, a vector or a tensor of i1 with the same shape as inputs in the other cases.

Its first argument is an attribute that defines which type of comparison is performed. The following comparisons are supported:

  • equal (mnemonic: "eq"; integer value: 0)
  • not equal (mnemonic: "ne"; integer value: 1)
  • signed less than (mnemonic: "slt"; integer value: 2)
  • signed less than or equal (mnemonic: "sle"; integer value: 3)
  • signed greater than (mnemonic: "sgt"; integer value: 4)
  • signed greater than or equal (mnemonic: "sge"; integer value: 5)
  • unsigned less than (mnemonic: "ult"; integer value: 6)
  • unsigned less than or equal (mnemonic: "ule"; integer value: 7)
  • unsigned greater than (mnemonic: "ugt"; integer value: 8)
  • unsigned greater than or equal (mnemonic: "uge"; integer value: 9)

The result is 1 if the comparison is true and 0 otherwise. For vector or tensor operands, the comparison is performed elementwise and the element of the result indicates whether the comparison is true for the operand elements with the same indices as those of the result.

Note: while the custom assembly form uses strings, the actual underlying attribute has integer type (or rather enum class in C++ code) as seen from the generic assembly form. String literals are used to improve readability of the IR by humans.

This operation only applies to integer-like operands, but not floats. The main reason being that comparison operations have diverging sets of attributes: integers require sign specification while floats require various floating point-related particularities, e.g., -ffast-math behavior, IEEE754 compliance, etc ( rationale ). The type of comparison is specified as attribute to avoid introducing ten similar operations, taking into account that they are often implemented using the same operation downstream ( rationale ). The separation between signed and unsigned order comparisons is necessary because of integers being signless. The comparison operation must know how to interpret values with the foremost bit being set: negatives in two’s complement or large positives ( rationale ).

Example:

// Custom form of scalar "signed less than" comparison.
%x = arith.cmpi "slt", %lhs, %rhs : i32

// Generic form of the same operation.
%x = "arith.cmpi"(%lhs, %rhs) {predicate = 2 : i64} : (i32, i32) -> i1

// Custom form of vector equality comparison.
%x = arith.cmpi "eq", %lhs, %rhs : vector<4xi64>

// Generic form of the same operation.
%x = "std.arith.cmpi"(%lhs, %rhs) {predicate = 0 : i64}
    : (vector<4xi64>, vector<4xi64>) -> vector<4xi1>

Attributes: 

AttributeMLIR TypeDescription
predicate::mlir::arith::CmpIPredicateAttrallowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

Operands: 

OperandDescription
lhssignless-integer-like
rhssignless-integer-like

Results: 

ResultDescription
resultbool-like

arith.constant (::mlir::arith::ConstantOp) 

integer or floating point constant

Syntax:

operation ::= `arith.constant` attr-dict $value

The constant operation produces an SSA value equal to some integer or floating-point constant specified by an attribute. This is the way MLIR forms simple integer and floating point constants.

Example:

// Integer constant
%1 = arith.constant 42 : i32

// Equivalent generic form
%1 = "arith.constant"() {value = 42 : i32} : () -> i32

Attributes: 

AttributeMLIR TypeDescription
value::mlir::Attributeany attribute

Results: 

ResultDescription
resultany type

arith.divf (::mlir::arith::DivFOp) 

floating point division operation

Syntax:

operation ::= `arith.divf` $lhs `,` $rhs attr-dict `:` type($result)

Operands: 

OperandDescription
lhsfloating-point-like
rhsfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

arith.divsi (::mlir::arith::DivSIOp) 

signed integer division operation

Syntax:

operation ::= `arith.divsi` $lhs `,` $rhs attr-dict `:` type($result)

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:

// Scalar signed integer division.
%a = arith.divsi %b, %c : i64

// SIMD vector element-wise division.
%f = arith.divsi %g, %h : vector<4xi32>

// Tensor element-wise integer division.
%x = arith.divsi %y, %z : tensor<4x?xi8>

Operands: 

OperandDescription
lhssignless-integer-like
rhssignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

arith.divui (::mlir::arith::DivUIOp) 

unsigned integer division operation

Syntax:

operation ::= `arith.divui` $lhs `,` $rhs attr-dict `:` type($result)

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:

// Scalar unsigned integer division.
%a = arith.divui %b, %c : i64

// SIMD vector element-wise division.
%f = arith.divui %g, %h : vector<4xi32>

// Tensor element-wise integer division.
%x = arith.divui %y, %z : tensor<4x?xi8>

Operands: 

OperandDescription
lhssignless-integer-like
rhssignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

arith.extf (::mlir::arith::ExtFOp) 

cast from floating-point to wider floating-point

Syntax:

operation ::= `arith.extf` $in attr-dict `:` type($in) `to` type($out)

Cast a floating-point value to a larger floating-point-typed value. The destination type must to be strictly wider than the source type. When operating on vectors, casts elementwise.

Operands: 

OperandDescription
infloating-point-like

Results: 

ResultDescription
outfloating-point-like

arith.extsi (::mlir::arith::ExtSIOp) 

integer sign extension operation

Syntax:

operation ::= `arith.extsi` $in attr-dict `:` type($in) `to` type($out)

The integer sign extension operation takes an integer input of width M and an integer destination type of width N. The destination bit-width must be larger than the input bit-width (N > M). The top-most (N - M) bits of the output are filled with copies of the most-significant bit of the input.

Example:

%1 = arith.constant 5 : i3      // %1 is 0b101
%2 = arith.extsi %1 : i3 to i6  // %2 is 0b111101
%3 = arith.constant 2 : i3      // %3 is 0b010
%4 = arith.extsi %3 : i3 to i6  // %4 is 0b000010

%5 = arith.extsi %0 : vector<2 x i32> to vector<2 x i64>

Operands: 

OperandDescription
insignless-fixed-width-integer-like

Results: 

ResultDescription
outsignless-fixed-width-integer-like

arith.extui (::mlir::arith::ExtUIOp) 

integer zero extension operation

Syntax:

operation ::= `arith.extui` $in attr-dict `:` type($in) `to` type($out)

The integer zero extension operation takes an integer input of width M and an integer destination type of width N. The destination bit-width must be larger than the input bit-width (N > M). The top-most (N - M) bits of the output are filled with zeros.

Example:

  %1 = arith.constant 5 : i3      // %1 is 0b101
  %2 = arith.extui %1 : i3 to i6  // %2 is 0b000101
  %3 = arith.constant 2 : i3      // %3 is 0b010
  %4 = arith.extui %3 : i3 to i6  // %4 is 0b000010

  %5 = arith.extui %0 : vector<2 x i32> to vector<2 x i64>

Operands: 

OperandDescription
insignless-fixed-width-integer-like

Results: 

ResultDescription
outsignless-fixed-width-integer-like

arith.fptosi (::mlir::arith::FPToSIOp) 

cast from floating-point type to integer type

Syntax:

operation ::= `arith.fptosi` $in attr-dict `:` type($in) `to` type($out)

Cast from a value interpreted as floating-point to the nearest (rounding towards zero) signed integer value. When operating on vectors, casts elementwise.

Operands: 

OperandDescription
infloating-point-like

Results: 

ResultDescription
outsignless-fixed-width-integer-like

arith.fptoui (::mlir::arith::FPToUIOp) 

cast from floating-point type to integer type

Syntax:

operation ::= `arith.fptoui` $in attr-dict `:` type($in) `to` type($out)

Cast from a value interpreted as floating-point to the nearest (rounding towards zero) unsigned integer value. When operating on vectors, casts elementwise.

Operands: 

OperandDescription
infloating-point-like

Results: 

ResultDescription
outsignless-fixed-width-integer-like

arith.floordivsi (::mlir::arith::FloorDivSIOp) 

signed floor integer division operation

Syntax:

operation ::= `arith.floordivsi` $lhs `,` $rhs attr-dict `:` type($result)

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:

// Scalar signed integer division.
%a = arith.floordivsi %b, %c : i64

Operands: 

OperandDescription
lhssignless-integer-like
rhssignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

arith.index_cast (::mlir::arith::IndexCastOp) 

cast between index and integer types

Syntax:

operation ::= `arith.index_cast` $in attr-dict `:` type($in) `to` type($out)

Casts between scalar or vector integers and corresponding ‘index’ scalar or vectors. 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.

Operands: 

OperandDescription
insignless-integer-like or memref of signless-integer

Results: 

ResultDescription
outsignless-integer-like or memref of signless-integer

arith.mulf (::mlir::arith::MulFOp) 

floating point multiplication operation

Syntax:

operation ::= `arith.mulf` $lhs `,` $rhs attr-dict `:` type($result)

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:

// Scalar multiplication.
%a = arith.mulf %b, %c : f64

// SIMD pointwise vector multiplication, e.g. for Intel SSE.
%f = arith.mulf %g, %h : vector<4xf32>

// Tensor pointwise multiplication.
%x = arith.mulf %y, %z : tensor<4x?xbf16>

TODO: In the distant future, this will accept optional attributes for fast math, contraction, rounding mode, and other controls.

Operands: 

OperandDescription
lhsfloating-point-like
rhsfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

arith.muli (::mlir::arith::MulIOp) 

integer multiplication operation

Syntax:

operation ::= `arith.muli` $lhs `,` $rhs attr-dict `:` type($result)

Operands: 

OperandDescription
lhssignless-integer-like
rhssignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

arith.negf (::mlir::arith::NegFOp) 

floating point negation

Syntax:

operation ::= `arith.negf` $operand attr-dict `:` type($result)

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:

// Scalar negation value.
%a = arith.negf %b : f64

// SIMD vector element-wise negation value.
%f = arith.negf %g : vector<4xf32>

// Tensor element-wise negation value.
%x = arith.negf %y : tensor<4x?xf8>

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

arith.ori (::mlir::arith::OrIOp) 

integer binary or

Syntax:

operation ::= `arith.ori` $lhs `,` $rhs attr-dict `:` type($result)

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:

// Scalar integer bitwise or.
%a = arith.ori %b, %c : i64

// SIMD vector element-wise bitwise integer or.
%f = arith.ori %g, %h : vector<4xi32>

// Tensor element-wise bitwise integer or.
%x = arith.ori %y, %z : tensor<4x?xi8>

Operands: 

OperandDescription
lhssignless-integer-like
rhssignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

arith.remf (::mlir::arith::RemFOp) 

floating point division remainder operation

Syntax:

operation ::= `arith.remf` $lhs `,` $rhs attr-dict `:` type($result)

Operands: 

OperandDescription
lhsfloating-point-like
rhsfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

arith.remsi (::mlir::arith::RemSIOp) 

signed integer division remainder operation

Syntax:

operation ::= `arith.remsi` $lhs `,` $rhs attr-dict `:` type($result)

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:

// Scalar signed integer division remainder.
%a = arith.remsi %b, %c : i64

// SIMD vector element-wise division remainder.
%f = arith.remsi %g, %h : vector<4xi32>

// Tensor element-wise integer division remainder.
%x = arith.remsi %y, %z : tensor<4x?xi8>

Operands: 

OperandDescription
lhssignless-integer-like
rhssignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

arith.remui (::mlir::arith::RemUIOp) 

unsigned integer division remainder operation

Syntax:

operation ::= `arith.remui` $lhs `,` $rhs attr-dict `:` type($result)

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:

// Scalar unsigned integer division remainder.
%a = arith.remui %b, %c : i64

// SIMD vector element-wise division remainder.
%f = arith.remui %g, %h : vector<4xi32>

// Tensor element-wise integer division remainder.
%x = arith.remui %y, %z : tensor<4x?xi8>

Operands: 

OperandDescription
lhssignless-integer-like
rhssignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

arith.sitofp (::mlir::arith::SIToFPOp) 

cast from integer type to floating-point

Syntax:

operation ::= `arith.sitofp` $in attr-dict `:` type($in) `to` type($out)

Cast from a value interpreted as a signed integer to the corresponding floating-point value. If the value cannot be exactly represented, it is rounded using the default rounding mode. When operating on vectors, casts elementwise.

Operands: 

OperandDescription
insignless-fixed-width-integer-like

Results: 

ResultDescription
outfloating-point-like

arith.shli (::mlir::arith::ShLIOp) 

integer left-shift

Syntax:

operation ::= `arith.shli` $lhs `,` $rhs attr-dict `:` type($result)

The shli operation shifts an integer value to the left by a variable amount. The low order bits are filled with zeros.

Example:

%1 = arith.constant 5 : i8                 // %1 is 0b00000101
%2 = arith.constant 3 : i8
%3 = arith.shli %1, %2 : (i8, i8) -> i8    // %3 is 0b00101000

Operands: 

OperandDescription
lhssignless-integer-like
rhssignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

arith.shrsi (::mlir::arith::ShRSIOp) 

signed integer right-shift

Syntax:

operation ::= `arith.shrsi` $lhs `,` $rhs attr-dict `:` type($result)

The shrsi operation shifts an integer value to the right by a variable amount. The integer is interpreted as signed. The high order bits in the output are filled with copies of the most-significant bit of the shifted value (which means that the sign of the value is preserved).

Example:

%1 = arith.constant 160 : i8               // %1 is 0b10100000
%2 = arith.constant 3 : i8
%3 = arith.shrsi %1, %2 : (i8, i8) -> i8   // %3 is 0b11110100
%4 = arith.constant 96 : i8                   // %4 is 0b01100000
%5 = arith.shrsi %4, %2 : (i8, i8) -> i8   // %5 is 0b00001100

Operands: 

OperandDescription
lhssignless-integer-like
rhssignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

arith.shrui (::mlir::arith::ShRUIOp) 

unsigned integer right-shift

Syntax:

operation ::= `arith.shrui` $lhs `,` $rhs attr-dict `:` type($result)

The shrui operation shifts an integer value to the right by a variable amount. The integer is interpreted as unsigned. The high order bits are always filled with zeros.

Example:

%1 = arith.constant 160 : i8               // %1 is 0b10100000
%2 = arith.constant 3 : i8
%3 = arith.shrui %1, %2 : (i8, i8) -> i8   // %3 is 0b00010100

Operands: 

OperandDescription
lhssignless-integer-like
rhssignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

arith.subf (::mlir::arith::SubFOp) 

floating point subtraction operation

Syntax:

operation ::= `arith.subf` $lhs `,` $rhs attr-dict `:` type($result)

Operands: 

OperandDescription
lhsfloating-point-like
rhsfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

arith.subi (::mlir::arith::SubIOp) 

integer subtraction operation

Syntax:

operation ::= `arith.subi` $lhs `,` $rhs attr-dict `:` type($result)

Operands: 

OperandDescription
lhssignless-integer-like
rhssignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

arith.truncf (::mlir::arith::TruncFOp) 

cast from floating-point to narrower floating-point

Syntax:

operation ::= `arith.truncf` $in attr-dict `:` type($in) `to` type($out)

Truncate a floating-point value to a smaller floating-point-typed value. The destination type must be strictly narrower than the source type. If the value cannot be exactly represented, it is rounded using the default rounding mode. When operating on vectors, casts elementwise.

Operands: 

OperandDescription
infloating-point-like

Results: 

ResultDescription
outfloating-point-like

arith.trunci (::mlir::arith::TruncIOp) 

integer truncation operation

Syntax:

operation ::= `arith.trunci` $in attr-dict `:` type($in) `to` type($out)

The integer truncation operation takes an integer input of width M and an integer destination type of width N. The destination bit-width must be smaller than the input bit-width (N < M). The top-most (N - M) bits of the input are discarded.

Example:

  %1 = arith.constant 21 : i5     // %1 is 0b10101
  %2 = arith.trunci %1 : i5 to i4 // %2 is 0b0101
  %3 = arith.trunci %1 : i5 to i3 // %3 is 0b101

  %5 = arith.trunci %0 : vector<2 x i32> to vector<2 x i16>

Operands: 

OperandDescription
insignless-fixed-width-integer-like

Results: 

ResultDescription
outsignless-fixed-width-integer-like

arith.uitofp (::mlir::arith::UIToFPOp) 

cast from unsigned integer type to floating-point

Syntax:

operation ::= `arith.uitofp` $in attr-dict `:` type($in) `to` type($out)

Cast from a value interpreted as unsigned integer to the corresponding floating-point value. If the value cannot be exactly represented, it is rounded using the default rounding mode. When operating on vectors, casts elementwise.

Operands: 

OperandDescription
insignless-fixed-width-integer-like

Results: 

ResultDescription
outfloating-point-like

arith.xori (::mlir::arith::XOrIOp) 

integer binary xor

Syntax:

operation ::= `arith.xori` $lhs `,` $rhs attr-dict `:` type($result)

The xori 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:

// Scalar integer bitwise xor.
%a = arith.xori %b, %c : i64

// SIMD vector element-wise bitwise integer xor.
%f = arith.xori %g, %h : vector<4xi32>

// Tensor element-wise bitwise integer xor.
%x = arith.xori %y, %z : tensor<4x?xi8>

Operands: 

OperandDescription
lhssignless-integer-like
rhssignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like