Trait cranelift_codegen::ir::InstBuilder

pub trait InstBuilder<'f>: InstBuilderBase<'f> {
    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<T1boolean: Into<bool>>(self, Bool: Type, N: T1boolean) -> 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 copy_nop(self, x: Value) -> Value { ... }
    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) { ... }
}

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

fn jump(self, EBB: Ebb, args: &[Value]) -> Inst

jump EBB, args

Jump.

fn fallthrough(self, EBB: Ebb, args: &[Value]) -> Inst

fallthrough EBB, args

Fall through to the next EBB.

fn brz(self, c: Value, EBB: Ebb, args: &[Value]) -> Inst

brz c, EBB, args

Branch when zero.

fn brnz(self, c: Value, EBB: Ebb, args: &[Value]) -> Inst

brnz c, EBB, args

Branch when non-zero.

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.

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.

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.

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

br_table x, EBB, JT

Indirect branch via jump table.

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.

fn jump_table_base(self, iAddr: Type, JT: JumpTable) -> Value

addr = jump_table_base JT

Get the absolute base address of a jump table.

fn indirect_jump_table_br(self, addr: Value, JT: JumpTable) -> Inst

indirect_jump_table_br addr, JT

Branch indirectly via a jump table entry.

fn debugtrap(self) -> Inst

debugtrap

Encodes an assembly debug trap.

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

trap code

Terminate execution unconditionally.

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

trapz c, code

Trap when zero.

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

trapnz c, code

Trap when non-zero.

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.

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.

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

return rvals

Return from the function.

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

fallthrough_return rvals

Return from the function by fallthrough.

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

rvals = call FN, args

Direct function call.

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

rvals = call_indirect SIG, callee, args

Indirect function call.

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

addr = func_addr FN

Get the address of a function.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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

a = global_value GV

Compute the value of global GV.

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

a = symbol_value GV

Compute the value of global GV, which is a symbolic 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.

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.

fn iconst<T1imm64: Into<Imm64>>(self, Int: Type, N: T1imm64) -> Value

a = iconst N

Integer constant.

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

a = f32const N

Floating point constant.

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

a = f64const N

Floating point constant.

fn bconst<T1boolean: Into<bool>>(self, Bool: Type, N: T1boolean) -> Value

a = bconst N

Boolean constant.

fn nop(self) -> Inst

nop

Just a dummy instruction

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

a = select c, x, y

Conditional select.

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.

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

a = copy x

Register-register copy.

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

a = spill x

Spill a register value to a stack slot.

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

a = fill x

Load a register value from a stack slot.

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.

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.

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

a = copy_nop x

Stack-slot-to-the-same-stack-slot copy, which is guaranteed to turn

fn adjust_sp_down(self, delta: Value) -> Inst

adjust_sp_down delta

Subtracts delta offset value from the stack pointer register.

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.

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

fn ifcmp_sp(self, addr: Value) -> Value

f = ifcmp_sp addr

Compare addr with the stack pointer and set the CPU flags.

fn regspill<T1regunit: Into<RegUnit>>(
    self,
    x: Value,
    src: T1regunit,
    SS: StackSlot
) -> Inst

regspill x, src, SS

Temporarily divert x from src to SS.

fn regfill<T1regunit: Into<RegUnit>>(
    self,
    x: Value,
    SS: StackSlot,
    dst: T1regunit
) -> Inst

regfill x, SS, dst

Temporarily divert x from SS to dst.

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

lo, hi = vsplit x

Split a vector into two halves.

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

a = vconcat x, y

Vector concatenation.

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

a = vselect c, x, y

Vector lane select.

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

a = splat x

Vector splat.

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.

fn extractlane<T1uimm8: Into<Uimm8>>(self, x: Value, Idx: T1uimm8) -> Value

a = extractlane x, Idx

Extract lane Idx from x.

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

a = icmp Cond, x, y

Integer comparison.

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.

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

f = ifcmp x, y

Compare scalar integers and return flags.

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.

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

a = iadd x, y

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

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

a = isub x, y

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

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

a = imul x, y

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

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

a = umulhi x, y

Unsigned integer multiplication, producing the high half of a

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

a = smulhi x, y

Signed integer multiplication, producing the high half of a

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

a = udiv x, y

Unsigned integer division: :math:a := \lfloor {x \over y} \rfloor.

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

