Struct lightning_sys::jitstate::JitState

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

Implementations

impl<'j> JitState<'j>

pub unsafe fn jit_absr_d(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_absr_f(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_addci(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_addcr(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_addi(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_addi_d(&mut self, u: c_long, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_addi_f(&mut self, u: c_long, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_addr(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_addr_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_addr_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_addxi(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_addxr(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_align(&mut self, u: c_long) -> JitNode<'j>

pub unsafe fn jit_andi(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_andr(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_beqi(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_beqi_d(&mut self, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_beqi_f(&mut self, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_beqr(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_beqr_d(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_beqr_f(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bgei(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bgei_d(&mut self, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_bgei_f(&mut self, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_bgei_u(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bger(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bger_d(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bger_f(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bger_u(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bgti(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bgti_d(&mut self, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_bgti_f(&mut self, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_bgti_u(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bgtr(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bgtr_d(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bgtr_f(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bgtr_u(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_blei(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_blei_d(&mut self, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_blei_f(&mut self, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_blei_u(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bler(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bler_d(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bler_f(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bler_u(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bltgti_d(&mut self, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_bltgti_f(&mut self, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_bltgtr_d(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bltgtr_f(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_blti(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_blti_d(&mut self, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_blti_f(&mut self, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_blti_u(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bltr(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bltr_d(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bltr_f(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bltr_u(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bmci(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bmcr(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bmsi(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bmsr(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bnei(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bnei_d(&mut self, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_bnei_f(&mut self, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_bner(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bner_d(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bner_f(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_boaddi(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_boaddi_u(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_boaddr(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_boaddr_u(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bordi_d(&mut self, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_bordi_f(&mut self, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_bordr_d(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bordr_f(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bosubi(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bosubi_u(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bosubr(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bosubr_u(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_buneqi_d(&mut self, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_buneqi_f(&mut self, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_buneqr_d(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_buneqr_f(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bungei_d(&mut self, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_bungei_f(&mut self, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_bunger_d(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bunger_f(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bungti_d(&mut self, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_bungti_f(&mut self, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_bungtr_d(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bungtr_f(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bunlei_d(&mut self, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_bunlei_f(&mut self, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_bunler_d(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bunler_f(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bunlti_d(&mut self, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_bunlti_f(&mut self, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_bunltr_d(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bunltr_f(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bunordi_d(&mut self, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_bunordi_f(&mut self, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_bunordr_d(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bunordr_f(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bxaddi(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bxaddi_u(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bxaddr(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bxaddr_u(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bxsubi(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bxsubi_u(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bxsubr(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_bxsubr_u(&mut self, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_calli(&mut self, u: *mut c_void) -> JitNode<'j>

pub unsafe fn jit_callr(&mut self, u: c_long) -> JitNode<'j>

pub unsafe fn jit_comr(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_divi(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_divi_d(&mut self, u: c_long, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_divi_f(&mut self, u: c_long, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_divi_u(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_divr(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_divr_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_divr_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_divr_u(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_eqi(&mut self, u: c_long, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_eqi_d(&mut self, u: c_long, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_eqi_f(&mut self, u: c_long, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_eqr(&mut self, u: c_long, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_eqr_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_eqr_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_extr_c(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_extr_d(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_extr_d_f(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_extr_f(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_extr_f_d(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_extr_i(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_extr_s(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_extr_uc(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_extr_ui(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_extr_us(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_gei(&mut self, u: c_long, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_gei_d(&mut self, u: c_long, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_gei_f(&mut self, u: c_long, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_gei_u(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ger(&mut self, u: c_long, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_ger_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ger_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ger_u(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_gti(&mut self, u: c_long, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_gti_d(&mut self, u: c_long, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_gti_f(&mut self, u: c_long, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_gti_u(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_gtr(&mut self, u: c_long, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_gtr_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_gtr_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_gtr_u(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_htonr(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_htonr_ui(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_htonr_ul(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_htonr_us(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_jmpi(&mut self) -> JitNode<'j>

pub unsafe fn jit_jmpr(&mut self, u: c_long) -> JitNode<'j>

pub unsafe fn jit_ldi_c(&mut self, u: c_long, v: *mut c_void) -> JitNode<'j>

pub unsafe fn jit_ldi_d(&mut self, u: c_long, v: *mut c_void) -> JitNode<'j>

pub unsafe fn jit_ldi_f(&mut self, u: c_long, v: *mut c_void) -> JitNode<'j>

pub unsafe fn jit_ldi_i(&mut self, u: c_long, v: *mut c_void) -> JitNode<'j>

pub unsafe fn jit_ldi_l(&mut self, u: c_long, v: *mut c_void) -> JitNode<'j>

pub unsafe fn jit_ldi_s(&mut self, u: c_long, v: *mut c_void) -> JitNode<'j>

pub unsafe fn jit_ldi_uc(&mut self, u: c_long, v: *mut c_void) -> JitNode<'j>

pub unsafe fn jit_ldi_ui(&mut self, u: c_long, v: *mut c_void) -> JitNode<'j>

pub unsafe fn jit_ldi_us(&mut self, u: c_long, v: *mut c_void) -> JitNode<'j>

pub unsafe fn jit_ldr_c(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_ldr_d(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_ldr_f(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_ldr_i(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_ldr_l(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_ldr_s(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_ldr_uc(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_ldr_ui(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_ldr_us(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_ldxi_c(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ldxi_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ldxi_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ldxi_i(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ldxi_l(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ldxi_s(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ldxi_uc(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ldxi_ui(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ldxi_us(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ldxr_c(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ldxr_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ldxr_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ldxr_i(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ldxr_l(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ldxr_s(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ldxr_uc(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ldxr_ui(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ldxr_us(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_lei(&mut self, u: c_long, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_lei_d(&mut self, u: c_long, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_lei_f(&mut self, u: c_long, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_lei_u(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ler(&mut self, u: c_long, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_ler_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ler_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ler_u(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_live(&mut self, u: c_long) -> JitNode<'j>

pub unsafe fn jit_lshi(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_lshr(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ltgti_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: f64
) -> JitNode<'j>

pub unsafe fn jit_ltgti_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: f32
) -> JitNode<'j>

pub unsafe fn jit_ltgtr_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ltgtr_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_lti(&mut self, u: c_long, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_lti_d(&mut self, u: c_long, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_lti_f(&mut self, u: c_long, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_lti_u(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ltr(&mut self, u: c_long, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_ltr_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ltr_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ltr_u(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_movi(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_movi_d(&mut self, u: c_long, v: f64) -> JitNode<'j>

pub unsafe fn jit_movi_d_w(&mut self, u: c_long, v: f64) -> JitNode<'j>

pub unsafe fn jit_movi_d_ww(
    &mut self,
    u: c_long,
    v: c_long,
    w: f64
) -> JitNode<'j>

pub unsafe fn jit_movi_f(&mut self, u: c_long, v: f32) -> JitNode<'j>

pub unsafe fn jit_movi_f_w(&mut self, u: c_long, v: f32) -> JitNode<'j>

pub unsafe fn jit_movr(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_movr_d(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_movr_d_w(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_movr_d_ww(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_movr_f(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_movr_f_w(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_movr_w_d(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_movr_w_f(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_movr_ww_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_muli(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_muli_d(&mut self, u: c_long, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_muli_f(&mut self, u: c_long, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_mulr(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_mulr_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_mulr_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_negr(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_negr_d(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_negr_f(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_nei(&mut self, u: c_long, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_nei_d(&mut self, u: c_long, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_nei_f(&mut self, u: c_long, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_ner(&mut self, u: c_long, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_ner_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ner_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_new_node(&mut self, c: jit_code_t) -> JitNode<'j>

pub unsafe fn jit_new_node_d(&mut self, c: jit_code_t, u: f64) -> JitNode<'j>

pub unsafe fn jit_new_node_dp(
    &mut self,
    c: jit_code_t,
    u: f64,
    v: *mut c_void
) -> JitNode<'j>

pub unsafe fn jit_new_node_f(&mut self, c: jit_code_t, u: f32) -> JitNode<'j>

pub unsafe fn jit_new_node_fp(
    &mut self,
    c: jit_code_t,
    u: f32,
    v: *mut c_void
) -> JitNode<'j>

pub unsafe fn jit_new_node_p(
    &mut self,
    c: jit_code_t,
    u: *mut c_void
) -> JitNode<'j>

pub unsafe fn jit_new_node_pw(
    &mut self,
    c: jit_code_t,
    u: *mut c_void,
    v: c_long
) -> JitNode<'j>

pub unsafe fn jit_new_node_pwd(
    &mut self,
    c: jit_code_t,
    u: *mut c_void,
    v: c_long,
    w: f64
) -> JitNode<'j>

pub unsafe fn jit_new_node_pwf(
    &mut self,
    c: jit_code_t,
    u: *mut c_void,
    v: c_long,
    w: f32
) -> JitNode<'j>

pub unsafe fn jit_new_node_pww(
    &mut self,
    c: jit_code_t,
    u: *mut c_void,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_new_node_qww(
    &mut self,
    c: jit_code_t,
    l: c_int,
    h: c_int,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_new_node_w(&mut self, c: jit_code_t, u: c_long) -> JitNode<'j>

pub unsafe fn jit_new_node_wd(
    &mut self,
    c: jit_code_t,
    u: c_long,
    v: f64
) -> JitNode<'j>

pub unsafe fn jit_new_node_wf(
    &mut self,
    c: jit_code_t,
    u: c_long,
    v: f32
) -> JitNode<'j>

pub unsafe fn jit_new_node_wp(
    &mut self,
    c: jit_code_t,
    u: c_long,
    v: *mut c_void
) -> JitNode<'j>

pub unsafe fn jit_new_node_ww(
    &mut self,
    c: jit_code_t,
    u: c_long,
    v: c_long
) -> JitNode<'j>

pub unsafe fn jit_new_node_wwd(
    &mut self,
    c: jit_code_t,
    u: c_long,
    v: c_long,
    w: f64
) -> JitNode<'j>

pub unsafe fn jit_new_node_wwf(
    &mut self,
    c: jit_code_t,
    u: c_long,
    v: c_long,
    w: f32
) -> JitNode<'j>

pub unsafe fn jit_new_node_www(
    &mut self,
    c: jit_code_t,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ntohr(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_ntohr_ui(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_ntohr_ul(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_ntohr_us(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_ordi_d(&mut self, u: c_long, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_ordi_f(&mut self, u: c_long, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_ordr_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ordr_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ori(&mut self, u: c_long, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_orr(&mut self, u: c_long, v: c_long, w: c_long) -> JitNode<'j>

pub unsafe fn jit_qdivi(
    &mut self,
    l: c_int,
    h: c_int,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_qdivi_u(
    &mut self,
    l: c_int,
    h: c_int,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_qdivr(
    &mut self,
    l: c_int,
    h: c_int,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_qdivr_u(
    &mut self,
    l: c_int,
    h: c_int,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_qmuli(
    &mut self,
    l: c_int,
    h: c_int,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_qmuli_u(
    &mut self,
    l: c_int,
    h: c_int,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_qmulr(
    &mut self,
    l: c_int,
    h: c_int,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_qmulr_u(
    &mut self,
    l: c_int,
    h: c_int,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_remi(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_remi_u(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_remr(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_remr_u(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_rsbi(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_rsbi_d(&mut self, u: c_long, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_rsbi_f(&mut self, u: c_long, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_rshi(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_rshi_u(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_rshr(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_rshr_u(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_sqrtr_d(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_sqrtr_f(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_sti_c(&mut self, u: *mut c_void, v: c_long) -> JitNode<'j>

pub unsafe fn jit_sti_d(&mut self, u: *mut c_void, v: c_long) -> JitNode<'j>

pub unsafe fn jit_sti_f(&mut self, u: *mut c_void, v: c_long) -> JitNode<'j>

pub unsafe fn jit_sti_i(&mut self, u: *mut c_void, v: c_long) -> JitNode<'j>

pub unsafe fn jit_sti_l(&mut self, u: *mut c_void, v: c_long) -> JitNode<'j>

pub unsafe fn jit_sti_s(&mut self, u: *mut c_void, v: c_long) -> JitNode<'j>

pub unsafe fn jit_str_c(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_str_d(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_str_f(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_str_i(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_str_l(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_str_s(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_stxi_c(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_stxi_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_stxi_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_stxi_i(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_stxi_l(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_stxi_s(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_stxr_c(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_stxr_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_stxr_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_stxr_i(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_stxr_l(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_stxr_s(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_subci(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_subcr(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_subi(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_subi_d(&mut self, u: c_long, v: c_long, w: f64) -> JitNode<'j>

pub unsafe fn jit_subi_f(&mut self, u: c_long, v: c_long, w: f32) -> JitNode<'j>

pub unsafe fn jit_subr(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_subr_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_subr_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_subxi(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_subxr(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_truncr_d_i(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_truncr_d_l(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_truncr_f_i(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_truncr_f_l(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_uneqi_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: f64
) -> JitNode<'j>

pub unsafe fn jit_uneqi_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: f32
) -> JitNode<'j>

pub unsafe fn jit_uneqr_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_uneqr_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ungei_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: f64
) -> JitNode<'j>

pub unsafe fn jit_ungei_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: f32
) -> JitNode<'j>

pub unsafe fn jit_unger_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_unger_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ungti_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: f64
) -> JitNode<'j>

pub unsafe fn jit_ungti_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: f32
) -> JitNode<'j>

pub unsafe fn jit_ungtr_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_ungtr_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_unlei_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: f64
) -> JitNode<'j>

pub unsafe fn jit_unlei_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: f32
) -> JitNode<'j>

pub unsafe fn jit_unler_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_unler_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_unlti_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: f64
) -> JitNode<'j>

pub unsafe fn jit_unlti_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: f32
) -> JitNode<'j>

pub unsafe fn jit_unltr_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_unltr_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_unordi_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: f64
) -> JitNode<'j>

pub unsafe fn jit_unordi_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: f32
) -> JitNode<'j>

pub unsafe fn jit_unordr_d(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_unordr_f(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_va_arg(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_va_arg_d(&mut self, u: c_long, v: c_long) -> JitNode<'j>

pub unsafe fn jit_va_end(&mut self, u: c_long) -> JitNode<'j>

pub unsafe fn jit_va_start(&mut self, u: c_long) -> JitNode<'j>

pub unsafe fn jit_xori(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

pub unsafe fn jit_xorr(
    &mut self,
    u: c_long,
    v: c_long,
    w: c_long
) -> JitNode<'j>

impl<'a> JitState<'a>

JitState utility methods

pub fn clear(&mut self)

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

pub fn raw_emit(&mut self) -> JitPointer

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

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

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

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

pub fn arg_register_p(&mut self, node: &JitNode<'_>) -> bool

pub fn callee_save_p(&mut self, reg: Reg) -> bool

pub fn pointer_p(&mut self, ptr: JitPointer) -> bool

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

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

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

pub fn realize(&mut self)

pub fn get_code(&self, code_size: Option<&mut JitWord>) -> JitPointer

pub fn set_code(&mut self, buf: JitPointer, size: JitWord)

pub fn get_data(
    &self,
    data_size: Option<&mut JitWord>,
    note_size: Option<&mut JitWord>
) -> JitPointer

pub fn set_data(&mut self, buf: JitPointer, data_size: JitWord, flags: JitWord)

pub fn print(&mut self)

impl<'a> JitState<'a>

implmentations of general instructions

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

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

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

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

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

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

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

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

pub fn prolog(&mut self)

pub fn ellipsis(&mut self)

pub fn allocai(&mut self, size: i32) -> i32

pub fn allocar(&mut self, off: Reg, size: Reg)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn va_push(&mut self, arg: Reg)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn ldxi(&mut self, targ: Reg, src: Reg, off: JitWord) -> JitNode<'a>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn prepare(&mut self)

pub fn pushargr(&mut self, arg: Reg)

pub fn pushargi(&mut self, arg: JitWord)

pub fn finishr(&mut self, arg: Reg)

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

pub fn ret(&mut self)

pub fn retr(&mut self, rv: Reg)

pub fn reti(&mut self, rv: JitWord)

pub fn retval_c(&mut self, rv: Reg)

pub fn retval_uc(&mut self, rv: Reg)

pub fn retval_s(&mut self, rv: Reg)

pub fn retval_us(&mut self, rv: Reg)

pub fn retval_i(&mut self, rv: Reg)

pub fn get_note(
    &self,
    code: JitPointer,
    name: Option<&mut *mut c_char>,
    file: Option<&mut *mut c_char>,
    lineno: Option<&mut c_int>
) -> bool

pub fn retval_ui(&mut self, rv: Reg)

pub fn retval_l(&mut self, rv: Reg)

pub fn retval(&mut self, rv: Reg)

pub fn epilog(&mut self)

pub fn frame(&mut self, size: i32)

pub fn tramp(&mut self, fsize: i32)

impl<'a> JitState<'a>

implmentations of 32-bit float instructions

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn pushargr_f(&mut self, reg: Reg)

pub fn pushargi_f(&mut self, imm: f32)

pub fn retr_f(&mut self, reg: Reg)

pub fn reti_f(&mut self, imm: f32)

pub fn retval_f(&mut self, reg: Reg)

impl<'a> JitState<'a>

implmentations of 64-bit float instructions

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pub fn pushargr_d(&mut self, reg: Reg)

pub fn pushargi_d(&mut self, imm: f64)

pub fn retr_d(&mut self, reg: Reg)

pub fn reti_d(&mut self, imm: f64)

pub fn retval_d(&mut self, reg: Reg)

Trait Implementations

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

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

Formats the value using the given formatter.

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

fn drop(&mut self)

Executes the destructor for this type.