Compiler Explorer

Source code

#![feature(test)] // for black_box().

use std::mem::MaybeUninit;

extern "C" {
    fn snprintf(s: *mut i8, len: usize, fmt: *const i8, ...);
}

// Based on the Godbolt example from
// https://www.ralfj.de/blog/2019/07/14/uninit.html.
//
// See if we can convince the optimizer to see an
// uninitialized chunk of memory as initialized.

pub fn always_true_or_false() -> bool {
    // Just claim we initialized this even though we did not.
    let mut x: [u8; 16] = unsafe { MaybeUninit::uninit().assume_init() };
    // UB: optimized to 'true' or 'false'
    x[11] == x[12]
}

pub fn always_true_or_false_vec() -> bool {
    // same as the first function, but use a Vec.
    let mut v = Vec::<u8>::with_capacity(256);
    unsafe { v.set_len(256); }
    // UB
    v[11] == v[12]
}

pub fn init_mem_using_ffi() -> bool {
    let mut x: [u8; 16] = unsafe { MaybeUninit::uninit().assume_init() };
    // An FFI call to some libc function makes the memory
    // initialized, as far as the optimizer is concerned.
    unsafe { snprintf((&mut x[..]).as_mut_ptr() as *mut i8, x.len(), b"x\0".as_ptr() as *const i8) };
    x[11] == x[12]
}

pub fn init_mem_black_box() -> bool {
    let mut x: [u8; 16] = unsafe { MaybeUninit::uninit().assume_init() };
    // black_box appears to work as well. however, the docs at
    // https://doc.rust-lang.org/nightly/std/hint/fn.black_box.html
    // seem to indicate that this is unreliable.
    std::hint::black_box(&mut x);
    x[11] == x[12]
}

pub fn not_sure_why_but_it_works() -> bool {
    // Just claim we initialized this even though we did not.
    let mut x: [u8; 16] = unsafe { MaybeUninit::uninit().assume_init() };
    // It appears calling an unsafe function that does a pointer write of just
    // the first byte works as well.
    unsafe { init_mem_helper((&mut x[..]).as_mut_ptr() as *mut i8); }
    x[11] == x[12]
}

// Need the inline(never)
#[inline(never)]
pub unsafe fn init_mem_helper(s: *mut i8) {   
    // Write to the first byte.
    s.write(0);
}