Skip to content

A lightweight WebAssembly runtime that is fast, secure, and standards-compliant

Add some more OOM-handling `Box<[T]>` constructor variants (#12441)

Nick Fitzgerald35483cc40056
diff --git a/cranelift/bitset/src/compound.rs b/cranelift/bitset/src/compound.rs
index ed5991821f..5ebe10bf1f 100644
--- a/cranelift/bitset/src/compound.rs
+++ b/cranelift/bitset/src/compound.rs
@@ -295,7 +295,7 @@ impl<T: ScalarBitSetStorage> CompoundBitSet<T> {
let to_grow = cmp::max(to_grow, 4);
let new_len = self.elems.len() + to_grow;
- match wasmtime_core::alloc::new_boxed_slice_from_iter(
+ match wasmtime_core::alloc::new_boxed_slice_from_iter_with_len(
new_len,
self.elems
.iter()
@@ -306,8 +306,10 @@ impl<T: ScalarBitSetStorage> CompoundBitSet<T> {
self.elems = new_elems;
Ok(())
}
- Err(wasmtime_core::alloc::BoxedSliceFromIterError::Oom(oom)) => Err(oom),
- Err(wasmtime_core::alloc::BoxedSliceFromIterError::TooFewItems) => unreachable!(),
+ Err(wasmtime_core::alloc::BoxedSliceFromIterWithLenError::Oom(oom)) => Err(oom),
+ Err(wasmtime_core::alloc::BoxedSliceFromIterWithLenError::TooFewItems) => {
+ unreachable!()
+ }
}
}
diff --git a/crates/core/src/alloc.rs b/crates/core/src/alloc.rs
index e5260512e1..695c8bb398 100644
--- a/crates/core/src/alloc.rs
+++ b/crates/core/src/alloc.rs
@@ -5,7 +5,11 @@ mod boxed;
mod try_new;
mod vec;
-pub use boxed::{BoxedSliceFromIterError, new_boxed_slice_from_iter};
+pub use boxed::{
+ BoxedSliceFromFallibleIterError, BoxedSliceFromIterWithLenError,
+ new_boxed_slice_from_fallible_iter, new_boxed_slice_from_iter,
+ new_boxed_slice_from_iter_with_len,
+};
pub use try_new::{TryNew, try_new};
pub use vec::Vec;
diff --git a/crates/core/src/alloc/boxed.rs b/crates/core/src/alloc/boxed.rs
index 840e063fc7..c0d179214a 100644
--- a/crates/core/src/alloc/boxed.rs
+++ b/crates/core/src/alloc/boxed.rs
@@ -1,6 +1,9 @@
-use super::{TryNew, try_alloc};
+use super::{TryNew, Vec, try_alloc};
use crate::error::OutOfMemory;
-use core::{alloc::Layout, mem::MaybeUninit};
+use core::{
+ alloc::Layout,
+ mem::{self, MaybeUninit},
+};
use std_alloc::boxed::Box;
/// Allocate an `Box<MaybeUninit<T>>` with uninitialized contents, returning
@@ -39,63 +42,153 @@ impl<T> TryNew for Box<T> {
}
}
-fn new_uninit_boxed_slice<T>(len: usize) -> Result<Box<[MaybeUninit<T>]>, OutOfMemory> {
- let layout = Layout::array::<MaybeUninit<T>>(len)
- .map_err(|_| OutOfMemory::new(len.saturating_mul(core::mem::size_of::<T>())))?;
+use boxed_slice_builder::BoxedSliceBuilder;
+mod boxed_slice_builder {
+ use super::*;
- if layout.size() == 0 {
- // NB: no actual allocation takes place when boxing zero-sized
- // types.
- return Ok(Box::new_uninit_slice(len));
+ /// Builder for constructing and initalizing a boxed slice.
+ ///
+ /// Also acts as an RAII guard to handle dropping the already-initialized
+ /// elements when we get too few items or an iterator panics during
+ /// construction.
+ pub struct BoxedSliceBuilder<T> {
+ vec: Vec<T>,
}
- // Safety: we just ensured that the new length is non-zero.
- debug_assert_ne!(layout.size(), 0);
- let ptr = unsafe { try_alloc(layout)? };
+ impl<T> BoxedSliceBuilder<T> {
+ pub fn new(len: usize) -> Result<Self, OutOfMemory> {
+ let mut vec = Vec::new();
+ vec.reserve_exact(len)?;
+ Ok(BoxedSliceBuilder { vec })
+ }
+
+ pub fn init_len(&self) -> usize {
+ self.vec.len()
+ }
+
+ pub fn capacity(&self) -> usize {
+ self.vec.capacity()
+ }
+
+ pub fn push(&mut self, value: T) -> Result<(), OutOfMemory> {
+ self.vec.push(value)
+ }
+
+ /// Finish this builder and take its boxed slice out.
+ ///
+ /// Panics if `self.init_len() != self.capacity()`. Call
+ /// `self.shrink_to_fit()` if necessary.
+ pub fn finish(mut self) -> Box<[T]> {
+ assert_eq!(self.init_len(), self.capacity());
+ let vec = mem::take(&mut self.vec);
+ mem::forget(self);
+ let (ptr, len, cap) = vec.into_raw_parts();
+ debug_assert_eq!(len, cap);
+ let ptr = core::ptr::slice_from_raw_parts_mut(ptr, len);
+ unsafe { Box::from_raw(ptr) }
+ }
- let ptr = ptr.cast::<MaybeUninit<T>>().as_ptr();
- let ptr = core::ptr::slice_from_raw_parts_mut(ptr, len);
+ /// Shrink this builder's allocation such that `self.init_len() ==
+ /// self.capacity()`.
+ pub fn shrink_to_fit(&mut self) -> Result<(), OutOfMemory> {
+ if self.init_len() == self.capacity() {
+ return Ok(());
+ }
+
+ let len = self.init_len();
+ let cap = self.capacity();
+ let vec = mem::take(&mut self.vec);
+
+ let old_layout = Layout::array::<T>(cap).expect(
+ "already have an allocation with this layout so should be able to recreate it",
+ );
+ let new_layout = Layout::array::<T>(len)
+ .expect("if `cap` is fine for an array layout, then `len` must be as well");
+ debug_assert_eq!(old_layout.align(), new_layout.align());
+
+ // Handle zero-sized reallocations, since the global `realloc` function
+ // does not.
+ if new_layout.size() == 0 {
+ debug_assert!(mem::size_of::<T>() == 0 || len == 0);
+ if len == 0 {
+ debug_assert_eq!(self.capacity(), 0);
+ debug_assert_eq!(self.init_len(), 0);
+ } else {
+ debug_assert_eq!(mem::size_of::<T>(), 0);
+ let ptr = core::ptr::dangling_mut::<T>();
+ debug_assert!(!ptr.is_null());
+ debug_assert!(ptr.is_aligned());
+ // Safety: T's dangling pointer is always non-null and aligned.
+ self.vec = unsafe { Vec::from_raw_parts(ptr, len, len) };
+ }
+ debug_assert_eq!(self.capacity(), self.init_len());
+ return Ok(());
+ }
- // Safety: `ptr` points to a memory block that is valid for
- // `[MaybeUninit<T>; len]` and which was allocated by the global memory
- // allocator.
- let boxed = unsafe { Box::from_raw(ptr) };
- Ok(boxed)
+ let (ptr, _len, _cap) = vec.into_raw_parts();
+ debug_assert_eq!(len, _len);
+ debug_assert_eq!(cap, _cap);
+
+ // Safety: `ptr` was allocated by the global allocator, its memory block
+ // is described by `old_layout`, the new size is non-zero, and the new
+ // size will not overflow `isize::MAX` when rounded up to the layout's
+ // alignment (this is checked in the construction of `new_layout`).
+ let new_ptr = unsafe {
+ std_alloc::alloc::realloc(ptr.cast::<u8>(), old_layout, new_layout.size())
+ };
+
+ // Update `self` based on whether the reallocation succeeded or not,
+ // either inserting the new vec or reconstructing and replacing the
+ // old one.
+ if new_ptr.is_null() {
+ // Safety: The allocation failed so we retain ownership of `ptr`,
+ // which was a valid vec and we can safely make it a vec again.
+ self.vec = unsafe { Vec::from_raw_parts(ptr, len, cap) };
+ Err(OutOfMemory::new(new_layout.size()))
+ } else {
+ let new_ptr = new_ptr.cast::<T>();
+ // Safety: The allocation succeeded, `new_ptr` was reallocated by
+ // the global allocator and points to a valid boxed slice of length
+ // `len`.
+ self.vec = unsafe { Vec::from_raw_parts(new_ptr, len, len) };
+ debug_assert_eq!(self.capacity(), self.init_len());
+ Ok(())
+ }
+ }
+ }
}
/// An error returned by [`new_boxed_slice_from_iter`].
#[derive(Debug)]
-pub enum BoxedSliceFromIterError {
+pub enum BoxedSliceFromIterWithLenError {
/// The iterator did not yield enough items to fill the boxed slice.
TooFewItems,
/// Failed to allocate space for the boxed slice.
Oom(OutOfMemory),
}
-impl From<OutOfMemory> for BoxedSliceFromIterError {
+impl From<OutOfMemory> for BoxedSliceFromIterWithLenError {
fn from(oom: OutOfMemory) -> Self {
Self::Oom(oom)
}
}
-impl core::fmt::Display for BoxedSliceFromIterError {
+impl core::fmt::Display for BoxedSliceFromIterWithLenError {
fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
match self {
- BoxedSliceFromIterError::TooFewItems => {
+ Self::TooFewItems => {
f.write_str("The iterator did not yield enough items to fill the boxed slice")
}
- BoxedSliceFromIterError::Oom(_) => {
- f.write_str("Failed to allocate space for the boxed slice")
- }
+ Self::Oom(_) => f.write_str("Failed to allocate space for the boxed slice"),
}
}
}
-impl core::error::Error for BoxedSliceFromIterError {
+impl core::error::Error for BoxedSliceFromIterWithLenError {
fn cause(&self) -> Option<&dyn core::error::Error> {
match self {
- BoxedSliceFromIterError::TooFewItems => None,
- BoxedSliceFromIterError::Oom(oom) => Some(oom),
+ Self::TooFewItems => None,
+ Self::Oom(oom) => Some(oom),
}
}
}
@@ -107,68 +200,109 @@ impl core::error::Error for BoxedSliceFromIterError {
///
/// The iterator is dropped after `len` elements have been yielded, this
/// function does not check that the iterator yields exactly `len` elements.
-pub fn new_boxed_slice_from_iter<T>(
+pub fn new_boxed_slice_from_iter_with_len<T>(
len: usize,
iter: impl IntoIterator<Item = T>,
-) -> Result<Box<[T]>, BoxedSliceFromIterError> {
- /// RAII guard to handle dropping the initialized elements of the boxed
- /// slice in the cases where we get too few items or the iterator panics.
- struct DropGuard<T> {
- boxed: Box<[MaybeUninit<T>]>,
- init_len: usize,
+) -> Result<Box<[T]>, BoxedSliceFromIterWithLenError> {
+ let mut builder = BoxedSliceBuilder::new(len)?;
+ assert_eq!(len, builder.capacity());
+
+ for elem in iter.into_iter().take(len) {
+ builder.push(elem).expect("reserved capacity");
}
- impl<T> Drop for DropGuard<T> {
- fn drop(&mut self) {
- debug_assert!(self.init_len <= self.boxed.len());
+ if builder.init_len() < builder.capacity() {
+ return Err(BoxedSliceFromIterWithLenError::TooFewItems);
+ }
- if !core::mem::needs_drop::<T>() {
- return;
- }
+ debug_assert_eq!(builder.init_len(), builder.capacity());
+ Ok(builder.finish())
+}
- for elem in self.boxed.iter_mut().take(self.init_len) {
- // Safety: the elements in `self.boxed[..self.init_len]` are
- // valid and initialized and will not be used again.
- unsafe {
- core::ptr::drop_in_place(elem.as_mut_ptr());
- }
- }
+/// An error returned by [`new_boxed_slice_from_fallible_iter`].
+#[derive(Debug)]
+pub enum BoxedSliceFromFallibleIterError<E> {
+ /// The fallible iterator produced an error.
+ IterError(E),
+ /// Failed to allocate space for the boxed slice.
+ Oom(OutOfMemory),
+}
+
+impl<E> From<OutOfMemory> for BoxedSliceFromFallibleIterError<E> {
+ fn from(oom: OutOfMemory) -> Self {
+ Self::Oom(oom)
+ }
+}
+
+impl<E> core::fmt::Display for BoxedSliceFromFallibleIterError<E> {
+ fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+ match self {
+ Self::IterError(_) => f.write_str("The fallible iterator produced an error"),
+ Self::Oom(_) => f.write_str("Failed to allocate space for the boxed slice"),
}
}
+}
- let mut guard = DropGuard {
- boxed: new_uninit_boxed_slice(len)?,
- init_len: 0,
- };
- assert_eq!(len, guard.boxed.len());
+impl<E> core::error::Error for BoxedSliceFromFallibleIterError<E>
+where
+ E: core::error::Error,
+{
+ fn cause(&self) -> Option<&dyn core::error::Error> {
+ match self {
+ Self::IterError(e) => Some(e),
+ Self::Oom(oom) => Some(oom),
+ }
+ }
+}
- for (i, elem) in iter.into_iter().enumerate().take(len) {
- debug_assert!(i < len);
- debug_assert_eq!(guard.init_len, i);
- guard.boxed[i].write(elem);
- guard.init_len += 1;
+impl BoxedSliceFromFallibleIterError<OutOfMemory> {
+ /// Flatten this error into its inner OOM.
+ pub fn flatten(self) -> OutOfMemory {
+ match self {
+ Self::IterError(oom) | Self::Oom(oom) => oom,
+ }
}
+}
- debug_assert!(guard.init_len <= guard.boxed.len());
+/// Create a `Box<[T]>` from the given iterator's `Result<T, E>` items.
+///
+/// Returns an error on allocation failure or if an iterator item is an `Err`.
+pub fn new_boxed_slice_from_fallible_iter<T, E>(
+ iter: impl IntoIterator<Item = Result<T, E>>,
+) -> Result<Box<[T]>, BoxedSliceFromFallibleIterError<E>> {
+ let iter = iter.into_iter();
- if guard.init_len < guard.boxed.len() {
- return Err(BoxedSliceFromIterError::TooFewItems);
- }
+ let (min, max) = iter.size_hint();
+ let len = max.unwrap_or_else(|| min);
- debug_assert_eq!(guard.init_len, guard.boxed.len());
+ let mut builder = BoxedSliceBuilder::new(len)?;
+ assert_eq!(len, builder.capacity());
- // Take the boxed slice out of the guard.
- let boxed = {
- guard.init_len = 0;
- let boxed = core::mem::take(&mut guard.boxed);
- core::mem::forget(guard);
- boxed
- };
+ for result in iter {
+ let elem = result.map_err(BoxedSliceFromFallibleIterError::IterError)?;
+ builder.push(elem)?;
+ }
- // Safety: we initialized all elements.
- let boxed = unsafe { boxed.assume_init() };
+ debug_assert!(builder.init_len() <= builder.capacity());
+ builder.shrink_to_fit()?;
+ debug_assert_eq!(builder.init_len(), builder.capacity());
- Ok(boxed)
+ Ok(builder.finish())
+}
+
+/// Create a `Box<[T]>` from the given iterator's elements.
+///
+/// Returns an error on allocation failure.
+pub fn new_boxed_slice_from_iter<T>(
+ iter: impl IntoIterator<Item = T>,
+) -> Result<Box<[T]>, OutOfMemory> {
+ let iter = iter
+ .into_iter()
+ .map(Result::<T, core::convert::Infallible>::Ok);
+ new_boxed_slice_from_fallible_iter(iter).map_err(|e| match e {
+ BoxedSliceFromFallibleIterError::Oom(oom) => oom,
+ BoxedSliceFromFallibleIterError::IterError(_) => unreachable!(),
+ })
}
#[cfg(test)]
@@ -199,20 +333,20 @@ mod tests {
}
#[test]
- fn new_boxed_slice_from_iter_smoke_test() {
- let slice = new_boxed_slice_from_iter(3, [42, 36, 1337]).unwrap();
+ fn new_boxed_slice_from_iter_with_len_smoke_test() {
+ let slice = new_boxed_slice_from_iter_with_len(3, [42, 36, 1337]).unwrap();
assert_eq!(&*slice, &[42, 36, 1337]);
}
#[test]
- fn new_boxed_slice_from_iter_with_too_few_elems() {
+ fn new_boxed_slice_from_iter_with_len_with_too_few_elems() {
let (a_dropped, a) = SetFlagOnDrop::new();
let (b_dropped, b) = SetFlagOnDrop::new();
let (c_dropped, c) = SetFlagOnDrop::new();
- match new_boxed_slice_from_iter(4, [a, b, c]) {
- Err(BoxedSliceFromIterError::TooFewItems) => {}
- Ok(_) | Err(BoxedSliceFromIterError::Oom(_)) => unreachable!(),
+ match new_boxed_slice_from_iter_with_len(4, [a, b, c]) {
+ Err(BoxedSliceFromIterWithLenError::TooFewItems) => {}
+ Ok(_) | Err(BoxedSliceFromIterWithLenError::Oom(_)) => unreachable!(),
}
assert!(a_dropped.get());
@@ -221,12 +355,12 @@ mod tests {
}
#[test]
- fn new_boxed_slice_from_iter_with_too_many_elems() {
+ fn new_boxed_slice_from_iter_with_len_with_too_many_elems() {
let (a_dropped, a) = SetFlagOnDrop::new();
let (b_dropped, b) = SetFlagOnDrop::new();
let (c_dropped, c) = SetFlagOnDrop::new();
- let slice = new_boxed_slice_from_iter(2, [a, b, c]).unwrap();
+ let slice = new_boxed_slice_from_iter_with_len(2, [a, b, c]).unwrap();
assert!(!a_dropped.get());
assert!(!b_dropped.get());
@@ -238,4 +372,26 @@ mod tests {
assert!(b_dropped.get());
assert!(c_dropped.get());
}
+
+ #[test]
+ fn new_boxed_slice_from_iter_smoke_test() {
+ let slice = new_boxed_slice_from_iter([10, 20, 30]).unwrap();
+ assert_eq!(&*slice, &[10, 20, 30]);
+ }
+
+ #[test]
+ fn new_boxed_slice_from_fallible_iter_smoke_test() {
+ let slice =
+ new_boxed_slice_from_fallible_iter::<_, &str>([Ok(10), Ok(20), Ok(30)]).unwrap();
+ assert_eq!(&*slice, &[10, 20, 30]);
+ }
+
+ #[test]
+ fn new_boxed_slice_from_fallible_iter_error() {
+ let result = new_boxed_slice_from_fallible_iter::<_, u32>([Ok(10), Ok(20), Err(30)]);
+ let Err(BoxedSliceFromFallibleIterError::IterError(err)) = result else {
+ panic!("unexpected result: {result:?}");
+ };
+ assert_eq!(err, 30);
+ }
}
diff --git a/crates/core/src/alloc/vec.rs b/crates/core/src/alloc/vec.rs
index fc126892bb..82bdc8af69 100644
--- a/crates/core/src/alloc/vec.rs
+++ b/crates/core/src/alloc/vec.rs
@@ -1,6 +1,6 @@
use crate::error::OutOfMemory;
use core::{
- fmt,
+ fmt, mem,
ops::{Deref, DerefMut, Index, IndexMut},
};
use std_alloc::vec::Vec as StdVec;
@@ -47,7 +47,7 @@ impl<T> Vec<T> {
OutOfMemory::new(
self.len()
.saturating_add(additional)
- .saturating_mul(core::mem::size_of::<T>()),
+ .saturating_mul(mem::size_of::<T>()),
)
})
}
@@ -89,6 +89,7 @@ impl<T> Vec<T> {
let ptr = self.as_mut_ptr();
let len = self.len();
let cap = self.capacity();
+ mem::forget(self);
(ptr, len, cap)
}