libv8-node 15.5.1.0.beta1-x86_64-darwin-21

data/vendor/v8/include/v8-internal.h

@@ -0,0 +1,427 @@
+// 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 INCLUDE_V8_INTERNAL_H_
+#define INCLUDE_V8_INTERNAL_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+#include <type_traits>
+
+#include "v8-version.h"  // NOLINT(build/include_directory)
+#include "v8config.h"    // NOLINT(build/include_directory)
+
+namespace v8 {
+
+class Context;
+class Data;
+class Isolate;
+
+namespace internal {
+
+class Isolate;
+
+typedef uintptr_t Address;
+static const Address kNullAddress = 0;
+
+/**
+ * Configuration of tagging scheme.
+ */
+const int kApiSystemPointerSize = sizeof(void*);
+const int kApiDoubleSize = sizeof(double);
+const int kApiInt32Size = sizeof(int32_t);
+const int kApiInt64Size = sizeof(int64_t);
+
+// Tag information for HeapObject.
+const int kHeapObjectTag = 1;
+const int kWeakHeapObjectTag = 3;
+const int kHeapObjectTagSize = 2;
+const intptr_t kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1;
+
+// Tag information for Smi.
+const int kSmiTag = 0;
+const int kSmiTagSize = 1;
+const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1;
+
+template <size_t tagged_ptr_size>
+struct SmiTagging;
+
+constexpr intptr_t kIntptrAllBitsSet = intptr_t{-1};
+constexpr uintptr_t kUintptrAllBitsSet =
+    static_cast<uintptr_t>(kIntptrAllBitsSet);
+
+// Smi constants for systems where tagged pointer is a 32-bit value.
+template <>
+struct SmiTagging<4> {
+  enum { kSmiShiftSize = 0, kSmiValueSize = 31 };
+
+  static constexpr intptr_t kSmiMinValue =
+      static_cast<intptr_t>(kUintptrAllBitsSet << (kSmiValueSize - 1));
+  static constexpr intptr_t kSmiMaxValue = -(kSmiMinValue + 1);
+
+  V8_INLINE static int SmiToInt(const internal::Address value) {
+    int shift_bits = kSmiTagSize + kSmiShiftSize;
+    // Truncate and shift down (requires >> to be sign extending).
+    return static_cast<int32_t>(static_cast<uint32_t>(value)) >> shift_bits;
+  }
+  V8_INLINE static constexpr bool IsValidSmi(intptr_t value) {
+    // Is value in range [kSmiMinValue, kSmiMaxValue].
+    // Use unsigned operations in order to avoid undefined behaviour in case of
+    // signed integer overflow.
+    return (static_cast<uintptr_t>(value) -
+            static_cast<uintptr_t>(kSmiMinValue)) <=
+           (static_cast<uintptr_t>(kSmiMaxValue) -
+            static_cast<uintptr_t>(kSmiMinValue));
+  }
+};
+
+// Smi constants for systems where tagged pointer is a 64-bit value.
+template <>
+struct SmiTagging<8> {
+  enum { kSmiShiftSize = 31, kSmiValueSize = 32 };
+
+  static constexpr intptr_t kSmiMinValue =
+      static_cast<intptr_t>(kUintptrAllBitsSet << (kSmiValueSize - 1));
+  static constexpr intptr_t kSmiMaxValue = -(kSmiMinValue + 1);
+
+  V8_INLINE static int SmiToInt(const internal::Address value) {
+    int shift_bits = kSmiTagSize + kSmiShiftSize;
+    // Shift down and throw away top 32 bits.
+    return static_cast<int>(static_cast<intptr_t>(value) >> shift_bits);
+  }
+  V8_INLINE static constexpr bool IsValidSmi(intptr_t value) {
+    // To be representable as a long smi, the value must be a 32-bit integer.
+    return (value == static_cast<int32_t>(value));
+  }
+};
+
+#ifdef V8_COMPRESS_POINTERS
+static_assert(
+    kApiSystemPointerSize == kApiInt64Size,
+    "Pointer compression can be enabled only for 64-bit architectures");
+const int kApiTaggedSize = kApiInt32Size;
+#else
+const int kApiTaggedSize = kApiSystemPointerSize;
+#endif
+
+constexpr bool PointerCompressionIsEnabled() {
+  return kApiTaggedSize != kApiSystemPointerSize;
+}
+
+constexpr bool HeapSandboxIsEnabled() {
+#ifdef V8_HEAP_SANDBOX
+  return true;
+#else
+  return false;
+#endif
+}
+
+using ExternalPointer_t = Address;
+
+#ifdef V8_31BIT_SMIS_ON_64BIT_ARCH
+using PlatformSmiTagging = SmiTagging<kApiInt32Size>;
+#else
+using PlatformSmiTagging = SmiTagging<kApiTaggedSize>;
+#endif
+
+// TODO(ishell): Consinder adding kSmiShiftBits = kSmiShiftSize + kSmiTagSize
+// since it's used much more often than the inividual constants.
+const int kSmiShiftSize = PlatformSmiTagging::kSmiShiftSize;
+const int kSmiValueSize = PlatformSmiTagging::kSmiValueSize;
+const int kSmiMinValue = static_cast<int>(PlatformSmiTagging::kSmiMinValue);
+const int kSmiMaxValue = static_cast<int>(PlatformSmiTagging::kSmiMaxValue);
+constexpr bool SmiValuesAre31Bits() { return kSmiValueSize == 31; }
+constexpr bool SmiValuesAre32Bits() { return kSmiValueSize == 32; }
+
+V8_INLINE static constexpr internal::Address IntToSmi(int value) {
+  return (static_cast<Address>(value) << (kSmiTagSize + kSmiShiftSize)) |
+         kSmiTag;
+}
+
+// {obj} must be the raw tagged pointer representation of a HeapObject
+// that's guaranteed to never be in ReadOnlySpace.
+V8_EXPORT internal::Isolate* IsolateFromNeverReadOnlySpaceObject(Address obj);
+
+// Returns if we need to throw when an error occurs. This infers the language
+// mode based on the current context and the closure. This returns true if the
+// language mode is strict.
+V8_EXPORT bool ShouldThrowOnError(v8::internal::Isolate* isolate);
+
+/**
+ * This class exports constants and functionality from within v8 that
+ * is necessary to implement inline functions in the v8 api.  Don't
+ * depend on functions and constants defined here.
+ */
+class Internals {
+ public:
+  // These values match non-compiler-dependent values defined within
+  // the implementation of v8.
+  static const int kHeapObjectMapOffset = 0;
+  static const int kMapInstanceTypeOffset = 1 * kApiTaggedSize + kApiInt32Size;
+  static const int kStringResourceOffset =
+      1 * kApiTaggedSize + 2 * kApiInt32Size;
+
+  static const int kOddballKindOffset = 4 * kApiTaggedSize + kApiDoubleSize;
+  static const int kJSObjectHeaderSize = 3 * kApiTaggedSize;
+  static const int kFixedArrayHeaderSize = 2 * kApiTaggedSize;
+  static const int kEmbedderDataArrayHeaderSize = 2 * kApiTaggedSize;
+  static const int kEmbedderDataSlotSize = kApiSystemPointerSize;
+  static const int kNativeContextEmbedderDataOffset = 6 * kApiTaggedSize;
+  static const int kFullStringRepresentationMask = 0x0f;
+  static const int kStringEncodingMask = 0x8;
+  static const int kExternalTwoByteRepresentationTag = 0x02;
+  static const int kExternalOneByteRepresentationTag = 0x0a;
+
+  static const uint32_t kNumIsolateDataSlots = 4;
+
+  // IsolateData layout guarantees.
+  static const int kIsolateEmbedderDataOffset = 0;
+  static const int kIsolateFastCCallCallerFpOffset =
+      kNumIsolateDataSlots * kApiSystemPointerSize;
+  static const int kIsolateFastCCallCallerPcOffset =
+      kIsolateFastCCallCallerFpOffset + kApiSystemPointerSize;
+  static const int kIsolateStackGuardOffset =
+      kIsolateFastCCallCallerPcOffset + kApiSystemPointerSize;
+  static const int kIsolateRootsOffset =
+      kIsolateStackGuardOffset + 7 * kApiSystemPointerSize;
+
+  static const int kUndefinedValueRootIndex = 4;
+  static const int kTheHoleValueRootIndex = 5;
+  static const int kNullValueRootIndex = 6;
+  static const int kTrueValueRootIndex = 7;
+  static const int kFalseValueRootIndex = 8;
+  static const int kEmptyStringRootIndex = 9;
+
+  static const int kNodeClassIdOffset = 1 * kApiSystemPointerSize;
+  static const int kNodeFlagsOffset = 1 * kApiSystemPointerSize + 3;
+  static const int kNodeStateMask = 0x7;
+  static const int kNodeStateIsWeakValue = 2;
+  static const int kNodeStateIsPendingValue = 3;
+
+  static const int kFirstNonstringType = 0x40;
+  static const int kOddballType = 0x43;
+  static const int kForeignType = 0x46;
+  static const int kJSSpecialApiObjectType = 0x410;
+  static const int kJSApiObjectType = 0x420;
+  static const int kJSObjectType = 0x421;
+
+  static const int kUndefinedOddballKind = 5;
+  static const int kNullOddballKind = 3;
+
+  // Constants used by PropertyCallbackInfo to check if we should throw when an
+  // error occurs.
+  static const int kThrowOnError = 0;
+  static const int kDontThrow = 1;
+  static const int kInferShouldThrowMode = 2;
+
+  // Soft limit for AdjustAmountofExternalAllocatedMemory. Trigger an
+  // incremental GC once the external memory reaches this limit.
+  static constexpr int kExternalAllocationSoftLimit = 64 * 1024 * 1024;
+
+  V8_EXPORT static void CheckInitializedImpl(v8::Isolate* isolate);
+  V8_INLINE static void CheckInitialized(v8::Isolate* isolate) {
+#ifdef V8_ENABLE_CHECKS
+    CheckInitializedImpl(isolate);
+#endif
+  }
+
+  V8_INLINE static bool HasHeapObjectTag(const internal::Address value) {
+    return (value & kHeapObjectTagMask) == static_cast<Address>(kHeapObjectTag);
+  }
+
+  V8_INLINE static int SmiValue(const internal::Address value) {
+    return PlatformSmiTagging::SmiToInt(value);
+  }
+
+  V8_INLINE static constexpr internal::Address IntToSmi(int value) {
+    return internal::IntToSmi(value);
+  }
+
+  V8_INLINE static constexpr bool IsValidSmi(intptr_t value) {
+    return PlatformSmiTagging::IsValidSmi(value);
+  }
+
+  V8_INLINE static int GetInstanceType(const internal::Address obj) {
+    typedef internal::Address A;
+    A map = ReadTaggedPointerField(obj, kHeapObjectMapOffset);
+    return ReadRawField<uint16_t>(map, kMapInstanceTypeOffset);
+  }
+
+  V8_INLINE static int GetOddballKind(const internal::Address obj) {
+    return SmiValue(ReadTaggedSignedField(obj, kOddballKindOffset));
+  }
+
+  V8_INLINE static bool IsExternalTwoByteString(int instance_type) {
+    int representation = (instance_type & kFullStringRepresentationMask);
+    return representation == kExternalTwoByteRepresentationTag;
+  }
+
+  V8_INLINE static uint8_t GetNodeFlag(internal::Address* obj, int shift) {
+    uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
+    return *addr & static_cast<uint8_t>(1U << shift);
+  }
+
+  V8_INLINE static void UpdateNodeFlag(internal::Address* obj, bool value,
+                                       int shift) {
+    uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
+    uint8_t mask = static_cast<uint8_t>(1U << shift);
+    *addr = static_cast<uint8_t>((*addr & ~mask) | (value << shift));
+  }
+
+  V8_INLINE static uint8_t GetNodeState(internal::Address* obj) {
+    uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
+    return *addr & kNodeStateMask;
+  }
+
+  V8_INLINE static void UpdateNodeState(internal::Address* obj, uint8_t value) {
+    uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;
+    *addr = static_cast<uint8_t>((*addr & ~kNodeStateMask) | value);
+  }
+
+  V8_INLINE static void SetEmbedderData(v8::Isolate* isolate, uint32_t slot,
+                                        void* data) {
+    internal::Address addr = reinterpret_cast<internal::Address>(isolate) +
+                             kIsolateEmbedderDataOffset +
+                             slot * kApiSystemPointerSize;
+    *reinterpret_cast<void**>(addr) = data;
+  }
+
+  V8_INLINE static void* GetEmbedderData(const v8::Isolate* isolate,
+                                         uint32_t slot) {
+    internal::Address addr = reinterpret_cast<internal::Address>(isolate) +
+                             kIsolateEmbedderDataOffset +
+                             slot * kApiSystemPointerSize;
+    return *reinterpret_cast<void* const*>(addr);
+  }
+
+  V8_INLINE static internal::Address* GetRoot(v8::Isolate* isolate, int index) {
+    internal::Address addr = reinterpret_cast<internal::Address>(isolate) +
+                             kIsolateRootsOffset +
+                             index * kApiSystemPointerSize;
+    return reinterpret_cast<internal::Address*>(addr);
+  }
+
+  template <typename T>
+  V8_INLINE static T ReadRawField(internal::Address heap_object_ptr,
+                                  int offset) {
+    internal::Address addr = heap_object_ptr + offset - kHeapObjectTag;
+#ifdef V8_COMPRESS_POINTERS
+    if (sizeof(T) > kApiTaggedSize) {
+      // TODO(ishell, v8:8875): When pointer compression is enabled 8-byte size
+      // fields (external pointers, doubles and BigInt data) are only
+      // kTaggedSize aligned so we have to use unaligned pointer friendly way of
+      // accessing them in order to avoid undefined behavior in C++ code.
+      T r;
+      memcpy(&r, reinterpret_cast<void*>(addr), sizeof(T));
+      return r;
+    }
+#endif
+    return *reinterpret_cast<const T*>(addr);
+  }
+
+  V8_INLINE static internal::Address ReadTaggedPointerField(
+      internal::Address heap_object_ptr, int offset) {
+#ifdef V8_COMPRESS_POINTERS
+    uint32_t value = ReadRawField<uint32_t>(heap_object_ptr, offset);
+    internal::Address root = GetRootFromOnHeapAddress(heap_object_ptr);
+    return root + static_cast<internal::Address>(static_cast<uintptr_t>(value));
+#else
+    return ReadRawField<internal::Address>(heap_object_ptr, offset);
+#endif
+  }
+
+  V8_INLINE static internal::Address ReadTaggedSignedField(
+      internal::Address heap_object_ptr, int offset) {
+#ifdef V8_COMPRESS_POINTERS
+    uint32_t value = ReadRawField<uint32_t>(heap_object_ptr, offset);
+    return static_cast<internal::Address>(static_cast<uintptr_t>(value));
+#else
+    return ReadRawField<internal::Address>(heap_object_ptr, offset);
+#endif
+  }
+
+  V8_INLINE static internal::Isolate* GetIsolateForHeapSandbox(
+      internal::Address obj) {
+#ifdef V8_HEAP_SANDBOX
+    return internal::IsolateFromNeverReadOnlySpaceObject(obj);
+#else
+    // Not used in non-sandbox mode.
+    return nullptr;
+#endif
+  }
+
+  V8_INLINE static internal::Address ReadExternalPointerField(
+      internal::Isolate* isolate, internal::Address heap_object_ptr,
+      int offset) {
+    internal::Address value = ReadRawField<Address>(heap_object_ptr, offset);
+#ifdef V8_HEAP_SANDBOX
+    // We currently have to treat zero as nullptr in embedder slots.
+    if (value) value = DecodeExternalPointer(isolate, value);
+#endif
+    return value;
+  }
+
+#ifdef V8_COMPRESS_POINTERS
+  // See v8:7703 or src/ptr-compr.* for details about pointer compression.
+  static constexpr size_t kPtrComprHeapReservationSize = size_t{1} << 32;
+  static constexpr size_t kPtrComprIsolateRootAlignment = size_t{1} << 32;
+
+  // See v8:10391 for details about V8 heap sandbox.
+  static constexpr uint32_t kExternalPointerSalt =
+      0x7fffffff & ~static_cast<uint32_t>(kHeapObjectTagMask);
+
+  V8_INLINE static internal::Address GetRootFromOnHeapAddress(
+      internal::Address addr) {
+    return addr & -static_cast<intptr_t>(kPtrComprIsolateRootAlignment);
+  }
+
+  V8_INLINE static internal::Address DecompressTaggedAnyField(
+      internal::Address heap_object_ptr, uint32_t value) {
+    internal::Address root = GetRootFromOnHeapAddress(heap_object_ptr);
+    return root + static_cast<internal::Address>(static_cast<uintptr_t>(value));
+  }
+
+  V8_INLINE static Address DecodeExternalPointer(
+      const Isolate* isolate, ExternalPointer_t encoded_pointer) {
+#ifndef V8_HEAP_SANDBOX
+    return encoded_pointer;
+#else
+    return encoded_pointer ^ kExternalPointerSalt;
+#endif
+  }
+#endif  // V8_COMPRESS_POINTERS
+};
+
+// Only perform cast check for types derived from v8::Data since
+// other types do not implement the Cast method.
+template <bool PerformCheck>
+struct CastCheck {
+  template <class T>
+  static void Perform(T* data);
+};
+
+template <>
+template <class T>
+void CastCheck<true>::Perform(T* data) {
+  T::Cast(data);
+}
+
+template <>
+template <class T>
+void CastCheck<false>::Perform(T* data) {}
+
+template <class T>
+V8_INLINE void PerformCastCheck(T* data) {
+  CastCheck<std::is_base_of<Data, T>::value>::Perform(data);
+}
+
+// A base class for backing stores, which is needed due to vagaries of
+// how static casts work with std::shared_ptr.
+class BackingStoreBase {};
+
+}  // namespace internal
+}  // namespace v8
+
+#endif  // INCLUDE_V8_INTERNAL_H_

