diff options
Diffstat (limited to 'Tests/LibWasm/test-wasm.cpp')
| -rw-r--r-- | Tests/LibWasm/test-wasm.cpp | 148 |
1 files changed, 145 insertions, 3 deletions
diff --git a/Tests/LibWasm/test-wasm.cpp b/Tests/LibWasm/test-wasm.cpp index c8f48a3002..ac2eea0b06 100644 --- a/Tests/LibWasm/test-wasm.cpp +++ b/Tests/LibWasm/test-wasm.cpp @@ -27,6 +27,36 @@ TESTJS_GLOBAL_FUNCTION(read_binary_wasm_file, readBinaryWasmFile) return array; } +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 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()) + global_object.vm().throw_exception<JS::TypeError>(global_object, result.release_error().error); + return instance; + } + void initialize(JS::GlobalObject&) override; + + ~WebAssemblyModule() override = default; + +private: + JS_DECLARE_NATIVE_FUNCTION(get_export); + JS_DECLARE_NATIVE_FUNCTION(wasm_invoke); + + Wasm::AbstractMachine m_machine; + Optional<Wasm::Module> m_module; +}; + TESTJS_GLOBAL_FUNCTION(parse_webassembly_module, parseWebAssemblyModule) { auto object = vm.argument(0).to_object(global_object); @@ -43,9 +73,12 @@ TESTJS_GLOBAL_FUNCTION(parse_webassembly_module, parseWebAssemblyModule) vm.throw_exception<JS::SyntaxError>(global_object, Wasm::parse_error_to_string(result.error())); return {}; } - if (stream.handle_any_error()) - return JS::js_undefined(); - return JS::js_null(); + + if (stream.handle_any_error()) { + vm.throw_exception<JS::SyntaxError>(global_object, "Bianry stream contained errors"); + return {}; + } + return WebAssemblyModule::create(global_object, result.release_value()); } TESTJS_GLOBAL_FUNCTION(compare_typed_arrays, compareTypedArrays) @@ -68,3 +101,112 @@ TESTJS_GLOBAL_FUNCTION(compare_typed_arrays, compareTypedArrays) auto& rhs_array = static_cast<JS::TypedArrayBase&>(*rhs); return JS::Value(lhs_array.viewed_array_buffer()->buffer() == rhs_array.viewed_array_buffer()->buffer()); } + +void WebAssemblyModule::initialize(JS::GlobalObject& global_object) +{ + Base::initialize(global_object); + define_native_function("getExport", get_export); + define_native_function("invoke", wasm_invoke); +} + +JS_DEFINE_NATIVE_FUNCTION(WebAssemblyModule::get_export) +{ + auto name = vm.argument(0).to_string(global_object); + if (vm.exception()) + return {}; + auto this_value = vm.this_value(global_object); + auto object = this_value.to_object(global_object); + if (vm.exception()) + return {}; + if (!object || !is<WebAssemblyModule>(object)) { + vm.throw_exception<JS::TypeError>(global_object, "Not a WebAssemblyModule"); + return {}; + } + auto instance = static_cast<WebAssemblyModule*>(object); + for (auto& entry : instance->m_machine.module_instance().exports()) { + if (entry.name() == name) { + auto& value = entry.value(); + if (auto ptr = value.get_pointer<Wasm::FunctionAddress>()) + return JS::Value(static_cast<unsigned long>(ptr->value())); + vm.throw_exception<JS::TypeError>(global_object, String::formatted("'{}' does not refer to a function", name)); + return {}; + } + } + vm.throw_exception<JS::TypeError>(global_object, String::formatted("'{}' could not be found", name)); + return {}; +} + +JS_DEFINE_NATIVE_FUNCTION(WebAssemblyModule::wasm_invoke) +{ + auto address = static_cast<unsigned long>(vm.argument(0).to_double(global_object)); + if (vm.exception()) + return {}; + auto this_value = vm.this_value(global_object); + auto object = this_value.to_object(global_object); + if (vm.exception()) + return {}; + if (!object || !is<WebAssemblyModule>(object)) { + vm.throw_exception<JS::TypeError>(global_object, "Not a WebAssemblyModule"); + return {}; + } + auto instance = static_cast<WebAssemblyModule*>(object); + Wasm::FunctionAddress function_address { address }; + auto function_instance = instance->m_machine.store().get(function_address); + if (!function_instance) { + vm.throw_exception<JS::TypeError>(global_object, "Invalid function address"); + return {}; + } + + const Wasm::FunctionType* type { nullptr }; + function_instance->visit([&](auto& value) { type = &value.type(); }); + if (!type) { + vm.throw_exception<JS::TypeError>(global_object, "Invalid function found at given address"); + return {}; + } + + Vector<Wasm::Value> arguments; + if (type->parameters().size() + 1 > vm.argument_count()) { + vm.throw_exception<JS::TypeError>(global_object, String::formatted("Expected {} arguments for call, but found {}", type->parameters().size() + 1, vm.argument_count())); + return {}; + } + size_t index = 1; + for (auto& param : type->parameters()) { + auto value = vm.argument(index++).to_double(global_object); + switch (param.kind()) { + case Wasm::ValueType::Kind::I32: + arguments.append(Wasm::Value(static_cast<i32>(value))); + break; + case Wasm::ValueType::Kind::I64: + arguments.append(Wasm::Value(static_cast<i64>(value))); + break; + case Wasm::ValueType::Kind::F32: + arguments.append(Wasm::Value(static_cast<float>(value))); + break; + case Wasm::ValueType::Kind::F64: + arguments.append(Wasm::Value(static_cast<double>(value))); + break; + case Wasm::ValueType::Kind::FunctionReference: + arguments.append(Wasm::Value(Wasm::FunctionAddress { static_cast<u64>(value) })); + break; + case Wasm::ValueType::Kind::ExternReference: + arguments.append(Wasm::Value(Wasm::ExternAddress { static_cast<u64>(value) })); + break; + } + } + + auto result = instance->m_machine.invoke(function_address, arguments); + if (result.is_trap()) { + vm.throw_exception<JS::TypeError>(global_object, "Execution trapped"); + return {}; + } + + if (result.values().is_empty()) + return JS::js_null(); + + JS::Value return_value; + result.values().first().value().visit( + [&](const auto& value) { return_value = JS::Value(static_cast<double>(value)); }, + [&](const Wasm::FunctionAddress& index) { return_value = JS::Value(static_cast<double>(index.value())); }, + [&](const Wasm::ExternAddress& index) { return_value = JS::Value(static_cast<double>(index.value())); }); + return return_value; +} |