@nativescript/canvas 2.0.0-alpha.10 → 2.0.0-alpha.12

package/pods/Headers/inspector/base64.h

@@ -1,9 +0,0 @@
-#ifndef BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A
-#define BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A
-
-#include <string>
-
-std::string base64_encode(const char* , unsigned int len);
-std::string base64_decode(std::string const& s);
-
-#endif /* BASE64_H_C0CE2A47_D10E_42C9_A27C_C883944E704A */

package/pods/Headers/inspector/src/base/address-region.h

@@ -1,95 +0,0 @@
-// Copyright 2018 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_BASE_ADDRESS_REGION_H_
-#define V8_BASE_ADDRESS_REGION_H_
-
-#include <iostream>
-
-#include "src/base/macros.h"
-
-namespace v8 {
-namespace base {
-
-// Helper class representing an address region of certain size.
-class AddressRegion {
- public:
-  // Function object that compares the start address of two regions. Usable as
-  // compare function on std data structures and algorithms.
-  struct StartAddressLess {
-    bool operator()(base::AddressRegion a, base::AddressRegion b) const {
-      return a.begin() < b.begin();
-    }
-  };
-
-  using Address = uintptr_t;
-
-  constexpr AddressRegion() = default;
-
-  constexpr AddressRegion(Address address, size_t size)
-      : address_(address), size_(size) {}
-
-  Address begin() const { return address_; }
-  Address end() const { return address_ + size_; }
-
-  size_t size() const { return size_; }
-  void set_size(size_t size) { size_ = size; }
-
-  bool is_empty() const { return size_ == 0; }
-
-  bool contains(Address address) const {
-    STATIC_ASSERT(std::is_unsigned<Address>::value);
-    return (address - begin()) < size();
-  }
-
-  bool contains(Address address, size_t size) const {
-    STATIC_ASSERT(std::is_unsigned<Address>::value);
-    Address offset = address - begin();
-    return (offset < size_) && (offset + size <= size_);
-  }
-
-  bool contains(AddressRegion region) const {
-    return contains(region.address_, region.size_);
-  }
-
-  base::AddressRegion GetOverlap(AddressRegion region) const {
-    Address overlap_start = std::max(begin(), region.begin());
-    Address overlap_end =
-        std::max(overlap_start, std::min(end(), region.end()));
-    return {overlap_start, overlap_end - overlap_start};
-  }
-
-  bool operator==(AddressRegion other) const {
-    return address_ == other.address_ && size_ == other.size_;
-  }
-
-  bool operator!=(AddressRegion other) const {
-    return address_ != other.address_ || size_ != other.size_;
-  }
-
- private:
-  Address address_ = 0;
-  size_t size_ = 0;
-};
-ASSERT_TRIVIALLY_COPYABLE(AddressRegion);
-
-// Construct an AddressRegion from anything providing a {data()} and {size()}
-// accessor.
-template <typename Container,
-          typename = decltype(std::declval<Container>().data()),
-          typename = decltype(std::declval<Container>().size())>
-inline constexpr AddressRegion AddressRegionOf(Container&& c) {
-  return AddressRegion{reinterpret_cast<AddressRegion::Address>(c.data()),
-                       sizeof(*c.data()) * c.size()};
-}
-
-inline std::ostream& operator<<(std::ostream& out, AddressRegion region) {
-  return out << "[" << reinterpret_cast<void*>(region.begin()) << "+"
-             << region.size() << "]";
-}
-
-}  // namespace base
-}  // namespace v8
-
-#endif  // V8_BASE_ADDRESS_REGION_H_

package/pods/Headers/inspector/src/base/atomic-utils.h

