Skip to content

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

Change `{Memory,Table}Type::new` to return `Result` (#14591)

Alex Crichtonddf01e51152c
diff --git a/crates/c-api/include/doc-wasm.h b/crates/c-api/include/doc-wasm.h
index 4a92d15d77..24c3e283ed 100644
--- a/crates/c-api/include/doc-wasm.h
+++ b/crates/c-api/include/doc-wasm.h
@@ -510,6 +510,9 @@
* This function takes ownership of the #wasm_valtype_t argument, but does not
* take ownership of the #wasm_limits_t.
*
+ * Returns `NULL` if the value type is not a reference type or if the limits
+ * are invalid (e.g. the minimum is greater than the maximum).
+ *
* The caller is responsible for deallocating the returned type.
*
* \fn const wasm_valtype_t* wasm_tabletype_element(const wasm_tabletype_t *);
@@ -596,6 +599,9 @@
* This function takes ownership of the #wasm_valtype_t argument, but does not
* take ownership of the #wasm_limits_t.
*
+ * Returns `NULL` if the limits are invalid (e.g. the minimum is greater than
+ * the maximum or the limits exceed the 32-bit address space).
+ *
* The caller is responsible for deallocating the returned type.
*
* For compatibility with memory64 it's recommended to use
diff --git a/crates/c-api/src/types/memory.rs b/crates/c-api/src/types/memory.rs
index 663fdd6b6e..f0b0929e75 100644
--- a/crates/c-api/src/types/memory.rs
+++ b/crates/c-api/src/types/memory.rs
@@ -49,11 +49,9 @@ impl CMemoryType {
}
#[unsafe(no_mangle)]
-pub extern "C" fn wasm_memorytype_new(limits: &wasm_limits_t) -> Box<wasm_memorytype_t> {
- Box::new(wasm_memorytype_t::new(MemoryType::new(
- limits.min,
- limits.max(),
- )))
+pub extern "C" fn wasm_memorytype_new(limits: &wasm_limits_t) -> Option<Box<wasm_memorytype_t>> {
+ let ty = MemoryType::new(limits.min, limits.max()).ok()?;
+ Some(Box::new(wasm_memorytype_t::new(ty)))
}
#[unsafe(no_mangle)]
diff --git a/crates/c-api/src/types/table.rs b/crates/c-api/src/types/table.rs
index 48173f86ee..55b057a94f 100644
--- a/crates/c-api/src/types/table.rs
+++ b/crates/c-api/src/types/table.rs
@@ -55,11 +55,8 @@ pub extern "C" fn wasm_tabletype_new(
limits: &wasm_limits_t,
) -> Option<Box<wasm_tabletype_t>> {
let ty = (*ty).as_ref()?.clone();
- Some(Box::new(wasm_tabletype_t::new(TableType::new(
- ty,
- limits.min,
- limits.max(),
- ))))
+ let ty = TableType::new(ty, limits.min, limits.max()).ok()?;
+ Some(Box::new(wasm_tabletype_t::new(ty)))
}
#[unsafe(no_mangle)]
diff --git a/crates/fuzzing/src/oracles/api.rs b/crates/fuzzing/src/oracles/api.rs
index 2fcacd0b96..167e09a51c 100644
--- a/crates/fuzzing/src/oracles/api.rs
+++ b/crates/fuzzing/src/oracles/api.rs
@@ -269,7 +269,7 @@ pub fn make_api_calls(api: ApiCalls) {
ApiCall::TableTypeNew { id, nullable } => {
log::trace!("creating table type {id}");
let element = RefType::new(nullable, HeapType::Func);
- let old = table_types.insert(id, TableType::new(element, 0, None));
+ let old = table_types.insert(id, TableType::new(element, 0, None).unwrap());
assert!(old.is_none());
}
@@ -404,7 +404,7 @@ pub fn make_api_calls(api: ApiCalls) {
maximum,
} => {
log::trace!("creating memory type {id}");
- let old = memory_types.insert(id, MemoryType::new(minimum, maximum));
+ let old = memory_types.insert(id, MemoryType::new(minimum, maximum).unwrap());
assert!(old.is_none());
}
diff --git a/crates/fuzzing/src/oracles/dummy.rs b/crates/fuzzing/src/oracles/dummy.rs
index 11918e4572..301834dbf4 100644
--- a/crates/fuzzing/src/oracles/dummy.rs
+++ b/crates/fuzzing/src/oracles/dummy.rs
@@ -35,7 +35,7 @@ mod tests {
#[test]
fn dummy_table_import() {
let mut store = store();
- let table_type = TableType::new(RefType::EXTERNREF, 10, None);
+ let table_type = TableType::new(RefType::EXTERNREF, 10, None).unwrap();
let table = table_type.default_value(&mut store).unwrap();
assert_eq!(table.size(&store), 10);
for i in 0..10 {
@@ -55,7 +55,7 @@ mod tests {
#[test]
fn dummy_memory_import() {
let mut store = store();
- let memory_type = MemoryType::new(1, None);
+ let memory_type = MemoryType::new(1, None).unwrap();
let memory = memory_type
.default_value(&mut store)
.unwrap()
diff --git a/crates/fuzzing/tests/oom/memory.rs b/crates/fuzzing/tests/oom/memory.rs
index a2361a7130..8f986cb96d 100644
--- a/crates/fuzzing/tests/oom/memory.rs
+++ b/crates/fuzzing/tests/oom/memory.rs
@@ -16,7 +16,7 @@ fn memory_new() -> Result<()> {
.allow_alloc_after_oom(true)
.test(|| {
let mut store = Store::try_new(&engine, ())?;
- let _memory = Memory::new(&mut store, MemoryType::new(1, None))?;
+ let _memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;
Ok(())
})
}
@@ -32,7 +32,7 @@ async fn memory_new_async() -> Result<()> {
.allow_alloc_after_oom(true)
.test_async(|| async {
let mut store = Store::try_new(&engine, ())?;
- let _memory = Memory::new_async(&mut store, MemoryType::new(1, None)).await?;
+ let _memory = Memory::new_async(&mut store, MemoryType::new(1, None)?).await?;
Ok(())
})
.await
@@ -47,7 +47,7 @@ fn memory_grow() -> Result<()> {
OomTest::new().allow_alloc_after_oom(true).test(|| {
let mut store = Store::try_new(&engine, ())?;
- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;
+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;
let _old_size = memory.grow(&mut store, 1)?;
Ok(())
})
@@ -64,7 +64,7 @@ async fn memory_grow_async() -> Result<()> {
.allow_alloc_after_oom(true)
.test_async(|| async {
let mut store = Store::try_new(&engine, ())?;
- let memory = Memory::new_async(&mut store, MemoryType::new(1, None)).await?;
+ let memory = Memory::new_async(&mut store, MemoryType::new(1, None)?).await?;
let _old_size = memory.grow_async(&mut store, 1).await?;
Ok(())
})
@@ -80,7 +80,7 @@ fn memory_ty() -> Result<()> {
OomTest::new().allow_alloc_after_oom(true).test(|| {
let mut store = Store::try_new(&engine, ())?;
- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;
+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;
let _ty = memory.ty(&store);
Ok(())
})
@@ -95,7 +95,7 @@ fn memory_size() -> Result<()> {
OomTest::new().allow_alloc_after_oom(true).test(|| {
let mut store = Store::try_new(&engine, ())?;
- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;
+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;
assert_eq!(memory.size(&store), 1);
Ok(())
})
@@ -110,7 +110,7 @@ fn memory_data_size() -> Result<()> {
OomTest::new().allow_alloc_after_oom(true).test(|| {
let mut store = Store::try_new(&engine, ())?;
- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;
+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;
assert_eq!(memory.data_size(&store), 65536);
Ok(())
})
@@ -125,7 +125,7 @@ fn memory_read_write() -> Result<()> {
OomTest::new().allow_alloc_after_oom(true).test(|| {
let mut store = Store::try_new(&engine, ())?;
- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;
+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;
memory.write(&mut store, 0, &[1, 2, 3, 4])?;
let mut buf = [0u8; 4];
memory.read(&store, 0, &mut buf)?;
@@ -143,7 +143,7 @@ fn memory_data() -> Result<()> {
OomTest::new().allow_alloc_after_oom(true).test(|| {
let mut store = Store::try_new(&engine, ())?;
- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;
+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;
let data = memory.data(&store);
assert_eq!(data.len(), 65536);
Ok(())
@@ -159,7 +159,7 @@ fn memory_data_mut() -> Result<()> {
OomTest::new().allow_alloc_after_oom(true).test(|| {
let mut store = Store::try_new(&engine, ())?;
- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;
+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;
let data = memory.data_mut(&mut store);
data[0] = 42;
assert_eq!(data[0], 42);
diff --git a/crates/fuzzing/tests/oom/table.rs b/crates/fuzzing/tests/oom/table.rs
index b797dfe6e3..abd2bcfc04 100644
--- a/crates/fuzzing/tests/oom/table.rs
+++ b/crates/fuzzing/tests/oom/table.rs
@@ -16,7 +16,7 @@ fn table_new() -> Result<()> {
.allow_alloc_after_oom(true)
.test(|| {
let mut store = Store::try_new(&engine, ())?;
- let ty = TableType::new(RefType::FUNCREF, 1, None);
+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;
let _table = wasmtime::Table::new(&mut store, ty, Ref::Func(None))?;
Ok(())
})
@@ -33,7 +33,7 @@ async fn table_new_async() -> Result<()> {
.allow_alloc_after_oom(true)
.test_async(|| async {
let mut store = Store::try_new(&engine, ())?;
- let ty = TableType::new(RefType::FUNCREF, 1, None);
+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;
let _table = Table::new_async(&mut store, ty, Ref::Func(None)).await?;
Ok(())
})
@@ -49,7 +49,7 @@ fn table_grow() -> Result<()> {
OomTest::new().allow_alloc_after_oom(true).test(|| {
let mut store = Store::try_new(&engine, ())?;
- let ty = TableType::new(RefType::FUNCREF, 1, None);
+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;
let table = Table::new(&mut store, ty, Ref::Func(None))?;
let _old_size = table.grow(&mut store, 4, Ref::Func(None))?;
Ok(())
@@ -67,7 +67,7 @@ async fn table_grow_async() -> Result<()> {
.allow_alloc_after_oom(true)
.test_async(|| async {
let mut store = Store::try_new(&engine, ())?;
- let ty = TableType::new(RefType::FUNCREF, 1, None);
+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;
let table = Table::new_async(&mut store, ty, Ref::Func(None)).await?;
let _old_size = table.grow_async(&mut store, 4, Ref::Func(None)).await?;
Ok(())
@@ -84,7 +84,7 @@ fn table_set() -> Result<()> {
OomTest::new().allow_alloc_after_oom(true).test(|| {
let mut store = Store::try_new(&engine, ())?;
- let ty = TableType::new(RefType::FUNCREF, 1, None);
+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;
let table = Table::new(&mut store, ty, Ref::Func(None))?;
table.set(&mut store, 0, Ref::Func(None))?;
Ok(())
@@ -100,7 +100,7 @@ fn table_copy() -> Result<()> {
OomTest::new().allow_alloc_after_oom(true).test(|| {
let mut store = Store::try_new(&engine, ())?;
- let ty = TableType::new(RefType::FUNCREF, 4, None);
+ let ty = TableType::new(RefType::FUNCREF, 4, None)?;
let table = Table::new(&mut store, ty, Ref::Func(None))?;
Table::copy(&mut store, &table, 0, &table, 2, 2)?;
Ok(())
@@ -116,7 +116,7 @@ fn table_fill() -> Result<()> {
OomTest::new().allow_alloc_after_oom(true).test(|| {
let mut store = Store::try_new(&engine, ())?;
- let ty = TableType::new(RefType::FUNCREF, 4, None);
+ let ty = TableType::new(RefType::FUNCREF, 4, None)?;
let table = Table::new(&mut store, ty, Ref::Func(None))?;
table.fill(&mut store, 0, Ref::Func(None), 4)?;
Ok(())
@@ -132,7 +132,7 @@ fn table_get() -> Result<()> {
OomTest::new().allow_alloc_after_oom(true).test(|| {
let mut store = Store::try_new(&engine, ())?;
- let ty = TableType::new(RefType::FUNCREF, 1, None);
+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;
let table = Table::new(&mut store, ty, Ref::Func(None))?;
let val = table.get(&mut store, 0);
assert!(val.is_some());
@@ -149,7 +149,7 @@ fn table_ty() -> Result<()> {
OomTest::new().allow_alloc_after_oom(true).test(|| {
let mut store = Store::try_new(&engine, ())?;
- let ty = TableType::new(RefType::FUNCREF, 1, None);
+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;
let table = Table::new(&mut store, ty, Ref::Func(None))?;
let _ty = table.ty(&store);
Ok(())
@@ -165,7 +165,7 @@ fn table_size() -> Result<()> {
OomTest::new().allow_alloc_after_oom(true).test(|| {
let mut store = Store::try_new(&engine, ())?;
- let ty = TableType::new(RefType::FUNCREF, 2, None);
+ let ty = TableType::new(RefType::FUNCREF, 2, None)?;
let table = Table::new(&mut store, ty, Ref::Func(None))?;
assert_eq!(table.size(&store), 2);
Ok(())
diff --git a/crates/fuzzing/tests/oom/types.rs b/crates/fuzzing/tests/oom/types.rs
index ff5a156bbc..47c8d00b35 100644
--- a/crates/fuzzing/tests/oom/types.rs
+++ b/crates/fuzzing/tests/oom/types.rs
@@ -22,7 +22,7 @@ fn func_type_params_results() -> Result<()> {
#[test]
fn table_type_accessors() -> Result<()> {
OomTest::new().test(|| {
- let ty = TableType::new(RefType::FUNCREF, 1, Some(10));
+ let ty = TableType::new(RefType::FUNCREF, 1, Some(10))?;
assert_eq!(ty.minimum(), 1);
assert_eq!(ty.maximum(), Some(10));
Ok(())
@@ -32,7 +32,7 @@ fn table_type_accessors() -> Result<()> {
#[test]
fn memory_type_accessors() -> Result<()> {
OomTest::new().test(|| {
- let ty = MemoryType::new(1, Some(10));
+ let ty = MemoryType::new(1, Some(10))?;
assert_eq!(ty.minimum(), 1);
assert_eq!(ty.maximum(), Some(10));
assert!(!ty.is_64());
diff --git a/crates/wasmtime/src/runtime/externals/table.rs b/crates/wasmtime/src/runtime/externals/table.rs
index b1c994d7ad..752570d354 100644
--- a/crates/wasmtime/src/runtime/externals/table.rs
+++ b/crates/wasmtime/src/runtime/externals/table.rs
@@ -77,7 +77,7 @@ impl Table {
/// let engine = Engine::default();
/// let mut store = Store::new(&engine, ());
///
- /// let ty = TableType::new(RefType::FUNCREF, 2, None);
+ /// let ty = TableType::new(RefType::FUNCREF, 2, None)?;
/// let table = Table::new(&mut store, ty, Ref::Func(None))?;
///
/// let module = Module::new(
diff --git a/crates/wasmtime/src/runtime/memory.rs b/crates/wasmtime/src/runtime/memory.rs
index 3955d541c7..8942faebfa 100644
--- a/crates/wasmtime/src/runtime/memory.rs
+++ b/crates/wasmtime/src/runtime/memory.rs
@@ -251,7 +251,7 @@ impl Memory {
/// let engine = Engine::default();
/// let mut store = Store::new(&engine, ());
///
- /// let memory_ty = MemoryType::new(1, None);
+ /// let memory_ty = MemoryType::new(1, None)?;
/// let memory = Memory::new(&mut store, memory_ty)?;
///
/// let module = Module::new(&engine, "(module (memory (import \"\" \"\") 1))")?;
@@ -848,7 +848,7 @@ pub unsafe trait MemoryCreator: Send + Sync {
/// let engine = Engine::new(&config)?;
/// let mut store = Store::new(&engine, ());
///
-/// let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 2))?;
+/// let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 2)?)?;
/// let module = Module::new(&engine, r#"(module (memory (import "" "") 1 2 shared))"#)?;
/// let instance = Instance::new(&mut store, &module, &[shared_memory.into()])?;
/// // ...
@@ -1113,7 +1113,7 @@ mod tests {
let mut cfg = Config::new();
cfg.memory_reservation(0).memory_guard_size(0);
let mut store = Store::new(&Engine::new(&cfg).unwrap(), ());
- let ty = MemoryType::new(1, None);
+ let ty = MemoryType::new(1, None).unwrap();
let mem = Memory::new(&mut store, ty).unwrap();
let store = store.as_context();
let tunables = store.engine().tunables();
diff --git a/crates/wasmtime/src/runtime/store.rs b/crates/wasmtime/src/runtime/store.rs
index 62f51b8224..294c3281a1 100644
--- a/crates/wasmtime/src/runtime/store.rs
+++ b/crates/wasmtime/src/runtime/store.rs
@@ -900,6 +900,7 @@ impl<T> Store<T> {
/// limits: StoreLimits,
/// }
///
+ /// # fn main() -> Result<()> {
/// let engine = Engine::default();
/// let my_state = MyApplicationState {
/// my_state: 42,
@@ -912,18 +913,20 @@ impl<T> Store<T> {
/// store.limiter(|state| &mut state.limits);
///
/// // Creation of smaller memories is allowed
- /// Memory::new(&mut store, MemoryType::new(1, None)).unwrap();
+ /// Memory::new(&mut store, MemoryType::new(1, None)?)?;
///
/// // Creation of a larger memory, however, will exceed the 1MB limit we've
/// // configured
- /// assert!(Memory::new(&mut store, MemoryType::new(1000, None)).is_err());
+ /// assert!(Memory::new(&mut store, MemoryType::new(1000, None)?).is_err());
///
/// // The number of instances in this store is limited to 2, so the third
/// // instance here should fail.
- /// let module = Module::new(&engine, "(module)").unwrap();
- /// assert!(Instance::new(&mut store, &module, &[]).is_ok());
- /// assert!(Instance::new(&mut store, &module, &[]).is_ok());
+ /// let module = Module::new(&engine, "(module)")?;
+ /// Instance::new(&mut store, &module, &[])?;
+ /// Instance::new(&mut store, &module, &[])?;
/// assert!(Instance::new(&mut store, &module, &[]).is_err());
+ /// # Ok(())
+ /// # }
/// ```
///
/// [`ResourceLimiter`]: crate::ResourceLimiter
diff --git a/crates/wasmtime/src/runtime/types.rs b/crates/wasmtime/src/runtime/types.rs
index fc3e313d48..2d4023269e 100644
--- a/crates/wasmtime/src/runtime/types.rs
+++ b/crates/wasmtime/src/runtime/types.rs
@@ -3174,7 +3174,16 @@ pub struct TableType {
impl TableType {
/// Creates a new table descriptor which will contain the specified
/// `element` and have the `limits` applied to its length.
- pub fn new(element: RefType, min: u32, max: Option<u32>) -> TableType {
+ ///
+ /// # Errors
+ ///
+ /// Returns an error if the minimum is greater than the maximum.
+ pub fn new(element: RefType, min: u32, max: Option<u32>) -> Result<TableType> {
+ if let Some(max) = max
+ && max < min
+ {
+ bail!("table's maximum size cannot be smaller than its minimum size");
+ }
let ref_type = element.to_wasm_type();
debug_assert!(
@@ -3187,21 +3196,30 @@ impl TableType {
max: max.map(|x| u64::from(x)),
};
- TableType {
+ Ok(TableType {
element,
ty: Table {
idx_type: IndexType::I32,
limits,
ref_type,
},
- }
+ })
}
/// Crates a new descriptor for a 64-bit table.
///
/// Note that 64-bit tables are part of the memory64 proposal for
/// WebAssembly which is not standardized yet.
- pub fn new64(element: RefType, min: u64, max: Option<u64>) -> TableType {
+ ///
+ /// # Errors
+ ///
+ /// Returns an error if the minimum is greater than the maximum.
+ pub fn new64(element: RefType, min: u64, max: Option<u64>) -> Result<TableType> {
+ if let Some(max) = max
+ && max < min
+ {
+ bail!("table's maximum size cannot be smaller than its minimum size");
+ }
let ref_type = element.to_wasm_type();
debug_assert!(
@@ -3209,14 +3227,14 @@ impl TableType {
"should be canonicalized for runtime usage: {ref_type:?}"
);
- TableType {
+ Ok(TableType {
element,
ty: Table {
ref_type,
idx_type: IndexType::I64,
limits: Limits { min, max },
},
- }
+ })
}
/// Returns whether or not this table is a 64-bit table.
@@ -3475,17 +3493,16 @@ impl MemoryType {
/// [`MemoryTypeBuilder`][crate::MemoryTypeBuilder] if you want a
/// non-default page size.
///
- /// # Panics
+ /// # Errors
///
- /// Panics if the minimum is greater than the maximum or if the minimum or
- /// maximum number of pages can result in a byte size that is not
- /// addressable with a 32-bit integer.
- pub fn new(minimum: u32, maximum: Option<u32>) -> MemoryType {
+ /// Returns an error if the minimum is greater than the maximum or if the
+ /// minimum or maximum number of pages can result in a byte size that is
+ /// not addressable with a 32-bit integer.
+ pub fn new(minimum: u32, maximum: Option<u32>) -> Result<MemoryType> {
MemoryTypeBuilder::default()
.min(minimum.into())
.max(maximum.map(Into::into))
.build()
- .unwrap()
}
/// Creates a new descriptor for a 64-bit WebAssembly memory given the
@@ -3500,18 +3517,17 @@ impl MemoryType {
/// proposal](https://github.com/WebAssembly/memory64) for WebAssembly which
/// is not fully standardized yet.
///
- /// # Panics
+ /// # Errors
///
- /// Panics if the minimum is greater than the maximum or if the minimum or
- /// maximum number of pages can result in a byte size that is not
- /// addressable with a 64-bit integer.
- pub fn new64(minimum: u64, maximum: Option<u64>) -> MemoryType {
+ /// Returns an error if the minimum is greater than the maximum or if the
+ /// minimum or maximum number of pages can result in a byte size that is
+ /// not addressable with a 64-bit integer.
+ pub fn new64(minimum: u64, maximum: Option<u64>) -> Result<MemoryType> {
MemoryTypeBuilder::default()
.memory64(true)
.min(minimum)
.max(maximum)
.build()
- .unwrap()
}
/// Creates a new descriptor for shared WebAssembly memory given the
@@ -3526,18 +3542,17 @@ impl MemoryType {
/// proposal](https://github.com/WebAssembly/threads) for WebAssembly which
/// is not fully standardized yet.
///
- /// # Panics
+ /// # Errors
///
- /// Panics if the minimum is greater than the maximum or if the minimum or
- /// maximum number of pages can result in a byte size that is not
- /// addressable with a 32-bit integer.
- pub fn shared(minimum: u32, maximum: u32) -> MemoryType {
+ /// Returns an error if the minimum is greater than the maximum or if the
+ /// minimum or maximum number of pages can result in a byte size that is
+ /// not addressable with a 32-bit integer.
+ pub fn shared(minimum: u32, maximum: u32) -> Result<MemoryType> {
MemoryTypeBuilder::default()
.shared(true)
.min(minimum.into())
.max(Some(maximum.into()))
.build()
- .unwrap()
}
/// Creates a new [`MemoryTypeBuilder`] to configure all the various knobs
diff --git a/crates/wast/src/spectest.rs b/crates/wast/src/spectest.rs
index b99421d7e0..4f5dd541e9 100644
--- a/crates/wast/src/spectest.rs
+++ b/crates/wast/src/spectest.rs
@@ -66,20 +66,20 @@ pub fn link_spectest<T>(
let g = Global::new(&mut *store, ty, Val::F64(0x4084_d4cc_cccc_cccd))?;
linker.define(&mut *store, "spectest", "global_f64", g)?;
- let ty = TableType::new(RefType::FUNCREF, 10, Some(20));
+ let ty = TableType::new(RefType::FUNCREF, 10, Some(20))?;
let table = Table::new(&mut *store, ty, Ref::Func(None))?;
linker.define(&mut *store, "spectest", "table", table)?;
- let ty = TableType::new64(RefType::FUNCREF, 10, Some(20));
+ let ty = TableType::new64(RefType::FUNCREF, 10, Some(20))?;
let table = Table::new(&mut *store, ty, Ref::Func(None))?;
linker.define(&mut *store, "spectest", "table64", table)?;
- let ty = MemoryType::new(1, Some(2));
+ let ty = MemoryType::new(1, Some(2))?;
let memory = Memory::new(&mut *store, ty)?;
linker.define(&mut *store, "spectest", "memory", memory)?;
if config.use_shared_memory {
- let ty = MemoryType::shared(1, 1);
+ let ty = MemoryType::shared(1, 1)?;
let memory = SharedMemory::new(store.engine(), ty)?;
linker.define(&mut *store, "spectest", "shared_memory", memory)?;
}
diff --git a/examples/memory.rs b/examples/memory.rs
index ef187c724f..3bc3adfba5 100644
--- a/examples/memory.rs
+++ b/examples/memory.rs
@@ -63,7 +63,7 @@ fn main() -> Result<()> {
assert!(memory.grow(&mut store, 0).is_ok());
println!("Creating stand-alone memory...");
- let memorytype = MemoryType::new(5, Some(5));
+ let memorytype = MemoryType::new(5, Some(5))?;
let memory2 = Memory::new(&mut store, memorytype)?;
assert_eq!(memory2.size(&store), 5);
assert!(memory2.grow(&mut store, 1).is_err());
diff --git a/src/commands/serve.rs b/src/commands/serve.rs
index deb3272ac0..d36cc9fe6d 100644
--- a/src/commands/serve.rs
+++ b/src/commands/serve.rs
@@ -1636,7 +1636,7 @@ fn use_pooling_allocator_by_default() -> Result<Option<bool>> {
let mut store = Store::new(&engine, ());
// NB: the maximum size is in wasm pages to take out the 16-bits of wasm
// page size here from the maximum size.
- let ty = MemoryType::new64(0, Some(1 << (BITS_TO_TEST - 16)));
+ let ty = MemoryType::new64(0, Some(1 << (BITS_TO_TEST - 16)))?;
if Memory::new(&mut store, ty).is_ok() {
Ok(Some(true))
} else {
diff --git a/tests/all/coredump.rs b/tests/all/coredump.rs
index 605118d7f9..8001fba646 100644
--- a/tests/all/coredump.rs
+++ b/tests/all/coredump.rs
@@ -136,7 +136,7 @@ fn coredump_has_host_globals_and_memory() -> Result<()> {
let mut store = Store::<()>::new(&engine, ());
let mut linker = Linker::new(&engine);
- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;
+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;
linker.define(&mut store, "memory", "memory", memory)?;
let global = Global::new(
@@ -210,7 +210,7 @@ fn multiple_globals_memories_and_instances() -> Result<()> {
let mut store = Store::<()>::new(&engine, ());
let mut linker = Linker::new(&engine);
- let memory = Memory::new(&mut store, MemoryType::new(1, None))?;
+ let memory = Memory::new(&mut store, MemoryType::new(1, None)?)?;
linker.define(&mut store, "host", "memory", memory)?;
let global = Global::new(
diff --git a/tests/all/cross_engine.rs b/tests/all/cross_engine.rs
index f216865fb8..4b90b345fc 100644
--- a/tests/all/cross_engine.rs
+++ b/tests/all/cross_engine.rs
@@ -320,7 +320,7 @@ fn table_new_rejects_foreign_type() -> Result<()> {
)],
)?;
let foreign_heap_ty = HeapType::ConcreteStruct(foreign_struct);
- let foreign_ty = TableType::new(RefType::new(true, foreign_heap_ty.clone()), 0, None);
+ let foreign_ty = TableType::new(RefType::new(true, foreign_heap_ty.clone()), 0, None)?;
Table::new(&mut store, foreign_ty, Ref::null(&foreign_heap_ty))
.unwrap_err()
@@ -346,7 +346,7 @@ async fn table_new_async_rejects_foreign_type() -> Result<()> {
)],
)?;
let foreign_heap_ty = HeapType::ConcreteStruct(foreign_struct);
- let foreign_ty = TableType::new(RefType::new(true, foreign_heap_ty.clone()), 0, None);
+ let foreign_ty = TableType::new(RefType::new(true, foreign_heap_ty.clone()), 0, None)?;
Table::new_async(&mut store, foreign_ty, Ref::null(&foreign_heap_ty))
.await
diff --git a/tests/all/externals.rs b/tests/all/externals.rs
index 31cfc243b6..f41bb76c8f 100644
--- a/tests/all/externals.rs
+++ b/tests/all/externals.rs
@@ -22,32 +22,32 @@ fn bad_tables() {
let mut store = Store::<()>::default();
// mismatched initializer
- let ty = TableType::new(RefType::FUNCREF, 0, Some(1));
+ let ty = TableType::new(RefType::FUNCREF, 0, Some(1)).unwrap();
assert!(Table::new(&mut store, ty.clone(), Ref::Extern(None)).is_err());
// get out of bounds
- let ty = TableType::new(RefType::FUNCREF, 0, Some(1));
+ let ty = TableType::new(RefType::FUNCREF, 0, Some(1)).unwrap();
let t = Table::new(&mut store, ty.clone(), Ref::Func(None)).unwrap();
assert!(t.get(&mut store, 0).is_none());
assert!(t.get(&mut store, u64::from(u32::MAX)).is_none());
assert!(t.get(&mut store, u64::MAX).is_none());
// set out of bounds or wrong type
- let ty = TableType::new(RefType::FUNCREF, 1, Some(1));
+ let ty = TableType::new(RefType::FUNCREF, 1, Some(1)).unwrap();
let t = Table::new(&mut store, ty.clone(), Ref::Func(None)).unwrap();
assert!(t.set(&mut store, 0, Ref::Extern(None)).is_err());
assert!(t.set(&mut store, 0, Ref::Func(None)).is_ok());
assert!(t.set(&mut store, 1, Ref::Func(None)).is_err());
// grow beyond max
- let ty = TableType::new(RefType::FUNCREF, 1, Some(1));
+ let ty = TableType::new(RefType::FUNCREF, 1, Some(1)).unwrap();
let t = Table::new(&mut store, ty.clone(), Ref::Func(None)).unwrap();
assert!(t.grow(&mut store, 0, Ref::Func(None)).is_ok());
assert!(t.grow(&mut store, 1, Ref::Func(None)).is_err());
assert_eq!(t.size(&store), 1);
// grow wrong type
- let ty = TableType::new(RefType::FUNCREF, 1, Some(2));
+ let ty = TableType::new(RefType::FUNCREF, 1, Some(2)).unwrap();
let t = Table::new(&mut store, ty.clone(), Ref::Func(None)).unwrap();
assert!(t.grow(&mut store, 1, Ref::Extern(None)).is_err());
assert_eq!(t.size(&store), 1);
@@ -67,9 +67,9 @@ fn cross_store() -> wasmtime::Result<()> {
let func = Func::wrap(&mut store2, || {});
let ty = GlobalType::new(ValType::I32, Mutability::Const);
let global = Global::new(&mut store2, ty, Val::I32(0))?;
- let ty = MemoryType::new(1, None);
+ let ty = MemoryType::new(1, None)?;
let memory = Memory::new(&mut store2, ty)?;
- let ty = TableType::new(RefType::FUNCREF, 1, None);
+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;
let table = Table::new(&mut store2, ty, Ref::Func(None))?;
let need_func = Module::new(&engine, r#"(module (import "" "" (func)))"#)?;
@@ -99,7 +99,7 @@ fn cross_store() -> wasmtime::Result<()> {
eprintln!("============ Cross-store tables ==============");
- let ty = TableType::new(RefType::FUNCREF, 1, None);
+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;
assert!(Table::new(&mut store2, ty.clone(), store1ref.clone()).is_err());
let t1 = Table::new(&mut store2, ty.clone(), store2ref.clone())?;
assert!(t1.set(&mut store2, 0, store1ref.clone()).is_err());
@@ -248,7 +248,7 @@ fn create_get_set_funcref_tables_via_api() -> wasmtime::Result<()> {
let engine = Engine::new(&cfg)?;
let mut store = Store::new(&engine, ());
- let table_ty = TableType::new(RefType::FUNCREF, 10, None);
+ let table_ty = TableType::new(RefType::FUNCREF, 10, None)?;
let init = Ref::Func(Some(Func::wrap(&mut store, || {})));
let table = Table::new(&mut store, table_ty, init)?;
@@ -266,7 +266,7 @@ fn fill_funcref_tables_via_api() -> wasmtime::Result<()> {
let engine = Engine::new(&cfg)?;
let mut store = Store::new(&engine, ());
- let table_ty = TableType::new(RefType::FUNCREF, 10, None);
+ let table_ty = TableType::new(RefType::FUNCREF, 10, None)?;
let table = Table::new(&mut store, table_ty, Ref::Func(None))?;
for i in 0..10 {
@@ -293,7 +293,7 @@ fn grow_funcref_tables_via_api() -> wasmtime::Result<()> {
let engine = Engine::new(&cfg)?;
let mut store = Store::new(&engine, ());
- let table_ty = TableType::new(RefType::FUNCREF, 10, None);
+ let table_ty = TableType::new(RefType::FUNCREF, 10, None)?;
let table = Table::new(&mut store, table_ty, Ref::Func(None))?;
assert_eq!(table.size(&store), 10);
@@ -310,7 +310,7 @@ fn create_get_set_externref_tables_via_api() -> wasmtime::Result<()> {
let engine = Engine::new(&cfg)?;
let mut store = Store::new(&engine, ());
- let table_ty = TableType::new(RefType::EXTERNREF, 10, None);
+ let table_ty = TableType::new(RefType::EXTERNREF, 10, None)?;
let init = ExternRef::new(&mut store, 42_usize)?;
let table = Table::new(&mut store, table_ty, init.into())?;
@@ -339,7 +339,7 @@ fn fill_externref_tables_via_api() -> wasmtime::Result<()> {
let engine = Engine::new(&cfg)?;
let mut store = Store::new(&engine, ());
- let table_ty = TableType::new(RefType::EXTERNREF, 10, None);
+ let table_ty = TableType::new(RefType::EXTERNREF, 10, None)?;
let table = Table::new(&mut store, table_ty, Ref::Extern(None))?;
for i in 0..10 {
@@ -377,7 +377,7 @@ fn grow_externref_tables_via_api() -> wasmtime::Result<()> {
let engine = Engine::new(&cfg)?;
let mut store = Store::new(&engine, ());
- let table_ty = TableType::new(RefType::EXTERNREF, 10, None);
+ let table_ty = TableType::new(RefType::EXTERNREF, 10, None)?;
let table = Table::new(&mut store, table_ty, Ref::Extern(None))?;
assert_eq!(table.size(&store), 10);
@@ -391,7 +391,7 @@ fn grow_externref_tables_via_api() -> wasmtime::Result<()> {
fn read_write_memory_via_api() {
let cfg = Config::new();
let mut store = Store::new(&Engine::new(&cfg).unwrap(), ());
- let ty = MemoryType::new(1, None);
+ let ty = MemoryType::new(1, None).unwrap();
let mem = Memory::new(&mut store, ty).unwrap();
mem.grow(&mut store, 1).unwrap();
@@ -607,7 +607,7 @@ fn new_table_func_subtyping() {
for (val, expected) in [(a, a_expected), (b, b_expected), (c, c_expected)] {
match Table::new(
&mut store,
- TableType::new(RefType::new(true, table_ty.clone().into()), 0, None),
+ TableType::new(RefType::new(true, table_ty.clone().into()), 0, None).unwrap(),
val.into(),
) {
Ok(_) if expected => {}
@@ -637,7 +637,7 @@ fn table_set_func_subtyping() {
] {
let table = Table::new(
&mut store,
- TableType::new(RefType::new(true, table_ty.clone().into()), 3, None),
+ TableType::new(RefType::new(true, table_ty.clone().into()), 3, None).unwrap(),
Ref::Func(None),
)
.unwrap();
@@ -680,7 +680,7 @@ fn table_grow_func_subtyping() {
] {
let table = Table::new(
&mut store,
- TableType::new(RefType::new(true, table_ty.clone().into()), 3, None),
+ TableType::new(RefType::new(true, table_ty.clone().into()), 3, None).unwrap(),
Ref::Func(None),
)
.unwrap();
@@ -725,7 +725,7 @@ fn table_fill_func_subtyping() {
for (val, expected) in [(a, a_expected), (b, b_expected), (c, c_expected)] {
let table = Table::new(
&mut store,
- TableType::new(RefType::new(true, table_ty.clone().into()), 10, None),
+ TableType::new(RefType::new(true, table_ty.clone().into()), 10, None).unwrap(),
Ref::Func(None),
)
.unwrap();
@@ -766,7 +766,7 @@ fn table_copy_func_subtyping() {
] {
let dest_table = Table::new(
&mut store,
- TableType::new(RefType::new(true, dst_ty.clone().into()), 10, None),
+ TableType::new(RefType::new(true, dst_ty.clone().into()), 10, None).unwrap(),
Ref::Func(None),
)
.unwrap();
@@ -780,7 +780,7 @@ fn table_copy_func_subtyping() {
let src_table = Table::new(
&mut store,
- TableType::new(RefType::new(true, src_ty.into()), 10, None),
+ TableType::new(RefType::new(true, src_ty.into()), 10, None).unwrap(),
val.into(),
)
.unwrap();
diff --git a/tests/all/func.rs b/tests/all/func.rs
index 4c94c67e64..3a1f42f750 100644
--- a/tests/all/func.rs
+++ b/tests/all/func.rs
@@ -287,7 +287,7 @@ fn call_indirect_native_from_wasm_import_table(config: &mut Config) -> Result<()
let func = Func::wrap(&mut store, || -> (i32, i32, i32) { (10, 20, 30) });
let table = Table::new(
&mut store,
- TableType::new(RefType::FUNCREF, 1, Some(1)),
+ TableType::new(RefType::FUNCREF, 1, Some(1))?,
Ref::Func(Some(func)),
)?;
let instance = Instance::new(&mut store, &module, &[table.into()])?;
diff --git a/tests/all/gc.rs b/tests/all/gc.rs
index 34e6c7eec1..3b27a5d094 100644
--- a/tests/all/gc.rs
+++ b/tests/all/gc.rs
@@ -343,7 +343,7 @@ fn table_drops_externref() -> Result<()> {
let externref = ExternRef::new(&mut store, SetFlagOnDrop(flag.clone()))?;
Table::new(
&mut store,
- TableType::new(RefType::EXTERNREF, 1, None),
+ TableType::new(RefType::EXTERNREF, 1, None)?,
externref.into(),
)?;
drop(store);
@@ -845,7 +845,7 @@ fn table_fill_doesnt_leak() -> Result<()> {
let x = ExternRef::new(&mut scope, SetFlagOnDrop(flag.clone()))?;
let table = Table::new(
&mut scope,
- TableType::new(RefType::EXTERNREF, 10, Some(10)),
+ TableType::new(RefType::EXTERNREF, 10, Some(10))?,
x.into(),
)?;
table.fill(&mut scope, 0, Ref::Extern(None), 10)?;
@@ -868,7 +868,7 @@ fn table_copy_doesnt_leak() -> Result<()> {
let mut scope = RootScope::new(&mut store);
let table = Table::new(
&mut scope,
- TableType::new(RefType::EXTERNREF, 10, Some(10)),
+ TableType::new(RefType::EXTERNREF, 10, Some(10))?,
Ref::Extern(None),
)?;
@@ -895,7 +895,7 @@ fn table_set_doesnt_leak() -> Result<()> {
let mut scope = RootScope::new(&mut store);
let table = Table::new(
&mut scope,
- TableType::new(RefType::EXTERNREF, 10, Some(10)),
+ TableType::new(RefType::EXTERNREF, 10, Some(10))?,
Ref::Extern(None),
)?;
@@ -922,7 +922,7 @@ fn table_grow_doesnt_leak() -> Result<()> {
let mut scope = RootScope::new(&mut store);
let table = Table::new(
&mut scope,
- TableType::new(RefType::EXTERNREF, 10, Some(10)),
+ TableType::new(RefType::EXTERNREF, 10, Some(10))?,
Ref::Extern(None),
)?;
@@ -3452,7 +3452,7 @@ fn miri_gc_smoke_test() -> Result<()> {
&engine,
[FieldType::new(Mutability::Const, StorageType::I8)],
)?;
- let table_ty = TableType::new(RefType::ANYREF, 1, None);
+ let table_ty = TableType::new(RefType::ANYREF, 1, None)?;
let global_ty = GlobalType::new(RefType::ANYREF.into(), Mutability::Var);
let exn_ty = ExnType::new(&engine, [ValType::I32])?;
let func_ty = FuncType::new(&engine, Some(ValType::I32), None);
diff --git a/tests/all/limits.rs b/tests/all/limits.rs
index 1e75a38d12..bff7d1b748 100644
--- a/tests/all/limits.rs
+++ b/tests/all/limits.rs
@@ -30,7 +30,7 @@ fn test_limits() -> Result<()> {
// Test instance exports and host objects hitting the limit
for memory in IntoIterator::into_iter([
instance.get_memory(&mut store, "m").unwrap(),
- Memory::new(&mut store, MemoryType::new(0, None))?,
+ Memory::new(&mut store, MemoryType::new(0, None)?)?,
]) {
memory.grow(&mut store, 3)?;
memory.grow(&mut store, 5)?;
@@ -50,7 +50,7 @@ fn test_limits() -> Result<()> {
instance.get_table(&mut store, "t").unwrap(),
Table::new(
&mut store,
- TableType::new(RefType::FUNCREF, 0, None),
+ TableType::new(RefType::FUNCREF, 0, None)?,
Ref::Func(None),
)?,
]) {
@@ -138,7 +138,7 @@ async fn test_limits_async() -> Result<()> {
// Test instance exports and host objects hitting the limit
for memory in IntoIterator::into_iter([
instance.get_memory(&mut store, "m").unwrap(),
- Memory::new_async(&mut store, MemoryType::new(0, None)).await?,
+ Memory::new_async(&mut store, MemoryType::new(0, None)?).await?,
]) {
memory.grow_async(&mut store, 3).await?;
memory.grow_async(&mut store, 5).await?;
@@ -159,7 +159,7 @@ async fn test_limits_async() -> Result<()> {
instance.get_table(&mut store, "t").unwrap(),
Table::new_async(
&mut store,
- TableType::new(RefType::FUNCREF, 0, None),
+ TableType::new(RefType::FUNCREF, 0, None)?,
Ref::Func(None),
)
.await?,
@@ -202,7 +202,7 @@ fn test_limits_memory_only() -> Result<()> {
// Test instance exports and host objects hitting the limit
for memory in IntoIterator::into_iter([
instance.get_memory(&mut store, "m").unwrap(),
- Memory::new(&mut store, MemoryType::new(0, None))?,
+ Memory::new(&mut store, MemoryType::new(0, None)?)?,
]) {
memory.grow(&mut store, 3)?;
memory.grow(&mut store, 5)?;
@@ -222,7 +222,7 @@ fn test_limits_memory_only() -> Result<()> {
instance.get_table(&mut store, "t").unwrap(),
Table::new(
&mut store,
- TableType::new(RefType::FUNCREF, 0, None),
+ TableType::new(RefType::FUNCREF, 0, None)?,
Ref::Func(None),
)?,
]) {
@@ -256,7 +256,7 @@ fn test_initial_memory_limits_exceeded() -> Result<()> {
),
}
- match Memory::new(&mut store, MemoryType::new(25, None)) {
+ match Memory::new(&mut store, MemoryType::new(25, None)?) {
Ok(_) => unreachable!(),
Err(e) => assert_eq!(
e.to_string(),
@@ -283,7 +283,7 @@ fn test_limits_table_only() -> Result<()> {
// Test instance exports and host objects *not* hitting the limit
for memory in IntoIterator::into_iter([
instance.get_memory(&mut store, "m").unwrap(),
- Memory::new(&mut store, MemoryType::new(0, None))?,
+ Memory::new(&mut store, MemoryType::new(0, None)?)?,
]) {
memory.grow(&mut store, 3)?;
memory.grow(&mut store, 5)?;
@@ -296,7 +296,7 @@ fn test_limits_table_only() -> Result<()> {
instance.get_table(&mut store, "t").unwrap(),
Table::new(
&mut store,
- TableType::new(RefType::FUNCREF, 0, None),
+ TableType::new(RefType::FUNCREF, 0, None)?,
Ref::Func(None),
)?,
]) {
@@ -334,7 +334,7 @@ fn test_initial_table_limits_exceeded() -> Result<()> {
match Table::new(
&mut store,
- TableType::new(RefType::FUNCREF, 99, None),
+ TableType::new(RefType::FUNCREF, 99, None)?,
Ref::Func(None),
) {
Ok(_) => unreachable!(),
@@ -1135,7 +1135,7 @@ fn growth_trap() -> Result<()> {
// Test instance exports and host objects hitting the limit
for memory in [
instance.get_memory(&mut store, "m").unwrap(),
- Memory::new(&mut store, MemoryType::new(0, None))?,
+ Memory::new(&mut store, MemoryType::new(0, None)?)?,
] {
memory.grow(&mut store, 1)?;
assert!(memory.grow(&mut store, 1).is_err());
@@ -1146,7 +1146,7 @@ fn growth_trap() -> Result<()> {
instance.get_table(&mut store, "t").unwrap(),
Table::new(
&mut store,
- TableType::new(RefType::FUNCREF, 0, None),
+ TableType::new(RefType::FUNCREF, 0, None)?,
Ref::Func(None),
)?,
] {
diff --git a/tests/all/linker.rs b/tests/all/linker.rs
index de6614ea60..b16af64c95 100644
--- a/tests/all/linker.rs
+++ b/tests/all/linker.rs
@@ -73,20 +73,20 @@ fn link_twice_bad() -> Result<()> {
assert!(linker.define(&mut store, "g", "3", global).is_err());
// memories
- let ty = MemoryType::new(1, None);
+ let ty = MemoryType::new(1, None)?;
let memory = Memory::new(&mut store, ty)?;
linker.define(&mut store, "m", "", memory)?;
assert!(linker.define(&mut store, "m", "", memory).is_err());
- let ty = MemoryType::new(2, None);
+ let ty = MemoryType::new(2, None)?;
let memory = Memory::new(&mut store, ty)?;
assert!(linker.define(&mut store, "m", "", memory).is_err());
// tables
- let ty = TableType::new(RefType::FUNCREF, 1, None);
+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;
let table = Table::new(&mut store, ty, Ref::Func(None))?;
linker.define(&mut store, "t", "", table)?;
assert!(linker.define(&mut store, "t", "", table).is_err());
- let ty = TableType::new(RefType::FUNCREF, 2, None);
+ let ty = TableType::new(RefType::FUNCREF, 2, None)?;
let table = Table::new(&mut store, ty, Ref::Func(None))?;
assert!(linker.define(&mut store, "t", "", table).is_err());
Ok(())
@@ -754,7 +754,7 @@ fn linker_defines_table_subtype_err() -> Result<()> {
let mut linker = Linker::new(&engine);
let t = Table::new(
&mut store,
- TableType::new(RefType::FUNCREF, 0, None),
+ TableType::new(RefType::FUNCREF, 0, None)?,
Ref::Func(None),
)?;
linker.define(&store, "env", "t", t)?;
@@ -765,7 +765,7 @@ fn linker_defines_table_subtype_err() -> Result<()> {
let mut linker = Linker::new(&engine);
let t = Table::new(
&mut store,
- TableType::new(RefType::NULLFUNCREF, 0, None),
+ TableType::new(RefType::NULLFUNCREF, 0, None)?,
Ref::Func(None),
)?;
linker.define(&store, "env", "t", t)?;
diff --git a/tests/all/memory.rs b/tests/all/memory.rs
index 89ed1ec0b8..f9f4d57b8a 100644
--- a/tests/all/memory.rs
+++ b/tests/all/memory.rs
@@ -121,7 +121,7 @@ fn offsets_static_dynamic_oh_my(config: &mut Config) -> Result<()> {
for (min, max) in [(1, Some(2)), (1, None)].iter() {
let mut store = Store::new(&engine, ());
- let mem = Memory::new(&mut store, MemoryType::new(*min, *max)).unwrap();
+ let mem = Memory::new(&mut store, MemoryType::new(*min, *max)?).unwrap();
let instance = Instance::new(&mut store, &module, &[mem.into()]).unwrap();
let funcs = find_funcs(&mut store, &instance);
@@ -153,8 +153,8 @@ fn guards_present() -> Result<()> {
config.guard_before_linear_memory(true);
let engine = Engine::new(&config)?;
let mut store = Store::new(&engine, ());
- let static_mem = Memory::new(&mut store, MemoryType::new(1, Some(2)))?;
- let dynamic_mem = Memory::new(&mut store, MemoryType::new(1, None))?;
+ let static_mem = Memory::new(&mut store, MemoryType::new(1, Some(2))?)?;
+ let dynamic_mem = Memory::new(&mut store, MemoryType::new(1, None)?)?;
let assert_guards = |store: &Store<()>| unsafe {
// guards before
@@ -369,7 +369,7 @@ fn massive_64_bit_still_limited() -> Result<()> {
let mut store = Store::new(&engine, MyLimiter { hit: false });
store.limiter(|x| x);
- let ty = MemoryType::new64(1 << 46, None);
+ let ty = MemoryType::new64(1 << 46, None)?;
assert!(Memory::new(&mut store, ty).is_err());
assert!(store.data().hit);
@@ -445,7 +445,7 @@ fn static_forced_max() -> Result<()> {
let engine = Engine::new(&config)?;
let mut store = Store::new(&engine, ());
- let mem = Memory::new(&mut store, MemoryType::new(0, None))?;
+ let mem = Memory::new(&mut store, MemoryType::new(0, None)?)?;
mem.grow(&mut store, 5).unwrap();
assert!(mem.grow(&mut store, 1).is_err());
Ok(())
@@ -505,7 +505,7 @@ fn dynamic_extra_growth_unchanged_pointer(config: &mut Config) -> Result<()> {
Ok(())
}
- let mem = Memory::new(&mut store, MemoryType::new(10, None))?;
+ let mem = Memory::new(&mut store, MemoryType::new(10, None)?)?;
assert_behaves_well(&mut store, &mem)?;
let module = Module::new(&engine, r#"(module (memory (export "mem") 10))"#)?;
@@ -595,10 +595,10 @@ fn shared_memory_basics() -> Result<()> {
let mut config = Config::new();
config.shared_memory(true);
let engine = Engine::new(&config)?;
- assert!(SharedMemory::new(&engine, MemoryType::new(1, None)).is_err());
- assert!(SharedMemory::new(&engine, MemoryType::new(1, Some(1))).is_err());
- assert!(SharedMemory::new(&engine, MemoryType::new64(1, None)).is_err());
- assert!(SharedMemory::new(&engine, MemoryType::new64(1, Some(1))).is_err());
+ assert!(SharedMemory::new(&engine, MemoryType::new(1, None)?).is_err());
+ assert!(SharedMemory::new(&engine, MemoryType::new(1, Some(1))?).is_err());
+ assert!(SharedMemory::new(&engine, MemoryType::new64(1, None)?).is_err());
+ assert!(SharedMemory::new(&engine, MemoryType::new64(1, Some(1))?).is_err());
assert!(
MemoryTypeBuilder::default()
.shared(true)
@@ -608,7 +608,7 @@ fn shared_memory_basics() -> Result<()> {
.is_err()
);
- let memory = SharedMemory::new(&engine, MemoryType::shared(1, 1))?;
+ let memory = SharedMemory::new(&engine, MemoryType::shared(1, 1)?)?;
assert!(memory.ty().is_shared());
assert_eq!(memory.ty().minimum(), 1);
assert_eq!(memory.ty().maximum(), Some(1));
@@ -670,7 +670,7 @@ fn shared_memory_wait_notify() -> Result<()> {
let mut config = Config::new();
config.shared_memory(true);
let engine = Engine::new(&config)?;
- let memory = SharedMemory::new(&engine, MemoryType::shared(1, 1))?;
+ let memory = SharedMemory::new(&engine, MemoryType::shared(1, 1)?)?;
let data = unsafe { AtomicU32::from_ptr(memory.data().as_ptr().cast_mut().cast()) };
let locked = unsafe { AtomicU32::from_ptr(memory.data().as_ptr().add(4).cast_mut().cast()) };
@@ -789,7 +789,7 @@ fn non_page_aligned_static_memory() -> Result<()> {
config.memory_reservation(100_000);
config.memory_may_move(false);
let engine = Engine::new(&config)?;
- let ty = MemoryType::new(1, None);
+ let ty = MemoryType::new(1, None)?;
Memory::new(&mut Store::new(&engine, ()), ty)?;
Ok(())
}
@@ -857,7 +857,7 @@ fn configure_zero(config: &mut Config) -> Result<()> {
let engine = Engine::new(&config)?;
let mut store = Store::new(&engine, ());
- let ty = MemoryType::new(0, None);
+ let ty = MemoryType::new(0, None)?;
let memory = Memory::new(&mut store, ty)?;
assert_eq!(memory.data_size(&store), 0);
@@ -870,7 +870,7 @@ fn atomic_wait_massive_timeout() -> Result<()> {
config.shared_memory(true);
let engine = Engine::new(&config)?;
- let memory = SharedMemory::new(&engine, MemoryType::shared(1, 1))?;
+ let memory = SharedMemory::new(&engine, MemoryType::shared(1, 1)?)?;
let result = memory.atomic_wait32(0, 1, Some(Duration::MAX));
assert_eq!(result, Ok(WaitResult::Mismatch));
let result = memory.atomic_wait64(0, 1, Some(Duration::MAX));
diff --git a/tests/all/missing_async.rs b/tests/all/missing_async.rs
index c6a5efa97c..88786ed988 100644
--- a/tests/all/missing_async.rs
+++ b/tests/all/missing_async.rs
@@ -332,7 +332,7 @@ fn start_sync_then_configure_async_then_do_async() -> Result<()> {
#[tokio::test]
async fn async_limiter_disallows_table_new() -> Result<()> {
let mut store = async_limiter_store();
- let ty = TableType::new(RefType::FUNCREF, 1, None);
+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;
assert!(Table::new(&mut store, ty.clone(), Ref::Func(None)).is_err());
Table::new_async(&mut store, ty, Ref::Func(None)).await?;
Ok(())
@@ -341,7 +341,7 @@ async fn async_limiter_disallows_table_new() -> Result<()> {
#[tokio::test]
async fn async_limiter_disallows_table_grow() -> Result<()> {
let mut store = async_limiter_store();
- let ty = TableType::new(RefType::FUNCREF, 1, None);
+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;
let table = Table::new_async(&mut store, ty, Ref::Func(None)).await?;
assert!(table.grow(&mut store, 1, Ref::Func(None)).is_err());
table.grow_async(&mut store, 1, Ref::Func(None)).await?;
@@ -351,7 +351,7 @@ async fn async_limiter_disallows_table_grow() -> Result<()> {
#[tokio::test]
async fn async_limiter_disallows_memory_new() -> Result<()> {
let mut store = async_limiter_store();
- let ty = MemoryType::new(1, None);
+ let ty = MemoryType::new(1, None)?;
assert!(Memory::new(&mut store, ty.clone()).is_err());
Memory::new_async(&mut store, ty).await?;
Ok(())
@@ -360,7 +360,7 @@ async fn async_limiter_disallows_memory_new() -> Result<()> {
#[tokio::test]
async fn async_limiter_disallows_memory_grow() -> Result<()> {
let mut store = async_limiter_store();
- let ty = MemoryType::new(1, None);
+ let ty = MemoryType::new(1, None)?;
let mem = Memory::new_async(&mut store, ty).await?;
assert!(mem.grow(&mut store, 1).is_err());
mem.grow_async(&mut store, 1).await?;
diff --git a/tests/all/pooling_allocator.rs b/tests/all/pooling_allocator.rs
index 4ef8ef79fb..3e4c393f9e 100644
--- a/tests/all/pooling_allocator.rs
+++ b/tests/all/pooling_allocator.rs
@@ -506,7 +506,7 @@ fn multi_memory_with_imported_memories() -> Result<()> {
let mut store = Store::new(&engine, ());
- let m1 = Memory::new(&mut store, MemoryType::new(0, None))?;
+ let m1 = Memory::new(&mut store, MemoryType::new(0, None)?)?;
let instance = Instance::new(&mut store, &module, &[m1.into()])?;
let m2 = instance.get_memory(&mut store, "m2").unwrap();
diff --git a/tests/all/table.rs b/tests/all/table.rs
index 6d8d9bd843..b47670546b 100644
--- a/tests/all/table.rs
+++ b/tests/all/table.rs
@@ -3,7 +3,7 @@ use wasmtime::*;
#[test]
fn get_none() {
let mut store = Store::<()>::default();
- let ty = TableType::new(RefType::FUNCREF, 1, None);
+ let ty = TableType::new(RefType::FUNCREF, 1, None).unwrap();
let table = Table::new(&mut store, ty, Ref::Func(None)).unwrap();
match table.get(&mut store, 0) {
Some(Ref::Func(None)) => {}
@@ -12,10 +12,21 @@ fn get_none() {
assert!(table.get(&mut store, 1).is_none());
}
+#[test]
+fn min_greater_than_max() -> Result<()> {
+ assert!(TableType::new(RefType::FUNCREF, 10, Some(5)).is_err());
+ assert!(TableType::new64(RefType::FUNCREF, 10, Some(5)).is_err());
+
+ let mut store = Store::<()>::default();
+ let ty = TableType::new(RefType::FUNCREF, 5, Some(5))?;
+ Table::new(&mut store, ty, Ref::Func(None))?;
+ Ok(())
+}
+
#[test]
fn fill_wrong() {
let mut store = Store::<()>::default();
- let ty = TableType::new(RefType::FUNCREF, 1, None);
+ let ty = TableType::new(RefType::FUNCREF, 1, None).unwrap();
let table = Table::new(&mut store, ty, Ref::Func(None)).unwrap();
assert_eq!(
table
@@ -25,7 +36,7 @@ fn fill_wrong() {
"type mismatch: value does not match table element type"
);
- let ty = TableType::new(RefType::EXTERNREF, 1, None);
+ let ty = TableType::new(RefType::EXTERNREF, 1, None).unwrap();
let table = Table::new(&mut store, ty, Ref::Extern(None)).unwrap();
assert_eq!(
table
@@ -39,9 +50,9 @@ fn fill_wrong() {
#[test]
fn copy_wrong() {
let mut store = Store::<()>::default();
- let ty = TableType::new(RefType::FUNCREF, 1, None);
+ let ty = TableType::new(RefType::FUNCREF, 1, None).unwrap();
let table1 = Table::new(&mut store, ty, Ref::Func(None)).unwrap();
- let ty = TableType::new(RefType::EXTERNREF, 1, None);
+ let ty = TableType::new(RefType::EXTERNREF, 1, None).unwrap();
let table2 = Table::new(&mut store, ty, Ref::Extern(None)).unwrap();
assert_eq!(
Table::copy(&mut store, &table1, 0, &table2, 0, 1)
@@ -55,7 +66,7 @@ fn copy_wrong() {
#[cfg_attr(miri, ignore)]
fn null_elem_segment_works_with_imported_table() -> Result<()> {
let mut store = Store::<()>::default();
- let ty = TableType::new(RefType::FUNCREF, 1, None);
+ let ty = TableType::new(RefType::FUNCREF, 1, None)?;
let table = Table::new(&mut store, ty, Ref::Func(None))?;
let module = Module::new(
store.engine(),
@@ -98,7 +109,7 @@ fn i31ref_table_new() -> Result<()> {
vec![AnyRef::from_i31(&mut store, I31::default()).into()],
),
] {
- let table_ty = TableType::new(elem_ty, 10, None);
+ let table_ty = TableType::new(elem_ty, 10, None)?;
for init in inits {
Table::new(&mut store, table_ty.clone(), init)?;
}
@@ -129,7 +140,7 @@ fn i31ref_table_get() -> Result<()> {
vec![AnyRef::from_i31(&mut store, I31::default()).into()],
),
] {
- let table_ty = TableType::new(elem_ty, 10, None);
+ let table_ty = TableType::new(elem_ty, 10, None)?;
for init in inits {
let table = Table::new(&mut store, table_ty.clone(), init.clone())?;
for i in 0..10 {
@@ -177,7 +188,7 @@ fn i31ref_table_set() -> Result<()> {
vec![AnyRef::from_i31(&mut store, I31::wrapping_u32(42)).into()],
),
] {
- let table_ty = TableType::new(elem_ty, 10, None);
+ let table_ty = TableType::new(elem_ty, 10, None)?;
for init in inits {
for expected in vals.clone() {
let table = Table::new(&mut store, table_ty.clone(), init.clone())?;
@@ -219,7 +230,7 @@ fn i31ref_table_grow() -> Result<()> {
AnyRef::from_i31(&mut store, I31::default()).into(),
),
] {
- let table_ty = TableType::new(elem_ty, 10, None);
+ let table_ty = TableType::new(elem_ty, 10, None)?;
let table = Table::new(&mut store, table_ty, init)?;
assert_eq!(table.size(&store), 10);
for i in 10..20 {
@@ -256,7 +267,7 @@ fn i31ref_table_fill() -> Result<()> {
let engine = Engine::new(&config)?;
let mut store = Store::new(&engine, ());
- let table_ty = TableType::new(RefType::I31REF, 10, None);
+ let table_ty = TableType::new(RefType::I31REF, 10, None)?;
let table = Table::new(&mut store, table_ty, Ref::Any(None))?;
let expected = I31::wrapping_u32(42);
@@ -299,7 +310,7 @@ fn i31ref_table_copy() -> Result<()> {
let engine = Engine::new(&config)?;
let mut store = Store::new(&engine, ());
- let table_ty = TableType::new(RefType::I31REF, 10, None);
+ let table_ty = TableType::new(RefType::I31REF, 10, None)?;
let dst_table = Table::new(&mut store, table_ty.clone(), Ref::Any(None))?;
let expected = I31::wrapping_u32(42);
@@ -347,7 +358,7 @@ fn host_table_keep_type_registration() -> Result<()> {
let t = Table::new(
&mut store,
- TableType::new(RefType::new(true, HeapType::ConcreteFunc(ty)), 1, None),
+ TableType::new(RefType::new(true, HeapType::ConcreteFunc(ty)), 1, None)?,
Ref::Func(None),
)?;
diff --git a/tests/all/threads.rs b/tests/all/threads.rs
index 66dd2ced64..dc4bf4635a 100644
--- a/tests/all/threads.rs
+++ b/tests/all/threads.rs
@@ -32,7 +32,7 @@ fn shared_memory_failed_creation() -> Result<()> {
let Ok(engine) = Engine::new(&config) else {
return Ok(());
};
- assert!(SharedMemory::new(&engine, MemoryType::shared(1, 1)).is_err());
+ assert!(SharedMemory::new(&engine, MemoryType::shared(1, 1)?).is_err());
let wat = r#"(module (memory 1 1 shared))"#;
let module = Module::new(&engine, wat)?;
let mut store = Store::new(&engine, ());
@@ -62,7 +62,7 @@ fn test_import_shared_memory() -> Result<()> {
};
let module = Module::new(&engine, wat)?;
let mut store = Store::new(&engine, ());
- let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 5))?;
+ let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 5)?)?;
let _instance = Instance::new(&mut store, &module, &[shared_memory.into()])?;
Ok(())
}
@@ -98,7 +98,7 @@ fn test_sharing_of_shared_memory() -> Result<()> {
};
let module = Module::new(&engine, wat)?;
let mut store = Store::new(&engine, ());
- let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 5))?;
+ let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 5)?)?;
let instance1 = Instance::new(&mut store, &module, &[shared_memory.clone().into()])?;
let instance2 = Instance::new(&mut store, &module, &[shared_memory.clone().into()])?;
let data = shared_memory.data();
@@ -171,7 +171,7 @@ fn test_multi_memory() -> Result<()> {
};
let module = Module::new(&engine, wat)?;
let mut store = Store::new(&engine, ());
- let incoming_shared_memory = SharedMemory::new(&engine, MemoryType::shared(5, 10))?;
+ let incoming_shared_memory = SharedMemory::new(&engine, MemoryType::shared(5, 10)?)?;
let instance = Instance::new(&mut store, &module, &[incoming_shared_memory.into()])?;
let owned_memory = instance.get_memory(&mut store, "owned").unwrap();
let shared_memory = instance.get_shared_memory(&mut store, "shared").unwrap();
@@ -208,7 +208,7 @@ fn test_grow_memory_in_multiple_threads() -> Result<()> {
return Ok(());
};
let module = Module::new(&engine, wat)?;
- let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, NUM_GROW_OPS as u32))?;
+ let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, NUM_GROW_OPS as u32)?)?;
let mut threads = vec![];
let observed_sizes = Arc::new(RwLock::new(vec![]));
@@ -280,7 +280,7 @@ fn test_memory_size_accessibility() -> Result<()> {
return Ok(());
};
let module = Module::new(&engine, wat)?;
- let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, NUM_GROW_OPS as u32))?;
+ let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, NUM_GROW_OPS as u32)?)?;
let done = Arc::new(AtomicBool::new(false));
let grow_memory = shared_memory.clone();
@@ -318,6 +318,6 @@ fn test_memory_size_accessibility() -> Result<()> {
fn create_shared_memory_through_memory() -> Result<()> {
let engine = Engine::default();
let mut store = Store::new(&engine, ());
- assert!(Memory::new(&mut store, MemoryType::shared(1, 1)).is_err());
+ assert!(Memory::new(&mut store, MemoryType::shared(1, 1)?).is_err());
Ok(())
}
diff --git a/tests/all/wait_notify.rs b/tests/all/wait_notify.rs
index 0460b3b388..e154bef382 100644
--- a/tests/all/wait_notify.rs
+++ b/tests/all/wait_notify.rs
@@ -23,7 +23,7 @@ fn atomic_wait_timeout_length() -> Result<()> {
};
let module = Module::new(&engine, wat)?;
let mut store = Store::new(&engine, ());
- let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 1))?;
+ let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 1)?)?;
let instance = Instance::new(&mut store, &module, &[shared_memory.clone().into()])?;
let now = Instant::now();
let func_ret = instance
@@ -67,7 +67,7 @@ fn atomic_wait_notify_basic() -> Result<()> {
};
let module = Module::new(&engine, wat)?;
let mut store = Store::new(&engine, ());
- let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 1))?;
+ let shared_memory = SharedMemory::new(&engine, MemoryType::shared(1, 1)?)?;
let instance1 = Instance::new(&mut store, &module, &[shared_memory.clone().into()])?;
let thread = {