MLIR

Multi-Level IR Compiler Framework

'math' Dialect

The math dialect is intended to hold mathematical operations on integer and floating types beyond simple arithmetics. Each operation works on scalar, vector or tensor type. On vector and tensor type operations apply elementwise unless explicitly specified otherwise. As an example, the floating point absolute value can be expressed as:

// Scalar absolute value.
%a = math.absf %b : f64

// Vector elementwise absolute value.
%f = math.absf %g : vector<4xf32>

// Tensor elementwise absolute value.
%x = math.absf %y : tensor<4x?xf8>

Operations 

source

math.absf (math::AbsFOp) 

Floating point absolute-value operation

Syntax:

operation ::= `math.absf` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The absf operation computes the absolute value. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type.

Example:

// Scalar absolute value.
%a = math.absf %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.absi (math::AbsIOp) 

Integer absolute-value operation

Syntax:

operation ::= `math.absi` $operand attr-dict `:` type($result)

The absi operation computes the absolute value. It takes one operand of integer type (i.e., scalar, tensor or vector) and returns one result of the same type.

Example:

// Scalar absolute value.
%a = math.absi %b : i64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
operandsignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

math.acos (math::AcosOp) 

Arcus cosine of the specified value

Syntax:

operation ::= `math.acos` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The acos operation computes the arcus cosine of a given value. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Scalar arcus cosine value.
%a = math.acos %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.acosh (math::AcoshOp) 

Hyperbolic arcus cosine of the given value

Syntax:

operation ::= `math.acosh` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

Syntax:

operation ::= ssa-id `=` `math.acosh` ssa-use `:` type

The acosh operation computes the arcus cosine of a given value. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Hyperbolic arcus cosine of scalar value.
%a = math.acosh %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.asin (math::AsinOp) 

Arcus sine of the given value

Syntax:

operation ::= `math.asin` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

Syntax:

operation ::= ssa-id `=` `math.asin` ssa-use `:` type

The asin operation computes the arcus sine of a given value. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Arcus sine of scalar value.
%a = math.asin %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.asinh (math::AsinhOp) 

Hyperbolic arcus sine of the given value

Syntax:

operation ::= `math.asinh` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

Syntax:

operation ::= ssa-id `=` `math.asinh` ssa-use `:` type

The asinh operation computes the hyperbolic arcus sine of a given value. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Hyperbolic arcus sine of scalar value.
%a = math.asinh %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.atan (math::AtanOp) 

Arcus tangent of the given value

Syntax:

operation ::= `math.atan` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The atan operation computes the arcus tangent of a given value. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Arcus tangent of scalar value.
%a = math.atan %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.atan2 (math::Atan2Op) 

2-argument arcus tangent of the given values

Syntax:

