Support re-entering instance after previous trap inside continuation

[frank-emrich]

TL;DR: We currently have some support for trapping inside a continuation, but things fall apart if you want to re-use the instance afterwards.

Consider the following sequence of events:

• We create an instance i.
• We start execution of some Wasm function entry1 inside i.
• entry1 runs some code inside a continuation. While doing so, a trap occurs.
• Wasm execution terminates, we return to the host.
• We want to execute more code inside i.

The following code snippet illustrates this:

fn reuse_instance_after_trap1() -> Result<()> {
    let wat = r#"
    (module
        (type $ft (func))
        (type $ct (cont $ft))

        (tag $t)

        (func $entry1 (export "entry1")
          (local $c (ref $ct))
          (local.set $c (cont.new $ct (ref.func $b)))
          (block $handlet (result (ref $ct))
            (resume $ct (on $t $handlet) (local.get $c))
            (return)
          )
          (drop)
        )

        (func $entry2 (export "entry2")
          (suspend $t)
        )

        (func $b (export "b")
          (unreachable)
        )
    )
    "#;

    let mut config = Config::default();
    config.wasm_function_references(true);
    config.wasm_exceptions(true);
    config.wasm_stack_switching(true);

    let engine = Engine::new(&config).unwrap();
    let mut store = Store::<()>::new(&engine, ());
    let module = Module::new(&engine, wat)?;

    let instance = Instance::new(&mut store, &module, &[])?;
    let entry1 = instance.get_typed_func::<(), ()>(&mut store, "entry1")?;

    let result1 = entry1.call(&mut store, ());

    let _ = result1.expect_err("Was expecting wasm execution to yield error");

    let entry2 = instance.get_typed_func::<(), ()>(&mut store, "entry2")?;

    let _ = entry2.call(&mut store, ());

    Ok(())
}

This segfaults, for a good reason: At the point when we do instance.get_typed_func::<(), i32>(&mut store, "entry2")?; the Instance (more precisely: the Store) thinks that we are still running inside the continuation previously called $c. On suspend, it then tries to use the context stored in $c about its parent, trying to suspend itself into a stack frame supposed to be executing the (long dead) entry1.

In general, what needs to happen is that either when a trap occurs while running inside a continuation, or when entering an instance in general, we reset the information about the currently active continuation. However, this is rather subtle, due to the various pieces of information associated with it (e.g., we also need to update the VMRuntimeLimits correctly).