Struct lightning_sys::jitstate::JitState

pub struct JitState<'a> { /* fields omitted */ }

Methods

impl<'a> JitState<'a>

JitState utility methods

pub fn clear(&self)

pub unsafe fn emit<T: Copy>(&self) -> T

pub fn raw_emit(&self) -> JitPointer

pub fn address<'b>(&'b self, node: &JitNode) -> JitPointer

pub fn forward_p<'b>(&'b self, node: &JitNode) -> bool

pub fn indirect_p<'b>(&'b self, node: &JitNode) -> bool

pub fn target_p<'b>(&'b self, node: &JitNode) -> bool

pub fn patch<'b>(&'b self, instr: &JitNode)

pub fn patch_at<'b>(&'b self, instr: &JitNode, target: &JitNode)

pub fn patch_abs<'b>(&'b self, instr: &JitNode, target: JitPointer)

pub fn realize<'b>(&'b self)

pub fn print<'b>(&'b self)

impl<'a> JitState<'a>

implmentations of general instructions

pub fn live<'b>(&'b self, a: Reg) -> JitNode<'b>

pub fn align<'b>(&'b self, a: Reg) -> JitNode<'b>

pub fn name<'b>(&'b self, name: &str) -> JitNode<'b>

pub fn note<'b>(&'b self, file: &str, line: u32) -> JitNode<'b>

pub fn label<'b>(&'b self) -> JitNode<'b>

pub fn forward<'b>(&'b self) -> JitNode<'b>

pub fn indirect<'b>(&'b self) -> JitNode<'b>

pub fn link<'b>(&'b self, node: &JitNode)

pub fn prolog<'b>(&'b self)

pub fn ellipsis<'b>(&'b self)

pub fn allocai<'b>(&'b self, size: i32) -> i32

pub fn allocar<'b>(&'b self, off: Reg, size: Reg)

pub fn arg<'b>(&'b self) -> JitNode<'b>

pub fn getarg_c<'b>(&'b self, reg: Reg, node: &JitNode)

pub fn getarg_uc<'b>(&'b self, reg: Reg, node: &JitNode)

pub fn getarg_s<'b>(&'b self, reg: Reg, node: &JitNode)

pub fn getarg_us<'b>(&'b self, reg: Reg, node: &JitNode)

pub fn getarg_i<'b>(&'b self, reg: Reg, node: &JitNode)

pub fn getarg_ui<'b>(&'b self, reg: Reg, node: &JitNode)

pub fn getarg_l<'b>(&'b self, reg: Reg, node: &JitNode)

pub fn getarg<'b>(&'b self, reg: Reg, node: &JitNode)

pub fn putargr<'b>(&'b self, reg: Reg, arg: &JitNode)

pub fn putargi<'b>(&'b self, imm: JitWord, arg: &JitNode)

pub fn va_start<'b>(&'b self, a: Reg) -> JitNode<'b>

pub fn va_arg<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn va_arg_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn va_end<'b>(&'b self, a: Reg) -> JitNode<'b>

pub fn addr<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn addi<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn addcr<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn addci<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn addxr<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn addxi<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn subr<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn subi<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn subcr<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn subci<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn subxr<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn subxi<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn rsbi<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn mulr<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn muli<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn qmulr<'b>(&'b self, a: Reg, b: Reg, c: Reg, d: Reg) -> JitNode<'b>

pub fn qmuli<'b>(&'b self, a: Reg, b: Reg, c: Reg, d: JitWord) -> JitNode<'b>

pub fn qmulr_u<'b>(&'b self, a: Reg, b: Reg, c: Reg, d: Reg) -> JitNode<'b>

pub fn qmuli_u<'b>(&'b self, a: Reg, b: Reg, c: Reg, d: JitWord) -> JitNode<'b>

pub fn divr<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn divi<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn divr_u<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn divi_u<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn qdivr<'b>(&'b self, a: Reg, b: Reg, c: Reg, d: Reg) -> JitNode<'b>

pub fn qdivi<'b>(&'b self, a: Reg, b: Reg, c: Reg, d: JitWord) -> JitNode<'b>

pub fn qdivr_u<'b>(&'b self, a: Reg, b: Reg, c: Reg, d: Reg) -> JitNode<'b>

pub fn qdivi_u<'b>(&'b self, a: Reg, b: Reg, c: Reg, d: JitWord) -> JitNode<'b>

