@triniwiz/nativescript-masonkit 1.0.0-alpha.11 → 1.0.0-alpha.13

package/src-native/pods/Headers/inspector/src/base/atomicops_internals_atomicword_compat.h

@@ -1,89 +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.
-
-// This file is an internal atomic implementation, use atomicops.h instead.
-
-#ifndef V8_BASE_ATOMICOPS_INTERNALS_ATOMICWORD_COMPAT_H_
-#define V8_BASE_ATOMICOPS_INTERNALS_ATOMICWORD_COMPAT_H_
-
-// AtomicWord is a synonym for intptr_t, and Atomic32 is a synonym for int32,
-// which in turn means int. On some LP32 platforms, intptr_t is an int, but
-// on others, it's a long. When AtomicWord and Atomic32 are based on different
-// fundamental types, their pointers are incompatible.
-//
-// This file defines function overloads to allow both AtomicWord and Atomic32
-// data to be used with this interface.
-//
-// On LP64 platforms, AtomicWord and Atomic64 are both always long,
-// so this problem doesn't occur.
-
-#if !defined(V8_HOST_ARCH_64_BIT)
-
-namespace v8 {
-namespace base {
-
-inline AtomicWord Relaxed_CompareAndSwap(volatile AtomicWord* ptr,
-                                         AtomicWord old_value,
-                                         AtomicWord new_value) {
-  return Relaxed_CompareAndSwap(reinterpret_cast<volatile Atomic32*>(ptr),
-                                old_value, new_value);
-}
-
-inline AtomicWord Relaxed_AtomicExchange(volatile AtomicWord* ptr,
-                                         AtomicWord new_value) {
-  return Relaxed_AtomicExchange(reinterpret_cast<volatile Atomic32*>(ptr),
-                                new_value);
-}
-
-inline AtomicWord Relaxed_AtomicIncrement(volatile AtomicWord* ptr,
-                                          AtomicWord increment) {
-  return Relaxed_AtomicIncrement(reinterpret_cast<volatile Atomic32*>(ptr),
-                                 increment);
-}
-
-inline AtomicWord Acquire_CompareAndSwap(volatile AtomicWord* ptr,
-                                         AtomicWord old_value,
-                                         AtomicWord new_value) {
-  return v8::base::Acquire_CompareAndSwap(
-      reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value);
-}
-
-inline AtomicWord Release_CompareAndSwap(volatile AtomicWord* ptr,
-                                         AtomicWord old_value,
-                                         AtomicWord new_value) {
-  return v8::base::Release_CompareAndSwap(
-      reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value);
-}
-
-inline AtomicWord AcquireRelease_CompareAndSwap(volatile AtomicWord* ptr,
-                                                AtomicWord old_value,
-                                                AtomicWord new_value) {
-  return v8::base::AcquireRelease_CompareAndSwap(
-      reinterpret_cast<volatile Atomic32*>(ptr), old_value, new_value);
-}
-
-inline void Relaxed_Store(volatile AtomicWord* ptr, AtomicWord value) {
-  Relaxed_Store(reinterpret_cast<volatile Atomic32*>(ptr), value);
-}
-
-inline void Release_Store(volatile AtomicWord* ptr, AtomicWord value) {
-  return v8::base::Release_Store(
-      reinterpret_cast<volatile Atomic32*>(ptr), value);
-}
-
-inline AtomicWord Relaxed_Load(volatile const AtomicWord* ptr) {
-  return Relaxed_Load(reinterpret_cast<volatile const Atomic32*>(ptr));
-}
-
-inline AtomicWord Acquire_Load(volatile const AtomicWord* ptr) {
-  return v8::base::Acquire_Load(
-      reinterpret_cast<volatile const Atomic32*>(ptr));
-}
-
-}  // namespace base
-}  // namespace v8
-
-#endif  // !defined(V8_HOST_ARCH_64_BIT)
-
-#endif  // V8_BASE_ATOMICOPS_INTERNALS_ATOMICWORD_COMPAT_H_

package/src-native/pods/Headers/inspector/src/base/base-export.h

