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

package/include/node/v8-exception.h

@@ -0,0 +1,298 @@
+// 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_EXCEPTION_H_
+#define INCLUDE_V8_EXCEPTION_H_
+
+#include <stddef.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;
+class Isolate;
+class Message;
+class StackTrace;
+class String;
+class Value;
+
+namespace internal {
+class Isolate;
+class ThreadLocalTop;
+}  // namespace internal
+
+/**
+ * Create new error objects by calling the corresponding error object
+ * constructor with the message.
+ */
+class V8_EXPORT Exception {
+ public:
+  static Local<Value> RangeError(Local<String> message,
+                                 Local<Value> options = {});
+  static Local<Value> ReferenceError(Local<String> message,
+                                     Local<Value> options = {});
+  static Local<Value> SyntaxError(Local<String> message,
+                                  Local<Value> options = {});
+  static Local<Value> TypeError(Local<String> message,
+                                Local<Value> options = {});
+  static Local<Value> WasmCompileError(Local<String> message,
+                                       Local<Value> options = {});
+  static Local<Value> WasmLinkError(Local<String> message,
+                                    Local<Value> options = {});
+  static Local<Value> WasmRuntimeError(Local<String> message,
+                                       Local<Value> options = {});
+  static Local<Value> WasmSuspendError(Local<String> message,
+                                       Local<Value> options = {});
+  static Local<Value> Error(Local<String> message, Local<Value> options = {});
+
+  /**
+   * Creates an error message for the given exception.
+   * Will try to reconstruct the original stack trace from the exception value,
+   * or capture the current stack trace if not available.
+   */
+  static Local<Message> CreateMessage(Isolate* isolate, Local<Value> exception);
+
+  /**
+   * Returns the original stack trace that was captured at the creation time
+   * of a given exception, or an empty handle if not available.
+   */
+  static Local<StackTrace> GetStackTrace(Local<Value> exception);
+
+  /**
+   * Captures the current stack trace and attaches it to the given object in the
+   * form of `stack` property.
+   */
+  static Maybe<bool> CaptureStackTrace(Local<Context> context,
+                                       Local<Object> object);
+};
+
+/**
+ * This is a part of experimental Api and might be changed without further
+ * notice.
+ * Do not use it.
+ */
+enum class ExceptionContext : uint32_t {
+  kUnknown,
+  kConstructor,
+  kOperation,
+  kAttributeGet,
+  kAttributeSet,
+  kIndexedQuery,
+  kIndexedGetter,
+  kIndexedDescriptor,
+  kIndexedSetter,
+  kIndexedDefiner,
+  kIndexedDeleter,
+  kNamedQuery,
+  kNamedGetter,
+  kNamedDescriptor,
+  kNamedSetter,
+  kNamedDefiner,
+  kNamedDeleter,
+  kNamedEnumerator
+};
+
+/**
+ * This is a part of experimental Api and might be changed without further
+ * notice.
+ * Do not use it.
+ */
+class ExceptionPropagationMessage {
+ public:
+  ExceptionPropagationMessage(v8::Isolate* isolate, Local<Object> exception,
+                              Local<String> interface_name,
+                              Local<String> property_name,
+                              ExceptionContext exception_context)
+      : isolate_(isolate),
+        exception_(exception),
+        interface_name_(interface_name),
+        property_name_(property_name),
+        exception_context_(exception_context) {}
+
+  V8_INLINE Isolate* GetIsolate() const { return isolate_; }
+  V8_INLINE Local<Object> GetException() const { return exception_; }
+  V8_INLINE Local<String> GetInterfaceName() const { return interface_name_; }
+  V8_INLINE Local<String> GetPropertyName() const { return property_name_; }
+  V8_INLINE ExceptionContext GetExceptionContext() const {
+    return exception_context_;
+  }
+
+ private:
+  Isolate* isolate_;
+  Local<Object> exception_;
+  Local<String> interface_name_;
+  Local<String> property_name_;
+  ExceptionContext exception_context_;
+};
+
+using ExceptionPropagationCallback =
+    void (*)(ExceptionPropagationMessage message);
+
+/**
+ * An external exception handler.
+ */
+class V8_EXPORT TryCatch {
+ public:
+  /**
+   * Creates a new try/catch block and registers it with v8.  Note that
+   * all TryCatch blocks should be stack allocated because the memory
+   * location itself is compared against JavaScript try/catch blocks.
+   */
+  explicit TryCatch(Isolate* isolate);
+
+  /**
+   * Unregisters and deletes this try/catch block.
+   */
+  ~TryCatch();
+
+  /**
+   * Returns true if an exception has been caught by this try/catch block.
+   */
+  bool HasCaught() const;
+
+  /**
+   * For certain types of exceptions, it makes no sense to continue execution.
+   *
+   * If CanContinue returns false, the correct action is to perform any C++
+   * cleanup needed and then return.  If CanContinue returns false and
+   * HasTerminated returns true, it is possible to call
+   * CancelTerminateExecution in order to continue calling into the engine.
+   */
+  bool CanContinue() const;
+
+  /**
+   * Returns true if an exception has been caught due to script execution
+   * being terminated.
+   *
+   * There is no JavaScript representation of an execution termination
+   * exception.  Such exceptions are thrown when the TerminateExecution
+   * methods are called to terminate a long-running script.
+   *
+   * If such an exception has been thrown, HasTerminated will return true,
+   * indicating that it is possible to call CancelTerminateExecution in order
+   * to continue calling into the engine.
+   */
+  bool HasTerminated() const;
+
+  /**
+   * Throws the exception caught by this TryCatch in a way that avoids
+   * it being caught again by this same TryCatch.  As with ThrowException
+   * it is illegal to execute any JavaScript operations after calling
+   * ReThrow; the caller must return immediately to where the exception
+   * is caught.
+   */
+  Local<Value> ReThrow();
+
+  /**
+   * Returns the exception caught by this try/catch block.  If no exception has
+   * been caught an empty handle is returned.
+   */
+  Local<Value> Exception() const;
+
+  /**
+   * Returns the .stack property of an object.  If no .stack
+   * property is present an empty handle is returned.
+   */
+  V8_WARN_UNUSED_RESULT static MaybeLocal<Value> StackTrace(
+      Local<Context> context, Local<Value> exception);
+
+  /**
+   * Returns the .stack property of the thrown object.  If no .stack property is
+   * present or if this try/catch block has not caught an exception, an empty
+   * handle is returned.
+   */
+  V8_WARN_UNUSED_RESULT MaybeLocal<Value> StackTrace(
+      Local<Context> context) const;
+
+  /**
+   * Returns the message associated with this exception.  If there is
+   * no message associated an empty handle is returned.
+   */
+  Local<v8::Message> Message() const;
+
+  /**
+   * Clears any exceptions that may have been caught by this try/catch block.
+   * After this method has been called, HasCaught() will return false. Cancels
+   * the scheduled exception if it is caught and ReThrow() is not called before.
+   *
+   * It is not necessary to clear a try/catch block before using it again; if
+   * another exception is thrown the previously caught exception will just be
+   * overwritten.  However, it is often a good idea since it makes it easier
+   * to determine which operation threw a given exception.
+   */
+  void Reset();
+
+  /**
+   * Set verbosity of the external exception handler.
+   *
+   * By default, exceptions that are caught by an external exception
+   * handler are not reported.  Call SetVerbose with true on an
+   * external exception handler to have exceptions caught by the
+   * handler reported as if they were not caught.
+   */
+  void SetVerbose(bool value);
+
+  /**
+   * Returns true if verbosity is enabled.
+   */
+  bool IsVerbose() const;
+
+  /**
+   * Set whether or not this TryCatch should capture a Message object
+   * which holds source information about where the exception
+   * occurred.  True by default.
+   */
+  void SetCaptureMessage(bool value);
+
+  TryCatch(const TryCatch&) = delete;
+  void operator=(const TryCatch&) = delete;
+
+ private:
+  // Declaring operator new and delete as deleted is not spec compliant.
+  // Therefore declare them private instead to disable dynamic alloc
+  void* operator new(size_t size);
+  void* operator new[](size_t size);
+  void operator delete(void*, size_t);
+  void operator delete[](void*, size_t);
+
+  /**
+   * There are cases when the raw address of C++ TryCatch object cannot be
+   * used for comparisons with addresses into the JS stack. The cases are:
+   * 1) ARM, ARM64 and MIPS simulators which have separate JS stack.
+   * 2) Address sanitizer allocates local C++ object in the heap when
+   *    UseAfterReturn mode is enabled.
+   * This method returns address that can be used for comparisons with
+   * addresses into the JS stack. When neither simulator nor ASAN's
+   * UseAfterReturn is enabled, then the address returned will be the address
+   * of the C++ try catch handler itself.
+   */
+  internal::Address JSStackComparableAddressPrivate() {
+    return js_stack_comparable_address_;
+  }
+
+  void ResetInternal();
+
+  // Helper methods for internal::Isolate.
+  bool capture_message() const;
+  void set_can_continue(bool value);
+  bool rethrow() const;
+  void set_rethrow(bool value);
+
+  internal::Isolate* i_isolate_;
+  TryCatch* next_;
+  void* exception_;
+  void* message_obj_;
+  internal::Address js_stack_comparable_address_;
+  uint8_t flags_;
+
+  friend class internal::Isolate;
+  friend class internal::ThreadLocalTop;
+};
+
+}  // namespace v8
+
+#endif  // INCLUDE_V8_EXCEPTION_H_

