27492556297

Committed 14 Jun 2026 07:57AM UTC coverage: 92.969% (-1.2%) from 94.121%

Build # 27492556297

Build Type

Pull #6

github

Committed by

web-flow

Commit Message

Merge b6c98ccdf into df49d44a8

Pull Request Pull Request #6: Feature/floats

Coverage Stats

533 of 584 new or added lines in 19 files covered. (91.27%)

5 existing lines in 3 files now uncovered.

2023 of 2176 relevant lines covered (92.97%)

62.72 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

64.2

/src/assembler.rs

use super::*;
use crate::runtime::{TrapCode, WasmReturnCode};
use aarch64::*;
use std::collections::HashMap;

pub mod aarch64;

pub fn emit_prologue(
    stack_size: usize,
    register_pool: &mut RegisterPool,
    machinecode: &mut Vec<u32>,
) {
    machinecode.push(0xA9BF7BFD); // stp fp, lr, [sp, #-16]!  ; create a new stack frame
    machinecode.push(processing::mov_sp(IReg::FP, IReg::SP, RegSize::Reg64bit)); // mov fp, sp

    if stack_size > 0 {
        if stack_size < 0x10000 {
            machinecode.push(arithmetic::sub_imm(
                IReg::SP,
                IReg::SP,
                stack_size as u32,
                false,
                RegSize::Reg64bit,
            ));
        } else {
            let reg = register_pool.alloc();
            compound::mov_large_immediate(reg, stack_size as i64, RegSize::Reg64bit, machinecode);
            machinecode.push(arithmetic::sub_extended_reg(
                IReg::SP,
                IReg::SP,
                reg,
                Extend::Uxtx,
                0,
                RegSize::Reg64bit,
            ));
            register_pool.free();
        }
    }
}

pub fn emit_epilogue(stack_size: usize, machinecode: &mut Vec<u32>) {
    if stack_size > 0 {
        // deallocate stack memory (add sp, sp, #stackSize)
        machinecode.push(arithmetic::add_imm(
            IReg::SP,
            IReg::SP,
            stack_size as u32,
            false,
            RegSize::Reg64bit,
        ));
    }
    machinecode.push(0xA8C17BFD); // ldp fp, lr, [sp], #16  ; destroy stack frame and restore FP, LR and SP
    machinecode.push(branch::ret(IReg::LR)); // ret
}

