Struct lightning_sys::jitstate::JitState

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

Methods

impl<'a> JitState<'a>

pub fn clear(&self)

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

pub fn raw_emit(&self) -> JitPointer

impl<'a> JitState<'a>

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 address<'b>(&'b self, node: &JitNode) -> JitPointer

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

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

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.