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

package/pods/Headers/inspector/src/base/lazy-instance.h

@@ -1,258 +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.
-
-// The LazyInstance<Type, Traits> class manages a single instance of Type,
-// which will be lazily created on the first time it's accessed.  This class is
-// useful for places you would normally use a function-level static, but you
-// need to have guaranteed thread-safety.  The Type constructor will only ever
-// be called once, even if two threads are racing to create the object.  Get()
-// and Pointer() will always return the same, completely initialized instance.
-//
-// LazyInstance is completely thread safe, assuming that you create it safely.
-// The class was designed to be POD initialized, so it shouldn't require a
-// static constructor.  It really only makes sense to declare a LazyInstance as
-// a global variable using the LAZY_INSTANCE_INITIALIZER initializer.
-//
-// LazyInstance is similar to Singleton, except it does not have the singleton
-// property.  You can have multiple LazyInstance's of the same type, and each
-// will manage a unique instance.  It also preallocates the space for Type, as
-// to avoid allocating the Type instance on the heap.  This may help with the
-// performance of creating the instance, and reducing heap fragmentation.  This
-// requires that Type be a complete type so we can determine the size. See
-// notes for advanced users below for more explanations.
-//
-// Example usage:
-//   static LazyInstance<MyClass>::type my_instance = LAZY_INSTANCE_INITIALIZER;
-//   void SomeMethod() {
-//     my_instance.Get().SomeMethod();  // MyClass::SomeMethod()
-//
-//     MyClass* ptr = my_instance.Pointer();
-//     ptr->DoDoDo();  // MyClass::DoDoDo
-//   }
-//
-// Additionally you can override the way your instance is constructed by
-// providing your own trait:
-// Example usage:
-//   struct MyCreateTrait {
-//     static void Construct(void* allocated_ptr) {
-//       new (allocated_ptr) MyClass(/* extra parameters... */);
-//     }
-//   };
-//   static LazyInstance<MyClass, MyCreateTrait>::type my_instance =
-//      LAZY_INSTANCE_INITIALIZER;
-//
-// WARNINGS:
-// - This implementation of LazyInstance IS THREAD-SAFE by default. See
-//   SingleThreadInitOnceTrait if you don't care about thread safety.
-// - Lazy initialization comes with a cost. Make sure that you don't use it on
-//   critical path. Consider adding your initialization code to a function
-//   which is explicitly called once.
-//
-// Notes for advanced users:
-// LazyInstance can actually be used in two different ways:
-//
-// - "Static mode" which is the default mode since it is the most efficient
-//   (no extra heap allocation). In this mode, the instance is statically
-//   allocated (stored in the global data section at compile time).
-//   The macro LAZY_STATIC_INSTANCE_INITIALIZER (= LAZY_INSTANCE_INITIALIZER)
-//   must be used to initialize static lazy instances.
-//
-// - "Dynamic mode". In this mode, the instance is dynamically allocated and
-//   constructed (using new) by default. This mode is useful if you have to
-//   deal with some code already allocating the instance for you (e.g.
-//   OS::Mutex() which returns a new private OS-dependent subclass of Mutex).
-//   The macro LAZY_DYNAMIC_INSTANCE_INITIALIZER must be used to initialize
-//   dynamic lazy instances.
-
-#ifndef V8_BASE_LAZY_INSTANCE_H_
-#define V8_BASE_LAZY_INSTANCE_H_
-
-#include <type_traits>
-
-#include "src/base/macros.h"
-#include "src/base/once.h"
-
-namespace v8 {
-namespace base {
-
-#define LAZY_STATIC_INSTANCE_INITIALIZER { V8_ONCE_INIT, { {} } }
-#define LAZY_DYNAMIC_INSTANCE_INITIALIZER { V8_ONCE_INIT, 0 }
-
-// Default to static mode.
-#define LAZY_INSTANCE_INITIALIZER LAZY_STATIC_INSTANCE_INITIALIZER
-
-
-template <typename T>
-struct LeakyInstanceTrait {
-  static void Destroy(T* /* instance */) {}
-};
-
-
-// Traits that define how an instance is allocated and accessed.
-
-
-template <typename T>
-struct StaticallyAllocatedInstanceTrait {
-  using StorageType =
-      typename std::aligned_storage<sizeof(T), alignof(T)>::type;
-
-  static T* MutableInstance(StorageType* storage) {
-    return reinterpret_cast<T*>(storage);
-  }
-
-  template <typename ConstructTrait>
-  static void InitStorageUsingTrait(StorageType* storage) {
-    ConstructTrait::Construct(storage);
-  }
-};
-
-
-template <typename T>
-struct DynamicallyAllocatedInstanceTrait {
-  using StorageType = T*;
-
-  static T* MutableInstance(StorageType* storage) {
-    return *storage;
-  }
-
-  template <typename CreateTrait>
-  static void InitStorageUsingTrait(StorageType* storage) {
-    *storage = CreateTrait::Create();
-  }
-};
-
-
-template <typename T>
-struct DefaultConstructTrait {
-  // Constructs the provided object which was already allocated.
-  static void Construct(void* allocated_ptr) { new (allocated_ptr) T(); }
-};
-
-
-template <typename T>
-struct DefaultCreateTrait {
-  static T* Create() {
-    return new T();
-  }
-};
-
-
-struct ThreadSafeInitOnceTrait {
-  template <typename Function, typename Storage>
-  static void Init(OnceType* once, Function function, Storage storage) {
-    CallOnce(once, function, storage);
-  }
-};
-
-
-// Initialization trait for users who don't care about thread-safety.
-struct SingleThreadInitOnceTrait {
-  template <typename Function, typename Storage>
-  static void Init(OnceType* once, Function function, Storage storage) {
-    if (*once == ONCE_STATE_UNINITIALIZED) {
-      function(storage);
-      *once = ONCE_STATE_DONE;
-    }
-  }
-};
-
-
-// TODO(pliard): Handle instances destruction (using global destructors).
-template <typename T, typename AllocationTrait, typename CreateTrait,
-          typename InitOnceTrait, typename DestroyTrait  /* not used yet. */>
-struct LazyInstanceImpl {
- public:
-  using StorageType = typename AllocationTrait::StorageType;
-
- private:
-  static void InitInstance(void* storage) {
-    AllocationTrait::template InitStorageUsingTrait<CreateTrait>(
-        static_cast<StorageType*>(storage));
-  }
-
-  void Init() const {
-    InitOnceTrait::Init(&once_, &InitInstance, static_cast<void*>(&storage_));
-  }
-
- public:
-  T* Pointer() {
-    Init();
-    return AllocationTrait::MutableInstance(&storage_);
-  }
-
-  const T& Get() const {
-    Init();
-    return *AllocationTrait::MutableInstance(&storage_);
-  }
-
-  mutable OnceType once_;
-  // Note that the previous field, OnceType, is an AtomicWord which guarantees
-  // 4-byte alignment of the storage field below. If compiling with GCC (>4.2),
-  // the LAZY_ALIGN macro above will guarantee correctness for any alignment.
-  mutable StorageType storage_;
-};
-
-
-template <typename T,
-          typename CreateTrait = DefaultConstructTrait<T>,
-          typename InitOnceTrait = ThreadSafeInitOnceTrait,
-          typename DestroyTrait = LeakyInstanceTrait<T> >
-struct LazyStaticInstance {
-  using type = LazyInstanceImpl<T, StaticallyAllocatedInstanceTrait<T>,
-                                CreateTrait, InitOnceTrait, DestroyTrait>;
-};
-
-
-template <typename T,
-          typename CreateTrait = DefaultConstructTrait<T>,
-          typename InitOnceTrait = ThreadSafeInitOnceTrait,
-          typename DestroyTrait = LeakyInstanceTrait<T> >
-struct LazyInstance {
-  // A LazyInstance is a LazyStaticInstance.
-  using type = typename LazyStaticInstance<T, CreateTrait, InitOnceTrait,
-                                           DestroyTrait>::type;
-};
-
-
-template <typename T,
-          typename CreateTrait = DefaultCreateTrait<T>,
-          typename InitOnceTrait = ThreadSafeInitOnceTrait,
-          typename DestroyTrait = LeakyInstanceTrait<T> >
-struct LazyDynamicInstance {
-  using type = LazyInstanceImpl<T, DynamicallyAllocatedInstanceTrait<T>,
-                                CreateTrait, InitOnceTrait, DestroyTrait>;
-};
-
-// LeakyObject<T> wraps an object of type T, which is initialized in the
-// constructor but never destructed. Thus LeakyObject<T> is trivially
-// destructible and can be used in static (lazily initialized) variables.
-template <typename T>
-class LeakyObject {
- public:
-  template <typename... Args>
-  explicit LeakyObject(Args&&... args) {
-    new (&storage_) T(std::forward<Args>(args)...);
-  }
-
-  LeakyObject(const LeakyObject&) = delete;
-  LeakyObject& operator=(const LeakyObject&) = delete;
-
-  T* get() { return reinterpret_cast<T*>(&storage_); }
-
- private:
-  typename std::aligned_storage<sizeof(T), alignof(T)>::type storage_;
-};
-
-// Define a function which returns a pointer to a lazily initialized and never
-// destructed object of type T.
-#define DEFINE_LAZY_LEAKY_OBJECT_GETTER(T, FunctionName, ...) \
-  T* FunctionName() {                                         \
-    static ::v8::base::LeakyObject<T> object{__VA_ARGS__};    \
-    return object.get();                                      \
-  }
-
-}  // namespace base
-}  // namespace v8
-
-#endif  // V8_BASE_LAZY_INSTANCE_H_

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

