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

package/include/node/v8-promise.h

@@ -0,0 +1,185 @@
+// 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_PROMISE_H_
+#define INCLUDE_V8_PROMISE_H_
+
+#include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8-object.h"        // NOLINT(build/include_directory)
+#include "v8config.h"         // NOLINT(build/include_directory)
+
+namespace v8 {
+
+class Context;
+
+#ifndef V8_PROMISE_INTERNAL_FIELD_COUNT
+// Defined using gn arg `v8_promise_internal_field_count`.
+#define V8_PROMISE_INTERNAL_FIELD_COUNT 0
+#endif
+
+/**
+ * An instance of the built-in Promise constructor.
+ */
+class V8_EXPORT Promise : public Object {
+ public:
+  /**
+   * State of the promise. Each value corresponds to one of the possible values
+   * of the [[PromiseState]] field.
+   */
+  enum PromiseState { kPending, kFulfilled, kRejected };
+
+  class V8_EXPORT Resolver : public Object {
+   public:
+    /**
+     * Create a new resolver, along with an associated promise in pending state.
+     */
+    static V8_WARN_UNUSED_RESULT MaybeLocal<Resolver> New(
+        Local<Context> context);
+
+    /**
+     * Extract the associated promise.
+     */
+    Local<Promise> GetPromise();
+
+    /**
+     * Resolve/reject the associated promise with a given value.
+     * Ignored if the promise is no longer pending.
+     */
+    V8_WARN_UNUSED_RESULT Maybe<bool> Resolve(Local<Context> context,
+                                              Local<Value> value);
+
+    V8_WARN_UNUSED_RESULT Maybe<bool> Reject(Local<Context> context,
+                                             Local<Value> value);
+
+    V8_INLINE static Resolver* Cast(Value* value) {
+#ifdef V8_ENABLE_CHECKS
+      CheckCast(value);
+#endif
+      return static_cast<Promise::Resolver*>(value);
+    }
+
+   private:
+    Resolver();
+    static void CheckCast(Value* obj);
+  };
+
+  /**
+   * Register a resolution/rejection handler with a promise. The handler is
+   * given the respective resolution/rejection value as an argument. If the
+   * promise is already resolved/rejected, the handler is invoked at the end of
+   * turn.
+   *
+   * This performs the PerformPromiseThen abstract operation with a fresh native
+   * promise as result, rather than the similar Promise.prototype.then
+   * operation. In particular, it does not do species lookup on the Promise
+   * constructor, and is therefore guaranteed to return a Promise.
+   *
+   * https://tc39.es/ecma262/#sec-performpromisethen
+   *
+   * This is consistent with Promise reactions in WebIDL:
+   *
+   * https://webidl.spec.whatwg.org/#dfn-perform-steps-once-promise-is-settled
+   */
+  V8_WARN_UNUSED_RESULT MaybeLocal<Promise> Catch(Local<Context> context,
+                                                  Local<Function> handler);
+
+  V8_WARN_UNUSED_RESULT MaybeLocal<Promise> Then(Local<Context> context,
+                                                 Local<Function> handler);
+
+  V8_WARN_UNUSED_RESULT MaybeLocal<Promise> Then(Local<Context> context,
+                                                 Local<Function> on_fulfilled,
+                                                 Local<Function> on_rejected);
+
+  /**
+   * Returns true if the promise has at least one derived promise, and
+   * therefore resolve/reject handlers (including default handler).
+   */
+  bool HasHandler() const;
+
+  /**
+   * Returns the content of the [[PromiseResult]] field. The Promise must not
+   * be pending.
+   */
+  Local<Value> Result();
+
+  /**
+   * Returns the value of the [[PromiseState]] field.
+   */
+  PromiseState State();
+
+  /**
+   * Marks this promise as handled to avoid reporting unhandled rejections.
+   */
+  void MarkAsHandled();
+
+  /**
+   * Marks this promise as silent to prevent pausing the debugger when the
+   * promise is rejected.
+   */
+  void MarkAsSilent();
+
+  V8_INLINE static Promise* Cast(Value* value) {
+#ifdef V8_ENABLE_CHECKS
+    CheckCast(value);
+#endif
+    return static_cast<Promise*>(value);
+  }
+
+  static constexpr int kEmbedderFieldCount = V8_PROMISE_INTERNAL_FIELD_COUNT;
+
+ private:
+  Promise();
+  static void CheckCast(Value* obj);
+};
+
+/**
+ * PromiseHook with type kInit is called when a new promise is
+ * created. When a new promise is created as part of the chain in the
+ * case of Promise.then or in the intermediate promises created by
+ * Promise.{race, all}/AsyncFunctionAwait, we pass the parent promise
+ * otherwise we pass undefined.
+ *
+ * PromiseHook with type kResolve is called at the beginning of
+ * resolve or reject function defined by CreateResolvingFunctions.
+ *
+ * PromiseHook with type kBefore is called at the beginning of the
+ * PromiseReactionJob.
+ *
+ * PromiseHook with type kAfter is called right at the end of the
+ * PromiseReactionJob.
+ */
+enum class PromiseHookType { kInit, kResolve, kBefore, kAfter };
+
+using PromiseHook = void (*)(PromiseHookType type, Local<Promise> promise,
+                             Local<Value> parent);
+
+// --- Promise Reject Callback ---
+enum PromiseRejectEvent {
+  kPromiseRejectWithNoHandler = 0,
+  kPromiseHandlerAddedAfterReject = 1,
+  kDeprecatedPromiseRejectAfterResolved V8_DEPRECATED("Removed event") = 2,
+  kDeprecatedPromiseResolveAfterResolved V8_DEPRECATED("Removed event") = 3,
+};
+
+class PromiseRejectMessage {
+ public:
+  PromiseRejectMessage(Local<Promise> promise, PromiseRejectEvent event,
+                       Local<Value> value)
+      : promise_(promise), event_(event), value_(value) {}
+
+  V8_INLINE Local<Promise> GetPromise() const { return promise_; }
+  V8_INLINE PromiseRejectEvent GetEvent() const { return event_; }
+  V8_INLINE Local<Value> GetValue() const { return value_; }
+
+ private:
+  Local<Promise> promise_;
+  PromiseRejectEvent event_;
+  Local<Value> value_;
+};
+
+using PromiseRejectCallback = void (*)(PromiseRejectMessage message);
+
+}  // namespace v8
+
+#endif  // INCLUDE_V8_PROMISE_H_

