Panic when reentering wasm_func_call from C API.

[peterhuene]

Repro

With the following WASM module:

(module
  (type $t0 (func (result i32 i32)))
  (import "" "get" (func $.get (type $t0)))
  (func $add (result i32)
    call $.get
    i32.add
  )
  (export "add" (func $add))
  (func $a (result i32)
    i32.const 1
  )
  (export "a" (func $a))
  (func $b (result i32)
    i32.const 2
  )
  (export "b" (func $b))
)

Define an import for get that calls exported functions a and b on the instance (here is an example of doing so from a prototype C# binding for Wasmtime):

class Host : Wasmtime.Host
{
    [Import("get")]
    public (int, int) Get()
    {
        var instance = (dynamic)Instance;
        return (instance.a(), instance.b());
    }
}

class Program
{
    static void Main(string[] args)
    {
        using (var engine = new Engine())
        {
            using (var store = engine.CreateStore())
            {
                using (var module = store.CreateModule("test.wasm"))
                {
                    using (dynamic instance = module.Instantiate<Host>())
                    {
                        Console.WriteLine($"Function returned: {instance.add()}.");
                    }
                }
            }
        }
    }
}

Expected Result

The program should output:

Function returned: 3.

Actual Result

The program panics:

thread '<unnamed>' panicked at 'already borrowed: BorrowMutError', src/libcore/result.rs:1084:5
stack backtrace:
   0: std::panicking::default_hook::{{closure}}
   1: std::panicking::default_hook
   2: std::panicking::rust_panic_with_hook
   3: std::panicking::continue_panic_fmt
   4: rust_begin_unwind
   5: core::panicking::panic_fmt
   6: core::result::unwrap_failed
   7: core::result::Result<T,E>::expect
   8: core::cell::RefCell<T>::borrow_mut
   9: <wasmtime_api::callable::WasmtimeFn as wasmtime_api::callable::WrappedCallable>::call
  10: wasmtime_api::externals::Func::call
  11: wasm_func_call

Additional Information

The problem appears to be the scope of the borrow for store, which remains borrowed across the call to wasmtime_call_trampoline. This prevents any imported function from calling an exported function.