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.rsindex 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.rsindex 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.rsindex 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.rsindex 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)}