// Copyright 2012 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef V8_OBJECTS_OBJECTS_INL_H_
#define V8_OBJECTS_OBJECTS_INL_H_
// Review notes:
//
// - The use of macros in these inline functions may seem superfluous
// but it is absolutely needed to make sure gcc generates optimal
// code. gcc is not happy when attempting to inline too deep.
#include "src/objects/objects.h"
// Include the non-inl header before the rest of the headers.
#include "include/v8-internal.h"
#include "src/base/bits.h"
#include "src/base/bounds.h"
#include "src/base/memory.h"
#include "src/base/numbers/double.h"
#include "src/base/strong-alias.h"
#include "src/builtins/builtins.h"
#include "src/common/globals.h"
#include "src/common/ptr-compr-inl.h"
#include "src/handles/handles-inl.h"
#include "src/heap/factory.h"
#include "src/heap/heap-layout-inl.h"
#include "src/heap/heap-verifier.h"
#include "src/heap/heap-write-barrier-inl.h"
#include "src/heap/read-only-heap-inl.h"
#include "src/numbers/conversions-inl.h"
#include "src/objects/allocation-site.h"
#include "src/objects/bigint.h"
#include "src/objects/casting.h"
#include "src/objects/contexts-inl.h"
#include "src/objects/deoptimization-data.h"
#include "src/objects/descriptor-array.h"
#include "src/objects/field-type.h"
#include "src/objects/foreign.h"
#include "src/objects/heap-number-inl.h"
#include "src/objects/heap-object-inl.h"
#include "src/objects/hole.h"
#include "src/objects/instance-type-checker.h"
#include "src/objects/js-proxy.h"
#include "src/objects/keys.h"
#include "src/objects/literal-objects.h"
#include "src/objects/map-word-inl.h"
#include "src/objects/number-string-cache-inl.h"
#include "src/objects/object-list-macros.h"
#include "src/objects/object-predicates-inl.h"
#include "src/objects/oddball-inl.h"
#include "src/objects/property-details-inl.h"
#include "src/objects/property.h"
#include "src/objects/regexp-match-info-inl.h"
#include "src/objects/scope-info-inl.h"
#include "src/objects/shared-function-info.h"
#include "src/objects/smi-inl.h"
#include "src/objects/tagged-field-inl.h"
#include "src/objects/tagged-impl-inl.h"
#include "src/objects/tagged-index.h"
#include "src/objects/templates-inl.h"
#include "src/objects/trusted-pointer-inl.h"
#include "src/roots/roots.h"
#include "src/sandbox/isolate-inl.h"
// Has to be the last include (doesn't have include guards):
#include "src/objects/object-macros.h"
namespace v8 {
namespace internal {
template <typename T>
class Managed;
template <typename T>
class TrustedManaged;
// TODO(jkummerow): Most DEF_CAST_TRAITS(Foo) macro invocations should move to
// wherever `IsFoo(Tagged<HeapObject>)` is defined.
// TODO(leszeks): Expand Is<T> to all types.
DEF_CAST_TRAITS(AbstractCode)
DEF_CAST_TRAITS(AccessorInfo)
DEF_CAST_TRAITS(AllocationSite)
DEF_CAST_TRAITS(BigInt)
DEF_CAST_TRAITS(BigIntBase)
DEF_CAST_TRAITS(Boolean)
DEF_CAST_TRAITS(Cell)
DEF_CAST_TRAITS(CompilationCacheTable)
DEF_CAST_TRAITS(Context)
DEF_CAST_TRAITS(ContextCell)
DEF_CAST_TRAITS(CoverageInfo)
DEF_CAST_TRAITS(CppHeapExternalObject)
DEF_CAST_TRAITS(CppGCManagedBase)
DEF_CAST_TRAITS(DataHandler)
DEF_CAST_TRAITS(DeoptimizationData)
DEF_CAST_TRAITS(DescriptorArray)
DEF_CAST_TRAITS(DictionaryTemplateInfo)
DEF_CAST_TRAITS(EmbedderDataArray)
DEF_CAST_TRAITS(EphemeronHashTable)
DEF_CAST_TRAITS(FeedbackCell)
DEF_CAST_TRAITS(FeedbackMetadata)
DEF_CAST_TRAITS(FeedbackVector)
DEF_CAST_TRAITS(FixedArrayBase)
DEF_CAST_TRAITS(FixedArrayExact)
DEF_CAST_TRAITS(Foreign)
DEF_CAST_TRAITS(GcSafeCode)
DEF_CAST_TRAITS(GlobalDictionary)
DEF_CAST_TRAITS(HashSeedWrapper)
DEF_CAST_TRAITS(InterceptorInfo)
DEF_CAST_TRAITS(JSArgumentsObject)
DEF_CAST_TRAITS(JSArray)
DEF_CAST_TRAITS(JSArrayBuffer)
DEF_CAST_TRAITS(JSArrayBufferView)
DEF_CAST_TRAITS(JSArrayIterator)
DEF_CAST_TRAITS(JSAsyncFromSyncIterator)
DEF_CAST_TRAITS(JSAsyncFunctionObject)
DEF_CAST_TRAITS(JSAsyncGeneratorObject)
DEF_CAST_TRAITS(JSAtomicsCondition)
DEF_CAST_TRAITS(JSAtomicsMutex)
DEF_CAST_TRAITS(JSBoundFunction)
DEF_CAST_TRAITS(JSCollection)
DEF_CAST_TRAITS(JSCollectionIterator)
DEF_CAST_TRAITS(JSCustomElementsObject)
DEF_CAST_TRAITS(JSDataView)
DEF_CAST_TRAITS(JSDataViewOrRabGsabDataView)
DEF_CAST_TRAITS(JSDate)
DEF_CAST_TRAITS(JSDisposableStackBase)
DEF_CAST_TRAITS(JSSyncDisposableStack)
DEF_CAST_TRAITS(JSAsyncDisposableStack)
DEF_CAST_TRAITS(JSExternalObject)
DEF_CAST_TRAITS(JSFinalizationRegistry)
DEF_CAST_TRAITS(JSFunction)
DEF_CAST_TRAITS(JSFunctionWithoutPrototype)
DEF_CAST_TRAITS(JSFunctionWithPrototype)
DEF_CAST_TRAITS(JSFunctionOrBoundFunctionOrWrappedFunction)
DEF_CAST_TRAITS(JSGeneratorObject)
DEF_CAST_TRAITS(JSGlobalObject)
DEF_CAST_TRAITS(JSGlobalProxy)
DEF_CAST_TRAITS(JSIteratorHelper)
DEF_CAST_TRAITS(JSIteratorHelperSimple)
DEF_CAST_TRAITS(JSIteratorFilterHelper)
DEF_CAST_TRAITS(JSIteratorMapHelper)
DEF_CAST_TRAITS(JSIteratorTakeHelper)
DEF_CAST_TRAITS(JSIteratorDropHelper)
DEF_CAST_TRAITS(JSIteratorFlatMapHelper)
DEF_CAST_TRAITS(JSIteratorConcatHelper)
DEF_CAST_TRAITS(JSIteratorZipHelper)
DEF_CAST_TRAITS(JSIteratorZipKeyedHelper)
DEF_CAST_TRAITS(JSMap)
DEF_CAST_TRAITS(JSMapIterator)
DEF_CAST_TRAITS(JSMessageObject)
DEF_CAST_TRAITS(JSModuleNamespace)
DEF_CAST_TRAITS(JSDeferredModuleNamespace)
DEF_CAST_TRAITS(JSObject)
DEF_CAST_TRAITS(JSAPIObjectWithEmbedderSlots)
DEF_CAST_TRAITS(JSObjectWithEmbedderSlots)
DEF_CAST_TRAITS(JSPrimitiveWrapper)
DEF_CAST_TRAITS(JSPromise)
DEF_CAST_TRAITS(JSRabGsabDataView)
DEF_CAST_TRAITS(JSRawJson)
DEF_CAST_TRAITS(JSReceiver)
DEF_CAST_TRAITS(JSRegExp)
DEF_CAST_TRAITS(JSRegExpStringIterator)
DEF_CAST_TRAITS(JSSet)
DEF_CAST_TRAITS(JSSetIterator)
DEF_CAST_TRAITS(JSShadowRealm)
DEF_CAST_TRAITS(JSSharedArray)
DEF_CAST_TRAITS(JSSharedStruct)
DEF_CAST_TRAITS(JSSpecialObject)
DEF_CAST_TRAITS(JSStringIterator)
DEF_CAST_TRAITS(JSSynchronizationPrimitive)
DEF_CAST_TRAITS(JSDetachedTypedArray)
DEF_CAST_TRAITS(JSTypedArray)
DEF_CAST_TRAITS(JSValidIteratorWrapper)
DEF_CAST_TRAITS(JSWeakCollection)
DEF_CAST_TRAITS(JSWeakRef)
DEF_CAST_TRAITS(JSWeakMap)
DEF_CAST_TRAITS(JSWeakSet)
DEF_CAST_TRAITS(JSWrappedFunction)
DEF_CAST_TRAITS(LoadHandler)
DEF_CAST_TRAITS(MegaDomHandler)
DEF_CAST_TRAITS(Module)
DEF_CAST_TRAITS(Microtask)
DEF_CAST_TRAITS(NameDictionary)
DEF_CAST_TRAITS(NativeContext)
DEF_CAST_TRAITS(NormalizedMapCache)
DEF_CAST_TRAITS(NumberDictionary)
DEF_CAST_TRAITS(ObjectHashSet)
DEF_CAST_TRAITS(ObjectHashTable)
DEF_CAST_TRAITS(ObjectTwoHashTable)
DEF_CAST_TRAITS(OnHeapBasicBlockProfilerData)
DEF_CAST_TRAITS(Hole)
DEF_CAST_TRAITS(OrderedHashMap)
DEF_CAST_TRAITS(OrderedHashSet)
DEF_CAST_TRAITS(OrderedNameDictionary)
DEF_CAST_TRAITS(PreparseData)
DEF_CAST_TRAITS(PrimitiveHeapObject)
DEF_CAST_TRAITS(PromiseReactionJobTask)
DEF_CAST_TRAITS(PropertyCell)
DEF_CAST_TRAITS(SharedFunctionInfo)
DEF_CAST_TRAITS(SimpleNameDictionary)
DEF_CAST_TRAITS(SimpleNumberDictionary)
DEF_CAST_TRAITS(SmallOrderedHashMap)
DEF_CAST_TRAITS(SmallOrderedHashSet)
DEF_CAST_TRAITS(SmallOrderedNameDictionary)
DEF_CAST_TRAITS(SortState)
DEF_CAST_TRAITS(SourceTextModule)
DEF_CAST_TRAITS(SourceTextModuleInfo)
DEF_CAST_TRAITS(StoreHandler)
DEF_CAST_TRAITS(StringSet)
DEF_CAST_TRAITS(RegisteredSymbolTable)
DEF_CAST_TRAITS(Struct)
DEF_CAST_TRAITS(SwissNameDictionary)
DEF_CAST_TRAITS(SyntheticModule)
DEF_CAST_TRAITS(TemplateInfo)
DEF_CAST_TRAITS(TemplateInfoWithProperties)
DEF_CAST_TRAITS(TemplateLiteralObject)
DEF_CAST_TRAITS(TransitionArray)
DEF_CAST_TRAITS(TurbofanBitsetType)
DEF_CAST_TRAITS(TurbofanHeapConstantType)
DEF_CAST_TRAITS(TurbofanOtherNumberConstantType)
DEF_CAST_TRAITS(TurbofanRangeType)
DEF_CAST_TRAITS(TurbofanType)
DEF_CAST_TRAITS(TurbofanUnionType)
DEF_CAST_TRAITS(TurboshaftFloat64RangeType)
DEF_CAST_TRAITS(TurboshaftFloat64SetType)
DEF_CAST_TRAITS(TurboshaftFloat64Type)
DEF_CAST_TRAITS(TurboshaftType)
DEF_CAST_TRAITS(TurboshaftWord32RangeType)
DEF_CAST_TRAITS(TurboshaftWord32SetType)
DEF_CAST_TRAITS(TurboshaftWord32Type)
DEF_CAST_TRAITS(TurboshaftWord64RangeType)
DEF_CAST_TRAITS(TurboshaftWord64SetType)
DEF_CAST_TRAITS(TurboshaftWord64Type)
#if V8_ENABLE_WEBASSEMBLY
DEF_CAST_TRAITS(WasmArray)
DEF_CAST_TRAITS(WasmContinuationObject)
DEF_CAST_TRAITS(WasmCustomMap)
DEF_CAST_TRAITS(WasmCustomMapWrapper)
DEF_CAST_TRAITS(WasmExceptionPackage)
DEF_CAST_TRAITS(WasmFastApiCallData)
DEF_CAST_TRAITS(WasmFuncRef)
DEF_CAST_TRAITS(WasmGlobalObject)
DEF_CAST_TRAITS(WasmInstanceObject)
DEF_CAST_TRAITS(WasmMemoryObject)
DEF_CAST_TRAITS(WasmModuleObject)
DEF_CAST_TRAITS(WasmNull)
DEF_CAST_TRAITS(WasmObject)
DEF_CAST_TRAITS(WasmResumeData)
DEF_CAST_TRAITS(WasmStackObject)
DEF_CAST_TRAITS(WasmStringViewIter)
DEF_CAST_TRAITS(WasmStruct)
DEF_CAST_TRAITS(WasmSuspendingObject)
DEF_CAST_TRAITS(WasmTableObject)
DEF_CAST_TRAITS(WasmTagObject)
DEF_CAST_TRAITS(WasmTypeInfo)
DEF_CAST_TRAITS(WasmValueObject)
#endif // V8_ENABLE_WEBASSEMBLY
DEF_CAST_TRAITS(WeakCell)
DEF_CAST_TRAITS(ClosureFeedbackCellArray)
DEF_CAST_TRAITS(ObjectBoilerplateDescription)
DEF_CAST_TRAITS(RegExpMatchInfo)
DEF_CAST_TRAITS(ScriptContextTable)
DEF_CAST_TRAITS(SloppyArgumentsElements)
DEF_CAST_TRAITS(WeakHomomorphicFixedArray)
#ifdef V8_INTL_SUPPORT
DEF_CAST_TRAITS(JSV8BreakIterator)
DEF_CAST_TRAITS(JSCollator)
DEF_CAST_TRAITS(JSDateTimeFormat)
DEF_CAST_TRAITS(JSDisplayNames)
DEF_CAST_TRAITS(JSDurationFormat)
DEF_CAST_TRAITS(JSListFormat)
DEF_CAST_TRAITS(JSLocale)
DEF_CAST_TRAITS(JSNumberFormat)
DEF_CAST_TRAITS(JSPluralRules)
DEF_CAST_TRAITS(JSRelativeTimeFormat)
DEF_CAST_TRAITS(JSSegmentDataObject)
DEF_CAST_TRAITS(JSSegmentDataObjectWithIsWordLike)
DEF_CAST_TRAITS(JSSegmentIterator)
DEF_CAST_TRAITS(JSSegmenter)
DEF_CAST_TRAITS(JSSegments)
#endif // V8_INTL_SUPPORT
#ifdef V8_TEMPORAL_SUPPORT
DEF_CAST_TRAITS(JSTemporalDuration)
DEF_CAST_TRAITS(JSTemporalPlainDate)
DEF_CAST_TRAITS(JSTemporalPlainTime)
DEF_CAST_TRAITS(JSTemporalPlainDateTime)
DEF_CAST_TRAITS(JSTemporalPlainMonthDay)
DEF_CAST_TRAITS(JSTemporalPlainYearMonth)
DEF_CAST_TRAITS(JSTemporalZonedDateTime)
DEF_CAST_TRAITS(JSTemporalInstant)
#endif // V8_TEMPORAL_SUPPORT
HEAP_OBJECT_TRUSTED_TYPE_LIST(DEF_CAST_TRAITS)
HOLE_LIST(DEF_CAST_TRAITS)
DEF_CAST_TRAITS(AccessCheckNeeded)
DEF_CAST_TRAITS(AlwaysSharedSpaceJSObject)
DEF_CAST_TRAITS(BigIntWrapper)
DEF_CAST_TRAITS(BooleanWrapper)
DEF_CAST_TRAITS(Callable)
DEF_CAST_TRAITS(Constructor)
DEF_CAST_TRAITS(Filler)
DEF_CAST_TRAITS(HandlerTable)
DEF_CAST_TRAITS(JSContextExtensionObject)
DEF_CAST_TRAITS(JSError)
DEF_CAST_TRAITS(MapCache)
DEF_CAST_TRAITS(Number)
DEF_CAST_TRAITS(NumberWrapper)
DEF_CAST_TRAITS(OSROptimizedCodeCache)
DEF_CAST_TRAITS(ScriptWrapper)
DEF_CAST_TRAITS(StringWrapper)
DEF_CAST_TRAITS(SymbolWrapper)
DEF_CAST_TRAITS(UniqueName)
DEF_CAST_TRAITS(Undetectable)
template <>
struct CastTraits<JSPrimitive> {
static inline bool AllowFrom(Tagged<Object> value) {
return IsPrimitive(value);
}
static inline bool AllowFrom(Tagged<HeapObject> value) {
return IsPrimitive(value);
}
};
template <>
struct CastTraits<JSAny> {
static inline bool AllowFrom(Tagged<Object> value) {
return IsPrimitive(value) || IsJSReceiver(value);
}
static inline bool AllowFrom(Tagged<HeapObject> value) {
return IsPrimitive(value) || IsJSReceiver(value);
}
};
template <>
struct CastTraits<AllocationSiteWithWeakNext> {
template <typename From>
static inline bool AllowFrom(Tagged<From> value) {
Tagged<AllocationSite> site;
return TryCast<AllocationSite>(value, &site) && site->HasWeakNext();
}
};
template <>
struct CastTraits<FieldType> {
static inline bool AllowFrom(Tagged<Object> value) {
return value == FieldType::None() || value == FieldType::Any() ||
IsMap(value);
}
static inline bool AllowFrom(Tagged<HeapObject> value) {
return IsMap(value);
}
};
template <typename T>
struct CastTraits<Managed<T>> : public CastTraits<Foreign> {};
template <typename T>
struct CastTraits<CppGCManaged<T>> : public CastTraits<CppGCManagedBase> {};
template <typename T>
struct CastTraits<TrustedManaged<T>> : public CastTraits<TrustedForeign> {};
template <typename T>
struct CastTraits<PodArray<T>> : public CastTraits<ByteArray> {};
template <typename T>
struct CastTraits<TrustedPodArray<T>> : public CastTraits<TrustedByteArray> {};
template <typename T, typename Base>
struct CastTraits<FixedIntegerArrayBase<T, Base>> : public CastTraits<Base> {};
template <>
struct CastTraits<TrustedFixedAddressArray>
: public CastTraits<TrustedByteArray> {};
template <>
struct CastTraits<JSRegExpResultIndices> : public CastTraits<JSArray> {};
template <>
struct CastTraits<DeoptimizationLiteralArray>
: public CastTraits<TrustedWeakFixedArray> {};
template <>
struct CastTraits<FreshlyAllocatedBigInt> : public CastTraits<BigInt> {};
template <>
struct CastTraits<JSIteratorResult> : public CastTraits<JSObject> {};
template <>
struct CastTraits<JSUint8ArraySetFromResult> : public CastTraits<JSObject> {};
template <>
struct CastTraits<DeoptimizationFrameTranslation>
: public CastTraits<TrustedByteArray> {};
template <class T>
T HeapObject::Relaxed_ReadField(size_t offset) const
requires((std::is_arithmetic_v<T> || std::is_enum_v<T>) &&
!std::is_floating_point_v<T>)
{
// Pointer compression causes types larger than kTaggedSize to be
// unaligned. Atomic loads must be aligned.
DCHECK_IMPLIES(COMPRESS_POINTERS_BOOL, sizeof(T) <= kTaggedSize);
using AtomicT = typename base::AtomicTypeFromByteWidth<sizeof(T)>::type;
return static_cast<T>(base::AsAtomicImpl<AtomicT>::Relaxed_Load(
reinterpret_cast<AtomicT*>(field_address(offset))));
}
template <class T>
void HeapObject::Relaxed_WriteField(size_t offset, T value)
requires((std::is_arithmetic_v<T> || std::is_enum_v<T>) &&
!std::is_floating_point_v<T>)
{
// Pointer compression causes types larger than kTaggedSize to be
// unaligned. Atomic stores must be aligned.
DCHECK_IMPLIES(COMPRESS_POINTERS_BOOL, sizeof(T) <= kTaggedSize);
using AtomicT = typename base::AtomicTypeFromByteWidth<sizeof(T)>::type;
base::AsAtomicImpl<AtomicT>::Relaxed_Store(
reinterpret_cast<AtomicT*>(field_address(offset)),
static_cast<AtomicT>(value));
}
template <class T>
T HeapObject::Acquire_ReadField(size_t offset) const
requires((std::is_arithmetic_v<T> || std::is_enum_v<T>) &&
!std::is_floating_point_v<T>)
{
// Pointer compression causes types larger than kTaggedSize to be
// unaligned. Atomic loads must be aligned.
DCHECK_IMPLIES(COMPRESS_POINTERS_BOOL, sizeof(T) <= kTaggedSize);
using AtomicT = typename base::AtomicTypeFromByteWidth<sizeof(T)>::type;
return static_cast<T>(base::AsAtomicImpl<AtomicT>::Acquire_Load(
reinterpret_cast<AtomicT*>(field_address(offset))));
}
// static
template <typename CompareAndSwapImpl>
Tagged<Object> HeapObject::SeqCst_CompareAndSwapField(
Tagged<Object> expected, Tagged<Object> value,
CompareAndSwapImpl compare_and_swap_impl) {
Tagged<Object> actual_expected = expected;
do {
Tagged<Object> old_value = compare_and_swap_impl(actual_expected, value);
if (old_value == actual_expected || !IsNumber(old_value) ||
!IsNumber(actual_expected)) {
return old_value;
}
if (!Object::SameNumberValue(
Object::NumberValue(Cast<Number>(old_value)),
Object::NumberValue(Cast<Number>(actual_expected)))) {
return old_value;
}
// The pointer comparison failed, but the numbers are equal. This can
// happen even if both numbers are HeapNumbers with the same value.
// Try again in the next iteration.
actual_expected = old_value;
} while (true);
}
constexpr bool FastInReadOnlySpaceOrSmallSmi(Tagged_t obj) {
#if V8_STATIC_ROOTS_BOOL && CONTIGUOUS_COMPRESSED_READ_ONLY_SPACE_BOOL
// The following assert ensures that the page size check covers all our static
// roots. This is not strictly necessary and can be relaxed in future as the
// most prominent static roots are anyways allocated at the beginning of the
// first page.
// This optimization requires contiguous compressed RO space to ensure RO
// space is at the beginning of the cage; otherwise, objects from other spaces
// could alias with low addresses.
constexpr int kLastStaticRootPage =
RoundUp<kRegularPageSize>(StaticReadOnlyRoot::kLastAllocatedRoot);
static_assert(kLastStaticRootPage <= kContiguousReadOnlyReservationSize);
return obj < kContiguousReadOnlyReservationSize;
#else
return false;
#endif
}
constexpr bool FastInReadOnlySpaceOrSmallSmi(Tagged<MaybeObject> obj) {
#ifdef V8_COMPRESS_POINTERS
// This check is only valid for objects in the main cage.
DCHECK(obj.IsSmi() || obj.IsInMainCageBase());
return FastInReadOnlySpaceOrSmallSmi(
V8HeapCompressionScheme::CompressAny(obj.ptr()));
#else // V8_COMPRESS_POINTERS
return false;
#endif // V8_COMPRESS_POINTERS
}
bool OutsideSandboxOrInReadonlySpace(Tagged<HeapObject> obj) {
#ifdef V8_ENABLE_SANDBOX
return OutsideSandbox(obj.address()) ||
MemoryChunk::FromHeapObject(obj)->SandboxSafeInReadOnlySpace();
#else
return true;
#endif
}
DEF_HEAP_OBJECT_PREDICATE(IsCallable) { return obj->map()->is_callable(); }
DEF_HEAP_OBJECT_PREDICATE(IsCallableJSProxy) {
return IsCallable(obj) && IsJSProxy(obj);
}
DEF_HEAP_OBJECT_PREDICATE(IsCallableApiObject) {
InstanceType type = obj->map()->instance_type();
return IsCallable(obj) &&
(type == JS_API_OBJECT_TYPE || type == JS_SPECIAL_API_OBJECT_TYPE);
}
DEF_HEAP_OBJECT_PREDICATE(IsNonNullForeign) {
return IsForeign(obj) &&
Cast<Foreign>(obj)->foreign_address_unchecked() != kNullAddress;
}
DEF_HEAP_OBJECT_PREDICATE(IsConstructor) {
return obj->map()->is_constructor();
}
DEF_HEAP_OBJECT_PREDICATE(IsSourceTextModuleInfo) {
return obj->map() == GetReadOnlyRoots().module_info_map();
}
DEF_HEAP_OBJECT_PREDICATE(IsTemplateLiteralObject) { return IsJSArray(obj); }
#if V8_INTL_SUPPORT
DEF_HEAP_OBJECT_PREDICATE(IsJSSegmentDataObject) { return IsJSObject(obj); }
DEF_HEAP_OBJECT_PREDICATE(IsJSSegmentDataObjectWithIsWordLike) {
return IsJSObject(obj);
}
#endif // V8_INTL_SUPPORT
DEF_HEAP_OBJECT_PREDICATE(IsDeoptimizationData) {
if (!Is<ProtectedFixedArray>(obj)) return false;
Tagged<ProtectedFixedArray> array = TrustedCast<ProtectedFixedArray>(obj);
// There's no sure way to detect the difference between a fixed array and
// a deoptimization data array. Since this is used for asserts we can
// check that the length is zero or else the fixed size plus a multiple of
// the entry size.
uint32_t length = array->ulength().value();
if (length == 0) return true;
if (length < DeoptimizationData::kFirstDeoptEntryIndex) return false;
length -= DeoptimizationData::kFirstDeoptEntryIndex;
return length % DeoptimizationData::kDeoptEntrySize == 0;
}
DEF_HEAP_OBJECT_PREDICATE(IsHandlerTable) { return IsFixedArrayExact(obj); }
DEF_HEAP_OBJECT_PREDICATE(IsOSROptimizedCodeCache) {
return IsWeakFixedArray(obj);
}
DEF_HEAP_OBJECT_PREDICATE(IsStringWrapper) {
return IsJSPrimitiveWrapper(obj) &&
IsString(Cast<JSPrimitiveWrapper>(obj)->value());
}
DEF_HEAP_OBJECT_PREDICATE(IsBooleanWrapper) {
return IsJSPrimitiveWrapper(obj) &&
IsBoolean(Cast<JSPrimitiveWrapper>(obj)->value());
}
DEF_HEAP_OBJECT_PREDICATE(IsScriptWrapper) {
return IsJSPrimitiveWrapper(obj) &&
IsScript(Cast<JSPrimitiveWrapper>(obj)->value());
}
DEF_HEAP_OBJECT_PREDICATE(IsNumberWrapper) {
return IsJSPrimitiveWrapper(obj) &&
IsNumber(Cast<JSPrimitiveWrapper>(obj)->value());
}
DEF_HEAP_OBJECT_PREDICATE(IsBigIntWrapper) {
return IsJSPrimitiveWrapper(obj) &&
IsBigInt(Cast<JSPrimitiveWrapper>(obj)->value());
}
DEF_HEAP_OBJECT_PREDICATE(IsSymbolWrapper) {
return IsJSPrimitiveWrapper(obj) &&
IsSymbol(Cast<JSPrimitiveWrapper>(obj)->value());
}
DEF_HEAP_OBJECT_PREDICATE(IsStringSet) { return IsHashTable(obj); }
DEF_HEAP_OBJECT_PREDICATE(IsObjectHashSet) { return IsHashTable(obj); }
DEF_HEAP_OBJECT_PREDICATE(IsCompilationCacheTable) { return IsHashTable(obj); }
DEF_HEAP_OBJECT_PREDICATE(IsMapCache) { return IsHashTable(obj); }
DEF_HEAP_OBJECT_PREDICATE(IsObjectHashTable) { return IsHashTable(obj); }
DEF_HEAP_OBJECT_PREDICATE(IsObjectTwoHashTable) { return IsHashTable(obj); }
DEF_HEAP_OBJECT_PREDICATE(IsHashTableBase) { return IsHashTable(obj); }
// static
Maybe<bool> Object::IsArray(DirectHandle<Object> object) {
if (IsSmi(*object)) return Just(false);
auto heap_object = Cast<HeapObject>(object);
if (IsJSArray(*heap_object)) return Just(true);
if (!IsJSProxy(*heap_object)) return Just(false);
return JSProxy::IsArray(Cast<JSProxy>(object));
}
DEF_HEAP_OBJECT_PREDICATE(IsUndetectable) {
return obj->map()->is_undetectable();
}
DEF_HEAP_OBJECT_PREDICATE(IsAccessCheckNeeded) {
if (IsJSGlobalProxy(obj)) {
const Tagged<JSGlobalProxy> proxy = Cast<JSGlobalProxy>(obj);
Isolate* isolate = Isolate::Current();
// TODO(ishell): compare security tokens here in order to allow ICs to
// take fast paths for cross context accesses.
Tagged<JSGlobalObject> global = isolate->context()->global_object();
return proxy->IsDetachedFrom(global);
}
return obj->map()->is_access_check_needed();
}
// static
template <typename T, template <typename> typename HandleType>
requires(std::is_convertible_v<HandleType<T>, DirectHandle<T>>)
Maybe<double> Object::IntegerValue(Isolate* isolate, HandleType<T> input) {
ASSIGN_RETURN_ON_EXCEPTION(isolate, input, ConvertToNumber(isolate, input));
if (IsSmi(*input)) {
return Just(static_cast<double>(Cast<Smi>(*input).value()));
}
return Just(DoubleToInteger(Cast<HeapNumber>(*input)->value()));
}
// static
bool Object::SameNumberValue(double value1, double value2) {
// Compare values bitwise, to cover -0 being different from 0 -- we'd need to
// look at sign bits anyway if we'd done a double comparison, so we may as
// well compare bitwise immediately.
uint64_t value1_bits = base::bit_cast<uint64_t>(value1);
uint64_t value2_bits = base::bit_cast<uint64_t>(value2);
if (value1_bits == value2_bits) {
return true;
}
// SameNumberValue(NaN, NaN) is true even for NaNs with different bit
// representations.
return std::isnan(value1) && std::isnan(value2);
}
// static
bool IsNaN(Tagged<Object> obj) {
return IsHeapNumber(obj) && std::isnan(Cast<HeapNumber>(obj)->value());
}
// static
bool IsMinusZero(Tagged<Object> obj) {
return IsHeapNumber(obj) && i::IsMinusZero(Cast<HeapNumber>(obj)->value());
}
// static
bool Object::HasValidElements(Tagged<Object> obj) {
// Dictionary is covered under FixedArray. ByteArray is used
// for the JSTypedArray backing stores.
return IsFixedArray(obj) || IsFixedDoubleArray(obj) || IsByteArray(obj);
}
// static
bool Object::FilterKey(Tagged<Object> obj, PropertyFilter filter) {
DCHECK(!IsPropertyCell(obj));
if (filter == PRIVATE_NAMES_ONLY) {
if (!IsSymbol(obj)) return true;
return !Cast<Symbol>(obj)->is_any_private_name();
} else if (IsSymbol(obj)) {
if (filter & SKIP_SYMBOLS) return true;
if (Cast<Symbol>(obj)->is_any_private()) return true;
} else {
if (filter & SKIP_STRINGS) return true;
}
return false;
}
// static
std::pair<Representation, PropertyConstness> Object::OptimalRepresentation(
Tagged<Object> obj, PropertyConstness constness) {
if (IsSmi(obj)) {
return {Representation::Smi(), constness};
}
Tagged<HeapObject> heap_object = Cast<HeapObject>(obj);
if (IsUninitializedHole(heap_object)) {
return {Representation::None(), constness};
}
if (IsHeapNumber(heap_object)) {
if (constness == PropertyConstness::kConst &&
Cast<HeapNumber>(heap_object)->is_the_hole()) {
// Make sure that even an initializing store of a double value with
// the hole NaN pattern removes constness, otherwise it wouldn't be
// possible to distinguish whether subsequent stores to a double field
// is initializing or not.
constness = PropertyConstness::kMutable;
}
return {Representation::Double(), constness};
}
return {Representation::HeapObject(), constness};
}
// static
ElementsKind Object::OptimalElementsKind(Tagged<Object> obj) {
if (IsSmi(obj)) return PACKED_SMI_ELEMENTS;
Tagged<HeapObject> heap_object = Cast<HeapObject>(obj);
if (IsHeapNumber(heap_object)) return PACKED_DOUBLE_ELEMENTS;
// if (IsUninitializedHole(heap_object)) {
// return PACKED_SMI_ELEMENTS;
// }
#ifdef V8_ENABLE_UNDEFINED_DOUBLE
if (IsUndefined(heap_object)) {
return HOLEY_DOUBLE_ELEMENTS;
}
#endif // V8_ENABLE_UNDEFINED_DOUBLE
return PACKED_ELEMENTS;
}
// static
bool Object::FitsRepresentation(Tagged<Object> obj,
Representation representation,
bool allow_coercion) {
if (representation.IsSmi()) {
return IsSmi(obj);
} else if (representation.IsDouble()) {
return allow_coercion ? IsNumber(obj) : IsHeapNumber(obj);
} else if (representation.IsHeapObject()) {
return IsHeapObject(obj);
} else if (representation.IsNone()) {
return false;
}
return true;
}
// static
template <typename T, template <typename> typename HandleType>
requires(std::is_convertible_v<HandleType<T>, DirectHandle<T>>)
typename HandleType<JSReceiver>::MaybeType Object::ToObject(
Isolate* isolate, HandleType<T> object, const char* method_name) {
if (V8_LIKELY(IsJSReceiver(*object))) return Cast<JSReceiver>(object);
return ToObjectImpl(isolate, object, method_name);
}
// static
template <template <typename> typename HandleType>
typename HandleType<Name>::MaybeType Object::ToName(Isolate* isolate,
HandleType<Object> input)
requires(std::is_convertible_v<HandleType<Object>, DirectHandle<Object>>)
{
if (IsName(*input)) return Cast<Name>(input);
return ConvertToName(isolate, input);
}
// static
template <typename T, template <typename> typename HandleType>
requires(std::is_convertible_v<HandleType<T>, DirectHandle<T>>)
typename HandleType<Object>::MaybeType Object::ToPropertyKey(
Isolate* isolate, HandleType<T> value) {
if (IsSmi(*value) || IsName(Cast<HeapObject>(*value))) return value;
return ConvertToPropertyKey(isolate, value);
}
// static
template <typename T, template <typename> typename HandleType>
requires(std::is_convertible_v<HandleType<T>, DirectHandle<T>>)
typename HandleType<Object>::MaybeType Object::ToPrimitive(
Isolate* isolate, HandleType<T> input, ToPrimitiveHint hint) {
if (IsPrimitive(*input)) return input;
return JSReceiver::ToPrimitive(isolate, Cast<JSReceiver>(input), hint);
}
// static
template <typename T, template <typename> typename HandleType>
requires(std::is_convertible_v<HandleType<T>, DirectHandle<T>>)
typename HandleType<Number>::MaybeType Object::ToNumber(Isolate* isolate,
HandleType<T> input) {
if (IsNumber(*input)) return Cast<Number>(input); // Shortcut.
return ConvertToNumber(isolate, Cast<Object>(input));
}
// static
template <typename T, template <typename> typename HandleType>
requires(std::is_convertible_v<HandleType<T>, DirectHandle<T>>)
typename HandleType<Object>::MaybeType Object::ToNumeric(Isolate* isolate,
HandleType<T> input) {
if (IsNumber(*input) || IsBigInt(*input)) return input; // Shortcut.
return ConvertToNumeric(isolate, Cast<Object>(input));
}
// static
template <typename T, template <typename> typename HandleType>
requires(std::is_convertible_v<HandleType<T>, DirectHandle<T>>)
typename HandleType<Number>::MaybeType Object::ToInteger(Isolate* isolate,
HandleType<T> input) {
if (IsSmi(*input)) return Cast<Smi>(input);
return ConvertToInteger(isolate, Cast<Object>(input));
}
// static
template <typename T, template <typename> typename HandleType>
requires(std::is_convertible_v<HandleType<T>, DirectHandle<T>>)
typename HandleType<Number>::MaybeType Object::ToInt32(Isolate* isolate,
HandleType<T> input) {
if (IsSmi(*input)) return Cast<Smi>(input);
return ConvertToInt32(isolate, Cast<Object>(input));
}
// static
template <typename T, template <typename> typename HandleType>
requires(std::is_convertible_v<HandleType<T>, DirectHandle<T>>)
typename HandleType<Number>::MaybeType Object::ToUint32(Isolate* isolate,
HandleType<T> input) {
if (IsSmi(*input)) {
return typename HandleType<Number>::MaybeType(
Smi::ToUint32Smi(Cast<Smi>(*input)), isolate);
}
return ConvertToUint32(isolate, Cast<Object>(input));
}
// static
template <typename T, template <typename> typename HandleType>
requires(std::is_convertible_v<HandleType<T>, DirectHandle<T>>)
typename HandleType<String>::MaybeType Object::ToString(Isolate* isolate,
HandleType<T> input) {
if (IsString(*input)) return Cast<String>(input);
return ConvertToString(isolate, Cast<Object>(input));
}
// static
MaybeHandle<Object> Object::ToLength(Isolate* isolate,
DirectHandle<Object> input) {
if (IsSmi(*input)) {
int value = std::max(Smi::ToInt(*input), 0);
return handle(Smi::FromInt(value), isolate);
}
return ConvertToLength(isolate, input);
}
// static
template <typename T, template <typename> typename HandleType>
requires(std::is_convertible_v<HandleType<T>, DirectHandle<T>>)
typename HandleType<Object>::MaybeType Object::ToIndex(
Isolate* isolate, HandleType<T> input, MessageTemplate error_index) {
if (IsSmi(*input) && Smi::ToInt(*input) >= 0) return input;
return ConvertToIndex(isolate, Cast<Object>(input), error_index);
}
// static
template <typename ObjectType>
JSDispatchHandle HeapObject::AllocateAndInstallJSDispatchHandle(
DirectHandle<ObjectType> host, size_t offset, Isolate* isolate,
uint16_t parameter_count, DirectHandle<Code> code, WriteBarrierMode mode) {
JSDispatchTable::Space* space =
isolate->GetJSDispatchTableSpaceFor(host->field_address(offset));
JSDispatchHandle handle =
isolate->factory()->NewJSDispatchHandle(parameter_count, code, space);
// Use a Release_Store to ensure that the store of the pointer into the table
// is not reordered after the store of the handle. Otherwise, other threads
// may access an uninitialized table entry and crash.
auto location =
reinterpret_cast<JSDispatchHandle*>(host->field_address(offset));
base::AsAtomic32::Release_Store(location, handle);
CONDITIONAL_JS_DISPATCH_HANDLE_WRITE_BARRIER(*host, handle, mode);
return handle;
}
#ifdef VERIFY_HEAP
void HeapObject::VerifyObjectField(Isolate* isolate, int offset) {
Object::VerifyPointer(isolate, TaggedField<Object>::load(this, offset));
static_assert(!COMPRESS_POINTERS_BOOL || kTaggedSize == kInt32Size);
}
void HeapObject::VerifyMaybeObjectField(Isolate* isolate, int offset) {
Object::VerifyMaybeObjectPointer(
isolate, TaggedField<MaybeObject>::load(this, offset));
static_assert(!COMPRESS_POINTERS_BOOL || kTaggedSize == kInt32Size);
}
void HeapObject::VerifySmiField(int offset) {
CHECK(IsSmi(TaggedField<Object>::load(this, offset)));
static_assert(!COMPRESS_POINTERS_BOOL || kTaggedSize == kInt32Size);
}
#endif
// static
bool JSArray::MayHaveReadOnlyLength(Tagged<Map> js_array_map) {
DCHECK(IsJSArrayMap(js_array_map));
if (V8_UNLIKELY(
js_array_map->instance_descriptors()->number_of_descriptors() == 0)) {
return true;
}
DCHECK(!js_array_map->is_dictionary_map());
// Fast path: "length" is the first fast property of arrays with non
// dictionary properties. Since it's not configurable, it's guaranteed to be
// the first in the descriptor array.
InternalIndex first(0);
DCHECK(js_array_map->instance_descriptors()->GetKey(first) ==
GetReadOnlyRoots().length_string());
return V8_UNLIKELY(
js_array_map->instance_descriptors()->GetDetails(first).IsReadOnly());
}
bool JSArray::HasReadOnlyLength(DirectHandle<JSArray> array) {
Tagged<Map> map = array->map();
// If map guarantees that there can't be a read-only length, we are done.
if (!MayHaveReadOnlyLength(map)) return false;
return V8_UNLIKELY(HasReadOnlyLengthSlowPath(array));
}
inline bool IsSpecialReceiverInstanceType(InstanceType instance_type) {
return instance_type <= LAST_SPECIAL_RECEIVER_TYPE;
}
// This should be in objects/map-inl.h, but can't, because of a cyclic
// dependency.
bool IsSpecialReceiverMap(Tagged<Map> map) {
bool result = IsSpecialReceiverInstanceType(map->instance_type());
DCHECK_IMPLIES(
!result, !map->has_named_interceptor() && !map->is_access_check_needed());
return result;
}
inline bool IsCustomElementsReceiverInstanceType(InstanceType instance_type) {
return instance_type <= LAST_CUSTOM_ELEMENTS_RECEIVER;
}
// This should be in objects/map-inl.h, but can't, because of a cyclic
// dependency.
bool IsCustomElementsReceiverMap(Tagged<Map> map) {
return IsCustomElementsReceiverInstanceType(map->instance_type());
}
WriteBarrierModeScope HeapObject::GetWriteBarrierMode(
const DisallowGarbageCollection& promise) {
return WriteBarrier::GetWriteBarrierModeForObject(this, promise);
}
// static
AllocationAlignment HeapObject::RequiredAlignment(AllocationSpace space,
Tagged<Map> map) {
return RequiredAlignment(InSharedSpace{IsAnyWritableSharedSpace(space)}, map);
}
// static
AllocationAlignment HeapObject::RequiredAlignment(InSharedSpace in_shared_space,
Tagged<Map> map) {
// TODO(v8:4153): We should think about requiring double alignment
// in general for ByteArray, since they are used as backing store for typed
// arrays now.
// TODO(ishell, v8:8875): Consider using aligned allocations for BigInt.
if (USE_ALLOCATION_ALIGNMENT_HEAP_NUMBER_BOOL) {
int instance_type = map->instance_type();
static_assert(!USE_ALLOCATION_ALIGNMENT_HEAP_NUMBER_BOOL ||
(OFFSET_OF_DATA_START(FixedDoubleArray) &
kDoubleAlignmentMask) == kTaggedSize);
if (instance_type == FIXED_DOUBLE_ARRAY_TYPE) return kDoubleAligned;
static_assert(!USE_ALLOCATION_ALIGNMENT_HEAP_NUMBER_BOOL ||
(offsetof(HeapNumber, value_) & kDoubleAlignmentMask) ==
kTaggedSize);
if (instance_type == HEAP_NUMBER_TYPE) return kDoubleUnaligned;
}
#if V8_ENABLE_WEBASSEMBLY
if (in_shared_space && v8_flags.wasm_shared) [[unlikely]] {
int instance_type = map->instance_type();
if (instance_type == WASM_STRUCT_TYPE ||
instance_type == WASM_CUSTOM_MAP_TYPE) {
// The map of a shared wasm struct needs to be in the shared space.
DCHECK(HeapLayout::InWritableSharedSpace(map));
return kDoubleAligned;
} else if (instance_type == WASM_ARRAY_TYPE) {
// The map of a shared wasm array needs to be in the shared space.
DCHECK(HeapLayout::InWritableSharedSpace(map));
return kDoubleUnaligned;
}
}
#endif
return kTaggedAligned;
}
Address HeapObject::GetFieldAddress(int field_offset) const {
return field_address(field_offset);
}
// static
Maybe<bool> Object::GreaterThan(Isolate* isolate, DirectHandle<Object> x,
DirectHandle<Object> y) {
Maybe<ComparisonResult> result = Compare(isolate, x, y);
if (result.IsJust()) {
switch (result.FromJust()) {
case ComparisonResult::kGreaterThan:
return Just(true);
case ComparisonResult::kLessThan:
case ComparisonResult::kEqual:
case ComparisonResult::kUndefined:
return Just(false);
}
}
return Nothing<bool>();
}
// static
Maybe<bool> Object::GreaterThanOrEqual(Isolate* isolate, DirectHandle<Object> x,
DirectHandle<Object> y) {
Maybe<ComparisonResult> result = Compare(isolate, x, y);
if (result.IsJust()) {
switch (result.FromJust()) {
case ComparisonResult::kEqual:
case ComparisonResult::kGreaterThan:
return Just(true);
case ComparisonResult::kLessThan:
case ComparisonResult::kUndefined:
return Just(false);
}
}
return Nothing<bool>();
}
// static
Maybe<bool> Object::LessThan(Isolate* isolate, DirectHandle<Object> x,
DirectHandle<Object> y) {
Maybe<ComparisonResult> result = Compare(isolate, x, y);
if (result.IsJust()) {
switch (result.FromJust()) {
case ComparisonResult::kLessThan:
return Just(true);
case ComparisonResult::kEqual:
case ComparisonResult::kGreaterThan:
case ComparisonResult::kUndefined:
return Just(false);
}
}
return Nothing<bool>();
}
// static
Maybe<bool> Object::LessThanOrEqual(Isolate* isolate, DirectHandle<Object> x,
DirectHandle<Object> y) {
Maybe<ComparisonResult> result = Compare(isolate, x, y);
if (result.IsJust()) {
switch (result.FromJust()) {
case ComparisonResult::kEqual:
case ComparisonResult::kLessThan:
return Just(true);
case ComparisonResult::kGreaterThan:
case ComparisonResult::kUndefined:
return Just(false);
}
}
return Nothing<bool>();
}
// static
Tagged<Object> Object::GetSimpleHash(Tagged<Object> object) {
DisallowGarbageCollection no_gc;
if (IsSmi(object)) {
return Smi::FromInt(SmiHash32(static_cast<uint32_t>(Smi::ToInt(object))));
}
auto instance_type = Cast<HeapObject>(object)->map()->instance_type();
if (InstanceTypeChecker::IsHeapNumber(instance_type)) {
double num = Cast<HeapNumber>(object)->value();
if (std::isnan(num)) return Smi::FromInt(Smi::kMaxValue);
// For values in Signed32 range, including -0 (which is considered equal
// to 0 because collections use SameValueZero), hash the integer form to
// match the Smi branch above.
uint32_t hash;
// Check range before conversion to avoid undefined behavior.
if (num >= kMinInt && num <= kMaxInt && FastI2D(FastD2I(num)) == num) {
hash = SmiHash32(static_cast<uint32_t>(FastD2I(num)));
} else {
hash = SmiHash64(base::double_to_uint64(num));
}
return Smi::FromInt(hash);
} else if (InstanceTypeChecker::IsName(instance_type)) {
uint32_t hash = Cast<Name>(object)->EnsureHash();
return Smi::FromInt(hash);
} else if (InstanceTypeChecker::IsOddball(instance_type)) {
uint32_t hash = Cast<Oddball>(object)->to_string()->EnsureHash();
return Smi::FromInt(hash);
} else if (InstanceTypeChecker::IsBigInt(instance_type)) {
uint32_t hash = Cast<BigInt>(object)->Hash();
return Smi::FromInt(hash & Smi::kMaxValue);
} else if (InstanceTypeChecker::IsSharedFunctionInfo(instance_type)) {
uint32_t hash = Cast<SharedFunctionInfo>(object)->Hash();
return Smi::FromInt(hash & Smi::kMaxValue);
} else if (InstanceTypeChecker::IsScopeInfo(instance_type)) {
uint32_t hash = Cast<ScopeInfo>(object)->Hash();
return Smi::FromInt(hash & Smi::kMaxValue);
} else if (InstanceTypeChecker::IsScript(instance_type)) {
int id = Cast<Script>(object)->id();
return Smi::FromInt(SmiHash32(static_cast<uint32_t>(id)));
} else if (InstanceTypeChecker::IsTemplateInfo(instance_type)) {
uint32_t hash = Cast<TemplateInfo>(object)->GetHash();
DCHECK_EQ(hash, hash & kSmiHashMask);
return Smi::FromInt(hash);
}
DCHECK_NE(instance_type, HOLE_TYPE);
DCHECK(IsJSReceiver(object));
return object;
}
// static
Tagged<Object> Object::GetHash(Tagged<Object> obj) {
DisallowGarbageCollection no_gc;
Tagged<Object> hash = GetSimpleHash(obj);
if (IsSmi(hash)) return hash;
// Make sure that we never cast internal objects to JSReceivers.
CHECK(IsJSReceiver(obj));
Tagged<JSReceiver> receiver = Cast<JSReceiver>(obj);
return receiver->GetIdentityHash();
}
// static
template <typename T, template <typename> typename HandleType>
requires(std::is_convertible_v<HandleType<T>, DirectHandle<T>>)
typename HandleType<Object>::MaybeType Object::Share(
Isolate* isolate, HandleType<T> value,
ShouldThrow throw_if_cannot_be_shared) {
// Sharing values requires the RO space be shared.
if (IsShared(*value)) return value;
return ShareSlow(isolate, Cast<HeapObject>(value), throw_if_cannot_be_shared);
}
// https://tc39.es/ecma262/#sec-canbeheldweakly
// static
bool Object::CanBeHeldWeakly(Tagged<Object> obj) {
if (IsJSReceiver(obj)) {
// TODO(v8:12547) Shared structs and arrays should only be able to point
// to shared values in weak collections. For now, disallow them as weak
// collection keys.
#if V8_ENABLE_WEBASSEMBLY
if (v8_flags.wasm_shared &&
(IsWasmStruct(obj) || IsWasmCustomMap(obj) || IsWasmArray(obj)) &&
HeapLayout::InAnySharedSpace(Cast<HeapObject>(obj))) {
return false;
}
#endif
return (!v8_flags.harmony_struct ||
(!IsJSSharedStruct(obj) && !IsJSSharedArray(obj)));
}
return IsSymbol(obj) && !Cast<Symbol>(obj)->is_in_public_symbol_table();
}
DirectHandle<Object> ObjectHashTableShapeBase::AsHandle(
DirectHandle<Object> key) {
return key;
}
Relocatable::Relocatable(Isolate* isolate) {
isolate_ = isolate;
prev_ = isolate->relocatable_top();
isolate->set_relocatable_top(this);
}
Relocatable::~Relocatable() {
DCHECK_EQ(isolate_->relocatable_top(), this);
isolate_->set_relocatable_top(prev_);
}
// Predictably converts HeapObject or Address to uint32 by calculating
// offset of the address in respective MemoryChunk.
inline uint32_t ObjectAddressForHashing(Address object) {
return MemoryChunk::AddressToOffset(object);
}
inline DirectHandle<Object> MakeEntryPair(Isolate* isolate, size_t index,
DirectHandle<Object> value) {
DirectHandle<Object> key = isolate->factory()->SizeToString(index);
DirectHandle<FixedArray> entry_storage = isolate->factory()->NewFixedArray(2);
{
entry_storage->set(0, *key, SKIP_WRITE_BARRIER);
entry_storage->set(1, *value, SKIP_WRITE_BARRIER);
}
return isolate->factory()->NewJSArrayWithElements(entry_storage,
PACKED_ELEMENTS, 2);
}
inline DirectHandle<Object> MakeEntryPair(Isolate* isolate,
DirectHandle<Object> key,
DirectHandle<Object> value) {
DirectHandle<FixedArray> entry_storage = isolate->factory()->NewFixedArray(2);
{
entry_storage->set(0, *key, SKIP_WRITE_BARRIER);
entry_storage->set(1, *value, SKIP_WRITE_BARRIER);
}
return isolate->factory()->NewJSArrayWithElements(entry_storage,
PACKED_ELEMENTS, 2);
}
} // namespace internal
} // namespace v8
#include "src/objects/object-macros-undef.h"
#endif // V8_OBJECTS_OBJECTS_INL_H_