@downdraft/native-mobile-android-arm64 0.0.0 → 0.1.1

package/include/node/v8-version.h

@@ -0,0 +1,20 @@
+// 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.
+
+#ifndef V8_INCLUDE_VERSION_H_  // V8_VERSION_H_ conflicts with src/version.h
+#define V8_INCLUDE_VERSION_H_
+
+// These macros define the version number for the current version.
+// NOTE these macros are used by some of the tool scripts and the build
+// system so their names cannot be changed without changing the scripts.
+#define V8_MAJOR_VERSION 14
+#define V8_MINOR_VERSION 6
+#define V8_BUILD_NUMBER 202
+#define V8_PATCH_LEVEL 34
+
+// Use 1 for candidates and 0 otherwise.
+// (Boolean macro values are not supported by all preprocessors.)
+#define V8_IS_CANDIDATE_VERSION 0
+
+#endif  // V8_INCLUDE_VERSION_H_

package/include/node/v8-wasm-trap-handler-posix.h

@@ -0,0 +1,31 @@
+// Copyright 2018 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 V8_WASM_TRAP_HANDLER_POSIX_H_
+#define V8_WASM_TRAP_HANDLER_POSIX_H_
+
+#include <signal.h>
+
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace v8 {
+/**
+ * This function determines whether a memory access violation has been an
+ * out-of-bounds memory access in WebAssembly. If so, it will modify the context
+ * parameter and add a return address where the execution can continue after the
+ * signal handling, and return true. Otherwise, false will be returned.
+ *
+ * The parameters to this function correspond to those passed to a Posix signal
+ * handler. Use this function only on Linux and Mac.
+ *
+ * \param sig_code The signal code, e.g. SIGSEGV.
+ * \param info A pointer to the siginfo_t struct provided to the signal handler.
+ * \param context A pointer to a ucontext_t struct provided to the signal
+ * handler.
+ */
+V8_EXPORT bool TryHandleWebAssemblyTrapPosix(int sig_code, siginfo_t* info,
+                                             void* context);
+
+}  // namespace v8
+#endif  // V8_WASM_TRAP_HANDLER_POSIX_H_

package/include/node/v8-wasm-trap-handler-win.h

@@ -0,0 +1,28 @@
+// Copyright 2018 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 V8_WASM_TRAP_HANDLER_WIN_H_
+#define V8_WASM_TRAP_HANDLER_WIN_H_
+
+#include <windows.h>
+
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace v8 {
+/**
+ * This function determines whether a memory access violation has been an
+ * out-of-bounds memory access in WebAssembly. If so, it will modify the
+ * exception parameter and add a return address where the execution can continue
+ * after the exception handling, and return true. Otherwise the return value
+ * will be false.
+ *
+ * The parameter to this function corresponds to the one passed to a Windows
+ * vectored exception handler. Use this function only on Windows.
+ *
+ * \param exception An EXCEPTION_POINTERS* as provided to the exception handler.
+ */
+V8_EXPORT bool TryHandleWebAssemblyTrapWindows(EXCEPTION_POINTERS* exception);
+
+}  // namespace v8
+#endif  // V8_WASM_TRAP_HANDLER_WIN_H_

package/include/node/v8-wasm.h

