From 1fd605809b3f587ac1696fa743565e6e8d673268 Mon Sep 17 00:00:00 2001 From: minggo Date: Fri, 12 Jul 2019 16:48:57 +0800 Subject: [PATCH] add missing header files for windows (#68) --- win32/include/v8/v8-internal.h | 373 ++++++++++++++++++ win32/include/v8/v8-wasm-trap-handler-posix.h | 31 ++ win32/include/v8/v8-wasm-trap-handler-win.h | 28 ++ 3 files changed, 432 insertions(+) create mode 100644 win32/include/v8/v8-internal.h create mode 100644 win32/include/v8/v8-wasm-trap-handler-posix.h create mode 100644 win32/include/v8/v8-wasm-trap-handler-win.h diff --git a/win32/include/v8/v8-internal.h b/win32/include/v8/v8-internal.h new file mode 100644 index 00000000..8e700a4d --- /dev/null +++ b/win32/include/v8/v8-internal.h @@ -0,0 +1,373 @@ +// 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 INCLUDE_V8_INTERNAL_H_ +#define INCLUDE_V8_INTERNAL_H_ + +#include +#include +#include +#include + +#include "v8-version.h" // NOLINT(build/include) +#include "v8config.h" // NOLINT(build/include) + +namespace v8 { + +class Context; +class Data; +class Isolate; + +namespace internal { + +class Isolate; + +typedef uintptr_t Address; +static const Address kNullAddress = 0; + +/** + * Configuration of tagging scheme. + */ +const int kApiSystemPointerSize = sizeof(void*); +const int kApiDoubleSize = sizeof(double); +const int kApiInt32Size = sizeof(int32_t); +const int kApiInt64Size = sizeof(int64_t); + +// Tag information for HeapObject. +const int kHeapObjectTag = 1; +const int kWeakHeapObjectTag = 3; +const int kHeapObjectTagSize = 2; +const intptr_t kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1; + +// Tag information for Smi. +const int kSmiTag = 0; +const int kSmiTagSize = 1; +const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1; + +template +struct SmiTagging; + +// Smi constants for systems where tagged pointer is a 32-bit value. +template <> +struct SmiTagging<4> { + enum { kSmiShiftSize = 0, kSmiValueSize = 31 }; + V8_INLINE static int SmiToInt(const internal::Address value) { + int shift_bits = kSmiTagSize + kSmiShiftSize; + // Shift down (requires >> to be sign extending). + return static_cast(static_cast(value)) >> shift_bits; + } + V8_INLINE static constexpr bool IsValidSmi(intptr_t value) { + // To be representable as an tagged small integer, the two + // most-significant bits of 'value' must be either 00 or 11 due to + // sign-extension. To check this we add 01 to the two + // most-significant bits, and check if the most-significant bit is 0. + // + // CAUTION: The original code below: + // bool result = ((value + 0x40000000) & 0x80000000) == 0; + // may lead to incorrect results according to the C language spec, and + // in fact doesn't work correctly with gcc4.1.1 in some cases: The + // compiler may produce undefined results in case of signed integer + // overflow. The computation must be done w/ unsigned ints. + return static_cast(value) + 0x40000000U < 0x80000000U; + } +}; + +// Smi constants for systems where tagged pointer is a 64-bit value. +template <> +struct SmiTagging<8> { + enum { kSmiShiftSize = 31, kSmiValueSize = 32 }; + V8_INLINE static int SmiToInt(const internal::Address value) { + int shift_bits = kSmiTagSize + kSmiShiftSize; + // Shift down and throw away top 32 bits. + return static_cast(static_cast(value) >> shift_bits); + } + V8_INLINE static constexpr bool IsValidSmi(intptr_t value) { + // To be representable as a long smi, the value must be a 32-bit integer. + return (value == static_cast(value)); + } +}; + +#ifdef V8_COMPRESS_POINTERS +static_assert( + kApiSystemPointerSize == kApiInt64Size, + "Pointer compression can be enabled only for 64-bit architectures"); +const int kApiTaggedSize = kApiInt32Size; +#else +const int kApiTaggedSize = kApiSystemPointerSize; +#endif + +#ifdef V8_31BIT_SMIS_ON_64BIT_ARCH +typedef SmiTagging PlatformSmiTagging; +#else +typedef SmiTagging PlatformSmiTagging; +#endif + +const int kSmiShiftSize = PlatformSmiTagging::kSmiShiftSize; +const int kSmiValueSize = PlatformSmiTagging::kSmiValueSize; +const int kSmiMinValue = (static_cast(-1)) << (kSmiValueSize - 1); +const int kSmiMaxValue = -(kSmiMinValue + 1); +constexpr bool SmiValuesAre31Bits() { return kSmiValueSize == 31; } +constexpr bool SmiValuesAre32Bits() { return kSmiValueSize == 32; } + +V8_INLINE static constexpr internal::Address IntToSmi(int value) { + return (static_cast
(value) << (kSmiTagSize + kSmiShiftSize)) | + kSmiTag; +} + +/** + * This class exports constants and functionality from within v8 that + * is necessary to implement inline functions in the v8 api. Don't + * depend on functions and constants defined here. + */ +class Internals { + public: + // These values match non-compiler-dependent values defined within + // the implementation of v8. + static const int kHeapObjectMapOffset = 0; + static const int kMapInstanceTypeOffset = 1 * kApiTaggedSize + kApiInt32Size; + static const int kStringResourceOffset = + 1 * kApiTaggedSize + 2 * kApiInt32Size; + + static const int kOddballKindOffset = 4 * kApiTaggedSize + kApiDoubleSize; + static const int kForeignAddressOffset = kApiTaggedSize; + static const int kJSObjectHeaderSize = 3 * kApiTaggedSize; + static const int kFixedArrayHeaderSize = 2 * kApiTaggedSize; + static const int kEmbedderDataArrayHeaderSize = 2 * kApiTaggedSize; + static const int kEmbedderDataSlotSize = kApiSystemPointerSize; + static const int kNativeContextEmbedderDataOffset = 7 * kApiTaggedSize; + static const int kFullStringRepresentationMask = 0x0f; + static const int kStringEncodingMask = 0x8; + static const int kExternalTwoByteRepresentationTag = 0x02; + static const int kExternalOneByteRepresentationTag = 0x0a; + + static const uint32_t kNumIsolateDataSlots = 4; + + static const int kIsolateEmbedderDataOffset = 0; + static const int kExternalMemoryOffset = + kNumIsolateDataSlots * kApiSystemPointerSize; + static const int kExternalMemoryLimitOffset = + kExternalMemoryOffset + kApiInt64Size; + static const int kExternalMemoryAtLastMarkCompactOffset = + kExternalMemoryLimitOffset + kApiInt64Size; + static const int kIsolateRootsOffset = + kExternalMemoryAtLastMarkCompactOffset + kApiInt64Size; + + static const int kUndefinedValueRootIndex = 4; + static const int kTheHoleValueRootIndex = 5; + static const int kNullValueRootIndex = 6; + static const int kTrueValueRootIndex = 7; + static const int kFalseValueRootIndex = 8; + static const int kEmptyStringRootIndex = 9; + + static const int kNodeClassIdOffset = 1 * kApiSystemPointerSize; + static const int kNodeFlagsOffset = 1 * kApiSystemPointerSize + 3; + static const int kNodeStateMask = 0x7; + static const int kNodeStateIsWeakValue = 2; + static const int kNodeStateIsPendingValue = 3; + static const int kNodeIsIndependentShift = 3; + static const int kNodeIsActiveShift = 4; + + static const int kFirstNonstringType = 0x40; + static const int kOddballType = 0x43; + static const int kForeignType = 0x47; + static const int kJSSpecialApiObjectType = 0x410; + static const int kJSApiObjectType = 0x420; + static const int kJSObjectType = 0x421; + + static const int kUndefinedOddballKind = 5; + static const int kNullOddballKind = 3; + + // Constants used by PropertyCallbackInfo to check if we should throw when an + // error occurs. + static const int kThrowOnError = 0; + static const int kDontThrow = 1; + static const int kInferShouldThrowMode = 2; + + // Soft limit for AdjustAmountofExternalAllocatedMemory. Trigger an + // incremental GC once the external memory reaches this limit. + static constexpr int kExternalAllocationSoftLimit = 64 * 1024 * 1024; + + V8_EXPORT static void CheckInitializedImpl(v8::Isolate* isolate); + V8_INLINE static void CheckInitialized(v8::Isolate* isolate) { +#ifdef V8_ENABLE_CHECKS + CheckInitializedImpl(isolate); +#endif + } + + V8_INLINE static bool HasHeapObjectTag(const internal::Address value) { + return (value & kHeapObjectTagMask) == static_cast
(kHeapObjectTag); + } + + V8_INLINE static int SmiValue(const internal::Address value) { + return PlatformSmiTagging::SmiToInt(value); + } + + V8_INLINE static constexpr internal::Address IntToSmi(int value) { + return internal::IntToSmi(value); + } + + V8_INLINE static constexpr bool IsValidSmi(intptr_t value) { + return PlatformSmiTagging::IsValidSmi(value); + } + + V8_INLINE static int GetInstanceType(const internal::Address obj) { + typedef internal::Address A; + A map = ReadTaggedPointerField(obj, kHeapObjectMapOffset); + return ReadRawField(map, kMapInstanceTypeOffset); + } + + V8_INLINE static int GetOddballKind(const internal::Address obj) { + return SmiValue(ReadTaggedSignedField(obj, kOddballKindOffset)); + } + + V8_INLINE static bool IsExternalTwoByteString(int instance_type) { + int representation = (instance_type & kFullStringRepresentationMask); + return representation == kExternalTwoByteRepresentationTag; + } + + V8_INLINE static uint8_t GetNodeFlag(internal::Address* obj, int shift) { + uint8_t* addr = reinterpret_cast(obj) + kNodeFlagsOffset; + return *addr & static_cast(1U << shift); + } + + V8_INLINE static void UpdateNodeFlag(internal::Address* obj, bool value, + int shift) { + uint8_t* addr = reinterpret_cast(obj) + kNodeFlagsOffset; + uint8_t mask = static_cast(1U << shift); + *addr = static_cast((*addr & ~mask) | (value << shift)); + } + + V8_INLINE static uint8_t GetNodeState(internal::Address* obj) { + uint8_t* addr = reinterpret_cast(obj) + kNodeFlagsOffset; + return *addr & kNodeStateMask; + } + + V8_INLINE static void UpdateNodeState(internal::Address* obj, uint8_t value) { + uint8_t* addr = reinterpret_cast(obj) + kNodeFlagsOffset; + *addr = static_cast((*addr & ~kNodeStateMask) | value); + } + + V8_INLINE static void SetEmbedderData(v8::Isolate* isolate, uint32_t slot, + void* data) { + internal::Address addr = reinterpret_cast(isolate) + + kIsolateEmbedderDataOffset + + slot * kApiSystemPointerSize; + *reinterpret_cast(addr) = data; + } + + V8_INLINE static void* GetEmbedderData(const v8::Isolate* isolate, + uint32_t slot) { + internal::Address addr = reinterpret_cast(isolate) + + kIsolateEmbedderDataOffset + + slot * kApiSystemPointerSize; + return *reinterpret_cast(addr); + } + + V8_INLINE static internal::Address* GetRoot(v8::Isolate* isolate, int index) { + internal::Address addr = reinterpret_cast(isolate) + + kIsolateRootsOffset + + index * kApiSystemPointerSize; + return reinterpret_cast(addr); + } + + template + V8_INLINE static T ReadRawField(internal::Address heap_object_ptr, + int offset) { + internal::Address addr = heap_object_ptr + offset - kHeapObjectTag; +#ifdef V8_COMPRESS_POINTERS + if (sizeof(T) > kApiTaggedSize) { + // TODO(ishell, v8:8875): When pointer compression is enabled 8-byte size + // fields (external pointers, doubles and BigInt data) are only + // kTaggedSize aligned so we have to use unaligned pointer friendly way of + // accessing them in order to avoid undefined behavior in C++ code. + T r; + memcpy(&r, reinterpret_cast(addr), sizeof(T)); + return r; + } +#endif + return *reinterpret_cast(addr); + } + + V8_INLINE static internal::Address ReadTaggedPointerField( + internal::Address heap_object_ptr, int offset) { +#ifdef V8_COMPRESS_POINTERS + int32_t value = ReadRawField(heap_object_ptr, offset); + internal::Address root = GetRootFromOnHeapAddress(heap_object_ptr); + return root + static_cast(static_cast(value)); +#else + return ReadRawField(heap_object_ptr, offset); +#endif + } + + V8_INLINE static internal::Address ReadTaggedSignedField( + internal::Address heap_object_ptr, int offset) { +#ifdef V8_COMPRESS_POINTERS + int32_t value = ReadRawField(heap_object_ptr, offset); + return static_cast(static_cast(value)); +#else + return ReadRawField(heap_object_ptr, offset); +#endif + } + +#ifdef V8_COMPRESS_POINTERS + // See v8:7703 or src/ptr-compr.* for details about pointer compression. + static constexpr size_t kPtrComprHeapReservationSize = size_t{1} << 32; + static constexpr size_t kPtrComprIsolateRootBias = + kPtrComprHeapReservationSize / 2; + static constexpr size_t kPtrComprIsolateRootAlignment = size_t{1} << 32; + + V8_INLINE static internal::Address GetRootFromOnHeapAddress( + internal::Address addr) { + return (addr + kPtrComprIsolateRootBias) & + -static_cast(kPtrComprIsolateRootAlignment); + } + + V8_INLINE static internal::Address DecompressTaggedAnyField( + internal::Address heap_object_ptr, int32_t value) { + internal::Address root_mask = static_cast( + -static_cast(value & kSmiTagMask)); + internal::Address root_or_zero = + root_mask & GetRootFromOnHeapAddress(heap_object_ptr); + return root_or_zero + + static_cast(static_cast(value)); + } +#endif // V8_COMPRESS_POINTERS +}; + +// Only perform cast check for types derived from v8::Data since +// other types do not implement the Cast method. +template +struct CastCheck { + template + static void Perform(T* data); +}; + +template <> +template +void CastCheck::Perform(T* data) { + T::Cast(data); +} + +template <> +template +void CastCheck::Perform(T* data) {} + +template +V8_INLINE void PerformCastCheck(T* data) { + CastCheck::value>::Perform(data); +} + +// {obj} must be the raw tagged pointer representation of a HeapObject +// that's guaranteed to never be in ReadOnlySpace. +V8_EXPORT internal::Isolate* IsolateFromNeverReadOnlySpaceObject(Address obj); + +// Returns if we need to throw when an error occurs. This infers the language +// mode based on the current context and the closure. This returns true if the +// language mode is strict. +V8_EXPORT bool ShouldThrowOnError(v8::internal::Isolate* isolate); + +} // namespace internal +} // namespace v8 + +#endif // INCLUDE_V8_INTERNAL_H_ diff --git a/win32/include/v8/v8-wasm-trap-handler-posix.h b/win32/include/v8/v8-wasm-trap-handler-posix.h new file mode 100644 index 00000000..998d0a41 --- /dev/null +++ b/win32/include/v8/v8-wasm-trap-handler-posix.h @@ -0,0 +1,31 @@ +// 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_WASM_TRAP_HANDLER_POSIX_H_ +#define V8_WASM_TRAP_HANDLER_POSIX_H_ + +#include + +#include "v8config.h" // NOLINT(build/include) + +namespace v8 { +/** + * This function determines whether a memory access violation has been an + * out-of-bounds memory access in WebAssembly. If so, it will modify the context + * parameter and add a return address where the execution can continue after the + * signal handling, and return true. Otherwise, false will be returned. + * + * The parameters to this function correspond to those passed to a Posix signal + * handler. Use this function only on Linux and Mac. + * + * \param sig_code The signal code, e.g. SIGSEGV. + * \param info A pointer to the siginfo_t struct provided to the signal handler. + * \param context A pointer to a ucontext_t struct provided to the signal + * handler. + */ +V8_EXPORT bool TryHandleWebAssemblyTrapPosix(int sig_code, siginfo_t* info, + void* context); + +} // namespace v8 +#endif // V8_WASM_TRAP_HANDLER_POSIX_H_ diff --git a/win32/include/v8/v8-wasm-trap-handler-win.h b/win32/include/v8/v8-wasm-trap-handler-win.h new file mode 100644 index 00000000..0185df64 --- /dev/null +++ b/win32/include/v8/v8-wasm-trap-handler-win.h @@ -0,0 +1,28 @@ +// 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_WASM_TRAP_HANDLER_WIN_H_ +#define V8_WASM_TRAP_HANDLER_WIN_H_ + +#include + +#include "v8config.h" // NOLINT(build/include) + +namespace v8 { +/** + * This function determines whether a memory access violation has been an + * out-of-bounds memory access in WebAssembly. If so, it will modify the + * exception parameter and add a return address where the execution can continue + * after the exception handling, and return true. Otherwise the return value + * will be false. + * + * The parameter to this function corresponds to the one passed to a Windows + * vectored exception handler. Use this function only on Windows. + * + * \param exception An EXCEPTION_POINTERS* as provided to the exception handler. + */ +V8_EXPORT bool TryHandleWebAssemblyTrapWindows(EXCEPTION_POINTERS* exception); + +} // namespace v8 +#endif // V8_WASM_TRAP_HANDLER_WIN_H_