Skip to content

Commit 9546c3f

Browse files
committed
Do not allocate for ZST ThinBox attempt 2 (using const_allocate)
There's PR #123184 which avoids allocation for ZST ThinBox. That PR has an issue with unsoundness with misuse of `MaybeUninit` (see comments in that PR). This PR is much simpler implementation which does not have this problem, but it uses `const_allocate` feature.
1 parent 204805a commit 9546c3f

File tree

2 files changed

+74
-13
lines changed

2 files changed

+74
-13
lines changed

library/alloc/src/boxed/thin.rs

+72-13
Original file line numberDiff line numberDiff line change
@@ -4,10 +4,14 @@
44
use crate::alloc::{self, Layout, LayoutError};
55
use core::error::Error;
66
use core::fmt::{self, Debug, Display, Formatter};
7+
#[cfg(not(no_global_oom_handling))]
8+
use core::intrinsics::const_allocate;
79
use core::marker::PhantomData;
810
#[cfg(not(no_global_oom_handling))]
911
use core::marker::Unsize;
10-
use core::mem::{self, SizedTypeProperties};
12+
use core::mem;
13+
#[cfg(not(no_global_oom_handling))]
14+
use core::mem::SizedTypeProperties;
1115
use core::ops::{Deref, DerefMut};
1216
use core::ptr::Pointee;
1317
use core::ptr::{self, NonNull};
@@ -91,6 +95,58 @@ impl<T> ThinBox<T> {
9195

9296
#[unstable(feature = "thin_box", issue = "92791")]
9397
impl<Dyn: ?Sized> ThinBox<Dyn> {
98+
#[cfg(not(no_global_oom_handling))]
99+
fn new_unsize_zst<T>(value: T) -> Self
100+
where
101+
T: Unsize<Dyn>,
102+
{
103+
assert!(mem::size_of::<T>() == 0);
104+
105+
const fn max(a: usize, b: usize) -> usize {
106+
if a > b { a } else { b }
107+
}
108+
109+
let alloc: &<Dyn as Pointee>::Metadata = const {
110+
// ZST T pointer must be aligned to both the value and the metadata.
111+
// Metadata must be at the address `&T - size_of::<Metadata>`.
112+
// This is how we need to allocate the memory:
113+
// [ padding | metadata | ZST T value ]
114+
115+
// FIXME: just call `WithHeader::alloc_layout` with size reset to 0.
116+
// Currently that's blocked on `Layout::extend` not being `const fn`.
117+
118+
let alloc_align =
119+
max(mem::align_of::<T>(), mem::align_of::<<Dyn as Pointee>::Metadata>());
120+
121+
let alloc_size =
122+
max(mem::align_of::<T>(), mem::size_of::<<Dyn as Pointee>::Metadata>());
123+
124+
unsafe {
125+
// SAFETY: align is power of two because it is the maximum of two alignments.
126+
let alloc: *mut u8 = const_allocate(alloc_size, alloc_align);
127+
128+
let metadata_offset =
129+
alloc_size.checked_sub(mem::size_of::<<Dyn as Pointee>::Metadata>()).unwrap();
130+
// SAFETY: adding offset within the allocation.
131+
let metadata_ptr: *mut <Dyn as Pointee>::Metadata =
132+
alloc.add(metadata_offset).cast();
133+
// SAFETY: `*metadata_ptr` is within the allocation.
134+
metadata_ptr.write(ptr::metadata::<Dyn>(ptr::dangling::<T>() as *const Dyn));
135+
136+
// SAFETY: we have just written the metadata.
137+
&*(metadata_ptr)
138+
}
139+
};
140+
141+
// SAFETY: `alloc` points to `<Dyn as Pointee>::Metadata`, so addition does not overflow.
142+
let value_ptr =
143+
unsafe { (alloc as *const <Dyn as Pointee>::Metadata).add(1) }.cast::<u8>().cast_mut();
144+
let ptr = WithOpaqueHeader(NonNull::new(value_ptr).unwrap());
145+
// Forget the value to avoid double drop.
146+
mem::forget(value);
147+
ThinBox::<Dyn> { ptr, _marker: PhantomData }
148+
}
149+
94150
/// Moves a type to the heap with its [`Metadata`] stored in the heap allocation instead of on
95151
/// the stack.
96152
///
@@ -109,9 +165,13 @@ impl<Dyn: ?Sized> ThinBox<Dyn> {
109165
where
110166
T: Unsize<Dyn>,
111167
{
112-
let meta = ptr::metadata(&value as &Dyn);
113-
let ptr = WithOpaqueHeader::new(meta, value);
114-
ThinBox { ptr, _marker: PhantomData }
168+
if mem::size_of::<T>() == 0 {
169+
Self::new_unsize_zst(value)
170+
} else {
171+
let meta = ptr::metadata(&value as &Dyn);
172+
let ptr = WithOpaqueHeader::new(meta, value);
173+
ThinBox { ptr, _marker: PhantomData }
174+
}
115175
}
116176
}
117177

@@ -300,20 +360,19 @@ impl<H> WithHeader<H> {
300360

301361
impl<H> Drop for DropGuard<H> {
302362
fn drop(&mut self) {
363+
// All ZST are allocated statically.
364+
if self.value_layout.size() == 0 {
365+
return;
366+
}
367+
303368
unsafe {
304369
// SAFETY: Layout must have been computable if we're in drop
305370
let (layout, value_offset) =
306371
WithHeader::<H>::alloc_layout(self.value_layout).unwrap_unchecked();
307372

308-
// Note: Don't deallocate if the layout size is zero, because the pointer
309-
// didn't come from the allocator.
310-
if layout.size() != 0 {
311-
alloc::dealloc(self.ptr.as_ptr().sub(value_offset), layout);
312-
} else {
313-
debug_assert!(
314-
value_offset == 0 && H::IS_ZST && self.value_layout.size() == 0
315-
);
316-
}
373+
// Since we only allocate for non-ZSTs, the layout size cannot be zero.
374+
debug_assert!(layout.size() != 0);
375+
alloc::dealloc(self.ptr.as_ptr().sub(value_offset), layout);
317376
}
318377
}
319378
}

library/alloc/src/lib.rs

+2
Original file line numberDiff line numberDiff line change
@@ -114,8 +114,10 @@
114114
#![feature(const_box)]
115115
#![feature(const_cow_is_borrowed)]
116116
#![feature(const_eval_select)]
117+
#![feature(const_heap)]
117118
#![feature(const_maybe_uninit_as_mut_ptr)]
118119
#![feature(const_maybe_uninit_write)]
120+
#![feature(const_option)]
119121
#![feature(const_pin)]
120122
#![feature(const_refs_to_cell)]
121123
#![feature(const_size_of_val)]

0 commit comments

Comments
 (0)