A lightweight WebAssembly runtime that is fast, secure, and standards-compliant
Add some fallible allocation methods to `cranelift_entity::SecondaryMap` (#12453)
Nick Fitzgerald63ecb815c34c
diff --git a/cranelift/entity/src/map.rs b/cranelift/entity/src/map.rsindex 34ce35c778..965f8ac9f7 100644--- a/cranelift/entity/src/map.rs+++ b/cranelift/entity/src/map.rs@@ -15,6 +15,7 @@ use serde::{de::{Deserializer, SeqAccess, Visitor},ser::{SerializeSeq, Serializer},};+use wasmtime_core::error::OutOfMemory;/// A mapping `K -> V` for densely indexed entity references.///@@ -67,6 +68,22 @@ where}}+ /// Like `with_capacity` but returns an error on allocation failure.+ pub fn try_with_capacity(capacity: usize) -> Result<Self, OutOfMemory>+ where+ V: Default,+ {+ let mut elems = Vec::new();+ elems+ .try_reserve(capacity)+ .map_err(|_| OutOfMemory::new(core::mem::size_of::<V>().saturating_mul(capacity)))?;+ Ok(Self {+ elems,+ default: Default::default(),+ unused: PhantomData,+ })+ }+/// Create a new empty map with a specified default value.////// This constructor does not require V to implement Default.@@ -89,6 +106,35 @@ whereself.elems.get(k.index())}+ /// Get the element at `k` mutably, if it exists.+ pub fn get_mut(&mut self, k: K) -> Option<&mut V> {+ self.elems.get_mut(k.index())+ }++ /// Insert the given key-value pair, returning the old value if it exists.+ pub fn insert(&mut self, k: K, v: V) -> Option<V> {+ let i = k.index();+ if i < self.elems.len() {+ Some(core::mem::replace(&mut self.elems[i], v))+ } else {+ self.resize(i + 1);+ self.elems[i] = v;+ None+ }+ }++ /// Like `insert` but returns an error on allocation failure.+ pub fn try_insert(&mut self, k: K, v: V) -> Result<Option<V>, OutOfMemory> {+ let i = k.index();+ if i < self.elems.len() {+ Ok(Some(core::mem::replace(&mut self.elems[i], v)))+ } else {+ self.try_resize(i + 1)?;+ self.elems[i] = v;+ Ok(None)+ }+ }+/// Is this map completely empty?#[inline(always)]pub fn is_empty(&self) -> bool {@@ -131,6 +177,18 @@ whereself.elems.resize(n, self.default.clone());}+ /// Like `resize` but returns an error on allocation failure.+ pub fn try_resize(&mut self, n: usize) -> Result<(), OutOfMemory> {+ if self.elems.capacity() < n {+ self.elems+ .try_reserve(n - self.elems.len())+ .map_err(|_| OutOfMemory::new(core::mem::size_of::<V>().saturating_mul(n)))?;+ }+ debug_assert!(self.elems.capacity() >= n);+ self.elems.resize(n, self.default.clone());+ Ok(())+ }+/// Slow path for `index_mut` which resizes the vector.#[cold]fn resize_for_index_mut(&mut self, i: usize) -> &mut V {@@ -331,6 +389,7 @@ mod tests {let r0 = E(0);let r1 = E(1);let r2 = E(2);+ let r3 = E(3);let mut m = SecondaryMap::new();let v: Vec<E> = m.keys().collect();@@ -342,12 +401,30 @@ mod tests {assert_eq!(m[r1], 5);assert_eq!(m[r2], 3);+ assert!(m.get(r3).is_none());+ assert!(m.get_mut(r3).is_none());++ let old = m.insert(r3, 99);+ assert!(old.is_none());+ assert_eq!(m.get(r3), Some(&99));+ assert_eq!(m[r3], 99);++ *m.get_mut(r3).unwrap() += 1;+ assert_eq!(m.get(r3), Some(&100));+ assert_eq!(m[r3], 100);++ let old = m.insert(r3, 42);+ assert_eq!(old, Some(100));+ assert_eq!(m.get(r3), Some(&42));+ assert_eq!(m[r3], 42);+let v: Vec<E> = m.keys().collect();- assert_eq!(v, [r0, r1, r2]);+ assert_eq!(v, [r0, r1, r2, r3]);let shared = &m;assert_eq!(shared[r0], 0);assert_eq!(shared[r1], 5);assert_eq!(shared[r2], 3);+ assert_eq!(shared[r3], 42);}}diff --git a/crates/fuzzing/tests/oom.rs b/crates/fuzzing/tests/oom.rsindex 17d1b8b0b4..2e022e5aef 100644--- a/crates/fuzzing/tests/oom.rs+++ b/crates/fuzzing/tests/oom.rs@@ -5,7 +5,7 @@ use std::{sync::atomic::{AtomicU32, Ordering::SeqCst},};use wasmtime::{error::OutOfMemory, *};-use wasmtime_environ::{PrimaryMap, collections::*};+use wasmtime_environ::{PrimaryMap, SecondaryMap, collections::*};use wasmtime_fuzzing::oom::{OomTest, OomTestAllocator};#[global_allocator]@@ -68,12 +68,12 @@ fn compound_bit_set_try_ensure_capacity() -> Result<()> {})}+#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]+struct Key(u32);+wasmtime_environ::entity_impl!(Key);+#[test]fn primary_map_try_with_capacity() -> Result<()> {- #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]- struct Key(u32);- wasmtime_environ::entity_impl!(Key);-OomTest::new().test(|| {let _map = PrimaryMap::<Key, u32>::try_with_capacity(32)?;Ok(())@@ -82,10 +82,6 @@ fn primary_map_try_with_capacity() -> Result<()> {#[test]fn primary_map_try_reserve() -> Result<()> {- #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]- struct Key(u32);- wasmtime_environ::entity_impl!(Key);-OomTest::new().test(|| {let mut map = PrimaryMap::<Key, u32>::new();map.try_reserve(100)?;@@ -95,10 +91,6 @@ fn primary_map_try_reserve() -> Result<()> {#[test]fn primary_map_try_reserve_exact() -> Result<()> {- #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]- struct Key(u32);- wasmtime_environ::entity_impl!(Key);-OomTest::new().test(|| {let mut map = PrimaryMap::<Key, u32>::new();map.try_reserve_exact(13)?;@@ -106,6 +98,32 @@ fn primary_map_try_reserve_exact() -> Result<()> {})}+#[test]+fn secondary_map_try_with_capacity() -> Result<()> {+ OomTest::new().test(|| {+ let _map = SecondaryMap::<Key, u32>::try_with_capacity(32)?;+ Ok(())+ })+}++#[test]+fn secondary_map_try_resize() -> Result<()> {+ OomTest::new().test(|| {+ let mut map = SecondaryMap::<Key, u32>::new();+ map.try_resize(100)?;+ Ok(())+ })+}++#[test]+fn secondary_map_try_insert() -> Result<()> {+ OomTest::new().test(|| {+ let mut map = SecondaryMap::<Key, u32>::new();+ map.try_insert(Key::from_u32(42), 100)?;+ Ok(())+ })+}+#[test]fn vec_with_capacity() -> Result<()> {OomTest::new().test(|| {