22797332632

Committed 07 Mar 2026 10:27AM UTC coverage: 33.202% (-0.1%) from 33.315%

Build # 22797332632

Build Type

push

github

Committed by

henrythasler

Commit Message

use generic function signatures

Coverage Stats

0 of 10 new or added lines in 2 files covered. (0.0%)

1 existing line in 1 file now uncovered.

592 of 1783 relevant lines covered (33.2%)

1.93 hits per line

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

0.0

/src/runtime.rs

use bytemuck;
use memmap2::{Mmap, MmapMut};
use std::mem;

#[cfg(target_arch = "aarch64")]
unsafe fn clear_cache(addr: *mut u8, len: usize) {
    // Use libc function
    unsafe extern "C" {
        fn __clear_cache(start: *mut u8, end: *mut u8);
    }
    unsafe {
        __clear_cache(addr, addr.add(len));
    }
}

pub struct Runtime {
    machinecode: Mmap,
}

impl Runtime {
    pub unsafe fn get_function<F>(&self) -> F
    where
        F: Sized,
    {
        let ptr = self.machinecode.as_ptr();

        // Ensure validity, proper alignment and size for function pointers
        assert!(!ptr.is_null());
        assert_eq!((ptr as usize) % mem::align_of::<F>(), 0);
        assert_eq!(mem::size_of::<F>(), mem::size_of::<*const u8>());

        unsafe { mem::transmute_copy(&ptr) }
    }
}

pub fn get_module_instance(jit_code: &[u32]) -> Runtime {
    // Allocate executable memory and copy JIT code into that region
    let bytes = bytemuck::cast_slice(jit_code);
    let mut mmap = MmapMut::map_anon(bytes.len()).expect("map_anon() failed");
    mmap.copy_from_slice(bytes);

    // clear instruction cache on aarch64 target
    #[cfg(target_arch = "aarch64")]
    unsafe {
        clear_cache(mmap.as_mut_ptr(), mmap.len());
    }

    // set execution permissions
    let machinecode = mmap.make_exec().expect("make_exec() failed");
    Runtime { machinecode }
}

1	use bytemuck;
2	use memmap2::{Mmap, MmapMut};
3	use std::mem;
4
5	#[cfg(target_arch = "aarch64")]
6	unsafe fn clear_cache(addr: *mut u8, len: usize) {	×
7	// Use libc function
8	unsafe extern "C" {
9	fn __clear_cache(start: mut u8, end: mut u8);
10	}
11	unsafe {	×
12	__clear_cache(addr, addr.add(len));	×
13	}	×
14	}	×
15
16	pub struct Runtime {
17	machinecode: Mmap,
18	}
19
20	impl Runtime {
NEW 21	pub unsafe fn get_function<F>(&self) -> F	×
NEW 22	where	×
NEW 23	F: Sized,	×
24	{
NEW 25	let ptr = self.machinecode.as_ptr();	×
26
27	// Ensure validity, proper alignment and size for function pointers
NEW 28	assert!(!ptr.is_null());	×
NEW 29	assert_eq!((ptr as usize) % mem::align_of::<F>(), 0);	×
NEW 30	assert_eq!(mem::size_of::<F>(), mem::size_of::<*const u8>());	×
31
NEW 32	unsafe { mem::transmute_copy(&ptr) }	×
UNCOV 33	}	×
34	}
35
36	pub fn get_module_instance(jit_code: &[u32]) -> Runtime {	×
37	// Allocate executable memory and copy JIT code into that region
38	let bytes = bytemuck::cast_slice(jit_code);	×
39	let mut mmap = MmapMut::map_anon(bytes.len()).expect("map_anon() failed");	×
40	mmap.copy_from_slice(bytes);	×
41
42	// clear instruction cache on aarch64 target
43	#[cfg(target_arch = "aarch64")]
44	unsafe {	×
45	clear_cache(mmap.as_mut_ptr(), mmap.len());	×
46	}	×
47
48	// set execution permissions
49	let machinecode = mmap.make_exec().expect("make_exec() failed");	×
50	Runtime { machinecode }	×
51	}	×

henrythasler / rust-tiny-wasm / 22797332632

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