use core::alloc::{AllocError, Allocator, GlobalAlloc, Layout};
use core::ptr::NonNull;
use crate::{Heap, NATURAL_ALIGN, RustyAlloc, WORD};
struct AbortOnUnwind;
impl Drop for AbortOnUnwind {
fn drop(&mut self) {
panic!("rusty_alloc: an Allocator method must not unwind; aborting");
}
}
#[inline(always)]
fn no_unwind<R>(body: impl FnOnce() -> R) -> R {
let guard = AbortOnUnwind;
let out = body();
core::mem::forget(guard);
out
}
#[inline]
fn zero_sized(layout: Layout) -> NonNull<[u8]> {
let p = core::ptr::without_provenance_mut::<u8>(layout.align());
let p = unsafe { NonNull::new_unchecked(p) };
NonNull::slice_from_raw_parts(p, 0)
}
#[inline]
fn block(p: *mut u8, size: usize) -> Result<NonNull<[u8]>, AllocError> {
match NonNull::new(p) {
Some(p) => Ok(NonNull::slice_from_raw_parts(p, size)),
None => Err(AllocError),
}
}
#[inline]
unsafe fn move_block<A: Allocator>(
a: &A,
ptr: NonNull<u8>,
old: Layout,
new: Layout,
keep: usize,
) -> Result<NonNull<[u8]>, AllocError> {
let moved = a.allocate(new)?;
unsafe {
core::ptr::copy_nonoverlapping(ptr.as_ptr(), moved.cast::<u8>().as_ptr(), keep);
a.deallocate(ptr, old);
}
Ok(moved)
}
#[inline]
unsafe fn zero_tail(block: NonNull<[u8]>, from: usize) {
unsafe {
block
.cast::<u8>()
.as_ptr()
.add(from)
.write_bytes(0, block.len() - from);
}
}
unsafe impl Allocator for RustyAlloc {
#[inline]
fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
no_unwind(|| {
if layout.size() == 0 {
return Ok(zero_sized(layout));
}
block(unsafe { GlobalAlloc::alloc(self, layout) }, layout.size())
})
}
#[inline]
fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
no_unwind(|| {
if layout.size() == 0 {
return Ok(zero_sized(layout));
}
block(
unsafe { GlobalAlloc::alloc_zeroed(self, layout) },
layout.size(),
)
})
}
#[inline]
unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
no_unwind(|| {
if layout.size() != 0 {
unsafe { GlobalAlloc::dealloc(self, ptr.as_ptr(), layout) }
}
})
}
#[inline]
unsafe fn grow(
&self,
ptr: NonNull<u8>,
old_layout: Layout,
new_layout: Layout,
) -> Result<NonNull<[u8]>, AllocError> {
no_unwind(|| {
if old_layout.size() == 0 {
return self.allocate(new_layout);
}
if old_layout.align() == new_layout.align() {
let p = unsafe {
GlobalAlloc::realloc(self, ptr.as_ptr(), old_layout, new_layout.size())
};
return block(p, new_layout.size());
}
unsafe { move_block(self, ptr, old_layout, new_layout, old_layout.size()) }
})
}
#[inline]
unsafe fn grow_zeroed(
&self,
ptr: NonNull<u8>,
old_layout: Layout,
new_layout: Layout,
) -> Result<NonNull<[u8]>, AllocError> {
no_unwind(|| {
if old_layout.size() == 0 {
return self.allocate_zeroed(new_layout);
}
let grown = unsafe { self.grow(ptr, old_layout, new_layout)? };
unsafe { zero_tail(grown, old_layout.size()) };
Ok(grown)
})
}
#[inline]
unsafe fn shrink(
&self,
ptr: NonNull<u8>,
old_layout: Layout,
new_layout: Layout,
) -> Result<NonNull<[u8]>, AllocError> {
no_unwind(|| {
if new_layout.size() == 0 {
unsafe { self.deallocate(ptr, old_layout) };
return Ok(zero_sized(new_layout));
}
if old_layout.align() == new_layout.align() {
let p = unsafe {
GlobalAlloc::realloc(self, ptr.as_ptr(), old_layout, new_layout.size())
};
return block(p, new_layout.size());
}
unsafe { move_block(self, ptr, old_layout, new_layout, new_layout.size()) }
})
}
}
impl Heap {
#[inline]
unsafe fn realloc_same_align(
&self,
ptr: NonNull<u8>,
old_size: usize,
align: usize,
new_size: usize,
) -> *mut u8 {
if align <= NATURAL_ALIGN {
let size = if align <= WORD {
new_size
} else {
new_size.max(NATURAL_ALIGN)
};
return unsafe { rusty_alloc::alloc::heap_realloc_fast(self.hb, ptr, size) };
}
let usable = unsafe { rusty_alloc::alloc::usable_size(ptr.as_ptr()) };
if new_size <= usable && new_size >= usable / 2 {
return ptr.as_ptr();
}
let moved =
unsafe { rusty_alloc::alloc::heap_malloc_aligned_at(self.hb, new_size, align, 0) };
if !moved.is_null() {
unsafe {
core::ptr::copy_nonoverlapping(ptr.as_ptr(), moved, old_size.min(new_size));
rusty_alloc::alloc::free(ptr.as_ptr());
}
}
moved
}
}
unsafe impl Allocator for Heap {
#[inline]
fn allocate(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
no_unwind(|| {
if layout.size() == 0 {
return Ok(zero_sized(layout));
}
match self.alloc(layout) {
Some(p) => Ok(NonNull::slice_from_raw_parts(p, layout.size())),
None => Err(AllocError),
}
})
}
#[inline]
fn allocate_zeroed(&self, layout: Layout) -> Result<NonNull<[u8]>, AllocError> {
no_unwind(|| {
if layout.size() == 0 {
return Ok(zero_sized(layout));
}
match self.alloc_zeroed(layout) {
Some(p) => Ok(NonNull::slice_from_raw_parts(p, layout.size())),
None => Err(AllocError),
}
})
}
#[inline]
unsafe fn deallocate(&self, ptr: NonNull<u8>, layout: Layout) {
no_unwind(|| {
if layout.size() != 0 {
unsafe { self.dealloc(ptr) }
}
})
}
#[inline]
unsafe fn grow(
&self,
ptr: NonNull<u8>,
old_layout: Layout,
new_layout: Layout,
) -> Result<NonNull<[u8]>, AllocError> {
no_unwind(|| {
if old_layout.size() == 0 {
return self.allocate(new_layout);
}
if old_layout.align() == new_layout.align() {
let p = unsafe {
self.realloc_same_align(
ptr,
old_layout.size(),
new_layout.align(),
new_layout.size(),
)
};
return block(p, new_layout.size());
}
unsafe { move_block(self, ptr, old_layout, new_layout, old_layout.size()) }
})
}
#[inline]
unsafe fn grow_zeroed(
&self,
ptr: NonNull<u8>,
old_layout: Layout,
new_layout: Layout,
) -> Result<NonNull<[u8]>, AllocError> {
no_unwind(|| {
if old_layout.size() == 0 {
return self.allocate_zeroed(new_layout);
}
let grown = unsafe { self.grow(ptr, old_layout, new_layout)? };
unsafe { zero_tail(grown, old_layout.size()) };
Ok(grown)
})
}
#[inline]
unsafe fn shrink(
&self,
ptr: NonNull<u8>,
old_layout: Layout,
new_layout: Layout,
) -> Result<NonNull<[u8]>, AllocError> {
no_unwind(|| {
if new_layout.size() == 0 {
unsafe { self.deallocate(ptr, old_layout) };
return Ok(zero_sized(new_layout));
}
if old_layout.align() == new_layout.align() {
let p = unsafe {
self.realloc_same_align(
ptr,
old_layout.size(),
new_layout.align(),
new_layout.size(),
)
};
return block(p, new_layout.size());
}
unsafe { move_block(self, ptr, old_layout, new_layout, new_layout.size()) }
})
}
}
#[cfg(test)]
mod tests {
use super::no_unwind;
#[test]
#[cfg_attr(miri, ignore = "spawns a process")]
fn an_unwind_out_of_a_method_aborts() {
const CHILD: &str = "RA_NO_UNWIND_CHILD";
if std::env::var_os(CHILD).is_some() {
no_unwind(|| panic!("deliberate: the guard must abort on this"));
}
let exe = std::env::current_exe().expect("the test binary's own path");
let out = std::process::Command::new(exe)
.args([
"--exact",
"allocator::tests::an_unwind_out_of_a_method_aborts",
])
.env(CHILD, "1")
.output()
.expect("spawn the child");
assert!(
!out.status.success(),
"the child survived a panic in a guarded body"
);
assert_ne!(
out.status.code(),
Some(101),
"the panic unwound to the harness instead of aborting"
);
}
}