Correct the meaning of CallStackLimit

Previously there were 2049 number of recursive calls allowed (depth
levels from 0 to 2048). With this change the number is reduced to 2048
(depth levels from 0 to 2047).

lib/fizzy/execute.cpp

@@ -504,7 +504,7 @@ inline bool invoke_function(const FuncType& func_type, uint32_t func_idx, Instan
 ExecutionResult execute(Instance& instance, FuncIdx func_idx, const Value* args, int depth)
 {
     assert(depth >= 0);
-    if (depth > CallStackLimit)
+    if (depth >= CallStackLimit)
         return Trap;
 
     const auto& func_type = instance.module->get_function_type(func_idx);

lib/fizzy/limits.hpp

@@ -19,8 +19,10 @@ static_assert(MemoryPagesValidationLimit == 65536);
 // The default hard limit of the memory size (256MB) as number of pages.
 constexpr uint32_t DefaultMemoryPagesLimit = (256 * 1024 * 1024ULL) / PageSize;
 
-// Call depth limit is set to default limit in wabt.
-// https://github.com/WebAssembly/wabt/blob/ae2140ddc6969ef53599fe2fab81818de65db875/src/interp/interp.h#L1007
-// TODO: review this
+
+/// The limit of the size of the call stack, i.e. how many calls are allowed to be stacked up
+/// in a single execution thread. Allowed values for call depth levels are [0, CallStackLimit-1].
+/// The current value is the same as the default limit in WABT:
+/// https://github.com/WebAssembly/wabt/blob/1.0.20/src/interp/interp.h#L1027
 constexpr int CallStackLimit = 2048;
 }  // namespace fizzy

test/unittests/execute_call_test.cpp

@@ -605,8 +605,7 @@ TEST(execute_call, call_indirect_infinite_recursion)
     EXPECT_TRUE(execute(module, 0, {}).trapped);
 }
 
-constexpr int MaxDepth = 2048;
-static_assert(MaxDepth == CallStackLimit);
+constexpr auto MaxDepth = CallStackLimit - 1;
 
 TEST(execute_call, call_initial_depth)
 {
@@ -805,7 +804,7 @@ TEST(execute_call, call_imported_interleaved_infinite_recursion)
     int counter = 0;
     auto host_foo = [&counter](Instance& instance, const Value* args, int depth) {
         // Function $f will increase depth. This means each iteration goes 2 steps deeper.
-        EXPECT_LE(depth, MaxDepth);
+        EXPECT_LT(depth, CallStackLimit);
         ++counter;
         return execute(instance, 1, args, depth + 1);
     };
@@ -816,12 +815,12 @@ TEST(execute_call, call_imported_interleaved_infinite_recursion)
     // Start with the imported host function.
     counter = 0;
     EXPECT_THAT(execute(*instance, 0, {}), Traps());
-    EXPECT_EQ(counter, MaxDepth / 2 + 1);
+    EXPECT_EQ(counter, CallStackLimit / 2);
 
     // Start with the wasm function.
     counter = 0;
     EXPECT_THAT(execute(*instance, 1, {}), Traps());
-    EXPECT_EQ(counter, MaxDepth / 2);
+    EXPECT_EQ(counter, CallStackLimit / 2);
 }
 
 TEST(execute_call, call_imported_max_depth_recursion)
@@ -858,7 +857,7 @@ TEST(execute_call, call_via_imported_max_depth_recursion)
     const auto module = parse(wasm);
     auto host_foo = [](Instance& instance, const Value* args, int depth) -> ExecutionResult {
         // Function $f will increase depth. This means each iteration goes 2 steps deeper.
-        if (depth == (MaxDepth - 1))
+        if (depth == MaxDepth)
             return Value{uint32_t{1}};  // Terminate recursion on the max depth.
         return execute(instance, 1, args, depth + 1);
     };