a = sdiv x, y

Signed integer division rounded toward zero: :math:`a := sign(xy)

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

a = urem x, y

Unsigned integer remainder.

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

a = srem x, y

Signed integer remainder. The result has the sign of the dividend.

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

a = iadd_imm x, Y

Add immediate integer.

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

a = imul_imm x, Y

Integer multiplication by immediate constant.

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

a = udiv_imm x, Y

Unsigned integer division by an immediate constant.

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

a = sdiv_imm x, Y

Signed integer division by an immediate constant.

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

a = urem_imm x, Y

Unsigned integer remainder with immediate divisor.

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

a = srem_imm x, Y

Signed integer remainder with immediate divisor.

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}.

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

a = iadd_cin x, y, c_in

Add integers with carry in.

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

a, c_out = iadd_cout x, y

Add integers with carry out.

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.

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

a = isub_bin x, y, b_in

Subtract integers with borrow in.

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

a, b_out = isub_bout x, y

Subtract integers with borrow out.

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.

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

a = band x, y

Bitwise and.

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

a = bor x, y

Bitwise or.

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

a = bxor x, y

Bitwise xor.

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

a = bnot x

Bitwise not.

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

a = band_not x, y

Bitwise and not.

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

a = bor_not x, y

Bitwise or not.

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

a = bxor_not x, y

Bitwise xor not.

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

a = band_imm x, Y

Bitwise and with immediate.

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

a = bor_imm x, Y

Bitwise or with immediate.

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

a = bxor_imm x, Y

Bitwise xor with immediate.

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

a = rotl x, y

Rotate left.

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

a = rotr x, y

Rotate right.

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

a = rotl_imm x, Y

Rotate left by immediate.

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

a = rotr_imm x, Y

Rotate right by immediate.

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

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

a = ushr x, y

Unsigned shift right. Shift bits in x towards the LSB by y

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

a = sshr x, y

Signed shift right. Shift bits in x towards the LSB by y

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

a = ishl_imm x, Y

Integer shift left by immediate.

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

a = ushr_imm x, Y

Unsigned shift right by immediate.

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

a = sshr_imm x, Y

Signed shift right by immediate.

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

a = bitrev x

Reverse the bits of a integer.

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

a = clz x

Count leading zero bits.

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

a = cls x

Count leading sign bits.

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

a = ctz x

Count trailing zeros.

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

a = popcnt x

Population count

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

a = fcmp Cond, x, y

Floating point comparison.

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

f = ffcmp x, y

Floating point comparison returning flags.

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

a = fadd x, y

Floating point addition.

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

a = fsub x, y

Floating point subtraction.

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

a = fmul x, y

Floating point multiplication.

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

a = fdiv x, y

Floating point division.

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

a = sqrt x

Floating point square root.

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

a = fma x, y, z

Floating point fused multiply-and-add.

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

a = fneg x

Floating point negation.

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

a = fabs x

Floating point absolute value.

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

a = fcopysign x, y

Floating point copy sign.

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

a = fmin x, y

Floating point minimum, propagating NaNs.

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

a = fmax x, y

Floating point maximum, propagating NaNs.

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

a = ceil x

Round floating point round to integral, towards positive infinity.

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

a = floor x

Round floating point round to integral, towards negative infinity.

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

a = trunc x

Round floating point round to integral, towards zero.

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

a = nearest x

Round floating point round to integral, towards nearest with ties to

fn trueif<T1intcc: Into<IntCC>>(self, Cond: T1intcc, f: Value) -> Value

a = trueif Cond, f

Test integer CPU flags for a specific condition.

fn trueff<T1floatcc: Into<FloatCC>>(self, Cond: T1floatcc, f: Value) -> Value

a = trueff Cond, f

Test floating point CPU flags for a specific condition.

fn bitcast(self, MemTo: Type, x: Value) -> Value

a = bitcast x

Reinterpret the bits in x as a different type.

fn breduce(self, BoolTo: Type, x: Value) -> Value

a = breduce x

Convert x to a smaller boolean type in the platform-defined way.

fn bextend(self, BoolTo: Type, x: Value) -> Value

a = bextend x

Convert x to a larger boolean type in the platform-defined way.

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

a = bint x

Convert x to an integer.

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

a = bmask x

Convert x to an integer mask.

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

a = ireduce x

Convert x to a smaller integer type by dropping high bits.

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

a = uextend x

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

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

a = sextend x

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

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

a = fpromote x

Convert x to a larger floating point format.

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

a = fdemote x

Convert x to a smaller floating point format.

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

a = fcvt_to_uint x

Convert floating point to unsigned integer.

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

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

a = fcvt_to_sint x

Convert floating point to signed integer.

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

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

a = fcvt_from_uint x

Convert unsigned integer to floating point.

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

a = fcvt_from_sint x

Convert signed integer to floating point.

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

lo, hi = isplit x

Split an integer into low and high parts.

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

a = iconcat lo, hi

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

fn x86_udivmodx(self, nlo: Value, nhi: Value, d: Value) -> (Value, Value)

q, r = x86_udivmodx nlo, nhi, d

Extended unsigned division.

fn x86_sdivmodx(self, nlo: Value, nhi: Value, d: Value) -> (Value, Value)

q, r = x86_sdivmodx nlo, nhi, d

Extended signed division.

fn x86_umulx(self, argL: Value, argR: Value) -> (Value, Value)

resLo, resHi = x86_umulx argL, argR

Unsigned integer multiplication, producing a double-length result.

fn x86_smulx(self, argL: Value, argR: Value) -> (Value, Value)

resLo, resHi = x86_smulx argL, argR

Signed integer multiplication, producing a double-length result.

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

a = x86_cvtt2si x

Convert with truncation floating point to signed integer.

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

a = x86_fmin x, y

Floating point minimum with x86 semantics.

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

a = x86_fmax x, y

Floating point maximum with x86 semantics.

fn x86_push(self, x: Value) -> Inst

x86_push x

Pushes a value onto the stack.

fn x86_pop(self, iWord: Type) -> Value

x = x86_pop

Pops a value from the stack.

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

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

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

Unary(imms=(), vals=1)

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

UnaryImm(imms=(imm: imm64), vals=0)

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

UnaryIeee32(imms=(imm: ieee32), vals=0)

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

UnaryIeee64(imms=(imm: ieee64), vals=0)

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

UnaryBool(imms=(imm: boolean), vals=0)

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

UnaryGlobalValue(imms=(global_value: global_value), vals=0)

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

Binary(imms=(), vals=2)

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

BinaryImm(imms=(imm: imm64), vals=1)

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

Ternary(imms=(), vals=3)

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

MultiAry(imms=(), vals=0)

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

NullAry(imms=(), vals=0)

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

InsertLane(imms=(lane: uimm8), vals=2)

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

ExtractLane(imms=(lane: uimm8), vals=1)

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

IntCompare(imms=(cond: intcc), vals=2)

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)

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

IntCond(imms=(cond: intcc), vals=1)

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

FloatCompare(imms=(cond: floatcc), vals=2)

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

FloatCond(imms=(cond: floatcc), vals=1)

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)

fn Jump(
    self,
    opcode: Opcode,
    ctrl_typevar: Type,
    destination: Ebb,
    args: ValueList
) -> (Inst, &'f mut DataFlowGraph)

Jump(imms=(destination: ebb), vals=0)

fn Branch(
    self,
    opcode: Opcode,
    ctrl_typevar: Type,
    destination: Ebb,
    args: ValueList
) -> (Inst, &'f mut DataFlowGraph)

Branch(imms=(destination: ebb), vals=1)

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)

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)

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)

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)

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)

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

BranchTableBase(imms=(table: jump_table), vals=0)

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

IndirectJump(imms=(table: jump_table), vals=1)

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)

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)

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

FuncAddr(imms=(func_ref: func_ref), vals=0)

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)

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)

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)

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)

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)

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)

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)

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)

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)

fn CopySpecial(
    self,
    opcode: Opcode,
    ctrl_typevar: Type,
    src: RegUnit,
    dst: RegUnit
) -> (Inst, &'f mut DataFlowGraph)

CopySpecial(imms=(src: regunit, dst: regunit), vals=0)

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)

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)

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

Trap(imms=(code: trapcode), vals=0)

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

CondTrap(imms=(code: trapcode), vals=1)

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)

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)

Loading content...

Implementors

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

Any type implementing InstBuilderBase gets all the InstBuilder methods for free.

Loading content...