package/include/node/v8-proxy.h

@@ -0,0 +1,49 @@
+// 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_PROXY_H_
+#define INCLUDE_V8_PROXY_H_
+
+#include "v8-context.h"       // NOLINT(build/include_directory)
+#include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8-object.h"        // NOLINT(build/include_directory)
+#include "v8config.h"         // NOLINT(build/include_directory)
+
+namespace v8 {
+
+class Context;
+
+/**
+ * An instance of the built-in Proxy constructor (ECMA-262, 6th Edition,
+ * 26.2.1).
+ */
+class V8_EXPORT Proxy : public Object {
+ public:
+  Local<Value> GetTarget();
+  Local<Value> GetHandler();
+  bool IsRevoked() const;
+  void Revoke();
+
+  /**
+   * Creates a new Proxy for the target object.
+   */
+  static MaybeLocal<Proxy> New(Local<Context> context,
+                               Local<Object> local_target,
+                               Local<Object> local_handler);
+
+  V8_INLINE static Proxy* Cast(Value* value) {
+#ifdef V8_ENABLE_CHECKS
+    CheckCast(value);
+#endif
+    return static_cast<Proxy*>(value);
+  }
+
+ private:
+  Proxy();
+  static void CheckCast(Value* obj);
+};
+
+}  // namespace v8
+
+#endif  // INCLUDE_V8_PROXY_H_

package/include/node/v8-regexp.h

