Simpler implementation of ExecuteFunction

lib/fizzy/instantiate.cpp

@@ -470,18 +470,13 @@ std::optional<FuncIdx> find_exported_function(const Module& module, std::string_
     return find_export(module, ExternalKind::Function, name);
 }
 
-ExecuteFunction::ExecuteFunction(Instance& instance, FuncIdx func_idx)
-  : m_function([](void* context, Instance&, const Value* args, int depth) noexcept {
-        auto [idx, inst] = *static_cast<std::pair<FuncIdx, Instance*>*>(context);
-        return execute(*inst, idx, args, depth);
-    }),
-    m_context(std::make_shared<std::pair<FuncIdx, Instance*>>(func_idx, &instance))
-{}
-
 ExecutionResult ExecuteFunction::operator()(
     Instance& instance, const Value* args, int depth) noexcept
 {
-    return m_function(m_context.get(), instance, args, depth);
+    if (m_instance)
+        return execute(*m_instance, m_func_idx, args, depth);
+    else
+        return m_host_function(m_host_context.get(), instance, args, depth);
 }
 
 std::optional<ExternalFunction> find_exported_function(Instance& instance, std::string_view name)

lib/fizzy/instantiate.hpp

@@ -33,24 +33,28 @@ class ExecuteFunction
     ExecuteFunction() = default;
 
     // WebAssembly function constructor.
-    ExecuteFunction(Instance& instance, FuncIdx func_idx);
+    ExecuteFunction(Instance& instance, FuncIdx func_idx) noexcept
+      : m_instance{&instance}, m_func_idx{func_idx}
+    {}
 
     // Host function constructor without taking ownership of context.
     ExecuteFunction(ExecuteFunctionPtr f, void* context = nullptr)
-      : m_function{f}, m_context{context, [](void*) noexcept {}}
+      : m_host_function{f}, m_host_context{context, [](void*) noexcept {}}
     {}
 
     // Host function constructor taking ownership of context.
     // Context will be alive as long as this function is.
     ExecuteFunction(ExecuteFunctionPtr f, std::shared_ptr<void> context)
-      : m_function{f}, m_context{std::move(context)}
+      : m_host_function{f}, m_host_context{std::move(context)}
     {}
 
     ExecutionResult operator()(Instance& instance, const Value* args, int depth) noexcept;
 
 private:
-    ExecuteFunctionPtr m_function = nullptr;
-    std::shared_ptr<void> m_context;
+    Instance* m_instance = nullptr;
+    FuncIdx m_func_idx = 0;
+    ExecuteFunctionPtr m_host_function = nullptr;
+    std::shared_ptr<void> m_host_context;
 };
 
 /// Function with associated input/output types,