Add segmented stack space to ExecutionContext

Author: chfast

lib/fizzy/execute.cpp

@@ -565,6 +565,7 @@ ExecutionResult execute(
         return Trap;
 
     const auto& func_type = instance.module->get_function_type(func_idx);
+    const auto args_count = func_type.inputs.size();
 
     assert(instance.module->imported_function_types.size() == instance.imported_functions.size());
     if (func_idx < instance.imported_functions.size())
@@ -573,10 +574,12 @@ ExecutionResult execute(
     const auto& code = instance.module->get_code(func_idx);
     auto* const memory = instance.memory.get();
 
-    const auto ctx_guard = ctx.increment_call_depth();
+    const auto required_stack_space =
+        args_count + code.local_count + static_cast<size_t>(code.max_stack_height);
+    const auto ctx_guard = ctx.increment_call_depth(required_stack_space);
 
-    OperandStack stack(args, func_type.inputs.size(), code.local_count,
-        static_cast<size_t>(code.max_stack_height));
+    OperandStack stack(
+        args, args_count, code.local_count, static_cast<size_t>(code.max_stack_height));
 
     const uint8_t* pc = code.instructions.data();
 

lib/fizzy/execute.hpp

@@ -45,6 +45,8 @@ constexpr ExecutionResult Trap{false};
 /// Users may decide how to allocate the execution context, but some good defaults are available.
 class ExecutionContext
 {
+    static constexpr size_t DefaultStackSpaceSegmentSize = 100;
+
     /// Call depth increment guard.
     /// It will automatically decrement the call depth to the original value
     /// when going out of scope.
@@ -53,19 +55,63 @@ class ExecutionContext
         ExecutionContext& m_execution_context;  ///< Reference to the guarded execution context.
 
     public:
+        Value* stack_space = nullptr;
+        Value* prev_stack_space_segment = nullptr;
+        size_t prev_free_stack_space = 0;
+
+        Guard(Guard&&) = default;
+        Guard(const Guard&) = delete;
+        Guard& operator=(Guard&&) = delete;
+        Guard& operator=(const Guard&) = delete;
+
         explicit Guard(ExecutionContext& ctx) noexcept : m_execution_context{ctx} {}
-        ~Guard() noexcept { --m_execution_context.depth; }
+
+        ~Guard() noexcept
+        {
+            --m_execution_context.depth;
+
+            m_execution_context.free_stack_space = prev_free_stack_space;
+            if (prev_stack_space_segment != nullptr)
+            {
+                assert(m_execution_context.stack_space_segment == stack_space);
+                delete[] stack_space;
+                m_execution_context.stack_space_segment = prev_stack_space_segment;
+            }
+        }
     };
 
 public:
+    Value first_stack_space_segment[DefaultStackSpaceSegmentSize];
+    Value* stack_space_segment = first_stack_space_segment;
+    size_t free_stack_space = DefaultStackSpaceSegmentSize;
+
     int depth = 0;  ///< Current call depth.
 
     /// Increments the call depth and returns the guard object which decrements
     /// the call depth back to the original value when going out of scope.
-    Guard increment_call_depth() noexcept
+    Guard increment_call_depth(size_t required_stack_space = 0) noexcept
     {
         ++depth;
-        return Guard{*this};
+        Guard g{*this};
+
+        g.prev_free_stack_space = free_stack_space;
+
+        if (required_stack_space <= free_stack_space)
+        {
+            // Must be a segment of default size or required_stack_space is 0.
+            const auto offset = DefaultStackSpaceSegmentSize - free_stack_space;
+            g.stack_space = stack_space_segment + offset;
+            g.prev_free_stack_space = free_stack_space;
+            free_stack_space -= required_stack_space;
+            return g;
+        }
+
+        g.prev_stack_space_segment = stack_space_segment;
+        const auto new_segment_size = std::max(DefaultStackSpaceSegmentSize, required_stack_space);
+        stack_space_segment = new Value[new_segment_size];
+        g.stack_space = stack_space_segment;
+        free_stack_space = new_segment_size - required_stack_space;
+        return g;
     }
 };