libv8-node 16.10.0.0-arm64-darwin

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 82276d6419d9e911c624d144c7ac19d7c107258cff62e653a12e06fb0f1b2ba2
+  data.tar.gz: 97ddc6eaec2f7181fb9c43023868e8d6a3eabdde526160e741024daa17934bff
+SHA512:
+  metadata.gz: 0bd3e7c158f56bc6f64d11881f900bc15d54da8fddd2159a82a76bc2bba32d29b72e6312c60b0bf6fba296dca14d37d011046b1199c34febf9f3b68737597822
+  data.tar.gz: 49381e7bb842a0420f19b736ba44d74f67859f462d25a54414e58ce1d07edffe123ca085db36c4782201a50f9e78f90ab387100e81edcc1a1e04d979e0b91d03

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

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

data/ext/libv8-node/location.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'pathname'
+require File.expand_path('paths', __dir__)
+
+module Libv8; end
+
+module Libv8::Node
+  class Location
+    def install!
+      File.open(Pathname(__FILE__).dirname.join('.location.yml'), 'w') do |f|
+        f.write(to_yaml)
+      end
+
+      0
+    end
+
+    def self.load!
+      File.open(Pathname(__FILE__).dirname.join('.location.yml')) do |f|
+        YAML.respond_to?(:unsafe_load) ? YAML.unsafe_load(f) : YAML.load(f) # rubocop:disable Security/YAMLLoad
+      end
+    end
+
+    class Vendor < Location
+      def install!
+        require File.expand_path('builder', __dir__)
+
+        builder = Libv8::Node::Builder.new
+        exit_status = builder.build_libv8!
+        builder.remove_intermediates!
+
+        super if exit_status == 0
+
+        verify_installation!
+
+        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? }
+          raise(HeaderNotFound, "Unable to locate 'v8.h' in the libv8 header paths: #{include_paths.inspect}")
+        end
+
+        Libv8::Node::Paths.object_paths.each do |p|
+          raise(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 MkmfContext
+      def incflags
+        $INCFLAGS # rubocop:disable Style/GlobalVars
+      end
+
+      def ldflags
+        $LDFLAGS # rubocop:disable Style/GlobalVars
+      end
+    end
+  end
+end

data/ext/libv8-node/paths.rb

@@ -0,0 +1,34 @@
+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,
+                                   platform,
+                                   'libv8',
+                                   'obj',
+                                   "libv8_monolith.#{config['LIBEXT']}"))]
+    end
+
+    def platform
+      Gem::Platform.local.to_s.gsub(/-darwin-?\d+/, '-darwin')
+    end
+
+    def config
+      RbConfig::MAKEFILE_CONFIG
+    end
+
+    def vendored_source_path
+      File.expand_path('../../vendor/v8', __dir__)
+    end
+  end
+end

data/lib/libv8/node/version.rb

@@ -0,0 +1,7 @@
+module Libv8; end
+
+module Libv8::Node
+  VERSION = '16.10.0.0'.freeze
+  NODE_VERSION = '16.10.0'.freeze
+  LIBV8_VERSION = '9.3.345.19'.freeze # from 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,232 @@
+// 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 <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <new>
+#include <type_traits>
+
+#include "cppgc/custom-space.h"
+#include "cppgc/internal/api-constants.h"
+#include "cppgc/internal/gc-info.h"
+#include "cppgc/type-traits.h"
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+
+/**
+ * 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)));
+    atomic_mutable_bitfield->fetch_or(api_constants::kFullyConstructedBitMask,
+                                      std::memory_order_release);
+  }
+
+  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 MakeGarbageCollectedTraitInternal::Allocate(
+          handle, size, internal::GCInfoTrait<U>::Index(),
+          CustomSpace::kSpaceIndex);
+    }
+  };
+
+  template <typename U>
+  struct SpacePolicy<U, void> {
+    static void* Allocate(AllocationHandle& handle, size_t size) {
+      // Default space.
+      return MakeGarbageCollectedTraitInternal::Allocate(
+          handle, size, internal::GCInfoTrait<U>::Index());
+    }
+  };
+
+ private:
+  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:
+  static_assert(internal::IsGarbageCollectedType<T>::value,
+                "T needs to be a garbage collected object");
+  static_assert(!IsGarbageCollectedWithMixinTypeV<T> ||
+                    sizeof(T) <=
+                        internal::api_constants::kLargeObjectSizeThreshold,
+                "GarbageCollectedMixin may not be a large object");
+
+ 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.
+   */
+  V8_INLINE static void* Allocate(AllocationHandle& handle, size_t size) {
+    static_assert(
+        std::is_base_of<typename T::ParentMostGarbageCollectedType, T>::value,
+        "U of GarbageCollected<U> must be a base of T. Check "
+        "GarbageCollected<T> base class inheritance.");
+    return SpacePolicy<
+        typename internal::GCInfoFolding<
+            T, typename T::ParentMostGarbageCollectedType>::ResultType,
+        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.
+   */
+  V8_INLINE static void MarkObjectAsFullyConstructed(const void* payload) {
+    internal::MakeGarbageCollectedTraitInternal::MarkObjectAsFullyConstructed(
+        payload);
+  }
+};
+
+/**
+ * Passed to MakeGarbageCollected to specify how many bytes should be appended
+ * to the allocated object.
+ *
+ * Example:
+ * \code
+ * class InlinedArray final : public GarbageCollected<InlinedArray> {
+ *  public:
+ *   explicit InlinedArray(size_t bytes) : size(bytes), byte_array(this + 1) {}
+ *   void Trace(Visitor*) const {}
+
+ *   size_t size;
+ *   char* byte_array;
+ * };
+ *
+ * auto* inlined_array = MakeGarbageCollected<InlinedArray(
+ *    GetAllocationHandle(), AdditionalBytes(4), 4);
+ * for (size_t i = 0; i < 4; i++) {
+ *   Process(inlined_array->byte_array[i]);
+ * }
+ * \endcode
+ */
+struct AdditionalBytes {
+  constexpr explicit AdditionalBytes(size_t bytes) : value(bytes) {}
+  const size_t value;
+};
+
+/**
+ * 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) {
+    void* memory =
+        MakeGarbageCollectedTraitBase<T>::Allocate(handle, sizeof(T));
+    T* object = ::new (memory) T(std::forward<Args>(args)...);
+    MakeGarbageCollectedTraitBase<T>::MarkObjectAsFullyConstructed(object);
+    return object;
+  }
+
+  template <typename... Args>
+  static T* Call(AllocationHandle& handle, AdditionalBytes additional_bytes,
+                 Args&&... args) {
+    void* memory = MakeGarbageCollectedTraitBase<T>::Allocate(
+        handle, sizeof(T) + additional_bytes.value);
+    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;
+}
+
+/**
+ * Constructs a managed object of type T where T transitively inherits from
+ * GarbageCollected. Created objects will have additional bytes appended to
+ * it. Allocated memory would suffice for `sizeof(T) + additional_bytes`.
+ *
+ * \param additional_bytes Denotes how many bytes to append to T.
+ * \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,
+                        AdditionalBytes additional_bytes, Args&&... args) {
+  T* object = MakeGarbageCollectedTrait<T>::Call(handle, additional_bytes,
+                                                 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,29 @@
+// 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 {
+  /**
+   * Stack may contain interesting heap pointers.
+   */
+  kMayContainHeapPointers,
+  /**
+   * Stack does not contain any interesting heap pointers.
+   */
+  kNoHeapPointers,
+};
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_COMMON_H_