Struct MachineRiscv 

pub struct MachineRiscv {
    assembler: AssemblerRiscv,
    used_gprs: u32,
    used_fprs: u32,
    trap_table: TrapTable,
    instructions_address_map: Vec<InstructionAddressMap>,
    src_loc: u32,
    unwind_ops: Vec<(usize, UnwindOps<GPR, FPR>)>,
}

The RISC-V machine state and code emitter.

Fields

assembler: AssemblerRiscv

used_gprs: u32

used_fprs: u32

trap_table: TrapTable

instructions_address_map: Vec<InstructionAddressMap>

Map from byte offset into wasm function to range of native instructions. Ordered by increasing InstructionAddressMap::srcloc.

src_loc: u32

The source location for the current operator.

unwind_ops: Vec<(usize, UnwindOps<GPR, FPR>)>

Vector of unwind operations with offset.

Implementations

impl MachineRiscv

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

Creates a new RISC-V machine for code generation.

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

fn used_gprs_insert(&mut self, r: GPR)

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

fn used_fp_contains(&self, r: &FPR) -> bool

fn used_fprs_insert(&mut self, r: FPR)

fn used_fprs_remove(&mut self, r: &FPR) -> bool

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

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

fn emit_relaxed_binop( &mut self, op: fn(&mut VecAssembler<RiscvRelocation>, Size, Location<GPR, FPR>, Location<GPR, FPR>) -> Result<(), CompileError>, sz: Size, src: Location<GPR, FPR>, dst: Location<GPR, FPR>, ) -> Result<(), CompileError>

fn emit_relaxed_binop_fp( &mut self, op: fn(&mut VecAssembler<RiscvRelocation>, Size, Location<GPR, FPR>, Location<GPR, FPR>) -> Result<(), CompileError>, sz: Size, src: Location<GPR, FPR>, dst: Location<GPR, FPR>, putback: bool, ) -> Result<(), CompileError>

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

fn emit_relaxed_atomic_binop3( &mut self, op: AtomicBinaryOp, sz: Size, dst: Location<GPR, FPR>, addr: GPR, src: Location<GPR, FPR>, ) -> Result<(), CompileError>

fn emit_relaxed_atomic_cmpxchg( &mut self, size: Size, dst: Location<GPR, FPR>, addr: GPR, new: Location<GPR, FPR>, cmp: Location<GPR, FPR>, ) -> Result<(), CompileError>

fn emit_relaxed_binop3_fp( &mut self, op: fn(&mut VecAssembler<RiscvRelocation>, Size, Location<GPR, FPR>, Location<GPR, FPR>, Location<GPR, FPR>) -> Result<(), CompileError>, sz: Size, src1: Location<GPR, FPR>, src2: Location<GPR, FPR>, dst: Location<GPR, FPR>, allow_imm: ImmType, return_nan_if_present: bool, ) -> Result<(), CompileError>

fn emit_relaxed_cmp( &mut self, c: Condition, loc_a: Location<GPR, FPR>, loc_b: Location<GPR, FPR>, ret: Location<GPR, FPR>, sz: Size, signed: bool, ) -> Result<(), CompileError>

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

I32 comparison with.

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

I64 comparison with.

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

NOTE: As observed on the VisionFive 2 board, when an unaligned memory write happens to write out of bounds (and thus triggers SIGSEGV), the memory is partially modified and observable for a subsequent memory read operations. Thus, we always check the boundaries.

fn emit_relaxed_load( &mut self, sz: Size, signed: bool, dst: Location<GPR, FPR>, src: Location<GPR, FPR>, ) -> Result<(), CompileError>

fn emit_maybe_unaligned_load( &mut self, sz: Size, signed: bool, dst: Location<GPR, FPR>, src: GPR, ) -> Result<(), CompileError>

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

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

fn emit_rol( &mut self, sz: Size, loc_a: Location<GPR, FPR>, loc_b: Location<GPR, FPR>, ret: Location<GPR, FPR>, allow_imm: ImmType, ) -> Result<(), CompileError>

fn emit_ror( &mut self, sz: Size, loc_a: Location<GPR, FPR>, loc_b: Location<GPR, FPR>, ret: Location<GPR, FPR>, allow_imm: ImmType, ) -> Result<(), CompileError>

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

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

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

fn convert_float_to_int( &mut self, loc: Location<GPR, FPR>, size_in: Size, ret: Location<GPR, FPR>, size_out: Size, signed: bool, sat: bool, ) -> Result<(), CompileError>

fn convert_int_to_float( &mut self, loc: Location<GPR, FPR>, size_in: Size, ret: Location<GPR, FPR>, size_out: Size, signed: bool, ) -> Result<(), CompileError>

