Auto merge of #152702 - oli-obk:nonnulltransmute, r=<try>

Prepare NonNull for pattern types

Author: bors

library/core/src/ptr/non_null.rs

@@ -1,7 +1,7 @@
 use crate::clone::TrivialClone;
 use crate::cmp::Ordering;
 use crate::marker::{Destruct, PointeeSized, Unsize};
-use crate::mem::{MaybeUninit, SizedTypeProperties};
+use crate::mem::{MaybeUninit, SizedTypeProperties, transmute};
 use crate::num::NonZero;
 use crate::ops::{CoerceUnsized, DispatchFromDyn};
 use crate::pin::PinCoerceUnsized;
@@ -100,9 +100,9 @@ impl<T: Sized> NonNull<T> {
     #[must_use]
     #[inline]
     pub const fn without_provenance(addr: NonZero<usize>) -> Self {
-        let pointer = crate::ptr::without_provenance(addr.get());
+        let pointer: *const T = crate::ptr::without_provenance(addr.get());
         // SAFETY: we know `addr` is non-zero.
-        unsafe { NonNull { pointer } }
+        unsafe { NonNull { pointer: transmute(pointer) } }
     }
 
     /// Creates a new `NonNull` that is dangling, but well-aligned.
@@ -239,7 +239,7 @@ impl<T: PointeeSized> NonNull<T> {
                 "NonNull::new_unchecked requires that the pointer is non-null",
                 (ptr: *mut () = ptr as *mut ()) => !ptr.is_null()
             );
-            NonNull { pointer: ptr as _ }
+            NonNull { pointer: transmute(ptr) }
         }
     }
 
