Miscompilation on release profile when std::ptr::read is used to cast byte primitive to some tuples in unreachable code paths #127286

fn main() {
    assert!(core::any::TypeId::of::<u8>() != core::any::TypeId::of::<(u8, u8)>()); // OK
    assert!(!can_cast_u8_to_tuple_u8_u8()); // FAIL
}

// Optimized to `movb $1, %al; retq;` on release profile.
// Optimized to `xorl %eax, %eax; retq;` if `transmute_copy` is used instead.
pub fn can_cast_u8_to_tuple_u8_u8() -> bool {
    fn cast_u8_to_tuple_u8_u8(value: u8) -> Result<(u8, u8), u8> {
        if core::any::TypeId::of::<u8>() == core::any::TypeId::of::<(u8, u8)>() {
            Ok(unsafe { std::ptr::read(&value as *const u8 as *const (u8, u8)) })
        } else {
            Err(value)
        }
    }

    cast_u8_to_tuple_u8_u8(123_u8).is_ok()
}

#[inline]
#[must_use]
#[track_caller]
pub const unsafe fn affected_variant_of_transmute_copy<Src, Dst>(src: &Src) -> Dst {
    // assert!(
    //     std::mem::size_of::<Src>() >= std::mem::size_of::<Dst>(),
    //     "cannot transmute_copy if Dst is larger than Src"
    // );

    if std::mem::align_of::<Dst>() > std::mem::align_of::<Src>() {
        unsafe { std::ptr::read_unaligned(src as *const Src as *const Dst) }
    } else {
        unsafe { std::ptr::read(src as *const Src as *const Dst) }
    }
}

assert!(castaway::cast!(12_u8, (u8, u8)).is_err()); // assertion failed
assert!(castaway::cast!(23_u8, (i32, char)).is_err()); // Illegal instruction (core dumped)
assert!(castaway::cast!(34_i8, (usize, f64)).is_err()); // Illegal instruction (core dumped)
assert!(castaway::cast!(false, (bool, u16)).is_err()); // Illegal instruction (core dumped)

fn main() {
    test1();
}

fn test1() {
    macro_rules! repeat { ( $( $ty:ty ),* ) => { $( test2::<$ty>(); )* }; }
    repeat!(u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize, f32, f64, bool, char);
}

fn test2<T1: 'static + Default>() {
    macro_rules! repeat { ( $( $ty:ty ),* ) => { $( test3::<T1, $ty>(); )* }; }
    // Adding `bool` or `char` here will result in `Illegal instruction (core dumped)` runtime error.
    repeat!(u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize, f32, f64);
}

fn test3<T1: 'static + Default, T2>() {
    macro_rules! repeat { ( $( $ty:ty ),* ) => { $( test4::<T1, T2, $ty>(); )* }; }
    repeat!(u8, u16, u32, u64, u128, usize, i8, i16, i32, i64, i128, isize, f32, f64, bool, char);
}

fn test4<T1: 'static + Default, T2, T3>() {
    if can_cast_t1_to_tuple_t2_t3::<T1, T2, T3>() {
        println!(
            "unexpected cast success from {:5} to ({:5}, {:5})",
            core::any::type_name::<T1>(),
            core::any::type_name::<T2>(),
            core::any::type_name::<T3>()
        );
    }
}

#[inline(never)]
fn can_cast_t1_to_tuple_t2_t3<T1: Default, T2, T3>() -> bool {
    fn cast<T1: Default, T2, T3>(value: T1) -> Result<(T2, T3), T1> {
        if core::any::TypeId::of::<u8>() == core::any::TypeId::of::<(u8, u8)>() {
            Ok(unsafe { std::ptr::read(&value as *const T1 as *const (T2, T3)) })
        } else {
            Err(value)
        }
    }

    cast::<T1, T2, T3>(T1::default()).is_ok()
}