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

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 459b4d84a8411c96abb43c762e1d82851476f1a2e21ca3ae88b3dd34065e9891
+  data.tar.gz: 7bc0449465bbb30b47e3d6d3be4b668af0fc33b5f5e244135062726a77297960
+SHA512:
+  metadata.gz: f42012c36645bd6f937b5fca6de7ea2ce861236296cd862c8994899943a036046c692b36a5831d49f8ce064513227c35c32d13d4899500fc817bfc5704ab8ea2
+  data.tar.gz: 11b5e12913e0b7c99016d8b02ded1cb80a90edf350756b98095e7e420335b8096d2efd0e5b414aa7adc5fc7c866e5d726921c310c385c5303954ae57b7519de5

data/ext/libv8-node/.location.yml

@@ -0,0 +1,2 @@
+--- !ruby/object:Libv8::Node::Location::Vendor {}
+

data/ext/libv8-node/location.rb

@@ -0,0 +1,91 @@
+require 'yaml'
+require 'pathname'
+require File.expand_path '../paths', __FILE__
+
+module Libv8; end
+
+module Libv8::Node
+  class Location
+    def install!
+      File.open(Pathname(__FILE__).dirname.join('.location.yml'), "w") do |f|
+        f.write self.to_yaml
+      end
+      return 0
+    end
+
+    def self.load!
+      File.open(Pathname(__FILE__).dirname.join('.location.yml')) do |f|
+        YAML.load f
+      end
+    end
+
+    class Vendor < Location
+      def install!
+        require File.expand_path '../builder', __FILE__
+        builder = Libv8::Node::Builder.new
+        exit_status = builder.build_libv8!
+        super if exit_status == 0
+        verify_installation!
+        return exit_status
+      end
+
+      def configure(context = MkmfContext.new)
+        context.incflags.insert 0, Libv8::Node::Paths.include_paths.map{ |p| "-I#{p}" }.join(" ")  + " "
+        context.ldflags.insert 0, Libv8::Node::Paths.object_paths.join(" ") + " "
+      end
+
+      def verify_installation!
+        include_paths = Libv8::Node::Paths.include_paths
+        unless include_paths.detect { |p| Pathname(p).join('v8.h').exist? }
+          fail HeaderNotFound, "Unable to locate 'v8.h' in the libv8 header paths: #{include_paths.inspect}"
+        end
+        Libv8::Node::Paths.object_paths.each do |p|
+          fail ArchiveNotFound, p unless File.exist? p
+        end
+      end
+
+      class HeaderNotFound < StandardError; end
+
+      class ArchiveNotFound < StandardError
+        def initialize(filename)
+          super "libv8 did not install properly, expected binary v8 archive '#{filename}'to exist, but it was not found"
+        end
+      end
+    end
+
+    class System < Location
+      def configure(context = MkmfContext.new)
+        context.send(:dir_config, 'v8')
+        context.send(:find_header, 'v8.h') or fail NotFoundError
+        context.send(:find_header, 'libplatform/libplatform.h') or fail NotFoundError
+        context.send(:have_library, 'v8') or fail NotFoundError
+      end
+
+      class NotFoundError < StandardError
+        def initialize(*args)
+          super(<<-EOS)
+By using --with-system-v8, you have chosen to use the version
+of V8 found on your system and *not* the one that is bundled with
+the libv8 rubygem.
+
+However, your system version of v8 could not be located.
+
+Please make sure your system version of v8 that is compatible
+with #{Libv8::Node::VERSION} installed. You may need to use the
+--with-v8-dir option if it is installed in a non-standard location
+EOS
+        end
+      end
+    end
+
+    class MkmfContext
+      def incflags
+        $INCFLAGS
+      end
+
+      def ldflags
+        $LDFLAGS
+      end
+    end
+  end
+end

data/ext/libv8-node/paths.rb

