@triniwiz/nativescript-masonkit 1.0.0-alpha.4 → 1.0.0-alpha.6

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

@@ -0,0 +1,367 @@
+// 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/pods/Headers/inspector/src/utils/vector.h

@@ -0,0 +1,324 @@
+// 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_