@@ -1,417 +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_BASE_LOGGING_H_
-#define V8_BASE_LOGGING_H_
-
-#include <cstring>
-#include <sstream>
-#include <string>
-
-#include "src/base/base-export.h"
-#include "src/base/build_config.h"
-#include "src/base/compiler-specific.h"
-#include "src/base/immediate-crash.h"
-#include "src/base/template-utils.h"
-
-V8_BASE_EXPORT V8_NOINLINE void V8_Dcheck(const char* file, int line,
-                                          const char* message);
-
-#ifdef DEBUG
-// In debug, include file, line, and full error message for all
-// FATAL() calls.
-[[noreturn]] PRINTF_FORMAT(3, 4) V8_BASE_EXPORT V8_NOINLINE
-    void V8_Fatal(const char* file, int line, const char* format, ...);
-#define FATAL(...) V8_Fatal(__FILE__, __LINE__, __VA_ARGS__)
-
-#else
-[[noreturn]] PRINTF_FORMAT(1, 2) V8_BASE_EXPORT V8_NOINLINE
-    void V8_Fatal(const char* format, ...);
-#if !defined(OFFICIAL_BUILD)
-// In non-official release, include full error message, but drop file & line
-// numbers. It saves binary size to drop the |file| & |line| as opposed to just
-// passing in "", 0 for them.
-#define FATAL(...) V8_Fatal(__VA_ARGS__)
-#else
-// FATAL(msg) -> IMMEDIATE_CRASH()
-// FATAL(msg, ...) -> V8_Fatal(msg, ...)
-#define FATAL_HELPER(_7, _6, _5, _4, _3, _2, _1, _0, ...) _0
-#define FATAL_DISCARD_ARG(arg) IMMEDIATE_CRASH()
-#define FATAL(...)                                                            \
-  FATAL_HELPER(__VA_ARGS__, V8_Fatal, V8_Fatal, V8_Fatal, V8_Fatal, V8_Fatal, \
-               V8_Fatal, FATAL_DISCARD_ARG)                                   \
-  (__VA_ARGS__)
-#endif  // !defined(OFFICIAL_BUILD)
-#endif  // DEBUG
-
-#define UNIMPLEMENTED() FATAL("unimplemented code")
-#define UNREACHABLE() FATAL("unreachable code")
-
-namespace v8 {
-namespace base {
-
-class CheckMessageStream : public std::ostringstream {};
-
-// Overwrite the default function that prints a stack trace.
-V8_BASE_EXPORT void SetPrintStackTrace(void (*print_stack_trace_)());
-
-// Override the default function that handles DCHECKs.
-V8_BASE_EXPORT void SetDcheckFunction(void (*dcheck_Function)(const char*, int,
-                                                              const char*));
-
-// In official builds, assume all check failures can be debugged given just the
-// stack trace.
-#if !defined(DEBUG) && defined(OFFICIAL_BUILD)
-#define CHECK_FAILED_HANDLER(message) FATAL("ignored")
-#else
-#define CHECK_FAILED_HANDLER(message) FATAL("Check failed: %s.", message)
-#endif
-
-// CHECK dies with a fatal error if condition is not true.  It is *not*
-// controlled by DEBUG, so the check will be executed regardless of
-// compilation mode.
-//
-// We make sure CHECK et al. always evaluates their arguments, as
-// doing CHECK(FunctionWithSideEffect()) is a common idiom.
-#define CHECK_WITH_MSG(condition, message) \
-  do {                                     \
-    if (V8_UNLIKELY(!(condition))) {       \
-      CHECK_FAILED_HANDLER(message);       \
-    }                                      \
-  } while (false)
-#define CHECK(condition) CHECK_WITH_MSG(condition, #condition)
-
-#ifdef DEBUG
-
-#define DCHECK_WITH_MSG(condition, message)   \
-  do {                                        \
-    if (V8_UNLIKELY(!(condition))) {          \
-      V8_Dcheck(__FILE__, __LINE__, message); \
-    }                                         \
-  } while (false)
-#define DCHECK(condition) DCHECK_WITH_MSG(condition, #condition)
-
-// Helper macro for binary operators.
-// Don't use this macro directly in your code, use CHECK_EQ et al below.
-#define CHECK_OP(name, op, lhs, rhs)                                      \
-  do {                                                                    \
-    if (std::string* _msg = ::v8::base::Check##name##Impl<                \
-            typename ::v8::base::pass_value_or_ref<decltype(lhs)>::type,  \
-            typename ::v8::base::pass_value_or_ref<decltype(rhs)>::type>( \
-            (lhs), (rhs), #lhs " " #op " " #rhs)) {                       \
-      FATAL("Check failed: %s.", _msg->c_str());                          \
-      delete _msg;                                                        \
-    }                                                                     \
-  } while (false)
-
-#define DCHECK_OP(name, op, lhs, rhs)                                     \
-  do {                                                                    \
-    if (std::string* _msg = ::v8::base::Check##name##Impl<                \
-            typename ::v8::base::pass_value_or_ref<decltype(lhs)>::type,  \
-            typename ::v8::base::pass_value_or_ref<decltype(rhs)>::type>( \
-            (lhs), (rhs), #lhs " " #op " " #rhs)) {                       \
-      V8_Dcheck(__FILE__, __LINE__, _msg->c_str());                       \
-      delete _msg;                                                        \
-    }                                                                     \
-  } while (false)
-
-#else
-
-// Make all CHECK functions discard their log strings to reduce code
-// bloat for official release builds.
-
-#define CHECK_OP(name, op, lhs, rhs)                                         \
-  do {                                                                       \
-    bool _cmp = ::v8::base::Cmp##name##Impl<                                 \
-        typename ::v8::base::pass_value_or_ref<decltype(lhs)>::type,         \
-        typename ::v8::base::pass_value_or_ref<decltype(rhs)>::type>((lhs),  \
-                                                                     (rhs)); \
-    CHECK_WITH_MSG(_cmp, #lhs " " #op " " #rhs);                             \
-  } while (false)
-
-#define DCHECK_WITH_MSG(condition, msg) void(0);
-
-#endif
-
-namespace detail {
-template <typename... Ts>
-std::string PrintToString(Ts&&... ts) {
-  CheckMessageStream oss;
-  int unused_results[]{((oss << std::forward<Ts>(ts)), 0)...};
-  (void)unused_results;  // Avoid "unused variable" warning.
-  return oss.str();
-}
-
-template <typename T>
-auto GetUnderlyingEnumTypeForPrinting(T val) {
-  using underlying_t = typename std::underlying_type<T>::type;
-  // For single-byte enums, return a 16-bit integer to avoid printing the value
-  // as a character.
-  using int_t = typename std::conditional_t<
-      sizeof(underlying_t) != 1, underlying_t,
-      std::conditional_t<std::is_signed<underlying_t>::value, int16_t,
-                         uint16_t> >;
-  return static_cast<int_t>(static_cast<underlying_t>(val));
-}
-}  // namespace detail
-
-// Define PrintCheckOperand<T> for each T which defines operator<< for ostream.
-template <typename T>
-typename std::enable_if<
-    !std::is_function<typename std::remove_pointer<T>::type>::value &&
-        !std::is_enum<T>::value &&
-        has_output_operator<T, CheckMessageStream>::value,
-    std::string>::type
-PrintCheckOperand(T val) {
-  return detail::PrintToString(std::forward<T>(val));
-}
-
-// Provide an overload for functions and function pointers. Function pointers
-// don't implicitly convert to void* but do implicitly convert to bool, so
-// without this function pointers are always printed as 1 or 0. (MSVC isn't
-// standards-conforming here and converts function pointers to regular
-// pointers, so this is a no-op for MSVC.)
-template <typename T>
-typename std::enable_if<
-    std::is_function<typename std::remove_pointer<T>::type>::value,
-    std::string>::type
-PrintCheckOperand(T val) {
-  return PrintCheckOperand(reinterpret_cast<const void*>(val));
-}
-
-// Define PrintCheckOperand<T> for enums with an output operator.
-template <typename T>
-typename std::enable_if<std::is_enum<T>::value &&
-                            has_output_operator<T, CheckMessageStream>::value,
-                        std::string>::type
-PrintCheckOperand(T val) {
-  std::string val_str = detail::PrintToString(val);
-  std::string int_str =
-      detail::PrintToString(detail::GetUnderlyingEnumTypeForPrinting(val));
-  // Printing the original enum might have printed a single non-printable
-  // character. Ignore it in that case. Also ignore if it printed the same as
-  // the integral representation.
-  // TODO(clemensb): Can we somehow statically find out if the output operator
-  // is the default one, printing the integral value?
-  if ((val_str.length() == 1 && !std::isprint(val_str[0])) ||
-      val_str == int_str) {
-    return int_str;
-  }
-  return detail::PrintToString(val_str, " (", int_str, ")");
-}
-
-// Define PrintCheckOperand<T> for enums without an output operator.
-template <typename T>
-typename std::enable_if<std::is_enum<T>::value &&
-                            !has_output_operator<T, CheckMessageStream>::value,
-                        std::string>::type
-PrintCheckOperand(T val) {
-  return detail::PrintToString(detail::GetUnderlyingEnumTypeForPrinting(val));
-}
-
-// Define default PrintCheckOperand<T> for non-printable types.
-template <typename T>
-typename std::enable_if<!has_output_operator<T, CheckMessageStream>::value &&
-                            !std::is_enum<T>::value,
-                        std::string>::type
-PrintCheckOperand(T val) {
-  return "<unprintable>";
-}
-
-// Define specializations for character types, defined in logging.cc.
-#define DEFINE_PRINT_CHECK_OPERAND_CHAR(type)                       \
-  template <>                                                       \
-  V8_BASE_EXPORT std::string PrintCheckOperand<type>(type ch);      \
-  template <>                                                       \
-  V8_BASE_EXPORT std::string PrintCheckOperand<type*>(type * cstr); \
-  template <>                                                       \
-  V8_BASE_EXPORT std::string PrintCheckOperand<const type*>(const type* cstr);
-
-DEFINE_PRINT_CHECK_OPERAND_CHAR(char)
-DEFINE_PRINT_CHECK_OPERAND_CHAR(signed char)
-DEFINE_PRINT_CHECK_OPERAND_CHAR(unsigned char)
-#undef DEFINE_PRINT_CHECK_OPERAND_CHAR
-
-// Build the error message string.  This is separate from the "Impl"
-// function template because it is not performance critical and so can
-// be out of line, while the "Impl" code should be inline. Caller
-// takes ownership of the returned string.
-template <typename Lhs, typename Rhs>
-V8_NOINLINE std::string* MakeCheckOpString(Lhs lhs, Rhs rhs, char const* msg) {
-  std::string lhs_str = PrintCheckOperand<Lhs>(lhs);
-  std::string rhs_str = PrintCheckOperand<Rhs>(rhs);
-  CheckMessageStream ss;
-  ss << msg;
-  constexpr size_t kMaxInlineLength = 50;
-  if (lhs_str.size() <= kMaxInlineLength &&
-      rhs_str.size() <= kMaxInlineLength) {
-    ss << " (" << lhs_str << " vs. " << rhs_str << ")";
-  } else {
-    ss << "\n   " << lhs_str << "\n vs.\n   " << rhs_str << "\n";
-  }
-  return new std::string(ss.str());
-}
-
-// Commonly used instantiations of MakeCheckOpString<>. Explicitly instantiated
-// in logging.cc.
-#define EXPLICIT_CHECK_OP_INSTANTIATION(type)                                \
-  extern template V8_BASE_EXPORT std::string* MakeCheckOpString<type, type>( \
-      type, type, char const*);                                              \
-  extern template V8_BASE_EXPORT std::string PrintCheckOperand<type>(type);
-
-EXPLICIT_CHECK_OP_INSTANTIATION(int)
-EXPLICIT_CHECK_OP_INSTANTIATION(long)       // NOLINT(runtime/int)
-EXPLICIT_CHECK_OP_INSTANTIATION(long long)  // NOLINT(runtime/int)
-EXPLICIT_CHECK_OP_INSTANTIATION(unsigned int)
-EXPLICIT_CHECK_OP_INSTANTIATION(unsigned long)       // NOLINT(runtime/int)
-EXPLICIT_CHECK_OP_INSTANTIATION(unsigned long long)  // NOLINT(runtime/int)
-EXPLICIT_CHECK_OP_INSTANTIATION(void const*)
-#undef EXPLICIT_CHECK_OP_INSTANTIATION
-
-// comparison_underlying_type provides the underlying integral type of an enum,
-// or std::decay<T>::type if T is not an enum. Booleans are converted to
-// "unsigned int", to allow "unsigned int == bool" comparisons.
-template <typename T>
-struct comparison_underlying_type {
-  // std::underlying_type must only be used with enum types, thus use this
-  // {Dummy} type if the given type is not an enum.
-  enum Dummy {};
-  using decay = typename std::decay<T>::type;
-  static constexpr bool is_enum = std::is_enum<decay>::value;
-  using underlying = typename std::underlying_type<
-      typename std::conditional<is_enum, decay, Dummy>::type>::type;
-  using type_or_bool =
-      typename std::conditional<is_enum, underlying, decay>::type;
-  using type =
-      typename std::conditional<std::is_same<type_or_bool, bool>::value,
-                                unsigned int, type_or_bool>::type;
-};
-// Cast a value to its underlying type
-#define MAKE_UNDERLYING(Type, value) \
-  static_cast<typename comparison_underlying_type<Type>::type>(value)
-
-// is_signed_vs_unsigned::value is true if both types are integral, Lhs is
-// signed, and Rhs is unsigned. False in all other cases.
-template <typename Lhs, typename Rhs>
-struct is_signed_vs_unsigned {
-  using lhs_underlying = typename comparison_underlying_type<Lhs>::type;
-  using rhs_underlying = typename comparison_underlying_type<Rhs>::type;
-  static constexpr bool value = std::is_integral<lhs_underlying>::value &&
-                                std::is_integral<rhs_underlying>::value &&
-                                std::is_signed<lhs_underlying>::value &&
-                                std::is_unsigned<rhs_underlying>::value;
-};
-// Same thing, other way around: Lhs is unsigned, Rhs signed.
-template <typename Lhs, typename Rhs>
-struct is_unsigned_vs_signed : public is_signed_vs_unsigned<Rhs, Lhs> {};
-
-// Specialize the compare functions for signed vs. unsigned comparisons.
-// std::enable_if ensures that this template is only instantiable if both Lhs
-// and Rhs are integral types, and their signedness does not match.
-#define MAKE_UNSIGNED(Type, value)         \
-  static_cast<typename std::make_unsigned< \
-      typename comparison_underlying_type<Type>::type>::type>(value)
-#define DEFINE_SIGNED_MISMATCH_COMP(CHECK, NAME, IMPL)            \
-  template <typename Lhs, typename Rhs>                           \
-  V8_INLINE constexpr                                             \
-      typename std::enable_if<CHECK<Lhs, Rhs>::value, bool>::type \
-          Cmp##NAME##Impl(Lhs lhs, Rhs rhs) {                     \
-    return IMPL;                                                  \
-  }
-DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, EQ,
-                            lhs >= 0 && MAKE_UNSIGNED(Lhs, lhs) ==
-                                            MAKE_UNDERLYING(Rhs, rhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, LT,
-                            lhs < 0 || MAKE_UNSIGNED(Lhs, lhs) <
-                                           MAKE_UNDERLYING(Rhs, rhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, LE,
-                            lhs <= 0 || MAKE_UNSIGNED(Lhs, lhs) <=
-                                            MAKE_UNDERLYING(Rhs, rhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, NE, !CmpEQImpl(lhs, rhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, GT, !CmpLEImpl(lhs, rhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_signed_vs_unsigned, GE, !CmpLTImpl(lhs, rhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, EQ, CmpEQImpl(rhs, lhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, NE, CmpNEImpl(rhs, lhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, LT, CmpGTImpl(rhs, lhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, LE, CmpGEImpl(rhs, lhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, GT, CmpLTImpl(rhs, lhs))
-DEFINE_SIGNED_MISMATCH_COMP(is_unsigned_vs_signed, GE, CmpLEImpl(rhs, lhs))
-#undef MAKE_UNSIGNED
-#undef DEFINE_SIGNED_MISMATCH_COMP
-
-// Helper functions for CHECK_OP macro.
-// The (float, float) and (double, double) instantiations are explicitly
-// externalized to ensure proper 32/64-bit comparisons on x86.
-// The Cmp##NAME##Impl function is only instantiable if one of the two types is
-// not integral or their signedness matches (i.e. whenever no specialization is
-// required, see above). Otherwise it is disabled by the enable_if construct,
-// and the compiler will pick a specialization from above.
-#define DEFINE_CHECK_OP_IMPL(NAME, op)                                        \
-  template <typename Lhs, typename Rhs>                                       \
-  V8_INLINE constexpr                                                         \
-      typename std::enable_if<!is_signed_vs_unsigned<Lhs, Rhs>::value &&      \
-                                  !is_unsigned_vs_signed<Lhs, Rhs>::value,    \
-                              bool>::type Cmp##NAME##Impl(Lhs lhs, Rhs rhs) { \
-    return lhs op rhs;                                                        \
-  }                                                                           \
-  template <typename Lhs, typename Rhs>                                       \
-  V8_INLINE constexpr std::string* Check##NAME##Impl(Lhs lhs, Rhs rhs,        \
-                                                     char const* msg) {       \
-    using LhsPassT = typename pass_value_or_ref<Lhs>::type;                   \
-    using RhsPassT = typename pass_value_or_ref<Rhs>::type;                   \
-    bool cmp = Cmp##NAME##Impl<LhsPassT, RhsPassT>(lhs, rhs);                 \
-    return V8_LIKELY(cmp)                                                     \
-               ? nullptr                                                      \
-               : MakeCheckOpString<LhsPassT, RhsPassT>(lhs, rhs, msg);        \
-  }
-DEFINE_CHECK_OP_IMPL(EQ, ==)
-DEFINE_CHECK_OP_IMPL(NE, !=)
-DEFINE_CHECK_OP_IMPL(LE, <=)
-DEFINE_CHECK_OP_IMPL(LT, < )
-DEFINE_CHECK_OP_IMPL(GE, >=)
-DEFINE_CHECK_OP_IMPL(GT, > )
-#undef DEFINE_CHECK_OP_IMPL
-
-#define CHECK_EQ(lhs, rhs) CHECK_OP(EQ, ==, lhs, rhs)
-#define CHECK_NE(lhs, rhs) CHECK_OP(NE, !=, lhs, rhs)
-#define CHECK_LE(lhs, rhs) CHECK_OP(LE, <=, lhs, rhs)
-#define CHECK_LT(lhs, rhs) CHECK_OP(LT, <, lhs, rhs)
-#define CHECK_GE(lhs, rhs) CHECK_OP(GE, >=, lhs, rhs)
-#define CHECK_GT(lhs, rhs) CHECK_OP(GT, >, lhs, rhs)
-#define CHECK_NULL(val) CHECK((val) == nullptr)
-#define CHECK_NOT_NULL(val) CHECK((val) != nullptr)
-#define CHECK_IMPLIES(lhs, rhs) \
-  CHECK_WITH_MSG(!(lhs) || (rhs), #lhs " implies " #rhs)
-
-}  // namespace base
-}  // namespace v8
-
-
-// The DCHECK macro is equivalent to CHECK except that it only
-// generates code in debug builds.
-#ifdef DEBUG
-#define DCHECK_EQ(lhs, rhs) DCHECK_OP(EQ, ==, lhs, rhs)
-#define DCHECK_NE(lhs, rhs) DCHECK_OP(NE, !=, lhs, rhs)
-#define DCHECK_GT(lhs, rhs) DCHECK_OP(GT, >, lhs, rhs)
-#define DCHECK_GE(lhs, rhs) DCHECK_OP(GE, >=, lhs, rhs)
-#define DCHECK_LT(lhs, rhs) DCHECK_OP(LT, <, lhs, rhs)
-#define DCHECK_LE(lhs, rhs) DCHECK_OP(LE, <=, lhs, rhs)
-#define DCHECK_NULL(val) DCHECK((val) == nullptr)
-#define DCHECK_NOT_NULL(val) DCHECK((val) != nullptr)
-#define DCHECK_IMPLIES(lhs, rhs) \
-  DCHECK_WITH_MSG(!(lhs) || (rhs), #lhs " implies " #rhs)
-#else
-#define DCHECK(condition)      ((void) 0)
-#define DCHECK_EQ(v1, v2)      ((void) 0)
-#define DCHECK_NE(v1, v2)      ((void) 0)
-#define DCHECK_GT(v1, v2)      ((void) 0)
-#define DCHECK_GE(v1, v2)      ((void) 0)
-#define DCHECK_LT(v1, v2)      ((void) 0)
-#define DCHECK_LE(v1, v2)      ((void) 0)
-#define DCHECK_NULL(val)       ((void) 0)
-#define DCHECK_NOT_NULL(val)   ((void) 0)
-#define DCHECK_IMPLIES(v1, v2) ((void) 0)
-#endif
-
-#endif  // V8_BASE_LOGGING_H_