1 use crate::TableType;
2 use crate::prelude::*;
3 use crate::runtime::vm::{Imports, ModuleRuntimeInfo, OnDemandInstanceAllocator};
4 use crate::store::{AllocateInstanceKind, InstanceId, StoreOpaque, StoreResourceLimiter};
5 use alloc::sync::Arc;
6 use wasmtime_environ::StaticModuleIndex;
7 use wasmtime_environ::{EntityIndex, Module, TypeTrace};
8 
9 pub async fn create_table(
10     store: &mut StoreOpaque,
11     limiter: Option<&mut StoreResourceLimiter<'_>>,
12     table: &TableType,
13 ) -> Result<InstanceId> {
14     let mut module = Module::new(StaticModuleIndex::from_u32(0));
15 
16     let wasmtime_table = *table.wasmtime_table();
17 
18     debug_assert!(
19         wasmtime_table.ref_type.is_canonicalized_for_runtime_usage(),
20         "should be canonicalized for runtime usage: {:?}",
21         wasmtime_table.ref_type
22     );
23 
24     let table_id = module.tables.push(wasmtime_table);
25 
26     // TODO: can this `exports.insert` get removed?
27     let name = module.strings.insert("")?;
28     module.exports.insert(name, EntityIndex::Table(table_id))?;
29 
30     let imports = Imports::default();
31 
32     unsafe {
33         let allocator =
34             OnDemandInstanceAllocator::new(store.engine().config().mem_creator.clone(), 0, false);
35         let module = Arc::new(module);
36         store
37             .allocate_instance(
38                 limiter,
39                 AllocateInstanceKind::Dummy {
40                     allocator: &allocator,
41                 },
42                 &ModuleRuntimeInfo::bare_with_registered_type(
43                     module,
44                     table.element().clone().into_registered_type(),
45                 )?,
46                 imports,
47             )
48             .await
49     }
50 }
51