package/include/node/v8-extension.h

@@ -0,0 +1,60 @@
+// 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_EXTENSION_H_
+#define INCLUDE_V8_EXTENSION_H_
+
+#include <memory>
+
+#include "v8-local-handle.h"  // NOLINT(build/include_directory)
+#include "v8-primitive.h"     // NOLINT(build/include_directory)
+#include "v8config.h"         // NOLINT(build/include_directory)
+
+namespace v8 {
+
+class FunctionTemplate;
+
+// --- Extensions ---
+
+/**
+ * Ignore
+ */
+class V8_EXPORT Extension {
+ public:
+  // Note that the strings passed into this constructor must live as long
+  // as the Extension itself.
+  Extension(const char* name, const char* source = nullptr, int dep_count = 0,
+            const char** deps = nullptr, int source_length = -1);
+  virtual ~Extension() { delete source_; }
+  virtual Local<FunctionTemplate> GetNativeFunctionTemplate(
+      Isolate* isolate, Local<String> name) {
+    return Local<FunctionTemplate>();
+  }
+
+  const char* name() const { return name_; }
+  const String::ExternalOneByteStringResource* source() const {
+    return source_;
+  }
+  int dependency_count() const { return dep_count_; }
+  const char** dependencies() const { return deps_; }
+  void set_auto_enable(bool value) { auto_enable_ = value; }
+  bool auto_enable() { return auto_enable_; }
+
+  // Disallow copying and assigning.
+  Extension(const Extension&) = delete;
+  void operator=(const Extension&) = delete;
+
+ private:
+  const char* name_;
+  String::ExternalOneByteStringResource* source_;
+  int dep_count_;
+  const char** deps_;
+  bool auto_enable_;
+};
+
+void V8_EXPORT RegisterExtension(std::unique_ptr<Extension>);
+
+}  // namespace v8
+
+#endif  // INCLUDE_V8_EXTENSION_H_

