cranelift_frontend

Struct FuncInstBuilder

Source 
pub struct FuncInstBuilder<'short, 'long: 'short> { /* private fields */ }
Expand description

Implementation of the [InstBuilder] that has one convenience method per Cranelift IR instruction.

Trait Implementations§

Source§

impl<'short, 'long> InstBuilderBase<'short> for FuncInstBuilder<'short, 'long>

Source§

fn data_flow_graph(&self) -> &DataFlowGraph

Get an immutable reference to the data flow graph that will hold the constructed instructions.
Source§

fn data_flow_graph_mut(&mut self) -> &mut DataFlowGraph

Get a mutable reference to the data flow graph that will hold the constructed instructions.
Source§

fn build( self, data: InstructionData, ctrl_typevar: Type, ) -> (Inst, &'short mut DataFlowGraph)

Insert an instruction and return a reference to it, consuming the builder. Read more

Auto Trait Implementations§

§

impl<'short, 'long> Freeze for FuncInstBuilder<'short, 'long>

§

impl<'short, 'long> RefUnwindSafe for FuncInstBuilder<'short, 'long>

§

impl<'short, 'long> Send for FuncInstBuilder<'short, 'long>

§

impl<'short, 'long> Sync for FuncInstBuilder<'short, 'long>

§

impl<'short, 'long> Unpin for FuncInstBuilder<'short, 'long>

§

impl<'short, 'long> !UnwindSafe for FuncInstBuilder<'short, 'long>

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

§

impl<'f, T> InstBuilder<'f> for T
where T: InstBuilderBase<'f>,

§

fn jump(self, block_call_label: Block, block_call_args: &[Value]) -> Inst

Jump. Read more
§

fn brif( self, c: Value, block_then_label: Block, block_then_args: &[Value], block_else_label: Block, block_else_args: &[Value], ) -> Inst

Conditional branch when cond is non-zero. Read more
§

fn br_table(self, x: Value, JT: JumpTable) -> Inst

Indirect branch via jump table. Read more
§

fn debugtrap(self) -> Inst

Encodes an assembly debug trap.
§

fn trap<T1>(self, code: T1) -> Inst
where T1: Into<TrapCode>,

Terminate execution unconditionally. Read more
§

fn trapz<T1>(self, c: Value, code: T1) -> Inst
where T1: Into<TrapCode>,

Trap when zero. Read more
§

fn trapnz<T1>(self, c: Value, code: T1) -> Inst
where T1: Into<TrapCode>,

Trap when non-zero. Read more
§

fn return_(self, rvals: &[Value]) -> Inst

Return from the function. Read more
§

fn call(self, FN: FuncRef, args: &[Value]) -> Inst

Direct function call. Read more
§

fn call_indirect(self, SIG: SigRef, callee: Value, args: &[Value]) -> Inst

Indirect function call. Read more
§

fn return_call(self, FN: FuncRef, args: &[Value]) -> Inst

Direct tail call. Read more
§

fn return_call_indirect( self, SIG: SigRef, callee: Value, args: &[Value], ) -> Inst

Indirect tail call. Read more
§

fn func_addr(self, iAddr: Type, FN: FuncRef) -> Value

Get the address of a function. Read more
§

fn splat(self, TxN: Type, x: Value) -> Value

Vector splat. Read more
§

fn swizzle(self, x: Value, y: Value) -> Value

Vector swizzle. Read more
§

fn x86_pshufb(self, x: Value, y: Value) -> Value

A vector swizzle lookalike which has the semantics of pshufb on x64. Read more
§

fn insertlane<T1>(self, x: Value, y: Value, Idx: T1) -> Value
where T1: Into<u8>,

Insert y as lane Idx in x. Read more
§

fn extractlane<T1>(self, x: Value, Idx: T1) -> Value
where T1: Into<u8>,

Extract lane Idx from x. Read more
§

fn smin(self, x: Value, y: Value) -> Value

Signed integer minimum. Read more
§

fn umin(self, x: Value, y: Value) -> Value

Unsigned integer minimum. Read more
§

fn smax(self, x: Value, y: Value) -> Value

Signed integer maximum. Read more
§

fn umax(self, x: Value, y: Value) -> Value

Unsigned integer maximum. Read more
§

fn avg_round(self, x: Value, y: Value) -> Value

Unsigned average with rounding: a := (x + y + 1) // 2 Read more
§

fn uadd_sat(self, x: Value, y: Value) -> Value

Add with unsigned saturation. Read more
§

fn sadd_sat(self, x: Value, y: Value) -> Value

Add with signed saturation. Read more
§

fn usub_sat(self, x: Value, y: Value) -> Value

Subtract with unsigned saturation. Read more
§

fn ssub_sat(self, x: Value, y: Value) -> Value

Subtract with signed saturation. Read more
§

fn load<T1, T2>(self, Mem: Type, MemFlags: T1, p: Value, Offset: T2) -> Value
where T1: Into<MemFlags>, T2: Into<Offset32>,

Load from memory at p + Offset. Read more
§

fn store<T1, T2>(self, MemFlags: T1, x: Value, p: Value, Offset: T2) -> Inst
where T1: Into<MemFlags>, T2: Into<Offset32>,

Store x to memory at p + Offset. Read more
§

fn uload8<T1, T2>( self, iExt8: Type, MemFlags: T1, p: Value, Offset: T2, ) -> Value
where T1: Into<MemFlags>, T2: Into<Offset32>,

Load 8 bits from memory at p + Offset and zero-extend. Read more
§

fn sload8<T1, T2>( self, iExt8: Type, MemFlags: T1, p: Value, Offset: T2, ) -> Value
where T1: Into<MemFlags>, T2: Into<Offset32>,

Load 8 bits from memory at p + Offset and sign-extend. Read more
§

fn istore8<T1, T2>(self, MemFlags: T1, x: Value, p: Value, Offset: T2) -> Inst
where T1: Into<MemFlags>, T2: Into<Offset32>,

Store the low 8 bits of x to memory at p + Offset. Read more
§

fn uload16<T1, T2>( self, iExt16: Type, MemFlags: T1, p: Value, Offset: T2, ) -> Value
where T1: Into<MemFlags>, T2: Into<Offset32>,

Load 16 bits from memory at p + Offset and zero-extend. Read more
§

fn sload16<T1, T2>( self, iExt16: Type, MemFlags: T1, p: Value, Offset: T2, ) -> Value
where T1: Into<MemFlags>, T2: Into<Offset32>,

Load 16 bits from memory at p + Offset and sign-extend. Read more
§

fn istore16<T1, T2>(self, MemFlags: T1, x: Value, p: Value, Offset: T2) -> Inst
where T1: Into<MemFlags>, T2: Into<Offset32>,

Store the low 16 bits of x to memory at p + Offset. Read more
§

fn uload32<T1, T2>(self, MemFlags: T1, p: Value, Offset: T2) -> Value
where T1: Into<MemFlags>, T2: Into<Offset32>,

Load 32 bits from memory at p + Offset and zero-extend. Read more
§

fn sload32<T1, T2>(self, MemFlags: T1, p: Value, Offset: T2) -> Value
where T1: Into<MemFlags>, T2: Into<Offset32>,

Load 32 bits from memory at p + Offset and sign-extend. Read more
§

fn istore32<T1, T2>(self, MemFlags: T1, x: Value, p: Value, Offset: T2) -> Inst
where T1: Into<MemFlags>, T2: Into<Offset32>,

Store the low 32 bits of x to memory at p + Offset. Read more
§

fn stack_switch( self, store_context_ptr: Value, load_context_ptr: Value, in_payload0: Value, ) -> Value

Suspends execution of the current stack and resumes execution of another one. Read more
§

fn uload8x8<T1, T2>(self, MemFlags: T1, p: Value, Offset: T2) -> Value
where T1: Into<MemFlags>, T2: Into<Offset32>,

Load an 8x8 vector (64 bits) from memory at p + Offset and zero-extend into an i16x8 vector. Read more
§

fn sload8x8<T1, T2>(self, MemFlags: T1, p: Value, Offset: T2) -> Value
where T1: Into<MemFlags>, T2: Into<Offset32>,

Load an 8x8 vector (64 bits) from memory at p + Offset and sign-extend into an i16x8 vector. Read more
§

fn uload16x4<T1, T2>(self, MemFlags: T1, p: Value, Offset: T2) -> Value
where T1: Into<MemFlags>, T2: Into<Offset32>,

Load a 16x4 vector (64 bits) from memory at p + Offset and zero-extend into an i32x4 vector. Read more
§

fn sload16x4<T1, T2>(self, MemFlags: T1, p: Value, Offset: T2) -> Value
where T1: Into<MemFlags>, T2: Into<Offset32>,

Load a 16x4 vector (64 bits) from memory at p + Offset and sign-extend into an i32x4 vector. Read more
§

fn uload32x2<T1, T2>(self, MemFlags: T1, p: Value, Offset: T2) -> Value
where T1: Into<MemFlags>, T2: Into<Offset32>,

Load an 32x2 vector (64 bits) from memory at p + Offset and zero-extend into an i64x2 vector. Read more
§

fn sload32x2<T1, T2>(self, MemFlags: T1, p: Value, Offset: T2) -> Value
where T1: Into<MemFlags>, T2: Into<Offset32>,

Load a 32x2 vector (64 bits) from memory at p + Offset and sign-extend into an i64x2 vector. Read more
§

fn stack_load<T1>(self, Mem: Type, SS: StackSlot, Offset: T1) -> Value
where T1: Into<Offset32>,

Load a value from a stack slot at the constant offset. Read more
§

fn stack_store<T1>(self, x: Value, SS: StackSlot, Offset: T1) -> Inst
where T1: Into<Offset32>,

Store a value to a stack slot at a constant offset. Read more
§

fn stack_addr<T1>(self, iAddr: Type, SS: StackSlot, Offset: T1) -> Value
where T1: Into<Offset32>,

Get the address of a stack slot. Read more
§

fn dynamic_stack_load(self, Mem: Type, DSS: DynamicStackSlot) -> Value

Load a value from a dynamic stack slot. Read more
§

fn dynamic_stack_store(self, x: Value, DSS: DynamicStackSlot) -> Inst

Store a value to a dynamic stack slot. Read more
§

fn dynamic_stack_addr(self, iAddr: Type, DSS: DynamicStackSlot) -> Value

Get the address of a dynamic stack slot. Read more
§

fn global_value(self, Mem: Type, GV: GlobalValue) -> Value

Compute the value of global GV. Read more
§

fn symbol_value(self, Mem: Type, GV: GlobalValue) -> Value

Compute the value of global GV, which is a symbolic value. Read more
§

fn tls_value(self, Mem: Type, GV: GlobalValue) -> Value

Compute the value of global GV, which is a TLS (thread local storage) value. Read more
§

fn get_pinned_reg(self, iAddr: Type) -> Value

Gets the content of the pinned register, when it’s enabled. Read more
§

fn set_pinned_reg(self, addr: Value) -> Inst

Sets the content of the pinned register, when it’s enabled. Read more
§

fn get_frame_pointer(self, iAddr: Type) -> Value

Get the address in the frame pointer register. Read more
§

fn get_stack_pointer(self, iAddr: Type) -> Value

Get the address in the stack pointer register. Read more
§

fn get_return_address(self, iAddr: Type) -> Value

Get the PC where this function will transfer control to when it returns. Read more
§

fn iconst<T1>(self, NarrowInt: Type, N: T1) -> Value
where T1: Into<Imm64>,

Integer constant. Read more
§

fn f16const<T1>(self, N: T1) -> Value
where T1: Into<Ieee16>,

Floating point constant. Read more
§

fn f32const<T1>(self, N: T1) -> Value
where T1: Into<Ieee32>,

Floating point constant. Read more
§

fn f64const<T1>(self, N: T1) -> Value
where T1: Into<Ieee64>,

Floating point constant. Read more
§

fn f128const<T1>(self, N: T1) -> Value
where T1: Into<Constant>,

Floating point constant. Read more
§

fn vconst<T1>(self, TxN: Type, N: T1) -> Value
where T1: Into<Constant>,

SIMD vector constant. Read more
§

fn shuffle<T1>(self, a: Value, b: Value, mask: T1) -> Value
where T1: Into<Immediate>,

SIMD vector shuffle. Read more
§

fn nop(self) -> Inst

Just a dummy instruction. Read more
§

fn select(self, c: Value, x: Value, y: Value) -> Value

Conditional select. Read more
§

fn select_spectre_guard(self, c: Value, x: Value, y: Value) -> Value

Conditional select intended for Spectre guards. Read more
§

fn bitselect(self, c: Value, x: Value, y: Value) -> Value

Conditional select of bits. Read more
§

fn x86_blendv(self, c: Value, x: Value, y: Value) -> Value

A bitselect-lookalike instruction except with the semantics of blendv-related instructions on x86. Read more
§

fn vany_true(self, a: Value) -> Value

Reduce a vector to a scalar boolean. Read more
§

fn vall_true(self, a: Value) -> Value

Reduce a vector to a scalar boolean. Read more
§

fn vhigh_bits(self, NarrowInt: Type, a: Value) -> Value

Reduce a vector to a scalar integer. Read more
§

fn icmp<T1>(self, Cond: T1, x: Value, y: Value) -> Value
where T1: Into<IntCC>,

Integer comparison. Read more
§

fn icmp_imm<T1, T2>(self, Cond: T1, x: Value, Y: T2) -> Value
where T1: Into<IntCC>, T2: Into<Imm64>,

Compare scalar integer to a constant. Read more
§

fn iadd(self, x: Value, y: Value) -> Value

Wrapping integer addition: a := x + y \pmod{2^B}. Read more
§

fn isub(self, x: Value, y: Value) -> Value

Wrapping integer subtraction: a := x - y \pmod{2^B}. Read more
§

fn ineg(self, x: Value) -> Value

Integer negation: a := -x \pmod{2^B}. Read more
§

fn iabs(self, x: Value) -> Value

Integer absolute value with wrapping: a := |x|. Read more
§

fn imul(self, x: Value, y: Value) -> Value

Wrapping integer multiplication: a := x y \pmod{2^B}. Read more
§

fn umulhi(self, x: Value, y: Value) -> Value

Unsigned integer multiplication, producing the high half of a double-length result. Read more
§

fn smulhi(self, x: Value, y: Value) -> Value

Signed integer multiplication, producing the high half of a double-length result. Read more
§

fn sqmul_round_sat(self, x: Value, y: Value) -> Value

Fixed-point multiplication of numbers in the QN format, where N + 1 is the number bitwidth: a := signed_saturate((x * y + (1 << (Q - 1))) >> Q) Read more
§

fn x86_pmulhrsw(self, x: Value, y: Value) -> Value

A similar instruction to sqmul_round_sat except with the semantics of x86’s pmulhrsw instruction. Read more
§

fn udiv(self, x: Value, y: Value) -> Value

Unsigned integer division: a := \lfloor {x \over y} \rfloor. Read more
§

fn sdiv(self, x: Value, y: Value) -> Value

Signed integer division rounded toward zero: a := sign(xy) \lfloor {|x| \over |y|}\rfloor. Read more
§

fn urem(self, x: Value, y: Value) -> Value

Unsigned integer remainder. Read more
§

fn srem(self, x: Value, y: Value) -> Value

Signed integer remainder. The result has the sign of the dividend. Read more
§

fn iadd_imm<T1>(self, x: Value, Y: T1) -> Value
where T1: Into<Imm64>,

Add immediate integer. Read more
§

fn imul_imm<T1>(self, x: Value, Y: T1) -> Value
where T1: Into<Imm64>,

Integer multiplication by immediate constant. Read more
§

fn udiv_imm<T1>(self, x: Value, Y: T1) -> Value
where T1: Into<Imm64>,

Unsigned integer division by an immediate constant. Read more
§

fn sdiv_imm<T1>(self, x: Value, Y: T1) -> Value
where T1: Into<Imm64>,

Signed integer division by an immediate constant. Read more
§

fn urem_imm<T1>(self, x: Value, Y: T1) -> Value
where T1: Into<Imm64>,

Unsigned integer remainder with immediate divisor. Read more
§

fn srem_imm<T1>(self, x: Value, Y: T1) -> Value
where T1: Into<Imm64>,

Signed integer remainder with immediate divisor. Read more
§

fn irsub_imm<T1>(self, x: Value, Y: T1) -> Value
where T1: Into<Imm64>,

Immediate reverse wrapping subtraction: a := Y - x \pmod{2^B}. Read more
§

fn sadd_overflow_cin(self, x: Value, y: Value, c_in: Value) -> (Value, Value)

Add signed integers with carry in and overflow out. Read more
§

fn uadd_overflow_cin(self, x: Value, y: Value, c_in: Value) -> (Value, Value)

Add unsigned integers with carry in and overflow out. Read more
§

fn uadd_overflow(self, x: Value, y: Value) -> (Value, Value)

Add integers unsigned with overflow out. of is set when the addition overflowed. Read more
§

fn sadd_overflow(self, x: Value, y: Value) -> (Value, Value)

Add integers signed with overflow out. of is set when the addition over- or underflowed. Polymorphic over all scalar integer types, but does not support vector types. Read more
§

fn usub_overflow(self, x: Value, y: Value) -> (Value, Value)

Subtract integers unsigned with overflow out. of is set when the subtraction underflowed. Read more
§

fn ssub_overflow(self, x: Value, y: Value) -> (Value, Value)

Subtract integers signed with overflow out. of is set when the subtraction over- or underflowed. Polymorphic over all scalar integer types, but does not support vector types. Read more
§

fn umul_overflow(self, x: Value, y: Value) -> (Value, Value)

Multiply integers unsigned with overflow out. of is set when the multiplication overflowed. Read more
§

fn smul_overflow(self, x: Value, y: Value) -> (Value, Value)

Multiply integers signed with overflow out. of is set when the multiplication over- or underflowed. Polymorphic over all scalar integer types except i128, but does not support vector types. Read more
§

fn uadd_overflow_trap<T1>(self, x: Value, y: Value, code: T1) -> Value
where T1: Into<TrapCode>,

Unsigned addition of x and y, trapping if the result overflows. Read more
§

fn ssub_overflow_bin(self, x: Value, y: Value, b_in: Value) -> (Value, Value)

Subtract signed integers with borrow in and overflow out. Read more
§

fn usub_overflow_bin(self, x: Value, y: Value, b_in: Value) -> (Value, Value)

Subtract unsigned integers with borrow in and overflow out. Read more
§

fn band(self, x: Value, y: Value) -> Value

Bitwise and. Read more
§

fn bor(self, x: Value, y: Value) -> Value

Bitwise or. Read more
§

fn bxor(self, x: Value, y: Value) -> Value

Bitwise xor. Read more
§

fn bnot(self, x: Value) -> Value

Bitwise not. Read more
§

fn band_not(self, x: Value, y: Value) -> Value

Bitwise and not. Read more
§

fn bor_not(self, x: Value, y: Value) -> Value

Bitwise or not. Read more
§

fn bxor_not(self, x: Value, y: Value) -> Value

Bitwise xor not. Read more
§

fn band_imm<T1>(self, x: Value, Y: T1) -> Value
where T1: Into<Imm64>,

Bitwise and with immediate. Read more
§

fn bor_imm<T1>(self, x: Value, Y: T1) -> Value
where T1: Into<Imm64>,

Bitwise or with immediate. Read more
§

fn bxor_imm<T1>(self, x: Value, Y: T1) -> Value
where T1: Into<Imm64>,

Bitwise xor with immediate. Read more
§

fn rotl(self, x: Value, y: Value) -> Value

Rotate left. Read more
§

fn rotr(self, x: Value, y: Value) -> Value

Rotate right. Read more
§

fn rotl_imm<T1>(self, x: Value, Y: T1) -> Value
where T1: Into<Imm64>,

Rotate left by immediate. Read more
§

fn rotr_imm<T1>(self, x: Value, Y: T1) -> Value
where T1: Into<Imm64>,

Rotate right by immediate. Read more
§

fn ishl(self, x: Value, y: Value) -> Value

Integer shift left. Shift the bits in x towards the MSB by y places. Shift in zero bits to the LSB. Read more
§

fn ushr(self, x: Value, y: Value) -> Value

Unsigned shift right. Shift bits in x towards the LSB by y places, shifting in zero bits to the MSB. Also called a logical shift. Read more
§

fn sshr(self, x: Value, y: Value) -> Value

Signed shift right. Shift bits in x towards the LSB by y places, shifting in sign bits to the MSB. Also called an arithmetic shift. Read more
§

fn ishl_imm<T1>(self, x: Value, Y: T1) -> Value
where T1: Into<Imm64>,

Integer shift left by immediate. Read more
§

fn ushr_imm<T1>(self, x: Value, Y: T1) -> Value
where T1: Into<Imm64>,

Unsigned shift right by immediate. Read more
§

fn sshr_imm<T1>(self, x: Value, Y: T1) -> Value
where T1: Into<Imm64>,

Signed shift right by immediate. Read more
§

fn bitrev(self, x: Value) -> Value

Reverse the bits of a integer. Read more
§

fn clz(self, x: Value) -> Value

Count leading zero bits. Read more
§

fn cls(self, x: Value) -> Value

Count leading sign bits. Read more
§

fn ctz(self, x: Value) -> Value

Count trailing zeros. Read more
§

fn bswap(self, x: Value) -> Value

Reverse the byte order of an integer. Read more
§

fn popcnt(self, x: Value) -> Value

Population count Read more
§

fn fcmp<T1>(self, Cond: T1, x: Value, y: Value) -> Value
where T1: Into<FloatCC>,

Floating point comparison. Read more
§

fn fadd(self, x: Value, y: Value) -> Value

Floating point addition. Read more
§

fn fsub(self, x: Value, y: Value) -> Value

Floating point subtraction. Read more
§

fn fmul(self, x: Value, y: Value) -> Value

Floating point multiplication. Read more
§

fn fdiv(self, x: Value, y: Value) -> Value

Floating point division. Read more
§

fn sqrt(self, x: Value) -> Value

Floating point square root. Read more
§

fn fma(self, x: Value, y: Value, z: Value) -> Value

Floating point fused multiply-and-add. Read more
§

fn fneg(self, x: Value) -> Value

Floating point negation. Read more
§

fn fabs(self, x: Value) -> Value

Floating point absolute value. Read more
§

fn fcopysign(self, x: Value, y: Value) -> Value

Floating point copy sign. Read more
§

fn fmin(self, x: Value, y: Value) -> Value

Floating point minimum, propagating NaNs using the WebAssembly rules. Read more
§

fn fmax(self, x: Value, y: Value) -> Value

Floating point maximum, propagating NaNs using the WebAssembly rules. Read more
§

fn ceil(self, x: Value) -> Value

Round floating point round to integral, towards positive infinity. Read more
§

fn floor(self, x: Value) -> Value

Round floating point round to integral, towards negative infinity. Read more
§

fn trunc(self, x: Value) -> Value

Round floating point round to integral, towards zero. Read more
§

fn nearest(self, x: Value) -> Value

Round floating point round to integral, towards nearest with ties to even. Read more
§

fn bitcast<T1>(self, MemTo: Type, MemFlags: T1, x: Value) -> Value
where T1: Into<MemFlags>,

Reinterpret the bits in x as a different type. Read more
§

fn scalar_to_vector(self, TxN: Type, s: Value) -> Value

Copies a scalar value to a vector value. The scalar is copied into the least significant lane of the vector, and all other lanes will be zero. Read more
§

fn bmask(self, IntTo: Type, x: Value) -> Value

Convert x to an integer mask. Read more
§

fn ireduce(self, Int: Type, x: Value) -> Value

Convert x to a smaller integer type by discarding the most significant bits. Read more
§

fn snarrow(self, x: Value, y: Value) -> Value

Combine x and y into a vector with twice the lanes but half the integer width while saturating overflowing values to the signed maximum and minimum. Read more
§

fn unarrow(self, x: Value, y: Value) -> Value

Combine x and y into a vector with twice the lanes but half the integer width while saturating overflowing values to the unsigned maximum and minimum. Read more
§

fn uunarrow(self, x: Value, y: Value) -> Value

Combine x and y into a vector with twice the lanes but half the integer width while saturating overflowing values to the unsigned maximum and minimum. Read more
§

fn swiden_low(self, x: Value) -> Value

Widen the low lanes of x using signed extension. Read more
§

fn swiden_high(self, x: Value) -> Value

Widen the high lanes of x using signed extension. Read more
§

fn uwiden_low(self, x: Value) -> Value

Widen the low lanes of x using unsigned extension. Read more
§

fn uwiden_high(self, x: Value) -> Value

Widen the high lanes of x using unsigned extension. Read more
§

fn iadd_pairwise(self, x: Value, y: Value) -> Value

Does lane-wise integer pairwise addition on two operands, putting the combined results into a single vector result. Here a pair refers to adjacent lanes in a vector, i.e. i2 + (i2+1) for i == num_lanes/2. The first operand pairwise add results will make up the low half of the resulting vector while the second operand pairwise add results will make up the upper half of the resulting vector. Read more
§

fn x86_pmaddubsw(self, x: Value, y: Value) -> Value

An instruction with equivalent semantics to pmaddubsw on x86. Read more
§

fn uextend(self, Int: Type, x: Value) -> Value

Convert x to a larger integer type by zero-extending. Read more
§

fn sextend(self, Int: Type, x: Value) -> Value

Convert x to a larger integer type by sign-extending. Read more
§

fn fpromote(self, FloatScalar: Type, x: Value) -> Value

Convert x to a larger floating point format. Read more
§

fn fdemote(self, FloatScalar: Type, x: Value) -> Value

Convert x to a smaller floating point format. Read more
§

fn fvdemote(self, x: Value) -> Value

Convert x to a smaller floating point format. Read more
§

fn fvpromote_low(self, a: Value) -> Value

Converts packed single precision floating point to packed double precision floating point. Read more
§

fn fcvt_to_uint(self, IntTo: Type, x: Value) -> Value

Converts floating point scalars to unsigned integer. Read more
§

fn fcvt_to_sint(self, IntTo: Type, x: Value) -> Value

Converts floating point scalars to signed integer. Read more
§

fn fcvt_to_uint_sat(self, IntTo: Type, x: Value) -> Value

Convert floating point to unsigned integer as fcvt_to_uint does, but saturates the input instead of trapping. NaN and negative values are converted to 0. Read more
§

fn fcvt_to_sint_sat(self, IntTo: Type, x: Value) -> Value

Convert floating point to signed integer as fcvt_to_sint does, but saturates the input instead of trapping. NaN values are converted to 0. Read more
§

fn x86_cvtt2dq(self, IntTo: Type, x: Value) -> Value

A float-to-integer conversion instruction for vectors-of-floats which has the same semantics as cvttp{s,d}2dq on x86. This specifically returns INT_MIN for NaN or out-of-bounds lanes. Read more
§

fn fcvt_from_uint(self, FloatTo: Type, x: Value) -> Value

Convert unsigned integer to floating point. Read more
§

fn fcvt_from_sint(self, FloatTo: Type, x: Value) -> Value

Convert signed integer to floating point. Read more
§

fn isplit(self, x: Value) -> (Value, Value)

Split an integer into low and high parts. Read more
§

fn iconcat(self, lo: Value, hi: Value) -> Value

Concatenate low and high bits to form a larger integer type. Read more
§

fn atomic_rmw<T1, T2>( self, AtomicMem: Type, MemFlags: T1, AtomicRmwOp: T2, p: Value, x: Value, ) -> Value
where T1: Into<MemFlags>, T2: Into<AtomicRmwOp>,

Atomically read-modify-write memory at p, with second operand x. The old value is returned. p has the type of the target word size, and x may be any integer type; note that some targets require specific target features to be enabled in order to support 128-bit integer atomics. The type of the returned value is the same as the type of x. This operation is sequentially consistent and creates happens-before edges that order normal (non-atomic) loads and stores. Read more
§

fn atomic_cas<T1>(self, MemFlags: T1, p: Value, e: Value, x: Value) -> Value
where T1: Into<MemFlags>,

Perform an atomic compare-and-swap operation on memory at p, with expected value e, storing x if the value at p equals e. The old value at p is returned, regardless of whether the operation succeeds or fails. p has the type of the target word size, and x and e must have the same type and the same size, which may be any integer type; note that some targets require specific target features to be enabled in order to support 128-bit integer atomics. The type of the returned value is the same as the type of x and e. This operation is sequentially consistent and creates happens-before edges that order normal (non-atomic) loads and stores. Read more
§

fn atomic_load<T1>(self, AtomicMem: Type, MemFlags: T1, p: Value) -> Value
where T1: Into<MemFlags>,

Atomically load from memory at p. Read more
§

fn atomic_store<T1>(self, MemFlags: T1, x: Value, p: Value) -> Inst
where T1: Into<MemFlags>,

Atomically store x to memory at p. Read more
§

fn fence(self) -> Inst

A memory fence. This must provide ordering to ensure that, at a minimum, neither loads nor stores of any kind may move forwards or backwards across the fence. This operation is sequentially consistent.
§

fn extract_vector<T1>(self, x: Value, y: T1) -> Value
where T1: Into<u8>,

Return a fixed length sub vector, extracted from a dynamic vector. Read more
§

fn AtomicCas( self, opcode: Opcode, ctrl_typevar: Type, flags: MemFlags, arg0: Value, arg1: Value, arg2: Value, ) -> (Inst, &'f mut DataFlowGraph)

AtomicCas(imms=(flags: ir::MemFlags), vals=3, blocks=0)
§

fn AtomicRmw( self, opcode: Opcode, ctrl_typevar: Type, flags: MemFlags, op: AtomicRmwOp, arg0: Value, arg1: Value, ) -> (Inst, &'f mut DataFlowGraph)

AtomicRmw(imms=(flags: ir::MemFlags, op: ir::AtomicRmwOp), vals=2, blocks=0)
§

fn Binary( self, opcode: Opcode, ctrl_typevar: Type, arg0: Value, arg1: Value, ) -> (Inst, &'f mut DataFlowGraph)

Binary(imms=(), vals=2, blocks=0)
§

fn BinaryImm64( self, opcode: Opcode, ctrl_typevar: Type, imm: Imm64, arg0: Value, ) -> (Inst, &'f mut DataFlowGraph)

BinaryImm64(imms=(imm: ir::immediates::Imm64), vals=1, blocks=0)
§

fn BinaryImm8( self, opcode: Opcode, ctrl_typevar: Type, imm: u8, arg0: Value, ) -> (Inst, &'f mut DataFlowGraph)

BinaryImm8(imms=(imm: ir::immediates::Uimm8), vals=1, blocks=0)
§

fn BranchTable( self, opcode: Opcode, ctrl_typevar: Type, table: JumpTable, arg0: Value, ) -> (Inst, &'f mut DataFlowGraph)

BranchTable(imms=(table: ir::JumpTable), vals=1, blocks=0)
§

fn Brif( self, opcode: Opcode, ctrl_typevar: Type, block0: BlockCall, block1: BlockCall, arg0: Value, ) -> (Inst, &'f mut DataFlowGraph)

Brif(imms=(), vals=1, blocks=2)
§

fn Call( self, opcode: Opcode, ctrl_typevar: Type, func_ref: FuncRef, args: EntityList<Value>, ) -> (Inst, &'f mut DataFlowGraph)

Call(imms=(func_ref: ir::FuncRef), vals=0, blocks=0)
§

fn CallIndirect( self, opcode: Opcode, ctrl_typevar: Type, sig_ref: SigRef, args: EntityList<Value>, ) -> (Inst, &'f mut DataFlowGraph)

CallIndirect(imms=(sig_ref: ir::SigRef), vals=1, blocks=0)
§

fn CondTrap( self, opcode: Opcode, ctrl_typevar: Type, code: TrapCode, arg0: Value, ) -> (Inst, &'f mut DataFlowGraph)

CondTrap(imms=(code: ir::TrapCode), vals=1, blocks=0)
§

fn DynamicStackLoad( self, opcode: Opcode, ctrl_typevar: Type, dynamic_stack_slot: DynamicStackSlot, ) -> (Inst, &'f mut DataFlowGraph)

DynamicStackLoad(imms=(dynamic_stack_slot: ir::DynamicStackSlot), vals=0, blocks=0)
§

fn DynamicStackStore( self, opcode: Opcode, ctrl_typevar: Type, dynamic_stack_slot: DynamicStackSlot, arg0: Value, ) -> (Inst, &'f mut DataFlowGraph)

DynamicStackStore(imms=(dynamic_stack_slot: ir::DynamicStackSlot), vals=1, blocks=0)
§

fn FloatCompare( self, opcode: Opcode, ctrl_typevar: Type, cond: FloatCC, arg0: Value, arg1: Value, ) -> (Inst, &'f mut DataFlowGraph)

FloatCompare(imms=(cond: ir::condcodes::FloatCC), vals=2, blocks=0)
§

fn FuncAddr( self, opcode: Opcode, ctrl_typevar: Type, func_ref: FuncRef, ) -> (Inst, &'f mut DataFlowGraph)

FuncAddr(imms=(func_ref: ir::FuncRef), vals=0, blocks=0)
§

fn IntAddTrap( self, opcode: Opcode, ctrl_typevar: Type, code: TrapCode, arg0: Value, arg1: Value, ) -> (Inst, &'f mut DataFlowGraph)

IntAddTrap(imms=(code: ir::TrapCode), vals=2, blocks=0)
§

fn IntCompare( self, opcode: Opcode, ctrl_typevar: Type, cond: IntCC, arg0: Value, arg1: Value, ) -> (Inst, &'f mut DataFlowGraph)

IntCompare(imms=(cond: ir::condcodes::IntCC), vals=2, blocks=0)
§

fn IntCompareImm( self, opcode: Opcode, ctrl_typevar: Type, cond: IntCC, imm: Imm64, arg0: Value, ) -> (Inst, &'f mut DataFlowGraph)

IntCompareImm(imms=(cond: ir::condcodes::IntCC, imm: ir::immediates::Imm64), vals=1, blocks=0)
§

fn Jump( self, opcode: Opcode, ctrl_typevar: Type, block0: BlockCall, ) -> (Inst, &'f mut DataFlowGraph)

Jump(imms=(), vals=0, blocks=1)
§

fn Load( self, opcode: Opcode, ctrl_typevar: Type, flags: MemFlags, offset: Offset32, arg0: Value, ) -> (Inst, &'f mut DataFlowGraph)

Load(imms=(flags: ir::MemFlags, offset: ir::immediates::Offset32), vals=1, blocks=0)
§

fn LoadNoOffset( self, opcode: Opcode, ctrl_typevar: Type, flags: MemFlags, arg0: Value, ) -> (Inst, &'f mut DataFlowGraph)

LoadNoOffset(imms=(flags: ir::MemFlags), vals=1, blocks=0)
§

fn MultiAry( self, opcode: Opcode, ctrl_typevar: Type, args: EntityList<Value>, ) -> (Inst, &'f mut DataFlowGraph)

MultiAry(imms=(), vals=0, blocks=0)
§

fn NullAry( self, opcode: Opcode, ctrl_typevar: Type, ) -> (Inst, &'f mut DataFlowGraph)

NullAry(imms=(), vals=0, blocks=0)
§

fn Shuffle( self, opcode: Opcode, ctrl_typevar: Type, imm: Immediate, arg0: Value, arg1: Value, ) -> (Inst, &'f mut DataFlowGraph)

Shuffle(imms=(imm: ir::Immediate), vals=2, blocks=0)
§

fn StackLoad( self, opcode: Opcode, ctrl_typevar: Type, stack_slot: StackSlot, offset: Offset32, ) -> (Inst, &'f mut DataFlowGraph)

StackLoad(imms=(stack_slot: ir::StackSlot, offset: ir::immediates::Offset32), vals=0, blocks=0)
§

fn StackStore( self, opcode: Opcode, ctrl_typevar: Type, stack_slot: StackSlot, offset: Offset32, arg0: Value, ) -> (Inst, &'f mut DataFlowGraph)

StackStore(imms=(stack_slot: ir::StackSlot, offset: ir::immediates::Offset32), vals=1, blocks=0)
§

fn Store( self, opcode: Opcode, ctrl_typevar: Type, flags: MemFlags, offset: Offset32, arg0: Value, arg1: Value, ) -> (Inst, &'f mut DataFlowGraph)

Store(imms=(flags: ir::MemFlags, offset: ir::immediates::Offset32), vals=2, blocks=0)
§

fn StoreNoOffset( self, opcode: Opcode, ctrl_typevar: Type, flags: MemFlags, arg0: Value, arg1: Value, ) -> (Inst, &'f mut DataFlowGraph)

StoreNoOffset(imms=(flags: ir::MemFlags), vals=2, blocks=0)
§

fn Ternary( self, opcode: Opcode, ctrl_typevar: Type, arg0: Value, arg1: Value, arg2: Value, ) -> (Inst, &'f mut DataFlowGraph)

Ternary(imms=(), vals=3, blocks=0)
§

fn TernaryImm8( self, opcode: Opcode, ctrl_typevar: Type, imm: u8, arg0: Value, arg1: Value, ) -> (Inst, &'f mut DataFlowGraph)

TernaryImm8(imms=(imm: ir::immediates::Uimm8), vals=2, blocks=0)
§

fn Trap( self, opcode: Opcode, ctrl_typevar: Type, code: TrapCode, ) -> (Inst, &'f mut DataFlowGraph)

Trap(imms=(code: ir::TrapCode), vals=0, blocks=0)
§

fn Unary( self, opcode: Opcode, ctrl_typevar: Type, arg0: Value, ) -> (Inst, &'f mut DataFlowGraph)

Unary(imms=(), vals=1, blocks=0)
§

fn UnaryConst( self, opcode: Opcode, ctrl_typevar: Type, constant_handle: Constant, ) -> (Inst, &'f mut DataFlowGraph)

UnaryConst(imms=(constant_handle: ir::Constant), vals=0, blocks=0)
§

fn UnaryGlobalValue( self, opcode: Opcode, ctrl_typevar: Type, global_value: GlobalValue, ) -> (Inst, &'f mut DataFlowGraph)

UnaryGlobalValue(imms=(global_value: ir::GlobalValue), vals=0, blocks=0)
§

fn UnaryIeee16( self, opcode: Opcode, ctrl_typevar: Type, imm: Ieee16, ) -> (Inst, &'f mut DataFlowGraph)

UnaryIeee16(imms=(imm: ir::immediates::Ieee16), vals=0, blocks=0)
§

fn UnaryIeee32( self, opcode: Opcode, ctrl_typevar: Type, imm: Ieee32, ) -> (Inst, &'f mut DataFlowGraph)

UnaryIeee32(imms=(imm: ir::immediates::Ieee32), vals=0, blocks=0)
§

fn UnaryIeee64( self, opcode: Opcode, ctrl_typevar: Type, imm: Ieee64, ) -> (Inst, &'f mut DataFlowGraph)

UnaryIeee64(imms=(imm: ir::immediates::Ieee64), vals=0, blocks=0)
§

fn UnaryImm( self, opcode: Opcode, ctrl_typevar: Type, imm: Imm64, ) -> (Inst, &'f mut DataFlowGraph)

UnaryImm(imms=(imm: ir::immediates::Imm64), vals=0, blocks=0)
Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> Same for T

Source§

type Output = T

Should always be Self
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.