Trait cranelift_codegen::ir::InstBuilder
source · pub trait InstBuilder<'f>: InstBuilderBase<'f> {
Show 221 methods
fn jump(self, EBB: Ebb, args: &[Value]) -> Inst { ... }
fn fallthrough(self, EBB: Ebb, args: &[Value]) -> Inst { ... }
fn brz(self, c: Value, EBB: Ebb, args: &[Value]) -> Inst { ... }
fn brnz(self, c: Value, EBB: Ebb, args: &[Value]) -> Inst { ... }
fn br_icmp<T1intcc: Into<IntCC>>(
self,
Cond: T1intcc,
x: Value,
y: Value,
EBB: Ebb,
args: &[Value]
) -> Inst { ... }
fn brif<T1intcc: Into<IntCC>>(
self,
Cond: T1intcc,
f: Value,
EBB: Ebb,
args: &[Value]
) -> Inst { ... }
fn brff<T1floatcc: Into<FloatCC>>(
self,
Cond: T1floatcc,
f: Value,
EBB: Ebb,
args: &[Value]
) -> Inst { ... }
fn br_table(self, x: Value, EBB: Ebb, JT: JumpTable) -> Inst { ... }
fn jump_table_entry<T1uimm8: Into<Uimm8>>(
self,
Entry: Type,
x: Value,
addr: Value,
Size: T1uimm8,
JT: JumpTable
) -> Value { ... }
fn jump_table_base(self, iAddr: Type, JT: JumpTable) -> Value { ... }
fn indirect_jump_table_br(self, addr: Value, JT: JumpTable) -> Inst { ... }
fn debugtrap(self) -> Inst { ... }
fn trap<T1trapcode: Into<TrapCode>>(self, code: T1trapcode) -> Inst { ... }
fn trapz<T1trapcode: Into<TrapCode>>(self, c: Value, code: T1trapcode) -> Inst { ... }
fn trapnz<T1trapcode: Into<TrapCode>>(
self,
c: Value,
code: T1trapcode
) -> Inst { ... }
fn trapif<T1intcc: Into<IntCC>, T2trapcode: Into<TrapCode>>(
self,
Cond: T1intcc,
f: Value,
code: T2trapcode
) -> Inst { ... }
fn trapff<T1floatcc: Into<FloatCC>, T2trapcode: Into<TrapCode>>(
self,
Cond: T1floatcc,
f: Value,
code: T2trapcode
) -> Inst { ... }
fn return_(self, rvals: &[Value]) -> Inst { ... }
fn fallthrough_return(self, rvals: &[Value]) -> Inst { ... }
fn call(self, FN: FuncRef, args: &[Value]) -> Inst { ... }
fn call_indirect(self, SIG: SigRef, callee: Value, args: &[Value]) -> Inst { ... }
fn func_addr(self, iAddr: Type, FN: FuncRef) -> Value { ... }
fn load<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
Mem: Type,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value { ... }
fn load_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
Mem: Type,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value { ... }
fn store<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
p: Value,
Offset: T2offset32
) -> Inst { ... }
fn store_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
args: &[Value],
Offset: T2offset32
) -> Inst { ... }
fn uload8<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt8: Type,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value { ... }
fn uload8_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt8: Type,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value { ... }
fn sload8<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt8: Type,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value { ... }
fn sload8_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt8: Type,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value { ... }
fn istore8<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
p: Value,
Offset: T2offset32
) -> Inst { ... }
fn istore8_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
args: &[Value],
Offset: T2offset32
) -> Inst { ... }
fn uload16<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt16: Type,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value { ... }
fn uload16_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt16: Type,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value { ... }
fn sload16<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt16: Type,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value { ... }
fn sload16_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt16: Type,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value { ... }
fn istore16<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
p: Value,
Offset: T2offset32
) -> Inst { ... }
fn istore16_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
args: &[Value],
Offset: T2offset32
) -> Inst { ... }
fn uload32<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value { ... }
fn uload32_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value { ... }
fn sload32<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value { ... }
fn sload32_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value { ... }
fn istore32<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
p: Value,
Offset: T2offset32
) -> Inst { ... }
fn istore32_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
args: &[Value],
Offset: T2offset32
) -> Inst { ... }
fn stack_load<T1offset32: Into<Offset32>>(
self,
Mem: Type,
SS: StackSlot,
Offset: T1offset32
) -> Value { ... }
fn stack_store<T1offset32: Into<Offset32>>(
self,
x: Value,
SS: StackSlot,
Offset: T1offset32
) -> Inst { ... }
fn stack_addr<T1offset32: Into<Offset32>>(
self,
iAddr: Type,
SS: StackSlot,
Offset: T1offset32
) -> Value { ... }
fn global_value(self, Mem: Type, GV: GlobalValue) -> Value { ... }
fn symbol_value(self, Mem: Type, GV: GlobalValue) -> Value { ... }
fn heap_addr<T1uimm32: Into<Uimm32>>(
self,
iAddr: Type,
H: Heap,
p: Value,
Size: T1uimm32
) -> Value { ... }
fn table_addr<T1offset32: Into<Offset32>>(
self,
iAddr: Type,
T: Table,
p: Value,
Offset: T1offset32
) -> Value { ... }
fn iconst<T1imm64: Into<Imm64>>(self, Int: Type, N: T1imm64) -> Value { ... }
fn f32const<T1ieee32: Into<Ieee32>>(self, N: T1ieee32) -> Value { ... }
fn f64const<T1ieee64: Into<Ieee64>>(self, N: T1ieee64) -> Value { ... }
fn bconst<T1bool: Into<bool>>(self, Bool: Type, N: T1bool) -> Value { ... }
fn nop(self) -> Inst { ... }
fn select(self, c: Value, x: Value, y: Value) -> Value { ... }
fn selectif<T1intcc: Into<IntCC>>(
self,
Any: Type,
cc: T1intcc,
flags: Value,
x: Value,
y: Value
) -> Value { ... }
fn copy(self, x: Value) -> Value { ... }
fn spill(self, x: Value) -> Value { ... }
fn fill(self, x: Value) -> Value { ... }
fn regmove<T1regunit: Into<RegUnit>, T2regunit: Into<RegUnit>>(
self,
x: Value,
src: T1regunit,
dst: T2regunit
) -> Inst { ... }
fn copy_special<T1regunit: Into<RegUnit>, T2regunit: Into<RegUnit>>(
self,
src: T1regunit,
dst: T2regunit
) -> Inst { ... }
fn adjust_sp_down(self, delta: Value) -> Inst { ... }
fn adjust_sp_up_imm<T1imm64: Into<Imm64>>(self, Offset: T1imm64) -> Inst { ... }
fn adjust_sp_down_imm<T1imm64: Into<Imm64>>(self, Offset: T1imm64) -> Inst { ... }
fn ifcmp_sp(self, addr: Value) -> Value { ... }
fn regspill<T1regunit: Into<RegUnit>>(
self,
x: Value,
src: T1regunit,
SS: StackSlot
) -> Inst { ... }
fn regfill<T1regunit: Into<RegUnit>>(
self,
x: Value,
SS: StackSlot,
dst: T1regunit
) -> Inst { ... }
fn vsplit(self, x: Value) -> (Value, Value) { ... }
fn vconcat(self, x: Value, y: Value) -> Value { ... }
fn vselect(self, c: Value, x: Value, y: Value) -> Value { ... }
fn splat(self, TxN: Type, x: Value) -> Value { ... }
fn insertlane<T1uimm8: Into<Uimm8>>(
self,
x: Value,
Idx: T1uimm8,
y: Value
) -> Value { ... }
fn extractlane<T1uimm8: Into<Uimm8>>(self, x: Value, Idx: T1uimm8) -> Value { ... }
fn icmp<T1intcc: Into<IntCC>>(self, Cond: T1intcc, x: Value, y: Value) -> Value { ... }
fn icmp_imm<T1intcc: Into<IntCC>, T2imm64: Into<Imm64>>(
self,
Cond: T1intcc,
x: Value,
Y: T2imm64
) -> Value { ... }
fn ifcmp(self, x: Value, y: Value) -> Value { ... }
fn ifcmp_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value { ... }
fn iadd(self, x: Value, y: Value) -> Value { ... }
fn isub(self, x: Value, y: Value) -> Value { ... }
fn imul(self, x: Value, y: Value) -> Value { ... }
fn umulhi(self, x: Value, y: Value) -> Value { ... }
fn smulhi(self, x: Value, y: Value) -> Value { ... }
fn udiv(self, x: Value, y: Value) -> Value { ... }
fn sdiv(self, x: Value, y: Value) -> Value { ... }
fn urem(self, x: Value, y: Value) -> Value { ... }
fn srem(self, x: Value, y: Value) -> Value { ... }
fn iadd_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value { ... }
fn imul_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value { ... }
fn udiv_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value { ... }
fn sdiv_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value { ... }
fn urem_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value { ... }
fn srem_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value { ... }
fn irsub_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value { ... }
fn iadd_cin(self, x: Value, y: Value, c_in: Value) -> Value { ... }
fn iadd_cout(self, x: Value, y: Value) -> (Value, Value) { ... }
fn iadd_carry(self, x: Value, y: Value, c_in: Value) -> (Value, Value) { ... }
fn isub_bin(self, x: Value, y: Value, b_in: Value) -> Value { ... }
fn isub_bout(self, x: Value, y: Value) -> (Value, Value) { ... }
fn isub_borrow(self, x: Value, y: Value, b_in: Value) -> (Value, Value) { ... }
fn band(self, x: Value, y: Value) -> Value { ... }
fn bor(self, x: Value, y: Value) -> Value { ... }
fn bxor(self, x: Value, y: Value) -> Value { ... }
fn bnot(self, x: Value) -> Value { ... }
fn band_not(self, x: Value, y: Value) -> Value { ... }
fn bor_not(self, x: Value, y: Value) -> Value { ... }
fn bxor_not(self, x: Value, y: Value) -> Value { ... }
fn band_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value { ... }
fn bor_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value { ... }
fn bxor_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value { ... }
fn rotl(self, x: Value, y: Value) -> Value { ... }
fn rotr(self, x: Value, y: Value) -> Value { ... }
fn rotl_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value { ... }
fn rotr_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value { ... }
fn ishl(self, x: Value, y: Value) -> Value { ... }
fn ushr(self, x: Value, y: Value) -> Value { ... }
fn sshr(self, x: Value, y: Value) -> Value { ... }
fn ishl_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value { ... }
fn ushr_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value { ... }
fn sshr_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value { ... }
fn bitrev(self, x: Value) -> Value { ... }
fn clz(self, x: Value) -> Value { ... }
fn cls(self, x: Value) -> Value { ... }
fn ctz(self, x: Value) -> Value { ... }
fn popcnt(self, x: Value) -> Value { ... }
fn fcmp<T1floatcc: Into<FloatCC>>(
self,
Cond: T1floatcc,
x: Value,
y: Value
) -> Value { ... }
fn ffcmp(self, x: Value, y: Value) -> Value { ... }
fn fadd(self, x: Value, y: Value) -> Value { ... }
fn fsub(self, x: Value, y: Value) -> Value { ... }
fn fmul(self, x: Value, y: Value) -> Value { ... }
fn fdiv(self, x: Value, y: Value) -> Value { ... }
fn sqrt(self, x: Value) -> Value { ... }
fn fma(self, x: Value, y: Value, z: Value) -> Value { ... }
fn fneg(self, x: Value) -> Value { ... }
fn fabs(self, x: Value) -> Value { ... }
fn fcopysign(self, x: Value, y: Value) -> Value { ... }
fn fmin(self, x: Value, y: Value) -> Value { ... }
fn fmax(self, x: Value, y: Value) -> Value { ... }
fn ceil(self, x: Value) -> Value { ... }
fn floor(self, x: Value) -> Value { ... }
fn trunc(self, x: Value) -> Value { ... }
fn nearest(self, x: Value) -> Value { ... }
fn trueif<T1intcc: Into<IntCC>>(self, Cond: T1intcc, f: Value) -> Value { ... }
fn trueff<T1floatcc: Into<FloatCC>>(self, Cond: T1floatcc, f: Value) -> Value { ... }
fn bitcast(self, MemTo: Type, x: Value) -> Value { ... }
fn breduce(self, BoolTo: Type, x: Value) -> Value { ... }
fn bextend(self, BoolTo: Type, x: Value) -> Value { ... }
fn bint(self, IntTo: Type, x: Value) -> Value { ... }
fn bmask(self, IntTo: Type, x: Value) -> Value { ... }
fn ireduce(self, IntTo: Type, x: Value) -> Value { ... }
fn uextend(self, IntTo: Type, x: Value) -> Value { ... }
fn sextend(self, IntTo: Type, x: Value) -> Value { ... }
fn fpromote(self, FloatTo: Type, x: Value) -> Value { ... }
fn fdemote(self, FloatTo: Type, x: Value) -> Value { ... }
fn fcvt_to_uint(self, IntTo: Type, x: Value) -> Value { ... }
fn fcvt_to_uint_sat(self, IntTo: Type, x: Value) -> Value { ... }
fn fcvt_to_sint(self, IntTo: Type, x: Value) -> Value { ... }
fn fcvt_to_sint_sat(self, IntTo: Type, x: Value) -> Value { ... }
fn fcvt_from_uint(self, FloatTo: Type, x: Value) -> Value { ... }
fn fcvt_from_sint(self, FloatTo: Type, x: Value) -> Value { ... }
fn isplit(self, x: Value) -> (Value, Value) { ... }
fn iconcat(self, lo: Value, hi: Value) -> Value { ... }
fn x86_udivmodx(self, nlo: Value, nhi: Value, d: Value) -> (Value, Value) { ... }
fn x86_sdivmodx(self, nlo: Value, nhi: Value, d: Value) -> (Value, Value) { ... }
fn x86_umulx(self, argL: Value, argR: Value) -> (Value, Value) { ... }
fn x86_smulx(self, argL: Value, argR: Value) -> (Value, Value) { ... }
fn x86_cvtt2si(self, IntTo: Type, x: Value) -> Value { ... }
fn x86_fmin(self, x: Value, y: Value) -> Value { ... }
fn x86_fmax(self, x: Value, y: Value) -> Value { ... }
fn x86_push(self, x: Value) -> Inst { ... }
fn x86_pop(self, iWord: Type) -> Value { ... }
fn x86_bsr(self, x: Value) -> (Value, Value) { ... }
fn x86_bsf(self, x: Value) -> (Value, Value) { ... }
fn Unary(
self,
opcode: Opcode,
ctrl_typevar: Type,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn UnaryImm(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Imm64
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn UnaryIeee32(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Ieee32
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn UnaryIeee64(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Ieee64
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn UnaryBool(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: bool
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn UnaryGlobalValue(
self,
opcode: Opcode,
ctrl_typevar: Type,
global_value: GlobalValue
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn Binary(
self,
opcode: Opcode,
ctrl_typevar: Type,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn BinaryImm(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Imm64,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn Ternary(
self,
opcode: Opcode,
ctrl_typevar: Type,
arg0: Value,
arg1: Value,
arg2: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn MultiAry(
self,
opcode: Opcode,
ctrl_typevar: Type,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn NullAry(
self,
opcode: Opcode,
ctrl_typevar: Type
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn InsertLane(
self,
opcode: Opcode,
ctrl_typevar: Type,
lane: Uimm8,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn ExtractLane(
self,
opcode: Opcode,
ctrl_typevar: Type,
lane: Uimm8,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn IntCompare(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn IntCompareImm(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
imm: Imm64,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn IntCond(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn FloatCompare(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: FloatCC,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn FloatCond(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: FloatCC,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn IntSelect(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
arg0: Value,
arg1: Value,
arg2: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn Jump(
self,
opcode: Opcode,
ctrl_typevar: Type,
destination: Ebb,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn Branch(
self,
opcode: Opcode,
ctrl_typevar: Type,
destination: Ebb,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn BranchInt(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
destination: Ebb,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn BranchFloat(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: FloatCC,
destination: Ebb,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn BranchIcmp(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
destination: Ebb,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn BranchTable(
self,
opcode: Opcode,
ctrl_typevar: Type,
destination: Ebb,
table: JumpTable,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn BranchTableEntry(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Uimm8,
table: JumpTable,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn BranchTableBase(
self,
opcode: Opcode,
ctrl_typevar: Type,
table: JumpTable
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn IndirectJump(
self,
opcode: Opcode,
ctrl_typevar: Type,
table: JumpTable,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn Call(
self,
opcode: Opcode,
ctrl_typevar: Type,
func_ref: FuncRef,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn CallIndirect(
self,
opcode: Opcode,
ctrl_typevar: Type,
sig_ref: SigRef,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn FuncAddr(
self,
opcode: Opcode,
ctrl_typevar: Type,
func_ref: FuncRef
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn Load(
self,
opcode: Opcode,
ctrl_typevar: Type,
flags: MemFlags,
offset: Offset32,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn LoadComplex(
self,
opcode: Opcode,
ctrl_typevar: Type,
flags: MemFlags,
offset: Offset32,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn Store(
self,
opcode: Opcode,
ctrl_typevar: Type,
flags: MemFlags,
offset: Offset32,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn StoreComplex(
self,
opcode: Opcode,
ctrl_typevar: Type,
flags: MemFlags,
offset: Offset32,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn StackLoad(
self,
opcode: Opcode,
ctrl_typevar: Type,
stack_slot: StackSlot,
offset: Offset32
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn StackStore(
self,
opcode: Opcode,
ctrl_typevar: Type,
stack_slot: StackSlot,
offset: Offset32,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn HeapAddr(
self,
opcode: Opcode,
ctrl_typevar: Type,
heap: Heap,
imm: Uimm32,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn TableAddr(
self,
opcode: Opcode,
ctrl_typevar: Type,
table: Table,
offset: Offset32,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn RegMove(
self,
opcode: Opcode,
ctrl_typevar: Type,
src: RegUnit,
dst: RegUnit,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn CopySpecial(
self,
opcode: Opcode,
ctrl_typevar: Type,
src: RegUnit,
dst: RegUnit
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn RegSpill(
self,
opcode: Opcode,
ctrl_typevar: Type,
src: RegUnit,
dst: StackSlot,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn RegFill(
self,
opcode: Opcode,
ctrl_typevar: Type,
src: StackSlot,
dst: RegUnit,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn Trap(
self,
opcode: Opcode,
ctrl_typevar: Type,
code: TrapCode
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn CondTrap(
self,
opcode: Opcode,
ctrl_typevar: Type,
code: TrapCode,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn IntCondTrap(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
code: TrapCode,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
fn FloatCondTrap(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: FloatCC,
code: TrapCode,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph) { ... }
}
Expand description
Convenience methods for building instructions.
The InstBuilder
trait has one method per instruction opcode for
conveniently constructing the instruction with minimum arguments.
Polymorphic instructions infer their result types from the input
arguments when possible. In some cases, an explicit ctrl_typevar
argument is required.
The opcode methods return the new instruction’s result values, or
the Inst
itself for instructions that don’t have any results.
There is also a method per instruction format. These methods all
return an Inst
.
Provided Methods§
sourcefn fallthrough(self, EBB: Ebb, args: &[Value]) -> Inst
fn fallthrough(self, EBB: Ebb, args: &[Value]) -> Inst
fallthrough EBB, args
Fall through to the next EBB.
sourcefn brnz(self, c: Value, EBB: Ebb, args: &[Value]) -> Inst
fn brnz(self, c: Value, EBB: Ebb, args: &[Value]) -> Inst
brnz c, EBB, args
Branch when non-zero.
sourcefn br_icmp<T1intcc: Into<IntCC>>(
self,
Cond: T1intcc,
x: Value,
y: Value,
EBB: Ebb,
args: &[Value]
) -> Inst
fn br_icmp<T1intcc: Into<IntCC>>(
self,
Cond: T1intcc,
x: Value,
y: Value,
EBB: Ebb,
args: &[Value]
) -> Inst
br_icmp Cond, x, y, EBB, args
Compare scalar integers and branch.
sourcefn brif<T1intcc: Into<IntCC>>(
self,
Cond: T1intcc,
f: Value,
EBB: Ebb,
args: &[Value]
) -> Inst
fn brif<T1intcc: Into<IntCC>>(
self,
Cond: T1intcc,
f: Value,
EBB: Ebb,
args: &[Value]
) -> Inst
brif Cond, f, EBB, args
Branch when condition is true in integer CPU flags.
sourcefn brff<T1floatcc: Into<FloatCC>>(
self,
Cond: T1floatcc,
f: Value,
EBB: Ebb,
args: &[Value]
) -> Inst
fn brff<T1floatcc: Into<FloatCC>>(
self,
Cond: T1floatcc,
f: Value,
EBB: Ebb,
args: &[Value]
) -> Inst
brff Cond, f, EBB, args
Branch when condition is true in floating point CPU flags.
sourcefn br_table(self, x: Value, EBB: Ebb, JT: JumpTable) -> Inst
fn br_table(self, x: Value, EBB: Ebb, JT: JumpTable) -> Inst
br_table x, EBB, JT
Indirect branch via jump table.
sourcefn jump_table_entry<T1uimm8: Into<Uimm8>>(
self,
Entry: Type,
x: Value,
addr: Value,
Size: T1uimm8,
JT: JumpTable
) -> Value
fn jump_table_entry<T1uimm8: Into<Uimm8>>(
self,
Entry: Type,
x: Value,
addr: Value,
Size: T1uimm8,
JT: JumpTable
) -> Value
entry = jump_table_entry x, addr, Size, JT
Get an entry from a jump table.
sourcefn jump_table_base(self, iAddr: Type, JT: JumpTable) -> Value
fn jump_table_base(self, iAddr: Type, JT: JumpTable) -> Value
addr = jump_table_base JT
Get the absolute base address of a jump table.
sourcefn indirect_jump_table_br(self, addr: Value, JT: JumpTable) -> Inst
fn indirect_jump_table_br(self, addr: Value, JT: JumpTable) -> Inst
indirect_jump_table_br addr, JT
Branch indirectly via a jump table entry.
sourcefn trap<T1trapcode: Into<TrapCode>>(self, code: T1trapcode) -> Inst
fn trap<T1trapcode: Into<TrapCode>>(self, code: T1trapcode) -> Inst
trap code
Terminate execution unconditionally.
sourcefn trapz<T1trapcode: Into<TrapCode>>(self, c: Value, code: T1trapcode) -> Inst
fn trapz<T1trapcode: Into<TrapCode>>(self, c: Value, code: T1trapcode) -> Inst
trapz c, code
Trap when zero.
sourcefn trapnz<T1trapcode: Into<TrapCode>>(self, c: Value, code: T1trapcode) -> Inst
fn trapnz<T1trapcode: Into<TrapCode>>(self, c: Value, code: T1trapcode) -> Inst
trapnz c, code
Trap when non-zero.
sourcefn trapif<T1intcc: Into<IntCC>, T2trapcode: Into<TrapCode>>(
self,
Cond: T1intcc,
f: Value,
code: T2trapcode
) -> Inst
fn trapif<T1intcc: Into<IntCC>, T2trapcode: Into<TrapCode>>(
self,
Cond: T1intcc,
f: Value,
code: T2trapcode
) -> Inst
trapif Cond, f, code
Trap when condition is true in integer CPU flags.
sourcefn trapff<T1floatcc: Into<FloatCC>, T2trapcode: Into<TrapCode>>(
self,
Cond: T1floatcc,
f: Value,
code: T2trapcode
) -> Inst
fn trapff<T1floatcc: Into<FloatCC>, T2trapcode: Into<TrapCode>>(
self,
Cond: T1floatcc,
f: Value,
code: T2trapcode
) -> Inst
trapff Cond, f, code
Trap when condition is true in floating point CPU flags.
sourcefn fallthrough_return(self, rvals: &[Value]) -> Inst
fn fallthrough_return(self, rvals: &[Value]) -> Inst
fallthrough_return rvals
Return from the function by fallthrough.
sourcefn call_indirect(self, SIG: SigRef, callee: Value, args: &[Value]) -> Inst
fn call_indirect(self, SIG: SigRef, callee: Value, args: &[Value]) -> Inst
rvals = call_indirect SIG, callee, args
Indirect function call.
sourcefn func_addr(self, iAddr: Type, FN: FuncRef) -> Value
fn func_addr(self, iAddr: Type, FN: FuncRef) -> Value
addr = func_addr FN
Get the address of a function.
sourcefn load<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
Mem: Type,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value
fn load<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
Mem: Type,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value
a = load MemFlags, p, Offset
Load from memory at p + Offset
.
sourcefn load_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
Mem: Type,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value
fn load_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
Mem: Type,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value
a = load_complex MemFlags, args, Offset
Load from memory at sum(args) + Offset
.
sourcefn store<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
p: Value,
Offset: T2offset32
) -> Inst
fn store<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
p: Value,
Offset: T2offset32
) -> Inst
store MemFlags, x, p, Offset
Store x
to memory at p + Offset
.
sourcefn store_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
args: &[Value],
Offset: T2offset32
) -> Inst
fn store_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
args: &[Value],
Offset: T2offset32
) -> Inst
store_complex MemFlags, x, args, Offset
Store x
to memory at sum(args) + Offset
.
sourcefn uload8<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt8: Type,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value
fn uload8<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt8: Type,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value
a = uload8 MemFlags, p, Offset
Load 8 bits from memory at p + Offset
and zero-extend.
sourcefn uload8_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt8: Type,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value
fn uload8_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt8: Type,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value
a = uload8_complex MemFlags, args, Offset
Load 8 bits from memory at sum(args) + Offset
and zero-extend.
sourcefn sload8<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt8: Type,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value
fn sload8<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt8: Type,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value
a = sload8 MemFlags, p, Offset
Load 8 bits from memory at p + Offset
and sign-extend.
sourcefn sload8_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt8: Type,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value
fn sload8_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt8: Type,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value
a = sload8_complex MemFlags, args, Offset
Load 8 bits from memory at sum(args) + Offset
and sign-extend.
sourcefn istore8<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
p: Value,
Offset: T2offset32
) -> Inst
fn istore8<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
p: Value,
Offset: T2offset32
) -> Inst
istore8 MemFlags, x, p, Offset
Store the low 8 bits of x
to memory at p + Offset
.
sourcefn istore8_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
args: &[Value],
Offset: T2offset32
) -> Inst
fn istore8_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
args: &[Value],
Offset: T2offset32
) -> Inst
istore8_complex MemFlags, x, args, Offset
Store the low 8 bits of x
to memory at sum(args) + Offset
.
sourcefn uload16<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt16: Type,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value
fn uload16<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt16: Type,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value
a = uload16 MemFlags, p, Offset
Load 16 bits from memory at p + Offset
and zero-extend.
sourcefn uload16_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt16: Type,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value
fn uload16_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt16: Type,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value
a = uload16_complex MemFlags, args, Offset
Load 16 bits from memory at sum(args) + Offset
and zero-extend.
sourcefn sload16<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt16: Type,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value
fn sload16<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt16: Type,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value
a = sload16 MemFlags, p, Offset
Load 16 bits from memory at p + Offset
and sign-extend.
sourcefn sload16_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt16: Type,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value
fn sload16_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
iExt16: Type,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value
a = sload16_complex MemFlags, args, Offset
Load 16 bits from memory at sum(args) + Offset
and sign-extend.
sourcefn istore16<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
p: Value,
Offset: T2offset32
) -> Inst
fn istore16<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
p: Value,
Offset: T2offset32
) -> Inst
istore16 MemFlags, x, p, Offset
Store the low 16 bits of x
to memory at p + Offset
.
sourcefn istore16_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
args: &[Value],
Offset: T2offset32
) -> Inst
fn istore16_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
args: &[Value],
Offset: T2offset32
) -> Inst
istore16_complex MemFlags, x, args, Offset
Store the low 16 bits of x
to memory at sum(args) + Offset
.
sourcefn uload32<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value
fn uload32<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value
a = uload32 MemFlags, p, Offset
Load 32 bits from memory at p + Offset
and zero-extend.
sourcefn uload32_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value
fn uload32_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value
a = uload32_complex MemFlags, args, Offset
Load 32 bits from memory at sum(args) + Offset
and zero-extend.
sourcefn sload32<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value
fn sload32<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
p: Value,
Offset: T2offset32
) -> Value
a = sload32 MemFlags, p, Offset
Load 32 bits from memory at p + Offset
and sign-extend.
sourcefn sload32_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value
fn sload32_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
args: &[Value],
Offset: T2offset32
) -> Value
a = sload32_complex MemFlags, args, Offset
Load 32 bits from memory at sum(args) + Offset
and sign-extend.
sourcefn istore32<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
p: Value,
Offset: T2offset32
) -> Inst
fn istore32<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
p: Value,
Offset: T2offset32
) -> Inst
istore32 MemFlags, x, p, Offset
Store the low 32 bits of x
to memory at p + Offset
.
sourcefn istore32_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
args: &[Value],
Offset: T2offset32
) -> Inst
fn istore32_complex<T1memflags: Into<MemFlags>, T2offset32: Into<Offset32>>(
self,
MemFlags: T1memflags,
x: Value,
args: &[Value],
Offset: T2offset32
) -> Inst
istore32_complex MemFlags, x, args, Offset
Store the low 32 bits of x
to memory at sum(args) + Offset
.
sourcefn stack_load<T1offset32: Into<Offset32>>(
self,
Mem: Type,
SS: StackSlot,
Offset: T1offset32
) -> Value
fn stack_load<T1offset32: Into<Offset32>>(
self,
Mem: Type,
SS: StackSlot,
Offset: T1offset32
) -> Value
a = stack_load SS, Offset
Load a value from a stack slot at the constant offset.
sourcefn stack_store<T1offset32: Into<Offset32>>(
self,
x: Value,
SS: StackSlot,
Offset: T1offset32
) -> Inst
fn stack_store<T1offset32: Into<Offset32>>(
self,
x: Value,
SS: StackSlot,
Offset: T1offset32
) -> Inst
stack_store x, SS, Offset
Store a value to a stack slot at a constant offset.
sourcefn stack_addr<T1offset32: Into<Offset32>>(
self,
iAddr: Type,
SS: StackSlot,
Offset: T1offset32
) -> Value
fn stack_addr<T1offset32: Into<Offset32>>(
self,
iAddr: Type,
SS: StackSlot,
Offset: T1offset32
) -> Value
addr = stack_addr SS, Offset
Get the address of a stack slot.
sourcefn global_value(self, Mem: Type, GV: GlobalValue) -> Value
fn global_value(self, Mem: Type, GV: GlobalValue) -> Value
a = global_value GV
Compute the value of global GV.
sourcefn symbol_value(self, Mem: Type, GV: GlobalValue) -> Value
fn symbol_value(self, Mem: Type, GV: GlobalValue) -> Value
a = symbol_value GV
Compute the value of global GV, which is a symbolic value.
sourcefn heap_addr<T1uimm32: Into<Uimm32>>(
self,
iAddr: Type,
H: Heap,
p: Value,
Size: T1uimm32
) -> Value
fn heap_addr<T1uimm32: Into<Uimm32>>(
self,
iAddr: Type,
H: Heap,
p: Value,
Size: T1uimm32
) -> Value
addr = heap_addr H, p, Size
Bounds check and compute absolute address of heap memory.
sourcefn table_addr<T1offset32: Into<Offset32>>(
self,
iAddr: Type,
T: Table,
p: Value,
Offset: T1offset32
) -> Value
fn table_addr<T1offset32: Into<Offset32>>(
self,
iAddr: Type,
T: Table,
p: Value,
Offset: T1offset32
) -> Value
addr = table_addr T, p, Offset
Bounds check and compute absolute address of a table entry.
sourcefn iconst<T1imm64: Into<Imm64>>(self, Int: Type, N: T1imm64) -> Value
fn iconst<T1imm64: Into<Imm64>>(self, Int: Type, N: T1imm64) -> Value
a = iconst N
Integer constant.
sourcefn f32const<T1ieee32: Into<Ieee32>>(self, N: T1ieee32) -> Value
fn f32const<T1ieee32: Into<Ieee32>>(self, N: T1ieee32) -> Value
a = f32const N
Floating point constant.
sourcefn f64const<T1ieee64: Into<Ieee64>>(self, N: T1ieee64) -> Value
fn f64const<T1ieee64: Into<Ieee64>>(self, N: T1ieee64) -> Value
a = f64const N
Floating point constant.
sourcefn bconst<T1bool: Into<bool>>(self, Bool: Type, N: T1bool) -> Value
fn bconst<T1bool: Into<bool>>(self, Bool: Type, N: T1bool) -> Value
a = bconst N
Boolean constant.
sourcefn selectif<T1intcc: Into<IntCC>>(
self,
Any: Type,
cc: T1intcc,
flags: Value,
x: Value,
y: Value
) -> Value
fn selectif<T1intcc: Into<IntCC>>(
self,
Any: Type,
cc: T1intcc,
flags: Value,
x: Value,
y: Value
) -> Value
a = selectif cc, flags, x, y
Conditional select, dependent on integer condition codes.
sourcefn regmove<T1regunit: Into<RegUnit>, T2regunit: Into<RegUnit>>(
self,
x: Value,
src: T1regunit,
dst: T2regunit
) -> Inst
fn regmove<T1regunit: Into<RegUnit>, T2regunit: Into<RegUnit>>(
self,
x: Value,
src: T1regunit,
dst: T2regunit
) -> Inst
regmove x, src, dst
Temporarily divert x
from src
to dst
.
sourcefn copy_special<T1regunit: Into<RegUnit>, T2regunit: Into<RegUnit>>(
self,
src: T1regunit,
dst: T2regunit
) -> Inst
fn copy_special<T1regunit: Into<RegUnit>, T2regunit: Into<RegUnit>>(
self,
src: T1regunit,
dst: T2regunit
) -> Inst
copy_special src, dst
Copies the contents of ’‘src’’ register to ’‘dst’’ register.
sourcefn adjust_sp_down(self, delta: Value) -> Inst
fn adjust_sp_down(self, delta: Value) -> Inst
adjust_sp_down delta
Subtracts delta
offset value from the stack pointer register.
sourcefn adjust_sp_up_imm<T1imm64: Into<Imm64>>(self, Offset: T1imm64) -> Inst
fn adjust_sp_up_imm<T1imm64: Into<Imm64>>(self, Offset: T1imm64) -> Inst
adjust_sp_up_imm Offset
Adds Offset
immediate offset value to the stack pointer register.
sourcefn adjust_sp_down_imm<T1imm64: Into<Imm64>>(self, Offset: T1imm64) -> Inst
fn adjust_sp_down_imm<T1imm64: Into<Imm64>>(self, Offset: T1imm64) -> Inst
adjust_sp_down_imm Offset
Subtracts Offset
immediate offset value from the stack pointer
sourcefn ifcmp_sp(self, addr: Value) -> Value
fn ifcmp_sp(self, addr: Value) -> Value
f = ifcmp_sp addr
Compare addr
with the stack pointer and set the CPU flags.
sourcefn regspill<T1regunit: Into<RegUnit>>(
self,
x: Value,
src: T1regunit,
SS: StackSlot
) -> Inst
fn regspill<T1regunit: Into<RegUnit>>(
self,
x: Value,
src: T1regunit,
SS: StackSlot
) -> Inst
regspill x, src, SS
Temporarily divert x
from src
to SS
.
sourcefn regfill<T1regunit: Into<RegUnit>>(
self,
x: Value,
SS: StackSlot,
dst: T1regunit
) -> Inst
fn regfill<T1regunit: Into<RegUnit>>(
self,
x: Value,
SS: StackSlot,
dst: T1regunit
) -> Inst
regfill x, SS, dst
Temporarily divert x
from SS
to dst
.
sourcefn vselect(self, c: Value, x: Value, y: Value) -> Value
fn vselect(self, c: Value, x: Value, y: Value) -> Value
a = vselect c, x, y
Vector lane select.
sourcefn insertlane<T1uimm8: Into<Uimm8>>(
self,
x: Value,
Idx: T1uimm8,
y: Value
) -> Value
fn insertlane<T1uimm8: Into<Uimm8>>(
self,
x: Value,
Idx: T1uimm8,
y: Value
) -> Value
a = insertlane x, Idx, y
Insert y
as lane Idx
in x.
sourcefn extractlane<T1uimm8: Into<Uimm8>>(self, x: Value, Idx: T1uimm8) -> Value
fn extractlane<T1uimm8: Into<Uimm8>>(self, x: Value, Idx: T1uimm8) -> Value
a = extractlane x, Idx
Extract lane Idx
from x
.
sourcefn icmp<T1intcc: Into<IntCC>>(self, Cond: T1intcc, x: Value, y: Value) -> Value
fn icmp<T1intcc: Into<IntCC>>(self, Cond: T1intcc, x: Value, y: Value) -> Value
a = icmp Cond, x, y
Integer comparison.
sourcefn icmp_imm<T1intcc: Into<IntCC>, T2imm64: Into<Imm64>>(
self,
Cond: T1intcc,
x: Value,
Y: T2imm64
) -> Value
fn icmp_imm<T1intcc: Into<IntCC>, T2imm64: Into<Imm64>>(
self,
Cond: T1intcc,
x: Value,
Y: T2imm64
) -> Value
a = icmp_imm Cond, x, Y
Compare scalar integer to a constant.
sourcefn ifcmp(self, x: Value, y: Value) -> Value
fn ifcmp(self, x: Value, y: Value) -> Value
f = ifcmp x, y
Compare scalar integers and return flags.
sourcefn ifcmp_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
fn ifcmp_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
f = ifcmp_imm x, Y
Compare scalar integer to a constant and return flags.
sourcefn iadd(self, x: Value, y: Value) -> Value
fn iadd(self, x: Value, y: Value) -> Value
a = iadd x, y
Wrapping integer addition: :math:a := x + y \pmod{2^B}
.
sourcefn isub(self, x: Value, y: Value) -> Value
fn isub(self, x: Value, y: Value) -> Value
a = isub x, y
Wrapping integer subtraction: :math:a := x - y \pmod{2^B}
.
sourcefn imul(self, x: Value, y: Value) -> Value
fn imul(self, x: Value, y: Value) -> Value
a = imul x, y
Wrapping integer multiplication: :math:a := x y \pmod{2^B}
.
sourcefn umulhi(self, x: Value, y: Value) -> Value
fn umulhi(self, x: Value, y: Value) -> Value
a = umulhi x, y
Unsigned integer multiplication, producing the high half of a
sourcefn smulhi(self, x: Value, y: Value) -> Value
fn smulhi(self, x: Value, y: Value) -> Value
a = smulhi x, y
Signed integer multiplication, producing the high half of a
sourcefn udiv(self, x: Value, y: Value) -> Value
fn udiv(self, x: Value, y: Value) -> Value
a = udiv x, y
Unsigned integer division: :math:a := \lfloor {x \over y} \rfloor
.
sourcefn sdiv(self, x: Value, y: Value) -> Value
fn sdiv(self, x: Value, y: Value) -> Value
a = sdiv x, y
Signed integer division rounded toward zero: :math:`a := sign(xy)
sourcefn srem(self, x: Value, y: Value) -> Value
fn srem(self, x: Value, y: Value) -> Value
a = srem x, y
Signed integer remainder. The result has the sign of the dividend.
sourcefn iadd_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
fn iadd_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
a = iadd_imm x, Y
Add immediate integer.
sourcefn imul_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
fn imul_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
a = imul_imm x, Y
Integer multiplication by immediate constant.
sourcefn udiv_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
fn udiv_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
a = udiv_imm x, Y
Unsigned integer division by an immediate constant.
sourcefn sdiv_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
fn sdiv_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
a = sdiv_imm x, Y
Signed integer division by an immediate constant.
sourcefn urem_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
fn urem_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
a = urem_imm x, Y
Unsigned integer remainder with immediate divisor.
sourcefn srem_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
fn srem_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
a = srem_imm x, Y
Signed integer remainder with immediate divisor.
sourcefn irsub_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
fn irsub_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
a = irsub_imm x, Y
Immediate reverse wrapping subtraction: :math:a := Y - x \pmod{2^B}
.
sourcefn iadd_cin(self, x: Value, y: Value, c_in: Value) -> Value
fn iadd_cin(self, x: Value, y: Value, c_in: Value) -> Value
a = iadd_cin x, y, c_in
Add integers with carry in.
sourcefn iadd_cout(self, x: Value, y: Value) -> (Value, Value)
fn iadd_cout(self, x: Value, y: Value) -> (Value, Value)
a, c_out = iadd_cout x, y
Add integers with carry out.
sourcefn iadd_carry(self, x: Value, y: Value, c_in: Value) -> (Value, Value)
fn iadd_carry(self, x: Value, y: Value, c_in: Value) -> (Value, Value)
a, c_out = iadd_carry x, y, c_in
Add integers with carry in and out.
sourcefn isub_bin(self, x: Value, y: Value, b_in: Value) -> Value
fn isub_bin(self, x: Value, y: Value, b_in: Value) -> Value
a = isub_bin x, y, b_in
Subtract integers with borrow in.
sourcefn isub_bout(self, x: Value, y: Value) -> (Value, Value)
fn isub_bout(self, x: Value, y: Value) -> (Value, Value)
a, b_out = isub_bout x, y
Subtract integers with borrow out.
sourcefn isub_borrow(self, x: Value, y: Value, b_in: Value) -> (Value, Value)
fn isub_borrow(self, x: Value, y: Value, b_in: Value) -> (Value, Value)
a, b_out = isub_borrow x, y, b_in
Subtract integers with borrow in and out.
sourcefn band_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
fn band_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
a = band_imm x, Y
Bitwise and with immediate.
sourcefn bor_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
fn bor_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
a = bor_imm x, Y
Bitwise or with immediate.
sourcefn bxor_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
fn bxor_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
a = bxor_imm x, Y
Bitwise xor with immediate.
sourcefn rotl_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
fn rotl_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
a = rotl_imm x, Y
Rotate left by immediate.
sourcefn rotr_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
fn rotr_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
a = rotr_imm x, Y
Rotate right by immediate.
sourcefn ishl(self, x: Value, y: Value) -> Value
fn ishl(self, x: Value, y: Value) -> Value
a = ishl x, y
Integer shift left. Shift the bits in x
towards the MSB by y
sourcefn ushr(self, x: Value, y: Value) -> Value
fn ushr(self, x: Value, y: Value) -> Value
a = ushr x, y
Unsigned shift right. Shift bits in x
towards the LSB by y
sourcefn sshr(self, x: Value, y: Value) -> Value
fn sshr(self, x: Value, y: Value) -> Value
a = sshr x, y
Signed shift right. Shift bits in x
towards the LSB by y
sourcefn ishl_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
fn ishl_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
a = ishl_imm x, Y
Integer shift left by immediate.
sourcefn ushr_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
fn ushr_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
a = ushr_imm x, Y
Unsigned shift right by immediate.
sourcefn sshr_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
fn sshr_imm<T1imm64: Into<Imm64>>(self, x: Value, Y: T1imm64) -> Value
a = sshr_imm x, Y
Signed shift right by immediate.
sourcefn fcmp<T1floatcc: Into<FloatCC>>(
self,
Cond: T1floatcc,
x: Value,
y: Value
) -> Value
fn fcmp<T1floatcc: Into<FloatCC>>(
self,
Cond: T1floatcc,
x: Value,
y: Value
) -> Value
a = fcmp Cond, x, y
Floating point comparison.
sourcefn ffcmp(self, x: Value, y: Value) -> Value
fn ffcmp(self, x: Value, y: Value) -> Value
f = ffcmp x, y
Floating point comparison returning flags.
sourcefn fma(self, x: Value, y: Value, z: Value) -> Value
fn fma(self, x: Value, y: Value, z: Value) -> Value
a = fma x, y, z
Floating point fused multiply-and-add.
sourcefn fmin(self, x: Value, y: Value) -> Value
fn fmin(self, x: Value, y: Value) -> Value
a = fmin x, y
Floating point minimum, propagating NaNs.
sourcefn fmax(self, x: Value, y: Value) -> Value
fn fmax(self, x: Value, y: Value) -> Value
a = fmax x, y
Floating point maximum, propagating NaNs.
sourcefn ceil(self, x: Value) -> Value
fn ceil(self, x: Value) -> Value
a = ceil x
Round floating point round to integral, towards positive infinity.
sourcefn floor(self, x: Value) -> Value
fn floor(self, x: Value) -> Value
a = floor x
Round floating point round to integral, towards negative infinity.
sourcefn trunc(self, x: Value) -> Value
fn trunc(self, x: Value) -> Value
a = trunc x
Round floating point round to integral, towards zero.
sourcefn nearest(self, x: Value) -> Value
fn nearest(self, x: Value) -> Value
a = nearest x
Round floating point round to integral, towards nearest with ties to
sourcefn trueif<T1intcc: Into<IntCC>>(self, Cond: T1intcc, f: Value) -> Value
fn trueif<T1intcc: Into<IntCC>>(self, Cond: T1intcc, f: Value) -> Value
a = trueif Cond, f
Test integer CPU flags for a specific condition.
sourcefn trueff<T1floatcc: Into<FloatCC>>(self, Cond: T1floatcc, f: Value) -> Value
fn trueff<T1floatcc: Into<FloatCC>>(self, Cond: T1floatcc, f: Value) -> Value
a = trueff Cond, f
Test floating point CPU flags for a specific condition.
sourcefn bitcast(self, MemTo: Type, x: Value) -> Value
fn bitcast(self, MemTo: Type, x: Value) -> Value
a = bitcast x
Reinterpret the bits in x
as a different type.
sourcefn breduce(self, BoolTo: Type, x: Value) -> Value
fn breduce(self, BoolTo: Type, x: Value) -> Value
a = breduce x
Convert x
to a smaller boolean type in the platform-defined way.
sourcefn bextend(self, BoolTo: Type, x: Value) -> Value
fn bextend(self, BoolTo: Type, x: Value) -> Value
a = bextend x
Convert x
to a larger boolean type in the platform-defined way.
sourcefn ireduce(self, IntTo: Type, x: Value) -> Value
fn ireduce(self, IntTo: Type, x: Value) -> Value
a = ireduce x
Convert x
to a smaller integer type by dropping high bits.
sourcefn uextend(self, IntTo: Type, x: Value) -> Value
fn uextend(self, IntTo: Type, x: Value) -> Value
a = uextend x
Convert x
to a larger integer type by zero-extending.
sourcefn sextend(self, IntTo: Type, x: Value) -> Value
fn sextend(self, IntTo: Type, x: Value) -> Value
a = sextend x
Convert x
to a larger integer type by sign-extending.
sourcefn fpromote(self, FloatTo: Type, x: Value) -> Value
fn fpromote(self, FloatTo: Type, x: Value) -> Value
a = fpromote x
Convert x
to a larger floating point format.
sourcefn fdemote(self, FloatTo: Type, x: Value) -> Value
fn fdemote(self, FloatTo: Type, x: Value) -> Value
a = fdemote x
Convert x
to a smaller floating point format.
sourcefn fcvt_to_uint(self, IntTo: Type, x: Value) -> Value
fn fcvt_to_uint(self, IntTo: Type, x: Value) -> Value
a = fcvt_to_uint x
Convert floating point to unsigned integer.
sourcefn fcvt_to_uint_sat(self, IntTo: Type, x: Value) -> Value
fn fcvt_to_uint_sat(self, IntTo: Type, x: Value) -> Value
a = fcvt_to_uint_sat x
Convert floating point to unsigned integer as fcvt_to_uint does, but
sourcefn fcvt_to_sint(self, IntTo: Type, x: Value) -> Value
fn fcvt_to_sint(self, IntTo: Type, x: Value) -> Value
a = fcvt_to_sint x
Convert floating point to signed integer.
sourcefn fcvt_to_sint_sat(self, IntTo: Type, x: Value) -> Value
fn fcvt_to_sint_sat(self, IntTo: Type, x: Value) -> Value
a = fcvt_to_sint_sat x
Convert floating point to signed integer as fcvt_to_sint does, but
sourcefn fcvt_from_uint(self, FloatTo: Type, x: Value) -> Value
fn fcvt_from_uint(self, FloatTo: Type, x: Value) -> Value
a = fcvt_from_uint x
Convert unsigned integer to floating point.
sourcefn fcvt_from_sint(self, FloatTo: Type, x: Value) -> Value
fn fcvt_from_sint(self, FloatTo: Type, x: Value) -> Value
a = fcvt_from_sint x
Convert signed integer to floating point.
sourcefn isplit(self, x: Value) -> (Value, Value)
fn isplit(self, x: Value) -> (Value, Value)
lo, hi = isplit x
Split an integer into low and high parts.
sourcefn iconcat(self, lo: Value, hi: Value) -> Value
fn iconcat(self, lo: Value, hi: Value) -> Value
a = iconcat lo, hi
Concatenate low and high bits to form a larger integer type.
sourcefn x86_udivmodx(self, nlo: Value, nhi: Value, d: Value) -> (Value, Value)
fn x86_udivmodx(self, nlo: Value, nhi: Value, d: Value) -> (Value, Value)
q, r = x86_udivmodx nlo, nhi, d
Extended unsigned division.
sourcefn x86_sdivmodx(self, nlo: Value, nhi: Value, d: Value) -> (Value, Value)
fn x86_sdivmodx(self, nlo: Value, nhi: Value, d: Value) -> (Value, Value)
q, r = x86_sdivmodx nlo, nhi, d
Extended signed division.
sourcefn x86_umulx(self, argL: Value, argR: Value) -> (Value, Value)
fn x86_umulx(self, argL: Value, argR: Value) -> (Value, Value)
resLo, resHi = x86_umulx argL, argR
Unsigned integer multiplication, producing a double-length result.
sourcefn x86_smulx(self, argL: Value, argR: Value) -> (Value, Value)
fn x86_smulx(self, argL: Value, argR: Value) -> (Value, Value)
resLo, resHi = x86_smulx argL, argR
Signed integer multiplication, producing a double-length result.
sourcefn x86_cvtt2si(self, IntTo: Type, x: Value) -> Value
fn x86_cvtt2si(self, IntTo: Type, x: Value) -> Value
a = x86_cvtt2si x
Convert with truncation floating point to signed integer.
sourcefn x86_fmin(self, x: Value, y: Value) -> Value
fn x86_fmin(self, x: Value, y: Value) -> Value
a = x86_fmin x, y
Floating point minimum with x86 semantics.
sourcefn x86_fmax(self, x: Value, y: Value) -> Value
fn x86_fmax(self, x: Value, y: Value) -> Value
a = x86_fmax x, y
Floating point maximum with x86 semantics.
sourcefn x86_bsr(self, x: Value) -> (Value, Value)
fn x86_bsr(self, x: Value) -> (Value, Value)
y, rflags = x86_bsr x
Bit Scan Reverse – returns the bit-index of the most significant 1
sourcefn x86_bsf(self, x: Value) -> (Value, Value)
fn x86_bsf(self, x: Value) -> (Value, Value)
y, rflags = x86_bsf x
Bit Scan Forwards – returns the bit-index of the least significant 1
sourcefn Unary(
self,
opcode: Opcode,
ctrl_typevar: Type,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn Unary(
self,
opcode: Opcode,
ctrl_typevar: Type,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
Unary(imms=(), vals=1)
sourcefn UnaryImm(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Imm64
) -> (Inst, &'f mut DataFlowGraph)
fn UnaryImm(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Imm64
) -> (Inst, &'f mut DataFlowGraph)
UnaryImm(imms=(imm: imm64), vals=0)
sourcefn UnaryIeee32(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Ieee32
) -> (Inst, &'f mut DataFlowGraph)
fn UnaryIeee32(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Ieee32
) -> (Inst, &'f mut DataFlowGraph)
UnaryIeee32(imms=(imm: ieee32), vals=0)
sourcefn UnaryIeee64(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Ieee64
) -> (Inst, &'f mut DataFlowGraph)
fn UnaryIeee64(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Ieee64
) -> (Inst, &'f mut DataFlowGraph)
UnaryIeee64(imms=(imm: ieee64), vals=0)
sourcefn UnaryBool(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: bool
) -> (Inst, &'f mut DataFlowGraph)
fn UnaryBool(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: bool
) -> (Inst, &'f mut DataFlowGraph)
UnaryBool(imms=(imm: bool), vals=0)
sourcefn UnaryGlobalValue(
self,
opcode: Opcode,
ctrl_typevar: Type,
global_value: GlobalValue
) -> (Inst, &'f mut DataFlowGraph)
fn UnaryGlobalValue(
self,
opcode: Opcode,
ctrl_typevar: Type,
global_value: GlobalValue
) -> (Inst, &'f mut DataFlowGraph)
UnaryGlobalValue(imms=(global_value: global_value), vals=0)
sourcefn Binary(
self,
opcode: Opcode,
ctrl_typevar: Type,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)
fn Binary(
self,
opcode: Opcode,
ctrl_typevar: Type,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)
Binary(imms=(), vals=2)
sourcefn BinaryImm(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Imm64,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn BinaryImm(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Imm64,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
BinaryImm(imms=(imm: imm64), vals=1)
sourcefn Ternary(
self,
opcode: Opcode,
ctrl_typevar: Type,
arg0: Value,
arg1: Value,
arg2: Value
) -> (Inst, &'f mut DataFlowGraph)
fn Ternary(
self,
opcode: Opcode,
ctrl_typevar: Type,
arg0: Value,
arg1: Value,
arg2: Value
) -> (Inst, &'f mut DataFlowGraph)
Ternary(imms=(), vals=3)
sourcefn MultiAry(
self,
opcode: Opcode,
ctrl_typevar: Type,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
fn MultiAry(
self,
opcode: Opcode,
ctrl_typevar: Type,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
MultiAry(imms=(), vals=0)
sourcefn NullAry(
self,
opcode: Opcode,
ctrl_typevar: Type
) -> (Inst, &'f mut DataFlowGraph)
fn NullAry(
self,
opcode: Opcode,
ctrl_typevar: Type
) -> (Inst, &'f mut DataFlowGraph)
NullAry(imms=(), vals=0)
sourcefn InsertLane(
self,
opcode: Opcode,
ctrl_typevar: Type,
lane: Uimm8,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)
fn InsertLane(
self,
opcode: Opcode,
ctrl_typevar: Type,
lane: Uimm8,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)
InsertLane(imms=(lane: uimm8), vals=2)
sourcefn ExtractLane(
self,
opcode: Opcode,
ctrl_typevar: Type,
lane: Uimm8,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn ExtractLane(
self,
opcode: Opcode,
ctrl_typevar: Type,
lane: Uimm8,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
ExtractLane(imms=(lane: uimm8), vals=1)
sourcefn IntCompare(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)
fn IntCompare(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)
IntCompare(imms=(cond: intcc), vals=2)
sourcefn IntCompareImm(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
imm: Imm64,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn IntCompareImm(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
imm: Imm64,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
IntCompareImm(imms=(cond: intcc, imm: imm64), vals=1)
sourcefn IntCond(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn IntCond(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
IntCond(imms=(cond: intcc), vals=1)
sourcefn FloatCompare(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: FloatCC,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)
fn FloatCompare(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: FloatCC,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)
FloatCompare(imms=(cond: floatcc), vals=2)
sourcefn FloatCond(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: FloatCC,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn FloatCond(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: FloatCC,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
FloatCond(imms=(cond: floatcc), vals=1)
sourcefn IntSelect(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
arg0: Value,
arg1: Value,
arg2: Value
) -> (Inst, &'f mut DataFlowGraph)
fn IntSelect(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
arg0: Value,
arg1: Value,
arg2: Value
) -> (Inst, &'f mut DataFlowGraph)
IntSelect(imms=(cond: intcc), vals=3)
sourcefn Jump(
self,
opcode: Opcode,
ctrl_typevar: Type,
destination: Ebb,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
fn Jump(
self,
opcode: Opcode,
ctrl_typevar: Type,
destination: Ebb,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
Jump(imms=(destination: ebb), vals=0)
sourcefn Branch(
self,
opcode: Opcode,
ctrl_typevar: Type,
destination: Ebb,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
fn Branch(
self,
opcode: Opcode,
ctrl_typevar: Type,
destination: Ebb,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
Branch(imms=(destination: ebb), vals=1)
sourcefn BranchInt(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
destination: Ebb,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
fn BranchInt(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
destination: Ebb,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
BranchInt(imms=(cond: intcc, destination: ebb), vals=1)
sourcefn BranchFloat(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: FloatCC,
destination: Ebb,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
fn BranchFloat(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: FloatCC,
destination: Ebb,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
BranchFloat(imms=(cond: floatcc, destination: ebb), vals=1)
sourcefn BranchIcmp(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
destination: Ebb,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
fn BranchIcmp(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
destination: Ebb,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
BranchIcmp(imms=(cond: intcc, destination: ebb), vals=2)
sourcefn BranchTable(
self,
opcode: Opcode,
ctrl_typevar: Type,
destination: Ebb,
table: JumpTable,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn BranchTable(
self,
opcode: Opcode,
ctrl_typevar: Type,
destination: Ebb,
table: JumpTable,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
BranchTable(imms=(destination: ebb, table: jump_table), vals=1)
sourcefn BranchTableEntry(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Uimm8,
table: JumpTable,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)
fn BranchTableEntry(
self,
opcode: Opcode,
ctrl_typevar: Type,
imm: Uimm8,
table: JumpTable,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)
BranchTableEntry(imms=(imm: uimm8, table: jump_table), vals=2)
sourcefn BranchTableBase(
self,
opcode: Opcode,
ctrl_typevar: Type,
table: JumpTable
) -> (Inst, &'f mut DataFlowGraph)
fn BranchTableBase(
self,
opcode: Opcode,
ctrl_typevar: Type,
table: JumpTable
) -> (Inst, &'f mut DataFlowGraph)
BranchTableBase(imms=(table: jump_table), vals=0)
sourcefn IndirectJump(
self,
opcode: Opcode,
ctrl_typevar: Type,
table: JumpTable,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn IndirectJump(
self,
opcode: Opcode,
ctrl_typevar: Type,
table: JumpTable,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
IndirectJump(imms=(table: jump_table), vals=1)
sourcefn Call(
self,
opcode: Opcode,
ctrl_typevar: Type,
func_ref: FuncRef,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
fn Call(
self,
opcode: Opcode,
ctrl_typevar: Type,
func_ref: FuncRef,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
Call(imms=(func_ref: func_ref), vals=0)
sourcefn CallIndirect(
self,
opcode: Opcode,
ctrl_typevar: Type,
sig_ref: SigRef,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
fn CallIndirect(
self,
opcode: Opcode,
ctrl_typevar: Type,
sig_ref: SigRef,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
CallIndirect(imms=(sig_ref: sig_ref), vals=1)
sourcefn FuncAddr(
self,
opcode: Opcode,
ctrl_typevar: Type,
func_ref: FuncRef
) -> (Inst, &'f mut DataFlowGraph)
fn FuncAddr(
self,
opcode: Opcode,
ctrl_typevar: Type,
func_ref: FuncRef
) -> (Inst, &'f mut DataFlowGraph)
FuncAddr(imms=(func_ref: func_ref), vals=0)
sourcefn Load(
self,
opcode: Opcode,
ctrl_typevar: Type,
flags: MemFlags,
offset: Offset32,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn Load(
self,
opcode: Opcode,
ctrl_typevar: Type,
flags: MemFlags,
offset: Offset32,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
Load(imms=(flags: memflags, offset: offset32), vals=1)
sourcefn LoadComplex(
self,
opcode: Opcode,
ctrl_typevar: Type,
flags: MemFlags,
offset: Offset32,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
fn LoadComplex(
self,
opcode: Opcode,
ctrl_typevar: Type,
flags: MemFlags,
offset: Offset32,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
LoadComplex(imms=(flags: memflags, offset: offset32), vals=0)
sourcefn Store(
self,
opcode: Opcode,
ctrl_typevar: Type,
flags: MemFlags,
offset: Offset32,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)
fn Store(
self,
opcode: Opcode,
ctrl_typevar: Type,
flags: MemFlags,
offset: Offset32,
arg0: Value,
arg1: Value
) -> (Inst, &'f mut DataFlowGraph)
Store(imms=(flags: memflags, offset: offset32), vals=2)
sourcefn StoreComplex(
self,
opcode: Opcode,
ctrl_typevar: Type,
flags: MemFlags,
offset: Offset32,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
fn StoreComplex(
self,
opcode: Opcode,
ctrl_typevar: Type,
flags: MemFlags,
offset: Offset32,
args: ValueList
) -> (Inst, &'f mut DataFlowGraph)
StoreComplex(imms=(flags: memflags, offset: offset32), vals=1)
sourcefn StackLoad(
self,
opcode: Opcode,
ctrl_typevar: Type,
stack_slot: StackSlot,
offset: Offset32
) -> (Inst, &'f mut DataFlowGraph)
fn StackLoad(
self,
opcode: Opcode,
ctrl_typevar: Type,
stack_slot: StackSlot,
offset: Offset32
) -> (Inst, &'f mut DataFlowGraph)
StackLoad(imms=(stack_slot: stack_slot, offset: offset32), vals=0)
sourcefn StackStore(
self,
opcode: Opcode,
ctrl_typevar: Type,
stack_slot: StackSlot,
offset: Offset32,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn StackStore(
self,
opcode: Opcode,
ctrl_typevar: Type,
stack_slot: StackSlot,
offset: Offset32,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
StackStore(imms=(stack_slot: stack_slot, offset: offset32), vals=1)
sourcefn HeapAddr(
self,
opcode: Opcode,
ctrl_typevar: Type,
heap: Heap,
imm: Uimm32,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn HeapAddr(
self,
opcode: Opcode,
ctrl_typevar: Type,
heap: Heap,
imm: Uimm32,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
HeapAddr(imms=(heap: heap, imm: uimm32), vals=1)
sourcefn TableAddr(
self,
opcode: Opcode,
ctrl_typevar: Type,
table: Table,
offset: Offset32,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn TableAddr(
self,
opcode: Opcode,
ctrl_typevar: Type,
table: Table,
offset: Offset32,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
TableAddr(imms=(table: table, offset: offset32), vals=1)
sourcefn RegMove(
self,
opcode: Opcode,
ctrl_typevar: Type,
src: RegUnit,
dst: RegUnit,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn RegMove(
self,
opcode: Opcode,
ctrl_typevar: Type,
src: RegUnit,
dst: RegUnit,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
RegMove(imms=(src: regunit, dst: regunit), vals=1)
sourcefn CopySpecial(
self,
opcode: Opcode,
ctrl_typevar: Type,
src: RegUnit,
dst: RegUnit
) -> (Inst, &'f mut DataFlowGraph)
fn CopySpecial(
self,
opcode: Opcode,
ctrl_typevar: Type,
src: RegUnit,
dst: RegUnit
) -> (Inst, &'f mut DataFlowGraph)
CopySpecial(imms=(src: regunit, dst: regunit), vals=0)
sourcefn RegSpill(
self,
opcode: Opcode,
ctrl_typevar: Type,
src: RegUnit,
dst: StackSlot,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn RegSpill(
self,
opcode: Opcode,
ctrl_typevar: Type,
src: RegUnit,
dst: StackSlot,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
RegSpill(imms=(src: regunit, dst: stack_slot), vals=1)
sourcefn RegFill(
self,
opcode: Opcode,
ctrl_typevar: Type,
src: StackSlot,
dst: RegUnit,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn RegFill(
self,
opcode: Opcode,
ctrl_typevar: Type,
src: StackSlot,
dst: RegUnit,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
RegFill(imms=(src: stack_slot, dst: regunit), vals=1)
sourcefn Trap(
self,
opcode: Opcode,
ctrl_typevar: Type,
code: TrapCode
) -> (Inst, &'f mut DataFlowGraph)
fn Trap(
self,
opcode: Opcode,
ctrl_typevar: Type,
code: TrapCode
) -> (Inst, &'f mut DataFlowGraph)
Trap(imms=(code: trapcode), vals=0)
sourcefn CondTrap(
self,
opcode: Opcode,
ctrl_typevar: Type,
code: TrapCode,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn CondTrap(
self,
opcode: Opcode,
ctrl_typevar: Type,
code: TrapCode,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
CondTrap(imms=(code: trapcode), vals=1)
sourcefn IntCondTrap(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
code: TrapCode,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn IntCondTrap(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: IntCC,
code: TrapCode,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
IntCondTrap(imms=(cond: intcc, code: trapcode), vals=1)
sourcefn FloatCondTrap(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: FloatCC,
code: TrapCode,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
fn FloatCondTrap(
self,
opcode: Opcode,
ctrl_typevar: Type,
cond: FloatCC,
code: TrapCode,
arg0: Value
) -> (Inst, &'f mut DataFlowGraph)
FloatCondTrap(imms=(cond: floatcc, code: trapcode), vals=1)
Implementors§
impl<'f, T: InstBuilderBase<'f>> InstBuilder<'f> for T
Any type implementing InstBuilderBase
gets all the InstBuilder
methods for free.