v8-wasm.h

Go to the documentation of this file.

// Copyright 2021 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.
 
#ifndef INCLUDE_V8_WASM_H_
#define INCLUDE_V8_WASM_H_
 
#include <functional>
#include <memory>
#include <string>
 
#include "v8-internal.h"      // NOLINT(build/include_directory)
#include "v8-local-handle.h"  // NOLINT(build/include_directory)
#include "v8-memory-span.h"   // NOLINT(build/include_directory)
#include "v8-object.h"        // NOLINT(build/include_directory)
#include "v8config.h"         // NOLINT(build/include_directory)
 
namespace v8 {
 
class ArrayBuffer;
class Promise;
 
namespace internal {
namespace wasm {
class NativeModule;
class StreamingDecoder;
}  // namespace wasm
}  // namespace internal
 
struct OwnedBuffer {
  std::unique_ptr<const uint8_t[]> buffer;
  size_t size = 0;
  OwnedBuffer(std::unique_ptr<const uint8_t[]> buffer, size_t size)
      : buffer(std::move(buffer)), size(size) {}
  OwnedBuffer() = default;
};
 
// Wrapper around a compiled WebAssembly module, which is potentially shared by
// different WasmModuleObjects.
class V8_EXPORT CompiledWasmModule {
 public:
  OwnedBuffer Serialize();
 
  MemorySpan<const uint8_t> GetWireBytesRef();
 
  const std::string& source_url() const { return source_url_; }
 
 private:
  friend class WasmModuleObject;
  friend class WasmStreaming;
 
  explicit CompiledWasmModule(std::shared_ptr<internal::wasm::NativeModule>,
                              const char* source_url, size_t url_length);
 
  const std::shared_ptr<internal::wasm::NativeModule> native_module_;
  const std::string source_url_;
};
 
// An instance of WebAssembly.Memory.
class V8_EXPORT WasmMemoryObject : public Object {
 public:
  WasmMemoryObject() = delete;
 
  Local<ArrayBuffer> Buffer();
 
  V8_INLINE static WasmMemoryObject* Cast(Value* value) {
#ifdef V8_ENABLE_CHECKS
    CheckCast(value);
#endif
    return static_cast<WasmMemoryObject*>(value);
  }
 
 private:
  static void CheckCast(Value* object);
};
 
// An instance of WebAssembly.Module.
class V8_EXPORT WasmModuleObject : public Object {
 public:
  WasmModuleObject() = delete;
 
  static MaybeLocal<WasmModuleObject> FromCompiledModule(
      Isolate* isolate, const CompiledWasmModule&);
 
  CompiledWasmModule GetCompiledModule();
 
  static MaybeLocal<WasmModuleObject> Compile(
      Isolate* isolate, MemorySpan<const uint8_t> wire_bytes);
 
  V8_INLINE static WasmModuleObject* Cast(Value* value) {
#ifdef V8_ENABLE_CHECKS
    CheckCast(value);
#endif
    return static_cast<WasmModuleObject*>(value);
  }
 
 private:
  static void CheckCast(Value* obj);
};
 
class V8_EXPORT WasmStreaming final {
 public:
  static constexpr internal::ExternalPointerTag kManagedTag =
      internal::kWasmWasmStreamingTag;
  class WasmStreamingImpl;
 
  explicit WasmStreaming(std::unique_ptr<WasmStreamingImpl> impl);
 
  ~WasmStreaming();
 
  void OnBytesReceived(const uint8_t* bytes, size_t size);
 
  void Finish(bool can_use_compiled_module = true);
 
  void Abort(MaybeLocal<Value> exception);
 
  bool SetCompiledModuleBytes(const uint8_t* bytes, size_t size);
 
  void SetMoreFunctionsCanBeSerializedCallback(
      std::function<void(CompiledWasmModule)>);
 
  /*
   * Sets the UTF-8 encoded source URL for the {Script} object. This must be
   * called before {Finish}.
   */
  void SetUrl(const char* url, size_t length);
 
  static std::shared_ptr<WasmStreaming> Unpack(Isolate* isolate,
                                               Local<Value> value);
 
 private:
  std::unique_ptr<WasmStreamingImpl> impl_;
};
 
}  // namespace v8
 
#endif  // INCLUDE_V8_WASM_H_