@triniwiz/nativescript-masonkit 1.0.0-alpha.8 → 1.0.0-beta.0

package/src-native/pods/Headers/inspector/src/utils/allocation.h

@@ -1,367 +0,0 @@
-// Copyright 2012 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_UTILS_ALLOCATION_H_
-#define V8_UTILS_ALLOCATION_H_
-
-#include "include/v8-platform.h"
-#include "src/base/address-region.h"
-#include "src/base/compiler-specific.h"
-#include "src/base/platform/platform.h"
-#include "src/common/globals.h"
-#include "src/init/v8.h"
-
-namespace v8 {
-
-namespace base {
-class BoundedPageAllocator;
-}  // namespace base
-
-namespace internal {
-
-class Isolate;
-
-// This file defines memory allocation functions. If a first attempt at an
-// allocation fails, these functions call back into the embedder, then attempt
-// the allocation a second time. The embedder callback must not reenter V8.
-
-// Called when allocation routines fail to allocate, even with a possible retry.
-// This function should not return, but should terminate the current processing.
-[[noreturn]] V8_EXPORT_PRIVATE void FatalProcessOutOfMemory(
-    Isolate* isolate, const char* message);
-
-// Superclass for classes managed with new & delete.
-class V8_EXPORT_PRIVATE Malloced {
- public:
-  static void* operator new(size_t size);
-  static void operator delete(void* p);
-};
-
-template <typename T>
-T* NewArray(size_t size) {
-  T* result = new (std::nothrow) T[size];
-  if (result == nullptr) {
-    V8::GetCurrentPlatform()->OnCriticalMemoryPressure();
-    result = new (std::nothrow) T[size];
-    if (result == nullptr) FatalProcessOutOfMemory(nullptr, "NewArray");
-  }
-  return result;
-}
-
-template <typename T, typename = typename std::enable_if<
-                          base::is_trivially_copyable<T>::value>::type>
-T* NewArray(size_t size, T default_val) {
-  T* result = reinterpret_cast<T*>(NewArray<uint8_t>(sizeof(T) * size));
-  for (size_t i = 0; i < size; ++i) result[i] = default_val;
-  return result;
-}
-
-template <typename T>
-void DeleteArray(T* array) {
-  delete[] array;
-}
-
-template <typename T>
-struct ArrayDeleter {
-  void operator()(T* array) { DeleteArray(array); }
-};
-
-template <typename T>
-using ArrayUniquePtr = std::unique_ptr<T, ArrayDeleter<T>>;
-
-// The normal strdup functions use malloc.  These versions of StrDup
-// and StrNDup uses new and calls the FatalProcessOutOfMemory handler
-// if allocation fails.
-V8_EXPORT_PRIVATE char* StrDup(const char* str);
-char* StrNDup(const char* str, int n);
-
-// Allocation policy for allocating in the C free store using malloc
-// and free. Used as the default policy for lists.
-class FreeStoreAllocationPolicy {
- public:
-  template <typename T, typename TypeTag = T[]>
-  V8_INLINE T* NewArray(size_t length) {
-    return static_cast<T*>(Malloced::operator new(length * sizeof(T)));
-  }
-  template <typename T, typename TypeTag = T[]>
-  V8_INLINE void DeleteArray(T* p, size_t length) {
-    Malloced::operator delete(p);
-  }
-};
-
-// Performs a malloc, with retry logic on failure. Returns nullptr on failure.
-// Call free to release memory allocated with this function.
-void* AllocWithRetry(size_t size);
-
-V8_EXPORT_PRIVATE void* AlignedAlloc(size_t size, size_t alignment);
-V8_EXPORT_PRIVATE void AlignedFree(void* ptr);
-
-// Returns platfrom page allocator instance. Guaranteed to be a valid pointer.
-V8_EXPORT_PRIVATE v8::PageAllocator* GetPlatformPageAllocator();
-
-// Sets the given page allocator as the platform page allocator and returns
-// the current one. This function *must* be used only for testing purposes.
-// It is not thread-safe and the testing infrastructure should ensure that
-// the tests do not modify the value simultaneously.
-V8_EXPORT_PRIVATE v8::PageAllocator* SetPlatformPageAllocatorForTesting(
-    v8::PageAllocator* page_allocator);
-
-// Gets the page granularity for AllocatePages and FreePages. Addresses returned
-// by AllocatePages are aligned to this size.
-V8_EXPORT_PRIVATE size_t AllocatePageSize();
-
-// Gets the granularity at which the permissions and release calls can be made.
-V8_EXPORT_PRIVATE size_t CommitPageSize();
-
-// Sets the random seed so that GetRandomMmapAddr() will generate repeatable
-// sequences of random mmap addresses.
-V8_EXPORT_PRIVATE void SetRandomMmapSeed(int64_t seed);
-
-// Generate a random address to be used for hinting allocation calls.
-V8_EXPORT_PRIVATE void* GetRandomMmapAddr();
-
-// Allocates memory. Permissions are set according to the access argument.
-// |address| is a hint. |size| and |alignment| must be multiples of
-// AllocatePageSize(). Returns the address of the allocated memory, with the
-// specified size and alignment, or nullptr on failure.
-V8_EXPORT_PRIVATE
-V8_WARN_UNUSED_RESULT void* AllocatePages(v8::PageAllocator* page_allocator,
-                                          void* address, size_t size,
-                                          size_t alignment,
-                                          PageAllocator::Permission access);
-
-// Frees memory allocated by a call to AllocatePages. |address| and |size| must
-// be multiples of AllocatePageSize(). Returns true on success, otherwise false.
-V8_EXPORT_PRIVATE
-V8_WARN_UNUSED_RESULT bool FreePages(v8::PageAllocator* page_allocator,
-                                     void* address, const size_t size);
-
-// Releases memory that is no longer needed. The range specified by |address|
-// and |size| must be an allocated memory region. |size| and |new_size| must be
-// multiples of CommitPageSize(). Memory from |new_size| to |size| is released.
-// Released memory is left in an undefined state, so it should not be accessed.
-// Returns true on success, otherwise false.
-V8_EXPORT_PRIVATE
-V8_WARN_UNUSED_RESULT bool ReleasePages(v8::PageAllocator* page_allocator,
-                                        void* address, size_t size,
-                                        size_t new_size);
-
-// Sets permissions according to |access|. |address| and |size| must be
-// multiples of CommitPageSize(). Setting permission to kNoAccess may
-// cause the memory contents to be lost. Returns true on success, otherwise
-// false.
-V8_EXPORT_PRIVATE
-V8_WARN_UNUSED_RESULT bool SetPermissions(v8::PageAllocator* page_allocator,
-                                          void* address, size_t size,
-                                          PageAllocator::Permission access);
-inline bool SetPermissions(v8::PageAllocator* page_allocator, Address address,
-                           size_t size, PageAllocator::Permission access) {
-  return SetPermissions(page_allocator, reinterpret_cast<void*>(address), size,
-                        access);
-}
-
-// Function that may release reserved memory regions to allow failed allocations
-// to succeed. |length| is the amount of memory needed. Returns |true| if memory
-// could be released, false otherwise.
-V8_EXPORT_PRIVATE bool OnCriticalMemoryPressure(size_t length);
-
-// Represents and controls an area of reserved memory.
-class VirtualMemory final {
- public:
-  enum JitPermission { kNoJit, kMapAsJittable };
-
-  // Empty VirtualMemory object, controlling no reserved memory.
-  V8_EXPORT_PRIVATE VirtualMemory();
-
-  VirtualMemory(const VirtualMemory&) = delete;
-  VirtualMemory& operator=(const VirtualMemory&) = delete;
-
-  // Reserves virtual memory containing an area of the given size that is
-  // aligned per |alignment| rounded up to the |page_allocator|'s allocate page
-  // size. The |size| must be aligned with |page_allocator|'s commit page size.
-  // This may not be at the position returned by address().
-  V8_EXPORT_PRIVATE VirtualMemory(v8::PageAllocator* page_allocator,
-                                  size_t size, void* hint, size_t alignment = 1,
-                                  JitPermission jit = kNoJit);
-
-  // Construct a virtual memory by assigning it some already mapped address
-  // and size.
-  VirtualMemory(v8::PageAllocator* page_allocator, Address address, size_t size)
-      : page_allocator_(page_allocator), region_(address, size) {
-    DCHECK_NOT_NULL(page_allocator);
-    DCHECK(IsAligned(address, page_allocator->AllocatePageSize()));
-    DCHECK(IsAligned(size, page_allocator->CommitPageSize()));
-  }
-
-  // Releases the reserved memory, if any, controlled by this VirtualMemory
-  // object.
-  V8_EXPORT_PRIVATE ~VirtualMemory();
-
-  // Move constructor.
-  VirtualMemory(VirtualMemory&& other) V8_NOEXCEPT { *this = std::move(other); }
-
-  // Move assignment operator.
-  VirtualMemory& operator=(VirtualMemory&& other) V8_NOEXCEPT {
-    DCHECK(!IsReserved());
-    page_allocator_ = other.page_allocator_;
-    region_ = other.region_;
-    other.Reset();
-    return *this;
-  }
-
-  // Returns whether the memory has been reserved.
-  bool IsReserved() const { return region_.begin() != kNullAddress; }
-
-  // Initialize or resets an embedded VirtualMemory object.
-  V8_EXPORT_PRIVATE void Reset();
-
-  v8::PageAllocator* page_allocator() { return page_allocator_; }
-
-  const base::AddressRegion& region() const { return region_; }
-
-  // Returns the start address of the reserved memory.
-  // If the memory was reserved with an alignment, this address is not
-  // necessarily aligned. The user might need to round it up to a multiple of
-  // the alignment to get the start of the aligned block.
-  Address address() const {
-    DCHECK(IsReserved());
-    return region_.begin();
-  }
-
-  Address end() const {
-    DCHECK(IsReserved());
-    return region_.end();
-  }
-
-  // Returns the size of the reserved memory. The returned value is only
-  // meaningful when IsReserved() returns true.
-  // If the memory was reserved with an alignment, this size may be larger
-  // than the requested size.
-  size_t size() const { return region_.size(); }
-
-  // Sets permissions according to the access argument. address and size must be
-  // multiples of CommitPageSize(). Returns true on success, otherwise false.
-  V8_EXPORT_PRIVATE bool SetPermissions(Address address, size_t size,
-                                        PageAllocator::Permission access);
-
-  // Releases memory after |free_start|. Returns the number of bytes released.
-  V8_EXPORT_PRIVATE size_t Release(Address free_start);
-
-  // Frees all memory.
-  V8_EXPORT_PRIVATE void Free();
-
-  // As with Free but does not write to the VirtualMemory object itself so it
-  // can be called on a VirtualMemory that is itself not writable.
-  V8_EXPORT_PRIVATE void FreeReadOnly();
-
-  bool InVM(Address address, size_t size) const {
-    return region_.contains(address, size);
-  }
-
- private:
-  // Page allocator that controls the virtual memory.
-  v8::PageAllocator* page_allocator_ = nullptr;
-  base::AddressRegion region_;
-};
-
-// Represents a VirtualMemory reservation along with a BoundedPageAllocator that
-// can be used to allocate within the reservation.
-//
-// Virtual memory cages are used for both the pointer compression cage and code
-// ranges (on platforms that require code ranges) and are configurable via
-// ReservationParams.
-//
-// +------------+-----------+-----------  ~~~  -+
-// |     ...    |    ...    |   ...             |
-// +------------+-----------+------------ ~~~  -+
-// ^            ^           ^
-// start        cage base   allocatable base
-//
-// <------------>           <------------------->
-// base bias size              allocatable size
-// <-------------------------------------------->
-//             reservation size
-//
-// - The reservation is made using ReservationParams::page_allocator.
-// - start is the start of the virtual memory reservation.
-// - cage base is the base address of the cage.
-// - allocatable base is the cage base rounded up to the nearest
-//   ReservationParams::page_size, and is the start of the allocatable area for
-//   the BoundedPageAllocator.
-//
-// - The base bias is configured by ReservationParams::base_bias_size.
-// - The reservation size is configured by ReservationParams::reservation_size.
-//
-// Additionally,
-// - The alignment of the cage base is configured by
-//   ReservationParams::base_alignment.
-// - The page size of the BoundedPageAllocator is configured by
-//   ReservationParams::page_size.
-// - A hint for the value of start can be passed by
-//   ReservationParams::requested_start_hint.
-//
-// The configuration is subject to the following alignment requirements.
-// Below, AllocatePageSize is short for
-// ReservationParams::page_allocator->AllocatePageSize().
-//
-// - The reservation size must be AllocatePageSize-aligned.
-// - If the base alignment is not kAnyBaseAlignment, both the base alignment
-//   and the base bias size must be AllocatePageSize-aligned.
-// - The base alignment may be kAnyBaseAlignment to denote any alignment is
-//   acceptable. In this case the base bias size does not need to be aligned.
-class VirtualMemoryCage {
- public:
-  VirtualMemoryCage();
-  virtual ~VirtualMemoryCage();
-
-  VirtualMemoryCage(const VirtualMemoryCage&) = delete;
-  VirtualMemoryCage& operator=(VirtualMemoryCage&) = delete;
-
-  VirtualMemoryCage(VirtualMemoryCage&& other) V8_NOEXCEPT;
-  VirtualMemoryCage& operator=(VirtualMemoryCage&& other) V8_NOEXCEPT;
-
-  Address base() const { return base_; }
-
-  base::BoundedPageAllocator* page_allocator() const {
-    return page_allocator_.get();
-  }
-
-  VirtualMemory* reservation() { return &reservation_; }
-  const VirtualMemory* reservation() const { return &reservation_; }
-
-  bool IsReserved() const {
-    DCHECK_EQ(base_ != kNullAddress, reservation_.IsReserved());
-    return reservation_.IsReserved();
-  }
-
-  struct ReservationParams {
-    // The allocator to use to reserve the virtual memory.
-    v8::PageAllocator* page_allocator;
-    // See diagram above.
-    size_t reservation_size;
-    size_t base_alignment;
-    size_t base_bias_size;
-    size_t page_size;
-    Address requested_start_hint;
-
-    static constexpr size_t kAnyBaseAlignment = 1;
-  };
-
-  // A number of attempts is made to try to reserve a region that satisfies the
-  // constraints in params, but this may fail. The base address may be different
-  // than the one requested.
-  bool InitReservation(const ReservationParams& params);
-
-  void Free();
-
- protected:
-  Address base_ = kNullAddress;
-  std::unique_ptr<base::BoundedPageAllocator> page_allocator_;
-  VirtualMemory reservation_;
-};
-
-}  // namespace internal
-}  // namespace v8
-
-#endif  // V8_UTILS_ALLOCATION_H_

