Struct wasmer_compiler_singlepass::machine_arm64::MachineARM64

pub struct MachineARM64 {
    assembler: VecAssembler<Aarch64Relocation>,
    used_gprs: u32,
    used_simd: u32,
    trap_table: TrapTable,
    instructions_address_map: Vec<InstructionAddressMap>,
    src_loc: u32,
    pushed: bool,
    unwind_ops: Vec<(usize, UnwindOps)>,
    has_neon: bool,
}

Fields

assembler: VecAssembler<Aarch64Relocation>

used_gprs: u32

used_simd: u32

trap_table: TrapTable

instructions_address_map: Vec<InstructionAddressMap>

Map from byte offset into wasm function to range of native instructions.

src_loc: u32

The source location for the current operator.

pushed: bool

is last push on a 8byte multiple or 16bytes?

unwind_ops: Vec<(usize, UnwindOps)>

Vector of unwind operations with offset

has_neon: bool

A boolean flag signaling if this machine supports NEON.

Implementations

impl MachineARM64

pub fn new(target: Option<Target>) -> Self

fn compatible_imm(&self, imm: i64, ty: ImmType) -> bool

fn location_to_reg( &mut self, sz: Size, src: Location<GPR, NEON>, temps: &mut Vec<GPR>, allow_imm: ImmType, read_val: bool, wanted: Option<GPR>, ) -> Result<Location<GPR, NEON>, CompileError>

fn location_to_neon( &mut self, sz: Size, src: Location<GPR, NEON>, temps: &mut Vec<NEON>, allow_imm: ImmType, read_val: bool, ) -> Result<Location<GPR, NEON>, CompileError>

fn emit_relaxed_binop( &mut self, op: fn(_: &mut VecAssembler<Aarch64Relocation>, _: Size, _: Location<GPR, NEON>, _: Location<GPR, NEON>) -> Result<(), CompileError>, sz: Size, src: Location<GPR, NEON>, dst: Location<GPR, NEON>, putback: bool, ) -> Result<(), CompileError>

fn emit_relaxed_binop_neon( &mut self, op: fn(_: &mut VecAssembler<Aarch64Relocation>, _: Size, _: Location<GPR, NEON>, _: Location<GPR, NEON>) -> Result<(), CompileError>, sz: Size, src: Location<GPR, NEON>, dst: Location<GPR, NEON>, putback: bool, ) -> Result<(), CompileError>

fn emit_relaxed_binop3( &mut self, op: fn(_: &mut VecAssembler<Aarch64Relocation>, _: Size, _: Location<GPR, NEON>, _: Location<GPR, NEON>, _: Location<GPR, NEON>) -> Result<(), CompileError>, sz: Size, src1: Location<GPR, NEON>, src2: Location<GPR, NEON>, dst: Location<GPR, NEON>, allow_imm: ImmType, ) -> Result<(), CompileError>

fn emit_relaxed_binop3_neon( &mut self, op: fn(_: &mut VecAssembler<Aarch64Relocation>, _: Size, _: Location<GPR, NEON>, _: Location<GPR, NEON>, _: Location<GPR, NEON>) -> Result<(), CompileError>, sz: Size, src1: Location<GPR, NEON>, src2: Location<GPR, NEON>, dst: Location<GPR, NEON>, allow_imm: ImmType, ) -> Result<(), CompileError>

fn emit_relaxed_ldr64( &mut self, sz: Size, dst: Location<GPR, NEON>, src: Location<GPR, NEON>, ) -> Result<(), CompileError>

fn emit_relaxed_ldr32( &mut self, sz: Size, dst: Location<GPR, NEON>, src: Location<GPR, NEON>, ) -> Result<(), CompileError>

fn emit_relaxed_ldr32s( &mut self, sz: Size, dst: Location<GPR, NEON>, src: Location<GPR, NEON>, ) -> Result<(), CompileError>

fn emit_relaxed_ldr16( &mut self, sz: Size, dst: Location<GPR, NEON>, src: Location<GPR, NEON>, ) -> Result<(), CompileError>

fn emit_relaxed_ldr16s( &mut self, sz: Size, dst: Location<GPR, NEON>, src: Location<GPR, NEON>, ) -> Result<(), CompileError>

fn emit_relaxed_ldr8( &mut self, sz: Size, dst: Location<GPR, NEON>, src: Location<GPR, NEON>, ) -> Result<(), CompileError>

fn emit_relaxed_ldr8s( &mut self, sz: Size, dst: Location<GPR, NEON>, src: Location<GPR, NEON>, ) -> Result<(), CompileError>

fn emit_relaxed_str64( &mut self, dst: Location<GPR, NEON>, src: Location<GPR, NEON>, ) -> Result<(), CompileError>

fn emit_relaxed_str32( &mut self, dst: Location<GPR, NEON>, src: Location<GPR, NEON>, ) -> Result<(), CompileError>

fn emit_relaxed_str16( &mut self, dst: Location<GPR, NEON>, src: Location<GPR, NEON>, ) -> Result<(), CompileError>