@@ -0,0 +1,30 @@
+require 'rbconfig'
+require 'shellwords'
+
+module Libv8; end
+
+module Libv8::Node
+  module Paths
+    module_function
+
+    def include_paths
+      [Shellwords.escape(File.join(vendored_source_path, 'include'))]
+    end
+
+    def object_paths
+      [Shellwords.escape(File.join(vendored_source_path,
+                                   'out.gn',
+                                   'libv8',
+                                   'obj',
+                                   "libv8_monolith.#{config['LIBEXT']}"))]
+    end
+
+    def config
+      RbConfig::MAKEFILE_CONFIG
+    end
+
+    def vendored_source_path
+      File.expand_path "../../../vendor/v8", __FILE__
+    end
+  end
+end

data/lib/libv8/node/version.rb

@@ -0,0 +1,7 @@
+module Libv8; end
+
+module Libv8::Node
+  VERSION = "15.5.1.0.beta1"
+  NODE_VERSION = "15.5.1"
+  LIBV8_VERSION = "8.6.395.17" # v8/include/v8-version.h
+end

data/lib/libv8/node.rb

@@ -0,0 +1,11 @@
+require 'libv8/node/version'
+require 'libv8-node/location'
+
+module Libv8; end
+
+module Libv8::Node
+  def self.configure_makefile
+    location = Location.load!
+    location.configure
+  end
+end

data/lib/libv8-node.rb

@@ -0,0 +1 @@
+require 'libv8/node'

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

