Overhaul of the AllocRef trait to match allocator-wg's latest consens

src/liballoc/alloc.rs

@@ -2,7 +2,7 @@
 
 #![stable(feature = "alloc_module", since = "1.28.0")]
 
-use core::intrinsics::{min_align_of_val, size_of_val};
+use core::intrinsics::{self, min_align_of_val, size_of_val};
 use core::ptr::{NonNull, Unique};
 use core::usize;
 
@@ -165,11 +165,19 @@ pub unsafe fn alloc_zeroed(layout: Layout) -> *mut u8 {
 #[unstable(feature = "allocator_api", issue = "32838")]
 unsafe impl AllocRef for Global {
  #[inline]
- fn alloc(&mut self, layout: Layout) -> Result<(NonNull<u8>, usize), AllocErr> {
- if layout.size() == 0 {
+ fn alloc(&mut self, layout: Layout, init: AllocInit) -> Result<(NonNull<u8>, usize), AllocErr> {
+ let new_size = layout.size();
+ if new_size == 0 {
  Ok((layout.dangling(), 0))
  } else {
- unsafe { NonNull::new(alloc(layout)).ok_or(AllocErr).map(|p| (p, layout.size())) }
+ unsafe {
+ let raw_ptr = match init {
+ AllocInit::Uninitialized => alloc(layout),
+ AllocInit::Zeroed => alloc_zeroed(layout),
+ };
+ let ptr = NonNull::new(raw_ptr).ok_or(AllocErr)?;
+ Ok((ptr, new_size))
+ }
  }
  }
 
@@ -181,33 +189,77 @@ unsafe impl AllocRef for Global {
  }
 
  #[inline]
- unsafe fn realloc(
+ unsafe fn grow(
  &mut self,
  ptr: NonNull<u8>,
  layout: Layout,
  new_size: usize,
+ placement: ReallocPlacement,
+ init: AllocInit,
  ) -> Result<(NonNull<u8>, usize), AllocErr> {
- match (layout.size(), new_size) {
- (0, 0) => Ok((layout.dangling(), 0)),
- (0, _) => self.alloc(Layout::from_size_align_unchecked(new_size, layout.align())),
- (_, 0) => {
- self.dealloc(ptr, layout);
- Ok((layout.dangling(), 0))
+ let old_size = layout.size();
+ debug_assert!(
+ new_size >= old_size,
+ "`new_size` must be greater than or equal to `layout.size()`"
+ );
+
+ if old_size == new_size {
+ return Ok((ptr, new_size));
+ }
+
+ match placement {
+ ReallocPlacement::MayMove => {
+ if old_size == 0 {
+ self.alloc(Layout::from_size_align_unchecked(new_size, layout.align()), init)
+ } else {
+ // `realloc` probably checks for `new_size > old_size` or something similar.
+ // `new_size` must be greater than or equal to `old_size` due to the safety constraint,
+ // and `new_size` == `old_size` was caught before
+ intrinsics::assume(new_size > old_size);
+ let ptr =
+ NonNull::new(realloc(ptr.as_ptr(), layout, new_size)).ok_or(AllocErr)?;
+ let new_layout = Layout::from_size_align_unchecked(new_size, layout.align());
+ init.initialize_offset(ptr, new_layout, old_size);
+ Ok((ptr, new_size))
+ }
  }
- (_, _) => NonNull::new(realloc(ptr.as_ptr(), layout, new_size))
- .ok_or(AllocErr)
- .map(|p| (p, new_size)),
+ ReallocPlacement::InPlace => Err(AllocErr),
  }
  }
 
  #[inline]
- fn alloc_zeroed(&mut self, layout: Layout) -> Result<(NonNull<u8>, usize), AllocErr> {
- if layout.size() == 0 {
- Ok((layout.dangling(), 0))
+ unsafe fn shrink(
+ &mut self,
+ ptr: NonNull<u8>,
+ layout: Layout,
+ new_size: usize,
+ placement: ReallocPlacement,
+ ) -> Result<(NonNull<u8>, usize), AllocErr> {
+ let old_size = layout.size();
+ debug_assert!(
+ new_size <= old_size,
+ "`new_size` must be smaller than or equal to `layout.size()`"
+ );
+
+ if old_size == new_size {
+ return Ok((ptr, new_size));
+ }
+
+ match placement {
+ ReallocPlacement::MayMove => {
+ let ptr = if new_size == 0 {
+ self.dealloc(ptr, layout);
+ layout.dangling()
  } else {
- unsafe {
- NonNull::new(alloc_zeroed(layout)).ok_or(AllocErr).map(|p| (p, layout.size()))
+ // `realloc` probably checks for `new_size > old_size` or something similar.
+ // `new_size` must be smaller than or equal to `old_size` due to the safety constraint,
+ // and `new_size` == `old_size` was caught before
+ intrinsics::assume(new_size < old_size);
+ NonNull::new(realloc(ptr.as_ptr(), layout, new_size)).ok_or(AllocErr)?
+ };
+ Ok((ptr, new_size))
  }
+ ReallocPlacement::InPlace => Err(AllocErr),
  }
  }
 }
@@ -218,16 +270,12 @@ unsafe impl AllocRef for Global {
 #[lang = "exchange_malloc"]
 #[inline]
 unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
- if size == 0 {
- align as *mut u8
- } else {
  let layout = Layout::from_size_align_unchecked(size, align);
-  match Global.alloc(layout) {
+ match Global.alloc(layout, AllocInit::Uninitialized) {
  Ok((ptr, _)) => ptr.as_ptr(),
  Err(_) => handle_alloc_error(layout),
  }
 }
-}
 
 #[cfg_attr(not(test), lang = "box_free")]
 #[inline]
@@ -239,11 +287,8 @@ unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
 pub(crate) unsafe fn box_free<T: ?Sized>(ptr: Unique<T>) {
  let size = size_of_val(ptr.as_ref());
  let align = min_align_of_val(ptr.as_ref());
- // We do not allocate for Box<T> when T is ZST, so deallocation is also not necessary.
- if size != 0 {
  let layout = Layout::from_size_align_unchecked(size, align);
- Global.dealloc(ptr.cast().into(), layout);
- }
+ Global.dealloc(ptr.cast().into(), layout)
 }
 
 /// Abort on memory allocation error or failure.

src/liballoc/alloc/tests.rs

@@ -8,8 +8,9 @@ use test::Bencher;
 fn allocate_zeroed() {
  unsafe {
  let layout = Layout::from_size_align(1024, 1).unwrap();
- let (ptr, _) =
- Global.alloc_zeroed(layout.clone()).unwrap_or_else(|_| handle_alloc_error(layout));
+ let (ptr, _) = Global
+ .alloc(layout.clone(), AllocInit::Zeroed)
+ .unwrap_or_else(|_| handle_alloc_error(layout));
 
  let mut i = ptr.cast::<u8>().as_ptr();
  let end = i.add(layout.size());

src/liballoc/boxed.rs

@@ -146,7 +146,7 @@ use core::ptr::{self, NonNull, Unique};
 use core::slice;
 use core::task::{Context, Poll};
 
-use crate::alloc::{self, AllocRef, Global};
+use crate::alloc::{self, AllocInit, AllocRef, Global};
 use crate::raw_vec::RawVec;
 use crate::str::from_boxed_utf8_unchecked;
 use crate::vec::Vec;
@@ -196,14 +196,12 @@ impl<T> Box<T> {
  #[unstable(feature = "new_uninit", issue = "63291")]
  pub fn new_uninit() -> Box<mem::MaybeUninit<T>> {
  let layout = alloc::Layout::new::<mem::MaybeUninit<T>>();
- unsafe {
- let ptr = if layout.size() == 0 {
- NonNull::dangling()
- } else {
- Global.alloc(layout).unwrap_or_else(|_| alloc::handle_alloc_error(layout)).0.cast()
- };
- Box::from_raw(ptr.as_ptr())
- }
+ let ptr = Global
+ .alloc(layout, AllocInit::Uninitialized)
+ .unwrap_or_else(|_| alloc::handle_alloc_error(layout))
+ .0
+ .cast();
+ unsafe { Box::from_raw(ptr.as_ptr()) }
  }
 
  /// Constructs a new `Box` with uninitialized contents, with the memory
@@ -226,11 +224,13 @@ impl<T> Box<T> {
  /// [zeroed]: ../../std/mem/union.MaybeUninit.html#method.zeroed
  #[unstable(feature = "new_uninit", issue = "63291")]
  pub fn new_zeroed() -> Box<mem::MaybeUninit<T>> {
- unsafe {
- let mut uninit = Self::new_uninit();
- ptr::write_bytes::<T>(uninit.as_mut_ptr(), 0, 1);
- uninit
- }
+ let layout = alloc::Layout::new::<mem::MaybeUninit<T>>();
+ let ptr = Global
+ .alloc(layout, AllocInit::Zeroed)
+ .unwrap_or_else(|_| alloc::handle_alloc_error(layout))
+ .0
+ .cast();
+ unsafe { Box::from_raw(ptr.as_ptr()) }
  }
 
  /// Constructs a new `Pin<Box<T>>`. If `T` does not implement `Unpin`, then
@@ -266,14 +266,12 @@ impl<T> Box<[T]> {
  #[unstable(feature = "new_uninit", issue = "63291")]
  pub fn new_uninit_slice(len: usize) -> Box<[mem::MaybeUninit<T>]> {
  let layout = alloc::Layout::array::<mem::MaybeUninit<T>>(len).unwrap();
- unsafe {
- let ptr = if layout.size() == 0 {
- NonNull::dangling()
- } else {
- Global.alloc(layout).unwrap_or_else(|_| alloc::handle_alloc_error(layout)).0.cast()
- };
- Box::from_raw(slice::from_raw_parts_mut(ptr.as_ptr(), len))
- }
+ let ptr = Global
+ .alloc(layout, AllocInit::Uninitialized)
+ .unwrap_or_else(|_| alloc::handle_alloc_error(layout))
+ .0
+ .cast();
+ unsafe { Box::from_raw(slice::from_raw_parts_mut(ptr.as_ptr(), len)) }
  }
 }
 
@@ -778,7 +776,7 @@ impl<T: Copy> From<&[T]> for Box<[T]> {
  let buf = RawVec::with_capacity(len);
  unsafe {
  ptr::copy_nonoverlapping(slice.as_ptr(), buf.ptr(), len);
- buf.into_box()
+ buf.into_box().assume_init()
  }
  }
 }