@@ -0,0 +1,325 @@
+// 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 <variant>
+
+#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::wasm {
+class NativeModule;
+}  // namespace internal::wasm
+
+/**
+ * An owned byte buffer with associated size.
+ */
+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:
+  /**
+   * Serialize the compiled module. The serialized data does not include the
+   * wire bytes.
+   */
+  OwnedBuffer Serialize();
+
+  /**
+   * Get the (wasm-encoded) wire bytes that were used to compile this module.
+   */
+  MemorySpan<const uint8_t> GetWireBytesRef();
+
+  const std::string& source_url() const { return source_url_; }
+
+ private:
+  friend class WasmModuleCompilation;
+  friend class WasmModuleObject;
+  friend class WasmStreaming;
+
+  explicit CompiledWasmModule(std::shared_ptr<internal::wasm::NativeModule>,
+                              std::string source_url);
+
+  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;
+
+  /**
+   * Returns underlying ArrayBuffer.
+   */
+  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;
+
+  /**
+   * Efficiently re-create a WasmModuleObject, without recompiling, from
+   * a CompiledWasmModule.
+   */
+  static MaybeLocal<WasmModuleObject> FromCompiledModule(
+      Isolate* isolate, const CompiledWasmModule&);
+
+  /**
+   * Get the compiled module for this module object. The compiled module can be
+   * shared by several module objects.
+   */
+  CompiledWasmModule GetCompiledModule();
+
+  /**
+   * Compile a Wasm module from the provided uncompiled bytes.
+   */
+  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);
+};
+
+/**
+ * The V8 interface for WebAssembly streaming compilation. When streaming
+ * compilation is initiated, V8 passes a {WasmStreaming} object to the embedder
+ * such that the embedder can pass the input bytes for streaming compilation to
+ * V8.
+ */
+class V8_EXPORT WasmStreaming final {
+ public:
+  static constexpr internal::ExternalPointerTag kManagedTag =
+      internal::kWasmWasmStreamingTag;
+  class WasmStreamingImpl;
+
+  class ModuleCachingInterface {
+   public:
+    // Get the full wire bytes, to check against the cached version.
+    virtual MemorySpan<const uint8_t> GetWireBytes() const = 0;
+    // Pass serialized (cached) compiled module bytes, to be deserialized and
+    // used as the result of this streaming compilation.
+    // The passed bytes will only be accessed inside this callback, i.e.
+    // lifetime can end after the call.
+    // The return value indicates whether V8 could use the passed bytes; {false}
+    // would be returned on e.g. version mismatch.
+    // This method can only be called once.
+    virtual bool SetCachedCompiledModuleBytes(MemorySpan<const uint8_t>) = 0;
+  };
+
+  using ModuleCachingCallback = std::function<void(ModuleCachingInterface&)>;
+
+  explicit WasmStreaming(std::unique_ptr<WasmStreamingImpl> impl);
+
+  ~WasmStreaming();
+
+  /**
+   * Pass a new chunk of bytes to WebAssembly streaming compilation.
+   * The buffer passed into {OnBytesReceived} is owned by the caller.
+   */
+  void OnBytesReceived(const uint8_t* bytes, size_t size);
+
+  /**
+   * {Finish} should be called after all received bytes where passed to
+   * {OnBytesReceived} to tell V8 that there will be no more bytes. {Finish}
+   * must not be called after {Abort} has been called already.
+   * If {SetHasCompiledModuleBytes()} was called before, a {caching_callback}
+   * can be passed which can inspect the full received wire bytes and set cached
+   * module bytes which will be deserialized then. This callback will happen
+   * synchronously within this call; the callback is not stored.
+   */
+  void Finish(const ModuleCachingCallback& caching_callback);
+
+  /**
+   * Abort streaming compilation. If {exception} has a value, then the promise
+   * associated with streaming compilation is rejected with that value. If
+   * {exception} does not have value, the promise does not get rejected.
+   * {Abort} must not be called repeatedly, or after {Finish}.
+   */
+  void Abort(MaybeLocal<Value> exception);
+
+  /**
+   * Mark that the embedder has (potentially) cached compiled module bytes (i.e.
+   * a serialized {CompiledWasmModule}) that could match this streaming request.
+   * This will cause V8 to skip streaming compilation.
+   * The embedder should then pass a callback to the {Finish} method to pass the
+   * serialized bytes, after potentially checking their validity against the
+   * full received wire bytes.
+   */
+  void SetHasCompiledModuleBytes();
+
+  /**
+   * Sets a callback which is called whenever a significant number of new
+   * functions are ready for serialization.
+   */
+  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);
+
+  /**
+   * Unpacks a {WasmStreaming} object wrapped in a  {Managed} for the embedder.
+   * Since the embedder is on the other side of the API, it cannot unpack the
+   * {Managed} itself.
+   */
+  static std::shared_ptr<WasmStreaming> Unpack(Isolate* isolate,
+                                               Local<Value> value);
+
+ private:
+  std::unique_ptr<WasmStreamingImpl> impl_;
+};
+
+/**
+ * An interface for asynchronous WebAssembly module compilation, to be used e.g.
+ * for implementing source phase imports.
+ * Note: This interface is experimental and can change or be removed without
+ * notice.
+ */
+class V8_EXPORT WasmModuleCompilation final {
+ public:
+  using ModuleCachingCallback = WasmStreaming::ModuleCachingCallback;
+
+  /**
+   * Start an asynchronous module compilation. This can be called on any thread.
+   * TODO(clemensb): Add some way to pass enabled features.
+   * TODO(clemensb): Add some way to pass compile time imports.
+   */
+  WasmModuleCompilation();
+
+  ~WasmModuleCompilation();
+
+  WasmModuleCompilation(const WasmModuleCompilation&) = delete;
+  WasmModuleCompilation& operator=(const WasmModuleCompilation&) = delete;
+
+  /**
+   * Pass a new chunk of bytes to WebAssembly compilation.
+   * The buffer passed into {OnBytesReceived} is owned by the caller and will
+   * not be accessed any more after this call returns.
+   */
+  void OnBytesReceived(const uint8_t* bytes, size_t size);
+
+  /**
+   * {Finish} must be called on the main thread after all bytes were passed to
+   * {OnBytesReceived}.
+   * It eventually calls the provided callback to deliver the compiled module or
+   * an error. This callback will also be called in foreground, but not
+   * necessarily within this call.
+   * {Finish} must not be called after {Abort} has been called already.
+   * If {SetHasCompiledModuleBytes()} was called before, a {caching_callback}
+   * can be passed which can inspect the full received wire bytes and set cached
+   * module bytes which will be deserialized then. This callback will happen
+   * synchronously within this call; the callback is not stored.
+   */
+  void Finish(
+      Isolate*, const ModuleCachingCallback& caching_callback,
+      const std::function<void(
+          std::variant<Local<WasmModuleObject>, Local<Value>> module_or_error)>&
+          resolution_callback);
+
+  /**
+   * Abort compilation. This can be called from any thread.
+   * {Abort} must not be called repeatedly, or after {Finish}.
+   */
+  void Abort();
+
+  /**
+   * Mark that the embedder has (potentially) cached compiled module bytes (i.e.
+   * a serialized {CompiledWasmModule}) that could match this streaming request.
+   * This will cause V8 to skip streaming compilation.
+   * The embedder should then pass a callback to the {Finish} method to pass the
+   * serialized bytes, after potentially checking their validity against the
+   * full received wire bytes.
+   */
+  void SetHasCompiledModuleBytes();
+
+  /**
+   * Sets a callback which is called whenever a significant number of new
+   * functions are ready for serialization.
+   */
+  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);
+
+ private:
+  class Impl;
+  const std::unique_ptr<Impl> impl_;
+};
+
+/**
+ * The V8 interface for a WebAssembly memory map descriptor. This is an
+ * experimental feature that may change and be removed without further
+ * communication.
+ */
+class V8_EXPORT WasmMemoryMapDescriptor : public Object {
+ public:
+  WasmMemoryMapDescriptor() = delete;
+
+  V8_INLINE static WasmMemoryMapDescriptor* Cast(Value* value) {
+#ifdef V8_ENABLE_CHECKS
+    CheckCast(value);
+#endif
+    return static_cast<WasmMemoryMapDescriptor*>(value);
+  }
+
+  using WasmFileDescriptor = int32_t;
+
+  static Local<WasmMemoryMapDescriptor> New(Isolate* isolate,
+                                            WasmFileDescriptor fd);
+
+ private:
+  static void CheckCast(Value* object);
+};
+}  // namespace v8
+
+#endif  // INCLUDE_V8_WASM_H_