@@ -1,219 +0,0 @@
-// Copyright 2015 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_BASE_ATOMIC_UTILS_H_
-#define V8_BASE_ATOMIC_UTILS_H_
-
-#include <limits.h>
-#include <type_traits>
-
-#include "src/base/atomicops.h"
-#include "src/base/macros.h"
-
-namespace v8 {
-namespace base {
-
-// Deprecated. Use std::atomic<T> for new code.
-// Flag using T atomically. Also accepts void* as T.
-template <typename T>
-class AtomicValue {
- public:
-  AtomicValue() : value_(0) {}
-
-  explicit AtomicValue(T initial)
-      : value_(cast_helper<T>::to_storage_type(initial)) {}
-
-  V8_INLINE T Value() const {
-    return cast_helper<T>::to_return_type(base::Acquire_Load(&value_));
-  }
-
-  V8_INLINE void SetValue(T new_value) {
-    base::Release_Store(&value_, cast_helper<T>::to_storage_type(new_value));
-  }
-
- private:
-  STATIC_ASSERT(sizeof(T) <= sizeof(base::AtomicWord));
-
-  template <typename S>
-  struct cast_helper {
-    static base::AtomicWord to_storage_type(S value) {
-      return static_cast<base::AtomicWord>(value);
-    }
-    static S to_return_type(base::AtomicWord value) {
-      return static_cast<S>(value);
-    }
-  };
-
-  template <typename S>
-  struct cast_helper<S*> {
-    static base::AtomicWord to_storage_type(S* value) {
-      return reinterpret_cast<base::AtomicWord>(value);
-    }
-    static S* to_return_type(base::AtomicWord value) {
-      return reinterpret_cast<S*>(value);
-    }
-  };
-
-  base::AtomicWord value_;
-};
-
-// Provides atomic operations for a values stored at some address.
-template <typename TAtomicStorageType>
-class AsAtomicImpl {
- public:
-  using AtomicStorageType = TAtomicStorageType;
-
-  template <typename T>
-  static T Acquire_Load(T* addr) {
-    STATIC_ASSERT(sizeof(T) <= sizeof(AtomicStorageType));
-    return cast_helper<T>::to_return_type(
-        base::Acquire_Load(to_storage_addr(addr)));
-  }
-
-  template <typename T>
-  static T Relaxed_Load(T* addr) {
-    STATIC_ASSERT(sizeof(T) <= sizeof(AtomicStorageType));
-    return cast_helper<T>::to_return_type(
-        base::Relaxed_Load(to_storage_addr(addr)));
-  }
-
-  template <typename T>
-  static void Release_Store(T* addr,
-                            typename std::remove_reference<T>::type new_value) {
-    STATIC_ASSERT(sizeof(T) <= sizeof(AtomicStorageType));
-    base::Release_Store(to_storage_addr(addr),
-                        cast_helper<T>::to_storage_type(new_value));
-  }
-
-  template <typename T>
-  static void Relaxed_Store(T* addr,
-                            typename std::remove_reference<T>::type new_value) {
-    STATIC_ASSERT(sizeof(T) <= sizeof(AtomicStorageType));
-    base::Relaxed_Store(to_storage_addr(addr),
-                        cast_helper<T>::to_storage_type(new_value));
-  }
-
-  template <typename T>
-  static T Release_CompareAndSwap(
-      T* addr, typename std::remove_reference<T>::type old_value,
-      typename std::remove_reference<T>::type new_value) {
-    STATIC_ASSERT(sizeof(T) <= sizeof(AtomicStorageType));
-    return cast_helper<T>::to_return_type(base::Release_CompareAndSwap(
-        to_storage_addr(addr), cast_helper<T>::to_storage_type(old_value),
-        cast_helper<T>::to_storage_type(new_value)));
-  }
-
-  template <typename T>
-  static T Relaxed_CompareAndSwap(
-      T* addr, typename std::remove_reference<T>::type old_value,
-      typename std::remove_reference<T>::type new_value) {
-    STATIC_ASSERT(sizeof(T) <= sizeof(AtomicStorageType));
-    return cast_helper<T>::to_return_type(base::Relaxed_CompareAndSwap(
-        to_storage_addr(addr), cast_helper<T>::to_storage_type(old_value),
-        cast_helper<T>::to_storage_type(new_value)));
-  }
-
-  template <typename T>
-  static T AcquireRelease_CompareAndSwap(
-      T* addr, typename std::remove_reference<T>::type old_value,
-      typename std::remove_reference<T>::type new_value) {
-    STATIC_ASSERT(sizeof(T) <= sizeof(AtomicStorageType));
-    return cast_helper<T>::to_return_type(base::AcquireRelease_CompareAndSwap(
-        to_storage_addr(addr), cast_helper<T>::to_storage_type(old_value),
-        cast_helper<T>::to_storage_type(new_value)));
-  }
-
-  // Atomically sets bits selected by the mask to the given value.
-  // Returns false if the bits are already set as needed.
-  template <typename T>
-  static bool SetBits(T* addr, T bits, T mask) {
-    STATIC_ASSERT(sizeof(T) <= sizeof(AtomicStorageType));
-    DCHECK_EQ(bits & ~mask, static_cast<T>(0));
-    T old_value = Relaxed_Load(addr);
-    T new_value, old_value_before_cas;
-    do {
-      if ((old_value & mask) == bits) return false;
-      new_value = (old_value & ~mask) | bits;
-      old_value_before_cas = old_value;
-      old_value = Release_CompareAndSwap(addr, old_value, new_value);
-    } while (old_value != old_value_before_cas);
-    return true;
-  }
-
- private:
-  template <typename U>
-  struct cast_helper {
-    static AtomicStorageType to_storage_type(U value) {
-      return static_cast<AtomicStorageType>(value);
-    }
-    static U to_return_type(AtomicStorageType value) {
-      return static_cast<U>(value);
-    }
-  };
-
-  template <typename U>
-  struct cast_helper<U*> {
-    static AtomicStorageType to_storage_type(U* value) {
-      return reinterpret_cast<AtomicStorageType>(value);
-    }
-    static U* to_return_type(AtomicStorageType value) {
-      return reinterpret_cast<U*>(value);
-    }
-  };
-
-  template <typename T>
-  static AtomicStorageType* to_storage_addr(T* value) {
-    return reinterpret_cast<AtomicStorageType*>(value);
-  }
-  template <typename T>
-  static const AtomicStorageType* to_storage_addr(const T* value) {
-    return reinterpret_cast<const AtomicStorageType*>(value);
-  }
-};
-
-using AsAtomic8 = AsAtomicImpl<base::Atomic8>;
-using AsAtomic32 = AsAtomicImpl<base::Atomic32>;
-using AsAtomicWord = AsAtomicImpl<base::AtomicWord>;
-
-// This is similar to AsAtomicWord but it explicitly deletes functionality
-// provided atomic access to bit representation of stored values.
-template <typename TAtomicStorageType>
-class AsAtomicPointerImpl : public AsAtomicImpl<TAtomicStorageType> {
- public:
-  template <typename T>
-  static bool SetBits(T* addr, T bits, T mask) = delete;
-};
-
-using AsAtomicPointer = AsAtomicPointerImpl<base::AtomicWord>;
-
-template <typename T,
-          typename = typename std::enable_if<std::is_unsigned<T>::value>::type>
-inline void CheckedIncrement(std::atomic<T>* number, T amount) {
-  const T old = number->fetch_add(amount);
-  DCHECK_GE(old + amount, old);
-  USE(old);
-}
-
-template <typename T,
-          typename = typename std::enable_if<std::is_unsigned<T>::value>::type>
-inline void CheckedDecrement(std::atomic<T>* number, T amount) {
-  const T old = number->fetch_sub(amount);
-  DCHECK_GE(old, amount);
-  USE(old);
-}
-
-template <typename T>
-V8_INLINE std::atomic<T>* AsAtomicPtr(T* t) {
-  return reinterpret_cast<std::atomic<T>*>(t);
-}
-
-template <typename T>
-V8_INLINE const std::atomic<T>* AsAtomicPtr(const T* t) {
-  return reinterpret_cast<const std::atomic<T>*>(t);
-}
-
-}  // namespace base
-}  // namespace v8
-
-#endif  // V8_BASE_ATOMIC_UTILS_H_

