Function wasmtime_environ::__core::ptr::write_bytes

pub unsafe fn write_bytes<T>(dst: *mut T, val: u8, count: usize)

Sets count * size_of::<T>() bytes of memory starting at dst to val.

write_bytes is similar to C’s memset, but sets count * size_of::<T>() bytes to val.

Safety

Behavior is undefined if any of the following conditions are violated:

• dst must be valid for writes of count * size_of::<T>() bytes.

• dst must be properly aligned.

Additionally, the caller must ensure that writing count * size_of::<T>() bytes to the given region of memory results in a valid value of T. Using a region of memory typed as a T that contains an invalid value of T is undefined behavior.

Note that even if the effectively copied size (count * size_of::<T>()) is 0, the pointer must be non-null and properly aligned.

Examples

Basic usage:

use std::ptr;

let mut vec = vec![0u32; 4];
unsafe {
    let vec_ptr = vec.as_mut_ptr();
    ptr::write_bytes(vec_ptr, 0xfe, 2);
}
assert_eq!(vec, [0xfefefefe, 0xfefefefe, 0, 0]);

Creating an invalid value:

use std::ptr;

let mut v = Box::new(0i32);

unsafe {
    // Leaks the previously held value by overwriting the `Box<T>` with
    // a null pointer.
    ptr::write_bytes(&mut v as *mut Box<i32>, 0, 1);
}

// At this point, using or dropping `v` results in undefined behavior.
// drop(v); // ERROR

// Even leaking `v` "uses" it, and hence is undefined behavior.
// mem::forget(v); // ERROR

// In fact, `v` is invalid according to basic type layout invariants, so *any*
// operation touching it is undefined behavior.
// let v2 = v; // ERROR

unsafe {
    // Let us instead put in a valid value
    ptr::write(&mut v as *mut Box<i32>, Box::new(42i32));
}

// Now the box is fine
assert_eq!(*v, 42);