NIR ALU Instructions — The Mesa 3D Graphics Library latest documentation

# NIR ALU Instructions

ALU instructions represent simple operations, such as addition, multiplication, comparison, etc., that take a certain number of arguments and return a result that only depends on the arguments. ALU instructions in NIR must be pure in the sense that they have no side effect and that identical inputs yields an identical output. A good rule of thumb is that only things which can be constant folded should be ALU operations. If it can’t be constant folded, then it should probably be an intrinsic instead.

Each ALU instruction has an opcode, which is a member of the `nir_op` enum, that describes what it does as well as how many arguments it takes. Associated with each opcode is an metadata structure, `nir_op_info`, which shows how many arguments the opcode takes, information about data types, and algebraic properties such as associativity and commutativity. The info structure for each opcode may be accessed through a global `nir_op_infos` array that’s indexed by the opcode.

ALU operations are typeless, meaning that they’re only defined to convert a certain bit-pattern input to another bit-pattern output. The only concrete notion of types for a NIR SSA value or register is that each value has a number of vector components and a bit-size. How that data is interpreted is entirely controlled by the opcode. NIR doesn’t have opcodes for `intBitsToFloat()` and friends because they are implicit.

Even though ALU operations are typeless, each opcode also has an “ALU type” metadata for each of the sources and the destination which can be floating-point, boolean, integer, or unsigned integer. The ALU type mainly helps back-ends which want to handle all conversion instructions, for instance, in a single switch case. They’re also important when a back-end requests the absolute value, negate, and saturate modifiers (not used by core NIR). In that case, modifiers are interpreted with respect to the ALU type on the source or destination of the instruction. In addition, if an operation takes a boolean argument, then the argument may be assumed to be either `0` for false or `~0` (a.k.a `-1`) for true even if it is not a 1-bit value. If an operation’s result has a boolean type, then it may only produce only `0` or `~0`.

Most of the common ALU ops in NIR operate per-component, meaning that the operation is defined by what it does on a single scalar value and, when performed on vectors, it performs the same operation on each component. Things like add, multiply, etc. fall into this category. Per-component operations naturally scale to as many components as necessary. Non-per-component ALU ops are things like `vec4` or `pack_64_2x32` where any given component in the result value may be a combination of any component in any source. These ops have a number of destination components and a number of components required by each source which is fixed by the opcode.

While most instruction types in NIR require vector sizes to perfectly match on inputs and outputs, ALU instruction sources have an additional `nir_alu_src.swizzle` field which allows them to act on vectors which are not the native vector size of the instruction. This is ideal for hardware with a native data type of `vec4` but also means that ALU instructions are often used (and required) for packing/unpacking vectors for use in other instruction types like intrinsics or texture ops.

struct nir_op_info
  const char *name

    Name of the NIR ALU opcode

  uint8_t num_inputs

    Number of inputs (sources)

  uint8_t output_size

    The number of components in the output

    If non-zero, this is the size of the output and input sizes are explicitly given; swizzle and writemask are still in effect, but if the output component is masked out, then the input component may still be in use.

    If zero, the opcode acts in the standard, per-component manner; the operation is performed on each component (except the ones that are masked out) with the input being taken from the input swizzle for that component.

    The size of some of the inputs may be given (i.e. non-zero) even though output_size is zero; in that case, the inputs with a zero size act per-component, while the inputs with non-zero size don’t.

  nir_alu_type output_type

    The type of vector that the instruction outputs.

  uint8_t input_sizes[NIR_ALU_MAX_INPUTS]

    The number of components in each input

    See nir_op_infos::output_size for more detail about the relationship between input and output sizes.

  nir_alu_type input_types[NIR_ALU_MAX_INPUTS]

    The type of vector that each input takes.

  nir_op_algebraic_property algebraic_properties

    Algebraic properties of this opcode

  bool is_conversion

    Whether this represents a numeric conversion opcode

extern const nir_op_info nir_op_infos[nir_num_opcodes]

  Metadata for each nir_op, indexed by opcode

struct nir_alu_instr
  nir_instr instr

    Base instruction

  nir_def def

    Destination

  nir_op op

    Opcode

  bool no_signed_wrap

    Indicates that this instruction doese not cause signed integer wrapping to occur, in the form of overflow or underflow.

  bool no_unsigned_wrap

    Indicates that this instruction does not cause unsigned integer wrapping to occur, in the form of overflow or underflow.

  uint32_t fp_math_ctrl

    The float controls bit float_controls2 cares about. The float_controls1 bits that have no float_controls2 equivalent (rounding mode and denorm handling) remain in the execution mode only.

  nir_alu_src src[]

    Sources

    The size of the array is given by `nir_op_info.num_inputs`.

struct nir_alu_src
  nir_src src

    Base source

  uint8_t swizzle[NIR_MAX_VEC_COMPONENTS]

    For each input component, says which component of the register it is chosen from.

    Note that which elements of the swizzle are used and which are ignored are based on the write mask for most opcodes - for example, a statement like “foo.xzw = bar.zyx” would have a writemask of 1101b and a swizzle of {2, 1, x, 0} where x means “don’t care.”

## NIR ALU Opcode Reference:

mov(uint[N] src0) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_mov(nir_builder*, nir_def *src0)