package/include/node/v8-weak-callback-info.h

@@ -0,0 +1,88 @@
+// 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_WEAK_CALLBACK_INFO_H_
+#define INCLUDE_V8_WEAK_CALLBACK_INFO_H_
+
+#include <cstring>
+
+#include "cppgc/internal/conditional-stack-allocated.h"  // NOLINT(build/include_directory)
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace v8 {
+
+class Isolate;
+
+namespace api_internal {
+V8_EXPORT void InternalFieldOutOfBounds(int index);
+}  // namespace api_internal
+
+static constexpr int kInternalFieldsInWeakCallback = 2;
+static constexpr int kEmbedderFieldsInWeakCallback = 2;
+
+template <typename T>
+class WeakCallbackInfo
+    : public cppgc::internal::ConditionalStackAllocatedBase<T> {
+ public:
+  using Callback = void (*)(const WeakCallbackInfo<T>& data);
+
+  WeakCallbackInfo(Isolate* isolate, T* parameter,
+                   void* embedder_fields[kEmbedderFieldsInWeakCallback],
+                   Callback* callback)
+      : isolate_(isolate), parameter_(parameter), callback_(callback) {
+    memcpy(embedder_fields_, embedder_fields,
+           sizeof(embedder_fields[0]) * kEmbedderFieldsInWeakCallback);
+  }
+
+  V8_INLINE Isolate* GetIsolate() const { return isolate_; }
+  V8_INLINE T* GetParameter() const { return parameter_; }
+  V8_INLINE void* GetInternalField(int index) const;
+
+  /**
+   * When a weak callback is first invoked the embedders _must_ Reset() the
+   * handle which triggered the callback. The handle itself is unusable for
+   * anything else. No other V8 API calls may be called in the first callback.
+   * Additional work requires scheduling a second invocation via
+   * `SetSecondPassCallback()` which will be called some time after all the
+   * initial callbacks are processed.
+   *
+   * The second pass callback is prohibited from executing JavaScript. Embedders
+   * should schedule another callback in case this is required.
+   */
+  void SetSecondPassCallback(Callback callback) const { *callback_ = callback; }
+
+ private:
+  Isolate* isolate_;
+  T* parameter_;
+  Callback* callback_;
+  void* embedder_fields_[kEmbedderFieldsInWeakCallback];
+};
+
+/**
+ * Weakness type for weak handles.
+ */
+enum class WeakCallbackType {
+  /**
+   * Passes a user-defined void* parameter back to the callback.
+   */
+  kParameter,
+  /**
+   * Passes the first two internal fields of the object back to the callback.
+   */
+  kInternalFields,
+};
+
+template <class T>
+void* WeakCallbackInfo<T>::GetInternalField(int index) const {
+#ifdef V8_ENABLE_CHECKS
+  if (index < 0 || index >= kEmbedderFieldsInWeakCallback) {
+    api_internal::InternalFieldOutOfBounds(index);
+  }
+#endif
+  return embedder_fields_[index];
+}
+
+}  // namespace v8
+
+#endif  // INCLUDE_V8_WEAK_CALLBACK_INFO_H_