fn convert_float_to_float( &mut self, loc: Location<GPR, FPR>, size_in: Size, ret: Location<GPR, FPR>, size_out: Size, ) -> Result<(), CompileError>

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

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

fn emit_relaxed_fcmp( &mut self, c: Condition, size: Size, loc_a: Location<GPR, FPR>, loc_b: Location<GPR, FPR>, ret: Location<GPR, FPR>, ) -> Result<(), CompileError>

fn emit_relaxed_fcvt_with_rounding( &mut self, rounding: RoundingMode, size: Size, loc: Location<GPR, FPR>, ret: Location<GPR, FPR>, ) -> Result<(), CompileError>

fn emit_unwind_op(&mut self, op: UnwindOps<GPR, FPR>)

Trait Implementations

impl Machine for MachineRiscv

fn set_srcloc(&mut self, offset: u32)

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

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

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

fn insert_stackoverflow(&mut self)

Insert a StackOverflow (at offset 0)

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

Get all current TrapInformation

fn get_param_registers( &self, _calling_convention: CallingConvention, ) -> &'static [Self::GPR]

Get registers for first N function call parameters.

type GPR = GPR

type SIMD = FPR

fn assembler_get_offset(&self) -> AssemblyOffset

Get current assembler offset

fn get_vmctx_reg(&self) -> Self::GPR

Get the GPR that hold vmctx

fn pick_gpr(&self) -> Option<Self::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 get_used_gprs(&self) -> Vec<Self::GPR>

Get all used GPR

fn get_used_simd(&self) -> Vec<Self::SIMD>

Get all used SIMD regs

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

Picks an unused general pupose register and mark it as used

fn release_gpr(&mut self, gpr: Self::GPR)

Releases a temporary GPR.

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

Specify that a given register is in use.

fn reserve_gpr(&mut self, gpr: Self::GPR)

reserve a GPR

fn push_used_gpr( &mut self, used_gprs: &[Self::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: &[Self::GPR]) -> Result<(), CompileError>

Pop used gpr from the stack.

fn pick_simd(&self) -> Option<Self::SIMD>

Picks an unused SIMD register.

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

Picks an unused SIMD register for internal temporary use.

fn acquire_temp_simd(&mut self) -> Option<Self::SIMD>

Acquires a temporary XMM register.

fn reserve_simd(&mut self, fpr: Self::SIMD)

reserve a SIMD register

fn release_simd(&mut self, fpr: Self::SIMD)

Releases a temporary XMM register.

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

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

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

Pop used simd regs to the stack

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

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

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_address_end(&mut self, begin: usize)

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

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

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

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

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

Allocate an extra space on the stack.

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

Truncate stack space by the delta_stack_offset.

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

Zero a location taht is 32bits

fn local_pointer(&self) -> Self::GPR

GPR Reg used for local pointer on the stack

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

push a value on the stack for a native call

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, FPR>

Determine a local’s location.

fn move_local( &mut self, stack_offset: i32, location: Location<GPR, FPR>, ) -> 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, FPR>>

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, FPR>

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

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

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

fn get_simple_param_location( &self, idx: usize, calling_convention: CallingConvention, ) -> Self::GPR

Get param location (idx must point to an argument that is passed in a GPR).

fn get_return_value_location( &self, idx: usize, stack_location: &mut usize, _calling_convention: CallingConvention, ) -> AbstractLocation<Self::GPR, Self::SIMD>

Get return value location (to build a call, using SP for stack return values).

fn get_call_return_value_location( &self, idx: usize, _calling_convention: CallingConvention, ) -> AbstractLocation<Self::GPR, Self::SIMD>

Get return value location (from a call, using FP for stack return values).

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

move a location to another

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

move a location to another, with zero or sign extension

fn init_stack_loc( &mut self, init_stack_loc_cnt: u64, last_stack_loc: Location<GPR, FPR>, ) -> 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, FPR>, ) -> Result<(), CompileError>

Pop a location

fn assembler_finalize( self, assembly_comments: HashMap<usize, AssemblyComment>, ) -> Result<FinalizedAssembly, 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_float(&mut self) -> Result<(), CompileError>

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

fn canonicalize_nan( &mut self, sz: Size, input: Location<GPR, FPR>, output: Location<GPR, FPR>, ) -> 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_gpr_for_call(&self) -> Self::GPR

get the gpr used for call. like RAX on x86_64