fcanonicalize(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_fcanonicalize(nir_builder*, nir_def *src0)

ineg(int[N] src0) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 == u_intN_min(bit_size) ? src0 : -src0

  Builder function:

  nir_def *nir_ineg(nir_builder*, nir_def *src0)

fneg(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      -src0

  Builder function:

  nir_def *nir_fneg(nir_builder*, nir_def *src0)

inot(int[N] src0) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Invert every bit of the integer

  Constant-folding:

      ~src0

  Builder function:

  nir_def *nir_inot(nir_builder*, nir_def *src0)

fsign(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Roughly implements the OpenGL / Vulkan rules for `sign(float)`. The `GLSL.std.450 FSign` instruction is defined as:

  > Result is 1.0 if x > 0, 0.0 if x = 0, or -1.0 if x < 0.

  If the source is equal to zero, there is a preference for the result to have the same sign, but this is not required (it is required by OpenCL). If the source is not a number, there is a preference for the result to be +0.0, but this is not required (it is required by OpenCL). If the source is not a number, and the result is not +0.0, the result should definitely not be NaN.

  The values returned for constant folding match the behavior required by OpenCL.

  Constant-folding:

      bit_size == 64 ? (isnan(src0) ? 0.0  : ((src0 == 0.0 ) ? src0 : (src0 > 0.0 ) ? 1.0  : -1.0 )) : (isnan(src0) ? 0.0f : ((src0 == 0.0f) ? src0 : (src0 > 0.0f) ? 1.0f : -1.0f))

  Builder function:

  nir_def *nir_fsign(nir_builder*, nir_def *src0)

isign(int[N] src0) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 == 0) ? 0 : ((src0 > 0) ? 1 : -1)

  Builder function:

  nir_def *nir_isign(nir_builder*, nir_def *src0)

iabs(int[N] src0) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 < 0) ? -src0 : src0

  Builder function:

  nir_def *nir_iabs(nir_builder*, nir_def *src0)

fabs(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      fabs(src0)

  Builder function:

  nir_def *nir_fabs(nir_builder*, nir_def *src0)

fsat(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      util_min_num(util_max_num(src0, 0.0), 1.0)

  Builder function:

  nir_def *nir_fsat(nir_builder*, nir_def *src0)

frcp(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      bit_size == 64 ? 1.0 / src0 : 1.0f / src0

  Builder function:

  nir_def *nir_frcp(nir_builder*, nir_def *src0)

frsq(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      bit_size == 64 ? 1.0 / sqrt(src0) : 1.0f / sqrtf(src0)

  Builder function:

  nir_def *nir_frsq(nir_builder*, nir_def *src0)

fsqrt(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      bit_size == 64 ? sqrt(src0) : sqrtf(src0)

  Builder function:

  nir_def *nir_fsqrt(nir_builder*, nir_def *src0)

fexp2(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      exp2f(src0)

  Builder function:

  nir_def *nir_fexp2(nir_builder*, nir_def *src0)

flog2(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      log2f(src0)

  Builder function:

  nir_def *nir_flog2(nir_builder*, nir_def *src0)

i2f16(int[N] src0) → float16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_i2f16(nir_builder*, nir_def *src0)

i2f32(int[N] src0) → float32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_i2f32(nir_builder*, nir_def *src0)

i2f64(int[N] src0) → float64[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_i2f64(nir_builder*, nir_def *src0)

i2i1(int[N] src0) → int1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_i2i1(nir_builder*, nir_def *src0)

i2i8(int[N] src0) → int8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_i2i8(nir_builder*, nir_def *src0)

i2i16(int[N] src0) → int16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_i2i16(nir_builder*, nir_def *src0)

i2i32(int[N] src0) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_i2i32(nir_builder*, nir_def *src0)

i2i64(int[N] src0) → int64[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_i2i64(nir_builder*, nir_def *src0)

u2f16(uint[N] src0) → float16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_u2f16(nir_builder*, nir_def *src0)

u2f32(uint[N] src0) → float32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_u2f32(nir_builder*, nir_def *src0)

u2f64(uint[N] src0) → float64[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_u2f64(nir_builder*, nir_def *src0)

u2u1(uint[N] src0) → uint1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_u2u1(nir_builder*, nir_def *src0)

u2u8(uint[N] src0) → uint8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_u2u8(nir_builder*, nir_def *src0)

u2u16(uint[N] src0) → uint16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_u2u16(nir_builder*, nir_def *src0)

u2u32(uint[N] src0) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_u2u32(nir_builder*, nir_def *src0)

u2u64(uint[N] src0) → uint64[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_u2u64(nir_builder*, nir_def *src0)

f2i1(float[N] src0) → int1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if (isnan(src0) || src0 < u_intN_min(1) || src0 >= 1.0) {
         poison = true;
         dst = 0;
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2i1(nir_builder*, nir_def *src0)

f2i8(float[N] src0) → int8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if (isnan(src0) || src0 < u_intN_min(8) || src0 >= 128.0) {
         poison = true;
         dst = 0;
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2i8(nir_builder*, nir_def *src0)

f2i16(float[N] src0) → int16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if (isnan(src0) || src0 < u_intN_min(16) || src0 >= 32768.0) {
         poison = true;
         dst = 0;
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2i16(nir_builder*, nir_def *src0)

f2i32(float[N] src0) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if (isnan(src0) || src0 < u_intN_min(32) || src0 >= 2147483648.0) {
         poison = true;
         dst = 0;
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2i32(nir_builder*, nir_def *src0)

f2i64(float[N] src0) → int64[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if (isnan(src0) || src0 < u_intN_min(64) || src0 >= 9223372036854775808.0) {
         poison = true;
         dst = 0;
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2i64(nir_builder*, nir_def *src0)

f2u1(float[N] src0) → uint1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if (isnan(src0) || src0 < 0.0 || src0 >= 2.0) {
         poison = true;
         dst = 0;
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2u1(nir_builder*, nir_def *src0)

f2u8(float[N] src0) → uint8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if (isnan(src0) || src0 < 0.0 || src0 >= 256.0) {
         poison = true;
         dst = 0;
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2u8(nir_builder*, nir_def *src0)

f2u16(float[N] src0) → uint16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if (isnan(src0) || src0 < 0.0 || src0 >= 65536.0) {
         poison = true;
         dst = 0;
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2u16(nir_builder*, nir_def *src0)

f2u32(float[N] src0) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if (isnan(src0) || src0 < 0.0 || src0 >= 4294967296.0) {
         poison = true;
         dst = 0;
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2u32(nir_builder*, nir_def *src0)

f2u64(float[N] src0) → uint64[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if (isnan(src0) || src0 < 0.0 || src0 >= 18446744073709551616.0) {
         poison = true;
         dst = 0;
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2u64(nir_builder*, nir_def *src0)

f2f16_rtne(float[N] src0) → float16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if (bit_size > 32) {
         dst = _mesa_half_to_float(_mesa_double_to_float16_rtne(src0));
      } else if (bit_size > 16) {
         dst = _mesa_half_to_float(_mesa_float_to_float16_rtne(src0));
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2f16_rtne(nir_builder*, nir_def *src0)

f2f16_rtz(float[N] src0) → float16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if (bit_size > 32) {
         dst = _mesa_half_to_float(_mesa_double_to_float16_rtz(src0));
      } else if (bit_size > 16) {
         dst = _mesa_half_to_float(_mesa_float_to_float16_rtz(src0));
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2f16_rtz(nir_builder*, nir_def *src0)

f2f16_ru(float[N] src0) → float16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if (bit_size > 16) {
         dst = _mesa_half_to_float(_mesa_float_to_float16_ru(src0));
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2f16_ru(nir_builder*, nir_def *src0)

f2f16_rd(float[N] src0) → float16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if (bit_size > 16) {
         dst = _mesa_half_to_float(_mesa_float_to_float16_rd(src0));
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2f16_rd(nir_builder*, nir_def *src0)

f2f16(float[N] src0) → float16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if (bit_size > 32) {
         if (nir_is_rounding_mode_rtz(execution_mode, 16))
            dst = _mesa_half_to_float(_mesa_double_to_float16_rtz(src0));
         else
            dst = _mesa_half_to_float(_mesa_double_to_float16_rtne(src0));
      } else if (bit_size > 16) {
         if (nir_is_rounding_mode_rtz(execution_mode, 16))
            dst = _mesa_half_to_float(_mesa_float_to_float16_rtz(src0));
         else
            dst = _mesa_half_to_float(_mesa_float_to_float16_rtne(src0));
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2f16(nir_builder*, nir_def *src0)

f2f32(float[N] src0) → float32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if (bit_size > 32 && nir_is_rounding_mode_rtz(execution_mode, 32)) {
         dst = _mesa_double_to_float_rtz(src0);
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2f32(nir_builder*, nir_def *src0)

f2f64(float[N] src0) → float64[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_f2f64(nir_builder*, nir_def *src0)

b2f16(bool[N] src0) → float16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_b2f16(nir_builder*, nir_def *src0)

b2f32(bool[N] src0) → float32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_b2f32(nir_builder*, nir_def *src0)

b2f64(bool[N] src0) → float64[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_b2f64(nir_builder*, nir_def *src0)

b2i1(bool[N] src0) → int1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_b2i1(nir_builder*, nir_def *src0)

b2i8(bool[N] src0) → int8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_b2i8(nir_builder*, nir_def *src0)

b2i16(bool[N] src0) → int16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_b2i16(nir_builder*, nir_def *src0)

b2i32(bool[N] src0) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_b2i32(nir_builder*, nir_def *src0)

b2i64(bool[N] src0) → int64[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_b2i64(nir_builder*, nir_def *src0)

b2b1(bool[N] src0) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 != 0

  Builder function:

  nir_def *nir_b2b1(nir_builder*, nir_def *src0)

b2b8(bool[N] src0) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 != 0

  Builder function:

  nir_def *nir_b2b8(nir_builder*, nir_def *src0)

b2b16(bool[N] src0) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 != 0

  Builder function:

  nir_def *nir_b2b16(nir_builder*, nir_def *src0)

b2b32(bool[N] src0) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 != 0

  Builder function:

  nir_def *nir_b2b32(nir_builder*, nir_def *src0)

f2fmp(float32[N] src0) → float16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Special opcode that is the same as `f2f16` except that it is safe to remove it if the result is immediately converted back to 32 bits again. This is generated as part of the precision lowering pass. `mp` stands for medium precision.

  Constant-folding:

      if (bit_size > 32) {
         if (nir_is_rounding_mode_rtz(execution_mode, 16))
            dst = _mesa_half_to_float(_mesa_double_to_float16_rtz(src0));
         else
            dst = _mesa_half_to_float(_mesa_double_to_float16_rtne(src0));
      } else if (bit_size > 16) {
         if (nir_is_rounding_mode_rtz(execution_mode, 16))
            dst = _mesa_half_to_float(_mesa_float_to_float16_rtz(src0));
         else
            dst = _mesa_half_to_float(_mesa_float_to_float16_rtne(src0));
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2fmp(nir_builder*, nir_def *src0)

i2imp(int32[N] src0) → int16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Special opcode that is the same as `i2i16` except that it is safe to remove it if the result is immediately converted back to 32 bits again. This is generated as part of the precision lowering pass. `mp` stands for medium precision.

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_i2imp(nir_builder*, nir_def *src0)

f2imp(float32[N] src0) → int16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Special opcode that is the same as `f2i16` except that it is safe to remove it if the result is immediately converted back to 32 bits again. This is generated as part of the precision lowering pass. `mp` stands for medium precision.

  Constant-folding:

      if (isnan(src0) || src0 < u_intN_min(16) || src0 >= 32768.0) {
         poison = true;
         dst = 0;
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2imp(nir_builder*, nir_def *src0)

f2ump(float32[N] src0) → uint16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Special opcode that is the same as `f2u16` except that it is safe to remove it if the result is immediately converted back to 32 bits again. This is generated as part of the precision lowering pass. `mp` stands for medium precision.

  Constant-folding:

      if (isnan(src0) || src0 < 0.0 || src0 >= 65536.0) {
         poison = true;
         dst = 0;
      } else {
         dst = src0;
      }

  Builder function:

  nir_def *nir_f2ump(nir_builder*, nir_def *src0)

i2fmp(int32[N] src0) → float16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Special opcode that is the same as `i2f16` except that it is safe to remove it if the result is immediately converted back to 32 bits again. This is generated as part of the precision lowering pass. `mp` stands for medium precision.

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_i2fmp(nir_builder*, nir_def *src0)

u2fmp(uint32[N] src0) → float16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Special opcode that is the same as `u2f16` except that it is safe to remove it if the result is immediately converted back to 32 bits again. This is generated as part of the precision lowering pass. `mp` stands for medium precision.

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_u2fmp(nir_builder*, nir_def *src0)

f2i32_rtne(float32[N] src0) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (int32_t)_mesa_roundevenf(src0)

  Builder function:

  nir_def *nir_f2i32_rtne(nir_builder*, nir_def *src0)

f2u8_sat(float[N] src0) → uint8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Convert float to uint with clamping to uint range. NaN becomes zero.

  Constant-folding:

      (uint8_t)fmin(fmax(src0, 0.0), (double)u_uintN_max(8))

  Builder function:

  nir_def *nir_f2u8_sat(nir_builder*, nir_def *src0)

f2i8_sat(float[N] src0) → int8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Convert float to int with clamping to int range. NaN becomes zero.

  Constant-folding:

      (int8_t) isnan(src0) ? 0.0 : fmin(fmax(src0, (double)u_intN_min(8)), (double)u_intN_max(8))

  Builder function:

  nir_def *nir_f2i8_sat(nir_builder*, nir_def *src0)

f2u16_sat(float[N] src0) → uint16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Convert float to uint with clamping to uint range. NaN becomes zero.

  Constant-folding:

      (uint16_t)fmin(fmax(src0, 0.0), (double)u_uintN_max(16))

  Builder function:

  nir_def *nir_f2u16_sat(nir_builder*, nir_def *src0)

f2i16_sat(float[N] src0) → int16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Convert float to int with clamping to int range. NaN becomes zero.

  Constant-folding:

      (int16_t) isnan(src0) ? 0.0 : fmin(fmax(src0, (double)u_intN_min(16)), (double)u_intN_max(16))

  Builder function:

  nir_def *nir_f2i16_sat(nir_builder*, nir_def *src0)

f2u32_sat(float[N] src0) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Convert float to uint with clamping to uint range. NaN becomes zero.

  Constant-folding:

      (uint32_t)fmin(fmax(src0, 0.0), (double)u_uintN_max(32))

  Builder function:

  nir_def *nir_f2u32_sat(nir_builder*, nir_def *src0)

f2i32_sat(float[N] src0) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Convert float to int with clamping to int range. NaN becomes zero.

  Constant-folding:

      (int32_t) isnan(src0) ? 0.0 : fmin(fmax(src0, (double)u_intN_min(32)), (double)u_intN_max(32))

  Builder function:

  nir_def *nir_f2i32_sat(nir_builder*, nir_def *src0)

ftrunc(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      bit_size == 64 ? trunc(src0) : truncf(src0)

  Builder function:

  nir_def *nir_ftrunc(nir_builder*, nir_def *src0)

fceil(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      bit_size == 64 ? ceil(src0) : ceilf(src0)

  Builder function:

  nir_def *nir_fceil(nir_builder*, nir_def *src0)

ffloor(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      bit_size == 64 ? floor(src0) : floorf(src0)

  Builder function:

  nir_def *nir_ffloor(nir_builder*, nir_def *src0)

ffract(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 - (bit_size == 64 ? floor(src0) : floorf(src0))

  Builder function:

  nir_def *nir_ffract(nir_builder*, nir_def *src0)

fround_even(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      bit_size == 64 ? _mesa_roundeven(src0) : _mesa_roundevenf(src0)

  Builder function:

  nir_def *nir_fround_even(nir_builder*, nir_def *src0)

fquantize2f16(float32[N] src0) → float32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (fabsf(src0) < ldexpf(1.0, -14)) ? copysignf(0.0f, src0) : _mesa_half_to_float(_mesa_float_to_half(src0))

  Builder function:

  nir_def *nir_fquantize2f16(nir_builder*, nir_def *src0)

fsin(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      bit_size == 64 ? sin(src0) : sinf(src0)

  Builder function:

  nir_def *nir_fsin(nir_builder*, nir_def *src0)

fcos(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      bit_size == 64 ? cos(src0) : cosf(src0)

  Builder function:

  nir_def *nir_fcos(nir_builder*, nir_def *src0)

frexp_exp(float[N] src0) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      frexp(src0, &dst);

  Builder function:

  nir_def *nir_frexp_exp(nir_builder*, nir_def *src0)

frexp_sig(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      int n; dst = frexp(src0, &n);

  Builder function:

  nir_def *nir_frexp_sig(nir_builder*, nir_def *src0)

pack_snorm_2x16(float[2] src0) → uint32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = (uint32_t) pack_snorm_1x16(src0.x);
      dst.x |= ((uint32_t) pack_snorm_1x16(src0.y)) << 16;

  Builder function:

  nir_def *nir_pack_snorm_2x16(nir_builder*, nir_def *src0)

pack_snorm_4x8(float32[4] src0) → uint32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = (uint32_t) pack_snorm_1x8(src0.x);
      dst.x |= ((uint32_t) pack_snorm_1x8(src0.y)) << 8;
      dst.x |= ((uint32_t) pack_snorm_1x8(src0.z)) << 16;
      dst.x |= ((uint32_t) pack_snorm_1x8(src0.w)) << 24;

  Builder function:

  nir_def *nir_pack_snorm_4x8(nir_builder*, nir_def *src0)

pack_unorm_2x16(float[2] src0) → uint32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = (uint32_t) pack_unorm_1x16(src0.x);
      dst.x |= ((uint32_t) pack_unorm_1x16(src0.y)) << 16;

  Builder function:

  nir_def *nir_pack_unorm_2x16(nir_builder*, nir_def *src0)

pack_unorm_4x8(float32[4] src0) → uint32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = (uint32_t) pack_unorm_1x8(src0.x);
      dst.x |= ((uint32_t) pack_unorm_1x8(src0.y)) << 8;
      dst.x |= ((uint32_t) pack_unorm_1x8(src0.z)) << 16;
      dst.x |= ((uint32_t) pack_unorm_1x8(src0.w)) << 24;

  Builder function:

  nir_def *nir_pack_unorm_4x8(nir_builder*, nir_def *src0)

pack_half_2x16(float32[2] src0) → uint32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = (uint32_t) pack_half_1x16(src0.x);
      dst.x |= ((uint32_t) pack_half_1x16(src0.y)) << 16;

  Builder function:

  nir_def *nir_pack_half_2x16(nir_builder*, nir_def *src0)

unpack_snorm_2x16(uint32[1] src0) → float32[2]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = unpack_snorm_1x16((uint16_t)(src0.x & 0xffff));
      dst.y = unpack_snorm_1x16((uint16_t)(src0.x >> 16));

  Builder function:

  nir_def *nir_unpack_snorm_2x16(nir_builder*, nir_def *src0)

unpack_snorm_4x8(uint32[1] src0) → float32[4]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = unpack_snorm_1x8((uint8_t)(src0.x & 0xff));
      dst.y = unpack_snorm_1x8((uint8_t)((src0.x >> 8) & 0xff));
      dst.z = unpack_snorm_1x8((uint8_t)((src0.x >> 16) & 0xff));
      dst.w = unpack_snorm_1x8((uint8_t)(src0.x >> 24));

  Builder function:

  nir_def *nir_unpack_snorm_4x8(nir_builder*, nir_def *src0)

unpack_unorm_2x16(uint32[1] src0) → float32[2]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = unpack_unorm_1x16((uint16_t)(src0.x & 0xffff));
      dst.y = unpack_unorm_1x16((uint16_t)(src0.x >> 16));

  Builder function:

  nir_def *nir_unpack_unorm_2x16(nir_builder*, nir_def *src0)

unpack_unorm_4x8(uint32[1] src0) → float32[4]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = unpack_unorm_1x8((uint8_t)(src0.x & 0xff));
      dst.y = unpack_unorm_1x8((uint8_t)((src0.x >> 8) & 0xff));
      dst.z = unpack_unorm_1x8((uint8_t)((src0.x >> 16) & 0xff));
      dst.w = unpack_unorm_1x8((uint8_t)(src0.x >> 24));

  Builder function:

  nir_def *nir_unpack_unorm_4x8(nir_builder*, nir_def *src0)

pack_uint_2x16(uint32[2] src0) → uint32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Description: Convert two unsigned integers into a packed unsigned short (clamp is applied).

  Constant-folding:

      dst.x = _mesa_unsigned_to_unsigned(src0.x, 16);
      dst.x |= _mesa_unsigned_to_unsigned(src0.y, 16) << 16;

  Builder function:

  nir_def *nir_pack_uint_2x16(nir_builder*, nir_def *src0)

pack_sint_2x16(int32[2] src0) → int32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Description: Convert two signed integers into a packed signed short (clamp is applied).

  Constant-folding:

      dst.x = _mesa_signed_to_signed(src0.x, 16) & 0xffff;
      dst.x |= _mesa_signed_to_signed(src0.y, 16) << 16;

  Builder function:

  nir_def *nir_pack_sint_2x16(nir_builder*, nir_def *src0)

pack_uvec2_to_uint(uint32[2] src0) → uint32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = (src0.x & 0xffff) | (src0.y << 16);

  Builder function:

  nir_def *nir_pack_uvec2_to_uint(nir_builder*, nir_def *src0)

pack_uvec4_to_uint(uint32[4] src0) → uint32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = ((src0.x & 0xff) <<  0) |
              ((src0.y & 0xff) <<  8) |
              ((src0.z & 0xff) << 16) |
              ((src0.w & 0xff) << 24);

  Builder function:

  nir_def *nir_pack_uvec4_to_uint(nir_builder*, nir_def *src0)

pack_32_4x8(uint8[4] src0) → uint32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = src0.x | ((uint32_t)src0.y << 8) | ((uint32_t)src0.z << 16) | ((uint32_t)src0.w << 24);

  Builder function:

  nir_def *nir_pack_32_4x8(nir_builder*, nir_def *src0)

pack_32_2x16(uint16[2] src0) → uint32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = src0.x | ((uint32_t)src0.y << 16);

  Builder function:

  nir_def *nir_pack_32_2x16(nir_builder*, nir_def *src0)

pack_64_2x32(uint32[2] src0) → uint64[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = src0.x | ((uint64_t)src0.y << 32);

  Builder function:

  nir_def *nir_pack_64_2x32(nir_builder*, nir_def *src0)

pack_64_4x16(uint16[4] src0) → uint64[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = src0.x | ((uint64_t)src0.y << 16) | ((uint64_t)src0.z << 32) | ((uint64_t)src0.w << 48);

  Builder function:

  nir_def *nir_pack_64_4x16(nir_builder*, nir_def *src0)

unpack_64_2x32(uint64[1] src0) → uint32[2]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = src0.x; dst.y = src0.x >> 32;

  Builder function:

  nir_def *nir_unpack_64_2x32(nir_builder*, nir_def *src0)

unpack_64_4x16(uint64[1] src0) → uint16[4]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = src0.x; dst.y = src0.x >> 16; dst.z = src0.x >> 32; dst.w = src0.x >> 48;

  Builder function:

  nir_def *nir_unpack_64_4x16(nir_builder*, nir_def *src0)

unpack_32_2x16(uint32[1] src0) → uint16[2]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = src0.x; dst.y = src0.x >> 16;

  Builder function:

  nir_def *nir_unpack_32_2x16(nir_builder*, nir_def *src0)

unpack_32_4x8(uint32[1] src0) → uint8[4]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = src0.x; dst.y = src0.x >> 8; dst.z = src0.x >> 16; dst.w = src0.x >> 24;

  Builder function:

  nir_def *nir_unpack_32_4x8(nir_builder*, nir_def *src0)

unpack_half_2x16(uint32[1] src0) → float32[2]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = unpack_half_1x16((uint16_t)(src0.x & 0xffff), nir_is_denorm_flush_to_zero(execution_mode, 16));
      dst.y = unpack_half_1x16((uint16_t)(src0.x >> 16), nir_is_denorm_flush_to_zero(execution_mode, 16));

  Builder function:

  nir_def *nir_unpack_half_2x16(nir_builder*, nir_def *src0)

unpack_32_2x16_split_x(uint32[N] src0) → uint16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_unpack_32_2x16_split_x(nir_builder*, nir_def *src0)

unpack_32_2x16_split_y(uint32[N] src0) → uint16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 >> 16

  Builder function:

  nir_def *nir_unpack_32_2x16_split_y(nir_builder*, nir_def *src0)

unpack_64_2x32_split_x(uint64[N] src0) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0

  Builder function:

  nir_def *nir_unpack_64_2x32_split_x(nir_builder*, nir_def *src0)

unpack_64_2x32_split_y(uint64[N] src0) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 >> 32

  Builder function:

  nir_def *nir_unpack_64_2x32_split_y(nir_builder*, nir_def *src0)

bitfield_reverse(uint[N] src0) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      /* we're not winning any awards for speed here, but that's ok */
      dst = 0;
      for (unsigned bit = 0; bit < bit_size; bit++)
         dst |= ((src0 >> bit) & 1) << ((bit_size - 1) - bit);

  Builder function:

  nir_def *nir_bitfield_reverse(nir_builder*, nir_def *src0)

bit_count(uint[N] src0) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      dst = 0;
      for (unsigned bit = 0; bit < bit_size; bit++) {
         if ((src0 >> bit) & 1)
            dst++;
      }

  Builder function:

  nir_def *nir_bit_count(nir_builder*, nir_def *src0)

ufind_msb(uint[N] src0) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      dst = -1;
      for (int bit = bit_size - 1; bit >= 0; bit--) {
         if ((src0 >> bit) & 1) {
            dst = bit;
            break;
         }
      }

  Builder function:

  nir_def *nir_ufind_msb(nir_builder*, nir_def *src0)

ufind_msb_rev(uint[N] src0) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      dst = -1;
      for (int bit = 0; bit < bit_size; bit++) {
         if ((src0 << bit) & 0x80000000) {
            dst = bit;
            break;
         }
      }

  Builder function:

  nir_def *nir_ufind_msb_rev(nir_builder*, nir_def *src0)

uclz(uint32[N] src0) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      int bit;
      for (bit = bit_size - 1; bit >= 0; bit--) {
         if ((src0 & (1u << bit)) != 0)
            break;
      }
      dst = (unsigned)(bit_size - bit - 1);

  Builder function:

  nir_def *nir_uclz(nir_builder*, nir_def *src0)

ifind_msb(int32[N] src0) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      dst = -1;
      for (int bit = bit_size - 1; bit >= 0; bit--) {
         /* If src0 < 0, we're looking for the first 0 bit.
          * if src0 >= 0, we're looking for the first 1 bit.
          */
         if ((((src0 >> bit) & 1) && (src0 >= 0)) ||
            (!((src0 >> bit) & 1) && (src0 < 0))) {
            dst = bit;
            break;
         }
      }

  Builder function:

  nir_def *nir_ifind_msb(nir_builder*, nir_def *src0)

ifind_msb_rev(int32[N] src0) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      dst = -1;
      /* We are looking for the highest bit that's not the same as the sign bit. */
      uint32_t sign = src0 & 0x80000000u;
      for (int bit = 0; bit < 32; bit++) {
         if ((((uint32_t)src0 << bit) & 0x80000000u) != sign) {
            dst = bit;
            break;
         }
      }

  Builder function:

  nir_def *nir_ifind_msb_rev(nir_builder*, nir_def *src0)

find_lsb(int[N] src0) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      dst = -1;
      for (unsigned bit = 0; bit < bit_size; bit++) {
         if ((src0 >> bit) & 1) {
            dst = bit;
            break;
         }
      }

  Builder function:

  nir_def *nir_find_lsb(nir_builder*, nir_def *src0)

fsum2(float[2] src0) → float[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Description: Sum of vector components

  Constant-folding:

      ((src0.x) + (src0.y))

  Builder function:

  nir_def *nir_fsum2(nir_builder*, nir_def *src0)

fsum3(float[3] src0) → float[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Description: Sum of vector components

  Constant-folding:

      ((src0.x) + (src0.y) + (src0.z))

  Builder function:

  nir_def *nir_fsum3(nir_builder*, nir_def *src0)

fsum4(float[4] src0) → float[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Description: Sum of vector components

  Constant-folding:

      ((src0.x) + (src0.y) + (src0.z) + (src0.w))

  Builder function:

  nir_def *nir_fsum4(nir_builder*, nir_def *src0)

fadd(float[N] src0, float[N] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      if (nir_is_rounding_mode_rtz(execution_mode, bit_size)) {
         if (bit_size == 64)
            dst = _mesa_double_add_rtz(src0, src1);
         else
            dst = _mesa_double_to_float_rtz((double)src0 + (double)src1);
      } else {
         dst = src0 + src1;
      }

  Builder function:

  nir_def *nir_fadd(nir_builder*, nir_def *src0, nir_def *src1)

iadd(int[N] src0, int[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      (uint64_t)src0 + (uint64_t)src1

  Builder function:

  nir_def *nir_iadd(nir_builder*, nir_def *src0, nir_def *src1)

iadd_sat(int[N] src0, int[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      util_add_check_overflow({dest_type}, src0, src1) ?
         (src1 < 0 ? u_intN_min(bit_size) : u_intN_max(bit_size)) : (src0 + src1)

  Builder function:

  nir_def *nir_iadd_sat(nir_builder*, nir_def *src0, nir_def *src1)

uadd_sat(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      util_add_check_overflow({dest_type}, src0, src1) ? u_uintN_max(sizeof(src0) * 8) : (src0 + src1)

  Builder function:

  nir_def *nir_uadd_sat(nir_builder*, nir_def *src0, nir_def *src1)

isub_sat(int[N] src0, int[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      util_sub_check_overflow({dest_type}, src0, src1) ?
         (src1 < 0 ? u_intN_max(bit_size) : u_intN_min(bit_size)) : (src0 - src1)

  Builder function:

  nir_def *nir_isub_sat(nir_builder*, nir_def *src0, nir_def *src1)

usub_sat(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 < src1 ? 0 : src0 - src1

  Builder function:

  nir_def *nir_usub_sat(nir_builder*, nir_def *src0, nir_def *src1)

uadd64_32(uint32[1] src0, uint32[1] src1, uint32[1] src2) → uint32[2]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      uint64_t sum = ((uint64_t)src1.x << 32 | (uint64_t)src0.x) + (uint64_t)src2.x;
      dst.x = sum & 0xffffffff;
      dst.y = sum >> 32;

  Builder function:

  nir_def *nir_uadd64_32(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

umad64_32(uint32[1] src0, uint32[1] src1, uint32[1] src2, uint32[1] src3) → uint32[2]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      uint64_t sum = ((uint64_t)src0.x * (uint64_t)src1.x) + ((uint64_t)src3.x << 32 | (uint64_t)src2.x);
      dst.x = sum & 0xffffffff;
      dst.y = sum >> 32;

  Builder function:

  nir_def *nir_umad64_32(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2, nir_def *src3)

fsub(float[N] src0, float[N] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if (nir_is_rounding_mode_rtz(execution_mode, bit_size)) {
         if (bit_size == 64)
            dst = _mesa_double_sub_rtz(src0, src1);
         else
            dst = _mesa_double_to_float_rtz((double)src0 - (double)src1);
      } else {
         dst = src0 - src1;
      }

  Builder function:

  nir_def *nir_fsub(nir_builder*, nir_def *src0, nir_def *src1)

isub(int[N] src0, int[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (uint64_t)src0 - (uint64_t)src1

  Builder function:

  nir_def *nir_isub(nir_builder*, nir_def *src0, nir_def *src1)

uabs_isub(int[N] src0, int[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src1 > src0 ? (uint64_t) src1 - (uint64_t) src0
                  : (uint64_t) src0 - (uint64_t) src1

  Builder function:

  nir_def *nir_uabs_isub(nir_builder*, nir_def *src0, nir_def *src1)

uabs_usub(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src1 > src0) ? (src1 - src0) : (src0 - src1)

  Builder function:

  nir_def *nir_uabs_usub(nir_builder*, nir_def *src0, nir_def *src1)

fmul(float[N] src0, float[N] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      if (nir_is_rounding_mode_rtz(execution_mode, bit_size)) {
         if (bit_size == 64)
            dst = _mesa_double_mul_rtz(src0, src1);
         else
            dst = _mesa_double_to_float_rtz((double)src0 * (double)src1);
      } else {
         dst = src0 * src1;
      }

  Builder function:

  nir_def *nir_fmul(nir_builder*, nir_def *src0, nir_def *src1)

fmul_rtz(float32[N] src0, float32[N] src1) → float32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      dst = _mesa_double_to_float_rtz((double)src0 * (double)src1);

  Builder function:

  nir_def *nir_fmul_rtz(nir_builder*, nir_def *src0, nir_def *src1)

fmulz(float32[N] src0, float32[N] src1) → float32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Description: Unlike `fmul`, anything (even infinity or NaN) multiplied by +/-0.0 is always +0.0.

  Constant-folding:

      if (src0 == 0.0 || src1 == 0.0)
         dst = 0.0;
      else if (nir_is_rounding_mode_rtz(execution_mode, 32))
         dst = _mesa_double_to_float_rtz((double)src0 * (double)src1);
      else
         dst = src0 * src1;

  Builder function:

  nir_def *nir_fmulz(nir_builder*, nir_def *src0, nir_def *src1)

imul(int[N] src0, int[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Description: Low 32-bits of signed/unsigned integer multiply

  Constant-folding:

      /* Use 64-bit multiplies to prevent overflow of signed arithmetic */
      dst = (uint64_t)src0 * (uint64_t)src1;

  Builder function:

  nir_def *nir_imul(nir_builder*, nir_def *src0, nir_def *src1)

imul_2x32_64(int32[N] src0, int32[N] src1) → int64[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Description: Multiply signed 32-bit integers, 64-bit result

  Constant-folding:

      (int64_t)src0 * (int64_t)src1

  Builder function:

  nir_def *nir_imul_2x32_64(nir_builder*, nir_def *src0, nir_def *src1)

umul_2x32_64(uint32[N] src0, uint32[N] src1) → uint64[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Description: Multiply unsigned 32-bit integers, 64-bit result

  Constant-folding:

      (uint64_t)src0 * (uint64_t)src1

  Builder function:

  nir_def *nir_umul_2x32_64(nir_builder*, nir_def *src0, nir_def *src1)

imul_high(int[N] src0, int[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Description: High 32-bits of signed integer multiply

  Constant-folding:

      if (bit_size == 64) {
         /* We need to do a full 128-bit x 128-bit multiply in order for the sign
          * extension to work properly.  The casts are kind-of annoying but needed
          * to prevent compiler warnings.
          */
         uint32_t src0_u32[4] = {
            src0,
            (int64_t)src0 >> 32,
            (int64_t)src0 >> 63,
            (int64_t)src0 >> 63,
         };
         uint32_t src1_u32[4] = {
            src1,
            (int64_t)src1 >> 32,
            (int64_t)src1 >> 63,
            (int64_t)src1 >> 63,
         };
         uint32_t prod_u32[4];
         ubm_mul_u32arr(prod_u32, src0_u32, src1_u32);
         dst = (uint64_t)prod_u32[2] | ((uint64_t)prod_u32[3] << 32);
      } else {
         /* First, sign-extend to 64-bit, then convert to unsigned to prevent
          * potential overflow of signed multiply */
         dst = ((uint64_t)(int64_t)src0 * (uint64_t)(int64_t)src1) >> bit_size;
      }

  Builder function:

  nir_def *nir_imul_high(nir_builder*, nir_def *src0, nir_def *src1)

umul_high(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Description: High 32-bits of unsigned integer multiply

  Constant-folding:

      if (bit_size == 64) {
         /* The casts are kind-of annoying but needed to prevent compiler warnings. */
         uint32_t src0_u32[2] = { src0, (uint64_t)src0 >> 32 };
         uint32_t src1_u32[2] = { src1, (uint64_t)src1 >> 32 };
         uint32_t prod_u32[4];
         ubm_mul_u32arr(prod_u32, src0_u32, src1_u32);
         dst = (uint64_t)prod_u32[2] | ((uint64_t)prod_u32[3] << 32);
      } else {
         dst = ((uint64_t)src0 * (uint64_t)src1) >> bit_size;
      }

  Builder function:

  nir_def *nir_umul_high(nir_builder*, nir_def *src0, nir_def *src1)

umul_16x16(uint32[N] src0, uint32[N] src1) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Description: Multiply low 16-bits of the sources, with zero extension, producing a 32-bit result

  Constant-folding:

      (uint32_t)(uint16_t)src0 * (uint32_t)(uint16_t)src1

  Builder function:

  nir_def *nir_umul_16x16(nir_builder*, nir_def *src0, nir_def *src1)

imul_32x16(int32[N] src0, int32[N] src1) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Multiply 32-bits with low 16-bits, with sign extension

  Constant-folding:

      src0 * (int16_t) src1

  Builder function:

  nir_def *nir_imul_32x16(nir_builder*, nir_def *src0, nir_def *src1)

umul_32x16(uint32[N] src0, uint32[N] src1) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Multiply 32-bits with low 16-bits, with zero extension

  Constant-folding:

      src0 * (uint16_t) src1

  Builder function:

  nir_def *nir_umul_32x16(nir_builder*, nir_def *src0, nir_def *src1)

fdiv(float[N] src0, float[N] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 / src1

  Builder function:

  nir_def *nir_fdiv(nir_builder*, nir_def *src0, nir_def *src1)

idiv(int[N] src0, int[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src1 == 0 || (src0 == u_intN_min(bit_size) && src1 == -1)) ? 0 : (src0 / src1)

  Builder function:

  nir_def *nir_idiv(nir_builder*, nir_def *src0, nir_def *src1)

udiv(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src1 == 0 ? 0 : (src0 / src1)

  Builder function:

  nir_def *nir_udiv(nir_builder*, nir_def *src0, nir_def *src1)

uadd_carry(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Description: Return an integer (1 or 0) representing the carry resulting from the addition of the two unsigned arguments.

  Constant-folding:

      util_add_check_overflow({dest_type}, src0, src1)

  Builder function:

  nir_def *nir_uadd_carry(nir_builder*, nir_def *src0, nir_def *src1)

usub_borrow(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Return an integer (1 or 0) representing the borrow resulting from the subtraction of the two unsigned arguments.

  Constant-folding:

      src0 < src1

  Builder function:

  nir_def *nir_usub_borrow(nir_builder*, nir_def *src0, nir_def *src1)

ihadd(int[N] src0, int[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      (src0 & src1) + ((src0 ^ src1) >> 1)

  Builder function:

  nir_def *nir_ihadd(nir_builder*, nir_def *src0, nir_def *src1)

uhadd(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      (src0 & src1) + ((src0 ^ src1) >> 1)

  Builder function:

  nir_def *nir_uhadd(nir_builder*, nir_def *src0, nir_def *src1)

irhadd(int[N] src0, int[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      (src0 | src1) - ((src0 ^ src1) >> 1)

  Builder function:

  nir_def *nir_irhadd(nir_builder*, nir_def *src0, nir_def *src1)

urhadd(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      (src0 | src1) - ((src0 ^ src1) >> 1)

  Builder function:

  nir_def *nir_urhadd(nir_builder*, nir_def *src0, nir_def *src1)

umod(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src1 == 0 ? 0 : src0 % src1

  Builder function:

  nir_def *nir_umod(nir_builder*, nir_def *src0, nir_def *src1)

irem(int[N] src0, int[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src1 == 0 || (src0 == u_intN_min(bit_size) && src1 == -1)) ? 0 : src0 % src1

  Builder function:

  nir_def *nir_irem(nir_builder*, nir_def *src0, nir_def *src1)

imod(int[N] src0, int[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src1 == 0 || (src0 == u_intN_min(bit_size) && src1 == -1)) ? 0 : ((src0 % src1 == 0 || (src0 >= 0) == (src1 >= 0)) ? src0 % src1 : src0 % src1 + src1)

  Builder function:

  nir_def *nir_imod(nir_builder*, nir_def *src0, nir_def *src1)

fmod(float[N] src0, float[N] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 - src1 * floorf(src0 / src1)

  Builder function:

  nir_def *nir_fmod(nir_builder*, nir_def *src0, nir_def *src1)

frem(float[N] src0, float[N] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 - src1 * truncf(src0 / src1)

  Builder function:

  nir_def *nir_frem(nir_builder*, nir_def *src0, nir_def *src1)

flt(float[N] src0, float[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 < src1

  Builder function:

  nir_def *nir_flt(nir_builder*, nir_def *src0, nir_def *src1)

flt8(float[N] src0, float[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 < src1

  Builder function:

  nir_def *nir_flt8(nir_builder*, nir_def *src0, nir_def *src1)

flt16(float[N] src0, float[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 < src1

  Builder function:

  nir_def *nir_flt16(nir_builder*, nir_def *src0, nir_def *src1)

flt32(float[N] src0, float[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 < src1

  Builder function:

  nir_def *nir_flt32(nir_builder*, nir_def *src0, nir_def *src1)

fge(float[N] src0, float[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 >= src1

  Builder function:

  nir_def *nir_fge(nir_builder*, nir_def *src0, nir_def *src1)

fge8(float[N] src0, float[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 >= src1

  Builder function:

  nir_def *nir_fge8(nir_builder*, nir_def *src0, nir_def *src1)

fge16(float[N] src0, float[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 >= src1

  Builder function:

  nir_def *nir_fge16(nir_builder*, nir_def *src0, nir_def *src1)

fge32(float[N] src0, float[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 >= src1

  Builder function:

  nir_def *nir_fge32(nir_builder*, nir_def *src0, nir_def *src1)

fltu(float[N] src0, float[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      isnan(src0) || isnan(src1) || src0 < src1

  Builder function:

  nir_def *nir_fltu(nir_builder*, nir_def *src0, nir_def *src1)

fltu8(float[N] src0, float[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      isnan(src0) || isnan(src1) || src0 < src1

  Builder function:

  nir_def *nir_fltu8(nir_builder*, nir_def *src0, nir_def *src1)

fltu16(float[N] src0, float[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      isnan(src0) || isnan(src1) || src0 < src1

  Builder function:

  nir_def *nir_fltu16(nir_builder*, nir_def *src0, nir_def *src1)

fltu32(float[N] src0, float[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      isnan(src0) || isnan(src1) || src0 < src1

  Builder function:

  nir_def *nir_fltu32(nir_builder*, nir_def *src0, nir_def *src1)

fgeu(float[N] src0, float[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      isnan(src0) || isnan(src1) || src0 >= src1

  Builder function:

  nir_def *nir_fgeu(nir_builder*, nir_def *src0, nir_def *src1)

fgeu8(float[N] src0, float[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      isnan(src0) || isnan(src1) || src0 >= src1

  Builder function:

  nir_def *nir_fgeu8(nir_builder*, nir_def *src0, nir_def *src1)

fgeu16(float[N] src0, float[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      isnan(src0) || isnan(src1) || src0 >= src1

  Builder function:

  nir_def *nir_fgeu16(nir_builder*, nir_def *src0, nir_def *src1)

fgeu32(float[N] src0, float[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      isnan(src0) || isnan(src1) || src0 >= src1

  Builder function:

  nir_def *nir_fgeu32(nir_builder*, nir_def *src0, nir_def *src1)

feq(float[N] src0, float[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      src0 == src1

  Builder function:

  nir_def *nir_feq(nir_builder*, nir_def *src0, nir_def *src1)

feq8(float[N] src0, float[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      src0 == src1

  Builder function:

  nir_def *nir_feq8(nir_builder*, nir_def *src0, nir_def *src1)

feq16(float[N] src0, float[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      src0 == src1

  Builder function:

  nir_def *nir_feq16(nir_builder*, nir_def *src0, nir_def *src1)

feq32(float[N] src0, float[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      src0 == src1

  Builder function:

  nir_def *nir_feq32(nir_builder*, nir_def *src0, nir_def *src1)

fneu(float[N] src0, float[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      src0 != src1

  Builder function:

  nir_def *nir_fneu(nir_builder*, nir_def *src0, nir_def *src1)

fneu8(float[N] src0, float[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      src0 != src1

  Builder function:

  nir_def *nir_fneu8(nir_builder*, nir_def *src0, nir_def *src1)

fneu16(float[N] src0, float[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      src0 != src1

  Builder function:

  nir_def *nir_fneu16(nir_builder*, nir_def *src0, nir_def *src1)

fneu32(float[N] src0, float[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      src0 != src1

  Builder function:

  nir_def *nir_fneu32(nir_builder*, nir_def *src0, nir_def *src1)

fequ(float[N] src0, float[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      isnan(src0) || isnan(src1) || src0 == src1

  Builder function:

  nir_def *nir_fequ(nir_builder*, nir_def *src0, nir_def *src1)

fequ8(float[N] src0, float[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      isnan(src0) || isnan(src1) || src0 == src1

  Builder function:

  nir_def *nir_fequ8(nir_builder*, nir_def *src0, nir_def *src1)

fequ16(float[N] src0, float[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      isnan(src0) || isnan(src1) || src0 == src1

  Builder function:

  nir_def *nir_fequ16(nir_builder*, nir_def *src0, nir_def *src1)

fequ32(float[N] src0, float[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      isnan(src0) || isnan(src1) || src0 == src1

  Builder function:

  nir_def *nir_fequ32(nir_builder*, nir_def *src0, nir_def *src1)

fneo(float[N] src0, float[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      !isnan(src0) && !isnan(src1) && src0 != src1

  Builder function:

  nir_def *nir_fneo(nir_builder*, nir_def *src0, nir_def *src1)

fneo8(float[N] src0, float[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      !isnan(src0) && !isnan(src1) && src0 != src1

  Builder function:

  nir_def *nir_fneo8(nir_builder*, nir_def *src0, nir_def *src1)

fneo16(float[N] src0, float[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      !isnan(src0) && !isnan(src1) && src0 != src1

  Builder function:

  nir_def *nir_fneo16(nir_builder*, nir_def *src0, nir_def *src1)

fneo32(float[N] src0, float[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      !isnan(src0) && !isnan(src1) && src0 != src1

  Builder function:

  nir_def *nir_fneo32(nir_builder*, nir_def *src0, nir_def *src1)

funord(float[N] src0, float[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      isnan(src0) || isnan(src1)

  Builder function:

  nir_def *nir_funord(nir_builder*, nir_def *src0, nir_def *src1)

funord8(float[N] src0, float[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      isnan(src0) || isnan(src1)

  Builder function:

  nir_def *nir_funord8(nir_builder*, nir_def *src0, nir_def *src1)

funord16(float[N] src0, float[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      isnan(src0) || isnan(src1)

  Builder function:

  nir_def *nir_funord16(nir_builder*, nir_def *src0, nir_def *src1)

funord32(float[N] src0, float[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      isnan(src0) || isnan(src1)

  Builder function:

  nir_def *nir_funord32(nir_builder*, nir_def *src0, nir_def *src1)

ford(float[N] src0, float[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      !isnan(src0) && !isnan(src1)

  Builder function:

  nir_def *nir_ford(nir_builder*, nir_def *src0, nir_def *src1)

ford8(float[N] src0, float[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      !isnan(src0) && !isnan(src1)

  Builder function:

  nir_def *nir_ford8(nir_builder*, nir_def *src0, nir_def *src1)

ford16(float[N] src0, float[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      !isnan(src0) && !isnan(src1)

  Builder function:

  nir_def *nir_ford16(nir_builder*, nir_def *src0, nir_def *src1)

ford32(float[N] src0, float[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      !isnan(src0) && !isnan(src1)

  Builder function:

  nir_def *nir_ford32(nir_builder*, nir_def *src0, nir_def *src1)

ilt(int[N] src0, int[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 < src1

  Builder function:

  nir_def *nir_ilt(nir_builder*, nir_def *src0, nir_def *src1)

ilt8(int[N] src0, int[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 < src1

  Builder function:

  nir_def *nir_ilt8(nir_builder*, nir_def *src0, nir_def *src1)

ilt16(int[N] src0, int[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 < src1

  Builder function:

  nir_def *nir_ilt16(nir_builder*, nir_def *src0, nir_def *src1)

ilt32(int[N] src0, int[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 < src1

  Builder function:

  nir_def *nir_ilt32(nir_builder*, nir_def *src0, nir_def *src1)

ige(int[N] src0, int[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 >= src1

  Builder function:

  nir_def *nir_ige(nir_builder*, nir_def *src0, nir_def *src1)

ige8(int[N] src0, int[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 >= src1

  Builder function:

  nir_def *nir_ige8(nir_builder*, nir_def *src0, nir_def *src1)

ige16(int[N] src0, int[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 >= src1

  Builder function:

  nir_def *nir_ige16(nir_builder*, nir_def *src0, nir_def *src1)

ige32(int[N] src0, int[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 >= src1

  Builder function:

  nir_def *nir_ige32(nir_builder*, nir_def *src0, nir_def *src1)

ieq(int[N] src0, int[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      src0 == src1

  Builder function:

  nir_def *nir_ieq(nir_builder*, nir_def *src0, nir_def *src1)

ieq8(int[N] src0, int[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      src0 == src1

  Builder function:

  nir_def *nir_ieq8(nir_builder*, nir_def *src0, nir_def *src1)

ieq16(int[N] src0, int[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      src0 == src1

  Builder function:

  nir_def *nir_ieq16(nir_builder*, nir_def *src0, nir_def *src1)

ieq32(int[N] src0, int[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      src0 == src1

  Builder function:

  nir_def *nir_ieq32(nir_builder*, nir_def *src0, nir_def *src1)

ine(int[N] src0, int[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      src0 != src1

  Builder function:

  nir_def *nir_ine(nir_builder*, nir_def *src0, nir_def *src1)

ine8(int[N] src0, int[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      src0 != src1

  Builder function:

  nir_def *nir_ine8(nir_builder*, nir_def *src0, nir_def *src1)

ine16(int[N] src0, int[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      src0 != src1

  Builder function:

  nir_def *nir_ine16(nir_builder*, nir_def *src0, nir_def *src1)

ine32(int[N] src0, int[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      src0 != src1

  Builder function:

  nir_def *nir_ine32(nir_builder*, nir_def *src0, nir_def *src1)

ult(uint[N] src0, uint[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 < src1

  Builder function:

  nir_def *nir_ult(nir_builder*, nir_def *src0, nir_def *src1)

ult8(uint[N] src0, uint[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 < src1

  Builder function:

  nir_def *nir_ult8(nir_builder*, nir_def *src0, nir_def *src1)

ult16(uint[N] src0, uint[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 < src1

  Builder function:

  nir_def *nir_ult16(nir_builder*, nir_def *src0, nir_def *src1)

ult32(uint[N] src0, uint[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 < src1

  Builder function:

  nir_def *nir_ult32(nir_builder*, nir_def *src0, nir_def *src1)

uge(uint[N] src0, uint[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 >= src1

  Builder function:

  nir_def *nir_uge(nir_builder*, nir_def *src0, nir_def *src1)

uge8(uint[N] src0, uint[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 >= src1

  Builder function:

  nir_def *nir_uge8(nir_builder*, nir_def *src0, nir_def *src1)

uge16(uint[N] src0, uint[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 >= src1

  Builder function:

  nir_def *nir_uge16(nir_builder*, nir_def *src0, nir_def *src1)

uge32(uint[N] src0, uint[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 >= src1

  Builder function:

  nir_def *nir_uge32(nir_builder*, nir_def *src0, nir_def *src1)

bitnz(uint[N] src0, uint32[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: only uses the least significant bits like SM5 shifts

  Constant-folding:

      ((uint64_t)src0 >> (src1 & (bit_size - 1)) & 0x1) == 0x1

  Builder function:

  nir_def *nir_bitnz(nir_builder*, nir_def *src0, nir_def *src1)

bitnz8(uint[N] src0, uint32[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: only uses the least significant bits like SM5 shifts

  Constant-folding:

      ((uint64_t)src0 >> (src1 & (bit_size - 1)) & 0x1) == 0x1

  Builder function:

  nir_def *nir_bitnz8(nir_builder*, nir_def *src0, nir_def *src1)

bitnz16(uint[N] src0, uint32[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: only uses the least significant bits like SM5 shifts

  Constant-folding:

      ((uint64_t)src0 >> (src1 & (bit_size - 1)) & 0x1) == 0x1

  Builder function:

  nir_def *nir_bitnz16(nir_builder*, nir_def *src0, nir_def *src1)

bitnz32(uint[N] src0, uint32[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: only uses the least significant bits like SM5 shifts

  Constant-folding:

      ((uint64_t)src0 >> (src1 & (bit_size - 1)) & 0x1) == 0x1

  Builder function:

  nir_def *nir_bitnz32(nir_builder*, nir_def *src0, nir_def *src1)

bitz(uint[N] src0, uint32[N] src1) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: only uses the least significant bits like SM5 shifts

  Constant-folding:

      ((uint64_t)src0 >> (src1 & (bit_size - 1)) & 0x1) == 0x0

  Builder function:

  nir_def *nir_bitz(nir_builder*, nir_def *src0, nir_def *src1)

bitz8(uint[N] src0, uint32[N] src1) → bool8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: only uses the least significant bits like SM5 shifts

  Constant-folding:

      ((uint64_t)src0 >> (src1 & (bit_size - 1)) & 0x1) == 0x0

  Builder function:

  nir_def *nir_bitz8(nir_builder*, nir_def *src0, nir_def *src1)

bitz16(uint[N] src0, uint32[N] src1) → bool16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: only uses the least significant bits like SM5 shifts

  Constant-folding:

      ((uint64_t)src0 >> (src1 & (bit_size - 1)) & 0x1) == 0x0

  Builder function:

  nir_def *nir_bitz16(nir_builder*, nir_def *src0, nir_def *src1)

bitz32(uint[N] src0, uint32[N] src1) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: only uses the least significant bits like SM5 shifts

  Constant-folding:

      ((uint64_t)src0 >> (src1 & (bit_size - 1)) & 0x1) == 0x0

  Builder function:

  nir_def *nir_bitz32(nir_builder*, nir_def *src0, nir_def *src1)

ball_fequal2(float[2] src0, float[2] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_ball_fequal2(nir_builder*, nir_def *src0, nir_def *src1)

ball_fequal4(float[4] src0, float[4] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_ball_fequal4(nir_builder*, nir_def *src0, nir_def *src1)

ball_fequal8(float[8] src0, float[8] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.h == src1.h) && (src0.g == src1.g) && (src0.f == src1.f) && (src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_ball_fequal8(nir_builder*, nir_def *src0, nir_def *src1)

ball_fequal16(float[16] src0, float[16] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.p == src1.p) && (src0.o == src1.o) && (src0.n == src1.n) && (src0.m == src1.m) && (src0.l == src1.l) && (src0.k == src1.k) && (src0.j == src1.j) && (src0.i == src1.i) && (src0.h == src1.h) && (src0.g == src1.g) && (src0.f == src1.f) && (src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_ball_fequal16(nir_builder*, nir_def *src0, nir_def *src1)

ball_fequal3(float[3] src0, float[3] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_ball_fequal3(nir_builder*, nir_def *src0, nir_def *src1)

ball_fequal5(float[5] src0, float[5] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_ball_fequal5(nir_builder*, nir_def *src0, nir_def *src1)

b8all_fequal2(float[2] src0, float[2] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b8all_fequal2(nir_builder*, nir_def *src0, nir_def *src1)

b8all_fequal4(float[4] src0, float[4] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b8all_fequal4(nir_builder*, nir_def *src0, nir_def *src1)

b8all_fequal8(float[8] src0, float[8] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.h == src1.h) && (src0.g == src1.g) && (src0.f == src1.f) && (src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b8all_fequal8(nir_builder*, nir_def *src0, nir_def *src1)

b8all_fequal16(float[16] src0, float[16] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.p == src1.p) && (src0.o == src1.o) && (src0.n == src1.n) && (src0.m == src1.m) && (src0.l == src1.l) && (src0.k == src1.k) && (src0.j == src1.j) && (src0.i == src1.i) && (src0.h == src1.h) && (src0.g == src1.g) && (src0.f == src1.f) && (src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b8all_fequal16(nir_builder*, nir_def *src0, nir_def *src1)

b8all_fequal3(float[3] src0, float[3] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b8all_fequal3(nir_builder*, nir_def *src0, nir_def *src1)

b8all_fequal5(float[5] src0, float[5] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b8all_fequal5(nir_builder*, nir_def *src0, nir_def *src1)

b16all_fequal2(float[2] src0, float[2] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b16all_fequal2(nir_builder*, nir_def *src0, nir_def *src1)

b16all_fequal4(float[4] src0, float[4] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b16all_fequal4(nir_builder*, nir_def *src0, nir_def *src1)

b16all_fequal8(float[8] src0, float[8] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.h == src1.h) && (src0.g == src1.g) && (src0.f == src1.f) && (src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b16all_fequal8(nir_builder*, nir_def *src0, nir_def *src1)

b16all_fequal16(float[16] src0, float[16] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.p == src1.p) && (src0.o == src1.o) && (src0.n == src1.n) && (src0.m == src1.m) && (src0.l == src1.l) && (src0.k == src1.k) && (src0.j == src1.j) && (src0.i == src1.i) && (src0.h == src1.h) && (src0.g == src1.g) && (src0.f == src1.f) && (src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b16all_fequal16(nir_builder*, nir_def *src0, nir_def *src1)

b16all_fequal3(float[3] src0, float[3] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b16all_fequal3(nir_builder*, nir_def *src0, nir_def *src1)

b16all_fequal5(float[5] src0, float[5] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b16all_fequal5(nir_builder*, nir_def *src0, nir_def *src1)

b32all_fequal2(float[2] src0, float[2] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b32all_fequal2(nir_builder*, nir_def *src0, nir_def *src1)

b32all_fequal4(float[4] src0, float[4] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b32all_fequal4(nir_builder*, nir_def *src0, nir_def *src1)

b32all_fequal8(float[8] src0, float[8] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.h == src1.h) && (src0.g == src1.g) && (src0.f == src1.f) && (src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b32all_fequal8(nir_builder*, nir_def *src0, nir_def *src1)

b32all_fequal16(float[16] src0, float[16] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.p == src1.p) && (src0.o == src1.o) && (src0.n == src1.n) && (src0.m == src1.m) && (src0.l == src1.l) && (src0.k == src1.k) && (src0.j == src1.j) && (src0.i == src1.i) && (src0.h == src1.h) && (src0.g == src1.g) && (src0.f == src1.f) && (src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b32all_fequal16(nir_builder*, nir_def *src0, nir_def *src1)

b32all_fequal3(float[3] src0, float[3] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b32all_fequal3(nir_builder*, nir_def *src0, nir_def *src1)

b32all_fequal5(float[5] src0, float[5] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b32all_fequal5(nir_builder*, nir_def *src0, nir_def *src1)

bany_fnequal2(float[2] src0, float[2] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_bany_fnequal2(nir_builder*, nir_def *src0, nir_def *src1)

bany_fnequal4(float[4] src0, float[4] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_bany_fnequal4(nir_builder*, nir_def *src0, nir_def *src1)

bany_fnequal8(float[8] src0, float[8] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.h != src1.h) || (src0.g != src1.g) || (src0.f != src1.f) || (src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_bany_fnequal8(nir_builder*, nir_def *src0, nir_def *src1)

bany_fnequal16(float[16] src0, float[16] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.p != src1.p) || (src0.o != src1.o) || (src0.n != src1.n) || (src0.m != src1.m) || (src0.l != src1.l) || (src0.k != src1.k) || (src0.j != src1.j) || (src0.i != src1.i) || (src0.h != src1.h) || (src0.g != src1.g) || (src0.f != src1.f) || (src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_bany_fnequal16(nir_builder*, nir_def *src0, nir_def *src1)

bany_fnequal3(float[3] src0, float[3] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_bany_fnequal3(nir_builder*, nir_def *src0, nir_def *src1)

bany_fnequal5(float[5] src0, float[5] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_bany_fnequal5(nir_builder*, nir_def *src0, nir_def *src1)

b8any_fnequal2(float[2] src0, float[2] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b8any_fnequal2(nir_builder*, nir_def *src0, nir_def *src1)

b8any_fnequal4(float[4] src0, float[4] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b8any_fnequal4(nir_builder*, nir_def *src0, nir_def *src1)

b8any_fnequal8(float[8] src0, float[8] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.h != src1.h) || (src0.g != src1.g) || (src0.f != src1.f) || (src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b8any_fnequal8(nir_builder*, nir_def *src0, nir_def *src1)

b8any_fnequal16(float[16] src0, float[16] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.p != src1.p) || (src0.o != src1.o) || (src0.n != src1.n) || (src0.m != src1.m) || (src0.l != src1.l) || (src0.k != src1.k) || (src0.j != src1.j) || (src0.i != src1.i) || (src0.h != src1.h) || (src0.g != src1.g) || (src0.f != src1.f) || (src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b8any_fnequal16(nir_builder*, nir_def *src0, nir_def *src1)

b8any_fnequal3(float[3] src0, float[3] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b8any_fnequal3(nir_builder*, nir_def *src0, nir_def *src1)

b8any_fnequal5(float[5] src0, float[5] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b8any_fnequal5(nir_builder*, nir_def *src0, nir_def *src1)

b16any_fnequal2(float[2] src0, float[2] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b16any_fnequal2(nir_builder*, nir_def *src0, nir_def *src1)

b16any_fnequal4(float[4] src0, float[4] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b16any_fnequal4(nir_builder*, nir_def *src0, nir_def *src1)

b16any_fnequal8(float[8] src0, float[8] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.h != src1.h) || (src0.g != src1.g) || (src0.f != src1.f) || (src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b16any_fnequal8(nir_builder*, nir_def *src0, nir_def *src1)

b16any_fnequal16(float[16] src0, float[16] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.p != src1.p) || (src0.o != src1.o) || (src0.n != src1.n) || (src0.m != src1.m) || (src0.l != src1.l) || (src0.k != src1.k) || (src0.j != src1.j) || (src0.i != src1.i) || (src0.h != src1.h) || (src0.g != src1.g) || (src0.f != src1.f) || (src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b16any_fnequal16(nir_builder*, nir_def *src0, nir_def *src1)

b16any_fnequal3(float[3] src0, float[3] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b16any_fnequal3(nir_builder*, nir_def *src0, nir_def *src1)

b16any_fnequal5(float[5] src0, float[5] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b16any_fnequal5(nir_builder*, nir_def *src0, nir_def *src1)

b32any_fnequal2(float[2] src0, float[2] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b32any_fnequal2(nir_builder*, nir_def *src0, nir_def *src1)

b32any_fnequal4(float[4] src0, float[4] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b32any_fnequal4(nir_builder*, nir_def *src0, nir_def *src1)

b32any_fnequal8(float[8] src0, float[8] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.h != src1.h) || (src0.g != src1.g) || (src0.f != src1.f) || (src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b32any_fnequal8(nir_builder*, nir_def *src0, nir_def *src1)

b32any_fnequal16(float[16] src0, float[16] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.p != src1.p) || (src0.o != src1.o) || (src0.n != src1.n) || (src0.m != src1.m) || (src0.l != src1.l) || (src0.k != src1.k) || (src0.j != src1.j) || (src0.i != src1.i) || (src0.h != src1.h) || (src0.g != src1.g) || (src0.f != src1.f) || (src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b32any_fnequal16(nir_builder*, nir_def *src0, nir_def *src1)

b32any_fnequal3(float[3] src0, float[3] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b32any_fnequal3(nir_builder*, nir_def *src0, nir_def *src1)

b32any_fnequal5(float[5] src0, float[5] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b32any_fnequal5(nir_builder*, nir_def *src0, nir_def *src1)

ball_iequal2(int[2] src0, int[2] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_ball_iequal2(nir_builder*, nir_def *src0, nir_def *src1)

ball_iequal4(int[4] src0, int[4] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_ball_iequal4(nir_builder*, nir_def *src0, nir_def *src1)

ball_iequal8(int[8] src0, int[8] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.h == src1.h) && (src0.g == src1.g) && (src0.f == src1.f) && (src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_ball_iequal8(nir_builder*, nir_def *src0, nir_def *src1)

ball_iequal16(int[16] src0, int[16] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.p == src1.p) && (src0.o == src1.o) && (src0.n == src1.n) && (src0.m == src1.m) && (src0.l == src1.l) && (src0.k == src1.k) && (src0.j == src1.j) && (src0.i == src1.i) && (src0.h == src1.h) && (src0.g == src1.g) && (src0.f == src1.f) && (src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_ball_iequal16(nir_builder*, nir_def *src0, nir_def *src1)

ball_iequal3(int[3] src0, int[3] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_ball_iequal3(nir_builder*, nir_def *src0, nir_def *src1)

ball_iequal5(int[5] src0, int[5] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_ball_iequal5(nir_builder*, nir_def *src0, nir_def *src1)

b8all_iequal2(int[2] src0, int[2] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b8all_iequal2(nir_builder*, nir_def *src0, nir_def *src1)

b8all_iequal4(int[4] src0, int[4] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b8all_iequal4(nir_builder*, nir_def *src0, nir_def *src1)

b8all_iequal8(int[8] src0, int[8] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.h == src1.h) && (src0.g == src1.g) && (src0.f == src1.f) && (src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b8all_iequal8(nir_builder*, nir_def *src0, nir_def *src1)

b8all_iequal16(int[16] src0, int[16] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.p == src1.p) && (src0.o == src1.o) && (src0.n == src1.n) && (src0.m == src1.m) && (src0.l == src1.l) && (src0.k == src1.k) && (src0.j == src1.j) && (src0.i == src1.i) && (src0.h == src1.h) && (src0.g == src1.g) && (src0.f == src1.f) && (src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b8all_iequal16(nir_builder*, nir_def *src0, nir_def *src1)

b8all_iequal3(int[3] src0, int[3] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b8all_iequal3(nir_builder*, nir_def *src0, nir_def *src1)

b8all_iequal5(int[5] src0, int[5] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b8all_iequal5(nir_builder*, nir_def *src0, nir_def *src1)

b16all_iequal2(int[2] src0, int[2] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b16all_iequal2(nir_builder*, nir_def *src0, nir_def *src1)

b16all_iequal4(int[4] src0, int[4] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b16all_iequal4(nir_builder*, nir_def *src0, nir_def *src1)

b16all_iequal8(int[8] src0, int[8] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.h == src1.h) && (src0.g == src1.g) && (src0.f == src1.f) && (src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b16all_iequal8(nir_builder*, nir_def *src0, nir_def *src1)

b16all_iequal16(int[16] src0, int[16] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.p == src1.p) && (src0.o == src1.o) && (src0.n == src1.n) && (src0.m == src1.m) && (src0.l == src1.l) && (src0.k == src1.k) && (src0.j == src1.j) && (src0.i == src1.i) && (src0.h == src1.h) && (src0.g == src1.g) && (src0.f == src1.f) && (src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b16all_iequal16(nir_builder*, nir_def *src0, nir_def *src1)

b16all_iequal3(int[3] src0, int[3] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b16all_iequal3(nir_builder*, nir_def *src0, nir_def *src1)

b16all_iequal5(int[5] src0, int[5] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b16all_iequal5(nir_builder*, nir_def *src0, nir_def *src1)

b32all_iequal2(int[2] src0, int[2] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b32all_iequal2(nir_builder*, nir_def *src0, nir_def *src1)

b32all_iequal4(int[4] src0, int[4] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b32all_iequal4(nir_builder*, nir_def *src0, nir_def *src1)

b32all_iequal8(int[8] src0, int[8] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.h == src1.h) && (src0.g == src1.g) && (src0.f == src1.f) && (src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b32all_iequal8(nir_builder*, nir_def *src0, nir_def *src1)

b32all_iequal16(int[16] src0, int[16] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.p == src1.p) && (src0.o == src1.o) && (src0.n == src1.n) && (src0.m == src1.m) && (src0.l == src1.l) && (src0.k == src1.k) && (src0.j == src1.j) && (src0.i == src1.i) && (src0.h == src1.h) && (src0.g == src1.g) && (src0.f == src1.f) && (src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b32all_iequal16(nir_builder*, nir_def *src0, nir_def *src1)

b32all_iequal3(int[3] src0, int[3] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b32all_iequal3(nir_builder*, nir_def *src0, nir_def *src1)

b32all_iequal5(int[5] src0, int[5] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.e == src1.e) && (src0.w == src1.w) && (src0.z == src1.z) && (src0.y == src1.y) && (src0.x == src1.x))

  Builder function:

  nir_def *nir_b32all_iequal5(nir_builder*, nir_def *src0, nir_def *src1)

bany_inequal2(int[2] src0, int[2] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_bany_inequal2(nir_builder*, nir_def *src0, nir_def *src1)

bany_inequal4(int[4] src0, int[4] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_bany_inequal4(nir_builder*, nir_def *src0, nir_def *src1)

bany_inequal8(int[8] src0, int[8] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.h != src1.h) || (src0.g != src1.g) || (src0.f != src1.f) || (src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_bany_inequal8(nir_builder*, nir_def *src0, nir_def *src1)

bany_inequal16(int[16] src0, int[16] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.p != src1.p) || (src0.o != src1.o) || (src0.n != src1.n) || (src0.m != src1.m) || (src0.l != src1.l) || (src0.k != src1.k) || (src0.j != src1.j) || (src0.i != src1.i) || (src0.h != src1.h) || (src0.g != src1.g) || (src0.f != src1.f) || (src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_bany_inequal16(nir_builder*, nir_def *src0, nir_def *src1)

bany_inequal3(int[3] src0, int[3] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_bany_inequal3(nir_builder*, nir_def *src0, nir_def *src1)

bany_inequal5(int[5] src0, int[5] src1) → bool1[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_bany_inequal5(nir_builder*, nir_def *src0, nir_def *src1)

b8any_inequal2(int[2] src0, int[2] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b8any_inequal2(nir_builder*, nir_def *src0, nir_def *src1)

b8any_inequal4(int[4] src0, int[4] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b8any_inequal4(nir_builder*, nir_def *src0, nir_def *src1)

b8any_inequal8(int[8] src0, int[8] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.h != src1.h) || (src0.g != src1.g) || (src0.f != src1.f) || (src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b8any_inequal8(nir_builder*, nir_def *src0, nir_def *src1)

b8any_inequal16(int[16] src0, int[16] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.p != src1.p) || (src0.o != src1.o) || (src0.n != src1.n) || (src0.m != src1.m) || (src0.l != src1.l) || (src0.k != src1.k) || (src0.j != src1.j) || (src0.i != src1.i) || (src0.h != src1.h) || (src0.g != src1.g) || (src0.f != src1.f) || (src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b8any_inequal16(nir_builder*, nir_def *src0, nir_def *src1)

b8any_inequal3(int[3] src0, int[3] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b8any_inequal3(nir_builder*, nir_def *src0, nir_def *src1)

b8any_inequal5(int[5] src0, int[5] src1) → bool8[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b8any_inequal5(nir_builder*, nir_def *src0, nir_def *src1)

b16any_inequal2(int[2] src0, int[2] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b16any_inequal2(nir_builder*, nir_def *src0, nir_def *src1)

b16any_inequal4(int[4] src0, int[4] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b16any_inequal4(nir_builder*, nir_def *src0, nir_def *src1)

b16any_inequal8(int[8] src0, int[8] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.h != src1.h) || (src0.g != src1.g) || (src0.f != src1.f) || (src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b16any_inequal8(nir_builder*, nir_def *src0, nir_def *src1)

b16any_inequal16(int[16] src0, int[16] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.p != src1.p) || (src0.o != src1.o) || (src0.n != src1.n) || (src0.m != src1.m) || (src0.l != src1.l) || (src0.k != src1.k) || (src0.j != src1.j) || (src0.i != src1.i) || (src0.h != src1.h) || (src0.g != src1.g) || (src0.f != src1.f) || (src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b16any_inequal16(nir_builder*, nir_def *src0, nir_def *src1)

b16any_inequal3(int[3] src0, int[3] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b16any_inequal3(nir_builder*, nir_def *src0, nir_def *src1)

b16any_inequal5(int[5] src0, int[5] src1) → bool16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b16any_inequal5(nir_builder*, nir_def *src0, nir_def *src1)

b32any_inequal2(int[2] src0, int[2] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b32any_inequal2(nir_builder*, nir_def *src0, nir_def *src1)

b32any_inequal4(int[4] src0, int[4] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b32any_inequal4(nir_builder*, nir_def *src0, nir_def *src1)

b32any_inequal8(int[8] src0, int[8] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.h != src1.h) || (src0.g != src1.g) || (src0.f != src1.f) || (src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b32any_inequal8(nir_builder*, nir_def *src0, nir_def *src1)

b32any_inequal16(int[16] src0, int[16] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.p != src1.p) || (src0.o != src1.o) || (src0.n != src1.n) || (src0.m != src1.m) || (src0.l != src1.l) || (src0.k != src1.k) || (src0.j != src1.j) || (src0.i != src1.i) || (src0.h != src1.h) || (src0.g != src1.g) || (src0.f != src1.f) || (src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b32any_inequal16(nir_builder*, nir_def *src0, nir_def *src1)

b32any_inequal3(int[3] src0, int[3] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b32any_inequal3(nir_builder*, nir_def *src0, nir_def *src1)

b32any_inequal5(int[5] src0, int[5] src1) → bool32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.e != src1.e) || (src0.w != src1.w) || (src0.z != src1.z) || (src0.y != src1.y) || (src0.x != src1.x))

  Builder function:

  nir_def *nir_b32any_inequal5(nir_builder*, nir_def *src0, nir_def *src1)

slt(float[N] src0, float[N] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 < src1) ? 1.0f : 0.0f

  Builder function:

  nir_def *nir_slt(nir_builder*, nir_def *src0, nir_def *src1)

sge(float[N] src0, float[N] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 >= src1) ? 1.0f : 0.0f

  Builder function:

  nir_def *nir_sge(nir_builder*, nir_def *src0, nir_def *src1)

seq(float[N] src0, float[N] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      (src0 == src1) ? 1.0f : 0.0f

  Builder function:

  nir_def *nir_seq(nir_builder*, nir_def *src0, nir_def *src1)

sne(float[N] src0, float[N] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      (src0 != src1) ? 1.0f : 0.0f

  Builder function:

  nir_def *nir_sne(nir_builder*, nir_def *src0, nir_def *src1)

ishl(int[N] src0, uint32[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Left shift. SPIRV shifts are undefined for shift-operands >= bitsize, but SM5 shifts are defined to use only the least significant bits. The NIR definition is according to the SM5 specification.

  Constant-folding:

      (uint64_t)src0 << (src1 & (sizeof(src0) * 8 - 1))

  Builder function:

  nir_def *nir_ishl(nir_builder*, nir_def *src0, nir_def *src1)

ishr(int[N] src0, uint32[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Signed right-shift. SPIRV shifts are undefined for shift-operands >= bitsize, but SM5 shifts are defined to use only the least significant bits. The NIR definition is according to the SM5 specification.

  Constant-folding:

      src0 >> (src1 & (sizeof(src0) * 8 - 1))

  Builder function:

  nir_def *nir_ishr(nir_builder*, nir_def *src0, nir_def *src1)

ushr(uint[N] src0, uint32[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Unsigned right-shift. SPIRV shifts are undefined for shift-operands >= bitsize, but SM5 shifts are defined to use only the least significant bits. The NIR definition is according to the SM5 specification.

  Constant-folding:

      src0 >> (src1 & (sizeof(src0) * 8 - 1))

  Builder function:

  nir_def *nir_ushr(nir_builder*, nir_def *src0, nir_def *src1)

udiv_aligned_4(uint[N] src0) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Divide a multiple of 4 by 4

  Constant-folding:

      dst = src0 >> 2;
      if (src0 & 3)
         poison = true;

  Builder function:

  nir_def *nir_udiv_aligned_4(nir_builder*, nir_def *src0)

urol(uint[N] src0, uint32[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      uint32_t rotate_mask = sizeof(src0) * 8 - 1;
      dst = (src0 << (src1 & rotate_mask)) |
            (src0 >> (-src1 & rotate_mask));

  Builder function:

  nir_def *nir_urol(nir_builder*, nir_def *src0, nir_def *src1)

uror(uint[N] src0, uint32[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      uint32_t rotate_mask = sizeof(src0) * 8 - 1;
      dst = (src0 >> (src1 & rotate_mask)) |
            (src0 << (-src1 & rotate_mask));

  Builder function:

  nir_def *nir_uror(nir_builder*, nir_def *src0, nir_def *src1)

shfr(uint32[N] src0, uint32[N] src1, uint32[N] src2) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      uint32_t rotate_mask = sizeof(src0) * 8 - 1;
      uint64_t src = src1 | ((uint64_t)src0 << 32);
      dst = src >> (src2 & rotate_mask);

  Builder function:

  nir_def *nir_shfr(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

iand(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Description: Bitwise AND, also used as a boolean AND for hardware supporting integers.

  Constant-folding:

      src0 & src1

  Builder function:

  nir_def *nir_iand(nir_builder*, nir_def *src0, nir_def *src1)

ior(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Description: Bitwise OR, also used as a boolean OR for hardware supporting integers.

  Constant-folding:

      src0 | src1

  Builder function:

  nir_def *nir_ior(nir_builder*, nir_def *src0, nir_def *src1)

ixor(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Description: Bitwise XOR, also used as a boolean XOR for hardware supporting integers.

  Constant-folding:

      src0 ^ src1

  Builder function:

  nir_def *nir_ixor(nir_builder*, nir_def *src0, nir_def *src1)

fdot2(float[2] src0, float[2] src1) → float[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.y * src1.y) + (src0.x * src1.x))

  Builder function:

  nir_def *nir_fdot2(nir_builder*, nir_def *src0, nir_def *src1)

fdot4(float[4] src0, float[4] src1) → float[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.w * src1.w) + (src0.z * src1.z) + (src0.y * src1.y) + (src0.x * src1.x))

  Builder function:

  nir_def *nir_fdot4(nir_builder*, nir_def *src0, nir_def *src1)

fdot8(float[8] src0, float[8] src1) → float[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.h * src1.h) + (src0.g * src1.g) + (src0.f * src1.f) + (src0.e * src1.e) + (src0.w * src1.w) + (src0.z * src1.z) + (src0.y * src1.y) + (src0.x * src1.x))

  Builder function:

  nir_def *nir_fdot8(nir_builder*, nir_def *src0, nir_def *src1)

fdot16(float[16] src0, float[16] src1) → float[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.p * src1.p) + (src0.o * src1.o) + (src0.n * src1.n) + (src0.m * src1.m) + (src0.l * src1.l) + (src0.k * src1.k) + (src0.j * src1.j) + (src0.i * src1.i) + (src0.h * src1.h) + (src0.g * src1.g) + (src0.f * src1.f) + (src0.e * src1.e) + (src0.w * src1.w) + (src0.z * src1.z) + (src0.y * src1.y) + (src0.x * src1.x))

  Builder function:

  nir_def *nir_fdot16(nir_builder*, nir_def *src0, nir_def *src1)

fdot3(float[3] src0, float[3] src1) → float[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.z * src1.z) + (src0.y * src1.y) + (src0.x * src1.x))

  Builder function:

  nir_def *nir_fdot3(nir_builder*, nir_def *src0, nir_def *src1)

fdot5(float[5] src0, float[5] src1) → float[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      ((src0.e * src1.e) + (src0.w * src1.w) + (src0.z * src1.z) + (src0.y * src1.y) + (src0.x * src1.x))

  Builder function:

  nir_def *nir_fdot5(nir_builder*, nir_def *src0, nir_def *src1)

fdot2_replicated(float[2] src0, float[2] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      ((src0.y * src1.y) + (src0.x * src1.x))

  Builder function:

  nir_def *nir_fdot2_replicated(nir_builder*, nir_def *src0, nir_def *src1)

fdot4_replicated(float[4] src0, float[4] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      ((src0.w * src1.w) + (src0.z * src1.z) + (src0.y * src1.y) + (src0.x * src1.x))

  Builder function:

  nir_def *nir_fdot4_replicated(nir_builder*, nir_def *src0, nir_def *src1)

fdot8_replicated(float[8] src0, float[8] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      ((src0.h * src1.h) + (src0.g * src1.g) + (src0.f * src1.f) + (src0.e * src1.e) + (src0.w * src1.w) + (src0.z * src1.z) + (src0.y * src1.y) + (src0.x * src1.x))

  Builder function:

  nir_def *nir_fdot8_replicated(nir_builder*, nir_def *src0, nir_def *src1)

fdot16_replicated(float[16] src0, float[16] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      ((src0.p * src1.p) + (src0.o * src1.o) + (src0.n * src1.n) + (src0.m * src1.m) + (src0.l * src1.l) + (src0.k * src1.k) + (src0.j * src1.j) + (src0.i * src1.i) + (src0.h * src1.h) + (src0.g * src1.g) + (src0.f * src1.f) + (src0.e * src1.e) + (src0.w * src1.w) + (src0.z * src1.z) + (src0.y * src1.y) + (src0.x * src1.x))

  Builder function:

  nir_def *nir_fdot16_replicated(nir_builder*, nir_def *src0, nir_def *src1)

fdot3_replicated(float[3] src0, float[3] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      ((src0.z * src1.z) + (src0.y * src1.y) + (src0.x * src1.x))

  Builder function:

  nir_def *nir_fdot3_replicated(nir_builder*, nir_def *src0, nir_def *src1)

fdot5_replicated(float[5] src0, float[5] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      ((src0.e * src1.e) + (src0.w * src1.w) + (src0.z * src1.z) + (src0.y * src1.y) + (src0.x * src1.x))

  Builder function:

  nir_def *nir_fdot5_replicated(nir_builder*, nir_def *src0, nir_def *src1)

fdph(float[3] src0, float[4] src1) → float[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      src0.x * src1.x + src0.y * src1.y + src0.z * src1.z + src1.w

  Builder function:

  nir_def *nir_fdph(nir_builder*, nir_def *src0, nir_def *src1)

fdph_replicated(float[3] src0, float[4] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0.x * src1.x + src0.y * src1.y + src0.z * src1.z + src1.w

  Builder function:

  nir_def *nir_fdph_replicated(nir_builder*, nir_def *src0, nir_def *src1)

fmin(float[N] src0, float[N] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      util_min_num(src0, src1)

  Builder function:

  nir_def *nir_fmin(nir_builder*, nir_def *src0, nir_def *src1)

fmax(float[N] src0, float[N] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      util_max_num(src0, src1)

  Builder function:

  nir_def *nir_fmax(nir_builder*, nir_def *src0, nir_def *src1)

imin(int[N] src0, int[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      MIN2(src0, src1)

  Builder function:

  nir_def *nir_imin(nir_builder*, nir_def *src0, nir_def *src1)

umin(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      MIN2(src0, src1)

  Builder function:

  nir_def *nir_umin(nir_builder*, nir_def *src0, nir_def *src1)

imax(int[N] src0, int[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      MAX2(src0, src1)

  Builder function:

  nir_def *nir_imax(nir_builder*, nir_def *src0, nir_def *src1)

umax(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      MAX2(src0, src1)

  Builder function:

  nir_def *nir_umax(nir_builder*, nir_def *src0, nir_def *src1)

fpow(float[N] src0, float[N] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      bit_size == 64 ? pow(src0, src1) : powf(src0, src1)

  Builder function:

  nir_def *nir_fpow(nir_builder*, nir_def *src0, nir_def *src1)

pack_half_2x16_split(float32[1] src0, float32[1] src1) → uint32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      pack_half_1x16(src0.x) | ((uint32_t)pack_half_1x16(src1.x) << 16)

  Builder function:

  nir_def *nir_pack_half_2x16_split(nir_builder*, nir_def *src0, nir_def *src1)

pack_half_2x16_rtz_split(float32[1] src0, float32[1] src1) → uint32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      pack_half_1x16_rtz(src0.x) | ((uint32_t)pack_half_1x16_rtz(src1.x) << 16)

  Builder function:

  nir_def *nir_pack_half_2x16_rtz_split(nir_builder*, nir_def *src0, nir_def *src1)

pack_64_2x32_split(uint32[N] src0, uint32[N] src1) → uint64[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 | ((uint64_t)src1 << 32)

  Builder function:

  nir_def *nir_pack_64_2x32_split(nir_builder*, nir_def *src0, nir_def *src1)

pack_32_2x16_split(uint16[N] src0, uint16[N] src1) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 | ((uint32_t)src1 << 16)

  Builder function:

  nir_def *nir_pack_32_2x16_split(nir_builder*, nir_def *src0, nir_def *src1)

pack_32_4x8_split(uint8[N] src0, uint8[N] src1, uint8[N] src2, uint8[N] src3) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 | ((uint32_t)src1 << 8) | ((uint32_t)src2 << 16) | ((uint32_t)src3 << 24)

  Builder function:

  nir_def *nir_pack_32_4x8_split(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2, nir_def *src3)

bfm(int32[N] src0, int32[N] src1) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Implements the behavior of the first operation of the SM5 “bfi” assembly and that of the “bfi1” i965 instruction. That is, the bits and offset values are from the low five bits of src0 and src1, respectively.

  Constant-folding:

      int bits = src0 & 0x1F;
      int offset = src1 & 0x1F;
      dst = ((1u << bits) - 1) << offset;

  Builder function:

  nir_def *nir_bfm(nir_builder*, nir_def *src0, nir_def *src1)

ldexp(float[N] src0, int32[N] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      dst = (bit_size == 64) ? ldexp(src0, src1) : ldexpf(src0, src1);
      /* flush denormals to zero. */
      if (!isnormal(dst))
         dst = copysignf(0.0f, src0);

  Builder function:

  nir_def *nir_ldexp(nir_builder*, nir_def *src0, nir_def *src1)

fcopysign_pco(float[N] src0, float[N] src1) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      bit_size == 64 ? copysign(src0, src1) : copysignf(src0, src1)

  Builder function:

  nir_def *nir_fcopysign_pco(nir_builder*, nir_def *src0, nir_def *src1)

vec2(uint[1] src0, uint[1] src1) → uint[2]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Description: Combines the first component of each input to make a 2-component vector.

  Constant-folding:

      dst.x = src0.x;
      dst.y = src1.x;

  Builder function:

  nir_def *nir_vec2(nir_builder*, nir_def *src0, nir_def *src1)

extract_u8(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if ((uint64_t)(src1 * 8) >= bit_size) {
         dst = 0;
         poison = true;
      } else {
         dst = (uint8_t)(src0 >> (src1 * 8));
      }

  Builder function:

  nir_def *nir_extract_u8(nir_builder*, nir_def *src0, nir_def *src1)

extract_i8(int[N] src0, int[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if ((uint64_t)(src1 * 8) >= bit_size) {
         dst = 0;
         poison = true;
      } else {
         dst = (int8_t)(src0 >> (src1 * 8));
      }

  Builder function:

  nir_def *nir_extract_i8(nir_builder*, nir_def *src0, nir_def *src1)

extract_u16(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if ((uint64_t)(src1 * 16) >= bit_size) {
         dst = 0;
         poison = true;
      } else {
         dst = (uint16_t)(src0 >> (src1 * 16));
      }

  Builder function:

  nir_def *nir_extract_u16(nir_builder*, nir_def *src0, nir_def *src1)

extract_i16(int[N] src0, int[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if ((uint64_t)(src1 * 16) >= bit_size) {
         dst = 0;
         poison = true;
      } else {
         dst = (int16_t)(src0 >> (src1 * 16));
      }

  Builder function:

  nir_def *nir_extract_i16(nir_builder*, nir_def *src0, nir_def *src1)

insert_u8(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if ((uint64_t)(src1 * 8) >= bit_size) {
         dst = 0;
         poison = true;
      } else {
         dst = (src0 & 0xff) << (src1 * 8);
      }

  Builder function:

  nir_def *nir_insert_u8(nir_builder*, nir_def *src0, nir_def *src1)

insert_u16(uint[N] src0, uint[N] src1) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      if ((uint64_t)(src1 * 16) >= bit_size) {
         dst = 0;
         poison = true;
      } else {
         dst = (src0 & 0xffff) << (src1 * 16);
      }

  Builder function:

  nir_def *nir_insert_u16(nir_builder*, nir_def *src0, nir_def *src1)

ffma(float[N] src0, float[N] src1, float[N] src2) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      if (nir_is_rounding_mode_rtz(execution_mode, bit_size)) {
         if (bit_size == 64)
            dst = _mesa_double_fma_rtz(src0, src1, src2);
         else if (bit_size == 32)
            dst = _mesa_float_fma_rtz(src0, src1, src2);
         else
            dst = _mesa_double_to_float_rtz(_mesa_double_fma_rtz(src0, src1, src2));
      } else {
         if (bit_size == 32)
            dst = fmaf(src0, src1, src2);
         else
            dst = fma(src0, src1, src2);
      }

  Builder function:

  nir_def *nir_ffma(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

ffmaz(float32[N] src0, float32[N] src1, float32[N] src2) → float32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Description: Floating-point multiply-add with modified zero handling.

  Unlike `ffma`, anything (even infinity or NaN) multiplied by +/-0.0 is +0.0. `ffmaz(0.0, inf, src2)` and `ffmaz(0.0, nan, src2)` must be `+0.0 + src2`.

  Constant-folding:

      if (src0 == 0.0 || src1 == 0.0)
         dst = 0.0 + src2;
      else if (nir_is_rounding_mode_rtz(execution_mode, 32))
         dst = _mesa_float_fma_rtz(src0, src1, src2);
      else
         dst = fmaf(src0, src1, src2);

  Builder function:

  nir_def *nir_ffmaz(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

flrp(float[N] src0, float[N] src1, float[N] src2) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 * (1 - src2) + src1 * src2

  Builder function:

  nir_def *nir_flrp(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

iadd3(int[N] src0, int[N] src1, int[N] src2) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Description: Ternary addition

  Constant-folding:

      (uint64_t)src0 + (uint64_t)src1 + (uint64_t)src2

  Builder function:

  nir_def *nir_iadd3(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

imad(int[N] src0, int[N] src1, int[N] src2) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Description: Integer multiply-add

  Constant-folding:

      src0 * src1 + src2

  Builder function:

  nir_def *nir_imad(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

fcsel(float32[N] src0, float32[N] src1, float32[N] src2) → float32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: A vector conditional select instruction (like ?:, but operating per- component on vectors). The condition is a floating point bool (0.0 vs 1.0).

  Constant-folding:

      (src0 != 0.0f) ? src1 : src2

  Builder function:

  nir_def *nir_fcsel(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

bcsel(bool1[N] src0, uint[N] src1, uint[N] src2) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: A vector conditional select instruction (like ?:, but operating per- component on vectors). The condition is a 1-bit bool (0 vs 1).

  Constant-folding:

      src0 ? src1 : src2

  Builder function:

  nir_def *nir_bcsel(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

b8csel(bool8[N] src0, uint[N] src1, uint[N] src2) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: A vector conditional select instruction (like ?:, but operating per- component on vectors). The condition is an 8-bit bool (0 vs ~0).

  Constant-folding:

      src0 ? src1 : src2

  Builder function:

  nir_def *nir_b8csel(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

b16csel(bool16[N] src0, uint[N] src1, uint[N] src2) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: A vector conditional select instruction (like ?:, but operating per- component on vectors). The condition is a 16-bit bool (0 vs ~0).

  Constant-folding:

      src0 ? src1 : src2

  Builder function:

  nir_def *nir_b16csel(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

b32csel(bool32[N] src0, uint[N] src1, uint[N] src2) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: A vector conditional select instruction (like ?:, but operating per- component on vectors). The condition is a 32-bit bool (0 vs ~0).

  Constant-folding:

      src0 ? src1 : src2

  Builder function:

  nir_def *nir_b32csel(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

icsel_eqz(int[N] src0, int[N] src1, int[N] src2) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 == 0) ? src1 : src2

  Builder function:

  nir_def *nir_icsel_eqz(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

i32csel_gt(int32[N] src0, int32[N] src1, int32[N] src2) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 > 0) ? src1 : src2

  Builder function:

  nir_def *nir_i32csel_gt(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

i32csel_ge(int32[N] src0, int32[N] src1, int32[N] src2) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 >= 0) ? src1 : src2

  Builder function:

  nir_def *nir_i32csel_ge(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

fcsel_gt(float32[N] src0, float32[N] src1, float32[N] src2) → float32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 > 0.0f) ? src1 : src2

  Builder function:

  nir_def *nir_fcsel_gt(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

fcsel_ge(float32[N] src0, float32[N] src1, float32[N] src2) → float32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 >= 0.0f) ? src1 : src2

  Builder function:

  nir_def *nir_fcsel_ge(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

bfi(uint32[N] src0, uint32[N] src1, uint32[N] src2) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: SM5 bfi assembly

  Constant-folding:

      unsigned mask = src0, insert = src1, base = src2;
      if (mask == 0) {
         dst = base;
      } else {
         unsigned tmp = mask;
         while (!(tmp & 1)) {
            tmp >>= 1;
            insert <<= 1;
         }
         dst = (base & ~mask) | (insert & mask);
      }

  Builder function:

  nir_def *nir_bfi(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

bitfield_select(uint[N] src0, uint[N] src1, uint[N] src2) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 & src1) | (~src0 & src2)

  Builder function:

  nir_def *nir_bitfield_select(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

ubfe(uint32[N] src0, uint32[N] src1, uint32[N] src2) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      unsigned base = src0;
      unsigned offset = src1 & 0x1F;
      unsigned bits = src2 & 0x1F;
      if (bits == 0) {
         dst = 0;
      } else if (offset + bits < 32) {
         dst = (base << (32 - bits - offset)) >> (32 - bits);
      } else {
         dst = base >> offset;
      }

  Builder function:

  nir_def *nir_ubfe(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

ibfe(int32[N] src0, uint32[N] src1, uint32[N] src2) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      uint32_t base = src0;
      unsigned offset = src1 & 0x1F;
      unsigned bits = src2 & 0x1F;
      if (bits == 0) {
         dst = 0;
      } else if (offset + bits < 32) {
         dst = util_mask_sign_extend(base >> offset, bits);
      } else {
         dst = util_mask_sign_extend(base >> offset, 32 - offset);
      }

  Builder function:

  nir_def *nir_ibfe(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

ubitfield_extract(uint[N] src0, int32[N] src1, int32[N] src2) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      unsigned base = src0;
      int offset = src1, bits = src2;
      if (bits == 0) {
         dst = 0;
      } else if (bits < 0 || offset < 0 || offset + bits > bit_size) {
         dst = 0; /* undefined per the spec */
         poison = true;
      } else {
         dst = (base >> offset) & ((1ull << bits) - 1);
      }

  Builder function:

  nir_def *nir_ubitfield_extract(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

ibitfield_extract(int[N] src0, int32[N] src1, int32[N] src2) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      int base = src0;
      int offset = src1, bits = src2;
      if (bits == 0) {
         dst = 0;
      } else if (offset < 0 || bits < 0 || offset + bits > bit_size) {
         dst = 0;
         poison = true;
      } else {
         dst = (int32_t)((uint32_t)base << (32 - offset - bits)) >> (32 - bits); /* use sign-extending shift */
      }

  Builder function:

  nir_def *nir_ibitfield_extract(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

msad_4x8(uint32[N] src0, uint32[N] src1, uint32[N] src2) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: Masked sum of absolute differences with accumulation. Equivalent to AMD’s v_msad_u8 instruction and DXIL’s MSAD.

  The first two sources contain packed 8-bit unsigned integers, the instruction will calculate the absolute difference of integers when src0’s is non-zero, and then add them together. There is also a third source which is a 32-bit unsigned integer and added to the result.

  Constant-folding:

      dst = msad(src0, src1, src2);

  Builder function:

  nir_def *nir_msad_4x8(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

mqsad_4x8(uint32[1] src0, uint32[2] src1, uint32[4] src2) → uint32[4]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      uint64_t src = src1.x | ((uint64_t)src1.y << 32);
      dst.x = msad(src0.x, src, src2.x);
      dst.y = msad(src0.x, src >> 8, src2.y);
      dst.z = msad(src0.x, src >> 16, src2.z);
      dst.w = msad(src0.x, src >> 24, src2.w);

  Builder function:

  nir_def *nir_mqsad_4x8(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

vec3(uint[1] src0, uint[1] src1, uint[1] src2) → uint[3]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = src0.x;
      dst.y = src1.x;
      dst.z = src2.x;

  Builder function:

  nir_def *nir_vec3(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

bitfield_insert(uint[N] src0, uint[N] src1, int32[N] src2, int32[N] src3) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      unsigned base = src0, insert = src1;
      int offset = src2, bits = src3;
      if (bits == 0) {
         dst = base;
      } else if (offset < 0 || bits < 0 || bits + offset > 32) {
         dst = 0;
         poison = true;
      } else {
         unsigned mask = ((1ull << bits) - 1) << offset;
         dst = (base & ~mask) | ((insert << offset) & mask);
      }

  Builder function:

  nir_def *nir_bitfield_insert(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2, nir_def *src3)

vec4(uint[1] src0, uint[1] src1, uint[1] src2, uint[1] src3) → uint[4]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = src0.x;
      dst.y = src1.x;
      dst.z = src2.x;
      dst.w = src3.x;

  Builder function:

  nir_def *nir_vec4(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2, nir_def *src3)

vec5(uint[1] src0, uint[1] src1, uint[1] src2, uint[1] src3, uint[1] src4) → uint[5]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = src0.x;
      dst.y = src1.x;
      dst.z = src2.x;
      dst.w = src3.x;
      dst.e = src4.x;

  Builder function:

  nir_def *nir_vec5(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2, nir_def *src3, nir_def *src4)

vec8(uint[1] src0, uint[1] src1, uint[1] src2, uint[1] src3, uint[1] src4, uint[1] src5, uint[1] src6, uint[1] src7) → uint[8]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = src0.x;
      dst.y = src1.x;
      dst.z = src2.x;
      dst.w = src3.x;
      dst.e = src4.x;
      dst.f = src5.x;
      dst.g = src6.x;
      dst.h = src7.x;

  Builder function:

  nir_def *nir_vec8(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2, nir_def *src3, nir_def *src4, nir_def *src5, nir_def *src6, nir_def *src7)

vec16(uint[1] src0, uint[1] src1, uint[1] src2, uint[1] src3, uint[1] src4, uint[1] src5, uint[1] src6, uint[1] src7, uint[1] src8, uint[1] src9, uint[1] src10, uint[1] src11, uint[1] src12, uint[1] src13, uint[1] src14, uint[1] src15) → uint[16]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = src0.x;
      dst.y = src1.x;
      dst.z = src2.x;
      dst.w = src3.x;
      dst.e = src4.x;
      dst.f = src5.x;
      dst.g = src6.x;
      dst.h = src7.x;
      dst.i = src8.x;
      dst.j = src9.x;
      dst.k = src10.x;
      dst.l = src11.x;
      dst.m = src12.x;
      dst.n = src13.x;
      dst.o = src14.x;
      dst.p = src15.x;

  Builder function:

  nir_def *nir_vec16(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2, nir_def *src3, nir_def *src4, nir_def *src5, nir_def *src6, nir_def *src7, nir_def *src8, nir_def *src9, nir_def *src10, nir_def *src11, nir_def *src12, nir_def *src13, nir_def *src14, nir_def *src15)

amul(int[N] src0, int[N] src1) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      src0 * src1

  Builder function:

  nir_def *nir_amul(nir_builder*, nir_def *src0, nir_def *src1)

imadsh_mix16(int32[N] src0, int32[N] src1, int32[N] src2) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      dst = (((int32_t)(((uint32_t)src0 & 0x0000ffff) << 16) * (src1 & 0xffff0000)) >> 16) + src2;

  Builder function:

  nir_def *nir_imadsh_mix16(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

imad24_ir3(int32[N] src0, int32[N] src1, int32[N] src2) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      util_mask_sign_extend(src0, 24) * util_mask_sign_extend(src1, 24) + src2

  Builder function:

  nir_def *nir_imad24_ir3(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

shrm_ir3(uint[N] src0, uint32[N] src1, uint[N] src2) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 >> (src1 & (sizeof(src0) * 8 - 1))) & src2

  Builder function:

  nir_def *nir_shrm_ir3(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

shlm_ir3(uint[N] src0, uint32[N] src1, uint[N] src2) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 << (src1 & (sizeof(src0) * 8 - 1))) & src2

  Builder function:

  nir_def *nir_shlm_ir3(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

shrg_ir3(uint[N] src0, uint32[N] src1, uint[N] src2) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 >> (src1 & (sizeof(src0) * 8 - 1))) | src2

  Builder function:

  nir_def *nir_shrg_ir3(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

shlg_ir3(uint[N] src0, uint32[N] src1, uint[N] src2) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 << (src1 & (sizeof(src0) * 8 - 1))) | src2

  Builder function:

  nir_def *nir_shlg_ir3(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

andg_ir3(uint[N] src0, uint[N] src1, uint[N] src2) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      (src0 & src1) | src2

  Builder function:

  nir_def *nir_andg_ir3(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

cube_amd(float32[3] src0) → float32[4]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = dst.y = dst.z = 0.0;
      float absX = fabsf(src0.x);
      float absY = fabsf(src0.y);
      float absZ = fabsf(src0.z);

      if (absX >= absY && absX >= absZ) { dst.z = 2 * src0.x; }
      if (absY >= absX && absY >= absZ) { dst.z = 2 * src0.y; }
      if (absZ >= absX && absZ >= absY) { dst.z = 2 * src0.z; }

      if (src0.x >= 0 && absX >= absY && absX >= absZ) {
         dst.y = -src0.z; dst.x = -src0.y; dst.w = 0;
      }
      if (src0.x < 0 && absX >= absY && absX >= absZ) {
         dst.y = src0.z; dst.x = -src0.y; dst.w = 1;
      }
      if (src0.y >= 0 && absY >= absX && absY >= absZ) {
         dst.y = src0.x; dst.x = src0.z; dst.w = 2;
      }
      if (src0.y < 0 && absY >= absX && absY >= absZ) {
         dst.y = src0.x; dst.x = -src0.z; dst.w = 3;
      }
      if (src0.z >= 0 && absZ >= absX && absZ >= absY) {
         dst.y = src0.x; dst.x = -src0.y; dst.w = 4;
      }
      if (src0.z < 0 && absZ >= absX && absZ >= absY) {
         dst.y = -src0.x; dst.x = -src0.y; dst.w = 5;
      }

  Builder function:

  nir_def *nir_cube_amd(nir_builder*, nir_def *src0)

fsin_normalized_2_pi(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      sinf(6.2831853 * src0)

  Builder function:

  nir_def *nir_fsin_normalized_2_pi(nir_builder*, nir_def *src0)

fcos_normalized_2_pi(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      cosf(6.2831853 * src0)

  Builder function:

  nir_def *nir_fcos_normalized_2_pi(nir_builder*, nir_def *src0)

alignbyte_amd(uint32[N] src0, uint32[N] src1, uint32[N] src2) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      uint64_t src = src1 | ((uint64_t)src0 << 32);
      dst = src >> ((src2 & 0x3) * 8);

  Builder function:

  nir_def *nir_alignbyte_amd(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

byte_perm_amd(uint32[N] src0, uint32[N] src1, uint32[N] src2) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      uint64_t src = src1 | ((uint64_t)src0 << 32);
      dst = 0;
      for (unsigned i = 0; i < 4; i++) {
         uint8_t sel = (src2 >> (i * 8)) & 0xff;
         unsigned res;
         if (sel >= 13) {
            res = 0xff;
         } else if (sel == 12) {
            res = 0;
         } else if (sel >= 8) {
            res = ((src >> (((sel - 8) * 2 + 1) * 8 + 7)) & 1) * 0xff;
         } else {
            res = (src >> (sel * 8)) & 0xff;
         }
         dst |= res << (i * 8);
      }

  Builder function:

  nir_def *nir_byte_perm_amd(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

fsin_mdg(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      sinf(3.141592653589793 * src0)

  Builder function:

  nir_def *nir_fsin_mdg(nir_builder*, nir_def *src0)

fcos_mdg(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      cosf(3.141592653589793 * src0)

  Builder function:

  nir_def *nir_fcos_mdg(nir_builder*, nir_def *src0)

fsin_agx(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      sinf(src0 * (6.2831853/4.0))

  Builder function:

  nir_def *nir_fsin_agx(nir_builder*, nir_def *src0)

extr_agx(uint32[N] src0, uint32[N] src1, uint32[N] src2, uint32[N] src3) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      uint32_t mask = 0xFFFFFFFF;
      uint8_t shift = src2 & 0x7F;
      if (src3 != 0) {
         mask = (1 << src3) - 1;
      }
      if (shift >= 64) {
          dst = 0;
      } else {
          dst = (((((uint64_t) src1) << 32) | (uint64_t) src0) >> shift) & mask;
      }

  Builder function:

  nir_def *nir_extr_agx(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2, nir_def *src3)

imadshl_agx(int[N] src0, int[N] src1, int[N] src2, int[N] src3) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 * src1) + (src2 << src3)

  Builder function:

  nir_def *nir_imadshl_agx(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2, nir_def *src3)

imsubshl_agx(int[N] src0, int[N] src1, int[N] src2, int[N] src3) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 * src1) - (src2 << src3)

  Builder function:

  nir_def *nir_imsubshl_agx(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2, nir_def *src3)

ilea_agx(uint64[N] src0, int32[N] src1, uint32[N] src2) → uint64[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 + (((int64_t)src1) << src2)

  Builder function:

  nir_def *nir_ilea_agx(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

ulea_agx(uint64[N] src0, uint32[N] src1, uint32[N] src2) → uint64[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 + (((uint64_t)src1) << src2)

  Builder function:

  nir_def *nir_ulea_agx(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

bounds_agx(int[N] src0, int[N] src1, int[N] src2) → int[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src1 <= src2 ? src0 : 0

  Builder function:

  nir_def *nir_bounds_agx(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

interleave(uint16[N] src0, uint16[N] src1) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description:

    Interleave bits of 16-bit integers to calculate a 32-bit integer. This can be used as-is for Morton encoding.

  Constant-folding:

      dst = 0;
      for (unsigned bit = 0; bit < 16; bit++) {
          dst |= (src0 & (1 << bit)) << bit;
          dst |= (src1 & (1 << bit)) << (bit + 1);
      }

  Builder function:

  nir_def *nir_interleave(nir_builder*, nir_def *src0, nir_def *src1)

fmin_agx(uint32[N] src0, uint32[N] src1) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      nir_const_value src0_cv = nir_const_value_for_raw_uint(src0, 32);
      nir_const_value src1_cv = nir_const_value_for_raw_uint(src1, 32);
      float src0_f = get_float_source(src0_cv, execution_mode, 32);
      float src1_f = get_float_source(src1_cv, execution_mode, 32);
      dst = (src0_f < src1_f || isnan(src1_f)) ? src0 : src1;

  Builder function:

  nir_def *nir_fmin_agx(nir_builder*, nir_def *src0, nir_def *src1)

fmax_agx(uint32[N] src0, uint32[N] src1) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      nir_const_value src0_cv = nir_const_value_for_raw_uint(src0, 32);
      nir_const_value src1_cv = nir_const_value_for_raw_uint(src1, 32);
      float src0_f = get_float_source(src0_cv, execution_mode, 32);
      float src1_f = get_float_source(src1_cv, execution_mode, 32);
      dst = (src0_f > src1_f || isnan(src1_f)) ? src0 : src1;

  Builder function:

  nir_def *nir_fmax_agx(nir_builder*, nir_def *src0, nir_def *src1)

prmt_nv(uint32[N] src0, uint32[N] src1, uint32[N] src2) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      dst = 0;
      for (unsigned i = 0; i < 4; i++) {
          uint8_t byte = (src0 >> (i * 4)) & 0x7;
          uint8_t x = byte < 4 ? (src1 >> (byte * 8))
                               : (src2 >> ((byte - 4) * 8));
          if ((src0 >> (i * 4)) & 0x8)
              x = ((int8_t)x) >> 7;
          dst |= ((uint32_t)x) << i * 8;
      }

  Builder function:

  nir_def *nir_prmt_nv(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

lea_nv(uint[N] src0, uint[N] src1, uint32[N] src2) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      src0 + (src1 << (src2 % bit_size))

  Builder function:

  nir_def *nir_lea_nv(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

imul24(int32[N] src0, int32[N] src1) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      util_mask_sign_extend(src0, 24) * util_mask_sign_extend(src1, 24)

  Builder function:

  nir_def *nir_imul24(nir_builder*, nir_def *src0, nir_def *src1)

umad24(uint32[N] src0, uint32[N] src1, uint32[N] src2) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      (((uint32_t)src0 << 8) >> 8) * (((uint32_t)src1 << 8) >> 8) + src2

  Builder function:

  nir_def *nir_umad24(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

umul24(int32[N] src0, int32[N] src1) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      (((uint32_t)src0 << 8) >> 8) * (((uint32_t)src1 << 8) >> 8)

  Builder function:

  nir_def *nir_umul24(nir_builder*, nir_def *src0, nir_def *src1)

imul24_relaxed(int32[N] src0, int32[N] src1) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      dst = src0 * src1;
      if (util_mask_sign_extend(src0, 24) != src0 || util_mask_sign_extend(src1, 24) != src1)
          poison = true;

  Builder function:

  nir_def *nir_imul24_relaxed(nir_builder*, nir_def *src0, nir_def *src1)

umad24_relaxed(uint32[N] src0, uint32[N] src1, uint32[N] src2) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      dst = src0 * src1 + src2;
      if ((src0 | src1) & ~BITFIELD_MASK(24))
          poison = true;

  Builder function:

  nir_def *nir_umad24_relaxed(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

umul24_relaxed(uint32[N] src0, uint32[N] src1) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      dst = src0 * src1;
      if ((src0 | src1) & ~BITFIELD_MASK(24))
          poison = true;

  Builder function:

  nir_def *nir_umul24_relaxed(nir_builder*, nir_def *src0, nir_def *src1)

fisnormal(float[N] src0) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: preserve_inf preserve_nan

  Constant-folding:

      isnormal(src0)

  Builder function:

  nir_def *nir_fisnormal(nir_builder*, nir_def *src0)

fisfinite(float[N] src0) → bool1[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: preserve_inf preserve_nan

  Constant-folding:

      isfinite(src0)

  Builder function:

  nir_def *nir_fisfinite(nir_builder*, nir_def *src0)

fisfinite32(float[N] src0) → bool32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: preserve_inf preserve_nan

  Constant-folding:

      isfinite(src0)

  Builder function:

  nir_def *nir_fisfinite32(nir_builder*, nir_def *src0)

ldexp16_pan(float16[N] src0, int16[N] src1) → float16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      dst = ldexpf(src0, src1);
      /* flush denormals to zero. */
      if (!isnormal(dst))
         dst = copysignf(0.0f, src0);

  Builder function:

  nir_def *nir_ldexp16_pan(nir_builder*, nir_def *src0, nir_def *src1)

usadd_4x8_vc4(int32[N] src0, int32[N] src1) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      dst = 0;
      for (int i = 0; i < 32; i += 8) {
         dst |= (uint32_t)MIN2(((src0 >> i) & 0xff) + ((src1 >> i) & 0xff), 0xff) << i;
      }

  Builder function:

  nir_def *nir_usadd_4x8_vc4(nir_builder*, nir_def *src0, nir_def *src1)

ussub_4x8_vc4(int32[N] src0, int32[N] src1) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      dst = 0;
      for (int i = 0; i < 32; i += 8) {
         int src0_chan = (src0 >> i) & 0xff;
         int src1_chan = (src1 >> i) & 0xff;
         if (src0_chan > src1_chan)
            dst |= (uint32_t)(src0_chan - src1_chan) << i;
      }

  Builder function:

  nir_def *nir_ussub_4x8_vc4(nir_builder*, nir_def *src0, nir_def *src1)

umin_4x8_vc4(int32[N] src0, int32[N] src1) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      dst = 0;
      for (int i = 0; i < 32; i += 8) {
         dst |= MIN2((src0 >> i) & 0xff, (src1 >> i) & 0xff) << i;
      }

  Builder function:

  nir_def *nir_umin_4x8_vc4(nir_builder*, nir_def *src0, nir_def *src1)

umax_4x8_vc4(int32[N] src0, int32[N] src1) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      dst = 0;
      for (int i = 0; i < 32; i += 8) {
         dst |= MAX2((src0 >> i) & 0xff, (src1 >> i) & 0xff) << i;
      }

  Builder function:

  nir_def *nir_umax_4x8_vc4(nir_builder*, nir_def *src0, nir_def *src1)

umul_unorm_4x8_vc4(uint32[N] src0, uint32[N] src1) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      dst = 0;
      for (int i = 0; i < 32; i += 8) {
         uint32_t src0_chan = (src0 >> i) & 0xff;
         uint32_t src1_chan = (src1 >> i) & 0xff;
         dst |= ((src0_chan * src1_chan) / 255) << i;
      }

  Builder function:

  nir_def *nir_umul_unorm_4x8_vc4(nir_builder*, nir_def *src0, nir_def *src1)

pack_32_to_r11g11b10_v3d(uint32[N] src0, uint32[N] src1) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      pack_32_to_r11g11b10_v3d(src0, src1)

  Builder function:

  nir_def *nir_pack_32_to_r11g11b10_v3d(nir_builder*, nir_def *src0, nir_def *src1)

pack_2x32_to_2x16_v3d(uint32[1] src0, uint32[1] src1) → uint32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      (src0.x & 0xffff) | (src1.x << 16)

  Builder function:

  nir_def *nir_pack_2x32_to_2x16_v3d(nir_builder*, nir_def *src0, nir_def *src1)

pack_uint_32_to_r10g10b10a2_v3d(uint32[N] src0, uint32[N] src1) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 & 0x3ff) | ((src0 >> 16) & 0x3ff) << 10 | (src1 & 0x3ff) << 20 | ((src1 >> 16) & 0x3ff) << 30

  Builder function:

  nir_def *nir_pack_uint_32_to_r10g10b10a2_v3d(nir_builder*, nir_def *src0, nir_def *src1)

pack_4x16_to_4x8_v3d(uint32[N] src0, uint32[N] src1) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      (src0 & 0x000000ff) | (src0 & 0x00ff0000) >> 8 | (src1 & 0x000000ff) << 16 | (src1 & 0x00ff0000) << 8

  Builder function:

  nir_def *nir_pack_4x16_to_4x8_v3d(nir_builder*, nir_def *src0, nir_def *src1)

pack_2x16_to_unorm_2x8_v3d(uint32[N] src0) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      _mesa_half_to_unorm(src0 & 0xffff, 8) | (_mesa_half_to_unorm(src0 >> 16, 8) << 16)

  Builder function:

  nir_def *nir_pack_2x16_to_unorm_2x8_v3d(nir_builder*, nir_def *src0)

pack_2x16_to_snorm_2x8_v3d(uint32[N] src0) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      _mesa_half_to_snorm(src0 & 0xffff, 8) | ((uint32_t)(_mesa_half_to_snorm(src0 >> 16, 8)) << 16)

  Builder function:

  nir_def *nir_pack_2x16_to_snorm_2x8_v3d(nir_builder*, nir_def *src0)

f2unorm_16_v3d(uint32[N] src0) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      _mesa_float_to_unorm16(src0)

  Builder function:

  nir_def *nir_f2unorm_16_v3d(nir_builder*, nir_def *src0)

f2snorm_16_v3d(uint32[N] src0) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      _mesa_float_to_snorm16(src0)

  Builder function:

  nir_def *nir_f2snorm_16_v3d(nir_builder*, nir_def *src0)

unorm2f_16_v3d(uint32[N] src0) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      _mesa_unorm_to_float(src0, 16)

  Builder function:

  nir_def *nir_unorm2f_16_v3d(nir_builder*, nir_def *src0)

snorm2f_16_v3d(uint32[N] src0) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      _mesa_snorm_to_float(src0, 16)

  Builder function:

  nir_def *nir_snorm2f_16_v3d(nir_builder*, nir_def *src0)

pack_2x16_to_unorm_2x10_v3d(uint32[N] src0) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      pack_2x16_to_unorm_2x10(src0)

  Builder function:

  nir_def *nir_pack_2x16_to_unorm_2x10_v3d(nir_builder*, nir_def *src0)

pack_2x16_to_unorm_10_2_v3d(uint32[N] src0) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      pack_2x16_to_unorm_10_2(src0)

  Builder function:

  nir_def *nir_pack_2x16_to_unorm_10_2_v3d(nir_builder*, nir_def *src0)

fsat_signed(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      fmin(fmax(src0, -1.0), 1.0)

  Builder function:

  nir_def *nir_fsat_signed(nir_builder*, nir_def *src0)

fclamp_pos(float[N] src0) → float[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      fmax(src0, 0.0)

  Builder function:

  nir_def *nir_fclamp_pos(nir_builder*, nir_def *src0)

b32fcsel_mdg(bool32[N] src0, float[N] src1, float[N] src2) → uint[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Description: A vector conditional select instruction (like ?:, but operating per- component on vectors). The condition is a 32-bit bool (0 vs ~0).

  > This Midgard-specific variant takes floating-point sources, rather than integer sources. That includes support for floating point modifiers in the backend.

  Constant-folding:

      src0 ? src1 : src2

  Builder function:

  nir_def *nir_b32fcsel_mdg(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

pack_double_2x32_dxil(uint32[2] src0) → uint64[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = src0.x | ((uint64_t)src0.y << 32);

  Builder function:

  nir_def *nir_pack_double_2x32_dxil(nir_builder*, nir_def *src0)

unpack_double_2x32_dxil(uint64[1] src0) → uint32[2]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      dst.x = src0.x; dst.y = src0.x >> 32;

  Builder function:

  nir_def *nir_unpack_double_2x32_dxil(nir_builder*, nir_def *src0)

unpack_half_x_dxil(uint32[N] src0) → float32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      unpack_half_1x16((uint16_t)(src0 & 0xffff), nir_is_denorm_flush_to_zero(execution_mode, 16))

  Builder function:

  nir_def *nir_unpack_half_x_dxil(nir_builder*, nir_def *src0)

sdot_4x8_iadd(uint32[N] src0, uint32[N] src1, int32[N] src2) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      const int32_t v0x = (int8_t)(src0      );
      const int32_t v0y = (int8_t)(src0 >>  8);
      const int32_t v0z = (int8_t)(src0 >> 16);
      const int32_t v0w = (int8_t)(src0 >> 24);
      const int32_t v1x = (int8_t)(src1      );
      const int32_t v1y = (int8_t)(src1 >>  8);
      const int32_t v1z = (int8_t)(src1 >> 16);
      const int32_t v1w = (int8_t)(src1 >> 24);

      dst = (v0x * v1x) + (v0y * v1y) + (v0z * v1z) + (v0w * v1w) + src2;

  Builder function:

  nir_def *nir_sdot_4x8_iadd(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

udot_4x8_uadd(uint32[N] src0, uint32[N] src1, uint32[N] src2) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      const uint32_t v0x = (uint8_t)(src0      );
      const uint32_t v0y = (uint8_t)(src0 >>  8);
      const uint32_t v0z = (uint8_t)(src0 >> 16);
      const uint32_t v0w = (uint8_t)(src0 >> 24);
      const uint32_t v1x = (uint8_t)(src1      );
      const uint32_t v1y = (uint8_t)(src1 >>  8);
      const uint32_t v1z = (uint8_t)(src1 >> 16);
      const uint32_t v1w = (uint8_t)(src1 >> 24);

      dst = (v0x * v1x) + (v0y * v1y) + (v0z * v1z) + (v0w * v1w) + src2;

  Builder function:

  nir_def *nir_udot_4x8_uadd(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

sudot_4x8_iadd(uint32[N] src0, uint32[N] src1, int32[N] src2) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      const int32_t v0x = (int8_t)(src0      );
      const int32_t v0y = (int8_t)(src0 >>  8);
      const int32_t v0z = (int8_t)(src0 >> 16);
      const int32_t v0w = (int8_t)(src0 >> 24);
      const uint32_t v1x = (uint8_t)(src1      );
      const uint32_t v1y = (uint8_t)(src1 >>  8);
      const uint32_t v1z = (uint8_t)(src1 >> 16);
      const uint32_t v1w = (uint8_t)(src1 >> 24);

      dst = (v0x * v1x) + (v0y * v1y) + (v0z * v1z) + (v0w * v1w) + src2;

  Builder function:

  nir_def *nir_sudot_4x8_iadd(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

sdot_4x8_iadd_sat(uint32[N] src0, uint32[N] src1, int32[N] src2) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      const int64_t v0x = (int8_t)(src0      );
      const int64_t v0y = (int8_t)(src0 >>  8);
      const int64_t v0z = (int8_t)(src0 >> 16);
      const int64_t v0w = (int8_t)(src0 >> 24);
      const int64_t v1x = (int8_t)(src1      );
      const int64_t v1y = (int8_t)(src1 >>  8);
      const int64_t v1z = (int8_t)(src1 >> 16);
      const int64_t v1w = (int8_t)(src1 >> 24);

      const int64_t tmp = (v0x * v1x) + (v0y * v1y) + (v0z * v1z) + (v0w * v1w) + src2;

      dst = tmp >= INT32_MAX ? INT32_MAX : (tmp <= INT32_MIN ? INT32_MIN : tmp);

  Builder function:

  nir_def *nir_sdot_4x8_iadd_sat(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

udot_4x8_uadd_sat(uint32[N] src0, uint32[N] src1, uint32[N] src2) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      const uint64_t v0x = (uint8_t)(src0      );
      const uint64_t v0y = (uint8_t)(src0 >>  8);
      const uint64_t v0z = (uint8_t)(src0 >> 16);
      const uint64_t v0w = (uint8_t)(src0 >> 24);
      const uint64_t v1x = (uint8_t)(src1      );
      const uint64_t v1y = (uint8_t)(src1 >>  8);
      const uint64_t v1z = (uint8_t)(src1 >> 16);
      const uint64_t v1w = (uint8_t)(src1 >> 24);

      const uint64_t tmp = (v0x * v1x) + (v0y * v1y) + (v0z * v1z) + (v0w * v1w) + src2;

      dst = tmp >= UINT32_MAX ? UINT32_MAX : tmp;

  Builder function:

  nir_def *nir_udot_4x8_uadd_sat(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

sudot_4x8_iadd_sat(uint32[N] src0, uint32[N] src1, int32[N] src2) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      const int64_t v0x = (int8_t)(src0      );
      const int64_t v0y = (int8_t)(src0 >>  8);
      const int64_t v0z = (int8_t)(src0 >> 16);
      const int64_t v0w = (int8_t)(src0 >> 24);
      const uint64_t v1x = (uint8_t)(src1      );
      const uint64_t v1y = (uint8_t)(src1 >>  8);
      const uint64_t v1z = (uint8_t)(src1 >> 16);
      const uint64_t v1w = (uint8_t)(src1 >> 24);

      const int64_t tmp = (v0x * v1x) + (v0y * v1y) + (v0z * v1z) + (v0w * v1w) + src2;

      dst = tmp >= INT32_MAX ? INT32_MAX : (tmp <= INT32_MIN ? INT32_MIN : tmp);

  Builder function:

  nir_def *nir_sudot_4x8_iadd_sat(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

sdot_2x16_iadd(uint32[N] src0, uint32[N] src1, int32[N] src2) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      const int32_t v0x = (int16_t)(src0      );
      const int32_t v0y = (int16_t)(src0 >> 16);
      const int32_t v1x = (int16_t)(src1      );
      const int32_t v1y = (int16_t)(src1 >> 16);

      dst = (v0x * v1x) + (v0y * v1y) + src2;

  Builder function:

  nir_def *nir_sdot_2x16_iadd(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

udot_2x16_uadd(uint32[N] src0, uint32[N] src1, uint32[N] src2) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      const uint32_t v0x = (uint16_t)(src0      );
      const uint32_t v0y = (uint16_t)(src0 >> 16);
      const uint32_t v1x = (uint16_t)(src1      );
      const uint32_t v1y = (uint16_t)(src1 >> 16);

      dst = (v0x * v1x) + (v0y * v1y) + src2;

  Builder function:

  nir_def *nir_udot_2x16_uadd(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

sdot_2x16_iadd_sat(uint32[N] src0, uint32[N] src1, int32[N] src2) → int32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      const int64_t v0x = (int16_t)(src0      );
      const int64_t v0y = (int16_t)(src0 >> 16);
      const int64_t v1x = (int16_t)(src1      );
      const int64_t v1y = (int16_t)(src1 >> 16);

      const int64_t tmp = (v0x * v1x) + (v0y * v1y) + src2;

      dst = tmp >= INT32_MAX ? INT32_MAX : (tmp <= INT32_MIN ? INT32_MIN : tmp);

  Builder function:

  nir_def *nir_sdot_2x16_iadd_sat(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

udot_2x16_uadd_sat(uint32[N] src0, uint32[N] src1, uint32[N] src2) → uint32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      const uint32_t v0x = (uint16_t)(src0      );
      const uint32_t v0y = (uint16_t)(src0 >> 16);
      const uint32_t v1x = (uint16_t)(src1      );
      const uint32_t v1y = (uint16_t)(src1 >> 16);

      /* SPIRV specifies that UDotAccSat is UB if the addition (or muliplication)
       * overflows before the accumulation step.
       */
      uint32_t dp = (v0x * v1x) + (v0y * v1y);
      if (dp < (v0x * v1x))
         poison = true;

      const uint64_t tmp = (uint64_t)dp + src2;

      dst = tmp >= UINT32_MAX ? UINT32_MAX : tmp;

  Builder function:

  nir_def *nir_udot_2x16_uadd_sat(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

bf2f(uint16[N] src0) → float32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      _mesa_bfloat16_bits_to_float(src0)

  Builder function:

  nir_def *nir_bf2f(nir_builder*, nir_def *src0)

f2bf(float32[N] src0) → uint16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      _mesa_float_to_bfloat16_bits_rte(src0)

  Builder function:

  nir_def *nir_f2bf(nir_builder*, nir_def *src0)

bfmul(uint16[N] src0, uint16[N] src1) → uint16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | Y | Y

  Constant-folding:

      const float a = _mesa_bfloat16_bits_to_float(src0);
      const float b = _mesa_bfloat16_bits_to_float(src1);
      dst = _mesa_float_to_bfloat16_bits_rte(a * b);

  Builder function:

  nir_def *nir_bfmul(nir_builder*, nir_def *src0, nir_def *src1)

bffma(uint16[N] src0, uint16[N] src1, uint16[N] src2) → uint16[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | Y

  Constant-folding:

      const float a = _mesa_bfloat16_bits_to_float(src0);
      const float b = _mesa_bfloat16_bits_to_float(src1);
      const float c = _mesa_bfloat16_bits_to_float(src2);
      dst = _mesa_float_to_bfloat16_bits_rte(fmaf(a, b, c));

  Builder function:

  nir_def *nir_bffma(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

bfdot2(uint16[2] src0, uint16[2] src1) → uint16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      _mesa_float_to_bfloat16_bits_rte((_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.y) * _mesa_bfloat16_bits_to_float(src1.y))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.x) * _mesa_bfloat16_bits_to_float(src1.x)))))

  Builder function:

  nir_def *nir_bfdot2(nir_builder*, nir_def *src0, nir_def *src1)

bfdot4(uint16[4] src0, uint16[4] src1) → uint16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      _mesa_float_to_bfloat16_bits_rte((_mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.w) * _mesa_bfloat16_bits_to_float(src1.w))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.z) * _mesa_bfloat16_bits_to_float(src1.z)))) + _mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.y) * _mesa_bfloat16_bits_to_float(src1.y))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.x) * _mesa_bfloat16_bits_to_float(src1.x))))))

  Builder function:

  nir_def *nir_bfdot4(nir_builder*, nir_def *src0, nir_def *src1)

bfdot8(uint16[8] src0, uint16[8] src1) → uint16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      _mesa_float_to_bfloat16_bits_rte((_mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.h) * _mesa_bfloat16_bits_to_float(src1.h))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.g) * _mesa_bfloat16_bits_to_float(src1.g)))) + _mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.f) * _mesa_bfloat16_bits_to_float(src1.f))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.e) * _mesa_bfloat16_bits_to_float(src1.e))))) + _mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.w) * _mesa_bfloat16_bits_to_float(src1.w))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.z) * _mesa_bfloat16_bits_to_float(src1.z)))) + _mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.y) * _mesa_bfloat16_bits_to_float(src1.y))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.x) * _mesa_bfloat16_bits_to_float(src1.x)))))))

  Builder function:

  nir_def *nir_bfdot8(nir_builder*, nir_def *src0, nir_def *src1)

bfdot16(uint16[16] src0, uint16[16] src1) → uint16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      _mesa_float_to_bfloat16_bits_rte((_mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.p) * _mesa_bfloat16_bits_to_float(src1.p))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.o) * _mesa_bfloat16_bits_to_float(src1.o)))) + _mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.n) * _mesa_bfloat16_bits_to_float(src1.n))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.m) * _mesa_bfloat16_bits_to_float(src1.m))))) + _mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.l) * _mesa_bfloat16_bits_to_float(src1.l))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.k) * _mesa_bfloat16_bits_to_float(src1.k)))) + _mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.j) * _mesa_bfloat16_bits_to_float(src1.j))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.i) * _mesa_bfloat16_bits_to_float(src1.i)))))) + _mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.h) * _mesa_bfloat16_bits_to_float(src1.h))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.g) * _mesa_bfloat16_bits_to_float(src1.g)))) + _mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.f) * _mesa_bfloat16_bits_to_float(src1.f))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.e) * _mesa_bfloat16_bits_to_float(src1.e))))) + _mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.w) * _mesa_bfloat16_bits_to_float(src1.w))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.z) * _mesa_bfloat16_bits_to_float(src1.z)))) + _mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.y) * _mesa_bfloat16_bits_to_float(src1.y))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.x) * _mesa_bfloat16_bits_to_float(src1.x))))))))

  Builder function:

  nir_def *nir_bfdot16(nir_builder*, nir_def *src0, nir_def *src1)

bfdot3(uint16[3] src0, uint16[3] src1) → uint16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      _mesa_float_to_bfloat16_bits_rte((_mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.z) * _mesa_bfloat16_bits_to_float(src1.z))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.y) * _mesa_bfloat16_bits_to_float(src1.y)))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.x) * _mesa_bfloat16_bits_to_float(src1.x)))))

  Builder function:

  nir_def *nir_bfdot3(nir_builder*, nir_def *src0, nir_def *src1)

bfdot5(uint16[5] src0, uint16[5] src1) → uint16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      _mesa_float_to_bfloat16_bits_rte((_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.e) * _mesa_bfloat16_bits_to_float(src1.e))) + _mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.w) * _mesa_bfloat16_bits_to_float(src1.w))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.z) * _mesa_bfloat16_bits_to_float(src1.z)))) + _mesa_bfloat16_bits_to_float(_mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.y) * _mesa_bfloat16_bits_to_float(src1.y))) + _mesa_bfloat16_bits_to_float((_mesa_bfloat16_bits_to_float(src0.x) * _mesa_bfloat16_bits_to_float(src1.x)))))))

  Builder function:

  nir_def *nir_bfdot5(nir_builder*, nir_def *src0, nir_def *src1)

bfdot2_bfadd(int16[2] src0, int16[2] src1, int16[1] src2) → int16[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      const float a0 = _mesa_bfloat16_bits_to_float(src0.x);
      const float a1 = _mesa_bfloat16_bits_to_float(src0.y);
      const float b0 = _mesa_bfloat16_bits_to_float(src1.x);
      const float b1 = _mesa_bfloat16_bits_to_float(src1.y);

      float acc = _mesa_bfloat16_bits_to_float(src2.x);
      acc = fmaf(a0, b0, acc);
      acc = fmaf(a1, b1, acc);

      dst.x = _mesa_float_to_bfloat16_bits_rte(acc);

  Builder function:

  nir_def *nir_bfdot2_bfadd(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

bfdot2_fadd(int16[2] src0, int16[2] src1, float32[1] src2) → float32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      const float a0 = _mesa_bfloat16_bits_to_float(src0.x);
      const float a1 = _mesa_bfloat16_bits_to_float(src0.y);
      const float b0 = _mesa_bfloat16_bits_to_float(src1.x);
      const float b1 = _mesa_bfloat16_bits_to_float(src1.y);

      float acc = src2.x;
      acc = fmaf(a0, b0, acc);
      acc = fmaf(a1, b1, acc);

      dst.x = acc;

  Builder function:

  nir_def *nir_bfdot2_fadd(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

e4m3fn2f(uint8[N] src0) → float32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      _mesa_e4m3fn_to_float(src0)

  Builder function:

  nir_def *nir_e4m3fn2f(nir_builder*, nir_def *src0)

f2e4m3fn(float32[N] src0) → uint8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      _mesa_float_to_e4m3fn(src0)

  Builder function:

  nir_def *nir_f2e4m3fn(nir_builder*, nir_def *src0)

f2e4m3fn_sat(float32[N] src0) → uint8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      _mesa_float_to_e4m3fn_sat(src0)

  Builder function:

  nir_def *nir_f2e4m3fn_sat(nir_builder*, nir_def *src0)

f2e4m3fn_satfn(float32[N] src0) → uint8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      isinf(src0) ? 0x7f : _mesa_float_to_e4m3fn_sat(src0)

  Builder function:

  nir_def *nir_f2e4m3fn_satfn(nir_builder*, nir_def *src0)

e5m22f(uint8[N] src0) → float32[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      _mesa_e5m2_to_float(src0)

  Builder function:

  nir_def *nir_e5m22f(nir_builder*, nir_def *src0)

f2e5m2(float32[N] src0) → uint8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      _mesa_float_to_e5m2(src0)

  Builder function:

  nir_def *nir_f2e5m2(nir_builder*, nir_def *src0)

f2e5m2_sat(float32[N] src0) → uint8[N]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  Y | N | N

  Constant-folding:

      _mesa_float_to_e5m2_sat(src0)

  Builder function:

  nir_def *nir_f2e5m2_sat(nir_builder*, nir_def *src0)

f16dot2_fadd(float16[2] src0, float16[2] src1, float[1] src2) → float[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      float acc = src2.x;
      acc = fmaf(src0.x, src1.x, acc);
      acc = fmaf(src0.y, src1.y, acc);

      dst.x = acc;

  Builder function:

  nir_def *nir_f16dot2_fadd(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

e4m3fn_dot4_fadd(uint32[1] src0, uint32[1] src1, float32[1] src2) → float32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      const float a0 = _mesa_e4m3fn_to_float(src0.x);
      const float a1 = _mesa_e4m3fn_to_float(src0.x >> 8);
      const float a2 = _mesa_e4m3fn_to_float(src0.x >> 16);
      const float a3 = _mesa_e4m3fn_to_float(src0.x >> 24);
      const float b0 = _mesa_e4m3fn_to_float(src1.x);
      const float b1 = _mesa_e4m3fn_to_float(src1.x >> 8);
      const float b2 = _mesa_e4m3fn_to_float(src1.x >> 16);
      const float b3 = _mesa_e4m3fn_to_float(src1.x >> 24);

      float acc = src2.x;
      acc = fmaf(a0, b0, acc);
      acc = fmaf(a1, b1, acc);
      acc = fmaf(a2, b2, acc);
      acc = fmaf(a3, b3, acc);

      dst.x = acc;

  Builder function:

  nir_def *nir_e4m3fn_dot4_fadd(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

e5m2_dot4_fadd(uint32[1] src0, uint32[1] src1, float32[1] src2) → float32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | Y

  Constant-folding:

      const float a0 = _mesa_e5m2_to_float(src0.x);
      const float a1 = _mesa_e5m2_to_float(src0.x >> 8);
      const float a2 = _mesa_e5m2_to_float(src0.x >> 16);
      const float a3 = _mesa_e5m2_to_float(src0.x >> 24);
      const float b0 = _mesa_e5m2_to_float(src1.x);
      const float b1 = _mesa_e5m2_to_float(src1.x >> 8);
      const float b2 = _mesa_e5m2_to_float(src1.x >> 16);
      const float b3 = _mesa_e5m2_to_float(src1.x >> 24);

      float acc = src2.x;
      acc = fmaf(a0, b0, acc);
      acc = fmaf(a1, b1, acc);
      acc = fmaf(a2, b2, acc);
      acc = fmaf(a3, b3, acc);

      dst.x = acc;

  Builder function:

  nir_def *nir_e5m2_dot4_fadd(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)

e4m3fn_e5m2_dot4_fadd(uint32[1] src0, uint32[1] src1, float32[1] src2) → float32[1]

  Properties:

  Per-component | Associative | 2-src commutative
  --- | --- | ---
  N | N | N

  Constant-folding:

      const float a0 = _mesa_e4m3fn_to_float(src0.x);
      const float a1 = _mesa_e4m3fn_to_float(src0.x >> 8);
      const float a2 = _mesa_e4m3fn_to_float(src0.x >> 16);
      const float a3 = _mesa_e4m3fn_to_float(src0.x >> 24);
      const float b0 = _mesa_e5m2_to_float(src1.x);
      const float b1 = _mesa_e5m2_to_float(src1.x >> 8);
      const float b2 = _mesa_e5m2_to_float(src1.x >> 16);
      const float b3 = _mesa_e5m2_to_float(src1.x >> 24);

      float acc = src2.x;
      acc = fmaf(a0, b0, acc);
      acc = fmaf(a1, b1, acc);
      acc = fmaf(a2, b2, acc);
      acc = fmaf(a3, b3, acc);

      dst.x = acc;

  Builder function:

  nir_def *nir_e4m3fn_e5m2_dot4_fadd(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)