package/include/node/v8.h

@@ -0,0 +1,88 @@
+// Copyright 2012 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_H_
+#define INCLUDE_V8_H_
+
+/** \mainpage V8 API Reference Guide
+ *
+ * V8 is Google's open source JavaScript engine.
+ *
+ * This set of documents provides reference material generated from the
+ * V8 header files in the include/ subdirectory.
+ *
+ * For other documentation see https://v8.dev/.
+ */
+
+#include <stddef.h>
+#include <stdint.h>
+
+#include <memory>
+
+#include "cppgc/common.h"
+#include "v8-array-buffer.h"       // NOLINT(build/include_directory)
+#include "v8-container.h"          // NOLINT(build/include_directory)
+#include "v8-context.h"            // NOLINT(build/include_directory)
+#include "v8-data.h"               // NOLINT(build/include_directory)
+#include "v8-date.h"               // NOLINT(build/include_directory)
+#include "v8-debug.h"              // NOLINT(build/include_directory)
+#include "v8-exception.h"          // NOLINT(build/include_directory)
+#include "v8-extension.h"          // NOLINT(build/include_directory)
+#include "v8-external.h"           // NOLINT(build/include_directory)
+#include "v8-function.h"           // NOLINT(build/include_directory)
+#include "v8-initialization.h"     // NOLINT(build/include_directory)
+#include "v8-internal.h"           // NOLINT(build/include_directory)
+#include "v8-isolate.h"            // NOLINT(build/include_directory)
+#include "v8-json.h"               // NOLINT(build/include_directory)
+#include "v8-local-handle.h"       // NOLINT(build/include_directory)
+#include "v8-locker.h"             // NOLINT(build/include_directory)
+#include "v8-maybe.h"              // NOLINT(build/include_directory)
+#include "v8-memory-span.h"        // NOLINT(build/include_directory)
+#include "v8-message.h"            // NOLINT(build/include_directory)
+#include "v8-microtask-queue.h"    // NOLINT(build/include_directory)
+#include "v8-microtask.h"          // NOLINT(build/include_directory)
+#include "v8-object.h"             // NOLINT(build/include_directory)
+#include "v8-persistent-handle.h"  // NOLINT(build/include_directory)
+#include "v8-primitive-object.h"   // NOLINT(build/include_directory)
+#include "v8-primitive.h"          // NOLINT(build/include_directory)
+#include "v8-promise.h"            // NOLINT(build/include_directory)
+#include "v8-proxy.h"              // NOLINT(build/include_directory)
+#include "v8-regexp.h"             // NOLINT(build/include_directory)
+#include "v8-script.h"             // NOLINT(build/include_directory)
+#include "v8-snapshot.h"           // NOLINT(build/include_directory)
+#include "v8-statistics.h"         // NOLINT(build/include_directory)
+#include "v8-template.h"           // NOLINT(build/include_directory)
+#include "v8-traced-handle.h"      // NOLINT(build/include_directory)
+#include "v8-typed-array.h"        // NOLINT(build/include_directory)
+#include "v8-unwinder.h"           // NOLINT(build/include_directory)
+#include "v8-value-serializer.h"   // NOLINT(build/include_directory)
+#include "v8-value.h"              // NOLINT(build/include_directory)
+#include "v8-version.h"            // NOLINT(build/include_directory)
+#include "v8-wasm.h"               // NOLINT(build/include_directory)
+#include "v8config.h"              // NOLINT(build/include_directory)
+
+// We reserve the V8_* prefix for macros defined in V8 public API and
+// assume there are no name conflicts with the embedder's code.
+
+/**
+ * The v8 JavaScript engine.
+ */
+namespace v8 {
+
+class Platform;
+
+/**
+ * \example shell.cc
+ * A simple shell that takes a list of expressions on the
+ * command-line and executes them.
+ */
+
+/**
+ * \example process.cc
+ */
+
+
+}  // namespace v8
+
+#endif  // INCLUDE_V8_H_