26724500385

Committed 31 May 2026 09:07PM UTC coverage: 93.974% (-1.2%) from 95.172%

Build # 26724500385

Build Type

push

github

Committed by

henrythasler

Commit Message

switch to inline trap handling

Coverage Stats

48 of 55 new or added lines in 7 files covered. (87.27%)

19 existing lines in 1 file now uncovered.

1731 of 1842 relevant lines covered (93.97%)

63.96 hits per line

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

67.53

/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(Reg::FP, Reg::SP, RegSize::Reg64bit)); // mov fp, sp

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

henrythasler / rust-tiny-wasm / 26724500385

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