pub fn remr<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn remi<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn remr_u<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn remi_u<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn andr<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn andi<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn orr<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn ori<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn xorr<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn xori<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn lshr<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn lshi<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn rshr<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn rshi<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn rshi_u<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn rshr_u<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn negr<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn comr<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn ltr<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn lti<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn ltr_u<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn lti_u<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn ler<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn lei<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn ler_u<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn lei_u<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn eqr<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn eqi<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn ger<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn gei<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn gtr<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn gti<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn gtr_u<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn gti_u<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn ner<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn nei<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn movr<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn movi<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn extr_c<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn extr_uc<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn extr_s<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn extr_us<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn extr_i<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn extr_ui<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn htonr_us<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn ntohr_us<'b>(&'b self, targ: Reg, src: Reg) -> JitNode<'b>

pub fn htonr_ui<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn ntohr_ui<'b>(&'b self, targ: Reg, src: Reg) -> JitNode<'b>

pub fn htonr_ul<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn ntohr_ul<'b>(&'b self, targ: Reg, src: Reg) -> JitNode<'b>

pub fn htonr<'b>(&'b self, targ: Reg, src: Reg) -> JitNode<'b>

pub fn ntohr<'b>(&'b self, targ: Reg, src: Reg) -> JitNode<'b>

pub fn ldr_c<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn ldi_c<'b>(&'b self, a: Reg, b: JitPointer) -> JitNode<'b>

pub fn ldr_uc<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn ldi_uc<'b>(&'b self, a: Reg, b: JitPointer) -> JitNode<'b>

pub fn ldr_s<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn ldi_s<'b>(&'b self, a: Reg, b: JitPointer) -> JitNode<'b>

pub fn ldr_us<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn ldi_us<'b>(&'b self, a: Reg, b: JitPointer) -> JitNode<'b>

pub fn ldr_i<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn ldi_i<'b>(&'b self, a: Reg, b: JitPointer) -> JitNode<'b>

pub fn ldr_ui<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn ldi_ui<'b>(&'b self, a: Reg, b: JitPointer) -> JitNode<'b>

pub fn ldr_l<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn ldi_l<'b>(&'b self, a: Reg, b: JitPointer) -> JitNode<'b>

pub fn ldr<'b>(&'b self, targ: Reg, src: Reg) -> JitNode<'b>

pub fn ldi<'b>(&'b self, targ: Reg, src: JitPointer) -> JitNode<'b>

pub fn ldxr_c<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn ldxi_c<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn ldxr_uc<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn ldxi_uc<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn ldxr_s<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn ldxi_us<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn ldxr_i<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn ldxi_i<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn ldxr_ui<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn ldxi_ui<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn ldxr_l<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn ldxi_l<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn ldxr<'b>(&'b self, targ: Reg, a: Reg, b: Reg) -> JitNode<'b>

pub fn str_c<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn sti_c<'b>(&'b self, a: JitPointer, b: Reg) -> JitNode<'b>

pub fn str_s<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn sti_s<'b>(&'b self, a: JitPointer, b: Reg) -> JitNode<'b>

pub fn str_i<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn sti_i<'b>(&'b self, a: JitPointer, b: Reg) -> JitNode<'b>

pub fn str_l<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn sti_l<'b>(&'b self, a: JitPointer, b: Reg) -> JitNode<'b>

pub fn str<'b>(&'b self, targ: Reg, src: Reg) -> JitNode<'b>

pub fn sti<'b>(&'b self, targ: JitPointer, src: Reg) -> JitNode<'b>

pub fn stxr_c<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn stxi_c<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn stxr_s<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn stxi_s<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn stxr_i<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn stxi_i<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn stxr_l<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn stxi_l<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn stxr<'b>(&'b self, targ: Reg, src: Reg, off: Reg) -> JitNode<'b>

pub fn stxi<'b>(&'b self, targ: Reg, src: Reg, off: JitWord) -> JitNode<'b>

pub fn bltr<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn blti<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn bltr_u<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn blti_u<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn bler<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn blei<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn beqr<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn beqi<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn bger<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bgei<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn bger_u<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bgei_u<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn bgtr<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bgti<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn bgtr_u<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bgti_u<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn bner<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bnei<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn bmsr<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bmsi<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn bmcr<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bmci<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn boaddr<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn boaddi<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn boaddr_u<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn boaddi_u<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn bxaddr<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bxaddi<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn bxaddr_u<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bxaddi_u<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn bosubr<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bosubi<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn bosubr_u<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bosubi_u<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn bxsubr<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bxsubi<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn bxsubr_u<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bxsubi_u<'b>(&'b self, a: Reg, b: JitWord) -> JitNode<'b>

pub fn jmpr<'b>(&'b self, a: Reg) -> JitNode<'b>

pub fn jmpi<'b>(&'b self) -> JitNode<'b>

pub fn callr<'b>(&'b self, a: Reg) -> JitNode<'b>

pub fn calli<'b>(&'b self, a: JitPointer) -> JitNode<'b>

pub fn prepare<'b>(&'b self)

pub fn pushargr<'b>(&'b self, arg: Reg)

pub fn pushargi<'b>(&'b self, arg: JitWord)

pub fn finishr<'b>(&'b self, arg: Reg)

pub fn finishi<'b>(&'b self, arg: JitPointer) -> JitNode<'b>

pub fn ret<'b>(&'b self)

pub fn retr<'b>(&'b self, rv: Reg)

pub fn reti<'b>(&'b self, rv: JitWord)

pub fn retval_c<'b>(&'b self, rv: Reg)

pub fn retval_uc<'b>(&'b self, rv: Reg)

pub fn retval_s<'b>(&'b self, rv: Reg)

pub fn retval_us<'b>(&'b self, rv: Reg)

pub fn retval_i<'b>(&'b self, rv: Reg)

pub fn retval_ui<'b>(&'b self, rv: Reg)

pub fn retval_l<'b>(&'b self, rv: Reg)

pub fn retval<'b>(&'b self, rv: Reg)

pub fn epilog<'b>(&'b self)

pub fn frame<'b>(&'b self, size: i32)

pub fn tramp<'b>(&'b self, fsize: i32)

impl<'a> JitState<'a>

implmentations of 32-bit float instructions

pub fn arg_f<'b>(&'b self) -> JitNode<'b>

pub fn getarg_f<'b>(&'b self, reg: Reg, arg: &JitNode)

pub fn putargr_f<'b>(&'b self, reg: Reg, arg: &JitNode)

pub fn putargi_f<'b>(&'b self, imm: f32, arg: &JitNode)

pub fn addr_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn addi_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn subr_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn subi_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn mulr_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn muli_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn divr_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn divi_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn negr_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn absr_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn sqrtr_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn ltr_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn lti_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn ler_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn lei_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn eqr_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn eqi_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn ger_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn gei_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn gtr_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn gti_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn ner_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn nei_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn unltr_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn unlti_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn unler_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn unlei_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn uneqr_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn uneqi_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn unger_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn ungei_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn ungtr_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn ungti_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn ltgtr_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn ltgti_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn ordr_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn ordi_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn unordr_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn unordi_f<'b>(&'b self, a: Reg, b: Reg, c: f32) -> JitNode<'b>

pub fn truncr_f_i<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn truncr_f_l<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn truncr_f<'b>(&'b self, int: Reg, float: Reg) -> JitNode<'b>

pub fn extr_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn extr_d_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn movr_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn movi_f<'b>(&'b self, a: Reg, b: f32) -> JitNode<'b>

pub fn ldr_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn ldi_f<'b>(&'b self, a: Reg, b: JitPointer) -> JitNode<'b>

pub fn ldxr_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn ldxi_f<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn str_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn sti_f<'b>(&'b self, a: JitPointer, b: Reg) -> JitNode<'b>

pub fn stxr_f<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn stxi_f<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn bltr_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn blti_f<'b>(&'b self, a: Reg, b: f32) -> JitNode<'b>

pub fn bler_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn blei_f<'b>(&'b self, a: Reg, b: f32) -> JitNode<'b>

pub fn beqr_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn beqi_f<'b>(&'b self, a: Reg, b: f32) -> JitNode<'b>

pub fn bger_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bgei_f<'b>(&'b self, a: Reg, b: f32) -> JitNode<'b>

pub fn bgtr_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bgti_f<'b>(&'b self, a: Reg, b: f32) -> JitNode<'b>

pub fn bner_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bnei_f<'b>(&'b self, a: Reg, b: f32) -> JitNode<'b>

pub fn bunltr_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bunlti_f<'b>(&'b self, a: Reg, b: f32) -> JitNode<'b>

pub fn bunler_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bunlei_f<'b>(&'b self, a: Reg, b: f32) -> JitNode<'b>

pub fn buneqr_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn buneqi_f<'b>(&'b self, a: Reg, b: f32) -> JitNode<'b>

pub fn bunger_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bungei_f<'b>(&'b self, a: Reg, b: f32) -> JitNode<'b>

pub fn bungtr_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bungti_f<'b>(&'b self, a: Reg, b: f32) -> JitNode<'b>

pub fn bordr_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bordi_f<'b>(&'b self, a: Reg, b: f32) -> JitNode<'b>

pub fn bunordr_f<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bunordi_f<'b>(&'b self, a: Reg, b: f32) -> JitNode<'b>

pub fn pushargr_f<'b>(&'b self, reg: Reg)

pub fn pushargi_f<'b>(&'b self, imm: f32)

pub fn retr_f<'b>(&'b self, reg: Reg)

pub fn reti_f<'b>(&'b self, imm: f32)

pub fn retval_f<'b>(&'b self, reg: Reg)

impl<'a> JitState<'a>

implmentations of 64-bit float instructions

pub fn arg_d<'b>(&'b self) -> JitNode<'b>

pub fn getarg_d<'b>(&'b self, reg: Reg, arg: &JitNode)

pub fn putargr_d<'b>(&'b self, reg: Reg, arg: &JitNode)

pub fn putargi_d<'b>(&'b self, imm: f64, arg: &JitNode)

pub fn addr_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn addi_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn subr_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn subi_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn mulr_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn muli_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn divr_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn divi_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn negr_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn absr_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn sqrtr_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn ltr_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn lti_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn ler_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn lei_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn eqr_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn eqi_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn ger_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn gei_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn gtr_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn gti_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn ner_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn nei_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn unltr_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn unlti_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn unler_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn unlei_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn uneqr_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn uneqi_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn unger_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn ungei_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn ungtr_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn ungti_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn ltgtr_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn ltgti_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn ordr_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn ordi_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn unordr_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn unordi_d<'b>(&'b self, a: Reg, b: Reg, c: f64) -> JitNode<'b>

pub fn truncr_d_i<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn truncr_d_l<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn truncr_d<'b>(&'b self, int: Reg, float: Reg) -> JitNode<'b>

pub fn extr_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn extr_f_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn movr_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn movi_d<'b>(&'b self, a: Reg, b: f64) -> JitNode<'b>

pub fn ldr_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn ldi_d<'b>(&'b self, a: Reg, b: JitPointer) -> JitNode<'b>

pub fn ldxr_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn ldxi_d<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn str_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn sti_d<'b>(&'b self, a: JitPointer, b: Reg) -> JitNode<'b>

pub fn stxr_d<'b>(&'b self, a: Reg, b: Reg, c: Reg) -> JitNode<'b>

pub fn stxi_d<'b>(&'b self, a: Reg, b: Reg, c: JitWord) -> JitNode<'b>

pub fn bltr_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn blti_d<'b>(&'b self, a: Reg, b: f64) -> JitNode<'b>

pub fn bler_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn blei_d<'b>(&'b self, a: Reg, b: f64) -> JitNode<'b>

pub fn beqr_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn beqi_d<'b>(&'b self, a: Reg, b: f64) -> JitNode<'b>

pub fn bger_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bgei_d<'b>(&'b self, a: Reg, b: f64) -> JitNode<'b>

pub fn bgtr_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bgti_d<'b>(&'b self, a: Reg, b: f64) -> JitNode<'b>

pub fn bner_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bnei_d<'b>(&'b self, a: Reg, b: f64) -> JitNode<'b>

pub fn bunltr_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bunlti_d<'b>(&'b self, a: Reg, b: f64) -> JitNode<'b>

pub fn bunler_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bunlei_d<'b>(&'b self, a: Reg, b: f64) -> JitNode<'b>

pub fn buneqr_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn buneqi_d<'b>(&'b self, a: Reg, b: f64) -> JitNode<'b>

pub fn bunger_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bungei_d<'b>(&'b self, a: Reg, b: f64) -> JitNode<'b>

pub fn bungtr_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bungti_d<'b>(&'b self, a: Reg, b: f64) -> JitNode<'b>

pub fn bordr_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bordi_d<'b>(&'b self, a: Reg, b: f64) -> JitNode<'b>

pub fn bunordr_d<'b>(&'b self, a: Reg, b: Reg) -> JitNode<'b>

pub fn bunordi_d<'b>(&'b self, a: Reg, b: f64) -> JitNode<'b>

pub fn pushargr_d<'b>(&'b self, reg: Reg)

pub fn pushargi_d<'b>(&'b self, imm: f64)

pub fn retr_d<'b>(&'b self, reg: Reg)

pub fn reti_d<'b>(&'b self, imm: f64)

pub fn retval_d<'b>(&'b self, reg: Reg)

Trait Implementations

impl<'a> Drop for JitState<'a>

fn drop(&mut self)

Executes the destructor for this type.

impl<'a> Debug for JitState<'a>

fn fmt(&self, f: &mut Formatter) -> Result

Formats the value using the given formatter.