package/src-native/pods/Headers/inspector/src/utils/vector.h

@@ -1,324 +0,0 @@
-// Copyright 2014 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_UTILS_VECTOR_H_
-#define V8_UTILS_VECTOR_H_
-
-#include <algorithm>
-#include <cstring>
-#include <iterator>
-#include <memory>
-#include <type_traits>
-
-#include "src/common/checks.h"
-#include "src/common/globals.h"
-#include "src/utils/allocation.h"
-
-namespace v8 {
-namespace internal {
-
-template <typename T>
-class Vector {
- public:
-  using value_type = T;
-  using iterator = T*;
-  using const_iterator = const T*;
-
-  constexpr Vector() : start_(nullptr), length_(0) {}
-
-  constexpr Vector(T* data, size_t length) : start_(data), length_(length) {
-    DCHECK(length == 0 || data != nullptr);
-  }
-
-  static Vector<T> New(size_t length) {
-    return Vector<T>(NewArray<T>(length), length);
-  }
-
-  // Returns a vector using the same backing storage as this one,
-  // spanning from and including 'from', to but not including 'to'.
-  Vector<T> SubVector(size_t from, size_t to) const {
-    DCHECK_LE(from, to);
-    DCHECK_LE(to, length_);
-    return Vector<T>(begin() + from, to - from);
-  }
-
-  // Returns the length of the vector. Only use this if you really need an
-  // integer return value. Use {size()} otherwise.
-  int length() const {
-    DCHECK_GE(std::numeric_limits<int>::max(), length_);
-    return static_cast<int>(length_);
-  }
-
-  // Returns the length of the vector as a size_t.
-  constexpr size_t size() const { return length_; }
-
-  // Returns whether or not the vector is empty.
-  constexpr bool empty() const { return length_ == 0; }
-
-  // Access individual vector elements - checks bounds in debug mode.
-  T& operator[](size_t index) const {
-    DCHECK_LT(index, length_);
-    return start_[index];
-  }
-
-  const T& at(size_t index) const { return operator[](index); }
-
-  T& first() { return start_[0]; }
-
-  T& last() {
-    DCHECK_LT(0, length_);
-    return start_[length_ - 1];
-  }
-
-  // Returns a pointer to the start of the data in the vector.
-  constexpr T* begin() const { return start_; }
-
-  // For consistency with other containers, do also provide a {data} accessor.
-  constexpr T* data() const { return start_; }
-
-  // Returns a pointer past the end of the data in the vector.
-  constexpr T* end() const { return start_ + length_; }
-
-  // Returns a clone of this vector with a new backing store.
-  Vector<T> Clone() const {
-    T* result = NewArray<T>(length_);
-    for (size_t i = 0; i < length_; i++) result[i] = start_[i];
-    return Vector<T>(result, length_);
-  }
-
-  void Truncate(size_t length) {
-    DCHECK(length <= length_);
-    length_ = length;
-  }
-
-  // Releases the array underlying this vector. Once disposed the
-  // vector is empty.
-  void Dispose() {
-    DeleteArray(start_);
-    start_ = nullptr;
-    length_ = 0;
-  }
-
-  Vector<T> operator+(size_t offset) {
-    DCHECK_LE(offset, length_);
-    return Vector<T>(start_ + offset, length_ - offset);
-  }
-
-  Vector<T> operator+=(size_t offset) {
-    DCHECK_LE(offset, length_);
-    start_ += offset;
-    length_ -= offset;
-    return *this;
-  }
-
-  // Implicit conversion from Vector<T> to Vector<const T>.
-  operator Vector<const T>() const { return {start_, length_}; }
-
-  template <typename S>
-  static Vector<T> cast(Vector<S> input) {
-    // Casting is potentially dangerous, so be really restrictive here. This
-    // might be lifted once we have use cases for that.
-    STATIC_ASSERT(std::is_pod<S>::value);
-    STATIC_ASSERT(std::is_pod<T>::value);
-    DCHECK_EQ(0, (input.size() * sizeof(S)) % sizeof(T));
-    DCHECK_EQ(0, reinterpret_cast<uintptr_t>(input.begin()) % alignof(T));
-    return Vector<T>(reinterpret_cast<T*>(input.begin()),
-                     input.size() * sizeof(S) / sizeof(T));
-  }
-
-  bool operator==(const Vector<const T> other) const {
-    return std::equal(begin(), end(), other.begin(), other.end());
-  }
-
-  bool operator!=(const Vector<const T> other) const {
-    return !operator==(other);
-  }
-
- private:
-  T* start_;
-  size_t length_;
-};
-
-template <typename T>
-class V8_NODISCARD ScopedVector : public Vector<T> {
- public:
-  explicit ScopedVector(size_t length)
-      : Vector<T>(NewArray<T>(length), length) {}
-  ~ScopedVector() { DeleteArray(this->begin()); }
-
- private:
-  DISALLOW_IMPLICIT_CONSTRUCTORS(ScopedVector);
-};
-
-template <typename T>
-class OwnedVector {
- public:
-  MOVE_ONLY_WITH_DEFAULT_CONSTRUCTORS(OwnedVector);
-  OwnedVector(std::unique_ptr<T[]> data, size_t length)
-      : data_(std::move(data)), length_(length) {
-    DCHECK_IMPLIES(length_ > 0, data_ != nullptr);
-  }
-
-  // Implicit conversion from {OwnedVector<U>} to {OwnedVector<T>}, instantiable
-  // if {std::unique_ptr<U>} can be converted to {std::unique_ptr<T>}.
-  // Can be used to convert {OwnedVector<T>} to {OwnedVector<const T>}.
-  template <typename U,
-            typename = typename std::enable_if<std::is_convertible<
-                std::unique_ptr<U>, std::unique_ptr<T>>::value>::type>
-  OwnedVector(OwnedVector<U>&& other)
-      : data_(std::move(other.data_)), length_(other.length_) {
-    STATIC_ASSERT(sizeof(U) == sizeof(T));
-    other.length_ = 0;
-  }
-
-  // Returns the length of the vector as a size_t.
-  constexpr size_t size() const { return length_; }
-
-  // Returns whether or not the vector is empty.
-  constexpr bool empty() const { return length_ == 0; }
-
-  // Returns the pointer to the start of the data in the vector.
-  T* start() const {
-    DCHECK_IMPLIES(length_ > 0, data_ != nullptr);
-    return data_.get();
-  }
-
-  constexpr T* begin() const { return start(); }
-  constexpr T* end() const { return start() + size(); }
-
-  // Access individual vector elements - checks bounds in debug mode.
-  T& operator[](size_t index) const {
-    DCHECK_LT(index, length_);
-    return data_[index];
-  }
-
-  // Returns a {Vector<T>} view of the data in this vector.
-  Vector<T> as_vector() const { return Vector<T>(start(), size()); }
-
-  // Releases the backing data from this vector and transfers ownership to the
-  // caller. This vector will be empty afterwards.
-  std::unique_ptr<T[]> ReleaseData() {
-    length_ = 0;
-    return std::move(data_);
-  }
-
-  // Allocates a new vector of the specified size via the default allocator.
-  // Elements in the new vector are value-initialized.
-  static OwnedVector<T> New(size_t size) {
-    if (size == 0) return {};
-    return OwnedVector<T>(std::make_unique<T[]>(size), size);
-  }
-
-  // Allocates a new vector of the specified size via the default allocator.
-  // Elements in the new vector are default-initialized.
-  static OwnedVector<T> NewForOverwrite(size_t size) {
-    if (size == 0) return {};
-    // TODO(v8): Use {std::make_unique_for_overwrite} once we allow C++20.
-    return OwnedVector<T>(std::unique_ptr<T[]>(new T[size]), size);
-  }
-
-  // Allocates a new vector containing the specified collection of values.
-  // {Iterator} is the common type of {std::begin} and {std::end} called on a
-  // {const U&}. This function is only instantiable if that type exists.
-  template <typename U, typename Iterator = typename std::common_type<
-                            decltype(std::begin(std::declval<const U&>())),
-                            decltype(std::end(std::declval<const U&>()))>::type>
-  static OwnedVector<T> Of(const U& collection) {
-    Iterator begin = std::begin(collection);
-    Iterator end = std::end(collection);
-    using non_const_t = typename std::remove_const<T>::type;
-    auto vec =
-        OwnedVector<non_const_t>::NewForOverwrite(std::distance(begin, end));
-    std::copy(begin, end, vec.start());
-    return vec;
-  }
-
-  bool operator==(std::nullptr_t) const { return data_ == nullptr; }
-  bool operator!=(std::nullptr_t) const { return data_ != nullptr; }
-
- private:
-  template <typename U>
-  friend class OwnedVector;
-
-  std::unique_ptr<T[]> data_;
-  size_t length_ = 0;
-};
-
-// The vectors returned by {StaticCharVector}, {CStrVector}, or {OneByteVector}
-// do not contain a null-termination byte. If you want the null byte, use
-// {ArrayVector}.
-
-// Known length, constexpr.
-template <size_t N>
-constexpr Vector<const char> StaticCharVector(const char (&array)[N]) {
-  return {array, N - 1};
-}
-
-// Unknown length, not constexpr.
-inline Vector<const char> CStrVector(const char* data) {
-  return {data, strlen(data)};
-}
-
-// OneByteVector is never constexpr because the data pointer is
-// {reinterpret_cast}ed.
-inline Vector<const uint8_t> OneByteVector(const char* data, size_t length) {
-  return {reinterpret_cast<const uint8_t*>(data), length};
-}
-
-inline Vector<const uint8_t> OneByteVector(const char* data) {
-  return OneByteVector(data, strlen(data));
-}
-
-template <size_t N>
-Vector<const uint8_t> StaticOneByteVector(const char (&array)[N]) {
-  return OneByteVector(array, N - 1);
-}
-
-// For string literals, ArrayVector("foo") returns a vector ['f', 'o', 'o', \0]
-// with length 4 and null-termination.
-// If you want ['f', 'o', 'o'], use CStrVector("foo").
-template <typename T, size_t N>
-inline constexpr Vector<T> ArrayVector(T (&arr)[N]) {
-  return {arr, N};
-}
-
-// Construct a Vector from a start pointer and a size.
-template <typename T>
-inline constexpr Vector<T> VectorOf(T* start, size_t size) {
-  return {start, size};
-}
-
-// Construct a Vector from anything providing a {data()} and {size()} accessor.
-template <typename Container>
-inline constexpr auto VectorOf(Container&& c)
-    -> decltype(VectorOf(c.data(), c.size())) {
-  return VectorOf(c.data(), c.size());
-}
-
-// Construct a Vector from an initializer list. The vector can obviously only be
-// used as long as the initializer list is live. Valid uses include direct use
-// in parameter lists: F(VectorOf({1, 2, 3}));
-template <typename T>
-inline constexpr Vector<const T> VectorOf(std::initializer_list<T> list) {
-  return VectorOf(list.begin(), list.size());
-}
-
-template <typename T, size_t kSize>
-class EmbeddedVector : public Vector<T> {
- public:
-  EmbeddedVector() : Vector<T>(buffer_, kSize) {}
-  explicit EmbeddedVector(const T& initial_value) : Vector<T>(buffer_, kSize) {
-    std::fill_n(buffer_, kSize, initial_value);
-  }
-  EmbeddedVector(const EmbeddedVector&) = delete;
-  EmbeddedVector& operator=(const EmbeddedVector&) = delete;
-
- private:
-  T buffer_[kSize];
-};
-
-}  // namespace internal
-}  // namespace v8
-
-#endif  // V8_UTILS_VECTOR_H_