data/vendor/v8/include/v8-metrics.h

@@ -0,0 +1,133 @@
+// Copyright 2020 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_METRICS_H_
+#define V8_METRICS_H_
+
+#include "v8.h"  // NOLINT(build/include_directory)
+
+namespace v8 {
+namespace metrics {
+
+struct WasmModuleDecoded {
+  bool async = false;
+  bool streamed = false;
+  bool success = false;
+  size_t module_size_in_bytes = 0;
+  size_t function_count = 0;
+  int64_t wall_clock_time_in_us = 0;
+};
+
+struct WasmModuleCompiled {
+  bool async = false;
+  bool streamed = false;
+  bool cached = false;
+  bool deserialized = false;
+  bool lazy = false;
+  bool success = false;
+  size_t code_size_in_bytes = 0;
+  size_t liftoff_bailout_count = 0;
+  int64_t wall_clock_time_in_us = 0;
+};
+
+struct WasmModuleInstantiated {
+  bool async = false;
+  bool success = false;
+  size_t imported_function_count = 0;
+  int64_t wall_clock_time_in_us = 0;
+};
+
+struct WasmModuleTieredUp {
+  bool lazy = false;
+  size_t code_size_in_bytes = 0;
+  int64_t wall_clock_time_in_us = 0;
+};
+
+struct WasmModulesPerIsolate {
+  size_t count = 0;
+};
+
+#define V8_MAIN_THREAD_METRICS_EVENTS(V) \
+  V(WasmModuleDecoded)                   \
+  V(WasmModuleCompiled)                  \
+  V(WasmModuleInstantiated)              \
+  V(WasmModuleTieredUp)
+
+#define V8_THREAD_SAFE_METRICS_EVENTS(V) V(WasmModulesPerIsolate)
+
+/**
+ * This class serves as a base class for recording event-based metrics in V8.
+ * There a two kinds of metrics, those which are expected to be thread-safe and
+ * whose implementation is required to fulfill this requirement and those whose
+ * implementation does not have that requirement and only needs to be
+ * executable on the main thread. If such an event is triggered from a
+ * background thread, it will be delayed and executed by the foreground task
+ * runner.
+ *
+ * The thread-safe events are listed in the V8_THREAD_SAFE_METRICS_EVENTS
+ * macro above while the main thread event are listed in
+ * V8_MAIN_THREAD_METRICS_EVENTS above. For the former, a virtual method
+ * AddMainThreadEvent(const E& event, v8::Context::Token token) will be
+ * generated and for the latter AddThreadSafeEvent(const E& event).
+ *
+ * Thread-safe events are not allowed to access the context and therefore do
+ * not carry a context ID with them. These IDs can be generated using
+ * Recorder::GetContextId() and the ID will be valid throughout the lifetime
+ * of the isolate. It is not guaranteed that the ID will still resolve to
+ * a valid context using Recorder::GetContext() at the time the metric is
+ * recorded. In this case, an empty handle will be returned.
+ *
+ * The embedder is expected to call v8::Isolate::SetMetricsRecorder()
+ * providing its implementation and have the virtual methods overwritten
+ * for the events it cares about.
+ */
+class V8_EXPORT Recorder {
+ public:
+  // A unique identifier for a context in this Isolate.
+  // It is guaranteed to not be reused throughout the lifetime of the Isolate.
+  class ContextId {
+   public:
+    ContextId() : id_(kEmptyId) {}
+
+    bool IsEmpty() const { return id_ == kEmptyId; }
+    static const ContextId Empty() { return ContextId{kEmptyId}; }
+
+    bool operator==(const ContextId& other) const { return id_ == other.id_; }
+    bool operator!=(const ContextId& other) const { return id_ != other.id_; }
+
+   private:
+    friend class ::v8::Context;
+    friend class ::v8::internal::Isolate;
+
+    explicit ContextId(uintptr_t id) : id_(id) {}
+
+    static constexpr uintptr_t kEmptyId = 0;
+    uintptr_t id_;
+  };
+
+  virtual ~Recorder() = default;
+
+#define ADD_MAIN_THREAD_EVENT(E) \
+  virtual void AddMainThreadEvent(const E& event, ContextId context_id) {}
+  V8_MAIN_THREAD_METRICS_EVENTS(ADD_MAIN_THREAD_EVENT)
+#undef ADD_MAIN_THREAD_EVENT
+
+#define ADD_THREAD_SAFE_EVENT(E) \
+  virtual void AddThreadSafeEvent(const E& event) {}
+  V8_THREAD_SAFE_METRICS_EVENTS(ADD_THREAD_SAFE_EVENT)
+#undef ADD_THREAD_SAFE_EVENT
+
+  virtual void NotifyIsolateDisposal() {}
+
+  // Return the context with the given id or an empty handle if the context
+  // was already garbage collected.
+  static MaybeLocal<Context> GetContext(Isolate* isolate, ContextId id);
+  // Return the unique id corresponding to the given context.
+  static ContextId GetContextId(Local<Context> context);
+};
+
+}  // namespace metrics
+}  // namespace v8
+
+#endif  // V8_METRICS_H_