package/include/node/v8-external-memory-accounter.h

@@ -0,0 +1,60 @@
+// 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_EXTERNAL_MEMORY_ACCOUNTER_H_
+#define INCLUDE_EXTERNAL_MEMORY_ACCOUNTER_H_
+
+#include <stdint.h>
+
+#include "v8-isolate.h"
+
+namespace v8 {
+
+/**
+ * This class is used to give V8 an indication of the amount of externally
+ * allocated memory that is kept alive by JavaScript objects. V8 uses this to
+ * decide when to perform garbage collections. Registering externally allocated
+ * memory will trigger garbage collections more often than it would otherwise in
+ * an attempt to garbage collect the JavaScript objects that keep the externally
+ * allocated memory alive. Instances of ExternalMemoryAccounter check that the
+ * reported external memory is back to 0 on destruction.
+ */
+class V8_EXPORT ExternalMemoryAccounter {
+ public:
+  /**
+   * Returns the amount of external memory registered for `isolate`.
+   */
+  static int64_t GetTotalAmountOfExternalAllocatedMemoryForTesting(
+      const Isolate* isolate);
+
+  ExternalMemoryAccounter() = default;
+  ~ExternalMemoryAccounter();
+  ExternalMemoryAccounter(ExternalMemoryAccounter&&);
+  ExternalMemoryAccounter& operator=(ExternalMemoryAccounter&&);
+  ExternalMemoryAccounter(const ExternalMemoryAccounter&) = delete;
+  ExternalMemoryAccounter& operator=(const ExternalMemoryAccounter&) = delete;
+
+  /**
+   * Reports an increase of `size` bytes of external memory.
+   */
+  void Increase(Isolate* isolate, size_t size);
+  /**
+   * Reports an update of `delta` bytes of external memory.
+   */
+  void Update(Isolate* isolate, int64_t delta);
+  /**
+   * Reports an decrease of `size` bytes of external memory.
+   */
+  void Decrease(Isolate* isolate, size_t size);
+
+ private:
+#ifdef V8_ENABLE_MEMORY_ACCOUNTING_CHECKS
+  size_t amount_of_external_memory_ = 0;
+  v8::Isolate* isolate_ = nullptr;
+#endif
+};
+
+}  // namespace v8
+
+#endif  // INCLUDE_EXTERNAL_MEMORY_ACCOUNTER_H_