fn emit_call_register( &mut self, register: Self::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 arch_emit_indirect_call_with_trampoline( &mut self, _location: Location<GPR, FPR>, ) -> Result<(), CompileError>

indirect call with trampoline

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

emit a call to a location

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

Emit a debug breakpoint

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

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

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

Cmp src - dst and set flags

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

jmp without condidtion

fn jmp_on_condition( &mut self, cond: UnsignedCondition, size: Size, loc_a: AbstractLocation<Self::GPR, Self::SIMD>, loc_b: AbstractLocation<Self::GPR, Self::SIMD>, label: DynamicLabel, ) -> Result<(), CompileError>

jmp to label if the provided condition is true (when comparing loc_a and loc_b)

fn emit_jmp_to_jumptable( &mut self, label: DynamicLabel, cond: Location<GPR, FPR>, ) -> 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, FPR>, ) -> Result<(), CompileError>

Stack push of a location

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

Stack pop of a location

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

relaxed mov: move from anywhere to anywhere

fn emit_relaxed_cmp( &mut self, _sz: Size, _src: Location<GPR, FPR>, _dst: Location<GPR, FPR>, ) -> Result<(), CompileError>

relaxed cmp: compare from anywhere and anywhere

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 emit_relaxed_sign_extension( &mut self, sz_src: Size, src: Location<GPR, FPR>, sz_dst: Size, dst: Location<GPR, FPR>, ) -> Result<(), CompileError>

relaxed move with sign extension

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

Multiply location with immediate

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

Add with location directly from the stack

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

Sub with location directly from the stack

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

Multiply with location directly from the stack

fn emit_binop_udiv32( &mut self, loc_a: Location<GPR, FPR>, loc_b: Location<GPR, FPR>, ret: Location<GPR, FPR>, integer_division_by_zero: 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, FPR>, loc_b: Location<GPR, FPR>, ret: Location<GPR, FPR>, 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, FPR>, loc_b: Location<GPR, FPR>, ret: Location<GPR, FPR>, integer_division_by_zero: 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, FPR>, loc_b: Location<GPR, FPR>, ret: Location<GPR, FPR>, integer_division_by_zero: 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, FPR>, loc_b: Location<GPR, FPR>, ret: Location<GPR, FPR>, ) -> Result<(), CompileError>

And with location directly from the stack

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

Or with location directly from the stack

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

Xor with location directly from the stack

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

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

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

Signed Greater Than Compare 2 i32, result in a GPR

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

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

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

Signed Less Than Compare 2 i32, result in a GPR

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

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

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

Unsigned Greater Than Compare 2 i32, result in a GPR

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

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

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

Unsigned Less Than Compare 2 i32, result in a GPR

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

Not Equal Compare 2 i32, result in a GPR

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

Equal Compare 2 i32, result in a GPR

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

Count Leading 0 bit of an i32

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

Count Trailling 0 bit of an i32

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

Count the number of 1 bit of an i32

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

i32 Logical Shift Left

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

i32 Logical Shift Right

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

i32 Arithmetic Shift Right

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

i32 Roll Left

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

i32 Roll Right

fn i32_load( &mut self, addr: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, value: Location<GPR, FPR>, memarg: &MemArg, addr: Location<GPR, FPR>, _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, value: Location<GPR, FPR>, memarg: &MemArg, addr: Location<GPR, FPR>, _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, value: Location<GPR, FPR>, memarg: &MemArg, addr: Location<GPR, FPR>, _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, value: Location<GPR, FPR>, memarg: &MemArg, addr: Location<GPR, FPR>, _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, value: Location<GPR, FPR>, memarg: &MemArg, addr: Location<GPR, FPR>, _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, value: Location<GPR, FPR>, memarg: &MemArg, addr: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, cmp: Location<GPR, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, cmp: Location<GPR, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, cmp: Location<GPR, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, loc_b: Location<GPR, FPR>, ret: Location<GPR, FPR>, ) -> Result<(), CompileError>

Add with location directly from the stack

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

Sub with location directly from the stack

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

Multiply with location directly from the stack

fn emit_binop_udiv64( &mut self, loc_a: Location<GPR, FPR>, loc_b: Location<GPR, FPR>, ret: Location<GPR, FPR>, integer_division_by_zero: 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, FPR>, loc_b: Location<GPR, FPR>, ret: Location<GPR, FPR>, 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, FPR>, loc_b: Location<GPR, FPR>, ret: Location<GPR, FPR>, integer_division_by_zero: 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, FPR>, loc_b: Location<GPR, FPR>, ret: Location<GPR, FPR>, integer_division_by_zero: 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, FPR>, loc_b: Location<GPR, FPR>, ret: Location<GPR, FPR>, ) -> Result<(), CompileError>

And with location directly from the stack

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

Or with location directly from the stack

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