@@ -0,0 +1,173 @@
+// 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_CPPGC_ALLOCATION_H_
+#define INCLUDE_CPPGC_ALLOCATION_H_
+
+#include <stdint.h>
+
+#include <atomic>
+
+#include "cppgc/custom-space.h"
+#include "cppgc/garbage-collected.h"
+#include "cppgc/internal/api-constants.h"
+#include "cppgc/internal/gc-info.h"
+
+namespace cppgc {
+
+template <typename T>
+class MakeGarbageCollectedTraitBase;
+
+namespace internal {
+class ObjectAllocator;
+}  // namespace internal
+
+/**
+ * AllocationHandle is used to allocate garbage-collected objects.
+ */
+class AllocationHandle;
+
+namespace internal {
+
+class V8_EXPORT MakeGarbageCollectedTraitInternal {
+ protected:
+  static inline void MarkObjectAsFullyConstructed(const void* payload) {
+    // See api_constants for an explanation of the constants.
+    std::atomic<uint16_t>* atomic_mutable_bitfield =
+        reinterpret_cast<std::atomic<uint16_t>*>(
+            const_cast<uint16_t*>(reinterpret_cast<const uint16_t*>(
+                reinterpret_cast<const uint8_t*>(payload) -
+                api_constants::kFullyConstructedBitFieldOffsetFromPayload)));
+    uint16_t value = atomic_mutable_bitfield->load(std::memory_order_relaxed);
+    value = value | api_constants::kFullyConstructedBitMask;
+    atomic_mutable_bitfield->store(value, std::memory_order_release);
+  }
+
+  static void* Allocate(cppgc::AllocationHandle& handle, size_t size,
+                        GCInfoIndex index);
+  static void* Allocate(cppgc::AllocationHandle& handle, size_t size,
+                        GCInfoIndex index, CustomSpaceIndex space_index);
+
+  friend class HeapObjectHeader;
+};
+
+}  // namespace internal
+
+/**
+ * Base trait that provides utilities for advancers users that have custom
+ * allocation needs (e.g., overriding size). It's expected that users override
+ * MakeGarbageCollectedTrait (see below) and inherit from
+ * MakeGarbageCollectedTraitBase and make use of the low-level primitives
+ * offered to allocate and construct an object.
+ */
+template <typename T>
+class MakeGarbageCollectedTraitBase
+    : private internal::MakeGarbageCollectedTraitInternal {
+ private:
+  template <typename U, typename CustomSpace>
+  struct SpacePolicy {
+    static void* Allocate(AllocationHandle& handle, size_t size) {
+      // Custom space.
+      static_assert(std::is_base_of<CustomSpaceBase, CustomSpace>::value,
+                    "Custom space must inherit from CustomSpaceBase.");
+      return internal::MakeGarbageCollectedTraitInternal::Allocate(
+          handle, size, internal::GCInfoTrait<T>::Index(),
+          CustomSpace::kSpaceIndex);
+    }
+  };
+
+  template <typename U>
+  struct SpacePolicy<U, void> {
+    static void* Allocate(AllocationHandle& handle, size_t size) {
+      // Default space.
+      return internal::MakeGarbageCollectedTraitInternal::Allocate(
+          handle, size, internal::GCInfoTrait<T>::Index());
+    }
+  };
+
+ protected:
+  /**
+   * Allocates memory for an object of type T.
+   *
+   * \param handle AllocationHandle identifying the heap to allocate the object
+   *   on.
+   * \param size The size that should be reserved for the object.
+   * \returns the memory to construct an object of type T on.
+   */
+  static void* Allocate(AllocationHandle& handle, size_t size) {
+    return SpacePolicy<T, typename SpaceTrait<T>::Space>::Allocate(handle,
+                                                                   size);
+  }
+
+  /**
+   * Marks an object as fully constructed, resulting in precise handling by the
+   * garbage collector.
+   *
+   * \param payload The base pointer the object is allocated at.
+   */
+  static void MarkObjectAsFullyConstructed(const void* payload) {
+    internal::MakeGarbageCollectedTraitInternal::MarkObjectAsFullyConstructed(
+        payload);
+  }
+};
+
+/**
+ * Default trait class that specifies how to construct an object of type T.
+ * Advanced users may override how an object is constructed using the utilities
+ * that are provided through MakeGarbageCollectedTraitBase.
+ *
+ * Any trait overriding construction must
+ * - allocate through MakeGarbageCollectedTraitBase<T>::Allocate;
+ * - mark the object as fully constructed using
+ *   MakeGarbageCollectedTraitBase<T>::MarkObjectAsFullyConstructed;
+ */
+template <typename T>
+class MakeGarbageCollectedTrait : public MakeGarbageCollectedTraitBase<T> {
+ public:
+  template <typename... Args>
+  static T* Call(AllocationHandle& handle, Args&&... args) {
+    static_assert(internal::IsGarbageCollectedType<T>::value,
+                  "T needs to be a garbage collected object");
+    static_assert(
+        !internal::IsGarbageCollectedMixinType<T>::value ||
+            sizeof(T) <= internal::api_constants::kLargeObjectSizeThreshold,
+        "GarbageCollectedMixin may not be a large object");
+    void* memory =
+        MakeGarbageCollectedTraitBase<T>::Allocate(handle, sizeof(T));
+    T* object = ::new (memory) T(std::forward<Args>(args)...);
+    MakeGarbageCollectedTraitBase<T>::MarkObjectAsFullyConstructed(object);
+    return object;
+  }
+};
+
+/**
+ * Allows users to specify a post-construction callback for specific types. The
+ * callback is invoked on the instance of type T right after it has been
+ * constructed. This can be useful when the callback requires a
+ * fully-constructed object to be able to dispatch to virtual methods.
+ */
+template <typename T, typename = void>
+struct PostConstructionCallbackTrait {
+  static void Call(T*) {}
+};
+
+/**
+ * Constructs a managed object of type T where T transitively inherits from
+ * GarbageCollected.
+ *
+ * \param args List of arguments with which an instance of T will be
+ *   constructed.
+ * \returns an instance of type T.
+ */
+template <typename T, typename... Args>
+T* MakeGarbageCollected(AllocationHandle& handle, Args&&... args) {
+  T* object =
+      MakeGarbageCollectedTrait<T>::Call(handle, std::forward<Args>(args)...);
+  PostConstructionCallbackTrait<T>::Call(object);
+  return object;
+}
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_ALLOCATION_H_

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

@@ -0,0 +1,26 @@
+// 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_CPPGC_COMMON_H_
+#define INCLUDE_CPPGC_COMMON_H_
+
+// TODO(chromium:1056170): Remove dependency on v8.
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+
+// Indicator for the stack state of the embedder.
+enum class EmbedderStackState {
+  kMayContainHeapPointers,
+  kNoHeapPointers,
+  kUnknown V8_ENUM_DEPRECATE_SOON("Use kMayContainHeapPointers") =
+      kMayContainHeapPointers,
+  kNonEmpty V8_ENUM_DEPRECATE_SOON("Use kMayContainHeapPointers") =
+      kMayContainHeapPointers,
+  kEmpty V8_ENUM_DEPRECATE_SOON("Use kNoHeapPointers") = kNoHeapPointers,
+};
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_COMMON_H_

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

@@ -0,0 +1,62 @@
+// 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_CPPGC_CUSTOM_SPACE_H_
+#define INCLUDE_CPPGC_CUSTOM_SPACE_H_
+
+#include <stddef.h>
+
+namespace cppgc {
+
+struct CustomSpaceIndex {
+  CustomSpaceIndex(size_t value) : value(value) {}  // NOLINT
+  size_t value;
+};
+
+/**
+ * Top-level base class for custom spaces. Users must inherit from CustomSpace
+ * below.
+ */
+class CustomSpaceBase {
+ public:
+  virtual ~CustomSpaceBase() = default;
+  virtual CustomSpaceIndex GetCustomSpaceIndex() const = 0;
+};
+
+/**
+ * Base class custom spaces should directly inherit from. The class inheriting
+ * from CustomSpace must define kSpaceIndex as unique space index. These
+ * indices need for form a sequence starting at 0.
+ *
+ * Example:
+ * \code
+ * class CustomSpace1 : public CustomSpace<CustomSpace1> {
+ *  public:
+ *   static constexpr CustomSpaceIndex kSpaceIndex = 0;
+ * };
+ * class CustomSpace2 : public CustomSpace<CustomSpace2> {
+ *  public:
+ *   static constexpr CustomSpaceIndex kSpaceIndex = 1;
+ * };
+ * \endcode
+ */
+template <typename ConcreteCustomSpace>
+class CustomSpace : public CustomSpaceBase {
+ public:
+  CustomSpaceIndex GetCustomSpaceIndex() const final {
+    return ConcreteCustomSpace::kSpaceIndex;
+  }
+};
+
+/**
+ * User-overridable trait that allows pinning types to custom spaces.
+ */
+template <typename T, typename = void>
+struct SpaceTrait {
+  using Space = void;
+};
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_CUSTOM_SPACE_H_

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

@@ -0,0 +1,76 @@
+// 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_CPPGC_DEFAULT_PLATFORM_H_
+#define INCLUDE_CPPGC_DEFAULT_PLATFORM_H_
+
+#include <memory>
+#include <thread>  // NOLINT(build/c++11)
+#include <vector>
+
+#include "cppgc/platform.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+
+/**
+ * Default task runner implementation. Keep posted tasks in a list that can be
+ * processed by calling RunSingleTask() or RunUntilIdle().
+ */
+class V8_EXPORT DefaultTaskRunner final : public cppgc::TaskRunner {
+ public:
+  DefaultTaskRunner() = default;
+
+  DefaultTaskRunner(const DefaultTaskRunner&) = delete;
+  DefaultTaskRunner& operator=(const DefaultTaskRunner&) = delete;
+
+  void PostTask(std::unique_ptr<cppgc::Task> task) override;
+  void PostNonNestableTask(std::unique_ptr<cppgc::Task> task) override;
+  void PostDelayedTask(std::unique_ptr<cppgc::Task> task, double) override;
+  void PostNonNestableDelayedTask(std::unique_ptr<cppgc::Task> task,
+                                  double) override;
+
+  void PostIdleTask(std::unique_ptr<cppgc::IdleTask> task) override;
+  bool IdleTasksEnabled() override { return true; }
+
+  bool RunSingleTask();
+  bool RunSingleIdleTask(double duration_in_seconds);
+
+  void RunUntilIdle();
+
+ private:
+  std::vector<std::unique_ptr<cppgc::Task>> tasks_;
+  std::vector<std::unique_ptr<cppgc::IdleTask>> idle_tasks_;
+};
+
+/**
+ * Default platform implementation that uses std::thread for spawning job tasks.
+ */
+class V8_EXPORT DefaultPlatform final : public Platform {
+ public:
+  DefaultPlatform();
+  ~DefaultPlatform() noexcept override;
+
+  cppgc::PageAllocator* GetPageAllocator() final;
+
+  double MonotonicallyIncreasingTime() final;
+
+  std::shared_ptr<cppgc::TaskRunner> GetForegroundTaskRunner() final;
+
+  std::unique_ptr<cppgc::JobHandle> PostJob(
+      cppgc::TaskPriority priority,
+      std::unique_ptr<cppgc::JobTask> job_task) final;
+
+  void WaitAllForegroundTasks();
+  void WaitAllBackgroundTasks();
+
+ private:
+  std::unique_ptr<PageAllocator> page_allocator_;
+  std::shared_ptr<DefaultTaskRunner> foreground_task_runner_;
+  std::vector<std::shared_ptr<std::thread>> job_threads_;
+};
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_DEFAULT_PLATFORM_H_

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

@@ -0,0 +1,116 @@
+// 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_CPPGC_GARBAGE_COLLECTED_H_
+#define INCLUDE_CPPGC_GARBAGE_COLLECTED_H_
+
+#include <type_traits>
+
+#include "cppgc/internal/api-constants.h"
+#include "cppgc/platform.h"
+#include "cppgc/trace-trait.h"
+#include "cppgc/type-traits.h"
+
+namespace cppgc {
+
+class Visitor;
+
+namespace internal {
+
+class GarbageCollectedBase {
+ public:
+  // Must use MakeGarbageCollected.
+  void* operator new(size_t) = delete;
+  void* operator new[](size_t) = delete;
+  // The garbage collector is taking care of reclaiming the object. Also,
+  // virtual destructor requires an unambiguous, accessible 'operator delete'.
+  void operator delete(void*) {
+#ifdef V8_ENABLE_CHECKS
+    internal::Abort();
+#endif  // V8_ENABLE_CHECKS
+  }
+  void operator delete[](void*) = delete;
+
+ protected:
+  GarbageCollectedBase() = default;
+};
+
+}  // namespace internal
+
+/**
+ * Base class for managed objects. Only descendent types of GarbageCollected
+ * can be constructed using MakeGarbageCollected. Must be inherited from as
+ * left-most base class.
+ *
+ * Types inheriting from GarbageCollected must provide a method of
+ * signature `void Trace(cppgc::Visitor*) const` that dispatchs all managed
+ * pointers to the visitor and delegates to garbage-collected base classes.
+ * The method must be virtual if the type is not directly a child of
+ * GarbageCollected and marked as final.
+ *
+ * \code
+ * // Example using final class.
+ * class FinalType final : public GarbageCollected<FinalType> {
+ *  public:
+ *   void Trace(cppgc::Visitor* visitor) const {
+ *     // Dispatch using visitor->Trace(...);
+ *   }
+ * };
+ *
+ * // Example using non-final base class.
+ * class NonFinalBase : public GarbageCollected<NonFinalBase> {
+ *  public:
+ *   virtual void Trace(cppgc::Visitor*) const {}
+ * };
+ *
+ * class FinalChild final : public NonFinalBase {
+ *  public:
+ *   void Trace(cppgc::Visitor* visitor) const final {
+ *     // Dispatch using visitor->Trace(...);
+ *     NonFinalBase::Trace(visitor);
+ *   }
+ * };
+ * \endcode
+ */
+template <typename>
+class GarbageCollected : public internal::GarbageCollectedBase {
+ public:
+  using IsGarbageCollectedTypeMarker = void;
+
+ protected:
+  GarbageCollected() = default;
+};
+
+/**
+ * Base class for managed mixin objects. Such objects cannot be constructed
+ * directly but must be mixed into the inheritance hierarchy of a
+ * GarbageCollected object.
+ *
+ * Types inheriting from GarbageCollectedMixin must override a virtual method
+ * of signature `void Trace(cppgc::Visitor*) const` that dispatchs all managed
+ * pointers to the visitor and delegates to base classes.
+ *
+ * \code
+ * class Mixin : public GarbageCollectedMixin {
+ *  public:
+ *   void Trace(cppgc::Visitor* visitor) const override {
+ *     // Dispatch using visitor->Trace(...);
+ *   }
+ * };
+ * \endcode
+ */
+class GarbageCollectedMixin : public internal::GarbageCollectedBase {
+ public:
+  using IsGarbageCollectedMixinTypeMarker = void;
+
+  /**
+   * This Trace method must be overriden by objects inheriting from
+   * GarbageCollectedMixin.
+   */
+  virtual void Trace(cppgc::Visitor*) const {}
+};
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_GARBAGE_COLLECTED_H_