File Explorer

1// Copyright 2018 the V8 project authors. All rights reserved.2// Use of this source code is governed by a BSD-style license that can be3// found in the LICENSE file.4 5#ifndef INCLUDE_V8_INTERNAL_H_6#define INCLUDE_V8_INTERNAL_H_7 8#include <stddef.h>9#include <stdint.h>10#include <string.h>11 12#include <atomic>13#include <iterator>14#include <limits>15#include <memory>16#include <optional>17#include <type_traits>18 19#include "v8config.h"  // NOLINT(build/include_directory)20 21// TODO(pkasting): Use <compare>/spaceship unconditionally after dropping22// support for old libstdc++ versions.23#if __has_include(<version>)24#include <version>25#endif26#if defined(__cpp_lib_three_way_comparison) &&   \27    __cpp_lib_three_way_comparison >= 201711L && \28    defined(__cpp_lib_concepts) && __cpp_lib_concepts >= 202002L29#include <compare>30#include <concepts>31 32#define V8_HAVE_SPACESHIP_OPERATOR 133#else34#define V8_HAVE_SPACESHIP_OPERATOR 035#endif36 37namespace v8 {38 39class Array;40class Context;41class Data;42class Isolate;43 44namespace internal {45 46class Heap;47class LocalHeap;48class Isolate;49class IsolateGroup;50class LocalIsolate;51 52typedef uintptr_t Address;53static constexpr Address kNullAddress = 0;54 55constexpr int KB = 1024;56constexpr int MB = KB * 1024;57constexpr int GB = MB * 1024;58#ifdef V8_TARGET_ARCH_X6459constexpr size_t TB = size_t{GB} * 1024;60#endif61 62/**63 * Configuration of tagging scheme.64 */65const int kApiSystemPointerSize = sizeof(void*);66const int kApiDoubleSize = sizeof(double);67const int kApiInt32Size = sizeof(int32_t);68const int kApiInt64Size = sizeof(int64_t);69const int kApiSizetSize = sizeof(size_t);70 71// Tag information for HeapObject.72const int kHeapObjectTag = 1;73const int kWeakHeapObjectTag = 3;74const int kHeapObjectTagSize = 2;75const intptr_t kHeapObjectTagMask = (1 << kHeapObjectTagSize) - 1;76const intptr_t kHeapObjectReferenceTagMask = 1 << (kHeapObjectTagSize - 1);77 78// Tag information for fowarding pointers stored in object headers.79// 0b00 at the lowest 2 bits in the header indicates that the map word is a80// forwarding pointer.81const int kForwardingTag = 0;82const int kForwardingTagSize = 2;83const intptr_t kForwardingTagMask = (1 << kForwardingTagSize) - 1;84 85// Tag information for Smi.86const int kSmiTag = 0;87const int kSmiTagSize = 1;88const intptr_t kSmiTagMask = (1 << kSmiTagSize) - 1;89 90template <size_t tagged_ptr_size>91struct SmiTagging;92 93constexpr intptr_t kIntptrAllBitsSet = intptr_t{-1};94constexpr uintptr_t kUintptrAllBitsSet =95    static_cast<uintptr_t>(kIntptrAllBitsSet);96 97// Smi constants for systems where tagged pointer is a 32-bit value.98template <>99struct SmiTagging<4> {100  enum { kSmiShiftSize = 0, kSmiValueSize = 31 };101 102  static constexpr intptr_t kSmiMinValue =103      static_cast<intptr_t>(kUintptrAllBitsSet << (kSmiValueSize - 1));104  static constexpr intptr_t kSmiMaxValue = -(kSmiMinValue + 1);105 106  V8_INLINE static constexpr int SmiToInt(Address value) {107    int shift_bits = kSmiTagSize + kSmiShiftSize;108    // Truncate and shift down (requires >> to be sign extending).109    return static_cast<int32_t>(static_cast<uint32_t>(value)) >> shift_bits;110  }111 112  template <class T, typename std::enable_if_t<std::is_integral_v<T> &&113                                               std::is_signed_v<T>>* = nullptr>114  V8_INLINE static constexpr bool IsValidSmi(T value) {115    // Is value in range [kSmiMinValue, kSmiMaxValue].116    // Use unsigned operations in order to avoid undefined behaviour in case of117    // signed integer overflow.118    return (static_cast<uintptr_t>(value) -119            static_cast<uintptr_t>(kSmiMinValue)) <=120           (static_cast<uintptr_t>(kSmiMaxValue) -121            static_cast<uintptr_t>(kSmiMinValue));122  }123 124  template <class T,125            typename std::enable_if_t<std::is_integral_v<T> &&126                                      std::is_unsigned_v<T>>* = nullptr>127  V8_INLINE static constexpr bool IsValidSmi(T value) {128    static_assert(kSmiMaxValue <= std::numeric_limits<uintptr_t>::max());129    return value <= static_cast<uintptr_t>(kSmiMaxValue);130  }131 132  // Same as the `intptr_t` version but works with int64_t on 32-bit builds133  // without slowing down anything else.134  V8_INLINE static constexpr bool IsValidSmi(int64_t value) {135    return (static_cast<uint64_t>(value) -136            static_cast<uint64_t>(kSmiMinValue)) <=137           (static_cast<uint64_t>(kSmiMaxValue) -138            static_cast<uint64_t>(kSmiMinValue));139  }140 141  V8_INLINE static constexpr bool IsValidSmi(uint64_t value) {142    static_assert(kSmiMaxValue <= std::numeric_limits<uint64_t>::max());143    return value <= static_cast<uint64_t>(kSmiMaxValue);144  }145};146 147// Smi constants for systems where tagged pointer is a 64-bit value.148template <>149struct SmiTagging<8> {150  enum { kSmiShiftSize = 31, kSmiValueSize = 32 };151 152  static constexpr intptr_t kSmiMinValue =153      static_cast<intptr_t>(kUintptrAllBitsSet << (kSmiValueSize - 1));154  static constexpr intptr_t kSmiMaxValue = -(kSmiMinValue + 1);155 156  V8_INLINE static constexpr int SmiToInt(Address value) {157    int shift_bits = kSmiTagSize + kSmiShiftSize;158    // Shift down and throw away top 32 bits.159    return static_cast<int>(static_cast<intptr_t>(value) >> shift_bits);160  }161 162  template <class T, typename std::enable_if_t<std::is_integral_v<T> &&163                                               std::is_signed_v<T>>* = nullptr>164  V8_INLINE static constexpr bool IsValidSmi(T value) {165    // To be representable as a long smi, the value must be a 32-bit integer.166    return std::numeric_limits<int32_t>::min() <= value &&167           value <= std::numeric_limits<int32_t>::max();168  }169 170  template <class T,171            typename std::enable_if_t<std::is_integral_v<T> &&172                                      std::is_unsigned_v<T>>* = nullptr>173  V8_INLINE static constexpr bool IsValidSmi(T value) {174    return value <= std::numeric_limits<int32_t>::max();175  }176};177 178#ifdef V8_COMPRESS_POINTERS179// See v8:7703 or src/common/ptr-compr-inl.h for details about pointer180// compression.181constexpr size_t kPtrComprCageReservationSize = size_t{1} << 32;182constexpr size_t kPtrComprCageBaseAlignment = size_t{1} << 32;183 184static_assert(185    kApiSystemPointerSize == kApiInt64Size,186    "Pointer compression can be enabled only for 64-bit architectures");187const int kApiTaggedSize = kApiInt32Size;188#else189const int kApiTaggedSize = kApiSystemPointerSize;190#endif191 192constexpr bool PointerCompressionIsEnabled() {193  return kApiTaggedSize != kApiSystemPointerSize;194}195 196#ifdef V8_31BIT_SMIS_ON_64BIT_ARCH197using PlatformSmiTagging = SmiTagging<kApiInt32Size>;198#else199using PlatformSmiTagging = SmiTagging<kApiTaggedSize>;200#endif201 202// TODO(ishell): Consinder adding kSmiShiftBits = kSmiShiftSize + kSmiTagSize203// since it's used much more often than the inividual constants.204const int kSmiShiftSize = PlatformSmiTagging::kSmiShiftSize;205const int kSmiValueSize = PlatformSmiTagging::kSmiValueSize;206const int kSmiMinValue = static_cast<int>(PlatformSmiTagging::kSmiMinValue);207const int kSmiMaxValue = static_cast<int>(PlatformSmiTagging::kSmiMaxValue);208constexpr bool SmiValuesAre31Bits() { return kSmiValueSize == 31; }209constexpr bool SmiValuesAre32Bits() { return kSmiValueSize == 32; }210constexpr bool Is64() { return kApiSystemPointerSize == sizeof(int64_t); }211 212V8_INLINE static constexpr Address IntToSmi(int value) {213  return (static_cast<Address>(value) << (kSmiTagSize + kSmiShiftSize)) |214         kSmiTag;215}216 217/*218 * Sandbox related types, constants, and functions.219 */220constexpr bool SandboxIsEnabled() {221#ifdef V8_ENABLE_SANDBOX222  return true;223#else224  return false;225#endif226}227 228// SandboxedPointers are guaranteed to point into the sandbox. This is achieved229// for example by storing them as offset rather than as raw pointers.230using SandboxedPointer_t = Address;231 232#ifdef V8_ENABLE_SANDBOX233 234// Size of the sandbox, excluding the guard regions surrounding it.235#if defined(V8_TARGET_OS_ANDROID)236// On Android, most 64-bit devices seem to be configured with only 39 bits of237// virtual address space for userspace. As such, limit the sandbox to 128GB (a238// quarter of the total available address space).239constexpr size_t kSandboxSizeLog2 = 37;  // 128 GB240#else241// Everywhere else use a 1TB sandbox.242constexpr size_t kSandboxSizeLog2 = 40;  // 1 TB243#endif  // V8_TARGET_OS_ANDROID244constexpr size_t kSandboxSize = 1ULL << kSandboxSizeLog2;245 246// Required alignment of the sandbox. For simplicity, we require the247// size of the guard regions to be a multiple of this, so that this specifies248// the alignment of the sandbox including and excluding surrounding guard249// regions. The alignment requirement is due to the pointer compression cage250// being located at the start of the sandbox.251constexpr size_t kSandboxAlignment = kPtrComprCageBaseAlignment;252 253// Sandboxed pointers are stored inside the heap as offset from the sandbox254// base shifted to the left. This way, it is guaranteed that the offset is255// smaller than the sandbox size after shifting it to the right again. This256// constant specifies the shift amount.257constexpr uint64_t kSandboxedPointerShift = 64 - kSandboxSizeLog2;258 259// Size of the guard regions surrounding the sandbox. This assumes a worst-case260// scenario of a 32-bit unsigned index used to access an array of 64-bit values261// with an additional 4GB (compressed pointer) offset. In particular, accesses262// to TypedArrays are effectively computed as263// `entry_pointer = array->base + array->offset + index * array->element_size`.264// See also https://crbug.com/40070746 for more details.265constexpr size_t kSandboxGuardRegionSize = 32ULL * GB + 4ULL * GB;266 267static_assert((kSandboxGuardRegionSize % kSandboxAlignment) == 0,268              "The size of the guard regions around the sandbox must be a "269              "multiple of its required alignment.");270 271// On OSes where reserving virtual memory is too expensive to reserve the272// entire address space backing the sandbox, notably Windows pre 8.1, we create273// a partially reserved sandbox that doesn't actually reserve most of the274// memory, and so doesn't have the desired security properties as unrelated275// memory allocations could end up inside of it, but which still ensures that276// objects that should be located inside the sandbox are allocated within277// kSandboxSize bytes from the start of the sandbox. The minimum size of the278// region that is actually reserved for such a sandbox is specified by this279// constant and should be big enough to contain the pointer compression cage as280// well as the ArrayBuffer partition.281constexpr size_t kSandboxMinimumReservationSize = 8ULL * GB;282 283static_assert(kSandboxMinimumReservationSize > kPtrComprCageReservationSize,284              "The minimum reservation size for a sandbox must be larger than "285              "the pointer compression cage contained within it.");286 287// The maximum buffer size allowed inside the sandbox. This is mostly dependent288// on the size of the guard regions around the sandbox: an attacker must not be289// able to construct a buffer that appears larger than the guard regions and290// thereby "reach out of" the sandbox.291constexpr size_t kMaxSafeBufferSizeForSandbox = 32ULL * GB - 1;292static_assert(kMaxSafeBufferSizeForSandbox <= kSandboxGuardRegionSize,293              "The maximum allowed buffer size must not be larger than the "294              "sandbox's guard regions");295 296constexpr size_t kBoundedSizeShift = 29;297static_assert(1ULL << (64 - kBoundedSizeShift) ==298                  kMaxSafeBufferSizeForSandbox + 1,299              "The maximum size of a BoundedSize must be synchronized with the "300              "kMaxSafeBufferSizeForSandbox");301 302#endif  // V8_ENABLE_SANDBOX303 304#ifdef V8_COMPRESS_POINTERS305 306#ifdef V8_TARGET_OS_ANDROID307// The size of the virtual memory reservation for an external pointer table.308// This determines the maximum number of entries in a table. Using a maximum309// size allows omitting bounds checks on table accesses if the indices are310// guaranteed (e.g. through shifting) to be below the maximum index. This311// value must be a power of two.312constexpr size_t kExternalPointerTableReservationSize = 256 * MB;313 314// The external pointer table indices stored in HeapObjects as external315// pointers are shifted to the left by this amount to guarantee that they are316// smaller than the maximum table size even after the C++ compiler multiplies317// them by 8 to be used as indexes into a table of 64 bit pointers.318constexpr uint32_t kExternalPointerIndexShift = 7;319#else320constexpr size_t kExternalPointerTableReservationSize = 512 * MB;321constexpr uint32_t kExternalPointerIndexShift = 6;322#endif  // V8_TARGET_OS_ANDROID323 324// The maximum number of entries in an external pointer table.325constexpr int kExternalPointerTableEntrySize = 8;326constexpr int kExternalPointerTableEntrySizeLog2 = 3;327constexpr size_t kMaxExternalPointers =328    kExternalPointerTableReservationSize / kExternalPointerTableEntrySize;329static_assert((1 << (32 - kExternalPointerIndexShift)) == kMaxExternalPointers,330              "kExternalPointerTableReservationSize and "331              "kExternalPointerIndexShift don't match");332 333#else  // !V8_COMPRESS_POINTERS334 335// Needed for the V8.SandboxedExternalPointersCount histogram.336constexpr size_t kMaxExternalPointers = 0;337 338#endif  // V8_COMPRESS_POINTERS339 340constexpr uint64_t kExternalPointerMarkBit = 1ULL << 48;341constexpr uint64_t kExternalPointerTagShift = 49;342constexpr uint64_t kExternalPointerTagMask = 0x00fe000000000000ULL;343constexpr uint64_t kExternalPointerShiftedTagMask =344    kExternalPointerTagMask >> kExternalPointerTagShift;345static_assert(kExternalPointerShiftedTagMask << kExternalPointerTagShift ==346              kExternalPointerTagMask);347constexpr uint64_t kExternalPointerTagAndMarkbitMask = 0x00ff000000000000ULL;348constexpr uint64_t kExternalPointerPayloadMask = 0xff00ffffffffffffULL;349 350// A ExternalPointerHandle represents a (opaque) reference to an external351// pointer that can be stored inside the sandbox. A ExternalPointerHandle has352// meaning only in combination with an (active) Isolate as it references an353// external pointer stored in the currently active Isolate's354// ExternalPointerTable. Internally, an ExternalPointerHandles is simply an355// index into an ExternalPointerTable that is shifted to the left to guarantee356// that it is smaller than the size of the table.357using ExternalPointerHandle = uint32_t;358 359// ExternalPointers point to objects located outside the sandbox. When the V8360// sandbox is enabled, these are stored on heap as ExternalPointerHandles,361// otherwise they are simply raw pointers.362#ifdef V8_ENABLE_SANDBOX363using ExternalPointer_t = ExternalPointerHandle;364#else365using ExternalPointer_t = Address;366#endif367 368constexpr ExternalPointer_t kNullExternalPointer = 0;369constexpr ExternalPointerHandle kNullExternalPointerHandle = 0;370 371// See `ExternalPointerHandle` for the main documentation. The difference to372// `ExternalPointerHandle` is that the handle does not represent an arbitrary373// external pointer but always refers to an object managed by `CppHeap`. The374// handles are using in combination with a dedicated table for `CppHeap`375// references.376using CppHeapPointerHandle = uint32_t;377 378// The actual pointer to objects located on the `CppHeap`. When pointer379// compression is enabled these pointers are stored as `CppHeapPointerHandle`.380// In non-compressed configurations the pointers are simply stored as raw381// pointers.382#ifdef V8_COMPRESS_POINTERS383using CppHeapPointer_t = CppHeapPointerHandle;384#else385using CppHeapPointer_t = Address;386#endif387 388constexpr CppHeapPointer_t kNullCppHeapPointer = 0;389constexpr CppHeapPointerHandle kNullCppHeapPointerHandle = 0;390 391constexpr uint64_t kCppHeapPointerMarkBit = 1ULL;392constexpr uint64_t kCppHeapPointerTagShift = 1;393constexpr uint64_t kCppHeapPointerPayloadShift = 16;394 395#ifdef V8_COMPRESS_POINTERS396// CppHeapPointers use a dedicated pointer table. These constants control the397// size and layout of the table. See the corresponding constants for the398// external pointer table for further details.399constexpr size_t kCppHeapPointerTableReservationSize =400    kExternalPointerTableReservationSize;401constexpr uint32_t kCppHeapPointerIndexShift = kExternalPointerIndexShift;402 403constexpr int kCppHeapPointerTableEntrySize = 8;404constexpr int kCppHeapPointerTableEntrySizeLog2 = 3;405constexpr size_t kMaxCppHeapPointers =406    kCppHeapPointerTableReservationSize / kCppHeapPointerTableEntrySize;407static_assert((1 << (32 - kCppHeapPointerIndexShift)) == kMaxCppHeapPointers,408              "kCppHeapPointerTableReservationSize and "409              "kCppHeapPointerIndexShift don't match");410 411#else  // !V8_COMPRESS_POINTERS412 413// Needed for the V8.SandboxedCppHeapPointersCount histogram.414constexpr size_t kMaxCppHeapPointers = 0;415 416#endif  // V8_COMPRESS_POINTERS417 418// Generic tag range struct to represent ranges of type tags.419//420// When referencing external objects via pointer tables, type tags are421// frequently necessary to guarantee type safety for the external objects. When422// support for subtyping is necessary, range-based type checks are used in423// which all subtypes of a given supertype use contiguous tags. This struct can424// then be used to represent such a type range.425//426// In addition, there is an option for performance tweaks: if the size of the427// type range corresponding to a supertype is a power of two and starts at a428// power of two (e.g. [0x100, 0x13f]), then the compiler can often optimize429// the type check to use even fewer instructions (essentially replace a AND +430// SUB with a single AND).431//432template <typename Tag>433struct TagRange {434  static_assert(std::is_enum_v<Tag> &&435                    std::is_same_v<std::underlying_type_t<Tag>, uint16_t>,436                "Tag parameter must be an enum with base type uint16_t");437 438  // Construct the inclusive tag range [first, last].439  constexpr TagRange(Tag first, Tag last) : first(first), last(last) {}440 441  // Construct a tag range consisting of a single tag.442  //443  // A single tag is always implicitly convertible to a tag range. This greatly444  // increases readability as most of the time, the exact tag of a field is445  // known and so no tag range needs to explicitly be created for it.446  constexpr TagRange(Tag tag)  // NOLINT(runtime/explicit)447      : first(tag), last(tag) {}448 449  // Construct an empty tag range.450  constexpr TagRange() : TagRange(static_cast<Tag>(0)) {}451 452  // A tag range is considered empty if it only contains the null tag.453  constexpr bool IsEmpty() const { return first == 0 && last == 0; }454 455  constexpr size_t Size() const {456    if (IsEmpty()) {457      return 0;458    } else {459      return last - first + 1;460    }461  }462 463  constexpr bool Contains(Tag tag) const {464    // Need to perform the math with uint32_t. Otherwise, the uint16_ts would465    // be promoted to (signed) int, allowing the compiler to (wrongly) assume466    // that an underflow cannot happen as that would be undefined behavior.467    return static_cast<uint32_t>(tag) - first <=468           static_cast<uint32_t>(last) - first;469  }470 471  constexpr bool Contains(TagRange tag_range) const {472    return tag_range.first >= first && tag_range.last <= last;473  }474 475  constexpr bool operator==(const TagRange other) const {476    return first == other.first && last == other.last;477  }478 479  constexpr size_t hash_value() const {480    static_assert(std::is_same_v<std::underlying_type_t<Tag>, uint16_t>);481    return (static_cast<size_t>(first) << 16) | last;482  }483 484  // Internally we represent tag ranges as half-open ranges [first, last).485  const Tag first;486  const Tag last;487};488 489//490// External Pointers.491//492// When the sandbox is enabled, external pointers are stored in an external493// pointer table and are referenced from HeapObjects through an index (a494// "handle"). When stored in the table, the pointers are tagged with per-type495// tags to prevent type confusion attacks between different external objects.496//497// When loading an external pointer, a range of allowed tags can be specified.498// This way, type hierarchies can be supported. The main requirement for that499// is that all (transitive) child classes of a given parent class have type ids500// in the same range, and that there are no unrelated types in that range. For501// more details about how to assign type tags to types, see the TagRange class.502//503// The external pointer sandboxing mechanism ensures that every access to an504// external pointer field will result in a valid pointer of the expected type505// even in the presence of an attacker able to corrupt memory inside the506// sandbox. However, if any data related to the external object is stored507// inside the sandbox it may still be corrupted and so must be validated before508// use or moved into the external object. Further, an attacker will always be509// able to substitute different external pointers of the same type for each510// other. Therefore, code using external pointers must be written in a511// "substitution-safe" way, i.e. it must always be possible to substitute512// external pointers of the same type without causing memory corruption outside513// of the sandbox. Generally this is achieved by referencing any group of514// related external objects through a single external pointer.515//516// Currently we use bit 62 for the marking bit which should always be unused as517// it's part of the non-canonical address range. When Arm's top-byte ignore518// (TBI) is enabled, this bit will be part of the ignored byte, and we assume519// that the Embedder is not using this byte (really only this one bit) for any520// other purpose. This bit also does not collide with the memory tagging521// extension (MTE) which would use bits [56, 60).522//523// External pointer tables are also available even when the sandbox is off but524// pointer compression is on. In that case, the mechanism can be used to ease525// alignment requirements as it turns unaligned 64-bit raw pointers into526// aligned 32-bit indices. To "opt-in" to the external pointer table mechanism527// for this purpose, instead of using the ExternalPointer accessors one needs to528// use ExternalPointerHandles directly and use them to access the pointers in an529// ExternalPointerTable.530//531// The tag is currently in practice limited to 15 bits since it needs to fit532// together with a marking bit into the unused parts of a pointer.533enum ExternalPointerTag : uint16_t {534  kFirstExternalPointerTag = 0,535  kExternalPointerNullTag = 0,536 537  // When adding new tags, please ensure that the code using these tags is538  // "substitution-safe", i.e. still operate safely if external pointers of the539  // same type are swapped by an attacker. See comment above for more details.540 541  // Shared external pointers are owned by the shared Isolate and stored in the542  // shared external pointer table associated with that Isolate, where they can543  // be accessed from multiple threads at the same time. The objects referenced544  // in this way must therefore always be thread-safe.545  kFirstSharedExternalPointerTag,546  kWaiterQueueNodeTag = kFirstSharedExternalPointerTag,547  kExternalStringResourceTag,548  kExternalStringResourceDataTag,549  kLastSharedExternalPointerTag = kExternalStringResourceDataTag,550 551  // External pointers using these tags are kept in a per-Isolate external552  // pointer table and can only be accessed when this Isolate is active.553  kNativeContextMicrotaskQueueTag,554  kEmbedderDataSlotPayloadTag,555  // This tag essentially stands for a `void*` pointer in the V8 API, and it is556  // the Embedder's responsibility to ensure type safety (against substitution)557  // and lifetime validity of these objects.558  kExternalObjectValueTag,559  kFirstMaybeReadOnlyExternalPointerTag,560  kFunctionTemplateInfoCallbackTag = kFirstMaybeReadOnlyExternalPointerTag,561  kAccessorInfoGetterTag,562  kAccessorInfoSetterTag,563  kLastMaybeReadOnlyExternalPointerTag = kAccessorInfoSetterTag,564  kWasmInternalFunctionCallTargetTag,565  kWasmTypeInfoNativeTypeTag,566  kWasmExportedFunctionDataSignatureTag,567  kWasmStackMemoryTag,568  kWasmIndirectFunctionTargetTag,569 570  // Foreigns571  kFirstForeignExternalPointerTag,572  kGenericForeignTag = kFirstForeignExternalPointerTag,573  kApiNamedPropertyQueryCallbackTag,574  kApiNamedPropertyGetterCallbackTag,575  kApiNamedPropertySetterCallbackTag,576  kApiNamedPropertyDescriptorCallbackTag,577  kApiNamedPropertyDefinerCallbackTag,578  kApiNamedPropertyDeleterCallbackTag,579  kApiIndexedPropertyQueryCallbackTag,580  kApiIndexedPropertyGetterCallbackTag,581  kApiIndexedPropertySetterCallbackTag,582  kApiIndexedPropertyDescriptorCallbackTag,583  kApiIndexedPropertyDefinerCallbackTag,584  kApiIndexedPropertyDeleterCallbackTag,585  kApiIndexedPropertyEnumeratorCallbackTag,586  kApiAccessCheckCallbackTag,587  kApiAbortScriptExecutionCallbackTag,588  kSyntheticModuleTag,589  kMicrotaskCallbackTag,590  kMicrotaskCallbackDataTag,591  kCFunctionTag,592  kCFunctionInfoTag,593  kMessageListenerTag,594  kWaiterQueueForeignTag,595 596  // Managed597  kFirstManagedResourceTag,598  kFirstManagedExternalPointerTag = kFirstManagedResourceTag,599  kGenericManagedTag = kFirstManagedExternalPointerTag,600  kWasmWasmStreamingTag,601  kWasmFuncDataTag,602  kWasmManagedDataTag,603  kWasmNativeModuleTag,604  kIcuBreakIteratorTag,605  kIcuUnicodeStringTag,606  kIcuListFormatterTag,607  kIcuLocaleTag,608  kIcuSimpleDateFormatTag,609  kIcuDateIntervalFormatTag,610  kIcuRelativeDateTimeFormatterTag,611  kIcuLocalizedNumberFormatterTag,612  kIcuPluralRulesTag,613  kIcuCollatorTag,614  kDisplayNamesInternalTag,615  kD8WorkerTag,616  kD8ModuleEmbedderDataTag,617  kLastForeignExternalPointerTag = kD8ModuleEmbedderDataTag,618  kLastManagedExternalPointerTag = kLastForeignExternalPointerTag,619  // External resources whose lifetime is tied to their entry in the external620  // pointer table but which are not referenced via a Managed621  kArrayBufferExtensionTag,622  kLastManagedResourceTag = kArrayBufferExtensionTag,623 624  kExternalPointerZappedEntryTag = 0x7d,625  kExternalPointerEvacuationEntryTag = 0x7e,626  kExternalPointerFreeEntryTag = 0x7f,627  // The tags are limited to 7 bits, so the last tag is 0x7f.628  kLastExternalPointerTag = 0x7f,629};630 631using ExternalPointerTagRange = TagRange<ExternalPointerTag>;632 633constexpr ExternalPointerTagRange kAnyExternalPointerTagRange(634    kFirstExternalPointerTag, kLastExternalPointerTag);635constexpr ExternalPointerTagRange kAnySharedExternalPointerTagRange(636    kFirstSharedExternalPointerTag, kLastSharedExternalPointerTag);637constexpr ExternalPointerTagRange kAnyForeignExternalPointerTagRange(638    kFirstForeignExternalPointerTag, kLastForeignExternalPointerTag);639constexpr ExternalPointerTagRange kAnyManagedExternalPointerTagRange(640    kFirstManagedExternalPointerTag, kLastManagedExternalPointerTag);641constexpr ExternalPointerTagRange kAnyMaybeReadOnlyExternalPointerTagRange(642    kFirstMaybeReadOnlyExternalPointerTag,643    kLastMaybeReadOnlyExternalPointerTag);644constexpr ExternalPointerTagRange kAnyManagedResourceExternalPointerTag(645    kFirstManagedResourceTag, kLastManagedResourceTag);646 647// True if the external pointer must be accessed from the shared isolate's648// external pointer table.649V8_INLINE static constexpr bool IsSharedExternalPointerType(650    ExternalPointerTagRange tag_range) {651  return kAnySharedExternalPointerTagRange.Contains(tag_range);652}653 654// True if the external pointer may live in a read-only object, in which case655// the table entry will be in the shared read-only segment of the external656// pointer table.657V8_INLINE static constexpr bool IsMaybeReadOnlyExternalPointerType(658    ExternalPointerTagRange tag_range) {659  return kAnyMaybeReadOnlyExternalPointerTagRange.Contains(tag_range);660}661 662// True if the external pointer references an external object whose lifetime is663// tied to the entry in the external pointer table.664// In this case, the entry in the ExternalPointerTable always points to an665// object derived from ExternalPointerTable::ManagedResource.666V8_INLINE static constexpr bool IsManagedExternalPointerType(667    ExternalPointerTagRange tag_range) {668  return kAnyManagedResourceExternalPointerTag.Contains(tag_range);669}670 671// When an external poiner field can contain the null external pointer handle,672// the type checking mechanism needs to also check for null.673// TODO(saelo): this is mostly a temporary workaround to introduce range-based674// type checks. In the future, we should either (a) change the type tagging675// scheme so that null always passes or (b) (more likely) introduce dedicated676// null entries for those tags that need them (similar to other well-known677// empty value constants such as the empty fixed array).678V8_INLINE static constexpr bool ExternalPointerCanBeEmpty(679    ExternalPointerTagRange tag_range) {680  return tag_range.Contains(kArrayBufferExtensionTag) ||681         tag_range.Contains(kEmbedderDataSlotPayloadTag);682}683 684// Indirect Pointers.685//686// When the sandbox is enabled, indirect pointers are used to reference687// HeapObjects that live outside of the sandbox (but are still managed by V8's688// garbage collector). When object A references an object B through an indirect689// pointer, object A will contain a IndirectPointerHandle, i.e. a shifted690// 32-bit index, which identifies an entry in a pointer table (either the691// trusted pointer table for TrustedObjects, or the code pointer table if it is692// a Code object). This table entry then contains the actual pointer to object693// B. Further, object B owns this pointer table entry, and it is responsible694// for updating the "self-pointer" in the entry when it is relocated in memory.695// This way, in contrast to "normal" pointers, indirect pointers never need to696// be tracked by the GC (i.e. there is no remembered set for them).697// These pointers do not exist when the sandbox is disabled.698 699// An IndirectPointerHandle represents a 32-bit index into a pointer table.700using IndirectPointerHandle = uint32_t;701 702// A null handle always references an entry that contains nullptr.703constexpr IndirectPointerHandle kNullIndirectPointerHandle = 0;704 705// When the sandbox is enabled, indirect pointers are used to implement:706// - TrustedPointers: an indirect pointer using the trusted pointer table (TPT)707//   and referencing a TrustedObject in one of the trusted heap spaces.708// - CodePointers, an indirect pointer using the code pointer table (CPT) and709//   referencing a Code object together with its instruction stream.710 711//712// Trusted Pointers.713//714// A pointer to a TrustedObject.715// When the sandbox is enabled, these are indirect pointers using the trusted716// pointer table (TPT). They are used to reference trusted objects (located in717// one of V8's trusted heap spaces, outside of the sandbox) from inside the718// sandbox in a memory-safe way. When the sandbox is disabled, these are719// regular tagged pointers.720using TrustedPointerHandle = IndirectPointerHandle;721 722// The size of the virtual memory reservation for the trusted pointer table.723// As with the external pointer table, a maximum table size in combination with724// shifted indices allows omitting bounds checks.725constexpr size_t kTrustedPointerTableReservationSize = 64 * MB;726 727// The trusted pointer handles are stored shifted to the left by this amount728// to guarantee that they are smaller than the maximum table size.729constexpr uint32_t kTrustedPointerHandleShift = 9;730 731// A null handle always references an entry that contains nullptr.732constexpr TrustedPointerHandle kNullTrustedPointerHandle =733    kNullIndirectPointerHandle;734 735// The maximum number of entries in an trusted pointer table.736constexpr int kTrustedPointerTableEntrySize = 8;737constexpr int kTrustedPointerTableEntrySizeLog2 = 3;738constexpr size_t kMaxTrustedPointers =739    kTrustedPointerTableReservationSize / kTrustedPointerTableEntrySize;740static_assert((1 << (32 - kTrustedPointerHandleShift)) == kMaxTrustedPointers,741              "kTrustedPointerTableReservationSize and "742              "kTrustedPointerHandleShift don't match");743 744//745// Code Pointers.746//747// A pointer to a Code object.748// Essentially a specialized version of a trusted pointer that (when the749// sandbox is enabled) uses the code pointer table (CPT) instead of the TPT.750// Each entry in the CPT contains both a pointer to a Code object as well as a751// pointer to the Code's entrypoint. This allows calling/jumping into Code with752// one fewer memory access (compared to the case where the entrypoint pointer753// first needs to be loaded from the Code object). As such, a CodePointerHandle754// can be used both to obtain the referenced Code object and to directly load755// its entrypoint.756//757// When the sandbox is disabled, these are regular tagged pointers.758using CodePointerHandle = IndirectPointerHandle;759 760// The size of the virtual memory reservation for the code pointer table.761// As with the other tables, a maximum table size in combination with shifted762// indices allows omitting bounds checks.763constexpr size_t kCodePointerTableReservationSize = 128 * MB;764 765// Code pointer handles are shifted by a different amount than indirect pointer766// handles as the tables have a different maximum size.767constexpr uint32_t kCodePointerHandleShift = 9;768 769// A null handle always references an entry that contains nullptr.770constexpr CodePointerHandle kNullCodePointerHandle = kNullIndirectPointerHandle;771 772// It can sometimes be necessary to distinguish a code pointer handle from a773// trusted pointer handle. A typical example would be a union trusted pointer774// field that can refer to both Code objects and other trusted objects. To775// support these use-cases, we use a simple marking scheme where some of the776// low bits of a code pointer handle are set, while they will be unset on a777// trusted pointer handle. This way, the correct table to resolve the handle778// can be determined even in the absence of a type tag.779constexpr uint32_t kCodePointerHandleMarker = 0x1;780static_assert(kCodePointerHandleShift > 0);781static_assert(kTrustedPointerHandleShift > 0);782 783// The maximum number of entries in a code pointer table.784constexpr int kCodePointerTableEntrySize = 16;785constexpr int kCodePointerTableEntrySizeLog2 = 4;786constexpr size_t kMaxCodePointers =787    kCodePointerTableReservationSize / kCodePointerTableEntrySize;788static_assert(789    (1 << (32 - kCodePointerHandleShift)) == kMaxCodePointers,790    "kCodePointerTableReservationSize and kCodePointerHandleShift don't match");791 792constexpr int kCodePointerTableEntryEntrypointOffset = 0;793constexpr int kCodePointerTableEntryCodeObjectOffset = 8;794 795// Constants that can be used to mark places that should be modified once796// certain types of objects are moved out of the sandbox and into trusted space.797constexpr bool kRuntimeGeneratedCodeObjectsLiveInTrustedSpace = true;798constexpr bool kBuiltinCodeObjectsLiveInTrustedSpace = false;799constexpr bool kAllCodeObjectsLiveInTrustedSpace =800    kRuntimeGeneratedCodeObjectsLiveInTrustedSpace &&801    kBuiltinCodeObjectsLiveInTrustedSpace;802 803// {obj} must be the raw tagged pointer representation of a HeapObject804// that's guaranteed to never be in ReadOnlySpace.805V8_EXPORT internal::Isolate* IsolateFromNeverReadOnlySpaceObject(Address obj);806 807// Returns if we need to throw when an error occurs. This infers the language808// mode based on the current context and the closure. This returns true if the809// language mode is strict.810V8_EXPORT bool ShouldThrowOnError(internal::Isolate* isolate);811/**812 * This class exports constants and functionality from within v8 that813 * is necessary to implement inline functions in the v8 api.  Don't814 * depend on functions and constants defined here.815 */816class Internals {817#ifdef V8_MAP_PACKING818  V8_INLINE static constexpr Address UnpackMapWord(Address mapword) {819    // TODO(wenyuzhao): Clear header metadata.820    return mapword ^ kMapWordXorMask;821  }822#endif823 824 public:825  // These values match non-compiler-dependent values defined within826  // the implementation of v8.827  static const int kHeapObjectMapOffset = 0;828  static const int kMapInstanceTypeOffset = 1 * kApiTaggedSize + kApiInt32Size;829  static const int kStringResourceOffset =830      1 * kApiTaggedSize + 2 * kApiInt32Size;831 832  static const int kOddballKindOffset = 4 * kApiTaggedSize + kApiDoubleSize;833  static const int kJSObjectHeaderSize = 3 * kApiTaggedSize;834#ifdef V8_COMPRESS_POINTERS835  static const int kJSAPIObjectWithEmbedderSlotsHeaderSize =836      kJSObjectHeaderSize + kApiInt32Size;837#else   // !V8_COMPRESS_POINTERS838  static const int kJSAPIObjectWithEmbedderSlotsHeaderSize =839      kJSObjectHeaderSize + kApiTaggedSize;840#endif  // !V8_COMPRESS_POINTERS841  static const int kFixedArrayHeaderSize = 2 * kApiTaggedSize;842  static const int kEmbedderDataArrayHeaderSize = 2 * kApiTaggedSize;843  static const int kEmbedderDataSlotSize = kApiSystemPointerSize;844#ifdef V8_ENABLE_SANDBOX845  static const int kEmbedderDataSlotExternalPointerOffset = kApiTaggedSize;846#else847  static const int kEmbedderDataSlotExternalPointerOffset = 0;848#endif849  static const int kNativeContextEmbedderDataOffset = 6 * kApiTaggedSize;850  static const int kStringRepresentationAndEncodingMask = 0x0f;851  static const int kStringEncodingMask = 0x8;852  static const int kExternalTwoByteRepresentationTag = 0x02;853  static const int kExternalOneByteRepresentationTag = 0x0a;854 855  static const uint32_t kNumIsolateDataSlots = 4;856  static const int kStackGuardSize = 8 * kApiSystemPointerSize;857  static const int kNumberOfBooleanFlags = 6;858  static const int kErrorMessageParamSize = 1;859  static const int kTablesAlignmentPaddingSize = 1;860  static const int kRegExpStaticResultOffsetsVectorSize = kApiSystemPointerSize;861  static const int kBuiltinTier0EntryTableSize = 7 * kApiSystemPointerSize;862  static const int kBuiltinTier0TableSize = 7 * kApiSystemPointerSize;863  static const int kLinearAllocationAreaSize = 3 * kApiSystemPointerSize;864  static const int kThreadLocalTopSize = 30 * kApiSystemPointerSize;865  static const int kHandleScopeDataSize =866      2 * kApiSystemPointerSize + 2 * kApiInt32Size;867 868  // ExternalPointerTable and TrustedPointerTable layout guarantees.869  static const int kExternalPointerTableBasePointerOffset = 0;870  static const int kExternalPointerTableSize = 2 * kApiSystemPointerSize;871  static const int kTrustedPointerTableSize = 2 * kApiSystemPointerSize;872  static const int kTrustedPointerTableBasePointerOffset = 0;873 874  // IsolateData layout guarantees.875  static const int kIsolateCageBaseOffset = 0;876  static const int kIsolateStackGuardOffset =877      kIsolateCageBaseOffset + kApiSystemPointerSize;878  static const int kVariousBooleanFlagsOffset =879      kIsolateStackGuardOffset + kStackGuardSize;880  static const int kErrorMessageParamOffset =881      kVariousBooleanFlagsOffset + kNumberOfBooleanFlags;882  static const int kBuiltinTier0EntryTableOffset =883      kErrorMessageParamOffset + kErrorMessageParamSize +884      kTablesAlignmentPaddingSize + kRegExpStaticResultOffsetsVectorSize;885  static const int kBuiltinTier0TableOffset =886      kBuiltinTier0EntryTableOffset + kBuiltinTier0EntryTableSize;887  static const int kNewAllocationInfoOffset =888      kBuiltinTier0TableOffset + kBuiltinTier0TableSize;889  static const int kOldAllocationInfoOffset =890      kNewAllocationInfoOffset + kLinearAllocationAreaSize;891 892  static const int kFastCCallAlignmentPaddingSize =893      kApiSystemPointerSize == 8 ? 5 * kApiSystemPointerSize894                                 : 1 * kApiSystemPointerSize;895  static const int kIsolateFastCCallCallerPcOffset =896      kOldAllocationInfoOffset + kLinearAllocationAreaSize +897      kFastCCallAlignmentPaddingSize;898  static const int kIsolateFastCCallCallerFpOffset =899      kIsolateFastCCallCallerPcOffset + kApiSystemPointerSize;900  static const int kIsolateFastApiCallTargetOffset =901      kIsolateFastCCallCallerFpOffset + kApiSystemPointerSize;902  static const int kIsolateLongTaskStatsCounterOffset =903      kIsolateFastApiCallTargetOffset + kApiSystemPointerSize;904  static const int kIsolateThreadLocalTopOffset =905      kIsolateLongTaskStatsCounterOffset + kApiSizetSize;906  static const int kIsolateHandleScopeDataOffset =907      kIsolateThreadLocalTopOffset + kThreadLocalTopSize;908  static const int kIsolateEmbedderDataOffset =909      kIsolateHandleScopeDataOffset + kHandleScopeDataSize;910#ifdef V8_COMPRESS_POINTERS911  static const int kIsolateExternalPointerTableOffset =912      kIsolateEmbedderDataOffset + kNumIsolateDataSlots * kApiSystemPointerSize;913  static const int kIsolateSharedExternalPointerTableAddressOffset =914      kIsolateExternalPointerTableOffset + kExternalPointerTableSize;915  static const int kIsolateCppHeapPointerTableOffset =916      kIsolateSharedExternalPointerTableAddressOffset + kApiSystemPointerSize;917#ifdef V8_ENABLE_SANDBOX918  static const int kIsolateTrustedCageBaseOffset =919      kIsolateCppHeapPointerTableOffset + kExternalPointerTableSize;920  static const int kIsolateTrustedPointerTableOffset =921      kIsolateTrustedCageBaseOffset + kApiSystemPointerSize;922  static const int kIsolateSharedTrustedPointerTableAddressOffset =923      kIsolateTrustedPointerTableOffset + kTrustedPointerTableSize;924  static const int kIsolateTrustedPointerPublishingScopeOffset =925      kIsolateSharedTrustedPointerTableAddressOffset + kApiSystemPointerSize;926  static const int kIsolateCodePointerTableBaseAddressOffset =927      kIsolateTrustedPointerPublishingScopeOffset + kApiSystemPointerSize;928  static const int kIsolateApiCallbackThunkArgumentOffset =929      kIsolateCodePointerTableBaseAddressOffset + kApiSystemPointerSize;930#else931  static const int kIsolateApiCallbackThunkArgumentOffset =932      kIsolateCppHeapPointerTableOffset + kExternalPointerTableSize;933#endif  // V8_ENABLE_SANDBOX934#else935  static const int kIsolateApiCallbackThunkArgumentOffset =936      kIsolateEmbedderDataOffset + kNumIsolateDataSlots * kApiSystemPointerSize;937#endif  // V8_COMPRESS_POINTERS938  static const int kIsolateRegexpExecVectorArgumentOffset =939      kIsolateApiCallbackThunkArgumentOffset + kApiSystemPointerSize;940  static const int kContinuationPreservedEmbedderDataOffset =941      kIsolateRegexpExecVectorArgumentOffset + kApiSystemPointerSize;942  static const int kIsolateRootsOffset =943      kContinuationPreservedEmbedderDataOffset + kApiSystemPointerSize;944 945  // Assert scopes946  static const int kDisallowGarbageCollectionAlign = alignof(uint32_t);947  static const int kDisallowGarbageCollectionSize = sizeof(uint32_t);948 949#if V8_STATIC_ROOTS_BOOL950 951// These constants are copied from static-roots.h and guarded by static asserts.952#define EXPORTED_STATIC_ROOTS_PTR_LIST(V) \953  V(UndefinedValue, 0x11)                 \954  V(NullValue, 0x2d)                      \955  V(TrueValue, 0x71)                      \956  V(FalseValue, 0x55)                     \957  V(EmptyString, 0x49)                    \958  V(TheHoleValue, 0x761)959 960  using Tagged_t = uint32_t;961  struct StaticReadOnlyRoot {962#define DEF_ROOT(name, value) static constexpr Tagged_t k##name = value;963    EXPORTED_STATIC_ROOTS_PTR_LIST(DEF_ROOT)964#undef DEF_ROOT965 966    // Use 0 for kStringMapLowerBound since string maps are the first maps.967    static constexpr Tagged_t kStringMapLowerBound = 0;968    static constexpr Tagged_t kStringMapUpperBound = 0x425;969 970#define PLUSONE(...) +1971    static constexpr size_t kNumberOfExportedStaticRoots =972        2 + EXPORTED_STATIC_ROOTS_PTR_LIST(PLUSONE);973#undef PLUSONE974  };975 976#endif  // V8_STATIC_ROOTS_BOOL977 978  static const int kUndefinedValueRootIndex = 4;979  static const int kTheHoleValueRootIndex = 5;980  static const int kNullValueRootIndex = 6;981  static const int kTrueValueRootIndex = 7;982  static const int kFalseValueRootIndex = 8;983  static const int kEmptyStringRootIndex = 9;984 985  static const int kNodeClassIdOffset = 1 * kApiSystemPointerSize;986  static const int kNodeFlagsOffset = 1 * kApiSystemPointerSize + 3;987  static const int kNodeStateMask = 0x3;988  static const int kNodeStateIsWeakValue = 2;989 990  static const int kFirstNonstringType = 0x80;991  static const int kOddballType = 0x83;992  static const int kForeignType = 0xcc;993  static const int kJSSpecialApiObjectType = 0x410;994  static const int kJSObjectType = 0x421;995  static const int kFirstJSApiObjectType = 0x422;996  static const int kLastJSApiObjectType = 0x80A;997  // Defines a range [kFirstEmbedderJSApiObjectType, kJSApiObjectTypesCount]998  // of JSApiObject instance type values that an embedder can use.999  static const int kFirstEmbedderJSApiObjectType = 0;1000  static const int kLastEmbedderJSApiObjectType =1001      kLastJSApiObjectType - kFirstJSApiObjectType;1002 1003  static const int kUndefinedOddballKind = 4;1004  static const int kNullOddballKind = 3;1005 1006  // Constants used by PropertyCallbackInfo to check if we should throw when an1007  // error occurs.1008  static const int kDontThrow = 0;1009  static const int kThrowOnError = 1;1010  static const int kInferShouldThrowMode = 2;1011 1012  // Soft limit for AdjustAmountofExternalAllocatedMemory. Trigger an1013  // incremental GC once the external memory reaches this limit.1014  static constexpr size_t kExternalAllocationSoftLimit = 64 * 1024 * 1024;1015 1016#ifdef V8_MAP_PACKING1017  static const uintptr_t kMapWordMetadataMask = 0xffffULL << 48;1018  // The lowest two bits of mapwords are always `0b10`1019  static const uintptr_t kMapWordSignature = 0b10;1020  // XORing a (non-compressed) map with this mask ensures that the two1021  // low-order bits are 0b10. The 0 at the end makes this look like a Smi,1022  // although real Smis have all lower 32 bits unset. We only rely on these1023  // values passing as Smis in very few places.1024  static const int kMapWordXorMask = 0b11;1025#endif1026 1027  V8_EXPORT static void CheckInitializedImpl(v8::Isolate* isolate);1028  V8_INLINE static void CheckInitialized(v8::Isolate* isolate) {1029#ifdef V8_ENABLE_CHECKS1030    CheckInitializedImpl(isolate);1031#endif1032  }1033 1034  V8_INLINE static constexpr bool HasHeapObjectTag(Address value) {1035    return (value & kHeapObjectTagMask) == static_cast<Address>(kHeapObjectTag);1036  }1037 1038  V8_INLINE static constexpr int SmiValue(Address value) {1039    return PlatformSmiTagging::SmiToInt(value);1040  }1041 1042  V8_INLINE static constexpr Address AddressToSmi(Address value) {1043    return (value << (kSmiTagSize + PlatformSmiTagging::kSmiShiftSize)) |1044           kSmiTag;1045  }1046 1047  V8_INLINE static constexpr Address IntToSmi(int value) {1048    return AddressToSmi(static_cast<Address>(value));1049  }1050 1051  template <typename T,1052            typename std::enable_if_t<std::is_integral_v<T>>* = nullptr>1053  V8_INLINE static constexpr Address IntegralToSmi(T value) {1054    return AddressToSmi(static_cast<Address>(value));1055  }1056 1057  template <typename T,1058            typename std::enable_if_t<std::is_integral_v<T>>* = nullptr>1059  V8_INLINE static constexpr bool IsValidSmi(T value) {1060    return PlatformSmiTagging::IsValidSmi(value);1061  }1062 1063  template <typename T,1064            typename std::enable_if_t<std::is_integral_v<T>>* = nullptr>1065  static constexpr std::optional<Address> TryIntegralToSmi(T value) {1066    if (V8_LIKELY(PlatformSmiTagging::IsValidSmi(value))) {1067      return {AddressToSmi(static_cast<Address>(value))};1068    }1069    return {};1070  }1071 1072#if V8_STATIC_ROOTS_BOOL1073  V8_INLINE static bool is_identical(Address obj, Tagged_t constant) {1074    return static_cast<Tagged_t>(obj) == constant;1075  }1076 1077  V8_INLINE static bool CheckInstanceMapRange(Address obj, Tagged_t first_map,1078                                              Tagged_t last_map) {1079    auto map = ReadRawField<Tagged_t>(obj, kHeapObjectMapOffset);1080#ifdef V8_MAP_PACKING1081    map = UnpackMapWord(map);1082#endif1083    return map >= first_map && map <= last_map;1084  }1085#endif1086 1087  V8_INLINE static int GetInstanceType(Address obj) {1088    Address map = ReadTaggedPointerField(obj, kHeapObjectMapOffset);1089#ifdef V8_MAP_PACKING1090    map = UnpackMapWord(map);1091#endif1092    return ReadRawField<uint16_t>(map, kMapInstanceTypeOffset);1093  }1094 1095  V8_INLINE static Address LoadMap(Address obj) {1096    if (!HasHeapObjectTag(obj)) return kNullAddress;1097    Address map = ReadTaggedPointerField(obj, kHeapObjectMapOffset);1098#ifdef V8_MAP_PACKING1099    map = UnpackMapWord(map);1100#endif1101    return map;1102  }1103 1104  V8_INLINE static int GetOddballKind(Address obj) {1105    return SmiValue(ReadTaggedSignedField(obj, kOddballKindOffset));1106  }1107 1108  V8_INLINE static bool IsExternalTwoByteString(int instance_type) {1109    int representation = (instance_type & kStringRepresentationAndEncodingMask);1110    return representation == kExternalTwoByteRepresentationTag;1111  }1112 1113  V8_INLINE static constexpr bool CanHaveInternalField(int instance_type) {1114    static_assert(kJSObjectType + 1 == kFirstJSApiObjectType);1115    static_assert(kJSObjectType < kLastJSApiObjectType);1116    static_assert(kFirstJSApiObjectType < kLastJSApiObjectType);1117    // Check for IsJSObject() || IsJSSpecialApiObject() || IsJSApiObject()1118    return instance_type == kJSSpecialApiObjectType ||1119           // inlined version of base::IsInRange1120           (static_cast<unsigned>(static_cast<unsigned>(instance_type) -1121                                  static_cast<unsigned>(kJSObjectType)) <=1122            static_cast<unsigned>(kLastJSApiObjectType - kJSObjectType));1123  }1124 1125  V8_INLINE static uint8_t GetNodeFlag(Address* obj, int shift) {1126    uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;1127    return *addr & static_cast<uint8_t>(1U << shift);1128  }1129 1130  V8_INLINE static void UpdateNodeFlag(Address* obj, bool value, int shift) {1131    uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;1132    uint8_t mask = static_cast<uint8_t>(1U << shift);1133    *addr = static_cast<uint8_t>((*addr & ~mask) | (value << shift));1134  }1135 1136  V8_INLINE static uint8_t GetNodeState(Address* obj) {1137    uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;1138    return *addr & kNodeStateMask;1139  }1140 1141  V8_INLINE static void UpdateNodeState(Address* obj, uint8_t value) {1142    uint8_t* addr = reinterpret_cast<uint8_t*>(obj) + kNodeFlagsOffset;1143    *addr = static_cast<uint8_t>((*addr & ~kNodeStateMask) | value);1144  }1145 1146  V8_INLINE static void SetEmbedderData(v8::Isolate* isolate, uint32_t slot,1147                                        void* data) {1148    Address addr = reinterpret_cast<Address>(isolate) +1149                   kIsolateEmbedderDataOffset + slot * kApiSystemPointerSize;1150    *reinterpret_cast<void**>(addr) = data;1151  }1152 1153  V8_INLINE static void* GetEmbedderData(const v8::Isolate* isolate,1154                                         uint32_t slot) {1155    Address addr = reinterpret_cast<Address>(isolate) +1156                   kIsolateEmbedderDataOffset + slot * kApiSystemPointerSize;1157    return *reinterpret_cast<void* const*>(addr);1158  }1159 1160  V8_INLINE static void IncrementLongTasksStatsCounter(v8::Isolate* isolate) {1161    Address addr =1162        reinterpret_cast<Address>(isolate) + kIsolateLongTaskStatsCounterOffset;1163    ++(*reinterpret_cast<size_t*>(addr));1164  }1165 1166  V8_INLINE static Address* GetRootSlot(v8::Isolate* isolate, int index) {1167    Address addr = reinterpret_cast<Address>(isolate) + kIsolateRootsOffset +1168                   index * kApiSystemPointerSize;1169    return reinterpret_cast<Address*>(addr);1170  }1171 1172  V8_INLINE static Address GetRoot(v8::Isolate* isolate, int index) {1173#if V8_STATIC_ROOTS_BOOL1174    Address base = *reinterpret_cast<Address*>(1175        reinterpret_cast<uintptr_t>(isolate) + kIsolateCageBaseOffset);1176    switch (index) {1177#define DECOMPRESS_ROOT(name, ...) \1178  case k##name##RootIndex:         \1179    return base + StaticReadOnlyRoot::k##name;1180      EXPORTED_STATIC_ROOTS_PTR_LIST(DECOMPRESS_ROOT)1181#undef DECOMPRESS_ROOT1182#undef EXPORTED_STATIC_ROOTS_PTR_LIST1183      default:1184        break;1185    }1186#endif  // V8_STATIC_ROOTS_BOOL1187    return *GetRootSlot(isolate, index);1188  }1189 1190#ifdef V8_ENABLE_SANDBOX1191  V8_INLINE static Address* GetExternalPointerTableBase(v8::Isolate* isolate) {1192    Address addr = reinterpret_cast<Address>(isolate) +1193                   kIsolateExternalPointerTableOffset +1194                   kExternalPointerTableBasePointerOffset;1195    return *reinterpret_cast<Address**>(addr);1196  }1197 1198  V8_INLINE static Address* GetSharedExternalPointerTableBase(1199      v8::Isolate* isolate) {1200    Address addr = reinterpret_cast<Address>(isolate) +1201                   kIsolateSharedExternalPointerTableAddressOffset;1202    addr = *reinterpret_cast<Address*>(addr);1203    addr += kExternalPointerTableBasePointerOffset;1204    return *reinterpret_cast<Address**>(addr);1205  }1206#endif1207 1208  template <typename T>1209  V8_INLINE static T ReadRawField(Address heap_object_ptr, int offset) {1210    Address addr = heap_object_ptr + offset - kHeapObjectTag;1211#ifdef V8_COMPRESS_POINTERS1212    if (sizeof(T) > kApiTaggedSize) {1213      // TODO(ishell, v8:8875): When pointer compression is enabled 8-byte size1214      // fields (external pointers, doubles and BigInt data) are only1215      // kTaggedSize aligned so we have to use unaligned pointer friendly way of1216      // accessing them in order to avoid undefined behavior in C++ code.1217      T r;1218      memcpy(&r, reinterpret_cast<void*>(addr), sizeof(T));1219      return r;1220    }1221#endif1222    return *reinterpret_cast<const T*>(addr);1223  }1224 1225  V8_INLINE static Address ReadTaggedPointerField(Address heap_object_ptr,1226                                                  int offset) {1227#ifdef V8_COMPRESS_POINTERS1228    uint32_t value = ReadRawField<uint32_t>(heap_object_ptr, offset);1229    Address base = GetPtrComprCageBaseFromOnHeapAddress(heap_object_ptr);1230    return base + static_cast<Address>(static_cast<uintptr_t>(value));1231#else1232    return ReadRawField<Address>(heap_object_ptr, offset);1233#endif1234  }1235 1236  V8_INLINE static Address ReadTaggedSignedField(Address heap_object_ptr,1237                                                 int offset) {1238#ifdef V8_COMPRESS_POINTERS1239    uint32_t value = ReadRawField<uint32_t>(heap_object_ptr, offset);1240    return static_cast<Address>(static_cast<uintptr_t>(value));1241#else1242    return ReadRawField<Address>(heap_object_ptr, offset);1243#endif1244  }1245 1246  V8_INLINE static v8::Isolate* GetIsolateForSandbox(Address obj) {1247#ifdef V8_ENABLE_SANDBOX1248    return reinterpret_cast<v8::Isolate*>(1249        internal::IsolateFromNeverReadOnlySpaceObject(obj));1250#else1251    // Not used in non-sandbox mode.1252    return nullptr;1253#endif1254  }1255 1256  template <ExternalPointerTagRange tag_range>1257  V8_INLINE static Address ReadExternalPointerField(v8::Isolate* isolate,1258                                                    Address heap_object_ptr,1259                                                    int offset) {1260#ifdef V8_ENABLE_SANDBOX1261    static_assert(!tag_range.IsEmpty());1262    // See src/sandbox/external-pointer-table.h. Logic duplicated here so1263    // it can be inlined and doesn't require an additional call.1264    Address* table = IsSharedExternalPointerType(tag_range)1265                         ? GetSharedExternalPointerTableBase(isolate)1266                         : GetExternalPointerTableBase(isolate);1267    internal::ExternalPointerHandle handle =1268        ReadRawField<ExternalPointerHandle>(heap_object_ptr, offset);1269    uint32_t index = handle >> kExternalPointerIndexShift;1270    std::atomic<Address>* ptr =1271        reinterpret_cast<std::atomic<Address>*>(&table[index]);1272    Address entry = std::atomic_load_explicit(ptr, std::memory_order_relaxed);1273    ExternalPointerTag actual_tag = static_cast<ExternalPointerTag>(1274        (entry & kExternalPointerTagMask) >> kExternalPointerTagShift);1275    if (V8_LIKELY(tag_range.Contains(actual_tag))) {1276      return entry & kExternalPointerPayloadMask;1277    } else {1278      return 0;1279    }1280    return entry;1281#else1282    return ReadRawField<Address>(heap_object_ptr, offset);1283#endif  // V8_ENABLE_SANDBOX1284  }1285 1286#ifdef V8_COMPRESS_POINTERS1287  V8_INLINE static Address GetPtrComprCageBaseFromOnHeapAddress(Address addr) {1288    return addr & -static_cast<intptr_t>(kPtrComprCageBaseAlignment);1289  }1290 1291  V8_INLINE static uint32_t CompressTagged(Address value) {1292    return static_cast<uint32_t>(value);1293  }1294 1295  V8_INLINE static Address DecompressTaggedField(Address heap_object_ptr,1296                                                 uint32_t value) {1297    Address base = GetPtrComprCageBaseFromOnHeapAddress(heap_object_ptr);1298    return base + static_cast<Address>(static_cast<uintptr_t>(value));1299  }1300 1301#endif  // V8_COMPRESS_POINTERS1302};1303 1304// Only perform cast check for types derived from v8::Data since1305// other types do not implement the Cast method.1306template <bool PerformCheck>1307struct CastCheck {1308  template <class T>1309  static void Perform(T* data);1310};1311 1312template <>1313template <class T>1314void CastCheck<true>::Perform(T* data) {1315  T::Cast(data);1316}1317 1318template <>1319template <class T>1320void CastCheck<false>::Perform(T* data) {}1321 1322template <class T>1323V8_INLINE void PerformCastCheck(T* data) {1324  CastCheck<std::is_base_of<Data, T>::value &&1325            !std::is_same<Data, std::remove_cv_t<T>>::value>::Perform(data);1326}1327 1328// A base class for backing stores, which is needed due to vagaries of1329// how static casts work with std::shared_ptr.1330class BackingStoreBase {};1331 1332// The maximum value in enum GarbageCollectionReason, defined in heap.h.1333// This is needed for histograms sampling garbage collection reasons.1334constexpr int kGarbageCollectionReasonMaxValue = 29;1335 1336// Base class for the address block allocator compatible with standard1337// containers, which registers its allocated range as strong roots.1338class V8_EXPORT StrongRootAllocatorBase {1339 public:1340  Heap* heap() const { return heap_; }1341 1342  friend bool operator==(const StrongRootAllocatorBase& a,1343                         const StrongRootAllocatorBase& b) {1344    // TODO(pkasting): Replace this body with `= default` after dropping support1345    // for old gcc versions.1346    return a.heap_ == b.heap_;1347  }1348 1349 protected:1350  explicit StrongRootAllocatorBase(Heap* heap) : heap_(heap) {}1351  explicit StrongRootAllocatorBase(LocalHeap* heap);1352  explicit StrongRootAllocatorBase(Isolate* isolate);1353  explicit StrongRootAllocatorBase(v8::Isolate* isolate);1354  explicit StrongRootAllocatorBase(LocalIsolate* isolate);1355 1356  // Allocate/deallocate a range of n elements of type internal::Address.1357  Address* allocate_impl(size_t n);1358  void deallocate_impl(Address* p, size_t n) noexcept;1359 1360 private:1361  Heap* heap_;1362};1363 1364// The general version of this template behaves just as std::allocator, with1365// the exception that the constructor takes the isolate as parameter. Only1366// specialized versions, e.g., internal::StrongRootAllocator<internal::Address>1367// and internal::StrongRootAllocator<v8::Local<T>> register the allocated range1368// as strong roots.1369template <typename T>1370class StrongRootAllocator : private std::allocator<T> {1371 public:1372  using value_type = T;1373 1374  template <typename HeapOrIsolateT>1375  explicit StrongRootAllocator(HeapOrIsolateT*) {}1376  template <typename U>1377  StrongRootAllocator(const StrongRootAllocator<U>& other) noexcept {}1378 1379  using std::allocator<T>::allocate;1380  using std::allocator<T>::deallocate;1381};1382 1383// TODO(pkasting): Replace with `requires` clauses after dropping support for1384// old gcc versions.1385template <typename Iterator, typename = void>1386inline constexpr bool kHaveIteratorConcept = false;1387template <typename Iterator>1388inline constexpr bool kHaveIteratorConcept<1389    Iterator, std::void_t<typename Iterator::iterator_concept>> = true;1390 1391template <typename Iterator, typename = void>1392inline constexpr bool kHaveIteratorCategory = false;1393template <typename Iterator>1394inline constexpr bool kHaveIteratorCategory<1395    Iterator, std::void_t<typename Iterator::iterator_category>> = true;1396 1397// Helper struct that contains an `iterator_concept` type alias only when either1398// `Iterator` or `std::iterator_traits<Iterator>` do.1399// Default: no alias.1400template <typename Iterator, typename = void>1401struct MaybeDefineIteratorConcept {};1402// Use `Iterator::iterator_concept` if available.1403template <typename Iterator>1404struct MaybeDefineIteratorConcept<1405    Iterator, std::enable_if_t<kHaveIteratorConcept<Iterator>>> {1406  using iterator_concept = typename Iterator::iterator_concept;1407};1408// Otherwise fall back to `std::iterator_traits<Iterator>` if possible.1409template <typename Iterator>1410struct MaybeDefineIteratorConcept<1411    Iterator, std::enable_if_t<kHaveIteratorCategory<Iterator> &&1412                               !kHaveIteratorConcept<Iterator>>> {1413  // There seems to be no feature-test macro covering this, so use the1414  // presence of `<ranges>` as a crude proxy, since it was added to the1415  // standard as part of the Ranges papers.1416  // TODO(pkasting): Add this unconditionally after dropping support for old1417  // libstdc++ versions.1418#if __has_include(<ranges>)1419  using iterator_concept =1420      typename std::iterator_traits<Iterator>::iterator_concept;1421#endif1422};1423 1424// A class of iterators that wrap some different iterator type.1425// If specified, ElementType is the type of element accessed by the wrapper1426// iterator; in this case, the actual reference and pointer types of Iterator1427// must be convertible to ElementType& and ElementType*, respectively.1428template <typename Iterator, typename ElementType = void>1429class WrappedIterator : public MaybeDefineIteratorConcept<Iterator> {1430 public:1431  static_assert(1432      std::is_void_v<ElementType> ||1433      (std::is_convertible_v<typename std::iterator_traits<Iterator>::pointer,1434                             std::add_pointer_t<ElementType>> &&1435       std::is_convertible_v<typename std::iterator_traits<Iterator>::reference,1436                             std::add_lvalue_reference_t<ElementType>>));1437 1438  using difference_type =1439      typename std::iterator_traits<Iterator>::difference_type;1440  using value_type =1441      std::conditional_t<std::is_void_v<ElementType>,1442                         typename std::iterator_traits<Iterator>::value_type,1443                         ElementType>;1444  using pointer =1445      std::conditional_t<std::is_void_v<ElementType>,1446                         typename std::iterator_traits<Iterator>::pointer,1447                         std::add_pointer_t<ElementType>>;1448  using reference =1449      std::conditional_t<std::is_void_v<ElementType>,1450                         typename std::iterator_traits<Iterator>::reference,1451                         std::add_lvalue_reference_t<ElementType>>;1452  using iterator_category =1453      typename std::iterator_traits<Iterator>::iterator_category;1454 1455  constexpr WrappedIterator() noexcept = default;1456  constexpr explicit WrappedIterator(Iterator it) noexcept : it_(it) {}1457 1458  // TODO(pkasting): Switch to `requires` and concepts after dropping support1459  // for old gcc and libstdc++ versions.1460  template <typename OtherIterator, typename OtherElementType,1461            typename = std::enable_if_t<1462                std::is_convertible_v<OtherIterator, Iterator>>>1463  constexpr WrappedIterator(1464      const WrappedIterator<OtherIterator, OtherElementType>& other) noexcept1465      : it_(other.base()) {}1466 1467  [[nodiscard]] constexpr reference operator*() const noexcept { return *it_; }1468  [[nodiscard]] constexpr pointer operator->() const noexcept {1469    if constexpr (std::is_pointer_v<Iterator>) {1470      return it_;1471    } else {1472      return it_.operator->();1473    }1474  }1475 1476  template <typename OtherIterator, typename OtherElementType>1477  [[nodiscard]] constexpr bool operator==(1478      const WrappedIterator<OtherIterator, OtherElementType>& other)1479      const noexcept {1480    return it_ == other.base();1481  }1482#if V8_HAVE_SPACESHIP_OPERATOR1483  template <typename OtherIterator, typename OtherElementType>1484  [[nodiscard]] constexpr auto operator<=>(1485      const WrappedIterator<OtherIterator, OtherElementType>& other)1486      const noexcept {1487    if constexpr (std::three_way_comparable_with<Iterator, OtherIterator>) {1488      return it_ <=> other.base();1489    } else if constexpr (std::totally_ordered_with<Iterator, OtherIterator>) {1490      if (it_ < other.base()) {1491        return std::strong_ordering::less;1492      }1493      return (it_ > other.base()) ? std::strong_ordering::greater1494                                  : std::strong_ordering::equal;1495    } else {1496      if (it_ < other.base()) {1497        return std::partial_ordering::less;1498      }1499      if (other.base() < it_) {1500        return std::partial_ordering::greater;1501      }1502      return (it_ == other.base()) ? std::partial_ordering::equivalent1503                                   : std::partial_ordering::unordered;1504    }1505  }1506#else1507  // Assume that if spaceship isn't present, operator rewriting might not be1508  // either.1509  template <typename OtherIterator, typename OtherElementType>1510  [[nodiscard]] constexpr bool operator!=(1511      const WrappedIterator<OtherIterator, OtherElementType>& other)1512      const noexcept {1513    return it_ != other.base();1514  }1515 1516  template <typename OtherIterator, typename OtherElementType>1517  [[nodiscard]] constexpr bool operator<(1518      const WrappedIterator<OtherIterator, OtherElementType>& other)1519      const noexcept {1520    return it_ < other.base();1521  }1522  template <typename OtherIterator, typename OtherElementType>1523  [[nodiscard]] constexpr bool operator<=(1524      const WrappedIterator<OtherIterator, OtherElementType>& other)1525      const noexcept {1526    return it_ <= other.base();1527  }1528  template <typename OtherIterator, typename OtherElementType>1529  [[nodiscard]] constexpr bool operator>(1530      const WrappedIterator<OtherIterator, OtherElementType>& other)1531      const noexcept {1532    return it_ > other.base();1533  }1534  template <typename OtherIterator, typename OtherElementType>1535  [[nodiscard]] constexpr bool operator>=(1536      const WrappedIterator<OtherIterator, OtherElementType>& other)1537      const noexcept {1538    return it_ >= other.base();1539  }1540#endif1541 1542  constexpr WrappedIterator& operator++() noexcept {1543    ++it_;1544    return *this;1545  }1546  constexpr WrappedIterator operator++(int) noexcept {1547    WrappedIterator result(*this);1548    ++(*this);1549    return result;1550  }1551 1552  constexpr WrappedIterator& operator--() noexcept {1553    --it_;1554    return *this;1555  }1556  constexpr WrappedIterator operator--(int) noexcept {1557    WrappedIterator result(*this);1558    --(*this);1559    return result;1560  }1561  [[nodiscard]] constexpr WrappedIterator operator+(1562      difference_type n) const noexcept {1563    WrappedIterator result(*this);1564    result += n;1565    return result;1566  }1567  [[nodiscard]] friend constexpr WrappedIterator operator+(1568      difference_type n, const WrappedIterator& x) noexcept {1569    return x + n;1570  }1571  constexpr WrappedIterator& operator+=(difference_type n) noexcept {1572    it_ += n;1573    return *this;1574  }1575  [[nodiscard]] constexpr WrappedIterator operator-(1576      difference_type n) const noexcept {1577    return *this + -n;1578  }1579  constexpr WrappedIterator& operator-=(difference_type n) noexcept {1580    return *this += -n;1581  }1582  template <typename OtherIterator, typename OtherElementType>1583  [[nodiscard]] constexpr auto operator-(1584      const WrappedIterator<OtherIterator, OtherElementType>& other)1585      const noexcept {1586    return it_ - other.base();1587  }1588  [[nodiscard]] constexpr reference operator[](1589      difference_type n) const noexcept {1590    return it_[n];1591  }1592 1593  [[nodiscard]] constexpr const Iterator& base() const noexcept { return it_; }1594 1595 private:1596  Iterator it_;1597};1598 1599// Helper functions about values contained in handles.1600// A value is either an indirect pointer or a direct pointer, depending on1601// whether direct local support is enabled.1602class ValueHelper final {1603 public:1604  // ValueHelper::InternalRepresentationType is an abstract type that1605  // corresponds to the internal representation of v8::Local and essentially1606  // to what T* really is (these two are always in sync). This type is used in1607  // methods like GetDataFromSnapshotOnce that need access to a handle's1608  // internal representation. In particular, if `x` is a `v8::Local<T>`, then1609  // `v8::Local<T>::FromRepr(x.repr())` gives exactly the same handle as `x`.1610#ifdef V8_ENABLE_DIRECT_HANDLE1611  static constexpr Address kTaggedNullAddress = 1;1612 1613  using InternalRepresentationType = internal::Address;1614  static constexpr InternalRepresentationType kEmpty = kTaggedNullAddress;1615#else1616  using InternalRepresentationType = internal::Address*;1617  static constexpr InternalRepresentationType kEmpty = nullptr;1618#endif  // V8_ENABLE_DIRECT_HANDLE1619 1620  template <typename T>1621  V8_INLINE static bool IsEmpty(T* value) {1622    return ValueAsRepr(value) == kEmpty;1623  }1624 1625  // Returns a handle's "value" for all kinds of abstract handles. For Local,1626  // it is equivalent to `*handle`. The variadic parameters support handle1627  // types with extra type parameters, like `Persistent<T, M>`.1628  template <template <typename T, typename... Ms> typename H, typename T,1629            typename... Ms>1630  V8_INLINE static T* HandleAsValue(const H<T, Ms...>& handle) {1631    return handle.template value<T>();1632  }1633 1634#ifdef V8_ENABLE_DIRECT_HANDLE1635 1636  template <typename T>1637  V8_INLINE static Address ValueAsAddress(const T* value) {1638    return reinterpret_cast<Address>(value);1639  }1640 1641  template <typename T, bool check_null = true, typename S>1642  V8_INLINE static T* SlotAsValue(S* slot) {1643    if (check_null && slot == nullptr) {1644      return reinterpret_cast<T*>(kTaggedNullAddress);1645    }1646    return *reinterpret_cast<T**>(slot);1647  }1648 1649  template <typename T>1650  V8_INLINE static InternalRepresentationType ValueAsRepr(const T* value) {1651    return reinterpret_cast<InternalRepresentationType>(value);1652  }1653 1654  template <typename T>1655  V8_INLINE static T* ReprAsValue(InternalRepresentationType repr) {1656    return reinterpret_cast<T*>(repr);1657  }1658 1659#else  // !V8_ENABLE_DIRECT_HANDLE1660 1661  template <typename T>1662  V8_INLINE static Address ValueAsAddress(const T* value) {1663    return *reinterpret_cast<const Address*>(value);1664  }1665 1666  template <typename T, bool check_null = true, typename S>1667  V8_INLINE static T* SlotAsValue(S* slot) {1668    return reinterpret_cast<T*>(slot);1669  }1670 1671  template <typename T>1672  V8_INLINE static InternalRepresentationType ValueAsRepr(const T* value) {1673    return const_cast<InternalRepresentationType>(1674        reinterpret_cast<const Address*>(value));1675  }1676 1677  template <typename T>1678  V8_INLINE static T* ReprAsValue(InternalRepresentationType repr) {1679    return reinterpret_cast<T*>(repr);1680  }1681 1682#endif  // V8_ENABLE_DIRECT_HANDLE1683};1684 1685/**1686 * Helper functions about handles.1687 */1688class HandleHelper final {1689 public:1690  /**1691   * Checks whether two handles are equal.1692   * They are equal iff they are both empty or they are both non-empty and the1693   * objects to which they refer are physically equal.1694   *1695   * If both handles refer to JS objects, this is the same as strict equality.1696   * For primitives, such as numbers or strings, a `false` return value does not1697   * indicate that the values aren't equal in the JavaScript sense.1698   * Use `Value::StrictEquals()` to check primitives for equality.1699   */1700  template <typename T1, typename T2>1701  V8_INLINE static bool EqualHandles(const T1& lhs, const T2& rhs) {1702    if (lhs.IsEmpty()) return rhs.IsEmpty();1703    if (rhs.IsEmpty()) return false;1704    return lhs.ptr() == rhs.ptr();1705  }1706};1707 1708V8_EXPORT void VerifyHandleIsNonEmpty(bool is_empty);1709 1710// These functions are here just to match friend declarations in1711// XxxCallbackInfo classes allowing these functions to access the internals1712// of the info objects. These functions are supposed to be called by debugger1713// macros.1714void PrintFunctionCallbackInfo(void* function_callback_info);1715void PrintPropertyCallbackInfo(void* property_callback_info);1716 1717}  // namespace internal1718}  // namespace v81719 1720#endif  // INCLUDE_V8_INTERNAL_H_1721