package/pods/Headers/inspector/src/base/atomicops.h

@@ -1,332 +0,0 @@
-// Copyright 2010 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.
-
-// The routines exported by this module are subtle.  If you use them, even if
-// you get the code right, it will depend on careful reasoning about atomicity
-// and memory ordering; it will be less readable, and harder to maintain.  If
-// you plan to use these routines, you should have a good reason, such as solid
-// evidence that performance would otherwise suffer, or there being no
-// alternative.  You should assume only properties explicitly guaranteed by the
-// specifications in this file.  You are almost certainly _not_ writing code
-// just for the x86; if you assume x86 semantics, x86 hardware bugs and
-// implementations on other archtectures will cause your code to break.  If you
-// do not know what you are doing, avoid these routines, and use a Mutex.
-//
-// It is incorrect to make direct assignments to/from an atomic variable.
-// You should use one of the Load or Store routines.  The Relaxed  versions
-// are provided when no fences are needed:
-//   Relaxed_Store()
-//   Relaxed_Load()
-// Although there are currently no compiler enforcement, you are encouraged
-// to use these.
-//
-
-#ifndef V8_BASE_ATOMICOPS_H_
-#define V8_BASE_ATOMICOPS_H_
-
-#include <stdint.h>
-
-#include <atomic>
-
-// Small C++ header which defines implementation specific macros used to
-// identify the STL implementation.
-// - libc++: captures __config for _LIBCPP_VERSION
-// - libstdc++: captures bits/c++config.h for __GLIBCXX__
-#include <cstddef>
-
-#include "src/base/base-export.h"
-#include "src/base/build_config.h"
-#include "src/base/macros.h"
-
-#if defined(V8_OS_STARBOARD)
-#include "starboard/atomic.h"
-
-#if SB_API_VERSION < 10
-#error Your version of Starboard must support SbAtomic8 in order to use V8.
-#endif  // SB_API_VERSION < 10
-#endif  // V8_OS_STARBOARD
-
-namespace v8 {
-namespace base {
-
-#ifdef V8_OS_STARBOARD
-using Atomic8 = SbAtomic8;
-using Atomic16 = int16_t;
-using Atomic32 = SbAtomic32;
-#if SB_IS_64_BIT
-using Atomic64 = SbAtomic64;
-#endif
-#else
-using Atomic8 = char;
-using Atomic16 = int16_t;
-using Atomic32 = int32_t;
-#if defined(V8_HOST_ARCH_64_BIT)
-// We need to be able to go between Atomic64 and AtomicWord implicitly.  This
-// means Atomic64 and AtomicWord should be the same type on 64-bit.
-#if defined(__ILP32__)
-using Atomic64 = int64_t;
-#else
-using Atomic64 = intptr_t;
-#endif  // defined(__ILP32__)
-#endif  // defined(V8_HOST_ARCH_64_BIT)
-#endif  // V8_OS_STARBOARD
-
-// Use AtomicWord for a machine-sized pointer.  It will use the Atomic32 or
-// Atomic64 routines below, depending on your architecture.
-#if defined(V8_OS_STARBOARD)
-using AtomicWord = SbAtomicPtr;
-#else
-using AtomicWord = intptr_t;
-#endif
-
-namespace helper {
-template <typename T>
-volatile std::atomic<T>* to_std_atomic(volatile T* ptr) {
-  return reinterpret_cast<volatile std::atomic<T>*>(ptr);
-}
-template <typename T>
-volatile const std::atomic<T>* to_std_atomic_const(volatile const T* ptr) {
-  return reinterpret_cast<volatile const std::atomic<T>*>(ptr);
-}
-}  // namespace helper
-
-inline void SeqCst_MemoryFence() {
-  std::atomic_thread_fence(std::memory_order_seq_cst);
-}
-
-// Atomically execute:
-//   result = *ptr;
-//   if (result == old_value)
-//     *ptr = new_value;
-//   return result;
-//
-// I.e. replace |*ptr| with |new_value| if |*ptr| used to be |old_value|.
-// Always return the value of |*ptr| before the operation.
-// Acquire, Relaxed, Release correspond to standard C++ memory orders.
-inline Atomic8 Relaxed_CompareAndSwap(volatile Atomic8* ptr, Atomic8 old_value,
-                                      Atomic8 new_value) {
-  std::atomic_compare_exchange_strong_explicit(
-      helper::to_std_atomic(ptr), &old_value, new_value,
-      std::memory_order_relaxed, std::memory_order_relaxed);
-  return old_value;
-}
-
-inline Atomic16 Relaxed_CompareAndSwap(volatile Atomic16* ptr,
-                                       Atomic16 old_value, Atomic16 new_value) {
-  std::atomic_compare_exchange_strong_explicit(
-      helper::to_std_atomic(ptr), &old_value, new_value,
-      std::memory_order_relaxed, std::memory_order_relaxed);
-  return old_value;
-}
-
-inline Atomic32 Relaxed_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value, Atomic32 new_value) {
-  std::atomic_compare_exchange_strong_explicit(
-      helper::to_std_atomic(ptr), &old_value, new_value,
-      std::memory_order_relaxed, std::memory_order_relaxed);
-  return old_value;
-}
-
-inline Atomic32 Relaxed_AtomicExchange(volatile Atomic32* ptr,
-                                       Atomic32 new_value) {
-  return std::atomic_exchange_explicit(helper::to_std_atomic(ptr), new_value,
-                                       std::memory_order_relaxed);
-}
-
-inline Atomic32 Relaxed_AtomicIncrement(volatile Atomic32* ptr,
-                                        Atomic32 increment) {
-  return increment + std::atomic_fetch_add_explicit(helper::to_std_atomic(ptr),
-                                                    increment,
-                                                    std::memory_order_relaxed);
-}
-
-inline Atomic32 Acquire_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value, Atomic32 new_value) {
-  atomic_compare_exchange_strong_explicit(
-      helper::to_std_atomic(ptr), &old_value, new_value,
-      std::memory_order_acquire, std::memory_order_acquire);
-  return old_value;
-}
-
-inline Atomic8 Release_CompareAndSwap(volatile Atomic8* ptr, Atomic8 old_value,
-                                      Atomic8 new_value) {
-  bool result = atomic_compare_exchange_strong_explicit(
-      helper::to_std_atomic(ptr), &old_value, new_value,
-      std::memory_order_release, std::memory_order_relaxed);
-  USE(result);  // Make gcc compiler happy.
-  return old_value;
-}
-
-inline Atomic32 Release_CompareAndSwap(volatile Atomic32* ptr,
-                                       Atomic32 old_value, Atomic32 new_value) {
-  atomic_compare_exchange_strong_explicit(
-      helper::to_std_atomic(ptr), &old_value, new_value,
-      std::memory_order_release, std::memory_order_relaxed);
-  return old_value;
-}
-
-inline Atomic32 AcquireRelease_CompareAndSwap(volatile Atomic32* ptr,
-                                              Atomic32 old_value,
-                                              Atomic32 new_value) {
-  atomic_compare_exchange_strong_explicit(
-      helper::to_std_atomic(ptr), &old_value, new_value,
-      std::memory_order_acq_rel, std::memory_order_acquire);
-  return old_value;
-}
-
-inline void Relaxed_Store(volatile Atomic8* ptr, Atomic8 value) {
-  std::atomic_store_explicit(helper::to_std_atomic(ptr), value,
-                             std::memory_order_relaxed);
-}
-
-inline void Relaxed_Store(volatile Atomic16* ptr, Atomic16 value) {
-  std::atomic_store_explicit(helper::to_std_atomic(ptr), value,
-                             std::memory_order_relaxed);
-}
-
-inline void Relaxed_Store(volatile Atomic32* ptr, Atomic32 value) {
-  std::atomic_store_explicit(helper::to_std_atomic(ptr), value,
-                             std::memory_order_relaxed);
-}
-
-inline void Release_Store(volatile Atomic8* ptr, Atomic8 value) {
-  std::atomic_store_explicit(helper::to_std_atomic(ptr), value,
-                             std::memory_order_release);
-}
-
-inline void Release_Store(volatile Atomic32* ptr, Atomic32 value) {
-  std::atomic_store_explicit(helper::to_std_atomic(ptr), value,
-                             std::memory_order_release);
-}
-
-inline Atomic8 Relaxed_Load(volatile const Atomic8* ptr) {
-  return std::atomic_load_explicit(helper::to_std_atomic_const(ptr),
-                                   std::memory_order_relaxed);
-}
-
-inline Atomic16 Relaxed_Load(volatile const Atomic16* ptr) {
-  return std::atomic_load_explicit(helper::to_std_atomic_const(ptr),
-                                   std::memory_order_relaxed);
-}
-
-inline Atomic32 Relaxed_Load(volatile const Atomic32* ptr) {
-  return std::atomic_load_explicit(helper::to_std_atomic_const(ptr),
-                                   std::memory_order_relaxed);
-}
-
-inline Atomic8 Acquire_Load(volatile const Atomic8* ptr) {
-  return std::atomic_load_explicit(helper::to_std_atomic_const(ptr),
-                                   std::memory_order_acquire);
-}
-
-inline Atomic32 Acquire_Load(volatile const Atomic32* ptr) {
-  return std::atomic_load_explicit(helper::to_std_atomic_const(ptr),
-                                   std::memory_order_acquire);
-}
-
-#if defined(V8_HOST_ARCH_64_BIT)
-
-inline Atomic64 Relaxed_CompareAndSwap(volatile Atomic64* ptr,
-                                       Atomic64 old_value, Atomic64 new_value) {
-  std::atomic_compare_exchange_strong_explicit(
-      helper::to_std_atomic(ptr), &old_value, new_value,
-      std::memory_order_relaxed, std::memory_order_relaxed);
-  return old_value;
-}
-
-inline Atomic64 Relaxed_AtomicExchange(volatile Atomic64* ptr,
-                                       Atomic64 new_value) {
-  return std::atomic_exchange_explicit(helper::to_std_atomic(ptr), new_value,
-                                       std::memory_order_relaxed);
-}
-
-inline Atomic64 Relaxed_AtomicIncrement(volatile Atomic64* ptr,
-                                        Atomic64 increment) {
-  return increment + std::atomic_fetch_add_explicit(helper::to_std_atomic(ptr),
-                                                    increment,
-                                                    std::memory_order_relaxed);
-}
-
-inline Atomic64 Acquire_CompareAndSwap(volatile Atomic64* ptr,
-                                       Atomic64 old_value, Atomic64 new_value) {
-  std::atomic_compare_exchange_strong_explicit(
-      helper::to_std_atomic(ptr), &old_value, new_value,
-      std::memory_order_acquire, std::memory_order_acquire);
-  return old_value;
-}
-
-inline Atomic64 Release_CompareAndSwap(volatile Atomic64* ptr,
-                                       Atomic64 old_value, Atomic64 new_value) {
-  std::atomic_compare_exchange_strong_explicit(
-      helper::to_std_atomic(ptr), &old_value, new_value,
-      std::memory_order_release, std::memory_order_relaxed);
-  return old_value;
-}
-
-inline Atomic64 AcquireRelease_CompareAndSwap(volatile Atomic64* ptr,
-                                              Atomic64 old_value,
-                                              Atomic64 new_value) {
-  std::atomic_compare_exchange_strong_explicit(
-      helper::to_std_atomic(ptr), &old_value, new_value,
-      std::memory_order_acq_rel, std::memory_order_acquire);
-  return old_value;
-}
-
-inline void Relaxed_Store(volatile Atomic64* ptr, Atomic64 value) {
-  std::atomic_store_explicit(helper::to_std_atomic(ptr), value,
-                             std::memory_order_relaxed);
-}
-
-inline void Release_Store(volatile Atomic64* ptr, Atomic64 value) {
-  std::atomic_store_explicit(helper::to_std_atomic(ptr), value,
-                             std::memory_order_release);
-}
-
-inline Atomic64 Relaxed_Load(volatile const Atomic64* ptr) {
-  return std::atomic_load_explicit(helper::to_std_atomic_const(ptr),
-                                   std::memory_order_relaxed);
-}
-
-inline Atomic64 Acquire_Load(volatile const Atomic64* ptr) {
-  return std::atomic_load_explicit(helper::to_std_atomic_const(ptr),
-                                   std::memory_order_acquire);
-}
-
-#endif  // defined(V8_HOST_ARCH_64_BIT)
-
-inline void Relaxed_Memcpy(volatile Atomic8* dst, volatile const Atomic8* src,
-                           size_t bytes) {
-  constexpr size_t kAtomicWordSize = sizeof(AtomicWord);
-  while (bytes > 0 &&
-         !IsAligned(reinterpret_cast<uintptr_t>(dst), kAtomicWordSize)) {
-    Relaxed_Store(dst++, Relaxed_Load(src++));
-    --bytes;
-  }
-  if (IsAligned(reinterpret_cast<uintptr_t>(src), kAtomicWordSize) &&
-      IsAligned(reinterpret_cast<uintptr_t>(dst), kAtomicWordSize)) {
-    while (bytes >= kAtomicWordSize) {
-      Relaxed_Store(
-          reinterpret_cast<volatile AtomicWord*>(dst),
-          Relaxed_Load(reinterpret_cast<const volatile AtomicWord*>(src)));
-      dst += kAtomicWordSize;
-      src += kAtomicWordSize;
-      bytes -= kAtomicWordSize;
-    }
-  }
-  while (bytes > 0) {
-    Relaxed_Store(dst++, Relaxed_Load(src++));
-    --bytes;
-  }
-}
-
-}  // namespace base
-}  // namespace v8
-
-// On some platforms we need additional declarations to make
-// AtomicWord compatible with our other Atomic* types.
-#if defined(V8_OS_MACOSX) || defined(V8_OS_OPENBSD) || defined(V8_OS_AIX)
-#include "src/base/atomicops_internals_atomicword_compat.h"
-#endif
-
-#endif  // V8_BASE_ATOMICOPS_H_