@triniwiz/nativescript-masonkit 1.0.0-alpha.9 → 1.0.0-beta.1

package/src-native/pods/Headers/inspector/src/base/compiler-specific.h

@@ -1,136 +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_COMPILER_SPECIFIC_H_
-#define V8_BASE_COMPILER_SPECIFIC_H_
-
-#include "include/v8config.h"
-
-// Annotate a  using ALLOW_UNUSED_TYPE = or function indicating it's ok if it's
-// not used. Use like:
-//    using Bar = Foo;
-#if V8_HAS_ATTRIBUTE_UNUSED
-#define ALLOW_UNUSED_TYPE __attribute__((unused))
-#else
-#define ALLOW_UNUSED_TYPE
-#endif
-
-// Tell the compiler a function is using a printf-style format string.
-// |format_param| is the one-based index of the format string parameter;
-// |dots_param| is the one-based index of the "..." parameter.
-// For v*printf functions (which take a va_list), pass 0 for dots_param.
-// (This is undocumented but matches what the system C headers do.)
-#if defined(__GNUC__)
-#define PRINTF_FORMAT(format_param, dots_param) \
-  __attribute__((format(printf, format_param, dots_param)))
-#else
-#define PRINTF_FORMAT(format_param, dots_param)
-#endif
-
-// The C++ standard requires that static const members have an out-of-class
-// definition (in a single compilation unit), but MSVC chokes on this (when
-// language extensions, which are required, are enabled). (You're only likely to
-// notice the need for a definition if you take the address of the member or,
-// more commonly, pass it to a function that takes it as a reference argument --
-// probably an STL function.) This macro makes MSVC do the right thing. See
-// http://msdn.microsoft.com/en-us/library/34h23df8(v=vs.100).aspx for more
-// information. Use like:
-//
-// In .h file:
-//   struct Foo {
-//     static const int kBar = 5;
-//   };
-//
-// In .cc file:
-//   STATIC_CONST_MEMBER_DEFINITION const int Foo::kBar;
-#if V8_HAS_DECLSPEC_SELECTANY
-#define STATIC_CONST_MEMBER_DEFINITION __declspec(selectany)
-#else
-#define STATIC_CONST_MEMBER_DEFINITION
-#endif
-
-#if V8_CC_MSVC
-
-#include <sal.h>
-
-// Macros for suppressing and disabling warnings on MSVC.
-//
-// Warning numbers are enumerated at:
-// http://msdn.microsoft.com/en-us/library/8x5x43k7(VS.80).aspx
-//
-// The warning pragma:
-// http://msdn.microsoft.com/en-us/library/2c8f766e(VS.80).aspx
-//
-// Using __pragma instead of #pragma inside macros:
-// http://msdn.microsoft.com/en-us/library/d9x1s805.aspx
-
-// MSVC_SUPPRESS_WARNING disables warning |n| for the remainder of the line and
-// for the next line of the source file.
-#define MSVC_SUPPRESS_WARNING(n) __pragma(warning(suppress : n))
-
-// Allows exporting a class that inherits from a non-exported base class.
-// This uses suppress instead of push/pop because the delimiter after the
-// declaration (either "," or "{") has to be placed before the pop macro.
-//
-// Example usage:
-// class EXPORT_API Foo : NON_EXPORTED_BASE(public Bar) {
-//
-// MSVC Compiler warning C4275:
-// non dll-interface class 'Bar' used as base for dll-interface class 'Foo'.
-// Note that this is intended to be used only when no access to the base class'
-// static data is done through derived classes or inline methods. For more info,
-// see http://msdn.microsoft.com/en-us/library/3tdb471s(VS.80).aspx
-#define NON_EXPORTED_BASE(code) \
-  MSVC_SUPPRESS_WARNING(4275)   \
-  code
-
-#else  // Not MSVC
-
-#define MSVC_SUPPRESS_WARNING(n)
-#define NON_EXPORTED_BASE(code) code
-
-#endif  // V8_CC_MSVC
-
-// Allowing the use of noexcept by removing the keyword on older compilers that
-// do not support adding noexcept to default members.
-// Disabled on MSVC because constructors of standard containers are not noexcept
-// there.
-#if ((!defined(V8_CC_GNU) && !defined(V8_CC_MSVC) &&                      \
-      !defined(V8_TARGET_ARCH_MIPS) && !defined(V8_TARGET_ARCH_MIPS64) && \
-      !defined(V8_TARGET_ARCH_PPC) && !defined(V8_TARGET_ARCH_PPC64) &&   \
-      !defined(V8_TARGET_ARCH_RISCV64)) ||                                \
-     (defined(__clang__) && __cplusplus > 201300L))
-#define V8_NOEXCEPT noexcept
-#else
-#define V8_NOEXCEPT
-#endif
-
-// Specify memory alignment for structs, classes, etc.
-// Use like:
-//   class ALIGNAS(16) MyClass { ... }
-//   ALIGNAS(16) int array[4];
-//
-// In most places you can use the C++11 keyword "alignas", which is preferred.
-//
-// But compilers have trouble mixing __attribute__((...)) syntax with
-// alignas(...) syntax.
-//
-// Doesn't work in clang or gcc:
-//   struct alignas(16) __attribute__((packed)) S { char c; };
-// Works in clang but not gcc:
-//   struct __attribute__((packed)) alignas(16) S2 { char c; };
-// Works in clang and gcc:
-//   struct alignas(16) S3 { char c; } __attribute__((packed));
-//
-// There are also some attributes that must be specified *before* a class
-// definition: visibility (used for exporting functions/classes) is one of
-// these attributes. This means that it is not possible to use alignas() with a
-// class that is marked as exported.
-#if defined(V8_CC_MSVC)
-#define ALIGNAS(byte_alignment) __declspec(align(byte_alignment))
-#else
-#define ALIGNAS(byte_alignment) __attribute__((aligned(byte_alignment)))
-#endif
-
-#endif  // V8_BASE_COMPILER_SPECIFIC_H_

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

