Method new_raw

crates/wasmtime/src/runtime/instance.rs:300–351

Internal function to create an instance which doesn't have its `start` function run yet. This is not intended to be exposed from Wasmtime, it's intended to refactor out common code from `new_started` and `new_started_async`. Note that this step needs to be run on a fiber in async mode even though it doesn't do any blocking work because an async resource limiter may need to yield. # Unsafety Th

(
        store: &mut StoreOpaque,
        mut limiter: Option<&mut StoreResourceLimiter<'_>>,
        module: &Module,
        imports: Imports<'_>,
    )

    /// provided. The `imports` provided must be suitable for the module
    /// provided as well.
    async unsafe fn new_raw(
        store: &mut StoreOpaque,
        mut limiter: Option<&mut StoreResourceLimiter<'_>>,
        module: &Module,
        imports: Imports<'_>,
    ) -> Result<Instance> {
        if !Engine::same(store.engine(), module.engine()) {
            bail!("cross-`Engine` instantiation is not currently supported");
        }
        store.bump_resource_counts(module)?;

        // Allocate the GC heap, if necessary.
        if module.env_module().needs_gc_heap {
            store.ensure_gc_store(limiter.as_deref_mut()).await?;

            // Eagerly register trace info for all types in this module.
            if let Some(gc_store) = store.optional_gc_store_mut() {
                for (_, ty) in module.signatures().as_module_map().iter() {
                    gc_store.ensure_trace_info(*ty);
                }
            }
        }

        // Register the module just before instantiation to ensure we keep the module
        // properly referenced while in use by the store.
        let (modules, engine, breakpoints) = store.modules_and_engine_and_breakpoints_mut();
        let module_id = modules.register_module(module, engine, breakpoints)?;

        // The first thing we do is issue an instance allocation request
        // to the instance allocator. This, on success, will give us an
        // instance handle.
        //
        // SAFETY: this module, by construction, was already validated within
        // the store.
        let id = unsafe {
            store
                .allocate_instance(
                    limiter.as_deref_mut(),
                    AllocateInstanceKind::Module(module_id),
                    &ModuleRuntimeInfo::Module(module.clone()),
                    imports,
                )
                .await?
        };

        // At this point the instance is created and stored within the store,
        // but it's also not quite usable just yet. Initialization hasn't
        // completed (e.g. active data/element segments) and the `start`
        // function additionally has not yet been invoked. That's the
        // responsibility of the caller to handle, however.
        Ok(Instance::from_wasmtime(id, store))
    }

    pub(crate) fn from_wasmtime(id: InstanceId, store: &mut StoreOpaque) -> Instance {
        Instance {