Pass output via args array

Author: chfast

lib/fizzy/execute.cpp

@@ -478,41 +478,40 @@ inline bool invoke_function(const FuncType& func_type, uint32_t func_idx, Instan
     OperandStack& stack, int depth)
 {
     const auto num_args = func_type.inputs.size();
+    const auto num_outputs = func_type.outputs.size();
     assert(stack.size() >= num_args);
 
     const auto ret = execute_internal(instance, func_idx, stack.rend(), depth + 1);
     // Bubble up traps
     if (ret.trapped)
         return false;
 
-    stack.drop(num_args);
-
-    const auto num_outputs = func_type.outputs.size();
-    // NOTE: we can assume these two from validation
-    assert(num_outputs <= 1);
-    assert(ret.has_value == (num_outputs == 1));
-    // Push back the result
-    if (num_outputs != 0)
-        stack.push(ret.value);
-
+    stack.drop(num_args - num_outputs);
     return true;
 }
 
 }  // namespace
 
 ExecutionResult execute_internal(Instance& instance, FuncIdx func_idx, Value* args_end, int depth)
 {
+    assert(args_end != nullptr);
+
     assert(depth >= 0);
     if (depth > CallStackLimit)
         return Trap;
 
     const auto& func_type = instance.module->get_function_type(func_idx);
 
-    const auto* args = args_end - func_type.inputs.size();
+    auto* args = args_end - func_type.inputs.size();
 
     assert(instance.module->imported_function_types.size() == instance.imported_functions.size());
     if (func_idx < instance.imported_functions.size())
-        return instance.imported_functions[func_idx].function(instance, args, depth);
+    {
+        const auto res = instance.imported_functions[func_idx].function(instance, args, depth);
+        if (res.has_value)
+            args[0] = res.value;
+        return res;
+    }
 
     const auto& code = instance.module->get_code(func_idx);
     auto* const memory = instance.memory.get();
@@ -1536,7 +1535,10 @@ ExecutionResult execute_internal(Instance& instance, FuncIdx func_idx, Value* ar
     assert(pc == &code.instructions[code.instructions.size()]);  // End of code must be reached.
     assert(stack.size() == instance.module->get_function_type(func_idx).outputs.size());
 
-    return stack.size() != 0 ? ExecutionResult{stack.top()} : Void;
+    if (stack.size() != 0 && args != nullptr)
+        args[0] = stack.top();
+
+    return Void;
 
 trap:
     return Trap;

lib/fizzy/execute.hpp

@@ -43,9 +43,31 @@ ExecutionResult execute_internal(Instance& instance, FuncIdx func_idx, Value* ar
 inline ExecutionResult execute(
     Instance& instance, FuncIdx func_idx, const Value* args, int depth = 0)
 {
-    const auto num_args = instance.module->get_function_type(func_idx).inputs.size();
-    auto* args_end = const_cast<Value*>(args + num_args);
-    return execute_internal(instance, func_idx, args_end, depth);
+    const auto& func_type = instance.module->get_function_type(func_idx);
+    const auto num_args = func_type.inputs.size();
+    const auto num_outputs = func_type.outputs.size();
+    assert(num_outputs <= 1);
+
+    const auto arg0 = num_args >= 1 ? args[0] : Value{};
+
+    Value fake_arg;
+    auto* p_args = num_args == 0 ? &fake_arg : const_cast<Value*>(args);
+
+    auto* args_end = p_args + num_args;
+    const auto res = execute_internal(instance, func_idx, args_end, depth);
+
+    if (res.trapped)
+        return res;
+
+    if (num_outputs == 1)
+    {
+        // Restore original value, because the caller does not expect it being modified.
+        const auto result_value = p_args[0];
+        p_args[0] = arg0;
+        return ExecutionResult(result_value);
+    }
+
+    return Void;
 }
 
 inline ExecutionResult execute(

lib/fizzy/stack.hpp

@@ -160,7 +160,7 @@ class OperandStack
 
     void drop(size_t num) noexcept
     {
-        assert(num <= size());
+        //        assert(num <= size());
         m_top -= num;
     }