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

data/vendor/v8/include/libplatform/v8-tracing.h

@@ -0,0 +1,332 @@
+// Copyright 2016 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_LIBPLATFORM_V8_TRACING_H_
+#define V8_LIBPLATFORM_V8_TRACING_H_
+
+#include <atomic>
+#include <fstream>
+#include <memory>
+#include <unordered_set>
+#include <vector>
+
+#include "libplatform/libplatform-export.h"
+#include "v8-platform.h"  // NOLINT(build/include_directory)
+
+namespace perfetto {
+namespace trace_processor {
+class TraceProcessorStorage;
+}
+class TracingSession;
+}
+
+namespace v8 {
+
+namespace base {
+class Mutex;
+}  // namespace base
+
+namespace platform {
+namespace tracing {
+
+class TraceEventListener;
+
+const int kTraceMaxNumArgs = 2;
+
+class V8_PLATFORM_EXPORT TraceObject {
+ public:
+  union ArgValue {
+    V8_DEPRECATED("use as_uint ? true : false") bool as_bool;
+    uint64_t as_uint;
+    int64_t as_int;
+    double as_double;
+    const void* as_pointer;
+    const char* as_string;
+  };
+
+  TraceObject() = default;
+  ~TraceObject();
+  void Initialize(
+      char phase, const uint8_t* category_enabled_flag, const char* name,
+      const char* scope, uint64_t id, uint64_t bind_id, int num_args,
+      const char** arg_names, const uint8_t* arg_types,
+      const uint64_t* arg_values,
+      std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables,
+      unsigned int flags, int64_t timestamp, int64_t cpu_timestamp);
+  void UpdateDuration(int64_t timestamp, int64_t cpu_timestamp);
+  void InitializeForTesting(
+      char phase, const uint8_t* category_enabled_flag, const char* name,
+      const char* scope, uint64_t id, uint64_t bind_id, int num_args,
+      const char** arg_names, const uint8_t* arg_types,
+      const uint64_t* arg_values,
+      std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables,
+      unsigned int flags, int pid, int tid, int64_t ts, int64_t tts,
+      uint64_t duration, uint64_t cpu_duration);
+
+  int pid() const { return pid_; }
+  int tid() const { return tid_; }
+  char phase() const { return phase_; }
+  const uint8_t* category_enabled_flag() const {
+    return category_enabled_flag_;
+  }
+  const char* name() const { return name_; }
+  const char* scope() const { return scope_; }
+  uint64_t id() const { return id_; }
+  uint64_t bind_id() const { return bind_id_; }
+  int num_args() const { return num_args_; }
+  const char** arg_names() { return arg_names_; }
+  uint8_t* arg_types() { return arg_types_; }
+  ArgValue* arg_values() { return arg_values_; }
+  std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables() {
+    return arg_convertables_;
+  }
+  unsigned int flags() const { return flags_; }
+  int64_t ts() { return ts_; }
+  int64_t tts() { return tts_; }
+  uint64_t duration() { return duration_; }
+  uint64_t cpu_duration() { return cpu_duration_; }
+
+ private:
+  int pid_;
+  int tid_;
+  char phase_;
+  const char* name_;
+  const char* scope_;
+  const uint8_t* category_enabled_flag_;
+  uint64_t id_;
+  uint64_t bind_id_;
+  int num_args_ = 0;
+  const char* arg_names_[kTraceMaxNumArgs];
+  uint8_t arg_types_[kTraceMaxNumArgs];
+  ArgValue arg_values_[kTraceMaxNumArgs];
+  std::unique_ptr<v8::ConvertableToTraceFormat>
+      arg_convertables_[kTraceMaxNumArgs];
+  char* parameter_copy_storage_ = nullptr;
+  unsigned int flags_;
+  int64_t ts_;
+  int64_t tts_;
+  uint64_t duration_;
+  uint64_t cpu_duration_;
+
+  // Disallow copy and assign
+  TraceObject(const TraceObject&) = delete;
+  void operator=(const TraceObject&) = delete;
+};
+
+class V8_PLATFORM_EXPORT TraceWriter {
+ public:
+  TraceWriter() = default;
+  virtual ~TraceWriter() = default;
+  virtual void AppendTraceEvent(TraceObject* trace_event) = 0;
+  virtual void Flush() = 0;
+
+  static TraceWriter* CreateJSONTraceWriter(std::ostream& stream);
+  static TraceWriter* CreateJSONTraceWriter(std::ostream& stream,
+                                            const std::string& tag);
+
+ private:
+  // Disallow copy and assign
+  TraceWriter(const TraceWriter&) = delete;
+  void operator=(const TraceWriter&) = delete;
+};
+
+class V8_PLATFORM_EXPORT TraceBufferChunk {
+ public:
+  explicit TraceBufferChunk(uint32_t seq);
+
+  void Reset(uint32_t new_seq);
+  bool IsFull() const { return next_free_ == kChunkSize; }
+  TraceObject* AddTraceEvent(size_t* event_index);
+  TraceObject* GetEventAt(size_t index) { return &chunk_[index]; }
+
+  uint32_t seq() const { return seq_; }
+  size_t size() const { return next_free_; }
+
+  static const size_t kChunkSize = 64;
+
+ private:
+  size_t next_free_ = 0;
+  TraceObject chunk_[kChunkSize];
+  uint32_t seq_;
+
+  // Disallow copy and assign
+  TraceBufferChunk(const TraceBufferChunk&) = delete;
+  void operator=(const TraceBufferChunk&) = delete;
+};
+
+class V8_PLATFORM_EXPORT TraceBuffer {
+ public:
+  TraceBuffer() = default;
+  virtual ~TraceBuffer() = default;
+
+  virtual TraceObject* AddTraceEvent(uint64_t* handle) = 0;
+  virtual TraceObject* GetEventByHandle(uint64_t handle) = 0;
+  virtual bool Flush() = 0;
+
+  static const size_t kRingBufferChunks = 1024;
+
+  static TraceBuffer* CreateTraceBufferRingBuffer(size_t max_chunks,
+                                                  TraceWriter* trace_writer);
+
+ private:
+  // Disallow copy and assign
+  TraceBuffer(const TraceBuffer&) = delete;
+  void operator=(const TraceBuffer&) = delete;
+};
+
+// Options determines how the trace buffer stores data.
+enum TraceRecordMode {
+  // Record until the trace buffer is full.
+  RECORD_UNTIL_FULL,
+
+  // Record until the user ends the trace. The trace buffer is a fixed size
+  // and we use it as a ring buffer during recording.
+  RECORD_CONTINUOUSLY,
+
+  // Record until the trace buffer is full, but with a huge buffer size.
+  RECORD_AS_MUCH_AS_POSSIBLE,
+
+  // Echo to console. Events are discarded.
+  ECHO_TO_CONSOLE,
+};
+
+class V8_PLATFORM_EXPORT TraceConfig {
+ public:
+  typedef std::vector<std::string> StringList;
+
+  static TraceConfig* CreateDefaultTraceConfig();
+
+  TraceConfig() : enable_systrace_(false), enable_argument_filter_(false) {}
+  TraceRecordMode GetTraceRecordMode() const { return record_mode_; }
+  const StringList& GetEnabledCategories() const {
+    return included_categories_;
+  }
+  bool IsSystraceEnabled() const { return enable_systrace_; }
+  bool IsArgumentFilterEnabled() const { return enable_argument_filter_; }
+
+  void SetTraceRecordMode(TraceRecordMode mode) { record_mode_ = mode; }
+  void EnableSystrace() { enable_systrace_ = true; }
+  void EnableArgumentFilter() { enable_argument_filter_ = true; }
+
+  void AddIncludedCategory(const char* included_category);
+
+  bool IsCategoryGroupEnabled(const char* category_group) const;
+
+ private:
+  TraceRecordMode record_mode_;
+  bool enable_systrace_ : 1;
+  bool enable_argument_filter_ : 1;
+  StringList included_categories_;
+
+  // Disallow copy and assign
+  TraceConfig(const TraceConfig&) = delete;
+  void operator=(const TraceConfig&) = delete;
+};
+
+#if defined(_MSC_VER)
+#define V8_PLATFORM_NON_EXPORTED_BASE(code) \
+  __pragma(warning(suppress : 4275)) code
+#else
+#define V8_PLATFORM_NON_EXPORTED_BASE(code) code
+#endif  // defined(_MSC_VER)
+
+class V8_PLATFORM_EXPORT TracingController
+    : public V8_PLATFORM_NON_EXPORTED_BASE(v8::TracingController) {
+ public:
+  TracingController();
+  ~TracingController() override;
+
+#if defined(V8_USE_PERFETTO)
+  // Must be called before StartTracing() if V8_USE_PERFETTO is true. Provides
+  // the output stream for the JSON trace data.
+  void InitializeForPerfetto(std::ostream* output_stream);
+  // Provide an optional listener for testing that will receive trace events.
+  // Must be called before StartTracing().
+  void SetTraceEventListenerForTesting(TraceEventListener* listener);
+#else   // defined(V8_USE_PERFETTO)
+  // The pointer returned from GetCategoryGroupEnabled() points to a value with
+  // zero or more of the following bits. Used in this class only. The
+  // TRACE_EVENT macros should only use the value as a bool. These values must
+  // be in sync with macro values in TraceEvent.h in Blink.
+  enum CategoryGroupEnabledFlags {
+    // Category group enabled for the recording mode.
+    ENABLED_FOR_RECORDING = 1 << 0,
+    // Category group enabled by SetEventCallbackEnabled().
+    ENABLED_FOR_EVENT_CALLBACK = 1 << 2,
+    // Category group enabled to export events to ETW.
+    ENABLED_FOR_ETW_EXPORT = 1 << 3
+  };
+
+  // Takes ownership of |trace_buffer|.
+  void Initialize(TraceBuffer* trace_buffer);
+
+  // v8::TracingController implementation.
+  const uint8_t* GetCategoryGroupEnabled(const char* category_group) override;
+  uint64_t AddTraceEvent(
+      char phase, const uint8_t* category_enabled_flag, const char* name,
+      const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
+      const char** arg_names, const uint8_t* arg_types,
+      const uint64_t* arg_values,
+      std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables,
+      unsigned int flags) override;
+  uint64_t AddTraceEventWithTimestamp(
+      char phase, const uint8_t* category_enabled_flag, const char* name,
+      const char* scope, uint64_t id, uint64_t bind_id, int32_t num_args,
+      const char** arg_names, const uint8_t* arg_types,
+      const uint64_t* arg_values,
+      std::unique_ptr<v8::ConvertableToTraceFormat>* arg_convertables,
+      unsigned int flags, int64_t timestamp) override;
+  void UpdateTraceEventDuration(const uint8_t* category_enabled_flag,
+                                const char* name, uint64_t handle) override;
+
+  static const char* GetCategoryGroupName(const uint8_t* category_enabled_flag);
+#endif  // !defined(V8_USE_PERFETTO)
+
+  void AddTraceStateObserver(
+      v8::TracingController::TraceStateObserver* observer) override;
+  void RemoveTraceStateObserver(
+      v8::TracingController::TraceStateObserver* observer) override;
+
+  void StartTracing(TraceConfig* trace_config);
+  void StopTracing();
+
+ protected:
+#if !defined(V8_USE_PERFETTO)
+  virtual int64_t CurrentTimestampMicroseconds();
+  virtual int64_t CurrentCpuTimestampMicroseconds();
+#endif  // !defined(V8_USE_PERFETTO)
+
+ private:
+#if !defined(V8_USE_PERFETTO)
+  void UpdateCategoryGroupEnabledFlag(size_t category_index);
+  void UpdateCategoryGroupEnabledFlags();
+#endif  // !defined(V8_USE_PERFETTO)
+
+  std::unique_ptr<base::Mutex> mutex_;
+  std::unique_ptr<TraceConfig> trace_config_;
+  std::atomic_bool recording_{false};
+  std::unordered_set<v8::TracingController::TraceStateObserver*> observers_;
+
+#if defined(V8_USE_PERFETTO)
+  std::ostream* output_stream_ = nullptr;
+  std::unique_ptr<perfetto::trace_processor::TraceProcessorStorage>
+      trace_processor_;
+  TraceEventListener* listener_for_testing_ = nullptr;
+  std::unique_ptr<perfetto::TracingSession> tracing_session_;
+#else   // !defined(V8_USE_PERFETTO)
+  std::unique_ptr<TraceBuffer> trace_buffer_;
+#endif  // !defined(V8_USE_PERFETTO)
+
+  // Disallow copy and assign
+  TracingController(const TracingController&) = delete;
+  void operator=(const TracingController&) = delete;
+};
+
+#undef V8_PLATFORM_NON_EXPORTED_BASE
+
+}  // namespace tracing
+}  // namespace platform
+}  // namespace v8
+
+#endif  // V8_LIBPLATFORM_V8_TRACING_H_

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