fn emit_relaxed_str8( &mut self, dst: Location<GPR, NEON>, src: Location<GPR, NEON>, ) -> Result<(), CompileError>

fn emit_cmpop_i64_dynamic_b( &mut self, c: Condition, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

I64 comparison with.

fn emit_cmpop_i32_dynamic_b( &mut self, c: Condition, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

I32 comparison with.

fn memory_op<F: FnOnce(&mut Self, GPR) -> Result<(), CompileError>>( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, check_alignment: bool, value_size: usize, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, cb: F, ) -> Result<(), CompileError>

fn offset_is_ok(&self, size: Size, offset: i32) -> bool

fn emit_push( &mut self, sz: Size, src: Location<GPR, NEON>, ) -> Result<(), CompileError>

fn emit_double_push( &mut self, sz: Size, src1: Location<GPR, NEON>, src2: Location<GPR, NEON>, ) -> Result<(), CompileError>

fn emit_pop( &mut self, sz: Size, dst: Location<GPR, NEON>, ) -> Result<(), CompileError>

fn emit_double_pop( &mut self, sz: Size, dst1: Location<GPR, NEON>, dst2: Location<GPR, NEON>, ) -> Result<(), CompileError>

fn set_default_nan(&mut self, temps: &mut Vec<GPR>) -> Result<GPR, CompileError>

fn set_trap_enabled( &mut self, temps: &mut Vec<GPR>, ) -> Result<GPR, CompileError>

fn restore_fpcr(&mut self, old_fpcr: GPR) -> Result<(), CompileError>

fn reset_exception_fpsr(&mut self) -> Result<(), CompileError>

fn read_fpsr(&mut self) -> Result<GPR, CompileError>

fn trap_float_convertion_errors( &mut self, old_fpcr: GPR, sz: Size, f: Location<GPR, NEON>, temps: &mut Vec<GPR>, ) -> Result<(), CompileError>

fn used_gprs_contains(&self, r: &GPR) -> bool

fn used_simd_contains(&self, r: &NEON) -> bool

fn used_gprs_insert(&mut self, r: GPR)

fn used_simd_insert(&mut self, r: NEON)

fn used_gprs_remove(&mut self, r: &GPR) -> bool

fn used_simd_remove(&mut self, r: &NEON) -> bool

fn emit_unwind_op(&mut self, op: UnwindOps)

fn emit_illegal_op_internal( &mut self, trap: TrapCode, ) -> Result<(), CompileError>

Trait Implementations

impl Machine for MachineARM64

fn set_srcloc(&mut self, offset: u32)

Set the source location of the Wasm to the given offset.

fn mark_address_range_with_trap_code( &mut self, code: TrapCode, begin: usize, end: usize, )

Marks each address in the code range emitted by f with the trap code code.

fn mark_address_with_trap_code(&mut self, code: TrapCode)

Marks one address as trappable with trap code code.

fn mark_instruction_with_trap_code(&mut self, code: TrapCode) -> usize

Marks the instruction as trappable with trap code code. return “begin” offset

fn mark_instruction_address_end(&mut self, begin: usize)

Pushes the instruction to the address map, calculating the offset from a provided beginning address.

fn insert_stackoverflow(&mut self)

Insert a StackOverflow (at offset 0)

fn collect_trap_information(&self) -> Vec<TrapInformation>

Get all current TrapInformation

type GPR = GPR

type SIMD = NEON

fn assembler_get_offset(&self) -> AssemblyOffset

Get current assembler offset

fn index_from_gpr(&self, x: GPR) -> RegisterIndex

Convert from a GPR register to index register

fn index_from_simd(&self, x: NEON) -> RegisterIndex

Convert from an SIMD register

fn get_vmctx_reg(&self) -> GPR

Get the GPR that hold vmctx

fn get_used_gprs(&self) -> Vec<GPR>

Get all used GPR

fn get_used_simd(&self) -> Vec<NEON>

Get all used SIMD regs

fn pick_gpr(&self) -> Option<GPR>

Picks an unused general purpose register for local/stack/argument use.

fn pick_temp_gpr(&self) -> Option<GPR>

Picks an unused general purpose register for internal temporary use.

fn acquire_temp_gpr(&mut self) -> Option<GPR>

Picks an unused general pupose register and mark it as used

fn release_gpr(&mut self, gpr: GPR)

Releases a temporary GPR.

fn reserve_unused_temp_gpr(&mut self, gpr: GPR) -> GPR

Specify that a given register is in use.

fn reserve_gpr(&mut self, gpr: GPR)

reserve a GPR

fn push_used_gpr(&mut self, used_gprs: &[GPR]) -> Result<usize, CompileError>

Push used gpr to the stack. Return the bytes taken on the stack

fn pop_used_gpr(&mut self, used_gprs: &[GPR]) -> Result<(), CompileError>

Pop used gpr to the stack

fn pick_simd(&self) -> Option<NEON>

Picks an unused SIMD register.

fn pick_temp_simd(&self) -> Option<NEON>

Picks an unused SIMD register for internal temporary use.

fn acquire_temp_simd(&mut self) -> Option<NEON>

Acquires a temporary XMM register.

fn reserve_simd(&mut self, simd: NEON)

reserve a SIMD register

fn release_simd(&mut self, simd: NEON)

Releases a temporary XMM register.

fn push_used_simd(&mut self, used_neons: &[NEON]) -> Result<usize, CompileError>

Push used simd regs to the stack. Return bytes taken on the stack

fn pop_used_simd(&mut self, used_neons: &[NEON]) -> Result<(), CompileError>

Pop used simd regs to the stack

fn instructions_address_map(&self) -> Vec<InstructionAddressMap>

fn round_stack_adjust(&self, value: usize) -> usize

Return a rounded stack adjustement value (must be multiple of 16bytes on ARM64 for example)

fn local_on_stack(&mut self, stack_offset: i32) -> Location<GPR, NEON>

Memory location for a local on the stack Like Location::Memory(GPR::RBP, -(self.stack_offset.0 as i32)) for x86_64

fn adjust_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError>

Adjust stack for locals Like assembler.emit_sub(Size::S64, Location::Imm32(delta_stack_offset as u32), Location::GPR(GPR::RSP))

fn restore_stack(&mut self, delta_stack_offset: u32) -> Result<(), CompileError>

restore stack Like assembler.emit_add(Size::S64, Location::Imm32(delta_stack_offset as u32), Location::GPR(GPR::RSP))

fn pop_stack_locals( &mut self, delta_stack_offset: u32, ) -> Result<(), CompileError>

Pop stack of locals Like assembler.emit_add(Size::S64, Location::Imm32(delta_stack_offset as u32), Location::GPR(GPR::RSP))

fn move_location_for_native( &mut self, size: Size, loc: Location<GPR, NEON>, dest: Location<GPR, NEON>, ) -> Result<(), CompileError>

push a value on the stack for a native call

fn zero_location( &mut self, size: Size, location: Location<GPR, NEON>, ) -> Result<(), CompileError>

Zero a location taht is 32bits

fn local_pointer(&self) -> GPR

GPR Reg used for local pointer on the stack

fn is_local_on_stack(&self, idx: usize) -> bool

Determine whether a local should be allocated on the stack.

fn get_local_location( &self, idx: usize, callee_saved_regs_size: usize, ) -> Location<GPR, NEON>

Determine a local’s location.

fn move_local( &mut self, stack_offset: i32, location: Location<GPR, NEON>, ) -> Result<(), CompileError>

Move a local to the stack Like emit_mov(Size::S64, location, Location::Memory(GPR::RBP, -(self.stack_offset.0 as i32)));

fn list_to_save( &self, _calling_convention: CallingConvention, ) -> Vec<Location<GPR, NEON>>

List of register to save, depending on the CallingConvention

fn get_param_location( &self, idx: usize, sz: Size, stack_args: &mut usize, calling_convention: CallingConvention, ) -> Location<GPR, NEON>

Get param location (to build a call, using SP for stack args)

fn get_call_param_location( &self, idx: usize, sz: Size, stack_args: &mut usize, calling_convention: CallingConvention, ) -> Location<GPR, NEON>

Get call param location (from a call, using FP for stack args)

fn get_simple_param_location( &self, idx: usize, calling_convention: CallingConvention, ) -> Location<GPR, NEON>

Get simple param location

fn move_location( &mut self, size: Size, source: Location<GPR, NEON>, dest: Location<GPR, NEON>, ) -> Result<(), CompileError>

move a location to another

fn move_location_extend( &mut self, size_val: Size, signed: bool, source: Location<GPR, NEON>, size_op: Size, dest: Location<GPR, NEON>, ) -> Result<(), CompileError>

move a location to another, with zero or sign extension

fn load_address( &mut self, _size: Size, _reg: Location<GPR, NEON>, _mem: Location<GPR, NEON>, ) -> Result<(), CompileError>

Load a memory value to a register, zero extending to 64bits. Panic if gpr is not a Location::GPR or if mem is not a Memory(2)

fn init_stack_loc( &mut self, init_stack_loc_cnt: u64, last_stack_loc: Location<GPR, NEON>, ) -> Result<(), CompileError>

Init the stack loc counter

fn restore_saved_area( &mut self, saved_area_offset: i32, ) -> Result<(), CompileError>

Restore save_area

fn pop_location( &mut self, location: Location<GPR, NEON>, ) -> Result<(), CompileError>

Pop a location

fn new_machine_state(&self) -> MachineState

Create a new MachineState with default values.

fn assembler_finalize(self) -> Result<Vec<u8>, CompileError>

Finalize the assembler

fn get_offset(&self) -> AssemblyOffset

get_offset of Assembler

fn finalize_function(&mut self) -> Result<(), CompileError>

finalize a function

fn emit_function_prolog(&mut self) -> Result<(), CompileError>

emit native function prolog (depending on the calling Convention, like “PUSH RBP / MOV RSP, RBP”)

fn emit_function_epilog(&mut self) -> Result<(), CompileError>

emit native function epilog (depending on the calling Convention, like “MOV RBP, RSP / POP RBP”)

fn emit_function_return_value( &mut self, ty: WpType, canonicalize: bool, loc: Location<GPR, NEON>, ) -> Result<(), CompileError>

handle return value, with optionnal cannonicalization if wanted

fn emit_function_return_float(&mut self) -> Result<(), CompileError>

Handle copy to SIMD register from ret value (if needed by the arch/calling convention)

fn arch_supports_canonicalize_nan(&self) -> bool

Is NaN canonicalization supported

fn canonicalize_nan( &mut self, sz: Size, input: Location<GPR, NEON>, output: Location<GPR, NEON>, ) -> Result<(), CompileError>

Cannonicalize a NaN (or panic if not supported)

fn emit_illegal_op(&mut self, trap: TrapCode) -> Result<(), CompileError>

emit an Illegal Opcode, associated with a trapcode

fn get_label(&mut self) -> DynamicLabel

create a new label

fn emit_label(&mut self, label: DynamicLabel) -> Result<(), CompileError>

emit a label

fn get_grp_for_call(&self) -> GPR

get the gpr use for call. like RAX on x86_64

fn emit_call_register(&mut self, reg: GPR) -> Result<(), CompileError>

Emit a call using the value in register

fn emit_call_label(&mut self, label: DynamicLabel) -> Result<(), CompileError>

Emit a call to a label

fn get_gpr_for_ret(&self) -> GPR

get the gpr for the return of generic values

fn get_simd_for_ret(&self) -> NEON

get the simd for the return of float/double values

fn arch_requires_indirect_call_trampoline(&self) -> bool

Does an trampoline is neededfor indirect call

fn arch_emit_indirect_call_with_trampoline( &mut self, location: Location<GPR, NEON>, ) -> Result<(), CompileError>

indirect call with trampoline

fn emit_debug_breakpoint(&mut self) -> Result<(), CompileError>

Emit a debug breakpoint

fn emit_call_location( &mut self, location: Location<GPR, NEON>, ) -> Result<(), CompileError>

emit a call to a location

fn location_address( &mut self, _size: Size, _source: Location<GPR, NEON>, _dest: Location<GPR, NEON>, ) -> Result<(), CompileError>

load the address of a memory location (will panic if src is not a memory) like LEA opcode on x86_64

fn location_and( &mut self, _size: Size, _source: Location<GPR, NEON>, _dest: Location<GPR, NEON>, _flags: bool, ) -> Result<(), CompileError>

And src & dst -> dst (with or without flags)

fn location_xor( &mut self, _size: Size, _source: Location<GPR, NEON>, _dest: Location<GPR, NEON>, _flags: bool, ) -> Result<(), CompileError>

Xor src & dst -> dst (with or without flags)

fn location_or( &mut self, _size: Size, _source: Location<GPR, NEON>, _dest: Location<GPR, NEON>, _flags: bool, ) -> Result<(), CompileError>

Or src & dst -> dst (with or without flags)

fn location_test( &mut self, _size: Size, _source: Location<GPR, NEON>, _dest: Location<GPR, NEON>, ) -> Result<(), CompileError>

Test src & dst and set flags

fn location_add( &mut self, size: Size, source: Location<GPR, NEON>, dest: Location<GPR, NEON>, flags: bool, ) -> Result<(), CompileError>

Add src+dst -> dst (with or without flags)

fn location_sub( &mut self, size: Size, source: Location<GPR, NEON>, dest: Location<GPR, NEON>, flags: bool, ) -> Result<(), CompileError>

Sub dst-src -> dst (with or without flags)

fn location_cmp( &mut self, size: Size, source: Location<GPR, NEON>, dest: Location<GPR, NEON>, ) -> Result<(), CompileError>

Cmp src - dst and set flags

fn jmp_unconditionnal( &mut self, label: DynamicLabel, ) -> Result<(), CompileError>

jmp without condidtion

fn jmp_on_equal(&mut self, label: DynamicLabel) -> Result<(), CompileError>

jmp on equal (src==dst) like Equal set on x86_64

fn jmp_on_different(&mut self, label: DynamicLabel) -> Result<(), CompileError>

jmp on different (src!=dst) like NotEqual set on x86_64

fn jmp_on_above(&mut self, label: DynamicLabel) -> Result<(), CompileError>

jmp on above (src>dst) like Above set on x86_64

fn jmp_on_aboveequal(&mut self, label: DynamicLabel) -> Result<(), CompileError>

jmp on above (src>=dst) like Above or Equal set on x86_64

fn jmp_on_belowequal(&mut self, label: DynamicLabel) -> Result<(), CompileError>

jmp on above (src<=dst) like Below or Equal set on x86_64

fn jmp_on_overflow(&mut self, label: DynamicLabel) -> Result<(), CompileError>

jmp on overflow like Carry set on x86_64

fn emit_jmp_to_jumptable( &mut self, label: DynamicLabel, cond: Location<GPR, NEON>, ) -> Result<(), CompileError>

jmp using a jump table at lable with cond as the indice

fn align_for_loop(&mut self) -> Result<(), CompileError>

Align for Loop (may do nothing, depending on the arch)

fn emit_ret(&mut self) -> Result<(), CompileError>

ret (from a Call)

fn emit_push( &mut self, size: Size, loc: Location<GPR, NEON>, ) -> Result<(), CompileError>

Stack push of a location

fn emit_pop( &mut self, size: Size, loc: Location<GPR, NEON>, ) -> Result<(), CompileError>

Stack pop of a location

fn emit_memory_fence(&mut self) -> Result<(), CompileError>

Emit a memory fence. Can be nothing for x86_64 or a DMB on ARM64 for example

fn location_neg( &mut self, _size_val: Size, _signed: bool, _source: Location<GPR, NEON>, _size_op: Size, _dest: Location<GPR, NEON>, ) -> Result<(), CompileError>

-src -> dst

fn emit_imul_imm32( &mut self, size: Size, imm32: u32, gpr: GPR, ) -> Result<(), CompileError>

Multiply location with immediate

fn emit_relaxed_mov( &mut self, sz: Size, src: Location<GPR, NEON>, dst: Location<GPR, NEON>, ) -> Result<(), CompileError>

relaxed mov: move from anywhere to anywhere

fn emit_relaxed_cmp( &mut self, sz: Size, src: Location<GPR, NEON>, dst: Location<GPR, NEON>, ) -> Result<(), CompileError>

relaxed cmp: compare from anywhere and anywhere

fn emit_relaxed_zero_extension( &mut self, _sz_src: Size, _src: Location<GPR, NEON>, _sz_dst: Size, _dst: Location<GPR, NEON>, ) -> Result<(), CompileError>

relaxed move with zero extension

fn emit_relaxed_sign_extension( &mut self, sz_src: Size, src: Location<GPR, NEON>, sz_dst: Size, dst: Location<GPR, NEON>, ) -> Result<(), CompileError>

relaxed move with sign extension

fn emit_binop_add32( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Add with location directly from the stack

fn emit_binop_sub32( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Sub with location directly from the stack

fn emit_binop_mul32( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Multiply with location directly from the stack

fn emit_binop_udiv32( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, integer_division_by_zero: DynamicLabel, _integer_overflow: DynamicLabel, ) -> Result<usize, CompileError>

Unsigned Division with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.

fn emit_binop_sdiv32( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, integer_division_by_zero: DynamicLabel, integer_overflow: DynamicLabel, ) -> Result<usize, CompileError>

Signed Division with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.

fn emit_binop_urem32( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, integer_division_by_zero: DynamicLabel, _integer_overflow: DynamicLabel, ) -> Result<usize, CompileError>

Unsigned Reminder (of a division) with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.

fn emit_binop_srem32( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, integer_division_by_zero: DynamicLabel, _integer_overflow: DynamicLabel, ) -> Result<usize, CompileError>

Signed Reminder (of a Division) with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.

fn emit_binop_and32( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

And with location directly from the stack

fn emit_binop_or32( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Or with location directly from the stack

fn emit_binop_xor32( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Xor with location directly from the stack

fn i32_cmp_ge_s( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Signed Greater of Equal Compare 2 i32, result in a GPR

fn i32_cmp_gt_s( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Signed Greater Than Compare 2 i32, result in a GPR

fn i32_cmp_le_s( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Signed Less of Equal Compare 2 i32, result in a GPR

fn i32_cmp_lt_s( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Signed Less Than Compare 2 i32, result in a GPR

fn i32_cmp_ge_u( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Unsigned Greater of Equal Compare 2 i32, result in a GPR

fn i32_cmp_gt_u( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Unsigned Greater Than Compare 2 i32, result in a GPR

fn i32_cmp_le_u( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Unsigned Less of Equal Compare 2 i32, result in a GPR

fn i32_cmp_lt_u( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Unsigned Less Than Compare 2 i32, result in a GPR

fn i32_cmp_ne( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Not Equal Compare 2 i32, result in a GPR

fn i32_cmp_eq( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Equal Compare 2 i32, result in a GPR

fn i32_clz( &mut self, src: Location<GPR, NEON>, dst: Location<GPR, NEON>, ) -> Result<(), CompileError>

Count Leading 0 bit of an i32

fn i32_ctz( &mut self, src: Location<GPR, NEON>, dst: Location<GPR, NEON>, ) -> Result<(), CompileError>

Count Trailling 0 bit of an i32

fn i32_popcnt( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Count the number of 1 bit of an i32

fn i32_shl( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

i32 Logical Shift Left

fn i32_shr( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

i32 Logical Shift Right

fn i32_sar( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

i32 Arithmetic Shift Right

fn i32_rol( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

i32 Roll Left

fn i32_ror( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

i32 Roll Right

fn i32_load( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 load

fn i32_load_8u( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 load of an unsigned 8bits

fn i32_load_8s( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 load of an signed 8bits

fn i32_load_16u( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 load of an unsigned 16bits

fn i32_load_16s( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 load of an signed 16bits

fn i32_atomic_load( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic load

fn i32_atomic_load_8u( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic load of an unsigned 8bits

fn i32_atomic_load_16u( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic load of an unsigned 16bits

fn i32_save( &mut self, target_value: Location<GPR, NEON>, memarg: &MemArg, target_addr: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 save

fn i32_save_8( &mut self, target_value: Location<GPR, NEON>, memarg: &MemArg, target_addr: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 save of the lower 8bits

fn i32_save_16( &mut self, target_value: Location<GPR, NEON>, memarg: &MemArg, target_addr: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 save of the lower 16bits

fn i32_atomic_save( &mut self, target_value: Location<GPR, NEON>, memarg: &MemArg, target_addr: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic save

fn i32_atomic_save_8( &mut self, target_value: Location<GPR, NEON>, memarg: &MemArg, target_addr: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic save of a the lower 8bits

fn i32_atomic_save_16( &mut self, target_value: Location<GPR, NEON>, memarg: &MemArg, target_addr: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic save of a the lower 16bits

fn i32_atomic_add( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Add with i32

fn i32_atomic_add_8u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Add with unsigned 8bits

fn i32_atomic_add_16u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Add with unsigned 16bits

fn i32_atomic_sub( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Sub with i32

fn i32_atomic_sub_8u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Sub with unsigned 8bits

fn i32_atomic_sub_16u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Sub with unsigned 16bits

fn i32_atomic_and( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic And with i32

fn i32_atomic_and_8u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic And with unsigned 8bits

fn i32_atomic_and_16u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic And with unsigned 16bits

fn i32_atomic_or( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Or with i32

fn i32_atomic_or_8u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Or with unsigned 8bits

fn i32_atomic_or_16u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Or with unsigned 16bits

fn i32_atomic_xor( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Xor with i32

fn i32_atomic_xor_8u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Xor with unsigned 8bits

fn i32_atomic_xor_16u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Xor with unsigned 16bits

fn i32_atomic_xchg( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Exchange with i32

fn i32_atomic_xchg_8u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Exchange with u8

fn i32_atomic_xchg_16u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Exchange with u16

fn i32_atomic_cmpxchg( &mut self, new: Location<GPR, NEON>, cmp: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Compare and Exchange with i32

fn i32_atomic_cmpxchg_8u( &mut self, new: Location<GPR, NEON>, cmp: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Compare and Exchange with u8

fn i32_atomic_cmpxchg_16u( &mut self, new: Location<GPR, NEON>, cmp: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i32 atomic Compare and Exchange with u16

fn emit_call_with_reloc( &mut self, _calling_convention: CallingConvention, reloc_target: RelocationTarget, ) -> Result<Vec<Relocation>, CompileError>

emit a move function address to GPR ready for call, using appropriate relocation

fn emit_binop_add64( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Add with location directly from the stack

fn emit_binop_sub64( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Sub with location directly from the stack

fn emit_binop_mul64( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Multiply with location directly from the stack

fn emit_binop_udiv64( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, integer_division_by_zero: DynamicLabel, _integer_overflow: DynamicLabel, ) -> Result<usize, CompileError>

Unsigned Division with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.

fn emit_binop_sdiv64( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, integer_division_by_zero: DynamicLabel, integer_overflow: DynamicLabel, ) -> Result<usize, CompileError>

Signed Division with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.

fn emit_binop_urem64( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, integer_division_by_zero: DynamicLabel, _integer_overflow: DynamicLabel, ) -> Result<usize, CompileError>

Unsigned Reminder (of a division) with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.

fn emit_binop_srem64( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, integer_division_by_zero: DynamicLabel, _integer_overflow: DynamicLabel, ) -> Result<usize, CompileError>

Signed Reminder (of a Division) with location directly from the stack. return the offset of the DIV opcode, to mark as trappable.

fn emit_binop_and64( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

And with location directly from the stack

fn emit_binop_or64( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Or with location directly from the stack

fn emit_binop_xor64( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Xor with location directly from the stack

fn i64_cmp_ge_s( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Signed Greater of Equal Compare 2 i64, result in a GPR

fn i64_cmp_gt_s( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Signed Greater Than Compare 2 i64, result in a GPR

fn i64_cmp_le_s( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Signed Less of Equal Compare 2 i64, result in a GPR

fn i64_cmp_lt_s( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Signed Less Than Compare 2 i64, result in a GPR

fn i64_cmp_ge_u( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Unsigned Greater of Equal Compare 2 i64, result in a GPR

fn i64_cmp_gt_u( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Unsigned Greater Than Compare 2 i64, result in a GPR

fn i64_cmp_le_u( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Unsigned Less of Equal Compare 2 i64, result in a GPR

fn i64_cmp_lt_u( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Unsigned Less Than Compare 2 i64, result in a GPR

fn i64_cmp_ne( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Not Equal Compare 2 i64, result in a GPR

fn i64_cmp_eq( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Equal Compare 2 i64, result in a GPR

fn i64_clz( &mut self, src: Location<GPR, NEON>, dst: Location<GPR, NEON>, ) -> Result<(), CompileError>

Count Leading 0 bit of an i64

fn i64_ctz( &mut self, src: Location<GPR, NEON>, dst: Location<GPR, NEON>, ) -> Result<(), CompileError>

Count Trailling 0 bit of an i64

fn i64_popcnt( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Count the number of 1 bit of an i64

fn i64_shl( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

i64 Logical Shift Left

fn i64_shr( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

i64 Logical Shift Right

fn i64_sar( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

i64 Arithmetic Shift Right

fn i64_rol( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

i64 Roll Left

fn i64_ror( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

i64 Roll Right

fn i64_load( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 load

fn i64_load_8u( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 load of an unsigned 8bits

fn i64_load_8s( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 load of an signed 8bits

fn i64_load_16u( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 load of an signed 16bits

fn i64_load_16s( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 load of an signed 16bits

fn i64_load_32u( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 load of an unsigned 32bits

fn i64_load_32s( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 load of an signed 32bits

fn i64_atomic_load( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic load

fn i64_atomic_load_8u( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic load from unsigned 8bits

fn i64_atomic_load_16u( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic load from unsigned 16bits

fn i64_atomic_load_32u( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic load from unsigned 32bits

fn i64_save( &mut self, target_value: Location<GPR, NEON>, memarg: &MemArg, target_addr: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 save

fn i64_save_8( &mut self, target_value: Location<GPR, NEON>, memarg: &MemArg, target_addr: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 save of the lower 8bits

fn i64_save_16( &mut self, target_value: Location<GPR, NEON>, memarg: &MemArg, target_addr: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 save of the lower 16bits

fn i64_save_32( &mut self, target_value: Location<GPR, NEON>, memarg: &MemArg, target_addr: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 save of the lower 32bits

fn i64_atomic_save( &mut self, target_value: Location<GPR, NEON>, memarg: &MemArg, target_addr: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic save

fn i64_atomic_save_8( &mut self, target_value: Location<GPR, NEON>, memarg: &MemArg, target_addr: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic save of a the lower 8bits

fn i64_atomic_save_16( &mut self, target_value: Location<GPR, NEON>, memarg: &MemArg, target_addr: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic save of a the lower 16bits

fn i64_atomic_save_32( &mut self, target_value: Location<GPR, NEON>, memarg: &MemArg, target_addr: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic save of a the lower 32bits

fn i64_atomic_add( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Add with i64

fn i64_atomic_add_8u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Add with unsigned 8bits

fn i64_atomic_add_16u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Add with unsigned 16bits

fn i64_atomic_add_32u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Add with unsigned 32bits

fn i64_atomic_sub( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Sub with i64

fn i64_atomic_sub_8u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Sub with unsigned 8bits

fn i64_atomic_sub_16u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Sub with unsigned 16bits

fn i64_atomic_sub_32u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Sub with unsigned 32bits

fn i64_atomic_and( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic And with i64

fn i64_atomic_and_8u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic And with unsigned 8bits

fn i64_atomic_and_16u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic And with unsigned 16bits

fn i64_atomic_and_32u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic And with unsigned 32bits

fn i64_atomic_or( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Or with i64

fn i64_atomic_or_8u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Or with unsigned 8bits

fn i64_atomic_or_16u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Or with unsigned 16bits

fn i64_atomic_or_32u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Or with unsigned 32bits

fn i64_atomic_xor( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Xor with i64

fn i64_atomic_xor_8u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Xor with unsigned 8bits

fn i64_atomic_xor_16u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Xor with unsigned 16bits

fn i64_atomic_xor_32u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Xor with unsigned 32bits

fn i64_atomic_xchg( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Exchange with i64

fn i64_atomic_xchg_8u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Exchange with u8

fn i64_atomic_xchg_16u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Exchange with u16

fn i64_atomic_xchg_32u( &mut self, loc: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Exchange with u32

fn i64_atomic_cmpxchg( &mut self, new: Location<GPR, NEON>, cmp: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Compare and Exchange with i32

fn i64_atomic_cmpxchg_8u( &mut self, new: Location<GPR, NEON>, cmp: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Compare and Exchange with u8

fn i64_atomic_cmpxchg_16u( &mut self, new: Location<GPR, NEON>, cmp: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Compare and Exchange with u16

fn i64_atomic_cmpxchg_32u( &mut self, new: Location<GPR, NEON>, cmp: Location<GPR, NEON>, target: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

i64 atomic Compare and Exchange with u32

fn f32_load( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

load an F32

fn f32_save( &mut self, target_value: Location<GPR, NEON>, memarg: &MemArg, target_addr: Location<GPR, NEON>, canonicalize: bool, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

f32 save

fn f64_load( &mut self, addr: Location<GPR, NEON>, memarg: &MemArg, ret: Location<GPR, NEON>, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

load an F64

fn f64_save( &mut self, target_value: Location<GPR, NEON>, memarg: &MemArg, target_addr: Location<GPR, NEON>, canonicalize: bool, need_check: bool, imported_memories: bool, offset: i32, heap_access_oob: DynamicLabel, unaligned_atomic: DynamicLabel, ) -> Result<(), CompileError>

f64 save

fn convert_f64_i64( &mut self, loc: Location<GPR, NEON>, signed: bool, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Convert a F64 from I64, signed or unsigned

fn convert_f64_i32( &mut self, loc: Location<GPR, NEON>, signed: bool, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Convert a F64 from I32, signed or unsigned

fn convert_f32_i64( &mut self, loc: Location<GPR, NEON>, signed: bool, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Convert a F32 from I64, signed or unsigned

fn convert_f32_i32( &mut self, loc: Location<GPR, NEON>, signed: bool, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Convert a F32 from I32, signed or unsigned

fn convert_i64_f64( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, signed: bool, sat: bool, ) -> Result<(), CompileError>

Convert a F64 to I64, signed or unsigned, without or without saturation

fn convert_i32_f64( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, signed: bool, sat: bool, ) -> Result<(), CompileError>

Convert a F64 to I32, signed or unsigned, without or without saturation

fn convert_i64_f32( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, signed: bool, sat: bool, ) -> Result<(), CompileError>

Convert a F32 to I64, signed or unsigned, without or without saturation

fn convert_i32_f32( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, signed: bool, sat: bool, ) -> Result<(), CompileError>

Convert a F32 to I32, signed or unsigned, without or without saturation

fn convert_f64_f32( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Convert a F32 to F64

fn convert_f32_f64( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Convert a F64 to F32

fn f64_neg( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Negate an F64

fn f64_abs( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Get the Absolute Value of an F64

fn emit_i64_copysign( &mut self, tmp1: GPR, tmp2: GPR, ) -> Result<(), CompileError>

Copy sign from tmp1 Self::GPR to tmp2 Self::GPR

fn f64_sqrt( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Get the Square Root of an F64

fn f64_trunc( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Trunc of an F64

fn f64_ceil( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Ceil of an F64

fn f64_floor( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Floor of an F64

fn f64_nearest( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Round at nearest int of an F64

fn f64_cmp_ge( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Greater of Equal Compare 2 F64, result in a GPR

fn f64_cmp_gt( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Greater Than Compare 2 F64, result in a GPR

fn f64_cmp_le( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Less of Equal Compare 2 F64, result in a GPR

fn f64_cmp_lt( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Less Than Compare 2 F64, result in a GPR

fn f64_cmp_ne( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Not Equal Compare 2 F64, result in a GPR

fn f64_cmp_eq( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Equal Compare 2 F64, result in a GPR

fn f64_min( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

get Min for 2 F64 values

fn f64_max( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

get Max for 2 F64 values

fn f64_add( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Add 2 F64 values

fn f64_sub( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Sub 2 F64 values

fn f64_mul( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Multiply 2 F64 values

fn f64_div( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Divide 2 F64 values

fn f32_neg( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Negate an F32

fn f32_abs( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Get the Absolute Value of an F32

fn emit_i32_copysign( &mut self, tmp1: GPR, tmp2: GPR, ) -> Result<(), CompileError>

Copy sign from tmp1 Self::GPR to tmp2 Self::GPR

fn f32_sqrt( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Get the Square Root of an F32

fn f32_trunc( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Trunc of an F32

fn f32_ceil( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Ceil of an F32

fn f32_floor( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Floor of an F32

fn f32_nearest( &mut self, loc: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Round at nearest int of an F32

fn f32_cmp_ge( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Greater of Equal Compare 2 F32, result in a GPR

fn f32_cmp_gt( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Greater Than Compare 2 F32, result in a GPR

fn f32_cmp_le( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Less of Equal Compare 2 F32, result in a GPR

fn f32_cmp_lt( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Less Than Compare 2 F32, result in a GPR

fn f32_cmp_ne( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Not Equal Compare 2 F32, result in a GPR

fn f32_cmp_eq( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Equal Compare 2 F32, result in a GPR

fn f32_min( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

get Min for 2 F32 values

fn f32_max( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

get Max for 2 F32 values

fn f32_add( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Add 2 F32 values

fn f32_sub( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Sub 2 F32 values

fn f32_mul( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Multiply 2 F32 values

fn f32_div( &mut self, loc_a: Location<GPR, NEON>, loc_b: Location<GPR, NEON>, ret: Location<GPR, NEON>, ) -> Result<(), CompileError>

Divide 2 F32 values

fn gen_std_trampoline( &self, sig: &FunctionType, calling_convention: CallingConvention, ) -> Result<FunctionBody, CompileError>

Standard function Trampoline generation

fn gen_std_dynamic_import_trampoline( &self, vmoffsets: &VMOffsets, sig: &FunctionType, calling_convention: CallingConvention, ) -> Result<FunctionBody, CompileError>

Generates dynamic import function call trampoline for a function type.

fn gen_import_call_trampoline( &self, vmoffsets: &VMOffsets, index: FunctionIndex, sig: &FunctionType, calling_convention: CallingConvention, ) -> Result<CustomSection, CompileError>

Singlepass calls import functions through a trampoline.

fn gen_dwarf_unwind_info( &mut self, code_len: usize, ) -> Option<UnwindInstructions>

generate eh_frame instruction (or None if not possible / supported)

fn gen_windows_unwind_info(&mut self, _code_len: usize) -> Option<Vec<u8>>

generate Windows unwind instructions (or None if not possible / supported)