libv8 6.2.414.42.1-universal-darwin-16 → 8.4.255.0-universal-darwin-16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a48341e50fb203ae1eae012add651d6766cbe656
-  data.tar.gz: a12eb920d8eb535b35aa0e27fc9b8546a35c3b70
+SHA256:
+  metadata.gz: 8829f5926bd749011670ae7361ee7e4cc8f28fcfbb450671e05ffd3abf65fff3
+  data.tar.gz: fd6bca9eb73d8b5adb403c5ae17fbdfa080dde029ec50be797ee1bd4761eee43
 SHA512:
-  metadata.gz: d5930d6e4cfb2dae7a018f33630f0e3bfee24a88dd9d1311b658a88e57ed9f758a8d8418f44526bf56c94d4ec26c8528658681259a5a275058ff5e616e8aa732
-  data.tar.gz: 316b88580e98bcfb48878a30d8fda9de1a327889874463f8e76f9c694b8af361347fd0e970bca81ce38e8756fd158c0ffdbf7856ef05d4116df2f7f1af9640e2
+  metadata.gz: 43d3c3e77e48f8792e55f3b39a4c222208d0770aa3c627e142b82785106802702eb5da723cc5f6d29804c3b8ced56b51de71e33af687b1a7115e9429b4dc93e6
+  data.tar.gz: 6f28b2098d2b30e2aee1664023c8c78ee67bf715fc6aa131e92351a99cb31fe2fe383ebce5bf63d765ece9d8e338dfdc6ff7b0d244c5274546940c886d8a47f6

data/ext/libv8/paths.rb

@@ -1,6 +1,5 @@
 require 'rbconfig'
 require 'shellwords'
-require File.expand_path '../arch', __FILE__
 
 module Libv8
   module Paths
@@ -11,29 +10,17 @@ module Libv8
     end
 
     def object_paths
-      [:base, :libplatform, :libsampler, :libbase, :snapshot].map do |name|
-        Shellwords.escape libv8_object(name)
-      end
+      [Shellwords.escape(File.join(vendored_source_path,
+                                   'out.gn',
+                                   'libv8',
+                                   'obj',
+                                   "libv8_monolith.#{config['LIBEXT']}"))]
     end
 
     def config
       RbConfig::MAKEFILE_CONFIG
     end
 
-    def libv8_object(name)
-      filename = "#{libv8_profile}/libv8_#{name}.#{config['LIBEXT']}"
-      unless File.exist? filename
-        filename = "#{libv8_profile}/obj.target/tools/gyp/libv8_#{name}.#{config['LIBEXT']}"
-      end
-      return filename
-    end
-
-    def libv8_profile
-      base = "#{vendored_source_path}/out/#{Libv8::Arch.libv8_arch}"
-      debug = "#{base}.debug"
-      File.exist?(debug) ? debug : "#{base}.release"
-    end
-
     def vendored_source_path
       File.expand_path "../../../vendor/v8", __FILE__
     end

data/lib/libv8/version.rb

@@ -1,3 +1,3 @@
 module Libv8
-  VERSION = "6.2.414.42.1"
+  VERSION = "8.4.255.0"
 end

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