@@ -282,7 +282,7 @@ impl<T: PointeeSized> NonNull<T> {
     #[inline]
     pub const fn from_ref(r: &T) -> Self {
         // SAFETY: A reference cannot be null.
-        unsafe { NonNull { pointer: r as *const T } }
+        unsafe { NonNull { pointer: transmute(r as *const T) } }
     }
 
     /// Converts a mutable reference to a `NonNull` pointer.
@@ -291,7 +291,7 @@ impl<T: PointeeSized> NonNull<T> {
     #[inline]
     pub const fn from_mut(r: &mut T) -> Self {
         // SAFETY: A mutable reference cannot be null.
-        unsafe { NonNull { pointer: r as *mut T } }
+        unsafe { NonNull { pointer: transmute(r as *mut T) } }
     }
 
     /// Performs the same functionality as [`std::ptr::from_raw_parts`], except that a
@@ -502,7 +502,7 @@ impl<T: PointeeSized> NonNull<T> {
     #[inline]
     pub const fn cast<U>(self) -> NonNull<U> {
         // SAFETY: `self` is a `NonNull` pointer which is necessarily non-null
-        unsafe { NonNull { pointer: self.as_ptr() as *mut U } }
+        unsafe { NonNull { pointer: transmute(self.as_ptr() as *mut U) } }
     }
 
     /// Try to cast to a pointer of another type by checking alignment.
@@ -581,7 +581,7 @@ impl<T: PointeeSized> NonNull<T> {
         // Additionally safety contract of `offset` guarantees that the resulting pointer is
         // pointing to an allocation, there can't be an allocation at null, thus it's safe to
         // construct `NonNull`.
-        unsafe { NonNull { pointer: intrinsics::offset(self.as_ptr(), count) } }
+        unsafe { NonNull { pointer: transmute(intrinsics::offset(self.as_ptr(), count)) } }
     }
 
     /// Calculates the offset from a pointer in bytes.
@@ -605,7 +605,7 @@ impl<T: PointeeSized> NonNull<T> {
         // Additionally safety contract of `offset` guarantees that the resulting pointer is
         // pointing to an allocation, there can't be an allocation at null, thus it's safe to
         // construct `NonNull`.
-        unsafe { NonNull { pointer: self.as_ptr().byte_offset(count) } }
+        unsafe { NonNull { pointer: transmute(self.as_ptr().byte_offset(count)) } }
     }
 
     /// Adds an offset to a pointer (convenience for `.offset(count as isize)`).
@@ -657,7 +657,7 @@ impl<T: PointeeSized> NonNull<T> {
         // Additionally safety contract of `offset` guarantees that the resulting pointer is
         // pointing to an allocation, there can't be an allocation at null, thus it's safe to
         // construct `NonNull`.
-        unsafe { NonNull { pointer: intrinsics::offset(self.as_ptr(), count) } }
+        unsafe { NonNull { pointer: transmute(intrinsics::offset(self.as_ptr(), count)) } }
     }
 
     /// Calculates the offset from a pointer in bytes (convenience for `.byte_offset(count as isize)`).
@@ -681,7 +681,7 @@ impl<T: PointeeSized> NonNull<T> {
         // Additionally safety contract of `add` guarantees that the resulting pointer is pointing
         // to an allocation, there can't be an allocation at null, thus it's safe to construct
         // `NonNull`.
-        unsafe { NonNull { pointer: self.as_ptr().byte_add(count) } }
+        unsafe { NonNull { pointer: transmute(self.as_ptr().byte_add(count)) } }
     }
 
     /// Subtracts an offset from a pointer (convenience for
@@ -763,7 +763,7 @@ impl<T: PointeeSized> NonNull<T> {
         // Additionally safety contract of `sub` guarantees that the resulting pointer is pointing
         // to an allocation, there can't be an allocation at null, thus it's safe to construct
         // `NonNull`.
-        unsafe { NonNull { pointer: self.as_ptr().byte_sub(count) } }
+        unsafe { NonNull { pointer: transmute(self.as_ptr().byte_sub(count)) } }
     }
 
     /// Calculates the distance between two pointers within the same allocation. The returned value is in

tests/codegen-llvm/loads.rs

@@ -58,7 +58,7 @@ pub fn load_raw_pointer<'a>(x: &*const i32) -> *const i32 {
 // CHECK-LABEL: @load_box
 #[no_mangle]
 pub fn load_box<'a>(x: Box<Box<i32>>) -> Box<i32> {
-    // CHECK: load ptr, ptr %{{.*}}, align [[PTR_ALIGNMENT]], !nonnull !{{[0-9]+}}, !align ![[ALIGN_4_META]], !noundef !{{[0-9]+}}
+    // CHECK: load ptr, ptr %{{.*}}, align [[PTR_ALIGNMENT]], !nonnull !{{[0-9]+}}, !noundef !{{[0-9]+}}
     *x
 }
 

tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir

@@ -5,33 +5,36 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     debug f => _2;
     let mut _0: ();
     let mut _10: usize;
-    let mut _28: std::option::Option<(usize, &T)>;
-    let mut _31: &impl Fn(usize, &T);
-    let mut _32: (usize, &T);
-    let _33: ();
+    let mut _31: std::option::Option<(usize, &T)>;
+    let mut _34: &impl Fn(usize, &T);
+    let mut _35: (usize, &T);
+    let _36: ();
     scope 1 {
         debug (((iter: Enumerate<std::slice::Iter<'_, T>>).0: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>) => _6;
         debug (((iter: Enumerate<std::slice::Iter<'_, T>>).0: std::slice::Iter<'_, T>).1: *const T) => _9;
         debug (((iter: Enumerate<std::slice::Iter<'_, T>>).0: std::slice::Iter<'_, T>).2: std::marker::PhantomData<&T>) => const ZeroSized: PhantomData<&T>;
         debug ((iter: Enumerate<std::slice::Iter<'_, T>>).1: usize) => _10;
-        let _29: usize;
-        let _30: &T;
+        let _32: usize;
+        let _33: &T;
         scope 2 {
-            debug i => _29;
-            debug x => _30;
+            debug i => _32;
+            debug x => _33;
         }
         scope 18 (inlined <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next) {
-            let mut _23: std::option::Option<&T>;
-            let mut _26: (usize, bool);
-            let mut _27: (usize, &T);
+            let mut _21: std::option::Option<std::convert::Infallible>;
+            let mut _26: std::option::Option<&T>;
+            let mut _29: (usize, bool);
+            let mut _30: (usize, &T);
             scope 19 {
-                let _25: usize;
+                let _28: usize;
                 scope 24 {
                 }
             }
             scope 20 {
                 scope 21 {
                     scope 27 (inlined <Option<(usize, &T)> as FromResidual<Option<Infallible>>>::from_residual) {
+                        let mut _20: isize;
+                        let mut _22: bool;
                     }
                 }
             }
@@ -40,7 +43,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
                 }
             }
             scope 25 (inlined <Option<&T> as Try>::branch) {
-                let _24: &T;
+                let _27: &T;
                 scope 26 {
                 }
             }
@@ -49,8 +52,8 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
                 let _11: std::ptr::NonNull<T>;
                 let _13: std::ptr::NonNull<T>;
                 let mut _16: bool;
-                let mut _20: usize;
-                let _22: &T;
+                let mut _23: usize;
+                let _25: &T;
                 scope 29 {
                     let _12: *const T;
                     scope 30 {
@@ -78,13 +81,13 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
                             }
                         }
                         scope 41 (inlined NonNull::<T>::add) {
-                            let mut _17: *const T;
+                            let mut _17: *mut T;
                             let mut _18: *const T;
                             scope 42 (inlined NonNull::<T>::as_ptr) {
                             }
                         }
                         scope 43 (inlined NonNull::<T>::as_ref::<'_>) {
-                            let _21: *const T;
+                            let _24: *const T;
                             scope 44 (inlined NonNull::<T>::as_ptr) {
                             }
                             scope 45 (inlined std::ptr::mut_ptr::<impl *mut T>::cast_const) {
@@ -169,16 +172,17 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb4: {
+        StorageLive(_31);
         StorageLive(_28);
-        StorageLive(_25);
+        StorageLive(_29);
         StorageLive(_26);
-        StorageLive(_23);
         StorageLive(_11);
         StorageLive(_12);
         StorageLive(_19);
-        StorageLive(_20);
+        StorageLive(_23);
         StorageLive(_13);
-        StorageLive(_22);
+        StorageLive(_25);
+        StorageLive(_14);
         _11 = copy _6;
         _12 = copy _9;
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb5, otherwise: bb8];
@@ -187,25 +191,23 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     bb5: {
         StorageLive(_16);
         _13 = copy _12 as std::ptr::NonNull<T> (Transmute);
-        StorageLive(_14);
         _14 = copy _11 as *mut T (Transmute);
         StorageLive(_15);
         _15 = copy _13 as *mut T (Transmute);
         _16 = Eq(copy _14, copy _15);
         StorageDead(_15);
-        StorageDead(_14);
         switchInt(move _16) -> [0: bb6, otherwise: bb7];
     }
 
     bb6: {
         StorageDead(_16);
-        StorageLive(_18);
         StorageLive(_17);
-        _17 = copy _11 as *const T (Transmute);
-        _18 = Offset(copy _17, const 1_usize);
-        StorageDead(_17);
+        StorageLive(_18);
+        _17 = Offset(copy _14, const 1_usize);
+        _18 = copy _17 as *const T (PtrToPtr);
         _6 = NonNull::<T> { pointer: copy _18 };
         StorageDead(_18);
+        StorageDead(_17);
         goto -> bb13;
     }
 
@@ -224,16 +226,24 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb10: {
-        StorageDead(_22);
+        StorageDead(_14);
+        StorageDead(_25);
         StorageDead(_13);
-        StorageDead(_20);
+        StorageDead(_23);
         StorageDead(_19);
         StorageDead(_12);
         StorageDead(_11);
-        StorageDead(_23);
         StorageDead(_26);
-        StorageDead(_25);
+        StorageLive(_20);
+        StorageLive(_22);
+        _20 = discriminant(_21);
+        _22 = Eq(copy _20, const 0_isize);
+        assume(move _22);
+        StorageDead(_22);
+        StorageDead(_20);
+        StorageDead(_29);
         StorageDead(_28);
+        StorageDead(_31);
         StorageDead(_10);
         drop(_2) -> [return: bb11, unwind unreachable];
     }
@@ -243,51 +253,52 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb12: {
-        _20 = SubUnchecked(copy _19, const 1_usize);
-        _9 = copy _20 as *const T (Transmute);
+        _23 = SubUnchecked(copy _19, const 1_usize);
+        _9 = copy _23 as *const T (Transmute);
         goto -> bb13;
     }
 
     bb13: {
-        StorageLive(_21);
-        _21 = copy _11 as *const T (Transmute);
-        _22 = &(*_21);
-        StorageDead(_21);
-        _23 = Option::<&T>::Some(copy _22);
-        StorageDead(_22);
+        StorageLive(_24);
+        _24 = copy _11 as *const T (Transmute);
+        _25 = &(*_24);
+        StorageDead(_24);
+        _26 = Option::<&T>::Some(copy _25);
+        StorageDead(_14);
+        StorageDead(_25);
         StorageDead(_13);
-        StorageDead(_20);
+        StorageDead(_23);
         StorageDead(_19);
         StorageDead(_12);
         StorageDead(_11);
-        _24 = copy ((_23 as Some).0: &T);
-        StorageDead(_23);
-        _25 = copy _10;
-        _26 = AddWithOverflow(copy _10, const 1_usize);
-        assert(!move (_26.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _10, const 1_usize) -> [success: bb14, unwind unreachable];
+        _27 = copy ((_26 as Some).0: &T);
+        StorageDead(_26);
+        _28 = copy _10;
+        _29 = AddWithOverflow(copy _10, const 1_usize);
+        assert(!move (_29.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _10, const 1_usize) -> [success: bb14, unwind unreachable];
     }
 
     bb14: {
-        _10 = move (_26.0: usize);
-        StorageLive(_27);
-        _27 = (copy _25, copy _24);
-        _28 = Option::<(usize, &T)>::Some(move _27);
-        StorageDead(_27);
-        StorageDead(_26);
-        StorageDead(_25);
-        _29 = copy (((_28 as Some).0: (usize, &T)).0: usize);
-        _30 = copy (((_28 as Some).0: (usize, &T)).1: &T);
-        StorageLive(_31);
-        _31 = &_2;
-        StorageLive(_32);
-        _32 = (copy _29, copy _30);
-        _33 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _31, move _32) -> [return: bb15, unwind unreachable];
+        _10 = move (_29.0: usize);
+        StorageLive(_30);
+        _30 = (copy _28, copy _27);
+        _31 = Option::<(usize, &T)>::Some(move _30);
+        StorageDead(_30);
+        StorageDead(_29);
+        StorageDead(_28);
+        _32 = copy (((_31 as Some).0: (usize, &T)).0: usize);
+        _33 = copy (((_31 as Some).0: (usize, &T)).1: &T);
+        StorageLive(_34);
+        _34 = &_2;
+        StorageLive(_35);
+        _35 = (copy _32, copy _33);
+        _36 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _34, move _35) -> [return: bb15, unwind unreachable];
     }
 
     bb15: {
-        StorageDead(_32);
+        StorageDead(_35);
+        StorageDead(_34);
         StorageDead(_31);
-        StorageDead(_28);
         goto -> bb4;
     }
 }