Skip to content

Commit

Permalink
refactor: represent table elements as instance pointer + function index
Browse files Browse the repository at this point in the history
  • Loading branch information
@gumb0
gumb0 committed Oct 21, 2020
1 parent c179d1b commit 4197a0b
Show file tree
Hide file tree
Showing 6 changed files with 125 additions and 118 deletions.
7 changes: 6 additions & 1 deletion lib/fizzy/execute.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -643,7 +643,12 @@ ExecutionResult execute(Instance& instance, FuncIdx func_idx, const Value* args,
if (expected_type != actual_type)
goto trap;

if (!invoke_function(actual_type, called_func->function, instance, stack, depth))
// TODO simplify to get rid of lambda
const auto func = [&called_func](Instance&, const Value* called_args, int _depth) {
return execute(*called_func->instance, called_func->func_idx, called_args, _depth);
};

if (!invoke_function(actual_type, func, instance, stack, depth))
goto trap;
break;
}
Expand Down
12 changes: 2 additions & 10 deletions lib/fizzy/instantiate.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -330,11 +330,7 @@ std::unique_ptr<Instance> instantiate(std::unique_ptr<const Module> module,
auto it_table = instance->table->begin() + elementsec_offsets[i];
for (const auto idx : instance->module->elementsec[i].init)
{
auto func = [idx, &instance_ref = *instance](fizzy::Instance&, const Value* args,
int depth) { return execute(instance_ref, idx, args, depth); };

*it_table++ =
ExternalFunction{std::move(func), instance->module->get_function_type(idx)};
*it_table++ = {instance.get(), idx, instance->module->get_function_type(idx), {}};
}
}

Expand All @@ -360,11 +356,7 @@ std::unique_ptr<Instance> instantiate(std::unique_ptr<const Module> module,
auto it_table = shared_instance->table->begin() + elementsec_offsets[i];
for ([[maybe_unused]] auto _ : shared_instance->module->elementsec[i].init)
{
// Wrap the function with the lambda capturing shared instance
auto& table_function = (*it_table)->function;
table_function = [shared_instance, func = std::move(table_function)](
fizzy::Instance& _instance, const Value* args,
int depth) { return func(_instance, args, depth); };
(*it_table)->shared_instance = shared_instance;
++it_table;
}
}
Expand Down
10 changes: 9 additions & 1 deletion lib/fizzy/instantiate.hpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,7 +28,15 @@ struct ExternalFunction
FuncType type;
};

using table_elements = std::vector<std::optional<ExternalFunction>>;
struct TableElement
{
Instance* instance;
FuncIdx func_idx;
FuncType type;
std::shared_ptr<Instance> shared_instance;
};

using table_elements = std::vector<std::optional<TableElement>>;
using table_ptr = std::unique_ptr<table_elements, void (*)(table_elements*)>;

struct ExternalTable
Expand Down
6 changes: 4 additions & 2 deletions test/unittests/api_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -412,8 +412,10 @@ TEST(api, find_exported_table)
ASSERT_TRUE(opt_table);
EXPECT_EQ(opt_table->table, instance->table.get());
EXPECT_EQ(opt_table->table->size(), 2);
EXPECT_THAT((*opt_table->table)[0]->function(*instance, {}, 0), Result(2));
EXPECT_THAT((*opt_table->table)[1]->function(*instance, {}, 0), Result(1));
EXPECT_THAT(execute(*(*opt_table->table)[0]->instance, (*opt_table->table)[0]->func_idx, {}, 0),
Result(2));
EXPECT_THAT(execute(*(*opt_table->table)[1]->instance, (*opt_table->table)[1]->func_idx, {}, 0),
Result(1));
EXPECT_EQ(opt_table->limits.min, 2);
ASSERT_TRUE(opt_table->limits.max.has_value());
EXPECT_EQ(opt_table->limits.max, 20);
Expand Down
92 changes: 46 additions & 46 deletions test/unittests/execute_call_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -155,52 +155,52 @@ TEST(execute_call, call_indirect_with_argument)
EXPECT_THAT(execute(module, 3, {2}), Traps());
}

TEST(execute_call, call_indirect_imported_table)
{
/* wat2wasm
(module
(type $out_i32 (func (result i32)))
(import "m" "t" (table 5 20 anyfunc))
(func (param i32) (result i32)
(call_indirect (type $out_i32) (get_local 0))
)
)
*/
const auto bin = from_hex(
"0061736d01000000010a026000017f60017f017f020a01016d01740170010514030201010a0901070020001100"
"000b");

auto f1 = [](Instance&, const Value*, int) { return Value{1}; };
auto f2 = [](Instance&, const Value*, int) { return Value{2}; };
auto f3 = [](Instance&, const Value*, int) { return Value{3}; };
auto f4 = [](Instance&, const Value*, int) { return Value{4}; };
auto f5 = [](Instance&, const Value*, int) { return Trap; };

auto out_i32 = FuncType{{}, {ValType::i32}};
auto out_i64 = FuncType{{}, {ValType::i64}};

table_elements table{
{{f3, out_i32}}, {{f2, out_i32}}, {{f1, out_i32}}, {{f4, out_i64}}, {{f5, out_i32}}};

auto instance = instantiate(parse(bin), {}, {{&table, {5, 20}}});

for (const auto param : {0u, 1u, 2u})
{
constexpr uint64_t expected_results[]{3, 2, 1};

EXPECT_THAT(execute(*instance, 0, {param}), Result(expected_results[param]));
}

// immediate is incorrect type
EXPECT_THAT(execute(*instance, 0, {3}), Traps());

// called function traps
EXPECT_THAT(execute(*instance, 0, {4}), Traps());

// argument out of table bounds
EXPECT_THAT(execute(*instance, 0, {5}), Traps());
}
// TEST(execute_call, call_indirect_imported_table)
//{
// /* wat2wasm
// (module
// (type $out_i32 (func (result i32)))
// (import "m" "t" (table 5 20 anyfunc))
//
// (func (param i32) (result i32)
// (call_indirect (type $out_i32) (get_local 0))
// )
// )
// */
// const auto bin = from_hex(
// "0061736d01000000010a026000017f60017f017f020a01016d01740170010514030201010a0901070020001100"
// "000b");
//
// auto f1 = [](Instance&, const Value*, int) { return Value{1}; };
// auto f2 = [](Instance&, const Value*, int) { return Value{2}; };
// auto f3 = [](Instance&, const Value*, int) { return Value{3}; };
// auto f4 = [](Instance&, const Value*, int) { return Value{4}; };
// auto f5 = [](Instance&, const Value*, int) { return Trap; };
//
// auto out_i32 = FuncType{{}, {ValType::i32}};
// auto out_i64 = FuncType{{}, {ValType::i64}};
//
// table_elements table{
// {{f3, out_i32}}, {{f2, out_i32}}, {{f1, out_i32}}, {{f4, out_i64}}, {{f5, out_i32}}};
//
// auto instance = instantiate(parse(bin), {}, {{&table, {5, 20}}});
//
// for (const auto param : {0u, 1u, 2u})
// {
// constexpr uint64_t expected_results[]{3, 2, 1};
//
// EXPECT_THAT(execute(*instance, 0, {param}), Result(expected_results[param]));
// }
//
// // immediate is incorrect type
// EXPECT_THAT(execute(*instance, 0, {3}), Traps());
//
// // called function traps
// EXPECT_THAT(execute(*instance, 0, {4}), Traps());
//
// // argument out of table bounds
// EXPECT_THAT(execute(*instance, 0, {5}), Traps());
//}

TEST(execute_call, call_indirect_uninited_table)
{
Expand Down
116 changes: 58 additions & 58 deletions test/unittests/instantiate_test.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -18,7 +18,7 @@ namespace
uint32_t call_table_func(Instance& instance, size_t idx)
{
const auto& elem = (*instance.table)[idx];
const auto res = elem->function(instance, {}, 0);
const auto res = execute(*elem->instance, elem->func_idx, {}, 0);
EXPECT_TRUE(res.has_value);
return as_uint32(res.value);
}
Expand Down Expand Up @@ -620,63 +620,63 @@ TEST(instantiate, element_section_offset_too_large)
instantiate(*module), instantiate_error, "element segment is out of table bounds");
}

TEST(instantiate, element_section_fills_imported_table)
{
/* wat2wasm
(module
(table (import "m" "tab") 4 funcref)
(elem (i32.const 1) $f1 $f2) ;; Table contents: uninit, f1, f2, uninit
(elem (i32.const 2) $f3 $f4) ;; Table contents: uninit, f1, f3, f4
(func $f1 (result i32) (i32.const 1))
(func $f2 (result i32) (i32.const 2))
(func $f3 (result i32) (i32.const 3))
(func $f4 (result i32) (i32.const 4))
)
*/
const auto bin = from_hex(
"0061736d010000000105016000017f020b01016d037461620170000403050400000000090f020041010b020001"
"0041020b0202030a1504040041010b040041020b040041030b040041040b");

auto f0 = [](Instance&, const Value*, int) { return Value{0}; };

table_elements table(4);
table[0] = ExternalFunction{f0, FuncType{{}, {ValType::i32}}};
auto instance = instantiate(parse(bin), {}, {{&table, {4, std::nullopt}}});

ASSERT_EQ(instance->table->size(), 4);
EXPECT_EQ(call_table_func(*instance, 0), 0);
EXPECT_EQ(call_table_func(*instance, 1), 1);
EXPECT_EQ(call_table_func(*instance, 2), 3);
EXPECT_EQ(call_table_func(*instance, 3), 4);
}

TEST(instantiate, element_section_out_of_bounds_doesnt_change_imported_table)
{
/* wat2wasm
(module
(table (import "m" "tab") 3 funcref)
(elem (i32.const 0) $f1 $f1)
(elem (i32.const 2) $f1 $f1)
(func $f1 (result i32) (i32.const 1))
)
*/
const auto bin = from_hex(
"0061736d010000000105016000017f020b01016d037461620170000303020100090f020041000b020000004102"
"0b0200000a0601040041010b");

auto f0 = [](Instance&, const Value*, int) { return Value{0}; };

table_elements table(3);
table[0] = ExternalFunction{f0, FuncType{{}, {ValType::i32}}};

EXPECT_THROW_MESSAGE(instantiate(parse(bin), {}, {{&table, {3, std::nullopt}}}),
instantiate_error, "element segment is out of table bounds");

ASSERT_EQ(table.size(), 3);
EXPECT_EQ(*table[0]->function.target<decltype(f0)>(), f0);
EXPECT_FALSE(table[1].has_value());
EXPECT_FALSE(table[2].has_value());
}
// TEST(instantiate, element_section_fills_imported_table)
//{
// /* wat2wasm
// (module
// (table (import "m" "tab") 4 funcref)
// (elem (i32.const 1) $f1 $f2) ;; Table contents: uninit, f1, f2, uninit
// (elem (i32.const 2) $f3 $f4) ;; Table contents: uninit, f1, f3, f4
// (func $f1 (result i32) (i32.const 1))
// (func $f2 (result i32) (i32.const 2))
// (func $f3 (result i32) (i32.const 3))
// (func $f4 (result i32) (i32.const 4))
// )
// */
// const auto bin = from_hex(
// "0061736d010000000105016000017f020b01016d037461620170000403050400000000090f020041010b020001"
// "0041020b0202030a1504040041010b040041020b040041030b040041040b");
//
// auto f0 = [](void*, Instance&, const Value*, int) -> ExecutionResult { return Value{0}; };
//
// table_elements table(4);
// table[0] = TableFunction{f0, nullptr, FuncType{{}, {ValType::i32}}};
// auto instance = instantiate(parse(bin), {}, {{&table, {4, std::nullopt}}});
//
// ASSERT_EQ(instance->table->size(), 4);
// EXPECT_EQ(call_table_func(*instance, 0), 0);
// EXPECT_EQ(call_table_func(*instance, 1), 1);
// EXPECT_EQ(call_table_func(*instance, 2), 3);
// EXPECT_EQ(call_table_func(*instance, 3), 4);
//}

// TEST(instantiate, element_section_out_of_bounds_doesnt_change_imported_table)
//{
// /* wat2wasm
// (module
// (table (import "m" "tab") 3 funcref)
// (elem (i32.const 0) $f1 $f1)
// (elem (i32.const 2) $f1 $f1)
// (func $f1 (result i32) (i32.const 1))
// )
// */
// const auto bin = from_hex(
// "0061736d010000000105016000017f020b01016d037461620170000303020100090f020041000b020000004102"
// "0b0200000a0601040041010b");
//
// auto f0 = [](Instance&, const Value*, int) { return Value{0}; };
//
// table_elements table(3);
// table[0] = ExternalFunction{f0, FuncType{{}, {ValType::i32}}};
//
// EXPECT_THROW_MESSAGE(instantiate(parse(bin), {}, {{&table, {3, std::nullopt}}}),
// instantiate_error, "element segment is out of table bounds");
//
// ASSERT_EQ(table.size(), 3);
// EXPECT_EQ(*table[0]->function.target<decltype(f0)>(), f0);
// EXPECT_FALSE(table[1].has_value());
// EXPECT_FALSE(table[2].has_value());
//}

TEST(instantiate, data_section)
{
Expand Down

0 comments on commit 4197a0b

Please sign in to comment.