allocator::adapt::DangleZst: fix ZST reallocs by mass reimplementation.

• Why was I trying to copy data to/from ZSTs?
• Why did I try to free dangling pointers corresponding to ZSTs?
• Why were I calling `realloc_uninit` to implement `thin::Realloc::realloc_zeroed`?
• No seriously, what the fuck?

Additionally:
• Additional test coverage (including for `AllocZst`)
• `impl thin::SizeOf{,Debug} for allocator::adapt::DangleZst`

relates to #32

Author: MaulingMonkey

src/allocator/adapt/dangle_zst.rs

@@ -14,7 +14,7 @@ use core::ptr::NonNull;
 
 impl<A: Meta> DangleZst<A> {
     // TODO: replace with NonNull::new when that stabilizes as a const fn
-    const DANGLE : NonNull<MaybeUninit<u8>> = unsafe { NonNull::new_unchecked(A::MAX_ALIGN.as_usize() as _) };
+    const DANGLE : NonNull<MaybeUninit<u8>> = match crate::util::nn::from_usize(A::MAX_ALIGN.as_usize()) { Some(nn) => nn, None => panic!("could not convert A::MAX_ALIGN to a NonNull") };
 }
 
 impl<A> core::ops::Deref for DangleZst<A> { fn deref(&self) -> &Self::Target { &self.0 } type Target = A; }
@@ -71,7 +71,21 @@ unsafe impl<A: thin::Realloc> thin::Realloc for DangleZst<A> {
     unsafe fn realloc_zeroed(&self, ptr: NonNull<MaybeUninit<u8>>, new_size: usize) -> Result<NonNull<MaybeUninit<u8>>, Self::Error> {
         if ptr == Self::DANGLE  { return self.0.alloc_zeroed(new_size).map(|a| a.cast()) }
         if new_size == 0        { unsafe { self.0.free(ptr) }; return Ok(Self::DANGLE) }
-        unsafe { self.0.realloc_uninit(ptr, new_size) }
+        unsafe { self.0.realloc_zeroed(ptr, new_size) }
+    }
+}
+
+unsafe impl<A: thin::SizeOf> thin::SizeOf for DangleZst<A> {
+    unsafe fn size_of(&self, ptr: NonNull<MaybeUninit<u8>>) -> usize {
+        if ptr == Self::DANGLE { return 0 }
+        unsafe { self.0.size_of(ptr) }
+    }
+}
+
+unsafe impl<A: thin::SizeOfDebug> thin::SizeOfDebug for DangleZst<A> {
+    unsafe fn size_of_debug(&self, ptr: NonNull<MaybeUninit<u8>>) -> Option<usize> {
+        if ptr == Self::DANGLE { return Some(0) }
+        unsafe { self.0.size_of_debug(ptr) }
     }
 }
 