operation ::= `math.atan2` $lhs `,` $rhs (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The atan2 operation takes two operands and returns one result, all of which must be of the same type. The operands must be of floating point type (i.e., scalar, tensor or vector).

The 2-argument arcus tangent atan2(y, x) returns the angle in the Euclidian plane between the positive x-axis and the ray through the point (x, y). It is a generalization of the 1-argument arcus tangent which returns the angle on the basis of the ratio y/x.

See also https://en.wikipedia.org/wiki/Atan2

Example:

// Scalar variant.
%a = math.atan2 %b, %c : f32

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
lhsfloating-point-like
rhsfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.atanh (math::AtanhOp) 

Hyperbolic arcus tangent of the given value

Syntax:

operation ::= `math.atanh` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

Syntax:

operation ::= ssa-id `=` `math.atanh` ssa-use `:` type

The atanh operation computes the hyperbolic arcus tangent of a given value. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Hyperbolic arcus tangent of scalar value.
%a = math.atanh %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.cbrt (math::CbrtOp) 

Cube root of the specified value

Syntax:

operation ::= `math.cbrt` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The cbrt operation computes the cube root. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Scalar cube root value.
%a = math.cbrt %b : f64

Note: This op is not equivalent to powf(…, 1/3.0).

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.ceil (math::CeilOp) 

Ceiling of the specified value

Syntax:

operation ::= `math.ceil` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The ceil operation computes the ceiling of a given value. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Scalar ceiling value.
%a = math.ceil %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.copysign (math::CopySignOp) 

A copysign operation

Syntax:

operation ::= `math.copysign` $lhs `,` $rhs (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The copysign returns a value with the magnitude of the first operand and the sign of the second operand. It takes two operands and returns one result of the same type. The operands must be of floating point type (i.e., scalar, tensor or vector). It has no standard attributes.

Example:

// Scalar copysign value.
%a = math.copysign %b, %c : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
lhsfloating-point-like
rhsfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.cos (math::CosOp) 

Cosine of the specified value

Syntax:

operation ::= `math.cos` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The cos operation computes the cosine of a given value. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Scalar cosine value.
%a = math.cos %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.cosh (math::CoshOp) 

Hyperbolic cosine of the specified value

Syntax:

operation ::= `math.cosh` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The cosh operation computes the hyperbolic cosine. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Scalar hyperbolic cosine value.
%a = math.cosh %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.ctlz (math::CountLeadingZerosOp) 

Counts the leading zeros an integer value

Syntax:

operation ::= `math.ctlz` $operand attr-dict `:` type($result)

The ctlz operation computes the number of leading zeros of an integer value. It operates on scalar, tensor or vector.

Example:

// Scalar ctlz function value.
%a = math.ctlz %b : i32

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
operandsignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

math.ctpop (math::CtPopOp) 

Counts the number of set bits of an integer value

Syntax:

operation ::= `math.ctpop` $operand attr-dict `:` type($result)

The ctpop operation computes the number of set bits of an integer value. It operates on scalar, tensor or vector.

Example:

// Scalar ctpop function value.
%a = math.ctpop %b : i32

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
operandsignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

math.cttz (math::CountTrailingZerosOp) 

Counts the trailing zeros an integer value

Syntax:

operation ::= `math.cttz` $operand attr-dict `:` type($result)

The cttz operation computes the number of trailing zeros of an integer value. It operates on scalar, tensor or vector.

Example:

// Scalar cttz function value.
%a = math.cttz %b : i32

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
operandsignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

math.erf (math::ErfOp) 

Error function of the specified value

Syntax:

operation ::= `math.erf` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The erf operation computes the error function. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Scalar error function value.
%a = math.erf %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.exp (math::ExpOp) 

Base-e exponential of the specified value

Syntax:

operation ::= `math.exp` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The exp operation takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Scalar natural exponential.
%a = math.exp %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.exp2 (math::Exp2Op) 

Base-2 exponential of the specified value

Syntax:

operation ::= `math.exp2` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The exp operation takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Scalar natural exponential.
%a = math.exp2 %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.expm1 (math::ExpM1Op) 

Base-e exponential of the specified value minus 1

Syntax:

operation ::= `math.expm1` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

expm1(x) := exp(x) - 1

The expm1 operation takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Scalar natural exponential minus 1.
%a = math.expm1 %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.floor (math::FloorOp) 

Floor of the specified value

Syntax:

operation ::= `math.floor` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The floor operation computes the floor of a given value. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Scalar floor value.
%a = math.floor %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.fma (math::FmaOp) 

Floating point fused multipy-add operation

Syntax:

operation ::= `math.fma` $a `,` $b `,` $c (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The fma operation takes three operands and returns one result, each of these is required to be the same type. Operands must be of floating point type (i.e., scalar, tensor or vector).

Example:

// Scalar fused multiply-add: d = a*b + c
%d = math.fma %a, %b, %c : f64

The semantics of the operation correspond to those of the llvm.fma intrinsic. In the particular case of lowering to LLVM, this is guaranteed to lower to the llvm.fma.* intrinsic.

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
afloating-point-like
bfloating-point-like
cfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.fpowi (math::FPowIOp) 

Floating point raised to the signed integer power

Syntax:

operation ::= `math.fpowi` $lhs `,` $rhs (`fastmath` `` $fastmath^)?
              attr-dict `:` type($lhs) `,` type($rhs)

The fpowi operation takes a base operand of floating point type (i.e. scalar, tensor or vector) and a power operand of integer type (also scalar, tensor or vector) and returns one result of the same type as base. The result is base raised to the power of power. The operation is elementwise for non-scalars, e.g.:

%v = math.fpowi %base, %power : vector<2xf32>, vector<2xi32

The result is a vector of:

[<math.fpowi %base[0], %power[0]>, <math.fpowi %base[1], %power[1]>]

Example:

// Scalar exponentiation.
%a = math.fpowi %base, %power : f64, i32

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultShape, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
lhsfloating-point-like
rhssignless-integer-like

Results: 

ResultDescription
resultfloating-point-like

math.ipowi (math::IPowIOp) 

Signed integer raised to the power of operation

Syntax:

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

The ipowi operation takes two operands of integer type (i.e., scalar, tensor or vector) and returns one result of the same type. Operands must have the same type.

Example:

// Scalar signed integer exponentiation.
%a = math.ipowi %b, %c : i32

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Operands: 

OperandDescription
lhssignless-integer-like
rhssignless-integer-like

Results: 

ResultDescription
resultsignless-integer-like

math.log (math::LogOp) 

Base-e logarithm of the specified value

Syntax:

operation ::= `math.log` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

Computes the base-e logarithm of the given value. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type.

Example:

// Scalar log operation.
%y = math.log %x : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.log10 (math::Log10Op) 

Base-10 logarithm of the specified value

Syntax:

operation ::= `math.log10` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

Computes the base-10 logarithm of the given value. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type.

Example:

// Scalar log10 operation.
%y = math.log10 %x : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.log1p (math::Log1pOp) 

Computes the natural logarithm of one plus the given value

Syntax:

operation ::= `math.log1p` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

Computes the base-e logarithm of one plus the given value. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type.

log1p(x) := log(1 + x)

Example:

// Scalar log1p operation.
%y = math.log1p %x : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.log2 (math::Log2Op) 

Base-2 logarithm of the specified value

Syntax:

operation ::= `math.log2` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

Computes the base-2 logarithm of the given value. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type.

Example:

// Scalar log2 operation.
%y = math.log2 %x : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.powf (math::PowFOp) 

Floating point raised to the power of operation

Syntax:

operation ::= `math.powf` $lhs `,` $rhs (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The powf operation takes two operands of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. Operands must have the same type.

Example:

// Scalar exponentiation.
%a = math.powf %b, %c : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
lhsfloating-point-like
rhsfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.round (math::RoundOp) 

Round of the specified value

Syntax:

operation ::= `math.round` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The round operation returns the operand rounded to the nearest integer value in floating-point format. It takes one operand of floating point type (i.e., scalar, tensor or vector) and produces one result of the same type. The operation rounds the argument to the nearest integer value in floating-point format, rounding halfway cases away from zero, regardless of the current rounding direction.

Example:

// Scalar round operation.
%a = math.round %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.roundeven (math::RoundEvenOp) 

Round of the specified value with halfway cases to even

Syntax:

operation ::= `math.roundeven` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The roundeven operation returns the operand rounded to the nearest integer value in floating-point format. It takes one operand of floating point type (i.e., scalar, tensor or vector) and produces one result of the same type. The operation rounds the argument to the nearest integer value in floating-point format, rounding halfway cases to even, regardless of the current rounding direction.

Example:

// Scalar round operation.
%a = math.roundeven %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.rsqrt (math::RsqrtOp) 

Reciprocal of sqrt (1 / sqrt of the specified value)

Syntax:

operation ::= `math.rsqrt` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The rsqrt operation computes the reciprocal of the square root. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Scalar reciprocal square root value.
%a = math.rsqrt %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.sin (math::SinOp) 

Sine of the specified value

Syntax:

operation ::= `math.sin` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The sin operation computes the sine of a given value. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Scalar sine value.
%a = math.sin %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.sinh (math::SinhOp) 

Hyperbolic sine of the specified value

Syntax:

operation ::= `math.sinh` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The sinh operation computes the hyperbolic sine. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Scalar hyperbolic sine value.
%a = math.sinh %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.sqrt (math::SqrtOp) 

Sqrt of the specified value

Syntax:

operation ::= `math.sqrt` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The sqrt operation computes the square root. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Scalar square root value.
%a = math.sqrt %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.tan (math::TanOp) 

Tangent of the specified value

Syntax:

operation ::= `math.tan` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The tan operation computes the tangent. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Scalar tangent value.
%a = math.tan %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.tanh (math::TanhOp) 

Hyperbolic tangent of the specified value

Syntax:

operation ::= `math.tanh` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The tanh operation computes the hyperbolic tangent. It takes one operand of floating point type (i.e., scalar, tensor or vector) and returns one result of the same type. It has no standard attributes.

Example:

// Scalar hyperbolic tangent value.
%a = math.tanh %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

math.trunc (math::TruncOp) 

Trunc of the specified value

Syntax:

operation ::= `math.trunc` $operand (`fastmath` `` $fastmath^)?
              attr-dict `:` type($result)

The trunc operation returns the operand rounded to the nearest integer value in floating-point format. It takes one operand of floating point type (i.e., scalar, tensor or vector) and produces one result of the same type. The operation always rounds to the nearest integer not larger in magnitude than the operand, regardless of the current rounding direction.

Example:

// Scalar trunc operation.
%a = math.trunc %b : f64

Traits: AlwaysSpeculatableImplTrait, Elementwise, SameOperandsAndResultType, Scalarizable, Tensorizable, Vectorizable

Interfaces: ArithFastMathInterface, ConditionallySpeculatable, InferTypeOpInterface, NoMemoryEffect (MemoryEffectOpInterface), VectorUnrollOpInterface

Effects: MemoryEffects::Effect{}

Attributes: 

AttributeMLIR TypeDescription
fastmath::mlir::arith::FastMathFlagsAttr
Floating point fast math flags

Enum cases:

  • none (none)
  • reassoc (reassoc)
  • nnan (nnan)
  • ninf (ninf)
  • nsz (nsz)
  • arcp (arcp)
  • contract (contract)
  • afn (afn)
  • fast (fast)

Operands: 

OperandDescription
operandfloating-point-like

Results: 

ResultDescription
resultfloating-point-like

Enums 

CmpFPredicate 

allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15

Cases: 

SymbolValueString
AlwaysFalse0false
OEQ1oeq
OGT2ogt
OGE3oge
OLT4olt
OLE5ole
ONE6one
ORD7ord
UEQ8ueq
UGT9ugt
UGE10uge
ULT11ult
ULE12ule
UNE13une
UNO14uno
AlwaysTrue15true

CmpIPredicate 

allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9

Cases: 

SymbolValueString
eq0eq
ne1ne
slt2slt
sle3sle
sgt4sgt
sge5sge
ult6ult
ule7ule
ugt8ugt
uge9uge

DenormalMode 

denormal mode arith

Cases: 

SymbolValueString
ieee0ieee
preserve_sign1preserve_sign
positive_zero2positive_zero

IntegerOverflowFlags 

Integer overflow arith flags

Cases: 

SymbolValueString
none0none
nsw1nsw
nuw2nuw

RoundingMode 

Floating point rounding mode

Cases: 

SymbolValueString
to_nearest_even0to_nearest_even
downward1downward
upward2upward
toward_zero3toward_zero
to_nearest_away4to_nearest_away

AtomicRMWKind 

allowed 64-bit signless integer cases: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14

Cases: 

SymbolValueString
addf0addf
addi1addi
assign2assign
maximumf3maximumf
maxs4maxs
maxu5maxu
minimumf6minimumf
mins7mins
minu8minu
mulf9mulf
muli10muli
ori11ori
andi12andi
maxnumf13maxnumf
minnumf14minnumf

FastMathFlags 

Floating point fast math flags

Cases: 

SymbolValueString
none0none
reassoc1reassoc
nnan2nnan
ninf4ninf
nsz8nsz
arcp16arcp
contract32contract
afn64afn
fast127fast