@@ -1,163 +0,0 @@
-// Copyright 2017 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_EXPORT_TEMPLATE_H_
-#define V8_BASE_EXPORT_TEMPLATE_H_
-
-// Synopsis
-//
-// This header provides macros for using FOO_EXPORT macros with explicit
-// template instantiation declarations and definitions.
-// Generally, the FOO_EXPORT macros are used at declarations,
-// and GCC requires them to be used at explicit instantiation declarations,
-// but MSVC requires __declspec(dllexport) to be used at the explicit
-// instantiation definitions instead.
-
-// Usage
-//
-// In a header file, write:
-//
-//   extern template class EXPORT_TEMPLATE_DECLARE(FOO_EXPORT) foo<bar>;
-//
-// In a source file, write:
-//
-//   template class EXPORT_TEMPLATE_DEFINE(FOO_EXPORT) foo<bar>;
-
-// Implementation notes
-//
-// The implementation of this header uses some subtle macro semantics to
-// detect what the provided FOO_EXPORT value was defined as and then
-// to dispatch to appropriate macro definitions.  Unfortunately,
-// MSVC's C preprocessor is rather non-compliant and requires special
-// care to make it work.
-//
-// Issue 1.
-//
-//   #define F(x)
-//   F()
-//
-// MSVC emits warning C4003 ("not enough actual parameters for macro
-// 'F'), even though it's a valid macro invocation.  This affects the
-// macros below that take just an "export" parameter, because export
-// may be empty.
-//
-// As a workaround, we can add a dummy parameter and arguments:
-//
-//   #define F(x,_)
-//   F(,)
-//
-// Issue 2.
-//
-//   #define F(x) G##x
-//   #define Gj() ok
-//   F(j())
-//
-// The correct replacement for "F(j())" is "ok", but MSVC replaces it
-// with "Gj()".  As a workaround, we can pass the result to an
-// identity macro to force MSVC to look for replacements again.  (This
-// is why EXPORT_TEMPLATE_STYLE_3 exists.)
-
-#define EXPORT_TEMPLATE_DECLARE(export) \
-  EXPORT_TEMPLATE_INVOKE(DECLARE, EXPORT_TEMPLATE_STYLE(export, ), export)
-#define EXPORT_TEMPLATE_DEFINE(export) \
-  EXPORT_TEMPLATE_INVOKE(DEFINE, EXPORT_TEMPLATE_STYLE(export, ), export)
-
-// INVOKE is an internal helper macro to perform parameter replacements
-// and token pasting to chain invoke another macro.  E.g.,
-//     EXPORT_TEMPLATE_INVOKE(DECLARE, DEFAULT, FOO_EXPORT)
-// will export to call
-//     EXPORT_TEMPLATE_DECLARE_DEFAULT(FOO_EXPORT, )
-// (but with FOO_EXPORT expanded too).
-#define EXPORT_TEMPLATE_INVOKE(which, style, export) \
-  EXPORT_TEMPLATE_INVOKE_2(which, style, export)
-#define EXPORT_TEMPLATE_INVOKE_2(which, style, export) \
-  EXPORT_TEMPLATE_##which##_##style(export, )
-
-// Default style is to apply the FOO_EXPORT macro at declaration sites.
-#define EXPORT_TEMPLATE_DECLARE_DEFAULT(export, _) export
-#define EXPORT_TEMPLATE_DEFINE_DEFAULT(export, _)
-
-// The "MSVC hack" style is used when FOO_EXPORT is defined
-// as __declspec(dllexport), which MSVC requires to be used at
-// definition sites instead.
-#define EXPORT_TEMPLATE_DECLARE_MSVC_HACK(export, _)
-#define EXPORT_TEMPLATE_DEFINE_MSVC_HACK(export, _) export
-
-// EXPORT_TEMPLATE_STYLE is an internal helper macro that identifies which
-// export style needs to be used for the provided FOO_EXPORT macro definition.
-// "", "__attribute__(...)", and "__declspec(dllimport)" are mapped
-// to "DEFAULT"; while "__declspec(dllexport)" is mapped to "MSVC_HACK".
-//
-// It's implemented with token pasting to transform the __attribute__ and
-// __declspec annotations into macro invocations.  E.g., if FOO_EXPORT is
-// defined as "__declspec(dllimport)", it undergoes the following sequence of
-// macro substitutions:
-//     EXPORT_TEMPLATE_STYLE(FOO_EXPORT, )
-//     EXPORT_TEMPLATE_STYLE_2(__declspec(dllimport), )
-//     EXPORT_TEMPLATE_STYLE_3(EXPORT_TEMPLATE_STYLE_MATCH__declspec(dllimport))
-//     EXPORT_TEMPLATE_STYLE_MATCH__declspec(dllimport)
-//     EXPORT_TEMPLATE_STYLE_MATCH_DECLSPEC_dllimport
-//     DEFAULT
-#define EXPORT_TEMPLATE_STYLE(export, _) EXPORT_TEMPLATE_STYLE_2(export, )
-#define EXPORT_TEMPLATE_STYLE_2(export, _) \
-  EXPORT_TEMPLATE_STYLE_3(                 \
-      EXPORT_TEMPLATE_STYLE_MATCH_foj3FJo5StF0OvIzl7oMxA##export)
-#define EXPORT_TEMPLATE_STYLE_3(style) style
-
-// Internal helper macros for EXPORT_TEMPLATE_STYLE.
-//
-// XXX: C++ reserves all identifiers containing "__" for the implementation,
-// but "__attribute__" and "__declspec" already contain "__" and the token-paste
-// operator can only add characters; not remove them.  To minimize the risk of
-// conflict with implementations, we include "foj3FJo5StF0OvIzl7oMxA" (a random
-// 128-bit string, encoded in Base64) in the macro name.
-#define EXPORT_TEMPLATE_STYLE_MATCH_foj3FJo5StF0OvIzl7oMxA DEFAULT
-#define EXPORT_TEMPLATE_STYLE_MATCH_foj3FJo5StF0OvIzl7oMxA__attribute__(...) \
-  DEFAULT
-#define EXPORT_TEMPLATE_STYLE_MATCH_foj3FJo5StF0OvIzl7oMxA__declspec(arg) \
-  EXPORT_TEMPLATE_STYLE_MATCH_DECLSPEC_##arg
-
-// Internal helper macros for EXPORT_TEMPLATE_STYLE.
-#define EXPORT_TEMPLATE_STYLE_MATCH_DECLSPEC_dllexport MSVC_HACK
-#define EXPORT_TEMPLATE_STYLE_MATCH_DECLSPEC_dllimport DEFAULT
-
-// Sanity checks.
-//
-// EXPORT_TEMPLATE_TEST uses the same macro invocation pattern as
-// EXPORT_TEMPLATE_DECLARE and EXPORT_TEMPLATE_DEFINE do to check that they're
-// working correctly.  When they're working correctly, the sequence of macro
-// replacements should go something like:
-//
-//     EXPORT_TEMPLATE_TEST(DEFAULT, __declspec(dllimport));
-//
-//     static_assert(EXPORT_TEMPLATE_INVOKE(TEST_DEFAULT,
-//         EXPORT_TEMPLATE_STYLE(__declspec(dllimport), ),
-//         __declspec(dllimport)), "__declspec(dllimport)");
-//
-//     static_assert(EXPORT_TEMPLATE_INVOKE(TEST_DEFAULT,
-//         DEFAULT, __declspec(dllimport)), "__declspec(dllimport)");
-//
-//     static_assert(EXPORT_TEMPLATE_TEST_DEFAULT_DEFAULT(
-//         __declspec(dllimport)), "__declspec(dllimport)");
-//
-//     static_assert(true, "__declspec(dllimport)");
-//
-// When they're not working correctly, a syntax error should occur instead.
-#define EXPORT_TEMPLATE_TEST(want, export)                                 \
-  static_assert(EXPORT_TEMPLATE_INVOKE(                                    \
-                    TEST_##want, EXPORT_TEMPLATE_STYLE(export, ), export), \
-                #export)
-#define EXPORT_TEMPLATE_TEST_DEFAULT_DEFAULT(...) true
-#define EXPORT_TEMPLATE_TEST_MSVC_HACK_MSVC_HACK(...) true
-
-EXPORT_TEMPLATE_TEST(DEFAULT, );
-EXPORT_TEMPLATE_TEST(DEFAULT, __attribute__((visibility("default"))));
-EXPORT_TEMPLATE_TEST(MSVC_HACK, __declspec(dllexport));
-EXPORT_TEMPLATE_TEST(DEFAULT, __declspec(dllimport));
-
-#undef EXPORT_TEMPLATE_TEST
-#undef EXPORT_TEMPLATE_TEST_DEFAULT_DEFAULT
-#undef EXPORT_TEMPLATE_TEST_MSVC_HACK_MSVC_HACK
-
-#endif  // V8_BASE_EXPORT_TEMPLATE_H_

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

@@ -1,130 +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_FLAGS_H_
-#define V8_BASE_FLAGS_H_
-
-#include <cstddef>
-
-#include "src/base/compiler-specific.h"
-
-namespace v8 {
-namespace base {
-
-// The Flags class provides a type-safe way of storing OR-combinations of enum
-// values. The Flags<T, S> class is a template class, where T is an enum type,
-// and S is the underlying storage type (usually int).
-//
-// The traditional C++ approach for storing OR-combinations of enum values is to
-// use an int or unsigned int variable. The inconvenience with this approach is
-// that there's no type checking at all; any enum value can be OR'd with any
-// other enum value and passed on to a function that takes an int or unsigned
-// int.
-template <typename T, typename S = int>
-class Flags final {
- public:
-  using flag_type = T;
-  using mask_type = S;
-
-  constexpr Flags() : mask_(0) {}
-  constexpr Flags(flag_type flag)  // NOLINT(runtime/explicit)
-      : mask_(static_cast<S>(flag)) {}
-  constexpr explicit Flags(mask_type mask) : mask_(static_cast<S>(mask)) {}
-
-  constexpr bool operator==(flag_type flag) const {
-    return mask_ == static_cast<S>(flag);
-  }
-  constexpr bool operator!=(flag_type flag) const {
-    return mask_ != static_cast<S>(flag);
-  }
-
-  Flags& operator&=(const Flags& flags) {
-    mask_ &= flags.mask_;
-    return *this;
-  }
-  Flags& operator|=(const Flags& flags) {
-    mask_ |= flags.mask_;
-    return *this;
-  }
-  Flags& operator^=(const Flags& flags) {
-    mask_ ^= flags.mask_;
-    return *this;
-  }
-
-  constexpr Flags operator&(const Flags& flags) const {
-    return Flags(mask_ & flags.mask_);
-  }
-  constexpr Flags operator|(const Flags& flags) const {
-    return Flags(mask_ | flags.mask_);
-  }
-  constexpr Flags operator^(const Flags& flags) const {
-    return Flags(mask_ ^ flags.mask_);
-  }
-
-  Flags& operator&=(flag_type flag) { return operator&=(Flags(flag)); }
-  Flags& operator|=(flag_type flag) { return operator|=(Flags(flag)); }
-  Flags& operator^=(flag_type flag) { return operator^=(Flags(flag)); }
-
-  constexpr Flags operator&(flag_type flag) const {
-    return operator&(Flags(flag));
-  }
-  constexpr Flags operator|(flag_type flag) const {
-    return operator|(Flags(flag));
-  }
-  constexpr Flags operator^(flag_type flag) const {
-    return operator^(Flags(flag));
-  }
-
-  constexpr Flags operator~() const { return Flags(~mask_); }
-
-  constexpr operator mask_type() const { return mask_; }
-  constexpr bool operator!() const { return !mask_; }
-
-  Flags without(flag_type flag) { return *this & (~Flags(flag)); }
-
-  friend size_t hash_value(const Flags& flags) { return flags.mask_; }
-
- private:
-  mask_type mask_;
-};
-
-#define DEFINE_OPERATORS_FOR_FLAGS(Type)                                   \
-  ALLOW_UNUSED_TYPE V8_WARN_UNUSED_RESULT inline constexpr Type operator&( \
-      Type::flag_type lhs, Type::flag_type rhs) {                          \
-    return Type(lhs) & rhs;                                                \
-  }                                                                        \
-  ALLOW_UNUSED_TYPE V8_WARN_UNUSED_RESULT inline constexpr Type operator&( \
-      Type::flag_type lhs, const Type& rhs) {                              \
-    return rhs & lhs;                                                      \
-  }                                                                        \
-  ALLOW_UNUSED_TYPE inline void operator&(Type::flag_type lhs,             \
-                                          Type::mask_type rhs) {}          \
-  ALLOW_UNUSED_TYPE V8_WARN_UNUSED_RESULT inline constexpr Type operator|( \
-      Type::flag_type lhs, Type::flag_type rhs) {                          \
-    return Type(lhs) | rhs;                                                \
-  }                                                                        \
-  ALLOW_UNUSED_TYPE V8_WARN_UNUSED_RESULT inline constexpr Type operator|( \
-      Type::flag_type lhs, const Type& rhs) {                              \
-    return rhs | lhs;                                                      \
-  }                                                                        \
-  ALLOW_UNUSED_TYPE inline void operator|(Type::flag_type lhs,             \
-                                          Type::mask_type rhs) {}          \
-  ALLOW_UNUSED_TYPE V8_WARN_UNUSED_RESULT inline constexpr Type operator^( \
-      Type::flag_type lhs, Type::flag_type rhs) {                          \
-    return Type(lhs) ^ rhs;                                                \
-  }                                                                        \
-  ALLOW_UNUSED_TYPE V8_WARN_UNUSED_RESULT inline constexpr Type operator^( \
-      Type::flag_type lhs, const Type& rhs) {                              \
-    return rhs ^ lhs;                                                      \
-  }                                                                        \
-  ALLOW_UNUSED_TYPE inline void operator^(Type::flag_type lhs,             \
-                                          Type::mask_type rhs) {}          \
-  ALLOW_UNUSED_TYPE inline constexpr Type operator~(Type::flag_type val) { \
-    return ~Type(val);                                                     \
-  }
-
-}  // namespace base
-}  // namespace v8
-
-#endif  // V8_BASE_FLAGS_H_

package/src-native/pods/Headers/inspector/src/base/immediate-crash.h

@@ -1,162 +0,0 @@
-// Copyright 2021 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_IMMEDIATE_CRASH_H_
-#define V8_BASE_IMMEDIATE_CRASH_H_
-
-#include "include/v8config.h"
-#include "src/base/build_config.h"
-
-// Crashes in the fastest possible way with no attempt at logging.
-// There are several constraints; see http://crbug.com/664209 for more context.
-//
-// - TRAP_SEQUENCE_() must be fatal. It should not be possible to ignore the
-//   resulting exception or simply hit 'continue' to skip over it in a debugger.
-// - Different instances of TRAP_SEQUENCE_() must not be folded together, to
-//   ensure crash reports are debuggable. Unlike __builtin_trap(), asm volatile
-//   blocks will not be folded together.
-//   Note: TRAP_SEQUENCE_() previously required an instruction with a unique
-//   nonce since unlike clang, GCC folds together identical asm volatile
-//   blocks.
-// - TRAP_SEQUENCE_() must produce a signal that is distinct from an invalid
-//   memory access.
-// - TRAP_SEQUENCE_() must be treated as a set of noreturn instructions.
-//   __builtin_unreachable() is used to provide that hint here. clang also uses
-//   this as a heuristic to pack the instructions in the function epilogue to
-//   improve code density.
-//
-// Additional properties that are nice to have:
-// - TRAP_SEQUENCE_() should be as compact as possible.
-// - The first instruction of TRAP_SEQUENCE_() should not change, to avoid
-//   shifting crash reporting clusters. As a consequence of this, explicit
-//   assembly is preferred over intrinsics.
-//   Note: this last bullet point may no longer be true, and may be removed in
-//   the future.
-
-// Note: TRAP_SEQUENCE Is currently split into two macro helpers due to the fact
-// that clang emits an actual instruction for __builtin_unreachable() on certain
-// platforms (see https://crbug.com/958675). In addition, the int3/bkpt/brk will
-// be removed in followups, so splitting it up like this now makes it easy to
-// land the followups.
-
-#if V8_CC_GNU
-
-#if V8_TARGET_ARCH_X64 || V8_TARGET_ARCH_IA32
-
-// TODO(https://crbug.com/958675): In theory, it should be possible to use just
-// int3. However, there are a number of crashes with SIGILL as the exception
-// code, so it seems likely that there's a signal handler that allows execution
-// to continue after SIGTRAP.
-#define TRAP_SEQUENCE1_() asm volatile("int3")
-
-#if V8_OS_MACOSX
-// Intentionally empty: __builtin_unreachable() is always part of the sequence
-// (see IMMEDIATE_CRASH below) and already emits a ud2 on Mac.
-#define TRAP_SEQUENCE2_() asm volatile("")
-#else
-#define TRAP_SEQUENCE2_() asm volatile("ud2")
-#endif  // V8_OS_MACOSX
-
-#elif V8_HOST_ARCH_ARM
-
-// bkpt will generate a SIGBUS when running on armv7 and a SIGTRAP when running
-// as a 32 bit userspace app on arm64. There doesn't seem to be any way to
-// cause a SIGTRAP from userspace without using a syscall (which would be a
-// problem for sandboxing).
-// TODO(https://crbug.com/958675): Remove bkpt from this sequence.
-#define TRAP_SEQUENCE1_() asm volatile("bkpt #0")
-#define TRAP_SEQUENCE2_() asm volatile("udf #0")
-
-#elif V8_HOST_ARCH_ARM64
-
-// This will always generate a SIGTRAP on arm64.
-// TODO(https://crbug.com/958675): Remove brk from this sequence.
-#define TRAP_SEQUENCE1_() asm volatile("brk #0")
-#define TRAP_SEQUENCE2_() asm volatile("hlt #0")
-
-#else
-
-// Crash report accuracy will not be guaranteed on other architectures, but at
-// least this will crash as expected.
-#define TRAP_SEQUENCE1_() __builtin_trap()
-#define TRAP_SEQUENCE2_() asm volatile("")
-
-#endif  // V8_HOST_ARCH_*
-
-#elif V8_CC_MSVC
-
-#if !defined(__clang__)
-
-// MSVC x64 doesn't support inline asm, so use the MSVC intrinsic.
-#define TRAP_SEQUENCE1_() __debugbreak()
-#define TRAP_SEQUENCE2_()
-
-#elif V8_HOST_ARCH_ARM64
-
-// Windows ARM64 uses "BRK #F000" as its breakpoint instruction, and
-// __debugbreak() generates that in both VC++ and clang.
-#define TRAP_SEQUENCE1_() __debugbreak()
-// Intentionally empty: __builtin_unreachable() is always part of the sequence
-// (see IMMEDIATE_CRASH below) and already emits a ud2 on Win64,
-// https://crbug.com/958373
-#define TRAP_SEQUENCE2_() __asm volatile("")
-
-#else
-
-#define TRAP_SEQUENCE1_() asm volatile("int3")
-#define TRAP_SEQUENCE2_() asm volatile("ud2")
-
-#endif  // __clang__
-
-#else
-
-#error No supported trap sequence!
-
-#endif  // V8_CC_GNU
-
-#define TRAP_SEQUENCE_() \
-  do {                   \
-    TRAP_SEQUENCE1_();   \
-    TRAP_SEQUENCE2_();   \
-  } while (false)
-
-// CHECK() and the trap sequence can be invoked from a constexpr function.
-// This could make compilation fail on GCC, as it forbids directly using inline
-// asm inside a constexpr function. However, it allows calling a lambda
-// expression including the same asm.
-// The side effect is that the top of the stacktrace will not point to the
-// calling function, but to this anonymous lambda. This is still useful as the
-// full name of the lambda will typically include the name of the function that
-// calls CHECK() and the debugger will still break at the right line of code.
-#if !V8_CC_GNU
-
-#define WRAPPED_TRAP_SEQUENCE_() TRAP_SEQUENCE_()
-
-#else
-
-#define WRAPPED_TRAP_SEQUENCE_() \
-  do {                           \
-    [] { TRAP_SEQUENCE_(); }();  \
-  } while (false)
-
-#endif  // !V8_CC_GCC
-
-#if defined(__clang__) || V8_CC_GCC
-
-// __builtin_unreachable() hints to the compiler that this is noreturn and can
-// be packed in the function epilogue.
-#define IMMEDIATE_CRASH()     \
-  ({                          \
-    WRAPPED_TRAP_SEQUENCE_(); \
-    __builtin_unreachable();  \
-  })
-
-#else
-
-// This is supporting build with MSVC where there is no __builtin_unreachable().
-#define IMMEDIATE_CRASH() WRAPPED_TRAP_SEQUENCE_()
-
-#endif  // defined(__clang__) || defined(COMPILER_GCC)
-
-#endif  // V8_BASE_IMMEDIATE_CRASH_H_