package/include/node/v8-external.h

@@ -0,0 +1,73 @@
+// 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_EXTERNAL_H_
+#define INCLUDE_V8_EXTERNAL_H_
+
+#include "v8-value.h"  // NOLINT(build/include_directory)
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace v8 {
+
+class Isolate;
+
+/**
+ * A tag for external pointers. Objects with different C++ types should use
+ * different values of ExternalPointerTypeTag when using v8::External. The
+ * allowed range is 0..V8_EXTERNAL_POINTER_TAG_COUNT - 1. If this is not
+ * sufficient, V8_EXTERNAL_POINTER_TAG_COUNT can be increased.
+ */
+using ExternalPointerTypeTag = uint16_t;
+
+constexpr ExternalPointerTypeTag kExternalPointerTypeTagDefault = 0;
+
+/**
+ * A JavaScript value that wraps a C++ void*. This type of value is mainly used
+ * to associate C++ data structures with JavaScript objects.
+ */
+class V8_EXPORT External : public Value {
+ public:
+  V8_DEPRECATED("Use the version with the type tag.")
+  static Local<External> New(Isolate* isolate, void* value) {
+    return New(isolate, value, kExternalPointerTypeTagDefault);
+  }
+  /**
+   * Creates a new External object.
+   *
+   * \param isolate The isolate for the external object.
+   * \param value The C++ pointer value.
+   * \param tag The type tag of the external pointer. If type tags are not used
+   * in the embedder, the default value `kExternalPointerTypeTagDefault` can be
+   * used.
+   * \return The new External object.
+   */
+  static Local<External> New(Isolate* isolate, void* value,
+                             ExternalPointerTypeTag tag);
+  V8_INLINE static External* Cast(Data* value) {
+#ifdef V8_ENABLE_CHECKS
+    CheckCast(value);
+#endif
+    return static_cast<External*>(value);
+  }
+
+  V8_DEPRECATED("Use the version with the type tag.")
+  void* Value() const { return Value(kExternalPointerTypeTagDefault); }
+
+  /**
+   * Returns the value of the external pointer.
+   *
+   * \param tag The type tag of the external pointer. If type tags are not used
+   * in the embedder, the default value `kExternalPointerTypeTagDefault` can be
+   * used.
+   * \return The value of the external pointer.
+   */
+  void* Value(ExternalPointerTypeTag tag) const;
+
+ private:
+  static void CheckCast(v8::Data* obj);
+};
+
+}  // namespace v8
+
+#endif  // INCLUDE_V8_EXTERNAL_H_