@@ -1,31 +0,0 @@
-// Copyright 2016 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_BASE_EXPORT_H_
-#define V8_BASE_BASE_EXPORT_H_
-
-#include "include/v8config.h"
-
-#if V8_OS_WIN
-
-#ifdef BUILDING_V8_BASE_SHARED
-#define V8_BASE_EXPORT __declspec(dllexport)
-#elif USING_V8_BASE_SHARED
-#define V8_BASE_EXPORT __declspec(dllimport)
-#else
-#define V8_BASE_EXPORT
-#endif  // BUILDING_V8_BASE_SHARED
-
-#else  // !V8_OS_WIN
-
-// Setup for Linux shared library export.
-#ifdef BUILDING_V8_BASE_SHARED
-#define V8_BASE_EXPORT __attribute__((visibility("default")))
-#else
-#define V8_BASE_EXPORT
-#endif
-
-#endif  // V8_OS_WIN
-
-#endif  // V8_BASE_BASE_EXPORT_H_

package/src-native/pods/Headers/inspector/src/base/bits.h

@@ -1,343 +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_BASE_BITS_H_
-#define V8_BASE_BITS_H_
-
-#include <stdint.h>
-#include <type_traits>
-
-#include "src/base/base-export.h"
-#include "src/base/macros.h"
-#if V8_CC_MSVC
-#include <intrin.h>
-#endif
-#if V8_OS_WIN32
-#include "src/base/win32-headers.h"
-#endif
-
-namespace v8 {
-namespace base {
-namespace bits {
-
-// CountPopulation(value) returns the number of bits set in |value|.
-template <typename T>
-constexpr inline
-    typename std::enable_if<std::is_unsigned<T>::value && sizeof(T) <= 8,
-                            unsigned>::type
-    CountPopulation(T value) {
-  STATIC_ASSERT(sizeof(T) <= 8);
-#if V8_HAS_BUILTIN_POPCOUNT
-  return sizeof(T) == 8 ? __builtin_popcountll(static_cast<uint64_t>(value))
-                        : __builtin_popcount(static_cast<uint32_t>(value));
-#else
-  // Fall back to divide-and-conquer popcount (see "Hacker's Delight" by Henry
-  // S. Warren, Jr.), chapter 5-1.
-  constexpr uint64_t mask[] = {0x5555555555555555, 0x3333333333333333,
-                               0x0f0f0f0f0f0f0f0f};
-  // Start with 64 buckets of 1 bits, holding values from [0,1].
-  value = ((value >> 1) & mask[0]) + (value & mask[0]);
-  // Having 32 buckets of 2 bits, holding values from [0,2] now.
-  value = ((value >> 2) & mask[1]) + (value & mask[1]);
-  // Having 16 buckets of 4 bits, holding values from [0,4] now.
-  value = ((value >> 4) & mask[2]) + (value & mask[2]);
-  // Having 8 buckets of 8 bits, holding values from [0,8] now.
-  // From this point on, the buckets are bigger than the number of bits
-  // required to hold the values, and the buckets are bigger the maximum
-  // result, so there's no need to mask value anymore, since there's no
-  // more risk of overflow between buckets.
-  if (sizeof(T) > 1) value = (value >> (sizeof(T) > 1 ? 8 : 0)) + value;
-  // Having 4 buckets of 16 bits, holding values from [0,16] now.
-  if (sizeof(T) > 2) value = (value >> (sizeof(T) > 2 ? 16 : 0)) + value;
-  // Having 2 buckets of 32 bits, holding values from [0,32] now.
-  if (sizeof(T) > 4) value = (value >> (sizeof(T) > 4 ? 32 : 0)) + value;
-  // Having 1 buckets of 64 bits, holding values from [0,64] now.
-  return static_cast<unsigned>(value & 0xff);
-#endif
-}
-
-// ReverseBits(value) returns |value| in reverse bit order.
-template <typename T>
-T ReverseBits(T value) {
-  STATIC_ASSERT((sizeof(value) == 1) || (sizeof(value) == 2) ||
-                (sizeof(value) == 4) || (sizeof(value) == 8));
-  T result = 0;
-  for (unsigned i = 0; i < (sizeof(value) * 8); i++) {
-    result = (result << 1) | (value & 1);
-    value >>= 1;
-  }
-  return result;
-}
-
-// CountLeadingZeros(value) returns the number of zero bits following the most
-// significant 1 bit in |value| if |value| is non-zero, otherwise it returns
-// {sizeof(T) * 8}.
-template <typename T, unsigned bits = sizeof(T) * 8>
-inline constexpr
-    typename std::enable_if<std::is_unsigned<T>::value && sizeof(T) <= 8,
-                            unsigned>::type
-    CountLeadingZeros(T value) {
-  static_assert(bits > 0, "invalid instantiation");
-#if V8_HAS_BUILTIN_CLZ
-  return value == 0
-             ? bits
-             : bits == 64
-                   ? __builtin_clzll(static_cast<uint64_t>(value))
-                   : __builtin_clz(static_cast<uint32_t>(value)) - (32 - bits);
-#else
-  // Binary search algorithm taken from "Hacker's Delight" (by Henry S. Warren,
-  // Jr.), figures 5-11 and 5-12.
-  if (bits == 1) return static_cast<unsigned>(value) ^ 1;
-  T upper_half = value >> (bits / 2);
-  T next_value = upper_half != 0 ? upper_half : value;
-  unsigned add = upper_half != 0 ? 0 : bits / 2;
-  constexpr unsigned next_bits = bits == 1 ? 1 : bits / 2;
-  return CountLeadingZeros<T, next_bits>(next_value) + add;
-#endif
-}
-
-inline constexpr unsigned CountLeadingZeros32(uint32_t value) {
-  return CountLeadingZeros(value);
-}
-inline constexpr unsigned CountLeadingZeros64(uint64_t value) {
-  return CountLeadingZeros(value);
-}
-
-// CountTrailingZeros(value) returns the number of zero bits preceding the
-// least significant 1 bit in |value| if |value| is non-zero, otherwise it
-// returns {sizeof(T) * 8}.
-// See CountTrailingZerosNonZero for an optimized version for the case that
-// |value| is guaranteed to be non-zero.
-template <typename T, unsigned bits = sizeof(T) * 8>
-inline constexpr
-    typename std::enable_if<std::is_integral<T>::value && sizeof(T) <= 8,
-                            unsigned>::type
-    CountTrailingZeros(T value) {
-#if V8_HAS_BUILTIN_CTZ
-  return value == 0 ? bits
-                    : bits == 64 ? __builtin_ctzll(static_cast<uint64_t>(value))
-                                 : __builtin_ctz(static_cast<uint32_t>(value));
-#else
-  // Fall back to popcount (see "Hacker's Delight" by Henry S. Warren, Jr.),
-  // chapter 5-4. On x64, since is faster than counting in a loop and faster
-  // than doing binary search.
-  using U = typename std::make_unsigned<T>::type;
-  U u = value;
-  return CountPopulation(static_cast<U>(~u & (u - 1u)));
-#endif
-}
-
-inline constexpr unsigned CountTrailingZeros32(uint32_t value) {
-  return CountTrailingZeros(value);
-}
-inline constexpr unsigned CountTrailingZeros64(uint64_t value) {
-  return CountTrailingZeros(value);
-}
-
-// CountTrailingZerosNonZero(value) returns the number of zero bits preceding
-// the least significant 1 bit in |value| if |value| is non-zero, otherwise the
-// behavior is undefined.
-// See CountTrailingZeros for an alternative version that allows |value| == 0.
-template <typename T, unsigned bits = sizeof(T) * 8>
-inline constexpr
-    typename std::enable_if<std::is_integral<T>::value && sizeof(T) <= 8,
-                            unsigned>::type
-    CountTrailingZerosNonZero(T value) {
-  DCHECK_NE(0, value);
-#if V8_HAS_BUILTIN_CTZ
-  return bits == 64 ? __builtin_ctzll(static_cast<uint64_t>(value))
-                    : __builtin_ctz(static_cast<uint32_t>(value));
-#else
-  return CountTrailingZeros<T, bits>(value);
-#endif
-}
-
-// Returns true iff |value| is a power of 2.
-template <typename T,
-          typename = typename std::enable_if<std::is_integral<T>::value ||
-                                             std::is_enum<T>::value>::type>
-constexpr inline bool IsPowerOfTwo(T value) {
-  return value > 0 && (value & (value - 1)) == 0;
-}
-
-// Identical to {CountTrailingZeros}, but only works for powers of 2.
-template <typename T,
-          typename = typename std::enable_if<std::is_integral<T>::value>::type>
-inline constexpr int WhichPowerOfTwo(T value) {
-  DCHECK(IsPowerOfTwo(value));
-#if V8_HAS_BUILTIN_CTZ
-  STATIC_ASSERT(sizeof(T) <= 8);
-  return sizeof(T) == 8 ? __builtin_ctzll(static_cast<uint64_t>(value))
-                        : __builtin_ctz(static_cast<uint32_t>(value));
-#else
-  // Fall back to popcount (see "Hacker's Delight" by Henry S. Warren, Jr.),
-  // chapter 5-4. On x64, since is faster than counting in a loop and faster
-  // than doing binary search.
-  using U = typename std::make_unsigned<T>::type;
-  U u = value;
-  return CountPopulation(static_cast<U>(u - 1));
-#endif
-}
-
-// RoundUpToPowerOfTwo32(value) returns the smallest power of two which is
-// greater than or equal to |value|. If you pass in a |value| that is already a
-// power of two, it is returned as is. |value| must be less than or equal to
-// 0x80000000u. Uses computation based on leading zeros if we have compiler
-// support for that. Falls back to the implementation from "Hacker's Delight" by
-// Henry S. Warren, Jr., figure 3-3, page 48, where the function is called clp2.
-V8_BASE_EXPORT uint32_t RoundUpToPowerOfTwo32(uint32_t value);
-// Same for 64 bit integers. |value| must be <= 2^63
-V8_BASE_EXPORT uint64_t RoundUpToPowerOfTwo64(uint64_t value);
-// Same for size_t integers.
-inline size_t RoundUpToPowerOfTwo(size_t value) {
-  if (sizeof(size_t) == sizeof(uint64_t)) {
-    return RoundUpToPowerOfTwo64(value);
-  } else {
-    return RoundUpToPowerOfTwo32(value);
-  }
-}
-
-// RoundDownToPowerOfTwo32(value) returns the greatest power of two which is
-// less than or equal to |value|. If you pass in a |value| that is already a
-// power of two, it is returned as is.
-inline uint32_t RoundDownToPowerOfTwo32(uint32_t value) {
-  if (value > 0x80000000u) return 0x80000000u;
-  uint32_t result = RoundUpToPowerOfTwo32(value);
-  if (result > value) result >>= 1;
-  return result;
-}
-
-
-// Precondition: 0 <= shift < 32
-inline constexpr uint32_t RotateRight32(uint32_t value, uint32_t shift) {
-  return (value >> shift) | (value << ((32 - shift) & 31));
-}
-
-// Precondition: 0 <= shift < 32
-inline constexpr uint32_t RotateLeft32(uint32_t value, uint32_t shift) {
-  return (value << shift) | (value >> ((32 - shift) & 31));
-}
-
-// Precondition: 0 <= shift < 64
-inline constexpr uint64_t RotateRight64(uint64_t value, uint64_t shift) {
-  return (value >> shift) | (value << ((64 - shift) & 63));
-}
-
-// Precondition: 0 <= shift < 64
-inline constexpr uint64_t RotateLeft64(uint64_t value, uint64_t shift) {
-  return (value << shift) | (value >> ((64 - shift) & 63));
-}
-
-// SignedAddOverflow32(lhs,rhs,val) performs a signed summation of |lhs| and
-// |rhs| and stores the result into the variable pointed to by |val| and
-// returns true if the signed summation resulted in an overflow.
-inline bool SignedAddOverflow32(int32_t lhs, int32_t rhs, int32_t* val) {
-#if V8_HAS_BUILTIN_SADD_OVERFLOW
-  return __builtin_sadd_overflow(lhs, rhs, val);
-#else
-  uint32_t res = static_cast<uint32_t>(lhs) + static_cast<uint32_t>(rhs);
-  *val = bit_cast<int32_t>(res);
-  return ((res ^ lhs) & (res ^ rhs) & (1U << 31)) != 0;
-#endif
-}
-
-
-// SignedSubOverflow32(lhs,rhs,val) performs a signed subtraction of |lhs| and
-// |rhs| and stores the result into the variable pointed to by |val| and
-// returns true if the signed subtraction resulted in an overflow.
-inline bool SignedSubOverflow32(int32_t lhs, int32_t rhs, int32_t* val) {
-#if V8_HAS_BUILTIN_SSUB_OVERFLOW
-  return __builtin_ssub_overflow(lhs, rhs, val);
-#else
-  uint32_t res = static_cast<uint32_t>(lhs) - static_cast<uint32_t>(rhs);
-  *val = bit_cast<int32_t>(res);
-  return ((res ^ lhs) & (res ^ ~rhs) & (1U << 31)) != 0;
-#endif
-}
-
-// SignedMulOverflow32(lhs,rhs,val) performs a signed multiplication of |lhs|
-// and |rhs| and stores the result into the variable pointed to by |val| and
-// returns true if the signed multiplication resulted in an overflow.
-V8_BASE_EXPORT bool SignedMulOverflow32(int32_t lhs, int32_t rhs, int32_t* val);
-
-// SignedAddOverflow64(lhs,rhs,val) performs a signed summation of |lhs| and
-// |rhs| and stores the result into the variable pointed to by |val| and
-// returns true if the signed summation resulted in an overflow.
-inline bool SignedAddOverflow64(int64_t lhs, int64_t rhs, int64_t* val) {
-  uint64_t res = static_cast<uint64_t>(lhs) + static_cast<uint64_t>(rhs);
-  *val = bit_cast<int64_t>(res);
-  return ((res ^ lhs) & (res ^ rhs) & (1ULL << 63)) != 0;
-}
-
-
-// SignedSubOverflow64(lhs,rhs,val) performs a signed subtraction of |lhs| and
-// |rhs| and stores the result into the variable pointed to by |val| and
-// returns true if the signed subtraction resulted in an overflow.
-inline bool SignedSubOverflow64(int64_t lhs, int64_t rhs, int64_t* val) {
-  uint64_t res = static_cast<uint64_t>(lhs) - static_cast<uint64_t>(rhs);
-  *val = bit_cast<int64_t>(res);
-  return ((res ^ lhs) & (res ^ ~rhs) & (1ULL << 63)) != 0;
-}
-
-// SignedMulHigh32(lhs, rhs) multiplies two signed 32-bit values |lhs| and
-// |rhs|, extracts the most significant 32 bits of the result, and returns
-// those.
-V8_BASE_EXPORT int32_t SignedMulHigh32(int32_t lhs, int32_t rhs);
-
-// SignedMulHighAndAdd32(lhs, rhs, acc) multiplies two signed 32-bit values
-// |lhs| and |rhs|, extracts the most significant 32 bits of the result, and
-// adds the accumulate value |acc|.
-V8_BASE_EXPORT int32_t SignedMulHighAndAdd32(int32_t lhs, int32_t rhs,
-                                             int32_t acc);
-
-// SignedDiv32(lhs, rhs) divides |lhs| by |rhs| and returns the quotient
-// truncated to int32. If |rhs| is zero, then zero is returned. If |lhs|
-// is minint and |rhs| is -1, it returns minint.
-V8_BASE_EXPORT int32_t SignedDiv32(int32_t lhs, int32_t rhs);
-
-// SignedMod32(lhs, rhs) divides |lhs| by |rhs| and returns the remainder
-// truncated to int32. If either |rhs| is zero or |lhs| is minint and |rhs|
-// is -1, it returns zero.
-V8_BASE_EXPORT int32_t SignedMod32(int32_t lhs, int32_t rhs);
-
-// UnsignedAddOverflow32(lhs,rhs,val) performs an unsigned summation of |lhs|
-// and |rhs| and stores the result into the variable pointed to by |val| and
-// returns true if the unsigned summation resulted in an overflow.
-inline bool UnsignedAddOverflow32(uint32_t lhs, uint32_t rhs, uint32_t* val) {
-#if V8_HAS_BUILTIN_SADD_OVERFLOW
-  return __builtin_uadd_overflow(lhs, rhs, val);
-#else
-  *val = lhs + rhs;
-  return *val < (lhs | rhs);
-#endif
-}
-
-
-// UnsignedDiv32(lhs, rhs) divides |lhs| by |rhs| and returns the quotient
-// truncated to uint32. If |rhs| is zero, then zero is returned.
-inline uint32_t UnsignedDiv32(uint32_t lhs, uint32_t rhs) {
-  return rhs ? lhs / rhs : 0u;
-}
-
-
-// UnsignedMod32(lhs, rhs) divides |lhs| by |rhs| and returns the remainder
-// truncated to uint32. If |rhs| is zero, then zero is returned.
-inline uint32_t UnsignedMod32(uint32_t lhs, uint32_t rhs) {
-  return rhs ? lhs % rhs : 0u;
-}
-
-
-// SignedSaturatedAdd64(lhs, rhs) adds |lhs| and |rhs|,
-// checks and returns the result.
-V8_BASE_EXPORT int64_t SignedSaturatedAdd64(int64_t lhs, int64_t rhs);
-
-// SignedSaturatedSub64(lhs, rhs) subtracts |lhs| by |rhs|,
-// checks and returns the result.
-V8_BASE_EXPORT int64_t SignedSaturatedSub64(int64_t lhs, int64_t rhs);
-
-}  // namespace bits
-}  // namespace base
-}  // namespace v8
-
-#endif  // V8_BASE_BITS_H_

