Function create_memory

crates/wasmtime/src/runtime/trampoline/memory.rs:27–69

Create a "frankenstein" instance with a single memory. This separate instance is necessary because Wasm objects in Wasmtime must be attached to instances (versus the store, e.g.) and some objects exist outside: a host-provided memory import, shared memory.

(
    store: &mut StoreOpaque,
    limiter: Option<&mut StoreResourceLimiter<'_>>,
    memory_ty: &MemoryType,
    preallocation: Option<&SharedMemory>,
)

/// attached to instances (versus the store, e.g.) and some objects exist
/// outside: a host-provided memory import, shared memory.
pub async fn create_memory(
    store: &mut StoreOpaque,
    limiter: Option<&mut StoreResourceLimiter<'_>>,
    memory_ty: &MemoryType,
    preallocation: Option<&SharedMemory>,
) -> Result<InstanceId> {
    let mut module = Module::new(StaticModuleIndex::from_u32(0));

    // Create a memory, though it will never be used for constructing a memory
    // with an allocator: instead the memories are either preallocated (i.e.,
    // shared memory) or allocated manually below.
    let memory_id = module.memories.push(*memory_ty.wasmtime_memory())?;

    // Since we have only associated a single memory with the "frankenstein"
    // instance, it will be exported at index 0.
    debug_assert_eq!(memory_id.as_u32(), 0);
    let name = module.strings.insert("")?;
    module
        .exports
        .insert(name, EntityIndex::Memory(memory_id))?;
    let info = ModuleRuntimeInfo::bare(try_new::<Arc<_>>(module)?)?;

    // We create an instance in the on-demand allocator when creating handles
    // associated with external objects. The configured instance allocator
    // should only be used when creating module instances as we don't want host
    // objects to count towards instance limits.
    let allocator = SingleMemoryInstance {
        preallocation,
        ondemand: OnDemandInstanceAllocator::default(),
    };
    unsafe {
        store
            .allocate_instance(
                limiter,
                AllocateInstanceKind::Dummy {
                    allocator: &allocator,
                },
                &info,
                Default::default(),
            )
            .await
    }
}

struct LinearMemoryProxy {
    mem: Box<dyn LinearMemory>,