| // Copyright 2015 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "src/wasm/wasm-js.h" |
| |
| #include <cinttypes> |
| #include <cstring> |
| |
| #include "src/api/api-inl.h" |
| #include "src/api/api-natives.h" |
| #include "src/ast/ast.h" |
| #include "src/base/logging.h" |
| #include "src/base/overflowing-math.h" |
| #include "src/common/assert-scope.h" |
| #include "src/execution/execution.h" |
| #include "src/execution/frames-inl.h" |
| #include "src/execution/isolate.h" |
| #include "src/handles/handles.h" |
| #include "src/heap/factory.h" |
| #include "src/init/v8.h" |
| #include "src/objects/js-collection-inl.h" |
| #include "src/objects/js-promise-inl.h" |
| #include "src/objects/objects-inl.h" |
| #include "src/objects/templates.h" |
| #include "src/parsing/parse-info.h" |
| #include "src/tasks/task-utils.h" |
| #include "src/trap-handler/trap-handler.h" |
| #include "src/wasm/function-compiler.h" |
| #include "src/wasm/streaming-decoder.h" |
| #include "src/wasm/value-type.h" |
| #include "src/wasm/wasm-debug.h" |
| #include "src/wasm/wasm-engine.h" |
| #include "src/wasm/wasm-limits.h" |
| #include "src/wasm/wasm-objects-inl.h" |
| #include "src/wasm/wasm-serialization.h" |
| #include "src/wasm/wasm-value.h" |
| |
| using v8::internal::wasm::ErrorThrower; |
| using v8::internal::wasm::ScheduledErrorThrower; |
| |
| namespace v8 { |
| |
| class WasmStreaming::WasmStreamingImpl { |
| public: |
| WasmStreamingImpl( |
| Isolate* isolate, const char* api_method_name, |
| std::shared_ptr<internal::wasm::CompilationResultResolver> resolver) |
| : isolate_(isolate), resolver_(std::move(resolver)) { |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate_); |
| auto enabled_features = i::wasm::WasmFeatures::FromIsolate(i_isolate); |
| streaming_decoder_ = i_isolate->wasm_engine()->StartStreamingCompilation( |
| i_isolate, enabled_features, handle(i_isolate->context(), i_isolate), |
| api_method_name, resolver_); |
| } |
| |
| void OnBytesReceived(const uint8_t* bytes, size_t size) { |
| streaming_decoder_->OnBytesReceived(i::VectorOf(bytes, size)); |
| } |
| void Finish() { streaming_decoder_->Finish(); } |
| |
| void Abort(MaybeLocal<Value> exception) { |
| i::HandleScope scope(reinterpret_cast<i::Isolate*>(isolate_)); |
| streaming_decoder_->Abort(); |
| |
| // If no exception value is provided, we do not reject the promise. This can |
| // happen when streaming compilation gets aborted when no script execution |
| // is allowed anymore, e.g. when a browser tab gets refreshed. |
| if (exception.IsEmpty()) return; |
| |
| resolver_->OnCompilationFailed( |
| Utils::OpenHandle(*exception.ToLocalChecked())); |
| } |
| |
| bool SetCompiledModuleBytes(const uint8_t* bytes, size_t size) { |
| if (!i::wasm::IsSupportedVersion({bytes, size})) return false; |
| return streaming_decoder_->SetCompiledModuleBytes({bytes, size}); |
| } |
| |
| void SetClient(std::shared_ptr<Client> client) { |
| streaming_decoder_->SetModuleCompiledCallback( |
| [client, streaming_decoder = streaming_decoder_]( |
| const std::shared_ptr<i::wasm::NativeModule>& native_module) { |
| i::Vector<const char> url = streaming_decoder->url(); |
| auto compiled_wasm_module = |
| CompiledWasmModule(native_module, url.begin(), url.size()); |
| client->OnModuleCompiled(compiled_wasm_module); |
| }); |
| } |
| |
| void SetUrl(internal::Vector<const char> url) { |
| streaming_decoder_->SetUrl(url); |
| } |
| |
| private: |
| Isolate* const isolate_; |
| std::shared_ptr<internal::wasm::StreamingDecoder> streaming_decoder_; |
| std::shared_ptr<internal::wasm::CompilationResultResolver> resolver_; |
| }; |
| |
| WasmStreaming::WasmStreaming(std::unique_ptr<WasmStreamingImpl> impl) |
| : impl_(std::move(impl)) { |
| TRACE_EVENT0("v8.wasm", "wasm.InitializeStreaming"); |
| } |
| |
| // The destructor is defined here because we have a unique_ptr with forward |
| // declaration. |
| WasmStreaming::~WasmStreaming() = default; |
| |
| void WasmStreaming::OnBytesReceived(const uint8_t* bytes, size_t size) { |
| TRACE_EVENT1("v8.wasm", "wasm.OnBytesReceived", "bytes", size); |
| impl_->OnBytesReceived(bytes, size); |
| } |
| |
| void WasmStreaming::Finish() { |
| TRACE_EVENT0("v8.wasm", "wasm.FinishStreaming"); |
| impl_->Finish(); |
| } |
| |
| void WasmStreaming::Abort(MaybeLocal<Value> exception) { |
| TRACE_EVENT0("v8.wasm", "wasm.AbortStreaming"); |
| impl_->Abort(exception); |
| } |
| |
| bool WasmStreaming::SetCompiledModuleBytes(const uint8_t* bytes, size_t size) { |
| TRACE_EVENT0("v8.wasm", "wasm.SetCompiledModuleBytes"); |
| return impl_->SetCompiledModuleBytes(bytes, size); |
| } |
| |
| void WasmStreaming::SetClient(std::shared_ptr<Client> client) { |
| TRACE_EVENT0("v8.wasm", "wasm.WasmStreaming.SetClient"); |
| impl_->SetClient(client); |
| } |
| |
| void WasmStreaming::SetUrl(const char* url, size_t length) { |
| TRACE_EVENT0("v8.wasm", "wasm.SetUrl"); |
| impl_->SetUrl(internal::VectorOf(url, length)); |
| } |
| |
| // static |
| std::shared_ptr<WasmStreaming> WasmStreaming::Unpack(Isolate* isolate, |
| Local<Value> value) { |
| TRACE_EVENT0("v8.wasm", "wasm.WasmStreaming.Unpack"); |
| i::HandleScope scope(reinterpret_cast<i::Isolate*>(isolate)); |
| auto managed = |
| i::Handle<i::Managed<WasmStreaming>>::cast(Utils::OpenHandle(*value)); |
| return managed->get(); |
| } |
| |
| namespace { |
| |
| #define ASSIGN(type, var, expr) \ |
| Local<type> var; \ |
| do { \ |
| if (!expr.ToLocal(&var)) { \ |
| DCHECK(i_isolate->has_scheduled_exception()); \ |
| return; \ |
| } else { \ |
| DCHECK(!i_isolate->has_scheduled_exception()); \ |
| } \ |
| } while (false) |
| |
| i::Handle<i::String> v8_str(i::Isolate* isolate, const char* str) { |
| return isolate->factory()->NewStringFromAsciiChecked(str); |
| } |
| Local<String> v8_str(Isolate* isolate, const char* str) { |
| return Utils::ToLocal(v8_str(reinterpret_cast<i::Isolate*>(isolate), str)); |
| } |
| |
| #define GET_FIRST_ARGUMENT_AS(Type) \ |
| i::MaybeHandle<i::Wasm##Type##Object> GetFirstArgumentAs##Type( \ |
| const v8::FunctionCallbackInfo<v8::Value>& args, \ |
| ErrorThrower* thrower) { \ |
| i::Handle<i::Object> arg0 = Utils::OpenHandle(*args[0]); \ |
| if (!arg0->IsWasm##Type##Object()) { \ |
| thrower->TypeError("Argument 0 must be a WebAssembly." #Type); \ |
| return {}; \ |
| } \ |
| Local<Object> obj = Local<Object>::Cast(args[0]); \ |
| return i::Handle<i::Wasm##Type##Object>::cast( \ |
| v8::Utils::OpenHandle(*obj)); \ |
| } |
| |
| GET_FIRST_ARGUMENT_AS(Module) |
| GET_FIRST_ARGUMENT_AS(Memory) |
| GET_FIRST_ARGUMENT_AS(Table) |
| GET_FIRST_ARGUMENT_AS(Global) |
| |
| #undef GET_FIRST_ARGUMENT_AS |
| |
| i::wasm::ModuleWireBytes GetFirstArgumentAsBytes( |
| const v8::FunctionCallbackInfo<v8::Value>& args, ErrorThrower* thrower, |
| bool* is_shared) { |
| const uint8_t* start = nullptr; |
| size_t length = 0; |
| v8::Local<v8::Value> source = args[0]; |
| if (source->IsArrayBuffer()) { |
| // A raw array buffer was passed. |
| Local<ArrayBuffer> buffer = Local<ArrayBuffer>::Cast(source); |
| auto backing_store = buffer->GetBackingStore(); |
| |
| start = reinterpret_cast<const uint8_t*>(backing_store->Data()); |
| length = backing_store->ByteLength(); |
| *is_shared = buffer->IsSharedArrayBuffer(); |
| } else if (source->IsTypedArray()) { |
| // A TypedArray was passed. |
| Local<TypedArray> array = Local<TypedArray>::Cast(source); |
| Local<ArrayBuffer> buffer = array->Buffer(); |
| |
| auto backing_store = buffer->GetBackingStore(); |
| |
| start = reinterpret_cast<const uint8_t*>(backing_store->Data()) + |
| array->ByteOffset(); |
| length = array->ByteLength(); |
| *is_shared = buffer->IsSharedArrayBuffer(); |
| } else { |
| thrower->TypeError("Argument 0 must be a buffer source"); |
| } |
| DCHECK_IMPLIES(length, start != nullptr); |
| if (length == 0) { |
| thrower->CompileError("BufferSource argument is empty"); |
| } |
| size_t max_length = i::wasm::max_module_size(); |
| if (length > max_length) { |
| thrower->RangeError("buffer source exceeds maximum size of %zu (is %zu)", |
| max_length, length); |
| } |
| if (thrower->error()) return i::wasm::ModuleWireBytes(nullptr, nullptr); |
| return i::wasm::ModuleWireBytes(start, start + length); |
| } |
| |
| i::MaybeHandle<i::JSReceiver> GetValueAsImports(Local<Value> arg, |
| ErrorThrower* thrower) { |
| if (arg->IsUndefined()) return {}; |
| |
| if (!arg->IsObject()) { |
| thrower->TypeError("Argument 1 must be an object"); |
| return {}; |
| } |
| Local<Object> obj = Local<Object>::Cast(arg); |
| return i::Handle<i::JSReceiver>::cast(v8::Utils::OpenHandle(*obj)); |
| } |
| |
| namespace { |
| // This class resolves the result of WebAssembly.compile. It just places the |
| // compilation result in the supplied {promise}. |
| class AsyncCompilationResolver : public i::wasm::CompilationResultResolver { |
| public: |
| AsyncCompilationResolver(i::Isolate* isolate, i::Handle<i::JSPromise> promise) |
| : promise_(isolate->global_handles()->Create(*promise)) { |
| i::GlobalHandles::AnnotateStrongRetainer(promise_.location(), |
| kGlobalPromiseHandle); |
| } |
| |
| ~AsyncCompilationResolver() override { |
| i::GlobalHandles::Destroy(promise_.location()); |
| } |
| |
| void OnCompilationSucceeded(i::Handle<i::WasmModuleObject> result) override { |
| if (finished_) return; |
| finished_ = true; |
| i::MaybeHandle<i::Object> promise_result = |
| i::JSPromise::Resolve(promise_, result); |
| CHECK_EQ(promise_result.is_null(), |
| promise_->GetIsolate()->has_pending_exception()); |
| } |
| |
| void OnCompilationFailed(i::Handle<i::Object> error_reason) override { |
| if (finished_) return; |
| finished_ = true; |
| i::MaybeHandle<i::Object> promise_result = |
| i::JSPromise::Reject(promise_, error_reason); |
| CHECK_EQ(promise_result.is_null(), |
| promise_->GetIsolate()->has_pending_exception()); |
| } |
| |
| private: |
| static constexpr char kGlobalPromiseHandle[] = |
| "AsyncCompilationResolver::promise_"; |
| bool finished_ = false; |
| i::Handle<i::JSPromise> promise_; |
| }; |
| |
| constexpr char AsyncCompilationResolver::kGlobalPromiseHandle[]; |
| |
| // This class resolves the result of WebAssembly.instantiate(module, imports). |
| // It just places the instantiation result in the supplied {promise}. |
| class InstantiateModuleResultResolver |
| : public i::wasm::InstantiationResultResolver { |
| public: |
| InstantiateModuleResultResolver(i::Isolate* isolate, |
| i::Handle<i::JSPromise> promise) |
| : promise_(isolate->global_handles()->Create(*promise)) { |
| i::GlobalHandles::AnnotateStrongRetainer(promise_.location(), |
| kGlobalPromiseHandle); |
| } |
| |
| ~InstantiateModuleResultResolver() override { |
| i::GlobalHandles::Destroy(promise_.location()); |
| } |
| |
| void OnInstantiationSucceeded( |
| i::Handle<i::WasmInstanceObject> instance) override { |
| i::MaybeHandle<i::Object> promise_result = |
| i::JSPromise::Resolve(promise_, instance); |
| CHECK_EQ(promise_result.is_null(), |
| promise_->GetIsolate()->has_pending_exception()); |
| } |
| |
| void OnInstantiationFailed(i::Handle<i::Object> error_reason) override { |
| i::MaybeHandle<i::Object> promise_result = |
| i::JSPromise::Reject(promise_, error_reason); |
| CHECK_EQ(promise_result.is_null(), |
| promise_->GetIsolate()->has_pending_exception()); |
| } |
| |
| private: |
| static constexpr char kGlobalPromiseHandle[] = |
| "InstantiateModuleResultResolver::promise_"; |
| i::Handle<i::JSPromise> promise_; |
| }; |
| |
| constexpr char InstantiateModuleResultResolver::kGlobalPromiseHandle[]; |
| |
| // This class resolves the result of WebAssembly.instantiate(bytes, imports). |
| // For that it creates a new {JSObject} which contains both the provided |
| // {WasmModuleObject} and the resulting {WebAssemblyInstanceObject} itself. |
| class InstantiateBytesResultResolver |
| : public i::wasm::InstantiationResultResolver { |
| public: |
| InstantiateBytesResultResolver(i::Isolate* isolate, |
| i::Handle<i::JSPromise> promise, |
| i::Handle<i::WasmModuleObject> module) |
| : isolate_(isolate), |
| promise_(isolate_->global_handles()->Create(*promise)), |
| module_(isolate_->global_handles()->Create(*module)) { |
| i::GlobalHandles::AnnotateStrongRetainer(promise_.location(), |
| kGlobalPromiseHandle); |
| i::GlobalHandles::AnnotateStrongRetainer(module_.location(), |
| kGlobalModuleHandle); |
| } |
| |
| ~InstantiateBytesResultResolver() override { |
| i::GlobalHandles::Destroy(promise_.location()); |
| i::GlobalHandles::Destroy(module_.location()); |
| } |
| |
| void OnInstantiationSucceeded( |
| i::Handle<i::WasmInstanceObject> instance) override { |
| // The result is a JSObject with 2 fields which contain the |
| // WasmInstanceObject and the WasmModuleObject. |
| i::Handle<i::JSObject> result = |
| isolate_->factory()->NewJSObject(isolate_->object_function()); |
| |
| i::Handle<i::String> instance_name = |
| isolate_->factory()->NewStringFromStaticChars("instance"); |
| |
| i::Handle<i::String> module_name = |
| isolate_->factory()->NewStringFromStaticChars("module"); |
| |
| i::JSObject::AddProperty(isolate_, result, instance_name, instance, |
| i::NONE); |
| i::JSObject::AddProperty(isolate_, result, module_name, module_, i::NONE); |
| |
| i::MaybeHandle<i::Object> promise_result = |
| i::JSPromise::Resolve(promise_, result); |
| CHECK_EQ(promise_result.is_null(), isolate_->has_pending_exception()); |
| } |
| |
| void OnInstantiationFailed(i::Handle<i::Object> error_reason) override { |
| i::MaybeHandle<i::Object> promise_result = |
| i::JSPromise::Reject(promise_, error_reason); |
| CHECK_EQ(promise_result.is_null(), isolate_->has_pending_exception()); |
| } |
| |
| private: |
| static constexpr char kGlobalPromiseHandle[] = |
| "InstantiateBytesResultResolver::promise_"; |
| static constexpr char kGlobalModuleHandle[] = |
| "InstantiateBytesResultResolver::module_"; |
| i::Isolate* isolate_; |
| i::Handle<i::JSPromise> promise_; |
| i::Handle<i::WasmModuleObject> module_; |
| }; |
| |
| constexpr char InstantiateBytesResultResolver::kGlobalPromiseHandle[]; |
| constexpr char InstantiateBytesResultResolver::kGlobalModuleHandle[]; |
| |
| // This class is the {CompilationResultResolver} for |
| // WebAssembly.instantiate(bytes, imports). When compilation finishes, |
| // {AsyncInstantiate} is started on the compilation result. |
| class AsyncInstantiateCompileResultResolver |
| : public i::wasm::CompilationResultResolver { |
| public: |
| AsyncInstantiateCompileResultResolver( |
| i::Isolate* isolate, i::Handle<i::JSPromise> promise, |
| i::MaybeHandle<i::JSReceiver> maybe_imports) |
| : isolate_(isolate), |
| promise_(isolate_->global_handles()->Create(*promise)), |
| maybe_imports_(maybe_imports.is_null() |
| ? maybe_imports |
| : isolate_->global_handles()->Create( |
| *maybe_imports.ToHandleChecked())) { |
| i::GlobalHandles::AnnotateStrongRetainer(promise_.location(), |
| kGlobalPromiseHandle); |
| if (!maybe_imports_.is_null()) { |
| i::GlobalHandles::AnnotateStrongRetainer( |
| maybe_imports_.ToHandleChecked().location(), kGlobalImportsHandle); |
| } |
| } |
| |
| ~AsyncInstantiateCompileResultResolver() override { |
| i::GlobalHandles::Destroy(promise_.location()); |
| if (!maybe_imports_.is_null()) { |
| i::GlobalHandles::Destroy(maybe_imports_.ToHandleChecked().location()); |
| } |
| } |
| |
| void OnCompilationSucceeded(i::Handle<i::WasmModuleObject> result) override { |
| if (finished_) return; |
| finished_ = true; |
| isolate_->wasm_engine()->AsyncInstantiate( |
| isolate_, |
| std::make_unique<InstantiateBytesResultResolver>(isolate_, promise_, |
| result), |
| result, maybe_imports_); |
| } |
| |
| void OnCompilationFailed(i::Handle<i::Object> error_reason) override { |
| if (finished_) return; |
| finished_ = true; |
| i::MaybeHandle<i::Object> promise_result = |
| i::JSPromise::Reject(promise_, error_reason); |
| CHECK_EQ(promise_result.is_null(), isolate_->has_pending_exception()); |
| } |
| |
| private: |
| static constexpr char kGlobalPromiseHandle[] = |
| "AsyncInstantiateCompileResultResolver::promise_"; |
| static constexpr char kGlobalImportsHandle[] = |
| "AsyncInstantiateCompileResultResolver::module_"; |
| bool finished_ = false; |
| i::Isolate* isolate_; |
| i::Handle<i::JSPromise> promise_; |
| i::MaybeHandle<i::JSReceiver> maybe_imports_; |
| }; |
| |
| constexpr char AsyncInstantiateCompileResultResolver::kGlobalPromiseHandle[]; |
| constexpr char AsyncInstantiateCompileResultResolver::kGlobalImportsHandle[]; |
| |
| std::string ToString(const char* name) { return std::string(name); } |
| |
| std::string ToString(const i::Handle<i::String> name) { |
| return std::string("Property '") + name->ToCString().get() + "'"; |
| } |
| |
| // Web IDL: '[EnforceRange] unsigned long' |
| // Previously called ToNonWrappingUint32 in the draft WebAssembly JS spec. |
| // https://heycam.github.io/webidl/#EnforceRange |
| template <typename T> |
| bool EnforceUint32(T argument_name, Local<v8::Value> v, Local<Context> context, |
| ErrorThrower* thrower, uint32_t* res) { |
| double double_number; |
| |
| if (!v->NumberValue(context).To(&double_number)) { |
| thrower->TypeError("%s must be convertible to a number", |
| ToString(argument_name).c_str()); |
| return false; |
| } |
| if (!std::isfinite(double_number)) { |
| thrower->TypeError("%s must be convertible to a valid number", |
| ToString(argument_name).c_str()); |
| return false; |
| } |
| if (double_number < 0) { |
| thrower->TypeError("%s must be non-negative", |
| ToString(argument_name).c_str()); |
| return false; |
| } |
| if (double_number > std::numeric_limits<uint32_t>::max()) { |
| thrower->TypeError("%s must be in the unsigned long range", |
| ToString(argument_name).c_str()); |
| return false; |
| } |
| |
| *res = static_cast<uint32_t>(double_number); |
| return true; |
| } |
| } // namespace |
| |
| // WebAssembly.compile(bytes) -> Promise |
| void WebAssemblyCompile(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| constexpr const char* kAPIMethodName = "WebAssembly.compile()"; |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| |
| HandleScope scope(isolate); |
| ScheduledErrorThrower thrower(i_isolate, kAPIMethodName); |
| |
| if (!i::wasm::IsWasmCodegenAllowed(i_isolate, i_isolate->native_context())) { |
| thrower.CompileError("Wasm code generation disallowed by embedder"); |
| } |
| |
| Local<Context> context = isolate->GetCurrentContext(); |
| ASSIGN(Promise::Resolver, promise_resolver, Promise::Resolver::New(context)); |
| Local<Promise> promise = promise_resolver->GetPromise(); |
| v8::ReturnValue<v8::Value> return_value = args.GetReturnValue(); |
| return_value.Set(promise); |
| |
| std::shared_ptr<i::wasm::CompilationResultResolver> resolver( |
| new AsyncCompilationResolver(i_isolate, Utils::OpenHandle(*promise))); |
| |
| bool is_shared = false; |
| auto bytes = GetFirstArgumentAsBytes(args, &thrower, &is_shared); |
| if (thrower.error()) { |
| resolver->OnCompilationFailed(thrower.Reify()); |
| return; |
| } |
| // Asynchronous compilation handles copying wire bytes if necessary. |
| auto enabled_features = i::wasm::WasmFeatures::FromIsolate(i_isolate); |
| i_isolate->wasm_engine()->AsyncCompile(i_isolate, enabled_features, |
| std::move(resolver), bytes, is_shared, |
| kAPIMethodName); |
| } |
| |
| void WasmStreamingCallbackForTesting( |
| const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| |
| HandleScope scope(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.compile()"); |
| |
| std::shared_ptr<v8::WasmStreaming> streaming = |
| v8::WasmStreaming::Unpack(args.GetIsolate(), args.Data()); |
| |
| bool is_shared = false; |
| i::wasm::ModuleWireBytes bytes = |
| GetFirstArgumentAsBytes(args, &thrower, &is_shared); |
| if (thrower.error()) { |
| streaming->Abort(Utils::ToLocal(thrower.Reify())); |
| return; |
| } |
| streaming->OnBytesReceived(bytes.start(), bytes.length()); |
| streaming->Finish(); |
| CHECK(!thrower.error()); |
| } |
| |
| void WasmStreamingPromiseFailedCallback( |
| const v8::FunctionCallbackInfo<v8::Value>& args) { |
| std::shared_ptr<v8::WasmStreaming> streaming = |
| v8::WasmStreaming::Unpack(args.GetIsolate(), args.Data()); |
| streaming->Abort(args[0]); |
| } |
| |
| // WebAssembly.compileStreaming(Response | Promise<Response>) |
| // -> Promise<WebAssembly.Module> |
| void WebAssemblyCompileStreaming( |
| const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| HandleScope scope(isolate); |
| const char* const kAPIMethodName = "WebAssembly.compileStreaming()"; |
| ScheduledErrorThrower thrower(i_isolate, kAPIMethodName); |
| Local<Context> context = isolate->GetCurrentContext(); |
| |
| // Create and assign the return value of this function. |
| ASSIGN(Promise::Resolver, result_resolver, Promise::Resolver::New(context)); |
| Local<Promise> promise = result_resolver->GetPromise(); |
| v8::ReturnValue<v8::Value> return_value = args.GetReturnValue(); |
| return_value.Set(promise); |
| |
| // Prepare the CompilationResultResolver for the compilation. |
| auto resolver = std::make_shared<AsyncCompilationResolver>( |
| i_isolate, Utils::OpenHandle(*promise)); |
| |
| if (!i::wasm::IsWasmCodegenAllowed(i_isolate, i_isolate->native_context())) { |
| thrower.CompileError("Wasm code generation disallowed by embedder"); |
| resolver->OnCompilationFailed(thrower.Reify()); |
| return; |
| } |
| |
| // Allocate the streaming decoder in a Managed so we can pass it to the |
| // embedder. |
| i::Handle<i::Managed<WasmStreaming>> data = |
| i::Managed<WasmStreaming>::Allocate( |
| i_isolate, 0, |
| std::make_unique<WasmStreaming::WasmStreamingImpl>( |
| isolate, kAPIMethodName, resolver)); |
| |
| DCHECK_NOT_NULL(i_isolate->wasm_streaming_callback()); |
| ASSIGN( |
| v8::Function, compile_callback, |
| v8::Function::New(context, i_isolate->wasm_streaming_callback(), |
| Utils::ToLocal(i::Handle<i::Object>::cast(data)), 1)); |
| ASSIGN( |
| v8::Function, reject_callback, |
| v8::Function::New(context, WasmStreamingPromiseFailedCallback, |
| Utils::ToLocal(i::Handle<i::Object>::cast(data)), 1)); |
| |
| // The parameter may be of type {Response} or of type {Promise<Response>}. |
| // Treat either case of parameter as Promise.resolve(parameter) |
| // as per https://www.w3.org/2001/tag/doc/promises-guide#resolve-arguments |
| |
| // Ending with: |
| // return Promise.resolve(parameter).then(compile_callback); |
| ASSIGN(Promise::Resolver, input_resolver, Promise::Resolver::New(context)); |
| if (!input_resolver->Resolve(context, args[0]).IsJust()) return; |
| |
| // We do not have any use of the result here. The {compile_callback} will |
| // start streaming compilation, which will eventually resolve the promise we |
| // set as result value. |
| USE(input_resolver->GetPromise()->Then(context, compile_callback, |
| reject_callback)); |
| } |
| |
| // WebAssembly.validate(bytes) -> bool |
| void WebAssemblyValidate(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| HandleScope scope(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.validate()"); |
| |
| bool is_shared = false; |
| auto bytes = GetFirstArgumentAsBytes(args, &thrower, &is_shared); |
| |
| v8::ReturnValue<v8::Value> return_value = args.GetReturnValue(); |
| |
| if (thrower.error()) { |
| if (thrower.wasm_error()) thrower.Reset(); // Clear error. |
| return_value.Set(v8::False(isolate)); |
| return; |
| } |
| |
| auto enabled_features = i::wasm::WasmFeatures::FromIsolate(i_isolate); |
| bool validated = false; |
| if (is_shared) { |
| // Make a copy of the wire bytes to avoid concurrent modification. |
| std::unique_ptr<uint8_t[]> copy(new uint8_t[bytes.length()]); |
| memcpy(copy.get(), bytes.start(), bytes.length()); |
| i::wasm::ModuleWireBytes bytes_copy(copy.get(), |
| copy.get() + bytes.length()); |
| validated = i_isolate->wasm_engine()->SyncValidate( |
| i_isolate, enabled_features, bytes_copy); |
| } else { |
| // The wire bytes are not shared, OK to use them directly. |
| validated = i_isolate->wasm_engine()->SyncValidate(i_isolate, |
| enabled_features, bytes); |
| } |
| |
| return_value.Set(Boolean::New(isolate, validated)); |
| } |
| |
| // new WebAssembly.Module(bytes) -> WebAssembly.Module |
| void WebAssemblyModule(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| if (i_isolate->wasm_module_callback()(args)) return; |
| |
| HandleScope scope(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Module()"); |
| |
| if (!args.IsConstructCall()) { |
| thrower.TypeError("WebAssembly.Module must be invoked with 'new'"); |
| return; |
| } |
| if (!i::wasm::IsWasmCodegenAllowed(i_isolate, i_isolate->native_context())) { |
| thrower.CompileError("Wasm code generation disallowed by embedder"); |
| return; |
| } |
| |
| bool is_shared = false; |
| auto bytes = GetFirstArgumentAsBytes(args, &thrower, &is_shared); |
| |
| if (thrower.error()) { |
| return; |
| } |
| auto enabled_features = i::wasm::WasmFeatures::FromIsolate(i_isolate); |
| i::MaybeHandle<i::Object> module_obj; |
| if (is_shared) { |
| // Make a copy of the wire bytes to avoid concurrent modification. |
| std::unique_ptr<uint8_t[]> copy(new uint8_t[bytes.length()]); |
| memcpy(copy.get(), bytes.start(), bytes.length()); |
| i::wasm::ModuleWireBytes bytes_copy(copy.get(), |
| copy.get() + bytes.length()); |
| module_obj = i_isolate->wasm_engine()->SyncCompile( |
| i_isolate, enabled_features, &thrower, bytes_copy); |
| } else { |
| // The wire bytes are not shared, OK to use them directly. |
| module_obj = i_isolate->wasm_engine()->SyncCompile( |
| i_isolate, enabled_features, &thrower, bytes); |
| } |
| |
| if (module_obj.is_null()) return; |
| |
| v8::ReturnValue<v8::Value> return_value = args.GetReturnValue(); |
| return_value.Set(Utils::ToLocal(module_obj.ToHandleChecked())); |
| } |
| |
| // WebAssembly.Module.imports(module) -> Array<Import> |
| void WebAssemblyModuleImports(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| HandleScope scope(args.GetIsolate()); |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Module.imports()"); |
| |
| auto maybe_module = GetFirstArgumentAsModule(args, &thrower); |
| if (thrower.error()) return; |
| auto imports = i::wasm::GetImports(i_isolate, maybe_module.ToHandleChecked()); |
| args.GetReturnValue().Set(Utils::ToLocal(imports)); |
| } |
| |
| // WebAssembly.Module.exports(module) -> Array<Export> |
| void WebAssemblyModuleExports(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| HandleScope scope(args.GetIsolate()); |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Module.exports()"); |
| |
| auto maybe_module = GetFirstArgumentAsModule(args, &thrower); |
| if (thrower.error()) return; |
| auto exports = i::wasm::GetExports(i_isolate, maybe_module.ToHandleChecked()); |
| args.GetReturnValue().Set(Utils::ToLocal(exports)); |
| } |
| |
| // WebAssembly.Module.customSections(module, name) -> Array<Section> |
| void WebAssemblyModuleCustomSections( |
| const v8::FunctionCallbackInfo<v8::Value>& args) { |
| HandleScope scope(args.GetIsolate()); |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| ScheduledErrorThrower thrower(i_isolate, |
| "WebAssembly.Module.customSections()"); |
| |
| auto maybe_module = GetFirstArgumentAsModule(args, &thrower); |
| if (thrower.error()) return; |
| |
| if (args[1]->IsUndefined()) { |
| thrower.TypeError("Argument 1 is required"); |
| return; |
| } |
| |
| i::MaybeHandle<i::Object> maybe_name = |
| i::Object::ToString(i_isolate, Utils::OpenHandle(*args[1])); |
| i::Handle<i::Object> name; |
| if (!maybe_name.ToHandle(&name)) return; |
| auto custom_sections = |
| i::wasm::GetCustomSections(i_isolate, maybe_module.ToHandleChecked(), |
| i::Handle<i::String>::cast(name), &thrower); |
| if (thrower.error()) return; |
| args.GetReturnValue().Set(Utils::ToLocal(custom_sections)); |
| } |
| |
| MaybeLocal<Value> WebAssemblyInstantiateImpl(Isolate* isolate, |
| Local<Value> module, |
| Local<Value> ffi) { |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| |
| i::MaybeHandle<i::Object> instance_object; |
| { |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Instance()"); |
| |
| // TODO(ahaas): These checks on the module should not be necessary here They |
| // are just a workaround for https://crbug.com/837417. |
| i::Handle<i::Object> module_obj = Utils::OpenHandle(*module); |
| if (!module_obj->IsWasmModuleObject()) { |
| thrower.TypeError("Argument 0 must be a WebAssembly.Module object"); |
| return {}; |
| } |
| |
| i::MaybeHandle<i::JSReceiver> maybe_imports = |
| GetValueAsImports(ffi, &thrower); |
| if (thrower.error()) return {}; |
| |
| instance_object = i_isolate->wasm_engine()->SyncInstantiate( |
| i_isolate, &thrower, i::Handle<i::WasmModuleObject>::cast(module_obj), |
| maybe_imports, i::MaybeHandle<i::JSArrayBuffer>()); |
| } |
| |
| DCHECK_EQ(instance_object.is_null(), i_isolate->has_scheduled_exception()); |
| if (instance_object.is_null()) return {}; |
| return Utils::ToLocal(instance_object.ToHandleChecked()); |
| } |
| |
| // new WebAssembly.Instance(module, imports) -> WebAssembly.Instance |
| void WebAssemblyInstance(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| i_isolate->CountUsage( |
| v8::Isolate::UseCounterFeature::kWebAssemblyInstantiation); |
| |
| HandleScope scope(args.GetIsolate()); |
| if (i_isolate->wasm_instance_callback()(args)) return; |
| |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Instance()"); |
| if (!args.IsConstructCall()) { |
| thrower.TypeError("WebAssembly.Instance must be invoked with 'new'"); |
| return; |
| } |
| |
| GetFirstArgumentAsModule(args, &thrower); |
| if (thrower.error()) return; |
| |
| // If args.Length < 2, this will be undefined - see FunctionCallbackInfo. |
| // We'll check for that in WebAssemblyInstantiateImpl. |
| Local<Value> data = args[1]; |
| |
| Local<Value> instance; |
| if (WebAssemblyInstantiateImpl(isolate, args[0], data).ToLocal(&instance)) { |
| args.GetReturnValue().Set(instance); |
| } |
| } |
| |
| // WebAssembly.instantiateStreaming(Response | Promise<Response> [, imports]) |
| // -> Promise<ResultObject> |
| // (where ResultObject has a "module" and an "instance" field) |
| void WebAssemblyInstantiateStreaming( |
| const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| i_isolate->CountUsage( |
| v8::Isolate::UseCounterFeature::kWebAssemblyInstantiation); |
| |
| HandleScope scope(isolate); |
| Local<Context> context = isolate->GetCurrentContext(); |
| const char* const kAPIMethodName = "WebAssembly.instantiateStreaming()"; |
| ScheduledErrorThrower thrower(i_isolate, kAPIMethodName); |
| |
| // Create and assign the return value of this function. |
| ASSIGN(Promise::Resolver, result_resolver, Promise::Resolver::New(context)); |
| Local<Promise> promise = result_resolver->GetPromise(); |
| v8::ReturnValue<v8::Value> return_value = args.GetReturnValue(); |
| return_value.Set(promise); |
| |
| // Create an InstantiateResultResolver in case there is an issue with the |
| // passed parameters. |
| std::unique_ptr<i::wasm::InstantiationResultResolver> resolver( |
| new InstantiateModuleResultResolver(i_isolate, |
| Utils::OpenHandle(*promise))); |
| |
| if (!i::wasm::IsWasmCodegenAllowed(i_isolate, i_isolate->native_context())) { |
| thrower.CompileError("Wasm code generation disallowed by embedder"); |
| resolver->OnInstantiationFailed(thrower.Reify()); |
| return; |
| } |
| |
| // If args.Length < 2, this will be undefined - see FunctionCallbackInfo. |
| Local<Value> ffi = args[1]; |
| i::MaybeHandle<i::JSReceiver> maybe_imports = |
| GetValueAsImports(ffi, &thrower); |
| |
| if (thrower.error()) { |
| resolver->OnInstantiationFailed(thrower.Reify()); |
| return; |
| } |
| |
| // We start compilation now, we have no use for the |
| // {InstantiationResultResolver}. |
| resolver.reset(); |
| |
| std::shared_ptr<i::wasm::CompilationResultResolver> compilation_resolver( |
| new AsyncInstantiateCompileResultResolver( |
| i_isolate, Utils::OpenHandle(*promise), maybe_imports)); |
| |
| // Allocate the streaming decoder in a Managed so we can pass it to the |
| // embedder. |
| i::Handle<i::Managed<WasmStreaming>> data = |
| i::Managed<WasmStreaming>::Allocate( |
| i_isolate, 0, |
| std::make_unique<WasmStreaming::WasmStreamingImpl>( |
| isolate, kAPIMethodName, compilation_resolver)); |
| |
| DCHECK_NOT_NULL(i_isolate->wasm_streaming_callback()); |
| ASSIGN( |
| v8::Function, compile_callback, |
| v8::Function::New(context, i_isolate->wasm_streaming_callback(), |
| Utils::ToLocal(i::Handle<i::Object>::cast(data)), 1)); |
| ASSIGN( |
| v8::Function, reject_callback, |
| v8::Function::New(context, WasmStreamingPromiseFailedCallback, |
| Utils::ToLocal(i::Handle<i::Object>::cast(data)), 1)); |
| |
| // The parameter may be of type {Response} or of type {Promise<Response>}. |
| // Treat either case of parameter as Promise.resolve(parameter) |
| // as per https://www.w3.org/2001/tag/doc/promises-guide#resolve-arguments |
| |
| // Ending with: |
| // return Promise.resolve(parameter).then(compile_callback); |
| ASSIGN(Promise::Resolver, input_resolver, Promise::Resolver::New(context)); |
| if (!input_resolver->Resolve(context, args[0]).IsJust()) return; |
| |
| // We do not have any use of the result here. The {compile_callback} will |
| // start streaming compilation, which will eventually resolve the promise we |
| // set as result value. |
| USE(input_resolver->GetPromise()->Then(context, compile_callback, |
| reject_callback)); |
| } |
| |
| // WebAssembly.instantiate(module, imports) -> WebAssembly.Instance |
| // WebAssembly.instantiate(bytes, imports) -> |
| // {module: WebAssembly.Module, instance: WebAssembly.Instance} |
| void WebAssemblyInstantiate(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| constexpr const char* kAPIMethodName = "WebAssembly.instantiate()"; |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| i_isolate->CountUsage( |
| v8::Isolate::UseCounterFeature::kWebAssemblyInstantiation); |
| |
| ScheduledErrorThrower thrower(i_isolate, kAPIMethodName); |
| |
| HandleScope scope(isolate); |
| |
| Local<Context> context = isolate->GetCurrentContext(); |
| |
| ASSIGN(Promise::Resolver, promise_resolver, Promise::Resolver::New(context)); |
| Local<Promise> promise = promise_resolver->GetPromise(); |
| args.GetReturnValue().Set(promise); |
| |
| std::unique_ptr<i::wasm::InstantiationResultResolver> resolver( |
| new InstantiateModuleResultResolver(i_isolate, |
| Utils::OpenHandle(*promise))); |
| |
| Local<Value> first_arg_value = args[0]; |
| i::Handle<i::Object> first_arg = Utils::OpenHandle(*first_arg_value); |
| if (!first_arg->IsJSObject()) { |
| thrower.TypeError( |
| "Argument 0 must be a buffer source or a WebAssembly.Module object"); |
| resolver->OnInstantiationFailed(thrower.Reify()); |
| return; |
| } |
| |
| // If args.Length < 2, this will be undefined - see FunctionCallbackInfo. |
| Local<Value> ffi = args[1]; |
| i::MaybeHandle<i::JSReceiver> maybe_imports = |
| GetValueAsImports(ffi, &thrower); |
| |
| if (thrower.error()) { |
| resolver->OnInstantiationFailed(thrower.Reify()); |
| return; |
| } |
| |
| if (first_arg->IsWasmModuleObject()) { |
| i::Handle<i::WasmModuleObject> module_obj = |
| i::Handle<i::WasmModuleObject>::cast(first_arg); |
| |
| i_isolate->wasm_engine()->AsyncInstantiate(i_isolate, std::move(resolver), |
| module_obj, maybe_imports); |
| return; |
| } |
| |
| bool is_shared = false; |
| auto bytes = GetFirstArgumentAsBytes(args, &thrower, &is_shared); |
| if (thrower.error()) { |
| resolver->OnInstantiationFailed(thrower.Reify()); |
| return; |
| } |
| |
| // We start compilation now, we have no use for the |
| // {InstantiationResultResolver}. |
| resolver.reset(); |
| |
| std::shared_ptr<i::wasm::CompilationResultResolver> compilation_resolver( |
| new AsyncInstantiateCompileResultResolver( |
| i_isolate, Utils::OpenHandle(*promise), maybe_imports)); |
| |
| // The first parameter is a buffer source, we have to check if we are allowed |
| // to compile it. |
| if (!i::wasm::IsWasmCodegenAllowed(i_isolate, i_isolate->native_context())) { |
| thrower.CompileError("Wasm code generation disallowed by embedder"); |
| compilation_resolver->OnCompilationFailed(thrower.Reify()); |
| return; |
| } |
| |
| // Asynchronous compilation handles copying wire bytes if necessary. |
| auto enabled_features = i::wasm::WasmFeatures::FromIsolate(i_isolate); |
| i_isolate->wasm_engine()->AsyncCompile(i_isolate, enabled_features, |
| std::move(compilation_resolver), bytes, |
| is_shared, kAPIMethodName); |
| } |
| |
| bool GetIntegerProperty(v8::Isolate* isolate, ErrorThrower* thrower, |
| Local<Context> context, v8::Local<v8::Value> value, |
| i::Handle<i::String> property_name, int64_t* result, |
| int64_t lower_bound, uint64_t upper_bound) { |
| uint32_t number; |
| if (!EnforceUint32(property_name, value, context, thrower, &number)) { |
| return false; |
| } |
| if (number < lower_bound) { |
| thrower->RangeError("Property '%s': value %" PRIu32 |
| " is below the lower bound %" PRIx64, |
| property_name->ToCString().get(), number, lower_bound); |
| return false; |
| } |
| if (number > upper_bound) { |
| thrower->RangeError("Property '%s': value %" PRIu32 |
| " is above the upper bound %" PRIu64, |
| property_name->ToCString().get(), number, upper_bound); |
| return false; |
| } |
| |
| *result = static_cast<int64_t>(number); |
| return true; |
| } |
| |
| bool GetOptionalIntegerProperty(v8::Isolate* isolate, ErrorThrower* thrower, |
| Local<Context> context, |
| Local<v8::Object> object, |
| Local<String> property, bool* has_property, |
| int64_t* result, int64_t lower_bound, |
| uint64_t upper_bound) { |
| v8::Local<v8::Value> value; |
| if (!object->Get(context, property).ToLocal(&value)) { |
| return false; |
| } |
| |
| // Web IDL: dictionary presence |
| // https://heycam.github.io/webidl/#dfn-present |
| if (value->IsUndefined()) { |
| if (has_property != nullptr) *has_property = false; |
| return true; |
| } |
| |
| if (has_property != nullptr) *has_property = true; |
| i::Handle<i::String> property_name = v8::Utils::OpenHandle(*property); |
| |
| return GetIntegerProperty(isolate, thrower, context, value, property_name, |
| result, lower_bound, upper_bound); |
| } |
| |
| // Fetch 'initial' or 'minimum' property from object. If both are provided, |
| // 'initial' is used. |
| // TODO(aseemgarg): change behavior when the following bug is resolved: |
| // https://github.com/WebAssembly/js-types/issues/6 |
| bool GetInitialOrMinimumProperty(v8::Isolate* isolate, ErrorThrower* thrower, |
| Local<Context> context, |
| Local<v8::Object> object, int64_t* result, |
| int64_t lower_bound, uint64_t upper_bound) { |
| bool has_initial = false; |
| if (!GetOptionalIntegerProperty(isolate, thrower, context, object, |
| v8_str(isolate, "initial"), &has_initial, |
| result, lower_bound, upper_bound)) { |
| return false; |
| } |
| auto enabled_features = i::wasm::WasmFeatures::FromFlags(); |
| if (!has_initial && enabled_features.has_type_reflection()) { |
| if (!GetOptionalIntegerProperty(isolate, thrower, context, object, |
| v8_str(isolate, "minimum"), &has_initial, |
| result, lower_bound, upper_bound)) { |
| return false; |
| } |
| } |
| if (!has_initial) { |
| // TODO(aseemgarg): update error message when the spec issue is resolved. |
| thrower->TypeError("Property 'initial' is required"); |
| return false; |
| } |
| return true; |
| } |
| |
| // new WebAssembly.Table(args) -> WebAssembly.Table |
| void WebAssemblyTable(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| HandleScope scope(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Module()"); |
| if (!args.IsConstructCall()) { |
| thrower.TypeError("WebAssembly.Table must be invoked with 'new'"); |
| return; |
| } |
| if (!args[0]->IsObject()) { |
| thrower.TypeError("Argument 0 must be a table descriptor"); |
| return; |
| } |
| Local<Context> context = isolate->GetCurrentContext(); |
| Local<v8::Object> descriptor = Local<Object>::Cast(args[0]); |
| i::wasm::ValueType type; |
| // The descriptor's 'element'. |
| { |
| v8::MaybeLocal<v8::Value> maybe = |
| descriptor->Get(context, v8_str(isolate, "element")); |
| v8::Local<v8::Value> value; |
| if (!maybe.ToLocal(&value)) return; |
| v8::Local<v8::String> string; |
| if (!value->ToString(context).ToLocal(&string)) return; |
| auto enabled_features = i::wasm::WasmFeatures::FromFlags(); |
| // The JS api uses 'anyfunc' instead of 'funcref'. |
| if (string->StringEquals(v8_str(isolate, "anyfunc"))) { |
| type = i::wasm::kWasmFuncRef; |
| } else if (enabled_features.has_reftypes() && |
| string->StringEquals(v8_str(isolate, "externref"))) { |
| type = i::wasm::kWasmExternRef; |
| } else { |
| thrower.TypeError( |
| "Descriptor property 'element' must be a WebAssembly reference type"); |
| return; |
| } |
| } |
| |
| int64_t initial = 0; |
| if (!GetInitialOrMinimumProperty(isolate, &thrower, context, descriptor, |
| &initial, 0, |
| i::wasm::max_table_init_entries())) { |
| return; |
| } |
| // The descriptor's 'maximum'. |
| int64_t maximum = -1; |
| bool has_maximum = true; |
| if (!GetOptionalIntegerProperty(isolate, &thrower, context, descriptor, |
| v8_str(isolate, "maximum"), &has_maximum, |
| &maximum, initial, |
| std::numeric_limits<uint32_t>::max())) { |
| return; |
| } |
| |
| i::Handle<i::FixedArray> fixed_array; |
| i::Handle<i::JSObject> table_obj = |
| i::WasmTableObject::New(i_isolate, i::Handle<i::WasmInstanceObject>(), |
| type, static_cast<uint32_t>(initial), has_maximum, |
| static_cast<uint32_t>(maximum), &fixed_array); |
| v8::ReturnValue<v8::Value> return_value = args.GetReturnValue(); |
| return_value.Set(Utils::ToLocal(table_obj)); |
| } |
| |
| void WebAssemblyMemory(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| HandleScope scope(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Memory()"); |
| if (!args.IsConstructCall()) { |
| thrower.TypeError("WebAssembly.Memory must be invoked with 'new'"); |
| return; |
| } |
| if (!args[0]->IsObject()) { |
| thrower.TypeError("Argument 0 must be a memory descriptor"); |
| return; |
| } |
| Local<Context> context = isolate->GetCurrentContext(); |
| Local<v8::Object> descriptor = Local<Object>::Cast(args[0]); |
| |
| int64_t initial = 0; |
| if (!GetInitialOrMinimumProperty(isolate, &thrower, context, descriptor, |
| &initial, 0, i::wasm::max_mem_pages())) { |
| return; |
| } |
| // The descriptor's 'maximum'. |
| int64_t maximum = -1; |
| if (!GetOptionalIntegerProperty(isolate, &thrower, context, descriptor, |
| v8_str(isolate, "maximum"), nullptr, &maximum, |
| initial, i::wasm::max_mem_pages())) { |
| return; |
| } |
| |
| auto shared = i::SharedFlag::kNotShared; |
| auto enabled_features = i::wasm::WasmFeatures::FromIsolate(i_isolate); |
| if (enabled_features.has_threads()) { |
| // Shared property of descriptor |
| Local<String> shared_key = v8_str(isolate, "shared"); |
| v8::MaybeLocal<v8::Value> maybe_value = |
| descriptor->Get(context, shared_key); |
| v8::Local<v8::Value> value; |
| if (maybe_value.ToLocal(&value)) { |
| shared = value->BooleanValue(isolate) ? i::SharedFlag::kShared |
| : i::SharedFlag::kNotShared; |
| } else { |
| DCHECK(i_isolate->has_scheduled_exception()); |
| return; |
| } |
| |
| // Throw TypeError if shared is true, and the descriptor has no "maximum" |
| if (shared == i::SharedFlag::kShared && maximum == -1) { |
| thrower.TypeError( |
| "If shared is true, maximum property should be defined."); |
| return; |
| } |
| } |
| |
| i::Handle<i::JSObject> memory_obj; |
| if (!i::WasmMemoryObject::New(i_isolate, static_cast<uint32_t>(initial), |
| static_cast<uint32_t>(maximum), shared) |
| .ToHandle(&memory_obj)) { |
| thrower.RangeError("could not allocate memory"); |
| return; |
| } |
| if (shared == i::SharedFlag::kShared) { |
| i::Handle<i::JSArrayBuffer> buffer( |
| i::Handle<i::WasmMemoryObject>::cast(memory_obj)->array_buffer(), |
| i_isolate); |
| Maybe<bool> result = |
| buffer->SetIntegrityLevel(buffer, i::FROZEN, i::kDontThrow); |
| if (!result.FromJust()) { |
| thrower.TypeError( |
| "Status of setting SetIntegrityLevel of buffer is false."); |
| return; |
| } |
| } |
| args.GetReturnValue().Set(Utils::ToLocal(memory_obj)); |
| } |
| |
| // Determines the type encoded in a value type property (e.g. type reflection). |
| // Returns false if there was an exception, true upon success. On success the |
| // outgoing {type} is set accordingly, or set to {wasm::kWasmStmt} in case the |
| // type could not be properly recognized. |
| bool GetValueType(Isolate* isolate, MaybeLocal<Value> maybe, |
| Local<Context> context, i::wasm::ValueType* type, |
| i::wasm::WasmFeatures enabled_features) { |
| v8::Local<v8::Value> value; |
| if (!maybe.ToLocal(&value)) return false; |
| v8::Local<v8::String> string; |
| if (!value->ToString(context).ToLocal(&string)) return false; |
| if (string->StringEquals(v8_str(isolate, "i32"))) { |
| *type = i::wasm::kWasmI32; |
| } else if (string->StringEquals(v8_str(isolate, "f32"))) { |
| *type = i::wasm::kWasmF32; |
| } else if (string->StringEquals(v8_str(isolate, "i64"))) { |
| *type = i::wasm::kWasmI64; |
| } else if (string->StringEquals(v8_str(isolate, "f64"))) { |
| *type = i::wasm::kWasmF64; |
| } else if (enabled_features.has_reftypes() && |
| string->StringEquals(v8_str(isolate, "externref"))) { |
| *type = i::wasm::kWasmExternRef; |
| } else if (enabled_features.has_reftypes() && |
| string->StringEquals(v8_str(isolate, "anyfunc"))) { |
| // The JS api spec uses 'anyfunc' instead of 'funcref'. |
| *type = i::wasm::kWasmFuncRef; |
| } else if (enabled_features.has_eh() && |
| string->StringEquals(v8_str(isolate, "exnref"))) { |
| *type = i::wasm::kWasmExnRef; |
| } else if (enabled_features.has_gc() && |
| string->StringEquals(v8_str(isolate, "eqref"))) { |
| *type = i::wasm::kWasmEqRef; |
| } else { |
| // Unrecognized type. |
| *type = i::wasm::kWasmStmt; |
| } |
| return true; |
| } |
| |
| // WebAssembly.Global |
| void WebAssemblyGlobal(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| HandleScope scope(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Global()"); |
| if (!args.IsConstructCall()) { |
| thrower.TypeError("WebAssembly.Global must be invoked with 'new'"); |
| return; |
| } |
| if (!args[0]->IsObject()) { |
| thrower.TypeError("Argument 0 must be a global descriptor"); |
| return; |
| } |
| Local<Context> context = isolate->GetCurrentContext(); |
| Local<v8::Object> descriptor = Local<Object>::Cast(args[0]); |
| auto enabled_features = i::wasm::WasmFeatures::FromIsolate(i_isolate); |
| |
| // The descriptor's 'mutable'. |
| bool is_mutable = false; |
| { |
| Local<String> mutable_key = v8_str(isolate, "mutable"); |
| v8::MaybeLocal<v8::Value> maybe = descriptor->Get(context, mutable_key); |
| v8::Local<v8::Value> value; |
| if (maybe.ToLocal(&value)) { |
| is_mutable = value->BooleanValue(isolate); |
| } else { |
| DCHECK(i_isolate->has_scheduled_exception()); |
| return; |
| } |
| } |
| |
| // The descriptor's type, called 'value'. It is called 'value' because this |
| // descriptor is planned to be re-used as the global's type for reflection, |
| // so calling it 'type' is redundant. |
| i::wasm::ValueType type; |
| { |
| v8::MaybeLocal<v8::Value> maybe = |
| descriptor->Get(context, v8_str(isolate, "value")); |
| if (!GetValueType(isolate, maybe, context, &type, enabled_features)) return; |
| if (type == i::wasm::kWasmStmt) { |
| thrower.TypeError( |
| "Descriptor property 'value' must be a WebAssembly type"); |
| return; |
| } |
| } |
| |
| const uint32_t offset = 0; |
| i::MaybeHandle<i::WasmGlobalObject> maybe_global_obj = |
| i::WasmGlobalObject::New(i_isolate, i::Handle<i::WasmInstanceObject>(), |
| i::MaybeHandle<i::JSArrayBuffer>(), |
| i::MaybeHandle<i::FixedArray>(), type, offset, |
| is_mutable); |
| |
| i::Handle<i::WasmGlobalObject> global_obj; |
| if (!maybe_global_obj.ToHandle(&global_obj)) { |
| thrower.RangeError("could not allocate memory"); |
| return; |
| } |
| |
| // Convert value to a WebAssembly value, the default value is 0. |
| Local<v8::Value> value = Local<Value>::Cast(args[1]); |
| switch (type.kind()) { |
| case i::wasm::ValueType::kI32: { |
| int32_t i32_value = 0; |
| if (!value->IsUndefined()) { |
| v8::Local<v8::Int32> int32_value; |
| if (!value->ToInt32(context).ToLocal(&int32_value)) return; |
| if (!int32_value->Int32Value(context).To(&i32_value)) return; |
| } |
| global_obj->SetI32(i32_value); |
| break; |
| } |
| case i::wasm::ValueType::kI64: { |
| int64_t i64_value = 0; |
| if (!value->IsUndefined()) { |
| if (!enabled_features.has_bigint()) { |
| thrower.TypeError("Can't set the value of i64 WebAssembly.Global"); |
| return; |
| } |
| |
| v8::Local<v8::BigInt> bigint_value; |
| if (!value->ToBigInt(context).ToLocal(&bigint_value)) return; |
| i64_value = bigint_value->Int64Value(); |
| } |
| global_obj->SetI64(i64_value); |
| break; |
| } |
| case i::wasm::ValueType::kF32: { |
| float f32_value = 0; |
| if (!value->IsUndefined()) { |
| double f64_value = 0; |
| v8::Local<v8::Number> number_value; |
| if (!value->ToNumber(context).ToLocal(&number_value)) return; |
| if (!number_value->NumberValue(context).To(&f64_value)) return; |
| f32_value = i::DoubleToFloat32(f64_value); |
| } |
| global_obj->SetF32(f32_value); |
| break; |
| } |
| case i::wasm::ValueType::kF64: { |
| double f64_value = 0; |
| if (!value->IsUndefined()) { |
| v8::Local<v8::Number> number_value; |
| if (!value->ToNumber(context).ToLocal(&number_value)) return; |
| if (!number_value->NumberValue(context).To(&f64_value)) return; |
| } |
| global_obj->SetF64(f64_value); |
| break; |
| } |
| case i::wasm::ValueType::kRef: |
| case i::wasm::ValueType::kOptRef: { |
| switch (type.heap_representation()) { |
| case i::wasm::HeapType::kExtern: |
| case i::wasm::HeapType::kExn: { |
| if (args.Length() < 2) { |
| // When no initial value is provided, we have to use the WebAssembly |
| // default value 'null', and not the JS default value 'undefined'. |
| global_obj->SetExternRef(i_isolate->factory()->null_value()); |
| break; |
| } |
| global_obj->SetExternRef(Utils::OpenHandle(*value)); |
| break; |
| } |
| case i::wasm::HeapType::kFunc: { |
| if (args.Length() < 2) { |
| // When no initial value is provided, we have to use the WebAssembly |
| // default value 'null', and not the JS default value 'undefined'. |
| global_obj->SetFuncRef(i_isolate, |
| i_isolate->factory()->null_value()); |
| break; |
| } |
| |
| if (!global_obj->SetFuncRef(i_isolate, Utils::OpenHandle(*value))) { |
| thrower.TypeError( |
| "The value of funcref globals must be null or an " |
| "exported function"); |
| } |
| break; |
| } |
| case i::wasm::HeapType::kEq: |
| default: |
| // TODO(7748): Implement these. |
| UNIMPLEMENTED(); |
| } |
| break; |
| } |
| case i::wasm::ValueType::kRtt: |
| // TODO(7748): Implement. |
| UNIMPLEMENTED(); |
| case i::wasm::ValueType::kI8: |
| case i::wasm::ValueType::kI16: |
| case i::wasm::ValueType::kStmt: |
| case i::wasm::ValueType::kS128: |
| case i::wasm::ValueType::kBottom: |
| UNREACHABLE(); |
| } |
| |
| i::Handle<i::JSObject> global_js_object(global_obj); |
| args.GetReturnValue().Set(Utils::ToLocal(global_js_object)); |
| } |
| |
| // WebAssembly.Exception |
| void WebAssemblyException(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| HandleScope scope(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Exception()"); |
| thrower.TypeError("WebAssembly.Exception cannot be called"); |
| } |
| |
| namespace { |
| |
| uint32_t GetIterableLength(i::Isolate* isolate, Local<Context> context, |
| Local<Object> iterable) { |
| Local<String> length = Utils::ToLocal(isolate->factory()->length_string()); |
| MaybeLocal<Value> property = iterable->Get(context, length); |
| if (property.IsEmpty()) return i::kMaxUInt32; |
| MaybeLocal<Uint32> number = property.ToLocalChecked()->ToArrayIndex(context); |
| if (number.IsEmpty()) return i::kMaxUInt32; |
| DCHECK_NE(i::kMaxUInt32, number.ToLocalChecked()->Value()); |
| return number.ToLocalChecked()->Value(); |
| } |
| |
| } // namespace |
| |
| // WebAssembly.Function |
| void WebAssemblyFunction(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| HandleScope scope(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Function()"); |
| if (!args.IsConstructCall()) { |
| thrower.TypeError("WebAssembly.Function must be invoked with 'new'"); |
| return; |
| } |
| if (!args[0]->IsObject()) { |
| thrower.TypeError("Argument 0 must be a function type"); |
| return; |
| } |
| Local<Object> function_type = Local<Object>::Cast(args[0]); |
| Local<Context> context = isolate->GetCurrentContext(); |
| auto enabled_features = i::wasm::WasmFeatures::FromIsolate(i_isolate); |
| |
| // Load the 'parameters' property of the function type. |
| Local<String> parameters_key = v8_str(isolate, "parameters"); |
| v8::MaybeLocal<v8::Value> parameters_maybe = |
| function_type->Get(context, parameters_key); |
| v8::Local<v8::Value> parameters_value; |
| if (!parameters_maybe.ToLocal(¶meters_value)) return; |
| if (!parameters_value->IsObject()) { |
| thrower.TypeError("Argument 0 must be a function type with 'parameters'"); |
| return; |
| } |
| Local<Object> parameters = parameters_value.As<Object>(); |
| uint32_t parameters_len = GetIterableLength(i_isolate, context, parameters); |
| if (parameters_len == i::kMaxUInt32) { |
| thrower.TypeError("Argument 0 contains parameters without 'length'"); |
| return; |
| } |
| if (parameters_len > i::wasm::kV8MaxWasmFunctionParams) { |
| thrower.TypeError("Argument 0 contains too many parameters"); |
| return; |
| } |
| |
| // Load the 'results' property of the function type. |
| Local<String> results_key = v8_str(isolate, "results"); |
| v8::MaybeLocal<v8::Value> results_maybe = |
| function_type->Get(context, results_key); |
| v8::Local<v8::Value> results_value; |
| if (!results_maybe.ToLocal(&results_value)) return; |
| if (!results_value->IsObject()) { |
| thrower.TypeError("Argument 0 must be a function type with 'results'"); |
| return; |
| } |
| Local<Object> results = results_value.As<Object>(); |
| uint32_t results_len = GetIterableLength(i_isolate, context, results); |
| if (results_len == i::kMaxUInt32) { |
| thrower.TypeError("Argument 0 contains results without 'length'"); |
| return; |
| } |
| if (results_len > (enabled_features.has_mv() |
| ? i::wasm::kV8MaxWasmFunctionMultiReturns |
| : i::wasm::kV8MaxWasmFunctionReturns)) { |
| thrower.TypeError("Argument 0 contains too many results"); |
| return; |
| } |
| |
| // Decode the function type and construct a signature. |
| i::Zone zone(i_isolate->allocator(), ZONE_NAME); |
| i::wasm::FunctionSig::Builder builder(&zone, results_len, parameters_len); |
| for (uint32_t i = 0; i < parameters_len; ++i) { |
| i::wasm::ValueType type; |
| MaybeLocal<Value> maybe = parameters->Get(context, i); |
| if (!GetValueType(isolate, maybe, context, &type, enabled_features)) return; |
| if (type == i::wasm::kWasmStmt) { |
| thrower.TypeError( |
| "Argument 0 parameter type at index #%u must be a value type", i); |
| return; |
| } |
| builder.AddParam(type); |
| } |
| for (uint32_t i = 0; i < results_len; ++i) { |
| i::wasm::ValueType type; |
| MaybeLocal<Value> maybe = results->Get(context, i); |
| if (!GetValueType(isolate, maybe, context, &type, enabled_features)) return; |
| if (type == i::wasm::kWasmStmt) { |
| thrower.TypeError( |
| "Argument 0 result type at index #%u must be a value type", i); |
| return; |
| } |
| builder.AddReturn(type); |
| } |
| |
| if (!args[1]->IsFunction()) { |
| thrower.TypeError("Argument 1 must be a function"); |
| return; |
| } |
| const i::wasm::FunctionSig* sig = builder.Build(); |
| |
| i::Handle<i::JSReceiver> callable = |
| Utils::OpenHandle(*args[1].As<Function>()); |
| if (i::WasmExportedFunction::IsWasmExportedFunction(*callable)) { |
| if (*i::Handle<i::WasmExportedFunction>::cast(callable)->sig() == *sig) { |
| args.GetReturnValue().Set(Utils::ToLocal(callable)); |
| return; |
| } |
| |
| thrower.TypeError( |
| "The signature of Argument 1 (a WebAssembly function) does " |
| "not match the signature specified in Argument 0"); |
| return; |
| } |
| |
| if (i::WasmJSFunction::IsWasmJSFunction(*callable)) { |
| if (i::Handle<i::WasmJSFunction>::cast(callable)->MatchesSignature(sig)) { |
| args.GetReturnValue().Set(Utils::ToLocal(callable)); |
| return; |
| } |
| |
| thrower.TypeError( |
| "The signature of Argument 1 (a WebAssembly function) does " |
| "not match the signature specified in Argument 0"); |
| return; |
| } |
| |
| i::Handle<i::JSFunction> result = |
| i::WasmJSFunction::New(i_isolate, sig, callable); |
| args.GetReturnValue().Set(Utils::ToLocal(result)); |
| } |
| |
| // WebAssembly.Function.type(WebAssembly.Function) -> FunctionType |
| void WebAssemblyFunctionType(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| HandleScope scope(isolate); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Function.type()"); |
| |
| const i::wasm::FunctionSig* sig; |
| i::Zone zone(i_isolate->allocator(), ZONE_NAME); |
| i::Handle<i::Object> arg0 = Utils::OpenHandle(*args[0]); |
| if (i::WasmExportedFunction::IsWasmExportedFunction(*arg0)) { |
| sig = i::Handle<i::WasmExportedFunction>::cast(arg0)->sig(); |
| } else if (i::WasmJSFunction::IsWasmJSFunction(*arg0)) { |
| sig = i::Handle<i::WasmJSFunction>::cast(arg0)->GetSignature(&zone); |
| } else { |
| thrower.TypeError("Argument 0 must be a WebAssembly.Function"); |
| return; |
| } |
| |
| auto type = i::wasm::GetTypeForFunction(i_isolate, sig); |
| args.GetReturnValue().Set(Utils::ToLocal(type)); |
| } |
| |
| constexpr const char* kName_WasmGlobalObject = "WebAssembly.Global"; |
| constexpr const char* kName_WasmMemoryObject = "WebAssembly.Memory"; |
| constexpr const char* kName_WasmInstanceObject = "WebAssembly.Instance"; |
| constexpr const char* kName_WasmTableObject = "WebAssembly.Table"; |
| |
| #define EXTRACT_THIS(var, WasmType) \ |
| i::Handle<i::WasmType> var; \ |
| { \ |
| i::Handle<i::Object> this_arg = Utils::OpenHandle(*args.This()); \ |
| if (!this_arg->Is##WasmType()) { \ |
| thrower.TypeError("Receiver is not a %s", kName_##WasmType); \ |
| return; \ |
| } \ |
| var = i::Handle<i::WasmType>::cast(this_arg); \ |
| } |
| |
| void WebAssemblyInstanceGetExports( |
| const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| HandleScope scope(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Instance.exports()"); |
| EXTRACT_THIS(receiver, WasmInstanceObject); |
| i::Handle<i::JSObject> exports_object(receiver->exports_object(), i_isolate); |
| args.GetReturnValue().Set(Utils::ToLocal(exports_object)); |
| } |
| |
| void WebAssemblyTableGetLength( |
| const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| HandleScope scope(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Table.length()"); |
| EXTRACT_THIS(receiver, WasmTableObject); |
| args.GetReturnValue().Set( |
| v8::Number::New(isolate, receiver->current_length())); |
| } |
| |
| // WebAssembly.Table.grow(num, init_value = null) -> num |
| void WebAssemblyTableGrow(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| HandleScope scope(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Table.grow()"); |
| Local<Context> context = isolate->GetCurrentContext(); |
| EXTRACT_THIS(receiver, WasmTableObject); |
| |
| uint32_t grow_by; |
| if (!EnforceUint32("Argument 0", args[0], context, &thrower, &grow_by)) { |
| return; |
| } |
| |
| i::Handle<i::Object> init_value = i_isolate->factory()->null_value(); |
| auto enabled_features = i::wasm::WasmFeatures::FromIsolate(i_isolate); |
| if (enabled_features.has_typed_funcref()) { |
| if (args.Length() >= 2 && !args[1]->IsUndefined()) { |
| init_value = Utils::OpenHandle(*args[1]); |
| } |
| if (!i::WasmTableObject::IsValidElement(i_isolate, receiver, init_value)) { |
| thrower.TypeError("Argument 1 must be a valid type for the table"); |
| return; |
| } |
| } |
| |
| int old_size = |
| i::WasmTableObject::Grow(i_isolate, receiver, grow_by, init_value); |
| |
| if (old_size < 0) { |
| thrower.RangeError("failed to grow table by %u", grow_by); |
| return; |
| } |
| v8::ReturnValue<v8::Value> return_value = args.GetReturnValue(); |
| return_value.Set(old_size); |
| } |
| |
| // WebAssembly.Table.get(num) -> JSFunction |
| void WebAssemblyTableGet(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| HandleScope scope(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Table.get()"); |
| Local<Context> context = isolate->GetCurrentContext(); |
| EXTRACT_THIS(receiver, WasmTableObject); |
| |
| uint32_t index; |
| if (!EnforceUint32("Argument 0", args[0], context, &thrower, &index)) { |
| return; |
| } |
| if (!i::WasmTableObject::IsInBounds(i_isolate, receiver, index)) { |
| thrower.RangeError("invalid index %u into function table", index); |
| return; |
| } |
| |
| i::Handle<i::Object> result = |
| i::WasmTableObject::Get(i_isolate, receiver, index); |
| |
| v8::ReturnValue<v8::Value> return_value = args.GetReturnValue(); |
| return_value.Set(Utils::ToLocal(result)); |
| } |
| |
| // WebAssembly.Table.set(num, JSFunction) |
| void WebAssemblyTableSet(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| HandleScope scope(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Table.set()"); |
| Local<Context> context = isolate->GetCurrentContext(); |
| EXTRACT_THIS(table_object, WasmTableObject); |
| |
| // Parameter 0. |
| uint32_t index; |
| if (!EnforceUint32("Argument 0", args[0], context, &thrower, &index)) { |
| return; |
| } |
| if (!i::WasmTableObject::IsInBounds(i_isolate, table_object, index)) { |
| thrower.RangeError("invalid index %u into function table", index); |
| return; |
| } |
| |
| i::Handle<i::Object> element = Utils::OpenHandle(*args[1]); |
| if (!i::WasmTableObject::IsValidElement(i_isolate, table_object, element)) { |
| thrower.TypeError( |
| "Argument 1 must be null or a WebAssembly function of type compatible " |
| "to 'this'"); |
| return; |
| } |
| i::WasmTableObject::Set(i_isolate, table_object, index, element); |
| } |
| |
| // WebAssembly.Table.type(WebAssembly.Table) -> TableType |
| void WebAssemblyTableType(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| HandleScope scope(isolate); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Table.type()"); |
| |
| auto maybe_table = GetFirstArgumentAsTable(args, &thrower); |
| if (thrower.error()) return; |
| i::Handle<i::WasmTableObject> table = maybe_table.ToHandleChecked(); |
| base::Optional<uint32_t> max_size; |
| if (!table->maximum_length().IsUndefined()) { |
| uint64_t max_size64 = table->maximum_length().Number(); |
| DCHECK_LE(max_size64, std::numeric_limits<uint32_t>::max()); |
| max_size.emplace(static_cast<uint32_t>(max_size64)); |
| } |
| auto type = i::wasm::GetTypeForTable(i_isolate, table->type(), |
| table->current_length(), max_size); |
| args.GetReturnValue().Set(Utils::ToLocal(type)); |
| } |
| |
| // WebAssembly.Memory.grow(num) -> num |
| void WebAssemblyMemoryGrow(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| HandleScope scope(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Memory.grow()"); |
| Local<Context> context = isolate->GetCurrentContext(); |
| EXTRACT_THIS(receiver, WasmMemoryObject); |
| |
| uint32_t delta_size; |
| if (!EnforceUint32("Argument 0", args[0], context, &thrower, &delta_size)) { |
| return; |
| } |
| |
| uint64_t max_size64 = receiver->maximum_pages(); |
| if (max_size64 > uint64_t{i::wasm::max_mem_pages()}) { |
| max_size64 = i::wasm::max_mem_pages(); |
| } |
| i::Handle<i::JSArrayBuffer> old_buffer(receiver->array_buffer(), i_isolate); |
| |
| DCHECK_LE(max_size64, std::numeric_limits<uint32_t>::max()); |
| |
| uint64_t old_size64 = old_buffer->byte_length() / i::wasm::kWasmPageSize; |
| uint64_t new_size64 = old_size64 + static_cast<uint64_t>(delta_size); |
| |
| if (new_size64 > max_size64) { |
| thrower.RangeError("Maximum memory size exceeded"); |
| return; |
| } |
| |
| int32_t ret = i::WasmMemoryObject::Grow(i_isolate, receiver, delta_size); |
| if (ret == -1) { |
| thrower.RangeError("Unable to grow instance memory."); |
| return; |
| } |
| v8::ReturnValue<v8::Value> return_value = args.GetReturnValue(); |
| return_value.Set(ret); |
| } |
| |
| // WebAssembly.Memory.buffer -> ArrayBuffer |
| void WebAssemblyMemoryGetBuffer( |
| const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| HandleScope scope(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Memory.buffer"); |
| EXTRACT_THIS(receiver, WasmMemoryObject); |
| |
| i::Handle<i::Object> buffer_obj(receiver->array_buffer(), i_isolate); |
| DCHECK(buffer_obj->IsJSArrayBuffer()); |
| i::Handle<i::JSArrayBuffer> buffer(i::JSArrayBuffer::cast(*buffer_obj), |
| i_isolate); |
| if (buffer->is_shared()) { |
| // TODO(gdeepti): More needed here for when cached buffer, and current |
| // buffer are out of sync, handle that here when bounds checks, and Grow |
| // are handled correctly. |
| Maybe<bool> result = |
| buffer->SetIntegrityLevel(buffer, i::FROZEN, i::kDontThrow); |
| if (!result.FromJust()) { |
| thrower.TypeError( |
| "Status of setting SetIntegrityLevel of buffer is false."); |
| } |
| } |
| v8::ReturnValue<v8::Value> return_value = args.GetReturnValue(); |
| return_value.Set(Utils::ToLocal(buffer)); |
| } |
| |
| // WebAssembly.Memory.type(WebAssembly.Memory) -> MemoryType |
| void WebAssemblyMemoryType(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| HandleScope scope(isolate); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Memory.type()"); |
| |
| auto maybe_memory = GetFirstArgumentAsMemory(args, &thrower); |
| if (thrower.error()) return; |
| i::Handle<i::WasmMemoryObject> memory = maybe_memory.ToHandleChecked(); |
| i::Handle<i::JSArrayBuffer> buffer(memory->array_buffer(), i_isolate); |
| size_t curr_size = buffer->byte_length() / i::wasm::kWasmPageSize; |
| DCHECK_LE(curr_size, std::numeric_limits<uint32_t>::max()); |
| uint32_t min_size = static_cast<uint32_t>(curr_size); |
| base::Optional<uint32_t> max_size; |
| if (memory->has_maximum_pages()) { |
| uint64_t max_size64 = memory->maximum_pages(); |
| DCHECK_LE(max_size64, std::numeric_limits<uint32_t>::max()); |
| max_size.emplace(static_cast<uint32_t>(max_size64)); |
| } |
| auto type = i::wasm::GetTypeForMemory(i_isolate, min_size, max_size); |
| args.GetReturnValue().Set(Utils::ToLocal(type)); |
| } |
| |
| void WebAssemblyGlobalGetValueCommon( |
| const v8::FunctionCallbackInfo<v8::Value>& args, const char* name) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| HandleScope scope(isolate); |
| ScheduledErrorThrower thrower(i_isolate, name); |
| EXTRACT_THIS(receiver, WasmGlobalObject); |
| |
| v8::ReturnValue<v8::Value> return_value = args.GetReturnValue(); |
| |
| switch (receiver->type().kind()) { |
| case i::wasm::ValueType::kI32: |
| return_value.Set(receiver->GetI32()); |
| break; |
| case i::wasm::ValueType::kI64: { |
| auto enabled_features = i::wasm::WasmFeatures::FromIsolate(i_isolate); |
| if (enabled_features.has_bigint()) { |
| Local<BigInt> value = BigInt::New(isolate, receiver->GetI64()); |
| return_value.Set(value); |
| } else { |
| thrower.TypeError("Can't get the value of i64 WebAssembly.Global"); |
| } |
| break; |
| } |
| case i::wasm::ValueType::kF32: |
| return_value.Set(receiver->GetF32()); |
| break; |
| case i::wasm::ValueType::kF64: |
| return_value.Set(receiver->GetF64()); |
| break; |
| case i::wasm::ValueType::kS128: |
| thrower.TypeError("Can't get the value of s128 WebAssembly.Global"); |
| break; |
| case i::wasm::ValueType::kRef: |
| case i::wasm::ValueType::kOptRef: |
| switch (receiver->type().heap_representation()) { |
| case i::wasm::HeapType::kExtern: |
| case i::wasm::HeapType::kFunc: |
| case i::wasm::HeapType::kExn: |
| return_value.Set(Utils::ToLocal(receiver->GetRef())); |
| break; |
| case i::wasm::HeapType::kEq: |
| default: |
| // TODO(7748): Implement these. |
| UNIMPLEMENTED(); |
| break; |
| } |
| break; |
| case i::wasm::ValueType::kRtt: |
| UNIMPLEMENTED(); // TODO(7748): Implement. |
| break; |
| case i::wasm::ValueType::kI8: |
| case i::wasm::ValueType::kI16: |
| case i::wasm::ValueType::kBottom: |
| case i::wasm::ValueType::kStmt: |
| UNREACHABLE(); |
| } |
| } |
| |
| // WebAssembly.Global.valueOf() -> num |
| void WebAssemblyGlobalValueOf(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| return WebAssemblyGlobalGetValueCommon(args, "WebAssembly.Global.valueOf()"); |
| } |
| |
| // get WebAssembly.Global.value -> num |
| void WebAssemblyGlobalGetValue( |
| const v8::FunctionCallbackInfo<v8::Value>& args) { |
| return WebAssemblyGlobalGetValueCommon(args, "get WebAssembly.Global.value"); |
| } |
| |
| // set WebAssembly.Global.value(num) |
| void WebAssemblyGlobalSetValue( |
| const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| HandleScope scope(isolate); |
| Local<Context> context = isolate->GetCurrentContext(); |
| ScheduledErrorThrower thrower(i_isolate, "set WebAssembly.Global.value"); |
| EXTRACT_THIS(receiver, WasmGlobalObject); |
| |
| if (!receiver->is_mutable()) { |
| thrower.TypeError("Can't set the value of an immutable global."); |
| return; |
| } |
| if (args[0]->IsUndefined()) { |
| thrower.TypeError("Argument 0 is required"); |
| return; |
| } |
| |
| switch (receiver->type().kind()) { |
| case i::wasm::ValueType::kI32: { |
| int32_t i32_value = 0; |
| if (!args[0]->Int32Value(context).To(&i32_value)) return; |
| receiver->SetI32(i32_value); |
| break; |
| } |
| case i::wasm::ValueType::kI64: { |
| auto enabled_features = i::wasm::WasmFeatures::FromIsolate(i_isolate); |
| if (enabled_features.has_bigint()) { |
| v8::Local<v8::BigInt> bigint_value; |
| if (!args[0]->ToBigInt(context).ToLocal(&bigint_value)) return; |
| receiver->SetI64(bigint_value->Int64Value()); |
| } else { |
| thrower.TypeError("Can't set the value of i64 WebAssembly.Global"); |
| } |
| break; |
| } |
| case i::wasm::ValueType::kF32: { |
| double f64_value = 0; |
| if (!args[0]->NumberValue(context).To(&f64_value)) return; |
| receiver->SetF32(i::DoubleToFloat32(f64_value)); |
| break; |
| } |
| case i::wasm::ValueType::kF64: { |
| double f64_value = 0; |
| if (!args[0]->NumberValue(context).To(&f64_value)) return; |
| receiver->SetF64(f64_value); |
| break; |
| } |
| case i::wasm::ValueType::kS128: |
| thrower.TypeError("Can't set the value of s128 WebAssembly.Global"); |
| break; |
| case i::wasm::ValueType::kRef: |
| case i::wasm::ValueType::kOptRef: |
| switch (receiver->type().heap_representation()) { |
| case i::wasm::HeapType::kExtern: |
| case i::wasm::HeapType::kExn: |
| receiver->SetExternRef(Utils::OpenHandle(*args[0])); |
| break; |
| case i::wasm::HeapType::kFunc: { |
| if (!receiver->SetFuncRef(i_isolate, Utils::OpenHandle(*args[0]))) { |
| thrower.TypeError( |
| "value of an funcref reference must be either null or an " |
| "exported function"); |
| } |
| break; |
| } |
| |
| case i::wasm::HeapType::kEq: |
| default: |
| // TODO(7748): Implement these. |
| UNIMPLEMENTED(); |
| break; |
| } |
| break; |
| case i::wasm::ValueType::kRtt: |
| // TODO(7748): Implement. |
| UNIMPLEMENTED(); |
| break; |
| case i::wasm::ValueType::kI8: |
| case i::wasm::ValueType::kI16: |
| case i::wasm::ValueType::kBottom: |
| case i::wasm::ValueType::kStmt: |
| UNREACHABLE(); |
| } |
| } |
| |
| // WebAssembly.Global.type(WebAssembly.Global) -> GlobalType |
| void WebAssemblyGlobalType(const v8::FunctionCallbackInfo<v8::Value>& args) { |
| v8::Isolate* isolate = args.GetIsolate(); |
| HandleScope scope(isolate); |
| i::Isolate* i_isolate = reinterpret_cast<i::Isolate*>(isolate); |
| ScheduledErrorThrower thrower(i_isolate, "WebAssembly.Global.type()"); |
| |
| auto maybe_global = GetFirstArgumentAsGlobal(args, &thrower); |
| if (thrower.error()) return; |
| i::Handle<i::WasmGlobalObject> global = maybe_global.ToHandleChecked(); |
| auto type = i::wasm::GetTypeForGlobal(i_isolate, global->is_mutable(), |
| global->type()); |
| args.GetReturnValue().Set(Utils::ToLocal(type)); |
| } |
| |
| } // namespace |
| |
| // TODO(titzer): we use the API to create the function template because the |
| // internal guts are too ugly to replicate here. |
| static i::Handle<i::FunctionTemplateInfo> NewFunctionTemplate( |
| i::Isolate* i_isolate, FunctionCallback func, bool has_prototype) { |
| Isolate* isolate = reinterpret_cast<Isolate*>(i_isolate); |
| Local<FunctionTemplate> templ = FunctionTemplate::New(isolate, func); |
| has_prototype ? templ->ReadOnlyPrototype() : templ->RemovePrototype(); |
| return v8::Utils::OpenHandle(*templ); |
| } |
| |
| static i::Handle<i::ObjectTemplateInfo> NewObjectTemplate( |
| i::Isolate* i_isolate) { |
| Isolate* isolate = reinterpret_cast<Isolate*>(i_isolate); |
| Local<ObjectTemplate> templ = ObjectTemplate::New(isolate); |
| return v8::Utils::OpenHandle(*templ); |
| } |
| |
| namespace internal { |
| |
| Handle<JSFunction> CreateFunc(Isolate* isolate, Handle<String> name, |
| FunctionCallback func, bool has_prototype) { |
| Handle<FunctionTemplateInfo> temp = |
| NewFunctionTemplate(isolate, func, has_prototype); |
| Handle<JSFunction> function = |
| ApiNatives::InstantiateFunction(temp, name).ToHandleChecked(); |
| DCHECK(function->shared().HasSharedName()); |
| return function; |
| } |
| |
| Handle<JSFunction> InstallFunc(Isolate* isolate, Handle<JSObject> object, |
| const char* str, FunctionCallback func, |
| int length, bool has_prototype = false, |
| PropertyAttributes attributes = NONE) { |
| Handle<String> name = v8_str(isolate, str); |
| Handle<JSFunction> function = CreateFunc(isolate, name, func, has_prototype); |
| function->shared().set_length(length); |
| JSObject::AddProperty(isolate, object, name, function, attributes); |
| return function; |
| } |
| |
| Handle<JSFunction> InstallConstructorFunc(Isolate* isolate, |
| Handle<JSObject> object, |
| const char* str, |
| FunctionCallback func) { |
| return InstallFunc(isolate, object, str, func, 1, true, DONT_ENUM); |
| } |
| |
| Handle<String> GetterName(Isolate* isolate, Handle<String> name) { |
| return Name::ToFunctionName(isolate, name, isolate->factory()->get_string()) |
| .ToHandleChecked(); |
| } |
| |
| void InstallGetter(Isolate* isolate, Handle<JSObject> object, const char* str, |
| FunctionCallback func) { |
| Handle<String> name = v8_str(isolate, str); |
| Handle<JSFunction> function = |
| CreateFunc(isolate, GetterName(isolate, name), func, false); |
| |
| Utils::ToLocal(object)->SetAccessorProperty(Utils::ToLocal(name), |
| Utils::ToLocal(function), |
| Local<Function>(), v8::None); |
| } |
| |
| Handle<String> SetterName(Isolate* isolate, Handle<String> name) { |
| return Name::ToFunctionName(isolate, name, isolate->factory()->set_string()) |
| .ToHandleChecked(); |
| } |
| |
| void InstallGetterSetter(Isolate* isolate, Handle<JSObject> object, |
| const char* str, FunctionCallback getter, |
| FunctionCallback setter) { |
| Handle<String> name = v8_str(isolate, str); |
| Handle<JSFunction> getter_func = |
| CreateFunc(isolate, GetterName(isolate, name), getter, false); |
| Handle<JSFunction> setter_func = |
| CreateFunc(isolate, SetterName(isolate, name), setter, false); |
| setter_func->shared().set_length(1); |
| |
| Utils::ToLocal(object)->SetAccessorProperty( |
| Utils::ToLocal(name), Utils::ToLocal(getter_func), |
| Utils::ToLocal(setter_func), v8::None); |
| } |
| |
| // Assigns a dummy instance template to the given constructor function. Used to |
| // make sure the implicit receivers for the constructors in this file have an |
| // instance type different from the internal one, they allocate the resulting |
| // object explicitly and ignore implicit receiver. |
| void SetDummyInstanceTemplate(Isolate* isolate, Handle<JSFunction> fun) { |
| Handle<ObjectTemplateInfo> instance_template = NewObjectTemplate(isolate); |
| FunctionTemplateInfo::SetInstanceTemplate( |
| isolate, handle(fun->shared().get_api_func_data(), isolate), |
| instance_template); |
| } |
| |
| // static |
| void WasmJs::Install(Isolate* isolate, bool exposed_on_global_object) { |
| Handle<JSGlobalObject> global = isolate->global_object(); |
| Handle<Context> context(global->native_context(), isolate); |
| // Install the JS API once only. |
| Object prev = context->get(Context::WASM_MODULE_CONSTRUCTOR_INDEX); |
| if (!prev.IsUndefined(isolate)) { |
| DCHECK(prev.IsJSFunction()); |
| return; |
| } |
| |
| Factory* factory = isolate->factory(); |
| |
| // Setup WebAssembly |
| Handle<String> name = v8_str(isolate, "WebAssembly"); |
| NewFunctionArgs args = NewFunctionArgs::ForFunctionWithoutCode( |
| name, isolate->strict_function_map(), LanguageMode::kStrict); |
| Handle<JSFunction> cons = factory->NewFunction(args); |
| JSFunction::SetPrototype(cons, isolate->initial_object_prototype()); |
| Handle<JSObject> webassembly = |
| factory->NewJSObject(cons, AllocationType::kOld); |
| |
| PropertyAttributes ro_attributes = |
| static_cast<PropertyAttributes>(DONT_ENUM | READ_ONLY); |
| JSObject::AddProperty(isolate, webassembly, factory->to_string_tag_symbol(), |
| name, ro_attributes); |
| InstallFunc(isolate, webassembly, "compile", WebAssemblyCompile, 1); |
| InstallFunc(isolate, webassembly, "validate", WebAssemblyValidate, 1); |
| InstallFunc(isolate, webassembly, "instantiate", WebAssemblyInstantiate, 1); |
| |
| if (FLAG_wasm_test_streaming) { |
| isolate->set_wasm_streaming_callback(WasmStreamingCallbackForTesting); |
| } |
| |
| if (isolate->wasm_streaming_callback() != nullptr) { |
| InstallFunc(isolate, webassembly, "compileStreaming", |
| WebAssemblyCompileStreaming, 1); |
| InstallFunc(isolate, webassembly, "instantiateStreaming", |
| WebAssemblyInstantiateStreaming, 1); |
| } |
| |
| // Expose the API on the global object if configured to do so. |
| if (exposed_on_global_object) { |
| JSObject::AddProperty(isolate, global, name, webassembly, DONT_ENUM); |
| } |
| |
| // Setup Module |
| Handle<JSFunction> module_constructor = |
| InstallConstructorFunc(isolate, webassembly, "Module", WebAssemblyModule); |
| context->set_wasm_module_constructor(*module_constructor); |
| SetDummyInstanceTemplate(isolate, module_constructor); |
| JSFunction::EnsureHasInitialMap(module_constructor); |
| Handle<JSObject> module_proto( |
| JSObject::cast(module_constructor->instance_prototype()), isolate); |
| Handle<Map> module_map = isolate->factory()->NewMap( |
| i::WASM_MODULE_OBJECT_TYPE, WasmModuleObject::kHeaderSize); |
| JSFunction::SetInitialMap(module_constructor, module_map, module_proto); |
| InstallFunc(isolate, module_constructor, "imports", WebAssemblyModuleImports, |
| 1); |
| InstallFunc(isolate, module_constructor, "exports", WebAssemblyModuleExports, |
| 1); |
| InstallFunc(isolate, module_constructor, "customSections", |
| WebAssemblyModuleCustomSections, 2); |
| JSObject::AddProperty(isolate, module_proto, factory->to_string_tag_symbol(), |
| v8_str(isolate, "WebAssembly.Module"), ro_attributes); |
| |
| // Setup Instance |
| Handle<JSFunction> instance_constructor = InstallConstructorFunc( |
| isolate, webassembly, "Instance", WebAssemblyInstance); |
| context->set_wasm_instance_constructor(*instance_constructor); |
| SetDummyInstanceTemplate(isolate, instance_constructor); |
| JSFunction::EnsureHasInitialMap(instance_constructor); |
| Handle<JSObject> instance_proto( |
| JSObject::cast(instance_constructor->instance_prototype()), isolate); |
| Handle<Map> instance_map = isolate->factory()->NewMap( |
| i::WASM_INSTANCE_OBJECT_TYPE, WasmInstanceObject::kHeaderSize); |
| JSFunction::SetInitialMap(instance_constructor, instance_map, instance_proto); |
| InstallGetter(isolate, instance_proto, "exports", |
| WebAssemblyInstanceGetExports); |
| JSObject::AddProperty(isolate, instance_proto, |
| factory->to_string_tag_symbol(), |
| v8_str(isolate, "WebAssembly.Instance"), ro_attributes); |
| |
| // The context is not set up completely yet. That's why we cannot use |
| // {WasmFeatures::FromIsolate} and have to use {WasmFeatures::FromFlags} |
| // instead. |
| auto enabled_features = i::wasm::WasmFeatures::FromFlags(); |
| |
| // Setup Table |
| Handle<JSFunction> table_constructor = |
| InstallConstructorFunc(isolate, webassembly, "Table", WebAssemblyTable); |
| context->set_wasm_table_constructor(*table_constructor); |
| SetDummyInstanceTemplate(isolate, table_constructor); |
| JSFunction::EnsureHasInitialMap(table_constructor); |
| Handle<JSObject> table_proto( |
| JSObject::cast(table_constructor->instance_prototype()), isolate); |
| Handle<Map> table_map = isolate->factory()->NewMap( |
| i::WASM_TABLE_OBJECT_TYPE, WasmTableObject::kHeaderSize); |
| JSFunction::SetInitialMap(table_constructor, table_map, table_proto); |
| InstallGetter(isolate, table_proto, "length", WebAssemblyTableGetLength); |
| InstallFunc(isolate, table_proto, "grow", WebAssemblyTableGrow, 1); |
| InstallFunc(isolate, table_proto, "get", WebAssemblyTableGet, 1); |
| InstallFunc(isolate, table_proto, "set", WebAssemblyTableSet, 2); |
| if (enabled_features.has_type_reflection()) { |
| InstallFunc(isolate, table_constructor, "type", WebAssemblyTableType, 1); |
| } |
| JSObject::AddProperty(isolate, table_proto, factory->to_string_tag_symbol(), |
| v8_str(isolate, "WebAssembly.Table"), ro_attributes); |
| |
| // Setup Memory |
| // Enables shared memory support. |
| i::FLAG_experimental_wasm_threads = true; |
| i::FLAG_experimental_wasm_simd = true; |
| Handle<JSFunction> memory_constructor = |
| InstallConstructorFunc(isolate, webassembly, "Memory", WebAssemblyMemory); |
| context->set_wasm_memory_constructor(*memory_constructor); |
| SetDummyInstanceTemplate(isolate, memory_constructor); |
| JSFunction::EnsureHasInitialMap(memory_constructor); |
| Handle<JSObject> memory_proto( |
| JSObject::cast(memory_constructor->instance_prototype()), isolate); |
| Handle<Map> memory_map = isolate->factory()->NewMap( |
| i::WASM_MEMORY_OBJECT_TYPE, WasmMemoryObject::kHeaderSize); |
| JSFunction::SetInitialMap(memory_constructor, memory_map, memory_proto); |
| InstallFunc(isolate, memory_proto, "grow", WebAssemblyMemoryGrow, 1); |
| InstallGetter(isolate, memory_proto, "buffer", WebAssemblyMemoryGetBuffer); |
| if (enabled_features.has_type_reflection()) { |
| InstallFunc(isolate, memory_constructor, "type", WebAssemblyMemoryType, 1); |
| } |
| JSObject::AddProperty(isolate, memory_proto, factory->to_string_tag_symbol(), |
| v8_str(isolate, "WebAssembly.Memory"), ro_attributes); |
| |
| // Setup Global |
| Handle<JSFunction> global_constructor = |
| InstallConstructorFunc(isolate, webassembly, "Global", WebAssemblyGlobal); |
| context->set_wasm_global_constructor(*global_constructor); |
| SetDummyInstanceTemplate(isolate, global_constructor); |
| JSFunction::EnsureHasInitialMap(global_constructor); |
| Handle<JSObject> global_proto( |
| JSObject::cast(global_constructor->instance_prototype()), isolate); |
| Handle<Map> global_map = isolate->factory()->NewMap( |
| i::WASM_GLOBAL_OBJECT_TYPE, WasmGlobalObject::kHeaderSize); |
| JSFunction::SetInitialMap(global_constructor, global_map, global_proto); |
| InstallFunc(isolate, global_proto, "valueOf", WebAssemblyGlobalValueOf, 0); |
| InstallGetterSetter(isolate, global_proto, "value", WebAssemblyGlobalGetValue, |
| WebAssemblyGlobalSetValue); |
| if (enabled_features.has_type_reflection()) { |
| InstallFunc(isolate, global_constructor, "type", WebAssemblyGlobalType, 1); |
| } |
| JSObject::AddProperty(isolate, global_proto, factory->to_string_tag_symbol(), |
| v8_str(isolate, "WebAssembly.Global"), ro_attributes); |
| |
| // Setup Exception |
| if (enabled_features.has_eh()) { |
| Handle<JSFunction> exception_constructor = InstallConstructorFunc( |
| isolate, webassembly, "Exception", WebAssemblyException); |
| context->set_wasm_exception_constructor(*exception_constructor); |
| SetDummyInstanceTemplate(isolate, exception_constructor); |
| JSFunction::EnsureHasInitialMap(exception_constructor); |
| Handle<JSObject> exception_proto( |
| JSObject::cast(exception_constructor->instance_prototype()), isolate); |
| Handle<Map> exception_map = isolate->factory()->NewMap( |
| i::WASM_EXCEPTION_OBJECT_TYPE, WasmExceptionObject::kHeaderSize); |
| JSFunction::SetInitialMap(exception_constructor, exception_map, |
| exception_proto); |
| } |
| |
| // Setup Function |
| if (enabled_features.has_type_reflection()) { |
| Handle<JSFunction> function_constructor = InstallConstructorFunc( |
| isolate, webassembly, "Function", WebAssemblyFunction); |
| SetDummyInstanceTemplate(isolate, function_constructor); |
| JSFunction::EnsureHasInitialMap(function_constructor); |
| Handle<JSObject> function_proto( |
| JSObject::cast(function_constructor->instance_prototype()), isolate); |
| Handle<Map> function_map = isolate->factory()->CreateSloppyFunctionMap( |
| FUNCTION_WITHOUT_PROTOTYPE, MaybeHandle<JSFunction>()); |
| CHECK(JSObject::SetPrototype( |
| function_proto, |
| handle(context->function_function().prototype(), isolate), false, |
| kDontThrow) |
| .FromJust()); |
| JSFunction::SetInitialMap(function_constructor, function_map, |
| function_proto); |
| InstallFunc(isolate, function_constructor, "type", WebAssemblyFunctionType, |
| 1); |
| // Make all exported functions an instance of {WebAssembly.Function}. |
| context->set_wasm_exported_function_map(*function_map); |
| } else { |
| // Make all exported functions an instance of {Function}. |
| Handle<Map> function_map = isolate->sloppy_function_without_prototype_map(); |
| context->set_wasm_exported_function_map(*function_map); |
| } |
| |
| // Setup errors |
| Handle<JSFunction> compile_error( |
| isolate->native_context()->wasm_compile_error_function(), isolate); |
| JSObject::AddProperty(isolate, webassembly, |
| isolate->factory()->CompileError_string(), |
| compile_error, DONT_ENUM); |
| Handle<JSFunction> link_error( |
| isolate->native_context()->wasm_link_error_function(), isolate); |
| JSObject::AddProperty(isolate, webassembly, |
| isolate->factory()->LinkError_string(), link_error, |
| DONT_ENUM); |
| Handle<JSFunction> runtime_error( |
| isolate->native_context()->wasm_runtime_error_function(), isolate); |
| JSObject::AddProperty(isolate, webassembly, |
| isolate->factory()->RuntimeError_string(), |
| runtime_error, DONT_ENUM); |
| } |
| |
| namespace { |
| void SetMapValue(Isolate* isolate, Handle<JSMap> map, Handle<Object> key, |
| Handle<Object> value) { |
| DCHECK(!map.is_null() && !key.is_null() && !value.is_null()); |
| Handle<Object> argv[] = {key, value}; |
| Execution::CallBuiltin(isolate, isolate->map_set(), map, arraysize(argv), |
| argv) |
| .Check(); |
| } |
| |
| Handle<Object> GetMapValue(Isolate* isolate, Handle<JSMap> map, |
| Handle<Object> key) { |
| DCHECK(!map.is_null() && !key.is_null()); |
| Handle<Object> argv[] = {key}; |
| return Execution::CallBuiltin(isolate, isolate->map_get(), map, |
| arraysize(argv), argv) |
| .ToHandleChecked(); |
| } |
| |
| // Look up a name in a name table. Name tables are stored under the "names" |
| // property of the handler and map names to index. |
| base::Optional<int> ResolveValueSelector(Isolate* isolate, |
| Handle<Name> property, |
| Handle<JSObject> handler, |
| bool enable_index_lookup) { |
| size_t index = 0; |
| if (enable_index_lookup && property->AsIntegerIndex(&index) && |
| index < kMaxInt) { |
| return static_cast<int>(index); |
| } |
| |
| Handle<Object> name_table = |
| JSObject::GetProperty(isolate, handler, "names").ToHandleChecked(); |
| DCHECK(name_table->IsJSMap()); |
| |
| Handle<Object> object = |
| GetMapValue(isolate, Handle<JSMap>::cast(name_table), property); |
| if (object->IsUndefined()) return {}; |
| DCHECK(object->IsNumeric()); |
| return NumberToInt32(*object); |
| } |
| |
| // Helper for unpacking a maybe name that makes a default with an index if |
| // the name is empty. If the name is not empty, it's prefixed with a $. |
| Handle<String> GetNameOrDefault(Isolate* isolate, |
| MaybeHandle<String> maybe_name, |
| const char* default_name_prefix, int index) { |
| Handle<String> name; |
| if (maybe_name.ToHandle(&name)) { |
| return isolate->factory() |
| ->NewConsString(isolate->factory()->NewStringFromAsciiChecked("$"), |
| name) |
| .ToHandleChecked(); |
| } |
| |
| // Maximum length of the default names: $memory-2147483648\0 |
| static constexpr int kMaxStrLen = 19; |
| EmbeddedVector<char, kMaxStrLen> value; |
| DCHECK_LT(strlen(default_name_prefix) + /*strlen(kMinInt)*/ 11, kMaxStrLen); |
| int len = SNPrintF(value, "%s%d", default_name_prefix, index); |
| return isolate->factory()->InternalizeString(value.SubVector(0, len)); |
| } |
| |
| // Generate names for the locals. Names either come from the name table, |
| // otherwise the default $varX is used. |
| std::vector<Handle<String>> GetLocalNames(Handle<WasmInstanceObject> instance, |
| Address pc) { |
| wasm::NativeModule* native_module = instance->module_object().native_module(); |
| wasm::DebugInfo* debug_info = native_module->GetDebugInfo(); |
| int num_locals = debug_info->GetNumLocals(pc); |
| auto* isolate = instance->GetIsolate(); |
| |
| wasm::ModuleWireBytes module_wire_bytes( |
| instance->module_object().native_module()->wire_bytes()); |
| const wasm::WasmFunction& function = debug_info->GetFunctionAtAddress(pc); |
| |
| std::vector<Handle<String>> names; |
| for (int i = 0; i < num_locals; ++i) { |
| wasm::WireBytesRef local_name_ref = |
| debug_info->GetLocalName(function.func_index, i); |
| DCHECK(module_wire_bytes.BoundsCheck(local_name_ref)); |
| Vector<const char> name_vec = |
| module_wire_bytes.GetNameOrNull(local_name_ref); |
| names.emplace_back(GetNameOrDefault( |
| isolate, |
| name_vec.empty() ? MaybeHandle<String>() |
| : isolate->factory()->NewStringFromUtf8(name_vec), |
| "$var", i)); |
| } |
| |
| return names; |
| } |
| |
| // Generate names for the globals. Names either come from the name table, |
| // otherwise the default $globalX is used. |
| std::vector<Handle<String>> GetGlobalNames( |
| Handle<WasmInstanceObject> instance) { |
| Isolate* isolate = instance->GetIsolate(); |
| auto& globals = instance->module()->globals; |
| std::vector<Handle<String>> names; |
| for (uint32_t i = 0; i < globals.size(); ++i) { |
| names.emplace_back(GetNameOrDefault( |
| isolate, WasmInstanceObject::GetGlobalNameOrNull(isolate, instance, i), |
| "$global", i)); |
| } |
| return names; |
| } |
| |
| // Generate names for the functions. |
| std::vector<Handle<String>> GetFunctionNames( |
| Handle<WasmInstanceObject> instance) { |
| Isolate* isolate = instance->GetIsolate(); |
| auto* module = instance->module(); |
| |
| wasm::ModuleWireBytes wire_bytes( |
| instance->module_object().native_module()->wire_bytes()); |
| |
| std::vector<Handle<String>> names; |
| for (auto& function : module->functions) { |
| DCHECK_EQ(function.func_index, names.size()); |
| wasm::WireBytesRef name_ref = |
| module->lazily_generated_names.LookupFunctionName( |
| wire_bytes, function.func_index, VectorOf(module->export_table)); |
| DCHECK(wire_bytes.BoundsCheck(name_ref)); |
| Vector<const char> name_vec = wire_bytes.GetNameOrNull(name_ref); |
| names.emplace_back(GetNameOrDefault( |
| isolate, |
| name_vec.empty() ? MaybeHandle<String>() |
| : isolate->factory()->NewStringFromUtf8(name_vec), |
| "$func", function.func_index)); |
| } |
| |
| return names; |
| } |
| |
| // Generate names for the imports. |
| std::vector<Handle<String>> GetImportNames( |
| Handle<WasmInstanceObject> instance) { |
| Isolate* isolate = instance->GetIsolate(); |
| const wasm::WasmModule* module = instance->module(); |
| Handle<WasmModuleObject> module_object(instance->module_object(), isolate); |
| int num_imports = static_cast<int>(module->import_table.size()); |
| |
| std::vector<Handle<String>> names; |
| for (int index = 0; index < num_imports; ++index) { |
| const wasm::WasmImport& import = module->import_table[index]; |
| |
| names.emplace_back(WasmModuleObject::ExtractUtf8StringFromModuleBytes( |
| isolate, module_object, import.field_name, kInternalize)); |
| } |
| |
| return names; |
| } |
| |
| // Generate names for the memories. |
| std::vector<Handle<String>> GetMemoryNames( |
| Handle<WasmInstanceObject> instance) { |
| Isolate* isolate = instance->GetIsolate(); |
| |
| std::vector<Handle<String>> names; |
| uint32_t memory_count = instance->has_memory_object() ? 1 : 0; |
| for (uint32_t memory_index = 0; memory_index < memory_count; ++memory_index) { |
| names.emplace_back(GetNameOrDefault(isolate, |
| WasmInstanceObject::GetMemoryNameOrNull( |
| isolate, instance, memory_index), |
| "$memory", memory_index)); |
| } |
| |
| return names; |
| } |
| |
| // Generate names for the tables. |
| std::vector<Handle<String>> GetTableNames(Handle<WasmInstanceObject> instance) { |
| Isolate* isolate = instance->GetIsolate(); |
| auto tables = handle(instance->tables(), isolate); |
| |
| std::vector<Handle<String>> names; |
| for (int table_index = 0; table_index < tables->length(); ++table_index) { |
| auto func_table = |
| handle(WasmTableObject::cast(tables->get(table_index)), isolate); |
| if (!func_table->type().is_reference_to(wasm::HeapType::kFunc)) continue; |
| |
| names.emplace_back(GetNameOrDefault( |
| isolate, |
| WasmInstanceObject::GetTableNameOrNull(isolate, instance, table_index), |
| "$table", table_index)); |
| } |
| return names; |
| } |
| |
| // Generate names for the exports |
| std::vector<Handle<String>> GetExportNames( |
| Handle<WasmInstanceObject> instance) { |
| Isolate* isolate = instance->GetIsolate(); |
| const wasm::WasmModule* module = instance->module(); |
| Handle<WasmModuleObject> module_object(instance->module_object(), isolate); |
| int num_exports = static_cast<int>(module->export_table.size()); |
| |
| std::vector<Handle<String>> names; |
| |
| for (int index = 0; index < num_exports; ++index) { |
| const wasm::WasmExport& exp = module->export_table[index]; |
| |
| names.emplace_back(WasmModuleObject::ExtractUtf8StringFromModuleBytes( |
| isolate, module_object, exp.name, kInternalize)); |
| } |
| return names; |
| } |
| |
| Handle<WasmInstanceObject> GetInstance(Isolate* isolate, |
| Handle<JSObject> handler) { |
| Handle<Object> instance = |
| JSObject::GetProperty(isolate, handler, "instance").ToHandleChecked(); |
| DCHECK(instance->IsWasmInstanceObject()); |
| return Handle<WasmInstanceObject>::cast(instance); |
| } |
| |
| Address GetPC(Isolate* isolate, Handle<JSObject> handler) { |
| Handle<Object> pc = |
| JSObject::GetProperty(isolate, handler, "pc").ToHandleChecked(); |
| DCHECK(pc->IsBigInt()); |
| return Handle<BigInt>::cast(pc)->AsUint64(); |
| } |
| |
| Address GetFP(Isolate* isolate, Handle<JSObject> handler) { |
| Handle<Object> fp = |
| JSObject::GetProperty(isolate, handler, "fp").ToHandleChecked(); |
| DCHECK(fp->IsBigInt()); |
| return Handle<BigInt>::cast(fp)->AsUint64(); |
| } |
| |
| Address GetCalleeFP(Isolate* isolate, Handle<JSObject> handler) { |
| Handle<Object> callee_fp = |
| JSObject::GetProperty(isolate, handler, "callee_fp").ToHandleChecked(); |
| DCHECK(callee_fp->IsBigInt()); |
| return Handle<BigInt>::cast(callee_fp)->AsUint64(); |
| } |
| |
| // Convert a WasmValue to an appropriate JS representation. |
| static Handle<Object> WasmValueToObject(Isolate* isolate, |
| wasm::WasmValue value) { |
| auto* factory = isolate->factory(); |
| switch (value.type().kind()) { |
| case wasm::ValueType::kI32: |
| return factory->NewNumberFromInt(value.to_i32()); |
| case wasm::ValueType::kI64: |
| return BigInt::FromInt64(isolate, value.to_i64()); |
| case wasm::ValueType::kF32: |
| return factory->NewNumber(value.to_f32()); |
| case wasm::ValueType::kF64: |
| return factory->NewNumber(value.to_f64()); |
| case wasm::ValueType::kS128: { |
| wasm::Simd128 s128 = value.to_s128(); |
| Handle<JSArrayBuffer> buffer; |
| if (!isolate->factory() |
| ->NewJSArrayBufferAndBackingStore( |
| kSimd128Size, InitializedFlag::kUninitialized) |
| .ToHandle(&buffer)) { |
| isolate->FatalProcessOutOfHeapMemory( |
| "failed to allocate backing store"); |
| } |
| |
| memcpy(buffer->allocation_base(), s128.bytes(), |
| buffer->byte_length()); |
| return isolate->factory()->NewJSTypedArray(kExternalUint8Array, buffer, 0, |
| buffer->byte_length()); |
| } |
| case wasm::ValueType::kRef: |
| return value.to_externref(); |
| default: |
| break; |
| } |
| return factory->undefined_value(); |
| } |
| |
| base::Optional<int> HasLocalImpl(Isolate* isolate, Handle<Name> property, |
| Handle<JSObject> handler, |
| bool enable_index_lookup) { |
| Handle<WasmInstanceObject> instance = GetInstance(isolate, handler); |
| |
| base::Optional<int> index = |
| ResolveValueSelector(isolate |