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. Note that the staurate modifier is only allowed on outputs with the float type.
-
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
-
const char *name¶
-
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_op op¶
Opcode
-
bool exact¶
Indicates that this ALU instruction generates an exact value
This is kind of a mixture of GLSL “precise” and “invariant” and not really equivalent to either. This indicates that the value generated by this operation is high-precision and any code transformations that touch it must ensure that the resulting value is bit-for-bit identical to the original.
-
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_fast_math¶
The float controls bit float_controls2 cares about. That is, NAN/INF/SIGNED_ZERO_PRESERVE only. Allow{Contract,Reassoc,Transform} are still handled through the exact bit, and the other float controls bits (rounding mode and denorm handling) remain in the execution mode only.
-
nir_def def¶
Destination
-
nir_alu_src src[]¶
Sources
The size of the array is given by
nir_op_info.num_inputs
.
-
nir_instr instr¶
-
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_src src¶
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)¶
-
nir_def *nir_mov(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)¶
-
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)¶
-
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)¶
-
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)
. TheGLSL.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)¶
-
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)¶
-
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)¶
-
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)¶
-
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:
fmin(fmax(src0, 0.0), 1.0)
Builder function:
-
nir_def *nir_fsat(nir_builder*, nir_def *src0)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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:
src0
Builder function:
-
nir_def *nir_f2i1(nir_builder*, nir_def *src0)¶
-
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:
src0
Builder function:
-
nir_def *nir_f2i8(nir_builder*, nir_def *src0)¶
-
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:
src0
Builder function:
-
nir_def *nir_f2i16(nir_builder*, nir_def *src0)¶
-
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:
src0
Builder function:
-
nir_def *nir_f2i32(nir_builder*, nir_def *src0)¶
-
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:
src0
Builder function:
-
nir_def *nir_f2i64(nir_builder*, nir_def *src0)¶
-
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:
src0
Builder function:
-
nir_def *nir_f2u1(nir_builder*, nir_def *src0)¶
-
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:
src0
Builder function:
-
nir_def *nir_f2u8(nir_builder*, nir_def *src0)¶
-
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:
src0
Builder function:
-
nir_def *nir_f2u16(nir_builder*, nir_def *src0)¶
-
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:
src0
Builder function:
-
nir_def *nir_f2u32(nir_builder*, nir_def *src0)¶
-
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:
src0
Builder function:
-
nir_def *nir_f2u64(nir_builder*, nir_def *src0)¶
-
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)¶
-
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)¶
-
nir_def *nir_f2f16_rtz(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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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:
src0
Builder function:
-
nir_def *nir_f2imp(nir_builder*, nir_def *src0)¶
-
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:
src0
Builder function:
-
nir_def *nir_f2ump(nir_builder*, nir_def *src0)¶
-
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)¶
-
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)¶
-
nir_def *nir_u2fmp(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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
nir_def *nir_fround_even(nir_builder*, nir_def *src0)¶
- fquantize2f16(float[N] src0) float[N] ¶
Properties:
Per-component
Associative
2-src commutative
Y
N
N
Constant-folding:
(fabs(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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
nir_def *nir_frexp_sig(nir_builder*, nir_def *src0)¶
- fddx(float[N] src0) float[N] ¶
Properties:
Per-component
Associative
2-src commutative
Y
N
N
Description: Calculate the screen-space partial derivative using either fine or coarse derivatives of the input with respect to the X-axis. The constant folding is trivial as the derivative of a constant is 0 if the constant is not Inf or NaN.
Constant-folding:
isfinite(src0) ? 0.0 : NAN
Builder function:
-
nir_def *nir_fddx(nir_builder*, nir_def *src0)¶
-
nir_def *nir_fddx(nir_builder*, nir_def *src0)¶
- fddy(float[N] src0) float[N] ¶
Properties:
Per-component
Associative
2-src commutative
Y
N
N
Description: Calculate the screen-space partial derivative using either fine or coarse derivatives of the input with respect to the Y-axis. The constant folding is trivial as the derivative of a constant is 0 if the constant is not Inf or NaN.
Constant-folding:
isfinite(src0) ? 0.0 : NAN
Builder function:
-
nir_def *nir_fddy(nir_builder*, nir_def *src0)¶
-
nir_def *nir_fddy(nir_builder*, nir_def *src0)¶
- fddx_fine(float[N] src0) float[N] ¶
Properties:
Per-component
Associative
2-src commutative
Y
N
N
Description: Calculate the screen-space partial derivative using fine derivatives of the input with respect to the X-axis. The constant folding is trivial as the derivative of a constant is 0 if the constant is not Inf or NaN.
Constant-folding:
isfinite(src0) ? 0.0 : NAN
Builder function:
-
nir_def *nir_fddx_fine(nir_builder*, nir_def *src0)¶
-
nir_def *nir_fddx_fine(nir_builder*, nir_def *src0)¶
- fddy_fine(float[N] src0) float[N] ¶
Properties:
Per-component
Associative
2-src commutative
Y
N
N
Description: Calculate the screen-space partial derivative using fine derivatives of the input with respect to the Y-axis. The constant folding is trivial as the derivative of a constant is 0 if the constant is not Inf or NaN.
Constant-folding:
isfinite(src0) ? 0.0 : NAN
Builder function:
-
nir_def *nir_fddy_fine(nir_builder*, nir_def *src0)¶
-
nir_def *nir_fddy_fine(nir_builder*, nir_def *src0)¶
- fddx_coarse(float[N] src0) float[N] ¶
Properties:
Per-component
Associative
2-src commutative
Y
N
N
Description: Calculate the screen-space partial derivative using coarse derivatives of the input with respect to the X-axis. The constant folding is trivial as the derivative of a constant is 0 if the constant is not Inf or NaN.
Constant-folding:
isfinite(src0) ? 0.0 : NAN
Builder function:
-
nir_def *nir_fddx_coarse(nir_builder*, nir_def *src0)¶
-
nir_def *nir_fddx_coarse(nir_builder*, nir_def *src0)¶
- fddy_coarse(float[N] src0) float[N] ¶
Properties:
Per-component
Associative
2-src commutative
Y
N
N
Description: Calculate the screen-space partial derivative using coarse derivatives of the input with respect to the Y-axis. The constant folding is trivial as the derivative of a constant is 0 if the constant is not Inf or NaN.
Constant-folding:
isfinite(src0) ? 0.0 : NAN
Builder function:
-
nir_def *nir_fddy_coarse(nir_builder*, nir_def *src0)¶
-
nir_def *nir_fddy_coarse(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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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 << 0) | (src0.y << 8) | (src0.z << 16) | (src0.w << 24);
Builder function:
-
nir_def *nir_pack_uvec4_to_uint(nir_builder*, nir_def *src0)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
nir_def *nir_unpack_half_2x16(nir_builder*, nir_def *src0)¶
- unpack_half_2x16_split_x(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_2x16_split_x(nir_builder*, nir_def *src0)¶
-
nir_def *nir_unpack_half_2x16_split_x(nir_builder*, nir_def *src0)¶
- unpack_half_2x16_split_y(uint32[N] src0) float32[N] ¶
Properties:
Per-component
Associative
2-src commutative
Y
N
N
Constant-folding:
unpack_half_1x16((uint16_t)(src0 >> 16), nir_is_denorm_flush_to_zero(execution_mode, 16))
Builder function:
-
nir_def *nir_unpack_half_2x16_split_y(nir_builder*, nir_def *src0)¶
-
nir_def *nir_unpack_half_2x16_split_y(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)¶
-
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)¶
-
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)¶
-
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)¶
-
nir_def *nir_unpack_64_2x32_split_y(nir_builder*, nir_def *src0)¶
- bitfield_reverse(uint32[N] src0) uint32[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 < 32; bit++) dst |= ((src0 >> bit) & 1) << (31 - bit);
Builder function:
-
nir_def *nir_bitfield_reverse(nir_builder*, nir_def *src0)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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 (((src0 << bit) & 0x80000000u) != sign) { dst = bit; break; } }
Builder function:
-
nir_def *nir_ifind_msb_rev(nir_builder*, nir_def *src0)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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:
src1 > 0 ? (src0 + src1 < src0 ? u_intN_max(bit_size) : src0 + src1) : (src0 < src0 + src1 ? u_intN_min(bit_size) : src0 + src1)
Builder function:
-
nir_def *nir_iadd_sat(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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:
(src0 + src1) < src0 ? u_uintN_max(sizeof(src0) * 8) : (src0 + src1)
Builder function:
-
nir_def *nir_uadd_sat(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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:
src1 < 0 ? (src0 - src1 < src0 ? u_intN_max(bit_size) : src0 - src1) : (src0 < src0 - src1 ? u_intN_min(bit_size) : src0 - src1)
Builder function:
-
nir_def *nir_isub_sat(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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)¶
-
nir_def *nir_usub_sat(nir_builder*, nir_def *src0, nir_def *src1)¶
- 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)¶
-
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:
src0 - src1
Builder function:
-
nir_def *nir_isub(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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)¶
-
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)¶
-
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)¶
-
nir_def *nir_fmul(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 zero is always zero.fmulz(0.0, inf)
andfmulz(0.0, nan)
must be +/-0.0, even ifINF_PRESERVE/NAN_PRESERVE
is not used. IfSIGNED_ZERO_PRESERVE
is used, then the result must be a positive zero if either operand is zero.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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
nir_def *nir_umul_high(nir_builder*, nir_def *src0, nir_def *src1)¶
- umul_low(uint32[N] src0, uint32[N] src1) uint32[N] ¶
Properties:
Per-component
Associative
2-src commutative
Y
N
Y
Description: Low 32-bits of unsigned integer multiply
Constant-folding:
uint64_t mask = (1 << (bit_size / 2)) - 1; dst = ((uint64_t)src0 & mask) * ((uint64_t)src1 & mask);
Builder function:
-
nir_def *nir_umul_low(nir_builder*, nir_def *src0, nir_def *src1)¶
-
nir_def *nir_umul_low(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)¶
-
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)¶
-
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)¶
-
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 ? 0 : (src0 / src1)
Builder function:
-
nir_def *nir_idiv(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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)¶
-
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:
src0 + src1 < src0
Builder function:
-
nir_def *nir_uadd_carry(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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 ? 0 : src0 % src1
Builder function:
-
nir_def *nir_irem(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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 ? 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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
nir_def *nir_b32any_inequal5(nir_builder*, nir_def *src0, nir_def *src1)¶
- fall_equal2(float32[2] src0, float32[2] src1) float32[1] ¶
Properties:
Per-component
Associative
2-src commutative
N
N
Y
Constant-folding:
((src0.y == src1.y) && (src0.x == src1.x)) ? 1.0f : 0.0f
Builder function:
-
nir_def *nir_fall_equal2(nir_builder*, nir_def *src0, nir_def *src1)¶
-
nir_def *nir_fall_equal2(nir_builder*, nir_def *src0, nir_def *src1)¶
- fall_equal4(float32[4] src0, float32[4] src1) float32[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)) ? 1.0f : 0.0f
Builder function:
-
nir_def *nir_fall_equal4(nir_builder*, nir_def *src0, nir_def *src1)¶
-
nir_def *nir_fall_equal4(nir_builder*, nir_def *src0, nir_def *src1)¶
- fall_equal8(float32[8] src0, float32[8] src1) float32[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)) ? 1.0f : 0.0f
Builder function:
-
nir_def *nir_fall_equal8(nir_builder*, nir_def *src0, nir_def *src1)¶
-
nir_def *nir_fall_equal8(nir_builder*, nir_def *src0, nir_def *src1)¶
- fall_equal16(float32[16] src0, float32[16] src1) float32[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)) ? 1.0f : 0.0f
Builder function:
-
nir_def *nir_fall_equal16(nir_builder*, nir_def *src0, nir_def *src1)¶
-
nir_def *nir_fall_equal16(nir_builder*, nir_def *src0, nir_def *src1)¶
- fall_equal3(float32[3] src0, float32[3] src1) float32[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)) ? 1.0f : 0.0f
Builder function:
-
nir_def *nir_fall_equal3(nir_builder*, nir_def *src0, nir_def *src1)¶
-
nir_def *nir_fall_equal3(nir_builder*, nir_def *src0, nir_def *src1)¶
- fall_equal5(float32[5] src0, float32[5] src1) float32[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)) ? 1.0f : 0.0f
Builder function:
-
nir_def *nir_fall_equal5(nir_builder*, nir_def *src0, nir_def *src1)¶
-
nir_def *nir_fall_equal5(nir_builder*, nir_def *src0, nir_def *src1)¶
- fany_nequal2(float32[2] src0, float32[2] src1) float32[1] ¶
Properties:
Per-component
Associative
2-src commutative
N
N
Y
Constant-folding:
((src0.y != src1.y) || (src0.x != src1.x)) ? 1.0f : 0.0f
Builder function:
-
nir_def *nir_fany_nequal2(nir_builder*, nir_def *src0, nir_def *src1)¶
-
nir_def *nir_fany_nequal2(nir_builder*, nir_def *src0, nir_def *src1)¶
- fany_nequal4(float32[4] src0, float32[4] src1) float32[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)) ? 1.0f : 0.0f
Builder function:
-
nir_def *nir_fany_nequal4(nir_builder*, nir_def *src0, nir_def *src1)¶
-
nir_def *nir_fany_nequal4(nir_builder*, nir_def *src0, nir_def *src1)¶
- fany_nequal8(float32[8] src0, float32[8] src1) float32[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)) ? 1.0f : 0.0f
Builder function:
-
nir_def *nir_fany_nequal8(nir_builder*, nir_def *src0, nir_def *src1)¶
-
nir_def *nir_fany_nequal8(nir_builder*, nir_def *src0, nir_def *src1)¶
- fany_nequal16(float32[16] src0, float32[16] src1) float32[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)) ? 1.0f : 0.0f
Builder function:
-
nir_def *nir_fany_nequal16(nir_builder*, nir_def *src0, nir_def *src1)¶
-
nir_def *nir_fany_nequal16(nir_builder*, nir_def *src0, nir_def *src1)¶
- fany_nequal3(float32[3] src0, float32[3] src1) float32[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)) ? 1.0f : 0.0f
Builder function:
-
nir_def *nir_fany_nequal3(nir_builder*, nir_def *src0, nir_def *src1)¶
-
nir_def *nir_fany_nequal3(nir_builder*, nir_def *src0, nir_def *src1)¶
- fany_nequal5(float32[5] src0, float32[5] src1) float32[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)) ? 1.0f : 0.0f
Builder function:
-
nir_def *nir_fany_nequal5(nir_builder*, nir_def *src0, nir_def *src1)¶
-
nir_def *nir_fany_nequal5(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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
nir_def *nir_ushr(nir_builder*, nir_def *src0, nir_def *src1)¶
- 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)¶
-
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)¶
-
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; dst = (src1 >> (src2 & rotate_mask)) | (src0 << (-src2 & rotate_mask));
Builder function:
-
nir_def *nir_shfr(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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:
bit_size == 64 ? (src0 == src1 ? uid(MIN2((int64_t)dui(src0), (int64_t)dui(src1))) : fmin(src0, src1)) :(src0 == src1 ? uif(MIN2((int32_t)fui(src0), (int32_t)fui(src1))) : fminf(src0, src1))
Builder function:
-
nir_def *nir_fmin(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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:
bit_size == 64 ? (src0 == src1 ? uid(MAX2((int64_t)dui(src0), (int64_t)dui(src1))) : fmax(src0, src1)) :(src0 == src1 ? uif(MAX2((int32_t)fui(src0), (int32_t)fui(src1))) : fmaxf(src0, src1))
Builder function:
-
nir_def *nir_fmax(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
nir_def *nir_ldexp(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)¶
-
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:
(uint8_t)(src0 >> (src1 * 8))
Builder function:
-
nir_def *nir_extract_u8(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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:
(int8_t)(src0 >> (src1 * 8))
Builder function:
-
nir_def *nir_extract_i8(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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:
(uint16_t)(src0 >> (src1 * 16))
Builder function:
-
nir_def *nir_extract_u16(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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:
(int16_t)(src0 >> (src1 * 16))
Builder function:
-
nir_def *nir_extract_i16(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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:
(src0 & 0xff) << (src1 * 8)
Builder function:
-
nir_def *nir_insert_u8(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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:
(src0 & 0xffff) << (src1 * 16)
Builder function:
-
nir_def *nir_insert_u16(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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)¶
-
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 zero is always zero.ffmaz(0.0, inf, src2)
andffmaz(0.0, nan, src2)
must be+/-0.0 + src2
, even ifINF_PRESERVE/NAN_PRESERVE
is not used. IfSIGNED_ZERO_PRESERVE
is used, then the result must be a positive zero plus src2 if either src0 or src1 is zero.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)¶
-
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)¶
-
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
Y
Y
Description: Ternary addition
Constant-folding:
src0 + src1 + src2
Builder function:
-
nir_def *nir_iadd3(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)¶
-
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
Y
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
nir_def *nir_b32csel(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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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:
int 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_ibfe(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)¶
-
nir_def *nir_ibfe(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)¶
- ubitfield_extract(uint32[N] src0, int32[N] src1, int32[N] src2) uint32[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 > 32) { dst = 0; /* undefined per the spec */ } 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)¶
-
nir_def *nir_ubitfield_extract(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)¶
- ibitfield_extract(int32[N] src0, int32[N] src1, int32[N] src2) int32[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 > 32) { dst = 0; } else { dst = (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)¶
-
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)¶
-
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)¶
-
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)¶
-
nir_def *nir_vec3(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)¶
- bitfield_insert(uint32[N] src0, uint32[N] src1, int32[N] src2, int32[N] src3) uint32[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; } 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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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 = ((((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)¶
-
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:
(((int32_t)src0 << 8) >> 8) * (((int32_t)src1 << 8) >> 8) + src2
Builder function:
-
nir_def *nir_imad24_ir3(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)¶
-
nir_def *nir_imad24_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)¶
-
nir_def *nir_cube_amd(nir_builder*, nir_def *src0)¶
- fsin_amd(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_amd(nir_builder*, nir_def *src0)¶
-
nir_def *nir_fsin_amd(nir_builder*, nir_def *src0)¶
- fcos_amd(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_amd(nir_builder*, nir_def *src0)¶
-
nir_def *nir_fcos_amd(nir_builder*, nir_def *src0)¶
- 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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
nir_def *nir_imsubshl_agx(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2, nir_def *src3)¶
- interleave_agx(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_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)¶
-
nir_def *nir_prmt_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
Y
Y
Constant-folding:
(((int32_t)src0 << 8) >> 8) * (((int32_t)src1 << 8) >> 8)
Builder function:
-
nir_def *nir_imul24(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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)¶
-
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
Y
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)¶
-
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
Y
Y
Constant-folding:
src0 * src1
Builder function:
-
nir_def *nir_imul24_relaxed(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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:
src0 * src1 + src2
Builder function:
-
nir_def *nir_umad24_relaxed(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)¶
-
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
Y
Y
Constant-folding:
src0 * src1
Builder function:
-
nir_def *nir_umul24_relaxed(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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
Constant-folding:
isnormal(src0)
Builder function:
-
nir_def *nir_fisnormal(nir_builder*, nir_def *src0)¶
-
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
Constant-folding:
isfinite(src0)
Builder function:
-
nir_def *nir_fisfinite(nir_builder*, nir_def *src0)¶
-
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
Constant-folding:
isfinite(src0)
Builder function:
-
nir_def *nir_fisfinite32(nir_builder*, nir_def *src0)¶
-
nir_def *nir_fisfinite32(nir_builder*, nir_def *src0)¶
- 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 |= 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)¶
-
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 |= (src0_chan - src1_chan) << i; }
Builder function:
-
nir_def *nir_ussub_4x8_vc4(nir_builder*, nir_def *src0, nir_def *src1)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
nir_def *nir_f2snorm_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)¶
-
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)¶
-
nir_def *nir_pack_2x16_to_unorm_10_2_v3d(nir_builder*, nir_def *src0)¶
- fsat_signed_mali(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_mali(nir_builder*, nir_def *src0)¶
-
nir_def *nir_fsat_signed_mali(nir_builder*, nir_def *src0)¶
- fclamp_pos_mali(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_mali(nir_builder*, nir_def *src0)¶
-
nir_def *nir_fclamp_pos_mali(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)¶
-
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)¶
-
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)¶
-
nir_def *nir_unpack_double_2x32_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)¶
-
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)¶
-
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)¶
-
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)¶
-
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, int32[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)¶
-
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)¶
-
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)¶
-
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)¶
-
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)¶
-
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, int32[N] src2) int32[N] ¶
Properties:
Per-component
Associative
2-src commutative
Y
N
Y
Constant-folding:
const uint64_t v0x = (uint16_t)(src0 ); const uint64_t v0y = (uint16_t)(src0 >> 16); const uint64_t v1x = (uint16_t)(src1 ); const uint64_t v1y = (uint16_t)(src1 >> 16); const uint64_t tmp = (v0x * v1x) + (v0y * v1y) + 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)¶
-
nir_def *nir_udot_2x16_uadd_sat(nir_builder*, nir_def *src0, nir_def *src1, nir_def *src2)¶