@@ -0,0 +1,105 @@
+// 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_REGEXP_H_
+#define INCLUDE_V8_REGEXP_H_
+
+#include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8-object.h"        // NOLINT(build/include_directory)
+#include "v8config.h"         // NOLINT(build/include_directory)
+
+namespace v8 {
+
+class Context;
+
+/**
+ * An instance of the built-in RegExp constructor (ECMA-262, 15.10).
+ */
+class V8_EXPORT RegExp : public Object {
+ public:
+  /**
+   * Regular expression flag bits. They can be or'ed to enable a set
+   * of flags.
+   * The kLinear value ('l') is experimental and can only be used with
+   * --enable-experimental-regexp-engine.  RegExps with kLinear flag are
+   *  guaranteed to be executed in asymptotic linear time wrt. the length of
+   *  the subject string.
+   */
+  enum Flags {
+    kNone = 0,
+    kGlobal = 1 << 0,
+    kIgnoreCase = 1 << 1,
+    kMultiline = 1 << 2,
+    kSticky = 1 << 3,
+    kUnicode = 1 << 4,
+    kDotAll = 1 << 5,
+    kLinear = 1 << 6,
+    kHasIndices = 1 << 7,
+    kUnicodeSets = 1 << 8,
+  };
+
+  static constexpr int kFlagCount = 9;
+
+  /**
+   * Creates a regular expression from the given pattern string and
+   * the flags bit field. May throw a JavaScript exception as
+   * described in ECMA-262, 15.10.4.1.
+   *
+   * For example,
+   *   RegExp::New(v8::String::New("foo"),
+   *               static_cast<RegExp::Flags>(kGlobal | kMultiline))
+   * is equivalent to evaluating "/foo/gm".
+   */
+  static V8_WARN_UNUSED_RESULT MaybeLocal<RegExp> New(Local<Context> context,
+                                                      Local<String> pattern,
+                                                      Flags flags);
+
+  /**
+   * Like New, but additionally specifies a backtrack limit. If the number of
+   * backtracks done in one Exec call hits the limit, a match failure is
+   * immediately returned.
+   */
+  static V8_WARN_UNUSED_RESULT MaybeLocal<RegExp> NewWithBacktrackLimit(
+      Local<Context> context, Local<String> pattern, Flags flags,
+      uint32_t backtrack_limit);
+
+  /**
+   * Executes the current RegExp instance on the given subject string.
+   * Equivalent to RegExp.prototype.exec as described in
+   *
+   *   https://tc39.es/ecma262/#sec-regexp.prototype.exec
+   *
+   * On success, an Array containing the matched strings is returned. On
+   * failure, returns Null.
+   *
+   * Note: modifies global context state, accessible e.g. through RegExp.input.
+   */
+  V8_WARN_UNUSED_RESULT MaybeLocal<Object> Exec(Local<Context> context,
+                                                Local<String> subject);
+
+  /**
+   * Returns the value of the source property: a string representing
+   * the regular expression.
+   */
+  Local<String> GetSource() const;
+
+  /**
+   * Returns the flags bit field.
+   */
+  Flags GetFlags() const;
+
+  V8_INLINE static RegExp* Cast(Value* value) {
+#ifdef V8_ENABLE_CHECKS
+    CheckCast(value);
+#endif
+    return static_cast<RegExp*>(value);
+  }
+
+ private:
+  static void CheckCast(Value* obj);
+};
+
+}  // namespace v8
+
+#endif  // INCLUDE_V8_REGEXP_H_

package/include/node/v8-sandbox.h