Xor with location directly from the stack

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

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

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

Signed Greater Than Compare 2 i64, result in a GPR

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

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

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

Signed Less Than Compare 2 i64, result in a GPR

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

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

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

Unsigned Greater Than Compare 2 i64, result in a GPR

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

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

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

Unsigned Less Than Compare 2 i64, result in a GPR

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

Not Equal Compare 2 i64, result in a GPR

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

Equal Compare 2 i64, result in a GPR

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

Count Leading 0 bit of an i64

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

Count Trailling 0 bit of an i64

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

Count the number of 1 bit of an i64

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

i64 Logical Shift Left

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

i64 Logical Shift Right

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

i64 Arithmetic Shift Right

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

i64 Roll Left

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

i64 Roll Right

fn i64_load( &mut self, addr: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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_32u( &mut self, addr: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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_load_16u( &mut self, addr: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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_atomic_load( &mut self, addr: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, value: Location<GPR, FPR>, memarg: &MemArg, addr: Location<GPR, FPR>, _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, value: Location<GPR, FPR>, memarg: &MemArg, addr: Location<GPR, FPR>, _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, value: Location<GPR, FPR>, memarg: &MemArg, addr: Location<GPR, FPR>, _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, value: Location<GPR, FPR>, memarg: &MemArg, addr: Location<GPR, FPR>, _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, value: Location<GPR, FPR>, memarg: &MemArg, addr: Location<GPR, FPR>, _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, value: Location<GPR, FPR>, memarg: &MemArg, addr: Location<GPR, FPR>, _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, value: Location<GPR, FPR>, memarg: &MemArg, addr: Location<GPR, FPR>, _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, value: Location<GPR, FPR>, memarg: &MemArg, addr: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, cmp: Location<GPR, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, cmp: Location<GPR, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, cmp: Location<GPR, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, cmp: Location<GPR, FPR>, target: Location<GPR, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, value: Location<GPR, FPR>, memarg: &MemArg, addr: Location<GPR, FPR>, 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, FPR>, memarg: &MemArg, ret: Location<GPR, FPR>, _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, value: Location<GPR, FPR>, memarg: &MemArg, addr: Location<GPR, FPR>, 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, FPR>, signed: bool, ret: Location<GPR, FPR>, ) -> Result<(), CompileError>

Convert a F64 from I64, signed or unsigned

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

Convert a F64 from I32, signed or unsigned

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

Convert a F32 from I64, signed or unsigned

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

Convert a F32 from I32, signed or unsigned

fn convert_i64_f64( &mut self, loc: Location<GPR, FPR>, ret: Location<GPR, FPR>, 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, FPR>, ret: Location<GPR, FPR>, 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, FPR>, ret: Location<GPR, FPR>, 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, FPR>, ret: Location<GPR, FPR>, 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, FPR>, ret: Location<GPR, FPR>, ) -> Result<(), CompileError>

Convert a F32 to F64

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

Convert a F64 to F32

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

Negate an F64

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

Get the Absolute Value of an F64

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

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

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

Get the Square Root of an F64

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

Trunc of an F64

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

Ceil of an F64

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

Floor of an F64

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

Round at nearest int of an F64

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

Greater of Equal Compare 2 F64, result in a GPR

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

Greater Than Compare 2 F64, result in a GPR

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

Less of Equal Compare 2 F64, result in a GPR

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

Less Than Compare 2 F64, result in a GPR

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

Not Equal Compare 2 F64, result in a GPR

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

Equal Compare 2 F64, result in a GPR

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

get Min for 2 F64 values

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

get Max for 2 F64 values

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

Add 2 F64 values

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

Sub 2 F64 values

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

Multiply 2 F64 values

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

Divide 2 F64 values

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

Negate an F32

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

Get the Absolute Value of an F32

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

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

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

Get the Square Root of an F32

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

Trunc of an F32

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

Ceil of an F32

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

Floor of an F32

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

Round at nearest int of an F32

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

Greater of Equal Compare 2 F32, result in a GPR

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

Greater Than Compare 2 F32, result in a GPR

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

Less of Equal Compare 2 F32, result in a GPR

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

Less Than Compare 2 F32, result in a GPR

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

Not Equal Compare 2 F32, result in a GPR

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

Equal Compare 2 F32, result in a GPR

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

get Min for 2 F32 values

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

get Max for 2 F32 values

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

Add 2 F32 values

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

Sub 2 F32 values

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

Multiply 2 F32 values

fn f32_div( &mut self, loc_a: Location<GPR, FPR>, loc_b: Location<GPR, FPR>, ret: Location<GPR, FPR>, ) -> 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)