reusing a `Module` may trigger invalid memory access

[tzemanovic]

Describe the bug

Related to #4377 (see comment #4377 (comment)) re-running the same Module that's created with a Store which is dropped after the first run and new Store created for the second run causes a segfault with invalid memory access.

We manage to workaround this issue by keeping a Store that's used to compile cached Modules alive and instantiate a new Store when we want to run them.

wasmer -vV; rustc -vV

Steps to reproduce

I've added a small example that reproduces this here https://github.com/heliaxdev/wasmer/blob/24024841309bff268115ff25cdbb86b1b2db0d52/examples/invalid_memory_access.rs

Run with e.g. cargo run --example invalid-memory-access --features=singlepass

Expected behavior

Module can be re-used for multiple runs

Actual behavior

segfaults on a second loop

[syrusakbary]

This is indeed a bug. We need to check that modules are run within the same store Engine.

Note that modules should not be reused across different stores Engines.

Edit: I had a typo, sorry for the misdirection here

[syrusakbary]

What's happening is that the engine is different each time. We should error when this happens.

At the same time, something like this should work:

    let compiler = Singlepass::default();
    let engine: Engine = compiler.into();
    for i in 0..2 {
        println!("Iteration {i}...");

        let mut store = Store::new(&engine);
        let module = match &module {
            Some(module) => module.clone(),
            None => {
                module = Some(Module::new(&engine, &wasm_bytes).unwrap());
                module.as_ref().unwrap().clone()
            }
        };
        let import_object = imports! {};

        println!("Instantiating module...");
        // Let's instantiate the Wasm module.
        let instance = Instance::new(&mut store, &module, &import_object)?;

        let sum = instance.exports.get_function("sum")?;

        println!("Calling `sum` function...");
        // Let's call the `sum` exported function. The parameters are a
        // slice of `Value`s. The results are a boxed slice of `Value`s.
        // let _results = sum.call(&mut store, 0_i32, 0_i32);

        if i == 1 {
            println!("The next call will segfault");
        }
        let _results = sum.call(&mut store, &[Value::I32(1), Value::I32(2)]);

        println!("Iteration {i} done.");
        println!();
    }

[theduke]

@tzemanovic to clarify:

A module is not tied to a store, it is just tied to an Engine.

You can re-use a module just fine if you stick with one engine instead.
So in your example, just move the engine out of the loop.

Our code should of course fail if you try to re-use a module with the wrong engine, and I actually thought we had added that.
We might have only added it to cranelift, or the change might have been lost.
We'll treat this as a bug and make sure that correctness check happens.