@@ -0,0 +1,226 @@
+// 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 INCLUDE_V8_CPPGC_H_
+#define INCLUDE_V8_CPPGC_H_
+
+#include "cppgc/visitor.h"
+#include "v8-internal.h"  // NOLINT(build/include_directory)
+#include "v8.h"  // NOLINT(build/include_directory)
+
+namespace v8 {
+
+class Isolate;
+template <typename T>
+class JSMember;
+
+namespace internal {
+
+class JSMemberBaseExtractor;
+
+class V8_EXPORT JSMemberBase {
+ public:
+  /**
+   * Returns true if the reference is empty, i.e., has not been assigned
+   * object.
+   */
+  bool IsEmpty() const { return val_ == nullptr; }
+
+  /**
+   * Clears the reference. IsEmpty() will return true after this call.
+   */
+  inline void Reset();
+
+ private:
+  static internal::Address* New(v8::Isolate* isolate,
+                                internal::Address* object_slot,
+                                internal::Address** this_slot);
+  static void Delete(internal::Address* object);
+  static void Copy(const internal::Address* const* from_slot,
+                   internal::Address** to_slot);
+  static void Move(internal::Address** from_slot, internal::Address** to_slot);
+
+  JSMemberBase() = default;
+
+  JSMemberBase(v8::Isolate* isolate, internal::Address* object_slot)
+      : val_(New(isolate, object_slot, &val_)) {}
+
+  inline JSMemberBase& CopyImpl(const JSMemberBase& other);
+  inline JSMemberBase& MoveImpl(JSMemberBase&& other);
+
+  // val_ points to a GlobalHandles node.
+  internal::Address* val_ = nullptr;
+
+  template <typename T>
+  friend class v8::JSMember;
+  friend class v8::internal::JSMemberBaseExtractor;
+};
+
+JSMemberBase& JSMemberBase::CopyImpl(const JSMemberBase& other) {
+  if (this != &other) {
+    Reset();
+    if (!other.IsEmpty()) {
+      Copy(&other.val_, &val_);
+    }
+  }
+  return *this;
+}
+
+JSMemberBase& JSMemberBase::MoveImpl(JSMemberBase&& other) {
+  if (this != &other) {
+    // No call to Reset() as Move() will conditionally reset itself when needed,
+    // and otherwise reuse the internal meta data.
+    Move(&other.val_, &val_);
+  }
+  return *this;
+}
+
+void JSMemberBase::Reset() {
+  if (IsEmpty()) return;
+  Delete(val_);
+  val_ = nullptr;
+}
+
+}  // namespace internal
+
+/**
+ * A traced handle without destructor that clears the handle. The handle may
+ * only be used in GarbageCollected objects and must be processed in a Trace()
+ * method.
+ */
+template <typename T>
+class V8_EXPORT JSMember : public internal::JSMemberBase {
+  static_assert(std::is_base_of<v8::Value, T>::value,
+                "JSMember only supports references to v8::Value");
+
+ public:
+  JSMember() = default;
+
+  template <typename U,
+            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+  JSMember(Isolate* isolate, Local<U> that)
+      : internal::JSMemberBase(isolate,
+                               reinterpret_cast<internal::Address*>(*that)) {}
+
+  JSMember(const JSMember& other) { CopyImpl(other); }
+
+  template <typename U,
+            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+  JSMember(const JSMember<U>& other) {  // NOLINT
+    CopyImpl(other);
+  }
+
+  JSMember(JSMember&& other) { MoveImpl(std::move(other)); }
+
+  template <typename U,
+            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+  JSMember(JSMember<U>&& other) {  // NOLINT
+    MoveImpl(std::move(other));
+  }
+
+  JSMember& operator=(const JSMember& other) { return CopyImpl(other); }
+
+  template <typename U,
+            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+  JSMember& operator=(const JSMember<U>& other) {
+    return CopyImpl(other);
+  }
+
+  JSMember& operator=(JSMember&& other) { return MoveImpl(other); }
+
+  template <typename U,
+            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+  JSMember& operator=(JSMember<U>&& other) {
+    return MoveImpl(other);
+  }
+
+  T* operator->() const { return reinterpret_cast<T*>(val_); }
+  T* operator*() const { return reinterpret_cast<T*>(val_); }
+
+  using internal::JSMemberBase::Reset;
+
+  template <typename U,
+            typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+  void Set(v8::Isolate* isolate, Local<U> that) {
+    Reset();
+    val_ = New(isolate, reinterpret_cast<internal::Address*>(*that), &val_);
+  }
+};
+
+template <typename T1, typename T2,
+          typename = std::enable_if_t<std::is_base_of<T2, T1>::value ||
+                                      std::is_base_of<T1, T2>::value>>
+inline bool operator==(const JSMember<T1>& lhs, const JSMember<T2>& rhs) {
+  v8::internal::Address* a = reinterpret_cast<v8::internal::Address*>(*lhs);
+  v8::internal::Address* b = reinterpret_cast<v8::internal::Address*>(*rhs);
+  if (a == nullptr) return b == nullptr;
+  if (b == nullptr) return false;
+  return *a == *b;
+}
+
+template <typename T1, typename T2,
+          typename = std::enable_if_t<std::is_base_of<T2, T1>::value ||
+                                      std::is_base_of<T1, T2>::value>>
+inline bool operator!=(const JSMember<T1>& lhs, const JSMember<T2>& rhs) {
+  return !(lhs == rhs);
+}
+
+template <typename T1, typename T2,
+          typename = std::enable_if_t<std::is_base_of<T2, T1>::value ||
+                                      std::is_base_of<T1, T2>::value>>
+inline bool operator==(const JSMember<T1>& lhs, const Local<T2>& rhs) {
+  v8::internal::Address* a = reinterpret_cast<v8::internal::Address*>(*lhs);
+  v8::internal::Address* b = reinterpret_cast<v8::internal::Address*>(*rhs);
+  if (a == nullptr) return b == nullptr;
+  if (b == nullptr) return false;
+  return *a == *b;
+}
+
+template <typename T1, typename T2,
+          typename = std::enable_if_t<std::is_base_of<T2, T1>::value ||
+                                      std::is_base_of<T1, T2>::value>>
+inline bool operator==(const Local<T1>& lhs, const JSMember<T2> rhs) {
+  return rhs == lhs;
+}
+
+template <typename T1, typename T2>
+inline bool operator!=(const JSMember<T1>& lhs, const T2& rhs) {
+  return !(lhs == rhs);
+}
+
+template <typename T1, typename T2>
+inline bool operator!=(const T1& lhs, const JSMember<T2>& rhs) {
+  return !(lhs == rhs);
+}
+
+class JSVisitor : public cppgc::Visitor {
+ public:
+  explicit JSVisitor(cppgc::Visitor::Key key) : cppgc::Visitor(key) {}
+
+  template <typename T>
+  void Trace(const JSMember<T>& ref) {
+    if (ref.IsEmpty()) return;
+    Visit(ref);
+  }
+
+ protected:
+  using cppgc::Visitor::Visit;
+
+  virtual void Visit(const internal::JSMemberBase& ref) {}
+};
+
+}  // namespace v8
+
+namespace cppgc {
+
+template <typename T>
+struct TraceTrait<v8::JSMember<T>> {
+  static void Trace(Visitor* visitor, const v8::JSMember<T>* self) {
+    static_cast<v8::JSVisitor*>(visitor)->Trace(*self);
+  }
+};
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_V8_CPPGC_H_