package/src-native/pods/Headers/inspector/src/base/build_config.h

@@ -1,234 +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_BASE_BUILD_CONFIG_H_
-#define V8_BASE_BUILD_CONFIG_H_
-
-#include "include/v8config.h"
-
-// Processor architecture detection.  For more info on what's defined, see:
-//   http://msdn.microsoft.com/en-us/library/b0084kay.aspx
-//   http://www.agner.org/optimize/calling_conventions.pdf
-//   or with gcc, run: "echo | gcc -E -dM -"
-#if defined(_M_X64) || defined(__x86_64__)
-#define V8_HOST_ARCH_X64 1
-#if defined(__x86_64__) && __SIZEOF_POINTER__ == 4  // Check for x32.
-#define V8_HOST_ARCH_32_BIT 1
-#else
-#define V8_HOST_ARCH_64_BIT 1
-#endif
-#elif defined(_M_IX86) || defined(__i386__)
-#define V8_HOST_ARCH_IA32 1
-#define V8_HOST_ARCH_32_BIT 1
-#elif defined(__AARCH64EL__) || defined(_M_ARM64)
-#define V8_HOST_ARCH_ARM64 1
-#define V8_HOST_ARCH_64_BIT 1
-#elif defined(__ARMEL__)
-#define V8_HOST_ARCH_ARM 1
-#define V8_HOST_ARCH_32_BIT 1
-#elif defined(__mips64)
-#define V8_HOST_ARCH_MIPS64 1
-#define V8_HOST_ARCH_64_BIT 1
-#elif defined(__MIPSEB__) || defined(__MIPSEL__)
-#define V8_HOST_ARCH_MIPS 1
-#define V8_HOST_ARCH_32_BIT 1
-#elif defined(__PPC64__) || defined(_ARCH_PPC64)
-#define V8_HOST_ARCH_PPC64 1
-#define V8_HOST_ARCH_64_BIT 1
-#elif defined(__PPC__) || defined(_ARCH_PPC)
-#define V8_HOST_ARCH_PPC 1
-#define V8_HOST_ARCH_32_BIT 1
-#elif defined(__s390__) || defined(__s390x__)
-#define V8_HOST_ARCH_S390 1
-#if defined(__s390x__)
-#define V8_HOST_ARCH_64_BIT 1
-#else
-#define V8_HOST_ARCH_32_BIT 1
-#endif
-#elif defined(__riscv) || defined(__riscv__)
-#if __riscv_xlen == 64
-#define V8_HOST_ARCH_RISCV64 1
-#define V8_HOST_ARCH_64_BIT 1
-#else
-#error "Cannot detect Riscv's bitwidth"
-#endif
-#else
-#error "Host architecture was not detected as supported by v8"
-#endif
-
-#if defined(__ARM_ARCH_7A__) || defined(__ARM_ARCH_7R__) || \
-    defined(__ARM_ARCH_7__)
-#define CAN_USE_ARMV7_INSTRUCTIONS 1
-#ifdef __ARM_ARCH_EXT_IDIV__
-#define CAN_USE_SUDIV 1
-#endif
-#ifndef CAN_USE_VFP3_INSTRUCTIONS
-#define CAN_USE_VFP3_INSTRUCTIONS 1
-#endif
-#endif
-
-#if defined(__ARM_ARCH_8A__)
-#define CAN_USE_ARMV7_INSTRUCTIONS 1
-#define CAN_USE_SUDIV 1
-#define CAN_USE_ARMV8_INSTRUCTIONS 1
-#ifndef CAN_USE_VFP3_INSTRUCTIONS
-#define CAN_USE_VFP3_INSTRUCTIONS 1
-#endif
-#endif
-
-// Target architecture detection. This may be set externally. If not, detect
-// in the same way as the host architecture, that is, target the native
-// environment as presented by the compiler.
-#if !V8_TARGET_ARCH_X64 && !V8_TARGET_ARCH_IA32 && !V8_TARGET_ARCH_ARM &&      \
-    !V8_TARGET_ARCH_ARM64 && !V8_TARGET_ARCH_MIPS && !V8_TARGET_ARCH_MIPS64 && \
-    !V8_TARGET_ARCH_PPC && !V8_TARGET_ARCH_PPC64 && !V8_TARGET_ARCH_S390 &&    \
-    !V8_TARGET_ARCH_RISCV64
-#if defined(_M_X64) || defined(__x86_64__)
-#define V8_TARGET_ARCH_X64 1
-#elif defined(_M_IX86) || defined(__i386__)
-#define V8_TARGET_ARCH_IA32 1
-#elif defined(__AARCH64EL__) || defined(_M_ARM64)
-#define V8_TARGET_ARCH_ARM64 1
-#elif defined(__ARMEL__)
-#define V8_TARGET_ARCH_ARM 1
-#elif defined(__mips64)
-#define V8_TARGET_ARCH_MIPS64 1
-#elif defined(__MIPSEB__) || defined(__MIPSEL__)
-#define V8_TARGET_ARCH_MIPS 1
-#elif defined(_ARCH_PPC64)
-#define V8_TARGET_ARCH_PPC64 1
-#elif defined(_ARCH_PPC)
-#define V8_TARGET_ARCH_PPC 1
-#elif defined(__riscv) || defined(__riscv__)
-#if __riscv_xlen == 64
-#define V8_TARGET_ARCH_RISCV64 1
-#endif
-#else
-#error Target architecture was not detected as supported by v8
-#endif
-#endif
-
-// Determine architecture pointer size.
-#if V8_TARGET_ARCH_IA32
-#define V8_TARGET_ARCH_32_BIT 1
-#elif V8_TARGET_ARCH_X64
-#if !V8_TARGET_ARCH_32_BIT && !V8_TARGET_ARCH_64_BIT
-#if defined(__x86_64__) && __SIZEOF_POINTER__ == 4  // Check for x32.
-#define V8_TARGET_ARCH_32_BIT 1
-#else
-#define V8_TARGET_ARCH_64_BIT 1
-#endif
-#endif
-#elif V8_TARGET_ARCH_ARM
-#define V8_TARGET_ARCH_32_BIT 1
-#elif V8_TARGET_ARCH_ARM64
-#define V8_TARGET_ARCH_64_BIT 1
-#elif V8_TARGET_ARCH_MIPS
-#define V8_TARGET_ARCH_32_BIT 1
-#elif V8_TARGET_ARCH_MIPS64
-#define V8_TARGET_ARCH_64_BIT 1
-#elif V8_TARGET_ARCH_PPC
-#define V8_TARGET_ARCH_32_BIT 1
-#elif V8_TARGET_ARCH_PPC64
-#define V8_TARGET_ARCH_64_BIT 1
-#elif V8_TARGET_ARCH_S390
-#if V8_TARGET_ARCH_S390X
-#define V8_TARGET_ARCH_64_BIT 1
-#else
-#define V8_TARGET_ARCH_32_BIT 1
-#endif
-#elif V8_TARGET_ARCH_RISCV64
-#define V8_TARGET_ARCH_64_BIT 1
-#else
-#error Unknown target architecture pointer size
-#endif
-
-// Check for supported combinations of host and target architectures.
-#if V8_TARGET_ARCH_IA32 && !V8_HOST_ARCH_IA32
-#error Target architecture ia32 is only supported on ia32 host
-#endif
-#if (V8_TARGET_ARCH_X64 && V8_TARGET_ARCH_64_BIT && \
-     !(V8_HOST_ARCH_X64 && V8_HOST_ARCH_64_BIT))
-#error Target architecture x64 is only supported on x64 host
-#endif
-#if (V8_TARGET_ARCH_X64 && V8_TARGET_ARCH_32_BIT && \
-     !(V8_HOST_ARCH_X64 && V8_HOST_ARCH_32_BIT))
-#error Target architecture x32 is only supported on x64 host with x32 support
-#endif
-#if (V8_TARGET_ARCH_ARM && !(V8_HOST_ARCH_IA32 || V8_HOST_ARCH_ARM))
-#error Target architecture arm is only supported on arm and ia32 host
-#endif
-#if (V8_TARGET_ARCH_ARM64 && !(V8_HOST_ARCH_X64 || V8_HOST_ARCH_ARM64))
-#error Target architecture arm64 is only supported on arm64 and x64 host
-#endif
-#if (V8_TARGET_ARCH_MIPS && !(V8_HOST_ARCH_IA32 || V8_HOST_ARCH_MIPS))
-#error Target architecture mips is only supported on mips and ia32 host
-#endif
-#if (V8_TARGET_ARCH_MIPS64 && !(V8_HOST_ARCH_X64 || V8_HOST_ARCH_MIPS64))
-#error Target architecture mips64 is only supported on mips64 and x64 host
-#endif
-#if (V8_TARGET_ARCH_RISCV64 && !(V8_HOST_ARCH_X64 || V8_HOST_ARCH_RISCV64))
-#error Target architecture riscv64 is only supported on riscv64 and x64 host
-#endif
-
-// Determine architecture endianness.
-#if V8_TARGET_ARCH_IA32
-#define V8_TARGET_LITTLE_ENDIAN 1
-#elif V8_TARGET_ARCH_X64
-#define V8_TARGET_LITTLE_ENDIAN 1
-#elif V8_TARGET_ARCH_ARM
-#define V8_TARGET_LITTLE_ENDIAN 1
-#elif V8_TARGET_ARCH_ARM64
-#define V8_TARGET_LITTLE_ENDIAN 1
-#elif V8_TARGET_ARCH_MIPS
-#if defined(__MIPSEB__)
-#define V8_TARGET_BIG_ENDIAN 1
-#else
-#define V8_TARGET_LITTLE_ENDIAN 1
-#endif
-#elif V8_TARGET_ARCH_MIPS64
-#if defined(__MIPSEB__) || defined(V8_TARGET_ARCH_MIPS64_BE)
-#define V8_TARGET_BIG_ENDIAN 1
-#else
-#define V8_TARGET_LITTLE_ENDIAN 1
-#endif
-#elif __BIG_ENDIAN__  // FOR PPCGR on AIX
-#define V8_TARGET_BIG_ENDIAN 1
-#elif V8_TARGET_ARCH_PPC_LE
-#define V8_TARGET_LITTLE_ENDIAN 1
-#elif V8_TARGET_ARCH_PPC_BE
-#define V8_TARGET_BIG_ENDIAN 1
-#elif V8_TARGET_ARCH_S390
-#if V8_TARGET_ARCH_S390_LE_SIM
-#define V8_TARGET_LITTLE_ENDIAN 1
-#else
-#define V8_TARGET_BIG_ENDIAN 1
-#endif
-#elif V8_TARGET_ARCH_RISCV64
-#define V8_TARGET_LITTLE_ENDIAN 1
-#else
-#error Unknown target architecture endianness
-#endif
-
-#if defined(V8_TARGET_ARCH_IA32) || defined(V8_TARGET_ARCH_X64)
-#define V8_TARGET_ARCH_STORES_RETURN_ADDRESS_ON_STACK true
-#else
-#define V8_TARGET_ARCH_STORES_RETURN_ADDRESS_ON_STACK false
-#endif
-constexpr int kReturnAddressStackSlotCount =
-    V8_TARGET_ARCH_STORES_RETURN_ADDRESS_ON_STACK ? 1 : 0;
-
-// Number of bits to represent the page size for paged spaces.
-#if defined(V8_TARGET_ARCH_PPC) || defined(V8_TARGET_ARCH_PPC64)
-// PPC has large (64KB) physical pages.
-const int kPageSizeBits = 19;
-#else
-// Arm64 supports up to 64k OS pages on Linux, however 4k pages are more common
-// so we keep the V8 page size at 256k. Nonetheless, we need to make sure we
-// don't decrease it further in the future due to reserving 3 OS pages for every
-// executable V8 page.
-const int kPageSizeBits = 18;
-#endif
-
-#endif  // V8_BASE_BUILD_CONFIG_H_