Rollup merge of #100030 - WaffleLapkin:nice_pointer_sis, r=scottmcm

cleanup code w/ pointers in std a little

Use pointer methods (`byte_add`, `null_mut`, etc) to make code in std a little nicer.

Author: Dylan-DPC

library/core/src/alloc/global.rs

@@ -74,7 +74,7 @@ use crate::ptr;
 ///         {
 ///             return null_mut();
 ///         };
-///         (self.arena.get() as *mut u8).add(allocated)
+///         self.arena.get().cast::<u8>().add(allocated)
 ///     }
 ///     unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {}
 /// }

library/core/src/ptr/const_ptr.rs

@@ -1267,20 +1267,21 @@ impl<T: ?Sized> *const T {
     /// Accessing adjacent `u8` as `u16`
     ///
     /// ```
-    /// # fn foo(n: usize) {
-    /// # use std::mem::align_of;
+    /// use std::mem::align_of;
+    ///
     /// # unsafe {
-    /// let x = [5u8, 6u8, 7u8, 8u8, 9u8];
-    /// let ptr = x.as_ptr().add(n) as *const u8;
+    /// let x = [5_u8, 6, 7, 8, 9];
+    /// let ptr = x.as_ptr();
     /// let offset = ptr.align_offset(align_of::<u16>());
-    /// if offset < x.len() - n - 1 {
-    ///     let u16_ptr = ptr.add(offset) as *const u16;
-    ///     assert_ne!(*u16_ptr, 500);
+    ///
+    /// if offset < x.len() - 1 {
+    ///     let u16_ptr = ptr.add(offset).cast::<u16>();
+    ///     assert!(*u16_ptr == u16::from_ne_bytes([5, 6]) || *u16_ptr == u16::from_ne_bytes([6, 7]));
     /// } else {
     ///     // while the pointer can be aligned via `offset`, it would point
     ///     // outside the allocation
     /// }
-    /// # } }
+    /// # }
     /// ```
     #[stable(feature = "align_offset", since = "1.36.0")]
     #[rustc_const_unstable(feature = "const_align_offset", issue = "90962")]

library/core/src/ptr/mut_ptr.rs

@@ -1545,20 +1545,23 @@ impl<T: ?Sized> *mut T {
     /// Accessing adjacent `u8` as `u16`
     ///
     /// ```
-    /// # fn foo(n: usize) {
-    /// # use std::mem::align_of;
+    /// use std::mem::align_of;
+    ///
     /// # unsafe {
-    /// let x = [5u8, 6u8, 7u8, 8u8, 9u8];
-    /// let ptr = x.as_ptr().add(n) as *const u8;
+    /// let mut x = [5_u8, 6, 7, 8, 9];
+    /// let ptr = x.as_mut_ptr();
     /// let offset = ptr.align_offset(align_of::<u16>());
-    /// if offset < x.len() - n - 1 {
-    ///     let u16_ptr = ptr.add(offset) as *const u16;
-    ///     assert_ne!(*u16_ptr, 500);
+    ///
+    /// if offset < x.len() - 1 {
+    ///     let u16_ptr = ptr.add(offset).cast::<u16>();
+    ///     *u16_ptr = 0;
+    ///
+    ///     assert!(x == [0, 0, 7, 8, 9] || x == [5, 0, 0, 8, 9]);
     /// } else {
     ///     // while the pointer can be aligned via `offset`, it would point
     ///     // outside the allocation
     /// }
-    /// # } }
+    /// # }
     /// ```
     #[stable(feature = "align_offset", since = "1.36.0")]
     #[rustc_const_unstable(feature = "const_align_offset", issue = "90962")]

library/core/src/slice/iter.rs

@@ -92,7 +92,7 @@ impl<'a, T> Iter<'a, T> {
             assume(!ptr.is_null());
 
             let end = if mem::size_of::<T>() == 0 {
-                (ptr as *const u8).wrapping_add(slice.len()) as *const T
+                ptr.wrapping_byte_add(slice.len())
             } else {
                 ptr.add(slice.len())
             };
@@ -228,7 +228,7 @@ impl<'a, T> IterMut<'a, T> {
             assume(!ptr.is_null());
 
             let end = if mem::size_of::<T>() == 0 {
-                (ptr as *mut u8).wrapping_add(slice.len()) as *mut T
+                ptr.wrapping_byte_add(slice.len())
             } else {
                 ptr.add(slice.len())
             };

library/core/tests/const_ptr.rs

@@ -3,7 +3,7 @@ const DATA: [u16; 2] = [u16::from_ne_bytes([0x01, 0x23]), u16::from_ne_bytes([0x
 
 const fn unaligned_ptr() -> *const u16 {
     // Since DATA.as_ptr() is aligned to two bytes, adding 1 byte to that produces an unaligned *const u16
-    unsafe { (DATA.as_ptr() as *const u8).add(1) as *const u16 }
+    unsafe { DATA.as_ptr().byte_add(1) }
 }
 
 #[test]
@@ -67,7 +67,7 @@ fn write() {
     const fn write_unaligned() -> [u16; 2] {
         let mut two_aligned = [0u16; 2];
         unsafe {
-            let unaligned_ptr = (two_aligned.as_mut_ptr() as *mut u8).add(1) as *mut u16;
+            let unaligned_ptr = two_aligned.as_mut_ptr().byte_add(1);
             ptr::write_unaligned(unaligned_ptr, u16::from_ne_bytes([0x23, 0x45]));
         }
         two_aligned
@@ -91,7 +91,7 @@ fn mut_ptr_write() {
     const fn write_unaligned() -> [u16; 2] {
         let mut two_aligned = [0u16; 2];
         unsafe {
-            let unaligned_ptr = (two_aligned.as_mut_ptr() as *mut u8).add(1) as *mut u16;
+            let unaligned_ptr = two_aligned.as_mut_ptr().byte_add(1);
             unaligned_ptr.write_unaligned(u16::from_ne_bytes([0x23, 0x45]));
         }
         two_aligned

library/core/tests/lib.rs

@@ -14,6 +14,7 @@
 #![feature(const_maybe_uninit_assume_init_read)]
 #![feature(const_nonnull_new)]
 #![feature(const_num_from_num)]
+#![feature(const_pointer_byte_offsets)]
 #![feature(const_ptr_as_ref)]
 #![feature(const_ptr_read)]
 #![feature(const_ptr_write)]
@@ -74,6 +75,7 @@
 #![feature(never_type)]
 #![feature(unwrap_infallible)]
 #![feature(result_into_ok_or_err)]
+#![feature(pointer_byte_offsets)]
 #![feature(portable_simd)]
 #![feature(ptr_metadata)]
 #![feature(once_cell)]

library/std/src/sys/sgx/abi/usercalls/alloc.rs

@@ -115,7 +115,7 @@ pub unsafe trait UserSafe {
     /// * the pointer is null.
     /// * the pointed-to range is not in user memory.
     unsafe fn check_ptr(ptr: *const Self) {
-        let is_aligned = |p| -> bool { 0 == (p as usize) & (Self::align_of() - 1) };
+        let is_aligned = |p: *const u8| -> bool { 0 == p.addr() & (Self::align_of() - 1) };
 
         assert!(is_aligned(ptr as *const u8));
         assert!(is_user_range(ptr as _, mem::size_of_val(unsafe { &*ptr })));

library/std/src/sys/unsupported/alloc.rs

@@ -1,22 +1,23 @@
 use crate::alloc::{GlobalAlloc, Layout, System};
+use crate::ptr::null_mut;
 
 #[stable(feature = "alloc_system_type", since = "1.28.0")]
 unsafe impl GlobalAlloc for System {
     #[inline]
     unsafe fn alloc(&self, _layout: Layout) -> *mut u8 {
-        0 as *mut u8
+        null_mut()
     }
 
     #[inline]
     unsafe fn alloc_zeroed(&self, _layout: Layout) -> *mut u8 {
-        0 as *mut u8
+        null_mut()
     }
 
     #[inline]
     unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {}
 
     #[inline]
     unsafe fn realloc(&self, _ptr: *mut u8, _layout: Layout, _new_size: usize) -> *mut u8 {
-        0 as *mut u8
+        null_mut()
     }
 }