@@ -0,0 +1,124 @@
+// 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/garbage-collected.h"
+#include "cppgc/heap.h"
+#include "cppgc/internal/api-constants.h"
+#include "cppgc/internal/gc-info.h"
+
+namespace cppgc {
+
+template <typename T>
+class MakeGarbageCollectedTraitBase;
+
+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::Heap* heap, size_t size, GCInfoIndex 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 {
+ protected:
+  /**
+   * Allocates memory for an object of type T.
+   *
+   * \param heap The heap to allocate this 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(Heap* heap, size_t size) {
+    // TODO(chromium:1056170): Allow specifying arena for specific embedder
+    // uses.
+    return internal::MakeGarbageCollectedTraitInternal::Allocate(
+        heap, size, internal::GCInfoTrait<T>::Index());
+  }
+
+  /**
+   * 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(Heap* heap, 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(heap, sizeof(T));
+    T* object = ::new (memory) T(std::forward<Args>(args)...);
+    MakeGarbageCollectedTraitBase<T>::MarkObjectAsFullyConstructed(object);
+    return object;
+  }
+};
+
+/**
+ * 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(Heap* heap, Args&&... args) {
+  return MakeGarbageCollectedTrait<T>::Call(heap, std::forward<Args>(args)...);
+}
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_ALLOCATION_H_

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

@@ -0,0 +1,192 @@
+// 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/macros.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;
+
+  // Sentinel used to mark not-fully-constructed mixins.
+  static constexpr void* kNotFullyConstructedObject = nullptr;
+
+  // Provide default implementation that indicate that the vtable is not yet
+  // set up properly. This is used to to get GCInfo objects for mixins so that
+  // these objects can be processed later on.
+  virtual TraceDescriptor GetTraceDescriptor() const {
+    return {kNotFullyConstructedObject, nullptr};
+  }
+
+  /**
+   * This Trace method must be overriden by objects inheriting from
+   * GarbageCollectedMixin.
+   */
+  virtual void Trace(cppgc::Visitor*) const {}
+};
+
+/**
+ * Macro defines all methods and markers needed for handling mixins. Must be
+ * used on the type that is inheriting from GarbageCollected *and*
+ * GarbageCollectedMixin.
+ *
+ * \code
+ * class Mixin : public GarbageCollectedMixin {
+ *  public:
+ *   void Trace(cppgc::Visitor* visitor) const override {
+ *     // Dispatch using visitor->Trace(...);
+ *   }
+ * };
+ *
+ * class Foo : public GarbageCollected<Foo>, public Mixin {
+ *   USING_GARBAGE_COLLECTED_MIXIN();
+ *  public:
+ *   void Trace(cppgc::Visitor* visitor) const override {
+ *     // Dispatch using visitor->Trace(...);
+ *     Mixin::Trace(visitor);
+ *   }
+ * };
+ * \endcode
+ */
+#define USING_GARBAGE_COLLECTED_MIXIN()                                      \
+ public:                                                                     \
+  /* Marker is used by clang to check for proper usages of the macro. */     \
+  typedef int HasUsingGarbageCollectedMixinMacro;                            \
+                                                                             \
+  TraceDescriptor GetTraceDescriptor() const override {                      \
+    static_assert(                                                           \
+        internal::IsSubclassOfTemplate<                                      \
+            std::remove_const_t<std::remove_pointer_t<decltype(this)>>,      \
+            cppgc::GarbageCollected>::value,                                 \
+        "Only garbage collected objects can have garbage collected mixins"); \
+    return {this, TraceTrait<std::remove_const_t<                            \
+                      std::remove_pointer_t<decltype(this)>>>::Trace};       \
+  }                                                                          \
+                                                                             \
+ private:                                                                    \
+  friend class internal::__thisIsHereToForceASemicolonAfterThisMacro
+
+/**
+ * Merge two or more Mixins into one.
+ *
+ * \code
+ * class A : public GarbageCollectedMixin {};
+ * class B : public GarbageCollectedMixin {};
+ * class C : public A, public B {
+ *   MERGE_GARBAGE_COLLECTED_MIXINS();
+ *  public:
+ * };
+ * \endcode
+ */
+#define MERGE_GARBAGE_COLLECTED_MIXINS()                \
+ public:                                                \
+  /* When using multiple mixins the methods become  */  \
+  /* ambigous. Providing additional implementations */  \
+  /* disambiguate them again.                       */  \
+  TraceDescriptor GetTraceDescriptor() const override { \
+    return {kNotFullyConstructedObject, nullptr};       \
+  }                                                     \
+                                                        \
+ private:                                               \
+  friend class internal::__thisIsHereToForceASemicolonAfterThisMacro
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_GARBAGE_COLLECTED_H_

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

@@ -0,0 +1,50 @@
+// 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_HEAP_H_
+#define INCLUDE_CPPGC_HEAP_H_
+
+#include <memory>
+
+#include "v8config.h"  // NOLINT(build/include_directory)
+
+namespace cppgc {
+namespace internal {
+class Heap;
+}  // namespace internal
+
+class V8_EXPORT Heap {
+ public:
+  // Normal spaces are used to store objects of different size classes:
+  // - kNormal1:  < 32 bytes
+  // - kNormal2:  < 64 bytes
+  // - kNormal3:  < 128 bytes
+  // - kNormal4: >= 128 bytes
+  // Objects of size greater than 2^16 get stored in the large space. Users can
+  // register up to 4 arenas for application specific needs.
+  enum class SpaceType {
+    kNormal1,
+    kNormal2,
+    kNormal3,
+    kNormal4,
+    kLarge,
+    kUserDefined1,
+    kUserDefined2,
+    kUserDefined3,
+    kUserDefined4,
+  };
+
+  static std::unique_ptr<Heap> Create();
+
+  virtual ~Heap() = default;
+
+ private:
+  Heap() = default;
+
+  friend class internal::Heap;
+};
+
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_HEAP_H_

data/vendor/v8/include/cppgc/internal/accessors.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_INTERNAL_ACCESSORS_H_
+#define INCLUDE_CPPGC_INTERNAL_ACCESSORS_H_
+
+#include "cppgc/internal/api-constants.h"
+
+namespace cppgc {
+
+class Heap;
+
+namespace internal {
+
+inline cppgc::Heap* GetHeapFromPayload(const void* payload) {
+  return *reinterpret_cast<cppgc::Heap**>(
+      ((reinterpret_cast<uintptr_t>(payload) & api_constants::kPageBaseMask) +
+       api_constants::kGuardPageSize) +
+      api_constants::kHeapOffset);
+}
+
+}  // namespace internal
+}  // namespace cppgc
+
+#endif  // INCLUDE_CPPGC_INTERNAL_ACCESSORS_H_