Use thread context space

Author: chfast

lib/fizzy/execute.cpp

@@ -463,15 +463,20 @@ __attribute__((no_sanitize("float-cast-overflow"))) inline constexpr float demot
 class ThreadContextGuard
 {
     ThreadContext& m_thread_context;
+    Value* const m_free_space;
 
 public:
     explicit ThreadContextGuard(ThreadContext& thread_context) noexcept
-      : m_thread_context{thread_context}
+      : m_thread_context{thread_context}, m_free_space{m_thread_context.free_space}
     {
         m_thread_context.lock();
     }
 
-    ~ThreadContextGuard() noexcept { m_thread_context.unlock(); }
+    ~ThreadContextGuard() noexcept
+    {
+        m_thread_context.unlock();
+        m_thread_context.free_space = m_free_space;
+    }
 };
 
 }  // namespace
@@ -493,10 +498,14 @@ ExecutionResult execute(Instance& instance, FuncIdx func_idx, span<const Value>
     const auto& code = instance.module.get_code(func_idx);
     auto* const memory = instance.memory.get();
 
-    constexpr auto stack_space_size = 128 / sizeof(Value);
-    Value stack_space[stack_space_size];
+    auto* current_thread_context = &thread_context;
+
     OperandStack stack(args, code.local_count, static_cast<size_t>(code.max_stack_height),
-        stack_space, std::size(stack_space));
+        current_thread_context->free_space, current_thread_context->space_left());
+    const auto storage_size_required =
+        args.size() + code.local_count + static_cast<size_t>(code.max_stack_height);
+    if (storage_size_required <= current_thread_context->space_left())
+        current_thread_context->free_space += storage_size_required;
 
     const Instr* pc = code.instructions.data();
     const uint8_t* immediates = code.immediates.data();
@@ -581,7 +590,8 @@ ExecutionResult execute(Instance& instance, FuncIdx func_idx, span<const Value>
             const auto called_func_idx = read<uint32_t>(immediates);
             const auto& called_func_type = instance.module.get_function_type(called_func_idx);
 
-            if (!invoke_function(called_func_type, called_func_idx, instance, stack, thread_context))
+            if (!invoke_function(
+                    called_func_type, called_func_idx, instance, stack, *current_thread_context))
                 goto trap;
             break;
         }
@@ -607,7 +617,7 @@ ExecutionResult execute(Instance& instance, FuncIdx func_idx, span<const Value>
                 goto trap;
 
             if (!invoke_function(
-                    actual_type, called_func->function, instance, stack, thread_context))
+                    actual_type, called_func->function, instance, stack, *current_thread_context))
                 goto trap;
             break;
         }

lib/fizzy/instantiate.hpp

@@ -25,9 +25,16 @@ struct Instance;
 class ThreadContext
 {
 public:
-    Value stack_space[512];
+    static constexpr size_t N = 128;
 
-    size_t space_left = 512;
+    Value stack_space[N];
+
+    Value* free_space = stack_space;
+
+    size_t space_left() const noexcept
+    {
+        return static_cast<size_t>((stack_space + N) - free_space);
+    }
 
     int depth = 0;
 

lib/fizzy/stack.hpp

@@ -106,7 +106,10 @@ class OperandStack
         }
 
         m_bottom = m_locals + num_args + num_local_variables;
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Warray-bounds"
         m_top = m_bottom - 1;
+#pragma GCC diagnostic pop
 
         std::copy(std::begin(args), std::end(args), m_locals);
         std::fill_n(m_locals + num_args, num_local_variables, 0);

test/unittests/execute_call_test.cpp

@@ -58,6 +58,34 @@ TEST(execute_call, call_with_arguments)
     EXPECT_THAT(execute(parse(wasm), 1, {}), Result(4));
 }
 
+TEST(execute_call, call_shared_stack_space)
+{
+    /* wat2wasm
+    (module
+      (func $double (param i32) (result i64)
+        local.get 0
+        i64.extend_i32_u
+        local.get 0
+        i64.extend_i32_u
+        i64.add
+      )
+
+      (func $main (param i32) (param i32) (result i64)
+        local.get 1
+        local.get 0
+        i32.add
+        call $double
+      )
+    )
+    */
+    const auto wasm = from_hex(
+        "0061736d01000000010c0260017f017e60027f7f017e03030200010a150209002000ad2000ad7c0b0900200120"
+        "006a10000b");
+
+    auto instance = instantiate(parse(wasm));
+    EXPECT_THAT(execute(*instance, 1, {2, 3}), Result(10));  // double(2+3)
+}
+
 TEST(execute_call, call_indirect)
 {
     /* wat2wasm
@@ -205,6 +233,36 @@ TEST(execute_call, call_indirect_uninited_table)
     EXPECT_THAT(execute(module, 3, {4}), Traps());
 }
 
+TEST(execute_call, call_indirect_shared_stack_space)
+{
+    /* wat2wasm
+    (module
+      (type $ft (func (param i32) (result i64)))
+      (func $double (param i32) (result i64)
+        local.get 0
+        i64.extend_i32_u
+        local.get 0
+        i64.extend_i32_u
+        i64.add
+      )
+
+      (func $main (param i32) (param i32) (result i64)
+        local.get 1
+        local.get 0
+        call_indirect (type $ft)
+      )
+
+      (table anyfunc (elem $double))
+    )
+    */
+    const auto wasm = from_hex(
+        "0061736d01000000010c0260017f017e60027f7f017e0303020001040501700101010907010041000b01000a15"
+        "0209002000ad2000ad7c0b0900200120001100000b");
+
+    auto instance = instantiate(parse(wasm));
+    EXPECT_THAT(execute(*instance, 1, {0, 10}), Result(20));  // double(10)
+}
+
 TEST(execute_call, imported_function_call)
 {
     /* wat2wasm
@@ -263,16 +321,16 @@ TEST(execute_call, imported_functions_call_indirect)
       (func $sqr    (import "env" "sqr") (param i32) (result i64))
       (func $isqrt  (import "env" "isqrt") (param i32) (result i64))
       (func $double (param i32) (result i64)
-        get_local 0
-        i64.extend_u/i32
-        get_local 0
-        i64.extend_u/i32
+        local.get 0
+        i64.extend_i32_u
+        local.get 0
+        i64.extend_i32_u
         i64.add
       )
 
       (func $main (param i32) (param i32) (result i64)
-        get_local 1
-        get_local 0
+        local.get 1
+        local.get 0
         call_indirect (type $ft)
       )
 
@@ -529,6 +587,7 @@ TEST(execute_call, call_imported_infinite_recursion)
     auto instance = instantiate(module, {{host_foo, host_foo_type}});
 
     EXPECT_THAT(execute(*instance, 0, {}), Traps());
+    EXPECT_THAT(execute(*instance, 1, {}), Traps());
 }
 
 TEST(execute_call, call_indirect_imported_table_infinite_recursion)

test/unittests/stack_test.cpp

@@ -10,9 +10,11 @@ using namespace testing;
 
 namespace
 {
-intptr_t address_diff(const void* a, const void* b) noexcept
+/// Computes absolute difference of two addresses.
+/*[[clang::no_sanitize("address")]]*/ intptr_t address_diff(const void* a, const void* b) noexcept
 {
-    return std::abs(reinterpret_cast<intptr_t>(a) - reinterpret_cast<intptr_t>(b));
+    const auto diff = reinterpret_cast<intptr_t>(a) - reinterpret_cast<intptr_t>(b);
+    return std::abs(diff);
 }
 }  // namespace