pub fn emit_trap_handler(
    machinecode: &mut Vec<u32>,
    trap_offsets: &mut HashMap<TrapCode, usize>,
) -> WasmFunction {
    let offset = machinecode.len();
    for (trap_cnt, &code) in TrapCode::ALL.iter().enumerate() {
        // store offset to current trap code
        trap_offsets.insert(code, machinecode.len());
        // emit a trap handler for each trap code, which moves the trap code to X1 and returns with X0=Trap (1)
        machinecode.push(processing::mov_imm(
            IReg::X1,
            code as u32,
            RegSize::Reg64bit,
        ));
        machinecode.push(branch::branch(
            ((TrapCode::ALL.len() - trap_cnt) as i32 * 2 - 1) * INSTRUCTION_SIZE as i32,
        )); // b <next trap handler>
    }
    machinecode.push(processing::mov_imm(
        IReg::X0,
        WasmReturnCode::Trap as u32,
        RegSize::Reg64bit,
    ));
    machinecode.push(branch::ret(IReg::LR)); // ret

    WasmFunction {
        name: String::from("trap_handler"),
        offset,
        length: machinecode.len() - offset,
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_oversized_stack() {
        let mut register_pool = RegisterPool::default();
        let mut machinecode: Vec<u32> = vec![];
        emit_prologue(0x80000, &mut register_pool, &mut machinecode);
        assert_eq!(
            machinecode,
            vec![0xA9BF7BFD, 0x910003FD, 0xD2800008, 0xF2A00108, 0xCB2863FF]
        );
    }
}

1	use super::*;
2	use crate::runtime::{TrapCode, WasmReturnCode};
3	use aarch64::*;
4	use std::collections::HashMap;
5
6	pub mod aarch64;
7
8	pub fn emit_prologue(	162✔
9	stack_size: usize,	162✔
10	register_pool: &mut RegisterPool,	162✔
11	machinecode: &mut Vec<u32>,	162✔
12	) {	162✔
13	machinecode.push(0xA9BF7BFD); // stp fp, lr, [sp, #-16]! ; create a new stack frame	162✔
14	machinecode.push(processing::mov_sp(IReg::FP, IReg::SP, RegSize::Reg64bit)); // mov fp, sp	162✔
15
16	if stack_size > 0 {	162✔
17	if stack_size < 0x10000 {	97✔
18	machinecode.push(arithmetic::sub_imm(	96✔
19	IReg::SP,	96✔
20	IReg::SP,	96✔
21	stack_size as u32,	96✔
22	false,	96✔
23	RegSize::Reg64bit,	96✔
24	));	96✔
25	} else {	96✔
26	let reg = register_pool.alloc();	1✔
27	compound::mov_large_immediate(reg, stack_size as i64, RegSize::Reg64bit, machinecode);	1✔
28	machinecode.push(arithmetic::sub_extended_reg(	1✔
29	IReg::SP,	1✔
30	IReg::SP,	1✔
31	reg,	1✔
32	Extend::Uxtx,	1✔
33	0,	1✔
34	RegSize::Reg64bit,	1✔
35	));	1✔
36	register_pool.free();	1✔
37	}	1✔
38	}	65✔
39	}	162✔
40
41	pub fn emit_epilogue(stack_size: usize, machinecode: &mut Vec<u32>) {	160✔
42	if stack_size > 0 {	160✔
43	// deallocate stack memory (add sp, sp, #stackSize)	96✔
44	machinecode.push(arithmetic::add_imm(	96✔
45	IReg::SP,	96✔
46	IReg::SP,	96✔
47	stack_size as u32,	96✔
48	false,	96✔
49	RegSize::Reg64bit,	96✔
50	));	96✔
51	}	96✔
52	machinecode.push(0xA8C17BFD); // ldp fp, lr, [sp], #16 ; destroy stack frame and restore FP, LR and SP	160✔
53	machinecode.push(branch::ret(IReg::LR)); // ret	160✔
54	}	160✔
55
56	pub fn emit_trap_handler(	×
57	machinecode: &mut Vec<u32>,	×
58	trap_offsets: &mut HashMap<TrapCode, usize>,	×
59	) -> WasmFunction {	×
60	let offset = machinecode.len();	×
61	for (trap_cnt, &code) in TrapCode::ALL.iter().enumerate() {	×
62	// store offset to current trap code	×
63	trap_offsets.insert(code, machinecode.len());	×
64	// emit a trap handler for each trap code, which moves the trap code to X1 and returns with X0=Trap (1)	×
NEW 65	machinecode.push(processing::mov_imm(	×
NEW 66	IReg::X1,	×
NEW 67	code as u32,	×
NEW 68	RegSize::Reg64bit,	×
NEW 69	));	×
70	machinecode.push(branch::branch(	×
71	((TrapCode::ALL.len() - trap_cnt) as i32 * 2 - 1) * INSTRUCTION_SIZE as i32,	×
72	)); // b <next trap handler>	×
73	}	×
74	machinecode.push(processing::mov_imm(	×
NEW 75	IReg::X0,	×
76	WasmReturnCode::Trap as u32,	×
77	RegSize::Reg64bit,	×
78	));
NEW 79	machinecode.push(branch::ret(IReg::LR)); // ret	×
80
81	WasmFunction {	×
82	name: String::from("trap_handler"),	×
83	offset,	×
84	length: machinecode.len() - offset,	×
85	}	×
86	}	×
87
88	#[cfg(test)]
89	mod tests {
90	use super::*;
91
92	#[test]
93	fn test_oversized_stack() {	1✔
94	let mut register_pool = RegisterPool::default();	1✔
95	let mut machinecode: Vec<u32> = vec![];	1✔
96	emit_prologue(0x80000, &mut register_pool, &mut machinecode);	1✔
97	assert_eq!(	1✔
98	machinecode,
99	vec![0xA9BF7BFD, 0x910003FD, 0xD2800008, 0xF2A00108, 0xCB2863FF]	1✔
100	);
101	}	1✔
102	}

henrythasler / rust-tiny-wasm / 27492556297

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous