refactor: parse returns unique_ptr<const Module>

Author: gumb0

lib/fizzy/instantiate.cpp

@@ -237,7 +237,7 @@ std::optional<uint32_t> find_export(const Module& module, ExternalKind kind, std
 
 }  // namespace
 
-std::unique_ptr<Instance> instantiate(std::unique_ptr<Module> module,
+std::unique_ptr<Instance> instantiate(std::unique_ptr<const Module> module,
     std::vector<ExternalFunction> imported_functions, std::vector<ExternalTable> imported_tables,
     std::vector<ExternalMemory> imported_memories, std::vector<ExternalGlobal> imported_globals,
     uint32_t memory_pages_limit /*= DefaultMemoryPagesLimit*/)

lib/fizzy/instantiate.hpp

@@ -54,7 +54,7 @@ using bytes_ptr = std::unique_ptr<bytes, void (*)(bytes*)>;
 // The module instance.
 struct Instance
 {
-    std::unique_ptr<Module> module;
+    std::unique_ptr<const Module> module;
     // Memory is either allocated and owned by the instance or imported as already allocated bytes
     // and owned externally.
     // For these cases unique_ptr would either have a normal deleter or noop deleter respectively
@@ -70,7 +70,7 @@ struct Instance
     std::vector<ExternalFunction> imported_functions;
     std::vector<ExternalGlobal> imported_globals;
 
-    Instance(std::unique_ptr<Module> _module, bytes_ptr _memory, Limits _memory_limits,
+    Instance(std::unique_ptr<const Module> _module, bytes_ptr _memory, Limits _memory_limits,
         uint32_t _memory_pages_limit, table_ptr _table, Limits _table_limits,
         std::vector<Value> _globals, std::vector<ExternalFunction> _imported_functions,
         std::vector<ExternalGlobal> _imported_globals)
@@ -87,7 +87,7 @@ struct Instance
 };
 
 // Instantiate a module.
-std::unique_ptr<Instance> instantiate(std::unique_ptr<Module> module,
+std::unique_ptr<Instance> instantiate(std::unique_ptr<const Module> module,
     std::vector<ExternalFunction> imported_functions = {},
     std::vector<ExternalTable> imported_tables = {},
     std::vector<ExternalMemory> imported_memories = {},

lib/fizzy/parser.cpp

@@ -430,7 +430,7 @@ inline parser_result<Data> parse(const uint8_t* pos, const uint8_t* end)
     return {{offset, std::move(init)}, pos};
 }
 
-std::unique_ptr<Module> parse(bytes_view input)
+std::unique_ptr<const Module> parse(bytes_view input)
 {
     if (input.substr(0, wasm_prefix.size()) != wasm_prefix)
         throw parser_error{"invalid wasm module prefix"};

lib/fizzy/parser.hpp

@@ -17,7 +17,7 @@ constexpr bytes_view wasm_prefix{wasm_prefix_data, sizeof(wasm_prefix_data)};
 template <typename T>
 using parser_result = std::pair<T, const uint8_t*>;
 
-std::unique_ptr<Module> parse(bytes_view input);
+std::unique_ptr<const Module> parse(bytes_view input);
 
 inline parser_result<uint8_t> parse_byte(const uint8_t* pos, const uint8_t* end)
 {

test/unittests/execute_test.cpp

@@ -380,7 +380,7 @@ TEST(execute, i32_load_all_variants)
         from_hex("0061736d0100000001060160017f017f030201000504010101010a0901070020002802000b");
     const auto module = parse(wasm);
 
-    auto& load_instr = module->codesec[0].instructions[1];
+    auto& load_instr = const_cast<Instr&>(module->codesec[0].instructions[1]);
     ASSERT_EQ(load_instr, Instr::i32_load);
     ASSERT_EQ(module->codesec[0].immediates.substr(4), "00000000"_bytes);  // load offset.
 
@@ -418,7 +418,7 @@ TEST(execute, i64_load_all_variants)
         from_hex("0061736d0100000001060160017f017e030201000504010101010a0901070020002903000b");
     const auto module = parse(wasm);
 
-    auto& load_instr = module->codesec[0].instructions[1];
+    auto& load_instr = const_cast<Instr&>(module->codesec[0].instructions[1]);
     ASSERT_EQ(load_instr, Instr::i64_load);
     ASSERT_EQ(module->codesec[0].immediates.substr(4), "00000000"_bytes);  // load offset.
 
@@ -529,7 +529,7 @@ TEST(execute, i32_store_all_variants)
         from_hex("0061736d0100000001060160027f7f00030201000504010101010a0b010900200120003602000b");
     const auto module = parse(wasm);
 
-    auto& store_instr = module->codesec[0].instructions[2];
+    auto& store_instr = const_cast<Instr&>(module->codesec[0].instructions[2]);
     ASSERT_EQ(store_instr, Instr::i32_store);
     ASSERT_EQ(module->codesec[0].immediates.substr(8), "00000000"_bytes);  // store offset
 
@@ -565,7 +565,7 @@ TEST(execute, i64_store_all_variants)
         from_hex("0061736d0100000001060160027e7f00030201000504010101010a0b010900200120003703000b");
     const auto module = parse(wasm);
 
-    auto& store_instr = module->codesec[0].instructions[2];
+    auto& store_instr = const_cast<Instr&>(module->codesec[0].instructions[2]);
     ASSERT_EQ(store_instr, Instr::i64_store);
     ASSERT_EQ(module->codesec[0].immediates.substr(8), "00000000"_bytes);  // store offset
 

test/utils/execute_helpers.hpp

@@ -16,4 +16,11 @@ inline ExecutionResult execute(
     auto instance = instantiate(*module);
     return execute(*instance, func_idx, args);
 }
+
+inline ExecutionResult execute(const std::unique_ptr<const Module>& module, FuncIdx func_idx,
+    std::initializer_list<Value> args)
+{
+    auto instance = instantiate(*module);
+    return execute(*instance, func_idx, args);
+}
 }  // namespace fizzy::test