@@ -114,42 +128,44 @@ unsafe impl<A: fat::Free> fat::Free for DangleZst<A> {
 
 unsafe impl<A: fat::Realloc> fat::Realloc for DangleZst<A> {
     unsafe fn realloc_uninit(&self, ptr: NonNull<MaybeUninit<u8>>, old_layout: Layout, new_layout: Layout) -> Result<NonNull<MaybeUninit<u8>>, Self::Error> {
-        if old_layout.size() > 0 && new_layout.size() > 0 {
-            unsafe { self.0.realloc_uninit(ptr, old_layout, new_layout) }
-        } else {
-            if cfg!(debug_assertions) && old_layout.size() == 0 {
-                if ptr != Self::DANGLE                          { bug::ub::invalid_ptr_for_allocator(ptr) }
-                if old_layout.align() > A::MAX_ALIGN.as_usize() { bug::ub::invalid_free_align_for_allocator(old_layout.align()) }
-            }
-            let alloc = self.alloc_uninit(new_layout)?;
-            let n = old_layout.size().min(new_layout.size());
-            {
-                let src : &    [MaybeUninit<u8>] = unsafe { core::slice::from_raw_parts    (ptr  .as_ptr(), n) };
-                let dst : &mut [MaybeUninit<u8>] = unsafe { core::slice::from_raw_parts_mut(alloc.as_ptr(), n) };
-                dst.copy_from_slice(src);
-            }
-            unsafe { self.free(ptr, old_layout) };
-            Ok(alloc)
+        let old_zst = old_layout.size() == 0;
+        let new_zst = new_layout.size() == 0;
+
+        if old_zst && cfg!(debug_assertions) {
+            if ptr != Self::DANGLE                          { bug::ub::invalid_ptr_for_allocator(ptr) }
+            if old_layout.align() > A::MAX_ALIGN.as_usize() { bug::ub::invalid_free_align_for_allocator(old_layout.align()) }
+        }
+
+        if new_zst && new_layout.align() > A::MAX_ALIGN.as_usize() {
+            return Err(ExcessiveAlignmentRequestedError{ requested: new_layout.into(), supported: A::MAX_ALIGN }.into())
+        }
+
+        match (old_zst, new_zst) {
+            (false, false) => unsafe { self.0.realloc_uninit(ptr, old_layout, new_layout)       },
+            (false, true ) => unsafe { self.0.free(ptr, old_layout); Ok(Self::DANGLE.cast())    },
+            (true,  false) =>        { self.0.alloc_uninit(new_layout)                          },
+            (true,  true ) =>        { Ok(Self::DANGLE.cast())                                  },
         }
     }
 
     unsafe fn realloc_zeroed(&self, ptr: NonNull<MaybeUninit<u8>>, old_layout: Layout, new_layout: Layout) -> Result<NonNull<MaybeUninit<u8>>, Self::Error> {
-        if old_layout.size() > 0 && new_layout.size() > 0 {
-            unsafe { self.0.realloc_zeroed(ptr, old_layout, new_layout) }
-        } else {
-            if cfg!(debug_assertions) && old_layout.size() == 0 {
-                if ptr != Self::DANGLE                          { bug::ub::invalid_ptr_for_allocator(ptr) }
-                if old_layout.align() > A::MAX_ALIGN.as_usize() { bug::ub::invalid_free_align_for_allocator(old_layout.align()) }
-            }
-            let alloc = self.alloc_zeroed(new_layout)?.cast();
-            let n = old_layout.size().min(new_layout.size());
-            {
-                let src : &    [MaybeUninit<u8>] = unsafe { core::slice::from_raw_parts    (ptr  .as_ptr(), n) };
-                let dst : &mut [MaybeUninit<u8>] = unsafe { core::slice::from_raw_parts_mut(alloc.as_ptr(), n) };
-                dst.copy_from_slice(src);
-            }
-            unsafe { self.free(ptr, old_layout) };
-            Ok(alloc)
+        let old_zst = old_layout.size() == 0;
+        let new_zst = new_layout.size() == 0;
+
+        if old_zst && cfg!(debug_assertions) {
+            if ptr != Self::DANGLE                          { bug::ub::invalid_ptr_for_allocator(ptr) }
+            if old_layout.align() > A::MAX_ALIGN.as_usize() { bug::ub::invalid_free_align_for_allocator(old_layout.align()) }
+        }
+
+        if new_zst && new_layout.align() > A::MAX_ALIGN.as_usize() {
+            return Err(ExcessiveAlignmentRequestedError{ requested: new_layout.into(), supported: A::MAX_ALIGN }.into())
+        }
+
+        match (old_zst, new_zst) {
+            (false, false) => unsafe { self.0.realloc_zeroed(ptr, old_layout, new_layout)       },
+            (false, true ) => unsafe { self.0.free(ptr, old_layout); Ok(Self::DANGLE.cast())    },
+            (true,  false) =>        { Ok(self.0.alloc_zeroed(new_layout)?.cast())              },
+            (true,  true ) =>        { Ok(Self::DANGLE.cast())                                  },
         }
     }
 }

src/allocator/c/malloc.rs

@@ -222,8 +222,6 @@ unsafe impl thin::SizeOfDebug for Malloc {
 #[test] fn thin_zeroed()                { thin::test::zeroed_alloc(Malloc) }
 #[test] fn thin_zeroed_realloc()        { thin::test::zeroed_realloc(Malloc) }
 #[test] fn thin_zst_support()           { thin::test::zst_supported_conservative(Malloc) }
-#[test] fn thin_zst_support_dangle()    { thin::test::zst_supported_conservative(crate::allocator::adapt::DangleZst(Malloc)) }
-#[test] fn thin_zst_support_alloc()     { thin::test::zst_supported_conservative(crate::allocator::adapt::AllocZst(Malloc)) }
 
 #[test] fn fat_alignment()              { fat::test::alignment(Malloc) }
 #[test] fn fat_edge_case_sizes()        { fat::test::edge_case_sizes(Malloc) }
@@ -232,5 +230,49 @@ unsafe impl thin::SizeOfDebug for Malloc {
 #[test] fn fat_zeroed()                 { fat::test::zeroed_alloc(Malloc) }
 #[test] fn fat_zeroed_realloc()         { fat::test::zeroed_realloc(Malloc) }
 #[test] fn fat_zst_support()            { fat::test::zst_supported_conservative(Malloc) }
-#[test] fn fat_zst_support_dangle()     { fat::test::zst_supported_conservative(crate::allocator::adapt::DangleZst(Malloc)) }
-#[test] fn fat_zst_support_alloc()      { fat::test::zst_supported_conservative(crate::allocator::adapt::AllocZst(Malloc)) }
+
+#[cfg(test)] mod adapt_alloc_zst {
+    use crate::allocator::adapt::AllocZst;
+    use super::{thin, fat, Malloc, MALLOC_ZERO_INITS};
+
+    #[test] fn thin_alignment()             { thin::test::alignment(AllocZst(Malloc)) }
+    #[test] fn thin_edge_case_sizes()       { thin::test::edge_case_sizes(AllocZst(Malloc)) }
+    #[test] fn thin_nullable()              { thin::test::nullable(AllocZst(Malloc)) }
+    #[test] fn thin_size()                  { thin::test::size_exact_alloc_except_zsts(AllocZst(Malloc)) }
+    #[test] fn thin_uninit()                { if !MALLOC_ZERO_INITS { unsafe { thin::test::uninit_alloc_unsound(AllocZst(Malloc)) } } }
+    #[test] fn thin_uninit_realloc()        { thin::test::uninit_realloc(AllocZst(Malloc)) }
+    #[test] fn thin_zeroed()                { thin::test::zeroed_alloc(AllocZst(Malloc)) }
+    #[test] fn thin_zeroed_realloc()        { thin::test::zeroed_realloc(AllocZst(Malloc)) }
+    #[test] fn thin_zst_support()           { thin::test::zst_supported_conservative(AllocZst(Malloc)) }
+
+    #[test] fn fat_alignment()              { fat::test::alignment(AllocZst(Malloc)) }
+    #[test] fn fat_edge_case_sizes()        { fat::test::edge_case_sizes(AllocZst(Malloc)) }
+    #[test] fn fat_uninit()                 { if !MALLOC_ZERO_INITS { unsafe { fat::test::uninit_alloc_unsound(AllocZst(Malloc)) } } }
+    #[test] fn fat_uninit_realloc()         { fat::test::uninit_realloc(AllocZst(Malloc)) }
+    #[test] fn fat_zeroed()                 { fat::test::zeroed_alloc(AllocZst(Malloc)) }
+    #[test] fn fat_zeroed_realloc()         { fat::test::zeroed_realloc(AllocZst(Malloc)) }
+    #[test] fn fat_zst_support()            { fat::test::zst_supported_conservative(AllocZst(Malloc)) }
+}
+
+#[cfg(test)] mod adapt_dangle_zst {
+    use crate::allocator::adapt::DangleZst;
+    use super::{thin, fat, Malloc, MALLOC_ZERO_INITS};
+
+    #[test] fn thin_alignment()             { thin::test::alignment(DangleZst(Malloc)) }
+    #[test] fn thin_edge_case_sizes()       { thin::test::edge_case_sizes(DangleZst(Malloc)) }
+    #[test] fn thin_nullable()              { thin::test::nullable(DangleZst(Malloc)) }
+    #[test] fn thin_size()                  { thin::test::size_exact_alloc(DangleZst(Malloc)) }
+    #[test] fn thin_uninit()                { if !MALLOC_ZERO_INITS { unsafe { thin::test::uninit_alloc_unsound(DangleZst(Malloc)) } } }
+    #[test] fn thin_uninit_realloc()        { thin::test::uninit_realloc(DangleZst(Malloc)) }
+    #[test] fn thin_zeroed()                { thin::test::zeroed_alloc(DangleZst(Malloc)) }
+    #[test] fn thin_zeroed_realloc()        { thin::test::zeroed_realloc(DangleZst(Malloc)) }
+    #[test] fn thin_zst_support()           { thin::test::zst_supported_conservative(DangleZst(Malloc)) }
+
+    #[test] fn fat_alignment()              { fat::test::alignment(DangleZst(Malloc)) }
+    #[test] fn fat_edge_case_sizes()        { fat::test::edge_case_sizes(DangleZst(Malloc)) }
+    #[test] fn fat_uninit()                 { if !MALLOC_ZERO_INITS { unsafe { fat::test::uninit_alloc_unsound(DangleZst(Malloc)) } } }
+    #[test] fn fat_uninit_realloc()         { fat::test::uninit_realloc(DangleZst(Malloc)) }
+    #[test] fn fat_zeroed()                 { fat::test::zeroed_alloc(DangleZst(Malloc)) }
+    #[test] fn fat_zeroed_realloc()         { fat::test::zeroed_realloc(DangleZst(Malloc)) }
+    #[test] fn fat_zst_support()            { fat::test::zst_supported_conservative(DangleZst(Malloc)) }
+}

src/util/nn.rs

@@ -23,3 +23,7 @@ pub /*const*/ fn slice_assume_init<T>(data: NonNull<[MaybeUninit<T>]>) -> NonNul
 pub fn dangling<T>(layout: Layout) -> NonNull<T> {
     NonNull::new(layout.align() as _).unwrap_or(NonNull::dangling())
 }
+
+// TODO: replace with NonNull::new when that stabilizes as a const fn
+pub const fn from_usize<T>(value: usize) -> Option<NonNull<T>> { from_ptr(value as *mut T) }
+pub const fn from_ptr<T>(ptr: *mut T) -> Option<NonNull<T>> { unsafe { core::mem::transmute(ptr) } }