@@ -0,0 +1,170 @@
+// Copyright 2024 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_SANDBOX_H_
+#define INCLUDE_V8_SANDBOX_H_
+
+#include <cstdint>
+
+#include "v8-internal.h"  // NOLINT(build/include_directory)
+#include "v8config.h"     // NOLINT(build/include_directory)
+
+namespace v8 {
+
+/**
+ * A pointer tag used for wrapping and unwrapping `CppHeap` pointers as used
+ * with JS API wrapper objects that rely on `v8::Object::Wrap()` and
+ * `v8::Object::Unwrap()`.
+ *
+ * The CppHeapPointers use a range-based type checking scheme, where on access
+ * to a pointer, the actual type of the pointer is checked to be within a
+ * specified range of types. This allows supporting type hierarchies, where a
+ * type check for a supertype must succeed for any subtype.
+ *
+ * The tag is currently in practice limited to 15 bits since it needs to fit
+ * together with a marking bit into the unused parts of a pointer.
+ */
+enum class CppHeapPointerTag : uint16_t {
+  kFirstTag = 0,
+  kNullTag = 0,
+
+  /**
+   * The lower type ids are reserved for the embedder to assign. For that, the
+   * main requirement is that all (transitive) child classes of a given parent
+   * class have type ids in the same range, and that there are no unrelated
+   * types in that range. For example, given the following type hierarchy:
+   *
+   *          A     F
+   *         / \
+   *        B   E
+   *       / \
+   *      C   D
+   *
+   * a potential type id assignment that satistifes these requirements is
+   * {C: 0, D: 1, B: 2, A: 3, E: 4, F: 5}. With that, the type check for type A
+   * would check for the range [0, 4], while the check for B would check range
+   * [0, 2], and for F it would simply check [5, 5].
+   *
+   * In addition, there is an option for performance tweaks: if the size of the
+   * type range corresponding to a supertype is a power of two and starts at a
+   * power of two (e.g. [0x100, 0x13f]), then the compiler can often optimize
+   * the type check to use even fewer instructions (essentially replace a AND +
+   * SUB with a single AND).
+   */
+
+  kDefaultTag = 0x7000,
+
+  kZappedEntryTag = 0x7ffd,
+  kEvacuationEntryTag = 0x7ffe,
+  kFreeEntryTag = 0x7fff,
+  // The tags are limited to 15 bits, so the last tag is 0x7fff.
+  kLastTag = 0x7fff,
+};
+
+using CppHeapPointerTagRange = internal::TagRange<CppHeapPointerTag>;
+
+constexpr CppHeapPointerTagRange kAnyCppHeapPointer(
+    CppHeapPointerTag::kFirstTag, CppHeapPointerTag::kLastTag);
+
+/**
+ * Hardware support for the V8 Sandbox.
+ *
+ * This is an experimental feature that may change or be removed without
+ * further notice. Use at your own risk.
+ */
+class SandboxHardwareSupport {
+ public:
+  /**
+   * Initialize sandbox hardware support. This needs to be called before
+   * creating any thread that might access sandbox memory since it sets up
+   * hardware permissions to the memory that will be inherited on clone.
+   */
+  V8_EXPORT static void InitializeBeforeThreadCreation();
+};
+
+namespace internal {
+
+#ifdef V8_COMPRESS_POINTERS
+V8_INLINE static Address* GetCppHeapPointerTableBase(v8::Isolate* isolate) {
+  Address addr = reinterpret_cast<Address>(isolate) +
+                 Internals::kIsolateCppHeapPointerTableOffset +
+                 Internals::kExternalEntityTableBasePointerOffset;
+  return *reinterpret_cast<Address**>(addr);
+}
+#endif  // V8_COMPRESS_POINTERS
+
+template <typename T>
+V8_INLINE static T* ReadCppHeapPointerField(v8::Isolate* isolate,
+                                            Address heap_object_ptr, int offset,
+                                            CppHeapPointerTagRange tag_range) {
+  // This is a specialized version of the the CppHeapPointerTable accessors
+  // which (1) allows the code to be inlined into the callers for performance
+  // and (2) is optimized for code size as there are a huge number of callers
+  // from auto-generated bindings code.
+
+#ifdef V8_COMPRESS_POINTERS
+  const CppHeapPointerHandle handle =
+      Internals::ReadRawField<CppHeapPointerHandle>(heap_object_ptr, offset);
+  const uint32_t index = handle >> kExternalPointerIndexShift;
+  const Address* table = GetCppHeapPointerTableBase(isolate);
+  const std::atomic<Address>* ptr =
+      reinterpret_cast<const std::atomic<Address>*>(&table[index]);
+  Address entry = std::atomic_load_explicit(ptr, std::memory_order_relaxed);
+
+  // Note: the cast to uint32_t is important here. Otherwise, the uint16_t's
+  // would be promoted to int in the range check below, which would result in
+  // undefined behavior (signed integer underflow) if the actual value is less
+  // than the lower bound. Then, the compiler would take advantage of the
+  // undefined behavior and turn the range check into a simple
+  // `actual_tag <= last_tag` comparison, which is incorrect.
+  uint32_t actual_tag = static_cast<uint16_t>(entry);
+  // The actual_tag is shifted to the left by one and contains the marking
+  // bit in the LSB. To ignore that during the type check, simply add one to
+  // the (shifted) range.
+  constexpr int kTagShift = internal::kCppHeapPointerTagShift;
+  uint32_t first_tag = static_cast<uint32_t>(tag_range.first) << kTagShift;
+  uint32_t last_tag = (static_cast<uint32_t>(tag_range.last) << kTagShift) + 1;
+  if (V8_LIKELY(actual_tag >= first_tag && actual_tag <= last_tag)) {
+    entry = entry >> kCppHeapPointerPayloadShift;
+  } else {
+    // If the type check failed, we simply return nullptr here. That way:
+    //  1. The null handle always results in nullptr being returned here, which
+    //     is a desired property. Otherwise, we would need an explicit check for
+    //     the null handle above, and therefore an additional branch. This
+    //     works because the 0th entry of the table always contains nullptr
+    //     tagged with the null tag (i.e. an all-zeros entry). As such,
+    //     regardless of whether the type check succeeds, the result will
+    //     always be nullptr.
+    //  2. The returned pointer is guaranteed to crash even on platforms with
+    //     top byte ignore (TBI), such as Arm64. The alternative would be to
+    //     simply return the original entry with the left-shifted payload.
+    //     However, due to TBI, an access to that may not always result in a
+    //     crash (specifically, if the second most significant byte happens to
+    //     be zero). In addition, there shouldn't be a difference on Arm64
+    //     between returning nullptr or the original entry, since it will
+    //     simply compile to a `csel x0, x8, xzr, lo` instead of a
+    //     `csel x0, x10, x8, lo` instruction.
+    //  3. The machine code sequence ends up being pretty short, which is
+    //     important here as this code will be inlined into a lot of functions.
+    entry = 0;
+  }
+  return reinterpret_cast<T*>(entry);
+#else   // !V8_COMPRESS_POINTERS
+  return reinterpret_cast<T*>(
+      Internals::ReadRawField<Address>(heap_object_ptr, offset));
+#endif  // !V8_COMPRESS_POINTERS
+}
+
+// TODO(saelo): temporary workaround needed to introduce range-based type
+// checks for the external pointer table. See comment above
+// ExternalPointerCanBeEmpty(ExternalPointerTagRange) function for details.
+V8_INLINE static constexpr bool ExternalPointerCanBeEmpty(
+    CppHeapPointerTagRange tag_range) {
+  return true;
+}
+
+}  // namespace internal
+}  // namespace v8
+
+#endif  // INCLUDE_V8_SANDBOX_H_