beenull/ladybird
1
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-25 00:50:22 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

LibWasm: Decouple ModuleInstance from the AbstractMachine

Browse source 
This fixes a FIXME and will allow linking only select modules together,
instead of linking every instantiated module into a big mess of exported
entities :P
This commit is contained in:
Ali Mohammad Pur 2021-05-10 15:40:49 +04:30 committed by Linus Groh
parent 24b2a6c93a
commit efb106069b
Notes: sideshowbarker 2024-07-18 17:39:46 +09:00 
Author: https://github.com/alimpfard
Commit: https://github.com/SerenityOS/serenity/commit/efb106069bb
Pull-request: https://github.com/SerenityOS/serenity/pull/7239
Reviewed-by: https://github.com/linusg
4 changed files with 55 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

20
Tests/LibWasm/test-wasm.cpp
View file

@ -31,18 +31,23 @@ class WebAssemblyModule final : public JS::Object {
JS_OBJECT(WebAssemblyModule, JS::Object);
public:
// FIXME: This should only contain an instantiated module, not the entire abstract machine!
explicit WebAssemblyModule(JS::Object& prototype)
: JS::Object(prototype)
{
}
static Wasm::AbstractMachine& machine() { return m_machine; }
Wasm::Module& module() { return *m_module; }
Wasm::ModuleInstance& module_instance() { return *m_module_instance; }
static WebAssemblyModule* create(JS::GlobalObject& global_object, Wasm::Module module)
{
auto instance = global_object.heap().allocate<WebAssemblyModule>(global_object, *global_object.object_prototype());
instance->m_module = move(module);
if (auto result = instance->m_machine.instantiate(*instance->m_module, {}); result.is_error())
if (auto result = machine().instantiate(*instance->m_module, {}); result.is_error())
global_object.vm().throw_exception<JS::TypeError>(global_object, result.release_error().error);
else
instance->m_module_instance = result.release_value();
return instance;
}
void initialize(JS::GlobalObject&) override;
@ -53,10 +58,13 @@ private:
JS_DECLARE_NATIVE_FUNCTION(get_export);
JS_DECLARE_NATIVE_FUNCTION(wasm_invoke);
Wasm::AbstractMachine m_machine;
static Wasm::AbstractMachine m_machine;
Optional<Wasm::Module> m_module;
Optional<Wasm::ModuleInstance> m_module_instance;
};
Wasm::AbstractMachine WebAssemblyModule::m_machine;
TESTJS_GLOBAL_FUNCTION(parse_webassembly_module, parseWebAssemblyModule)
{
auto object = vm.argument(0).to_object(global_object);
@ -123,7 +131,7 @@ JS_DEFINE_NATIVE_FUNCTION(WebAssemblyModule::get_export)
return {};
}
auto instance = static_cast<WebAssemblyModule*>(object);
for (auto& entry : instance->m_machine.module_instance().exports()) {
for (auto& entry : instance->module_instance().exports()) {
if (entry.name() == name) {
auto& value = entry.value();
if (auto ptr = value.get_pointer<Wasm::FunctionAddress>())
@ -151,7 +159,7 @@ JS_DEFINE_NATIVE_FUNCTION(WebAssemblyModule::wasm_invoke)
}
auto instance = static_cast<WebAssemblyModule*>(object);
Wasm::FunctionAddress function_address { address };
auto function_instance = instance->m_machine.store().get(function_address);
auto function_instance = WebAssemblyModule::machine().store().get(function_address);
if (!function_instance) {
vm.throw_exception<JS::TypeError>(global_object, "Invalid function address");
return {};
@ -194,7 +202,7 @@ JS_DEFINE_NATIVE_FUNCTION(WebAssemblyModule::wasm_invoke)
}
}
auto result = instance->m_machine.invoke(function_address, arguments);
auto result = WebAssemblyModule::machine().invoke(function_address, arguments);
if (result.is_trap()) {
vm.throw_exception<JS::TypeError>(global_object, "Execution trapped");
return {};

69
Userland/Libraries/LibWasm/AbstractMachine/AbstractMachine.cpp
View file

@ -85,10 +85,11 @@ GlobalInstance* Store::get(GlobalAddress address)
InstantiationResult AbstractMachine::instantiate(const Module& module, Vector<ExternValue> externs)
{
ModuleInstance main_module_instance;
Optional<InstantiationResult> instantiation_result;
module.for_each_section_of_type<TypeSection>([&](const TypeSection& section) {
m_module_instance.types() = section.types();
main_module_instance.types() = section.types();
});
// FIXME: Validate stuff
@ -121,8 +122,8 @@ InstantiationResult AbstractMachine::instantiate(const Module& module, Vector<Ex
}
});
if (auto result = allocate_all(module, externs, global_values); result.is_error()) {
return result.error();
if (auto result = allocate_all(module, main_module_instance, externs, global_values); result.has_value()) {
return result.release_value();
}
module.for_each_section_of_type<ElementSection>([&](const ElementSection&) {
@ -136,7 +137,7 @@ InstantiationResult AbstractMachine::instantiate(const Module& module, Vector<Ex
segment.value().visit(
[&](const DataSection::Data::Active& data) {
auto frame = make<Frame>(
m_module_instance,
main_module_instance,
Vector<Value> {},
data.offset,
1);
@ -150,11 +151,11 @@ InstantiationResult AbstractMachine::instantiate(const Module& module, Vector<Ex
[&](const ExternAddress&) { instantiation_result = InstantiationError { "Data segment offset returned an address" }; });
if (instantiation_result.has_value() && instantiation_result->is_error())
return;
if (m_module_instance.memories().size() <= data.index.value()) {
instantiation_result = InstantiationError { String::formatted("Data segment referenced out-of-bounds memory ({}) of max {} entries", data.index.value(), m_module_instance.memories().size()) };
if (main_module_instance.memories().size() <= data.index.value()) {
instantiation_result = InstantiationError { String::formatted("Data segment referenced out-of-bounds memory ({}) of max {} entries", data.index.value(), main_module_instance.memories().size()) };
return;
}
auto address = m_module_instance.memories()[data.index.value()];
auto address = main_module_instance.memories()[data.index.value()];
if (auto instance = m_store.get(address)) {
if (instance->type().limits().max().value_or(data.init.size() + offset + 1) <= data.init.size() + offset) {
instantiation_result = InstantiationError { String::formatted("Data segment attempted to write to out-of-bounds memory ({}) of max {} bytes", data.init.size() + offset, instance->type().limits().max().value()) };
@ -171,7 +172,7 @@ InstantiationResult AbstractMachine::instantiate(const Module& module, Vector<Ex
});
module.for_each_section_of_type<StartSection>([&](const StartSection& section) {
auto& functions = m_module_instance.functions();
auto& functions = main_module_instance.functions();
auto index = section.function().index();
if (functions.size() <= index.value()) {
instantiation_result = InstantiationError { String::formatted("Start section function referenced invalid index {} of max {} entries", index.value(), functions.size()) };
@ -180,34 +181,34 @@ InstantiationResult AbstractMachine::instantiate(const Module& module, Vector<Ex
invoke(functions[index.value()], {});
});
return instantiation_result.value_or({});
return instantiation_result.value_or(move(main_module_instance));
}
InstantiationResult AbstractMachine::allocate_all(const Module& module, Vector<ExternValue>& externs, Vector<Value>& global_values)
Optional<InstantiationError> AbstractMachine::allocate_all(const Module& module, ModuleInstance& module_instance, Vector<ExternValue>& externs, Vector<Value>& global_values)
{
Optional<InstantiationResult> result;
Optional<InstantiationError> result;
for (auto& entry : externs) {
entry.visit(
[&](const FunctionAddress& address) { m_module_instance.functions().append(address); },
[&](const TableAddress& address) { m_module_instance.tables().append(address); },
[&](const MemoryAddress& address) { m_module_instance.memories().append(address); },
[&](const GlobalAddress& address) { m_module_instance.globals().append(address); });
[&](const FunctionAddress& address) { module_instance.functions().append(address); },
[&](const TableAddress& address) { module_instance.tables().append(address); },
[&](const MemoryAddress& address) { module_instance.memories().append(address); },
[&](const GlobalAddress& address) { module_instance.globals().append(address); });
}
// FIXME: What if this fails?
for (auto& func : module.functions()) {
auto address = m_store.allocate(m_module_instance, func);
auto address = m_store.allocate(module_instance, func);
VERIFY(address.has_value());
m_module_instance.functions().append(*address);
module_instance.functions().append(*address);
}
module.for_each_section_of_type<TableSection>([&](const TableSection& section) {
for (auto& table : section.tables()) {
auto table_address = m_store.allocate(table.type());
VERIFY(table_address.has_value());
m_module_instance.tables().append(*table_address);
module_instance.tables().append(*table_address);
}
});
@ -215,7 +216,7 @@ InstantiationResult AbstractMachine::allocate_all(const Module& module, Vector<E
for (auto& memory : section.memories()) {
auto memory_address = m_store.allocate(memory.type());
VERIFY(memory_address.has_value());
m_module_instance.memories().append(*memory_address);
module_instance.memories().append(*memory_address);
}
});
@ -224,7 +225,7 @@ InstantiationResult AbstractMachine::allocate_all(const Module& module, Vector<E
for (auto& entry : section.entries()) {
auto address = m_store.allocate(entry.type(), global_values[index]);
VERIFY(address.has_value());
m_module_instance.globals().append(*address);
module_instance.globals().append(*address);
index++;
}
});
@ -234,28 +235,28 @@ InstantiationResult AbstractMachine::allocate_all(const Module& module, Vector<E
Variant<FunctionAddress, TableAddress, MemoryAddress, GlobalAddress, Empty> address { Empty {} };
entry.description().visit(
[&](const FunctionIndex& index) {
if (m_module_instance.functions().size() > index.value())
address = FunctionAddress { m_module_instance.functions()[index.value()] };
if (module_instance.functions().size() > index.value())
address = FunctionAddress { module_instance.functions()[index.value()] };
else
dbgln("Failed to export '{}', the exported address ({}) was out of bounds (min: 0, max: {})", entry.name(), index.value(), m_module_instance.functions().size());
dbgln("Failed to export '{}', the exported address ({}) was out of bounds (min: 0, max: {})", entry.name(), index.value(), module_instance.functions().size());
},
[&](const TableIndex& index) {
if (m_module_instance.tables().size() > index.value())
address = TableAddress { m_module_instance.tables()[index.value()] };
if (module_instance.tables().size() > index.value())
address = TableAddress { module_instance.tables()[index.value()] };
else
dbgln("Failed to export '{}', the exported address ({}) was out of bounds (min: 0, max: {})", entry.name(), index.value(), m_module_instance.tables().size());
dbgln("Failed to export '{}', the exported address ({}) was out of bounds (min: 0, max: {})", entry.name(), index.value(), module_instance.tables().size());
},
[&](const MemoryIndex& index) {
if (m_module_instance.memories().size() > index.value())
address = MemoryAddress { m_module_instance.memories()[index.value()] };
if (module_instance.memories().size() > index.value())
address = MemoryAddress { module_instance.memories()[index.value()] };
else
dbgln("Failed to export '{}', the exported address ({}) was out of bounds (min: 0, max: {})", entry.name(), index.value(), m_module_instance.memories().size());
dbgln("Failed to export '{}', the exported address ({}) was out of bounds (min: 0, max: {})", entry.name(), index.value(), module_instance.memories().size());
},
[&](const GlobalIndex& index) {
if (m_module_instance.globals().size() > index.value())
address = GlobalAddress { m_module_instance.globals()[index.value()] };
if (module_instance.globals().size() > index.value())
address = GlobalAddress { module_instance.globals()[index.value()] };
else
dbgln("Failed to export '{}', the exported address ({}) was out of bounds (min: 0, max: {})", entry.name(), index.value(), m_module_instance.globals().size());
dbgln("Failed to export '{}', the exported address ({}) was out of bounds (min: 0, max: {})", entry.name(), index.value(), module_instance.globals().size());
});
if (address.has<Empty>()) {
@ -263,14 +264,14 @@ InstantiationResult AbstractMachine::allocate_all(const Module& module, Vector<E
continue;
}
m_module_instance.exports().append(ExportInstance {
module_instance.exports().append(ExportInstance {
entry.name(),
move(address).downcast<FunctionAddress, TableAddress, MemoryAddress, GlobalAddress>(),
});
}
});
return result.value_or({});
return result;
}
Result AbstractMachine::invoke(FunctionAddress address, Vector<Value> arguments)

8
Userland/Libraries/LibWasm/AbstractMachine/AbstractMachine.h
View file

@ -15,7 +15,6 @@ namespace Wasm {
struct InstantiationError {
String error { "Unknown error" };
};
using InstantiationResult = Result<void, InstantiationError>;
TYPEDEF_DISTINCT_NUMERIC_GENERAL(u64, true, true, false, false, false, true, FunctionAddress);
TYPEDEF_DISTINCT_NUMERIC_GENERAL(u64, true, true, false, false, false, true, ExternAddress);
@ -419,6 +418,8 @@ private:
Vector<EntryType> m_data;
};
using InstantiationResult = AK::Result<ModuleInstance, InstantiationError>;
class AbstractMachine {
public:
explicit AbstractMachine() = default;
@ -427,14 +428,11 @@ public:
InstantiationResult instantiate(const Module&, Vector<ExternValue>);
Result invoke(FunctionAddress, Vector<Value>);
auto& module_instance() const { return m_module_instance; }
auto& module_instance() { return m_module_instance; }
auto& store() const { return m_store; }
auto& store() { return m_store; }
private:
InstantiationResult allocate_all(const Module&, Vector<ExternValue>&, Vector<Value>& global_values);
ModuleInstance m_module_instance;
Optional<InstantiationError> allocate_all(const Module&, ModuleInstance&, Vector<ExternValue>&, Vector<Value>& global_values);
Store m_store;
};

5
Userland/Utilities/wasm.cpp
View file

@ -70,6 +70,7 @@ int main(int argc, char* argv[])
warnln("Module instantiation failed: {}", result.error().error);
return 1;
}
auto module_instance = result.release_value();
auto stream = Core::OutputFileStream::standard_output();
auto print_func = [&](const auto& address) {
@ -90,7 +91,7 @@ int main(int argc, char* argv[])
};
if (print) {
// Now, let's dump the functions!
for (auto& address : machine.module_instance().functions()) {
for (auto& address : module_instance.functions()) {
print_func(address);
}
}
@ -98,7 +99,7 @@ int main(int argc, char* argv[])
if (!exported_function_to_execute.is_empty()) {
Optional<Wasm::FunctionAddress> run_address;
Vector<Wasm::Value> values;
for (auto& entry : machine.module_instance().exports()) {
for (auto& entry : module_instance.exports()) {
if (entry.name() == exported_function_to_execute) {
if (auto addr = entry.value().get_pointer<Wasm::FunctionAddress>())
run_address = *addr;