Miri cannot represent partial pointers (for byte-wise copy and partial overwrite)

[RalfJung]

Miri's model of memory can only attach provenance to pointer-sized chunks of memory, but not to individual bytes. This leads to incorrect behavior in several situations:

• We cannot copy a pointer one MaybeUninit<u8> at a time. In particular this affects ptr::swap_nonoverlapping.
• We cannot overwrite some of the bytes of a pointer, but preserve provenance on the bytes that remain.

[RalfJung]

Testcases for the first problem

These should pass but currently raise an "unsupported operation".

use std::{
    mem::{self, MaybeUninit},
    ptr,
};

fn main() {
    let mut ptr1 = &1;
    let mut ptr2 = &2;

    // Swap them, bytewise.
    unsafe {
        ptr::swap_nonoverlapping(
            &mut ptr1 as *mut _ as *mut MaybeUninit<u8>,
            &mut ptr2 as *mut _ as *mut MaybeUninit<u8>,
            mem::size_of::<&i32>(),
        );
    }
    
    // Make sure they still work.
    assert_eq!(*ptr1, 2);
    assert_eq!(*ptr2, 1);

    // TODO: also test ptr::swap, ptr::copy, ptr::copy_nonoverlapping.
}

use std::mem::{self, MaybeUninit};

unsafe fn memcpy<T>(to: *mut T, from: *const T) {
    let to = to.cast::<MaybeUninit<u8>>();
    let from = from.cast::<MaybeUninit<u8>>();
    for i in 0..mem::size_of::<T>() {
        let b = from.add(i).read();
        to.add(i).write(b);
    }
}

fn main() {
    let ptr1 = &1;
    let mut ptr2 = &2;

    // Copy, bytewise.
    unsafe {
        memcpy(&mut ptr2, &ptr1);
    }

    // Make sure they still work.
    assert_eq!(*ptr1, 1);
    assert_eq!(*ptr2, 1);
}

Testcase for the second problem

This should pass but currently reports UB.

use std::mem::{self, MaybeUninit};

unsafe fn ptr_bytes<'x>(ptr: &'x mut &i32)
-> &'x mut [MaybeUninit<u8>; mem::size_of::<&i32>()]
{
    mem::transmute(ptr)
}

fn main() { unsafe {
    let mut ptr = &42;
    // Get a bytewise view of the pointer.
    let ptr_bytes = ptr_bytes(&mut ptr);

    // The 2 highest bytes are both 0.
    assert_eq!(*ptr_bytes[6].as_ptr().cast::<u8>(), 0);
    assert_eq!(*ptr_bytes[7].as_ptr().cast::<u8>(), 0);
    // Overwrite provenance on the last byte.
    ptr_bytes[7] = MaybeUninit::new(0);
    // Restore it from the previous byte.
    ptr_bytes[7] = ptr_bytes[6];

    // Now ptr should be good again.
    assert_eq!(*ptr, 42);
} }

[RalfJung]

Also this special case in the standard library should not be needed any more when this is properly implemented. And this one.