how to constrain the lifetime when doing unsafe conversion

user_17836287 0
Viewed 59

I want to create a Test ref from the array ref with the same size and keep the lifetime checking.
I can do this by using a function and I know the function can deduce the lifetime. The code below is intentionally designed to fail when compiling because of use after move. It works.

struct Test {
    a: i32,
}

/// 'a can be removed for simplification
fn create_test<'a>(ptr: &'a mut [u8]) -> &'a mut Test {
    assert_eq!(ptr.len(), size_of::<Test>());
    unsafe { &mut *(ptr as *mut [u8] as *mut Test) }
}

fn main() {
    let mut space = Box::new([0 as u8; 100]);
    let (s1, _s2) = space.split_at_mut(size_of::<Test>());

    let test = create_test(s1);
    drop(space);

    test.a += 1;
}

My question is how can I do this without declaring an extra function to constrain the lifetime.

fn main() {
    let mut space = Box::new([0 as u8; 100]);
    let (s1, _s2): (&'a mut [u8], _) = space.split_at_mut(size_of::<Test>());
    let test: &'a mut Test = unsafe { &mut *(s1 as *mut [u8] as *mut Test) };
    drop(space);
}

such `a is not allowed.

rust
2 Answers

The following code works. And it holds the borrowing check.

fn main() {
    let mut space = Box::new([0 as u8; 100]);
    let layout = Layout::new::<Test>();
    println!("{}", layout.align());
    let (_prefix, tests, _suffix) = unsafe { space.align_to_mut::<Test>() };
    assert!(tests.len() > 0);
    let test = &mut tests[0];
    let (_, suffix, _) = unsafe { tests[1..].align_to_mut::<u8>() };
}
user_178362870

You cannot do that, but this is not needed either. Lifetimes are used to ensure safety across function boundaries. In the same function you can just ensure safety manually.

Theoretically, we would not need a borrow checker if the compiler could just inspect the called functions and follow the execution path to deterime whether we invoke Undefined Behavior. Practically, this can't be done because of problems like the Halting Problem and performance.

user_78843050
Related