| // 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. |
| // |
| // 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. |
| // |
| |
| #ifndef V8_OBJECTS_INL_H_ |
| #define V8_OBJECTS_INL_H_ |
| |
| #include "src/objects.h" |
| |
| #include "src/base/bits.h" |
| #include "src/base/tsan.h" |
| #include "src/builtins/builtins.h" |
| #include "src/conversions.h" |
| #include "src/double.h" |
| #include "src/handles-inl.h" |
| #include "src/heap/factory.h" |
| #include "src/heap/heap-write-barrier-inl.h" |
| #include "src/keys.h" |
| #include "src/lookup-inl.h" // TODO(jkummerow): Drop. |
| #include "src/objects/bigint.h" |
| #include "src/objects/heap-number-inl.h" |
| #include "src/objects/heap-object.h" |
| #include "src/objects/js-proxy-inl.h" // TODO(jkummerow): Drop. |
| #include "src/objects/literal-objects.h" |
| #include "src/objects/oddball.h" |
| #include "src/objects/regexp-match-info.h" |
| #include "src/objects/scope-info.h" |
| #include "src/objects/shared-function-info.h" |
| #include "src/objects/slots-inl.h" |
| #include "src/objects/smi-inl.h" |
| #include "src/objects/templates.h" |
| #include "src/property-details.h" |
| #include "src/property.h" |
| #include "src/v8memory.h" |
| |
| // Has to be the last include (doesn't have include guards): |
| #include "src/objects/object-macros.h" |
| |
| namespace v8 { |
| namespace internal { |
| |
| PropertyDetails::PropertyDetails(Smi smi) { value_ = smi->value(); } |
| |
| Smi PropertyDetails::AsSmi() const { |
| // Ensure the upper 2 bits have the same value by sign extending it. This is |
| // necessary to be able to use the 31st bit of the property details. |
| int value = value_ << 1; |
| return Smi::FromInt(value >> 1); |
| } |
| |
| |
| int PropertyDetails::field_width_in_words() const { |
| DCHECK_EQ(location(), kField); |
| if (!FLAG_unbox_double_fields) return 1; |
| if (kDoubleSize == kTaggedSize) return 1; |
| return representation().IsDouble() ? kDoubleSize / kTaggedSize : 1; |
| } |
| |
| bool HeapObject::IsSloppyArgumentsElements() const { |
| return IsFixedArrayExact(); |
| } |
| |
| bool HeapObject::IsJSSloppyArgumentsObject() const { |
| return IsJSArgumentsObject(); |
| } |
| |
| bool HeapObject::IsJSGeneratorObject() const { |
| return map()->instance_type() == JS_GENERATOR_OBJECT_TYPE || |
| IsJSAsyncFunctionObject() || IsJSAsyncGeneratorObject(); |
| } |
| |
| bool HeapObject::IsDataHandler() const { |
| return IsLoadHandler() || IsStoreHandler(); |
| } |
| |
| bool HeapObject::IsClassBoilerplate() const { return IsFixedArrayExact(); } |
| |
| #define IS_TYPE_FUNCTION_DEF(type_) \ |
| bool Object::Is##type_() const { \ |
| return IsHeapObject() && HeapObject::cast(*this)->Is##type_(); \ |
| } |
| HEAP_OBJECT_TYPE_LIST(IS_TYPE_FUNCTION_DEF) |
| #undef IS_TYPE_FUNCTION_DEF |
| |
| #define IS_TYPE_FUNCTION_DEF(Type, Value) \ |
| bool Object::Is##Type(Isolate* isolate) const { \ |
| return Is##Type(ReadOnlyRoots(isolate->heap())); \ |
| } \ |
| bool Object::Is##Type(ReadOnlyRoots roots) const { \ |
| return *this == roots.Value(); \ |
| } \ |
| bool Object::Is##Type() const { \ |
| return IsHeapObject() && HeapObject::cast(*this)->Is##Type(); \ |
| } \ |
| bool HeapObject::Is##Type(Isolate* isolate) const { \ |
| return Object::Is##Type(isolate); \ |
| } \ |
| bool HeapObject::Is##Type(ReadOnlyRoots roots) const { \ |
| return Object::Is##Type(roots); \ |
| } \ |
| bool HeapObject::Is##Type() const { return Is##Type(GetReadOnlyRoots()); } |
| ODDBALL_LIST(IS_TYPE_FUNCTION_DEF) |
| #undef IS_TYPE_FUNCTION_DEF |
| |
| bool Object::IsNullOrUndefined(Isolate* isolate) const { |
| return IsNullOrUndefined(ReadOnlyRoots(isolate)); |
| } |
| |
| bool Object::IsNullOrUndefined(ReadOnlyRoots roots) const { |
| return IsNull(roots) || IsUndefined(roots); |
| } |
| |
| bool Object::IsNullOrUndefined() const { |
| return IsHeapObject() && HeapObject::cast(*this)->IsNullOrUndefined(); |
| } |
| |
| bool HeapObject::IsNullOrUndefined(Isolate* isolate) const { |
| return Object::IsNullOrUndefined(isolate); |
| } |
| |
| bool HeapObject::IsNullOrUndefined(ReadOnlyRoots roots) const { |
| return Object::IsNullOrUndefined(roots); |
| } |
| |
| bool HeapObject::IsNullOrUndefined() const { |
| return IsNullOrUndefined(GetReadOnlyRoots()); |
| } |
| |
| bool HeapObject::IsUniqueName() const { |
| return IsInternalizedString() || IsSymbol(); |
| } |
| |
| bool HeapObject::IsFunction() const { |
| STATIC_ASSERT(LAST_FUNCTION_TYPE == LAST_TYPE); |
| return map()->instance_type() >= FIRST_FUNCTION_TYPE; |
| } |
| |
| bool HeapObject::IsCallable() const { return map()->is_callable(); } |
| |
| bool HeapObject::IsConstructor() const { return map()->is_constructor(); } |
| |
| bool HeapObject::IsModuleInfo() const { |
| return map() == GetReadOnlyRoots().module_info_map(); |
| } |
| |
| bool HeapObject::IsTemplateInfo() const { |
| return IsObjectTemplateInfo() || IsFunctionTemplateInfo(); |
| } |
| |
| bool HeapObject::IsConsString() const { |
| if (!IsString()) return false; |
| return StringShape(String::cast(*this)).IsCons(); |
| } |
| |
| bool HeapObject::IsThinString() const { |
| if (!IsString()) return false; |
| return StringShape(String::cast(*this)).IsThin(); |
| } |
| |
| bool HeapObject::IsSlicedString() const { |
| if (!IsString()) return false; |
| return StringShape(String::cast(*this)).IsSliced(); |
| } |
| |
| bool HeapObject::IsSeqString() const { |
| if (!IsString()) return false; |
| return StringShape(String::cast(*this)).IsSequential(); |
| } |
| |
| bool HeapObject::IsSeqOneByteString() const { |
| if (!IsString()) return false; |
| return StringShape(String::cast(*this)).IsSequential() && |
| String::cast(*this)->IsOneByteRepresentation(); |
| } |
| |
| bool HeapObject::IsSeqTwoByteString() const { |
| if (!IsString()) return false; |
| return StringShape(String::cast(*this)).IsSequential() && |
| String::cast(*this)->IsTwoByteRepresentation(); |
| } |
| |
| bool HeapObject::IsExternalString() const { |
| if (!IsString()) return false; |
| return StringShape(String::cast(*this)).IsExternal(); |
| } |
| |
| bool HeapObject::IsExternalOneByteString() const { |
| if (!IsString()) return false; |
| return StringShape(String::cast(*this)).IsExternal() && |
| String::cast(*this)->IsOneByteRepresentation(); |
| } |
| |
| bool HeapObject::IsExternalTwoByteString() const { |
| if (!IsString()) return false; |
| return StringShape(String::cast(*this)).IsExternal() && |
| String::cast(*this)->IsTwoByteRepresentation(); |
| } |
| |
| bool Object::IsNumber() const { return IsSmi() || IsHeapNumber(); } |
| |
| bool Object::IsNumeric() const { return IsNumber() || IsBigInt(); } |
| |
| bool HeapObject::IsFiller() const { |
| InstanceType instance_type = map()->instance_type(); |
| return instance_type == FREE_SPACE_TYPE || instance_type == FILLER_TYPE; |
| } |
| |
| bool HeapObject::IsJSWeakCollection() const { |
| return IsJSWeakMap() || IsJSWeakSet(); |
| } |
| |
| bool HeapObject::IsJSCollection() const { return IsJSMap() || IsJSSet(); } |
| |
| bool HeapObject::IsPromiseReactionJobTask() const { |
| return IsPromiseFulfillReactionJobTask() || IsPromiseRejectReactionJobTask(); |
| } |
| |
| bool HeapObject::IsEnumCache() const { return IsTuple2(); } |
| |
| bool HeapObject::IsFrameArray() const { return IsFixedArrayExact(); } |
| |
| bool HeapObject::IsArrayList() const { |
| return map() == GetReadOnlyRoots().array_list_map() || |
| *this == GetReadOnlyRoots().empty_fixed_array(); |
| } |
| |
| bool HeapObject::IsRegExpMatchInfo() const { return IsFixedArrayExact(); } |
| |
| bool Object::IsLayoutDescriptor() const { return IsSmi() || IsByteArray(); } |
| |
| bool HeapObject::IsDeoptimizationData() const { |
| // Must be a fixed array. |
| if (!IsFixedArrayExact()) return false; |
| |
| // 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. |
| int length = FixedArray::cast(*this)->length(); |
| if (length == 0) return true; |
| |
| length -= DeoptimizationData::kFirstDeoptEntryIndex; |
| return length >= 0 && length % DeoptimizationData::kDeoptEntrySize == 0; |
| } |
| |
| bool HeapObject::IsHandlerTable() const { |
| if (!IsFixedArrayExact()) return false; |
| // There's actually no way to see the difference between a fixed array and |
| // a handler table array. |
| return true; |
| } |
| |
| bool HeapObject::IsTemplateList() const { |
| if (!IsFixedArrayExact()) return false; |
| // There's actually no way to see the difference between a fixed array and |
| // a template list. |
| if (FixedArray::cast(*this)->length() < 1) return false; |
| return true; |
| } |
| |
| bool HeapObject::IsDependentCode() const { |
| if (!IsWeakFixedArray()) return false; |
| // There's actually no way to see the difference between a weak fixed array |
| // and a dependent codes array. |
| return true; |
| } |
| |
| bool HeapObject::IsAbstractCode() const { |
| return IsBytecodeArray() || IsCode(); |
| } |
| |
| bool HeapObject::IsStringWrapper() const { |
| return IsJSValue() && JSValue::cast(*this)->value()->IsString(); |
| } |
| |
| bool HeapObject::IsBooleanWrapper() const { |
| return IsJSValue() && JSValue::cast(*this)->value()->IsBoolean(); |
| } |
| |
| bool HeapObject::IsScriptWrapper() const { |
| return IsJSValue() && JSValue::cast(*this)->value()->IsScript(); |
| } |
| |
| bool HeapObject::IsNumberWrapper() const { |
| return IsJSValue() && JSValue::cast(*this)->value()->IsNumber(); |
| } |
| |
| bool HeapObject::IsBigIntWrapper() const { |
| return IsJSValue() && JSValue::cast(*this)->value()->IsBigInt(); |
| } |
| |
| bool HeapObject::IsSymbolWrapper() const { |
| return IsJSValue() && JSValue::cast(*this)->value()->IsSymbol(); |
| } |
| |
| bool HeapObject::IsJSArrayBufferView() const { |
| return IsJSDataView() || IsJSTypedArray(); |
| } |
| |
| bool HeapObject::IsStringSet() const { return IsHashTable(); } |
| |
| bool HeapObject::IsObjectHashSet() const { return IsHashTable(); } |
| |
| bool HeapObject::IsCompilationCacheTable() const { return IsHashTable(); } |
| |
| bool HeapObject::IsMapCache() const { return IsHashTable(); } |
| |
| bool HeapObject::IsObjectHashTable() const { return IsHashTable(); } |
| |
| bool Object::IsHashTableBase() const { return IsHashTable(); } |
| |
| bool Object::IsSmallOrderedHashTable() const { |
| return IsSmallOrderedHashSet() || IsSmallOrderedHashMap() || |
| IsSmallOrderedNameDictionary(); |
| } |
| |
| bool Object::IsPrimitive() const { |
| return IsSmi() || HeapObject::cast(*this)->map()->IsPrimitiveMap(); |
| } |
| |
| // static |
| Maybe<bool> Object::IsArray(Handle<Object> object) { |
| if (object->IsSmi()) return Just(false); |
| Handle<HeapObject> heap_object = Handle<HeapObject>::cast(object); |
| if (heap_object->IsJSArray()) return Just(true); |
| if (!heap_object->IsJSProxy()) return Just(false); |
| return JSProxy::IsArray(Handle<JSProxy>::cast(object)); |
| } |
| |
| bool HeapObject::IsUndetectable() const { return map()->is_undetectable(); } |
| |
| bool HeapObject::IsAccessCheckNeeded() const { |
| if (IsJSGlobalProxy()) { |
| const JSGlobalProxy proxy = JSGlobalProxy::cast(*this); |
| JSGlobalObject global = proxy->GetIsolate()->context()->global_object(); |
| return proxy->IsDetachedFrom(global); |
| } |
| return map()->is_access_check_needed(); |
| } |
| |
| bool HeapObject::IsStruct() const { |
| switch (map()->instance_type()) { |
| #define MAKE_STRUCT_CASE(TYPE, Name, name) \ |
| case TYPE: \ |
| return true; |
| STRUCT_LIST(MAKE_STRUCT_CASE) |
| #undef MAKE_STRUCT_CASE |
| // It is hard to include ALLOCATION_SITE_TYPE in STRUCT_LIST because |
| // that macro is used for many things and AllocationSite needs a few |
| // special cases. |
| case ALLOCATION_SITE_TYPE: |
| return true; |
| case LOAD_HANDLER_TYPE: |
| case STORE_HANDLER_TYPE: |
| return true; |
| case FEEDBACK_CELL_TYPE: |
| return true; |
| case CALL_HANDLER_INFO_TYPE: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| #define MAKE_STRUCT_PREDICATE(NAME, Name, name) \ |
| bool Object::Is##Name() const { \ |
| return IsHeapObject() && HeapObject::cast(*this)->Is##Name(); \ |
| } \ |
| TYPE_CHECKER(Name) |
| STRUCT_LIST(MAKE_STRUCT_PREDICATE) |
| #undef MAKE_STRUCT_PREDICATE |
| |
| double Object::Number() const { |
| DCHECK(IsNumber()); |
| return IsSmi() ? static_cast<double>(Smi(this->ptr())->value()) |
| : HeapNumber::unchecked_cast(*this)->value(); |
| } |
| |
| bool Object::IsNaN() const { |
| return this->IsHeapNumber() && std::isnan(HeapNumber::cast(*this)->value()); |
| } |
| |
| bool Object::IsMinusZero() const { |
| return this->IsHeapNumber() && |
| i::IsMinusZero(HeapNumber::cast(*this)->value()); |
| } |
| |
| OBJECT_CONSTRUCTORS_IMPL(RegExpMatchInfo, FixedArray) |
| OBJECT_CONSTRUCTORS_IMPL(ScopeInfo, FixedArray) |
| OBJECT_CONSTRUCTORS_IMPL(BigIntBase, HeapObject) |
| OBJECT_CONSTRUCTORS_IMPL(BigInt, BigIntBase) |
| OBJECT_CONSTRUCTORS_IMPL(FreshlyAllocatedBigInt, BigIntBase) |
| |
| // ------------------------------------ |
| // Cast operations |
| |
| CAST_ACCESSOR(BigInt) |
| CAST_ACCESSOR(RegExpMatchInfo) |
| CAST_ACCESSOR(ScopeInfo) |
| |
| bool Object::HasValidElements() { |
| // Dictionary is covered under FixedArray. |
| return IsFixedArray() || IsFixedDoubleArray() || IsFixedTypedArrayBase(); |
| } |
| |
| bool Object::FilterKey(PropertyFilter filter) { |
| DCHECK(!IsPropertyCell()); |
| if (filter == PRIVATE_NAMES_ONLY) { |
| if (!IsSymbol()) return true; |
| return !Symbol::cast(*this)->is_private_name(); |
| } else if (IsSymbol()) { |
| if (filter & SKIP_SYMBOLS) return true; |
| |
| if (Symbol::cast(*this)->is_private()) return true; |
| } else { |
| if (filter & SKIP_STRINGS) return true; |
| } |
| return false; |
| } |
| |
| Representation Object::OptimalRepresentation() { |
| if (!FLAG_track_fields) return Representation::Tagged(); |
| if (IsSmi()) { |
| return Representation::Smi(); |
| } else if (FLAG_track_double_fields && IsHeapNumber()) { |
| return Representation::Double(); |
| } else if (FLAG_track_computed_fields && IsUninitialized()) { |
| return Representation::None(); |
| } else if (FLAG_track_heap_object_fields) { |
| DCHECK(IsHeapObject()); |
| return Representation::HeapObject(); |
| } else { |
| return Representation::Tagged(); |
| } |
| } |
| |
| |
| ElementsKind Object::OptimalElementsKind() { |
| if (IsSmi()) return PACKED_SMI_ELEMENTS; |
| if (IsNumber()) return PACKED_DOUBLE_ELEMENTS; |
| return PACKED_ELEMENTS; |
| } |
| |
| |
| bool Object::FitsRepresentation(Representation representation) { |
| if (FLAG_track_fields && representation.IsSmi()) { |
| return IsSmi(); |
| } else if (FLAG_track_double_fields && representation.IsDouble()) { |
| return IsMutableHeapNumber() || IsNumber(); |
| } else if (FLAG_track_heap_object_fields && representation.IsHeapObject()) { |
| return IsHeapObject(); |
| } else if (FLAG_track_fields && representation.IsNone()) { |
| return false; |
| } |
| return true; |
| } |
| |
| bool Object::ToUint32(uint32_t* value) const { |
| if (IsSmi()) { |
| int num = Smi::ToInt(*this); |
| if (num < 0) return false; |
| *value = static_cast<uint32_t>(num); |
| return true; |
| } |
| if (IsHeapNumber()) { |
| double num = HeapNumber::cast(*this)->value(); |
| return DoubleToUint32IfEqualToSelf(num, value); |
| } |
| return false; |
| } |
| |
| // static |
| MaybeHandle<JSReceiver> Object::ToObject(Isolate* isolate, |
| Handle<Object> object, |
| const char* method_name) { |
| if (object->IsJSReceiver()) return Handle<JSReceiver>::cast(object); |
| return ToObjectImpl(isolate, object, method_name); |
| } |
| |
| |
| // static |
| MaybeHandle<Name> Object::ToName(Isolate* isolate, Handle<Object> input) { |
| if (input->IsName()) return Handle<Name>::cast(input); |
| return ConvertToName(isolate, input); |
| } |
| |
| // static |
| MaybeHandle<Object> Object::ToPropertyKey(Isolate* isolate, |
| Handle<Object> value) { |
| if (value->IsSmi() || HeapObject::cast(*value)->IsName()) return value; |
| return ConvertToPropertyKey(isolate, value); |
| } |
| |
| // static |
| MaybeHandle<Object> Object::ToPrimitive(Handle<Object> input, |
| ToPrimitiveHint hint) { |
| if (input->IsPrimitive()) return input; |
| return JSReceiver::ToPrimitive(Handle<JSReceiver>::cast(input), hint); |
| } |
| |
| // static |
| MaybeHandle<Object> Object::ToNumber(Isolate* isolate, Handle<Object> input) { |
| if (input->IsNumber()) return input; // Shortcut. |
| return ConvertToNumberOrNumeric(isolate, input, Conversion::kToNumber); |
| } |
| |
| // static |
| MaybeHandle<Object> Object::ToNumeric(Isolate* isolate, Handle<Object> input) { |
| if (input->IsNumber() || input->IsBigInt()) return input; // Shortcut. |
| return ConvertToNumberOrNumeric(isolate, input, Conversion::kToNumeric); |
| } |
| |
| // static |
| MaybeHandle<Object> Object::ToInteger(Isolate* isolate, Handle<Object> input) { |
| if (input->IsSmi()) return input; |
| return ConvertToInteger(isolate, input); |
| } |
| |
| // static |
| MaybeHandle<Object> Object::ToInt32(Isolate* isolate, Handle<Object> input) { |
| if (input->IsSmi()) return input; |
| return ConvertToInt32(isolate, input); |
| } |
| |
| // static |
| MaybeHandle<Object> Object::ToUint32(Isolate* isolate, Handle<Object> input) { |
| if (input->IsSmi()) return handle(Smi::cast(*input)->ToUint32Smi(), isolate); |
| return ConvertToUint32(isolate, input); |
| } |
| |
| // static |
| MaybeHandle<String> Object::ToString(Isolate* isolate, Handle<Object> input) { |
| if (input->IsString()) return Handle<String>::cast(input); |
| return ConvertToString(isolate, input); |
| } |
| |
| // static |
| MaybeHandle<Object> Object::ToLength(Isolate* isolate, Handle<Object> input) { |
| if (input->IsSmi()) { |
| int value = std::max(Smi::ToInt(*input), 0); |
| return handle(Smi::FromInt(value), isolate); |
| } |
| return ConvertToLength(isolate, input); |
| } |
| |
| // static |
| MaybeHandle<Object> Object::ToIndex(Isolate* isolate, Handle<Object> input, |
| MessageTemplate error_index) { |
| if (input->IsSmi() && Smi::ToInt(*input) >= 0) return input; |
| return ConvertToIndex(isolate, input, error_index); |
| } |
| |
| MaybeHandle<Object> Object::GetProperty(Isolate* isolate, Handle<Object> object, |
| Handle<Name> name) { |
| LookupIterator it(isolate, object, name); |
| if (!it.IsFound()) return it.factory()->undefined_value(); |
| return GetProperty(&it); |
| } |
| |
| MaybeHandle<Object> Object::GetElement(Isolate* isolate, Handle<Object> object, |
| uint32_t index) { |
| LookupIterator it(isolate, object, index); |
| if (!it.IsFound()) return it.factory()->undefined_value(); |
| return GetProperty(&it); |
| } |
| |
| MaybeHandle<Object> Object::SetElement(Isolate* isolate, Handle<Object> object, |
| uint32_t index, Handle<Object> value, |
| ShouldThrow should_throw) { |
| LookupIterator it(isolate, object, index); |
| MAYBE_RETURN_NULL( |
| SetProperty(&it, value, StoreOrigin::kMaybeKeyed, Just(should_throw))); |
| return value; |
| } |
| |
| ObjectSlot HeapObject::RawField(int byte_offset) const { |
| return ObjectSlot(FIELD_ADDR(*this, byte_offset)); |
| } |
| |
| MaybeObjectSlot HeapObject::RawMaybeWeakField(int byte_offset) const { |
| return MaybeObjectSlot(FIELD_ADDR(*this, byte_offset)); |
| } |
| |
| MapWord MapWord::FromMap(const Map map) { return MapWord(map.ptr()); } |
| |
| Map MapWord::ToMap() const { return Map::unchecked_cast(Object(value_)); } |
| |
| bool MapWord::IsForwardingAddress() const { return HAS_SMI_TAG(value_); } |
| |
| MapWord MapWord::FromForwardingAddress(HeapObject object) { |
| return MapWord(object->ptr() - kHeapObjectTag); |
| } |
| |
| HeapObject MapWord::ToForwardingAddress() { |
| DCHECK(IsForwardingAddress()); |
| return HeapObject::FromAddress(value_); |
| } |
| |
| #ifdef VERIFY_HEAP |
| void HeapObject::VerifyObjectField(Isolate* isolate, int offset) { |
| VerifyPointer(isolate, READ_FIELD(*this, offset)); |
| STATIC_ASSERT(!COMPRESS_POINTERS_BOOL || kTaggedSize == kInt32Size); |
| } |
| |
| void HeapObject::VerifyMaybeObjectField(Isolate* isolate, int offset) { |
| MaybeObject::VerifyMaybeObjectPointer(isolate, |
| READ_WEAK_FIELD(*this, offset)); |
| STATIC_ASSERT(!COMPRESS_POINTERS_BOOL || kTaggedSize == kInt32Size); |
| } |
| |
| void HeapObject::VerifySmiField(int offset) { |
| CHECK(READ_FIELD(*this, offset)->IsSmi()); |
| STATIC_ASSERT(!COMPRESS_POINTERS_BOOL || kTaggedSize == kInt32Size); |
| } |
| |
| #endif |
| |
| ReadOnlyRoots HeapObject::GetReadOnlyRoots() const { |
| // TODO(v8:7464): When RO_SPACE is embedded, this will access a global |
| // variable instead. |
| return ReadOnlyRoots(GetHeapFromWritableObject(*this)); |
| } |
| |
| Map HeapObject::map() const { return map_word().ToMap(); } |
| |
| void HeapObject::set_map(Map value) { |
| if (!value.is_null()) { |
| #ifdef VERIFY_HEAP |
| GetHeapFromWritableObject(*this)->VerifyObjectLayoutChange(*this, value); |
| #endif |
| } |
| set_map_word(MapWord::FromMap(value)); |
| if (!value.is_null()) { |
| // TODO(1600) We are passing kNullAddress as a slot because maps can never |
| // be on an evacuation candidate. |
| MarkingBarrier(*this, ObjectSlot(kNullAddress), value); |
| } |
| } |
| |
| Map HeapObject::synchronized_map() const { |
| return synchronized_map_word().ToMap(); |
| } |
| |
| void HeapObject::synchronized_set_map(Map value) { |
| if (!value.is_null()) { |
| #ifdef VERIFY_HEAP |
| GetHeapFromWritableObject(*this)->VerifyObjectLayoutChange(*this, value); |
| #endif |
| } |
| synchronized_set_map_word(MapWord::FromMap(value)); |
| if (!value.is_null()) { |
| // TODO(1600) We are passing kNullAddress as a slot because maps can never |
| // be on an evacuation candidate. |
| MarkingBarrier(*this, ObjectSlot(kNullAddress), value); |
| } |
| } |
| |
| |
| // Unsafe accessor omitting write barrier. |
| void HeapObject::set_map_no_write_barrier(Map value) { |
| if (!value.is_null()) { |
| #ifdef VERIFY_HEAP |
| GetHeapFromWritableObject(*this)->VerifyObjectLayoutChange(*this, value); |
| #endif |
| } |
| set_map_word(MapWord::FromMap(value)); |
| } |
| |
| void HeapObject::set_map_after_allocation(Map value, WriteBarrierMode mode) { |
| set_map_word(MapWord::FromMap(value)); |
| if (mode != SKIP_WRITE_BARRIER) { |
| DCHECK(!value.is_null()); |
| // TODO(1600) We are passing kNullAddress as a slot because maps can never |
| // be on an evacuation candidate. |
| MarkingBarrier(*this, ObjectSlot(kNullAddress), value); |
| } |
| } |
| |
| MapWordSlot HeapObject::map_slot() const { |
| return MapWordSlot(FIELD_ADDR(*this, kMapOffset)); |
| } |
| |
| MapWord HeapObject::map_word() const { |
| return MapWord(map_slot().Relaxed_Load().ptr()); |
| } |
| |
| void HeapObject::set_map_word(MapWord map_word) { |
| map_slot().Relaxed_Store(Object(map_word.value_)); |
| } |
| |
| |
| MapWord HeapObject::synchronized_map_word() const { |
| return MapWord(map_slot().Acquire_Load().ptr()); |
| } |
| |
| void HeapObject::synchronized_set_map_word(MapWord map_word) { |
| map_slot().Release_Store(Object(map_word.value_)); |
| } |
| |
| int HeapObject::Size() const { return SizeFromMap(map()); } |
| |
| 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 Map::IsSpecialReceiverMap() const { |
| bool result = IsSpecialReceiverInstanceType(instance_type()); |
| DCHECK_IMPLIES(!result, |
| !has_named_interceptor() && !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 Map::IsCustomElementsReceiverMap() const { |
| return IsCustomElementsReceiverInstanceType(instance_type()); |
| } |
| |
| bool Object::ToArrayLength(uint32_t* index) const { |
| return Object::ToUint32(index); |
| } |
| |
| bool Object::ToArrayIndex(uint32_t* index) const { |
| return Object::ToUint32(index) && *index != kMaxUInt32; |
| } |
| |
| bool Object::GetHeapObjectIfStrong(HeapObject* result) const { |
| return GetHeapObject(result); |
| } |
| |
| bool Object::GetHeapObject(HeapObject* result) const { |
| if (!IsHeapObject()) return false; |
| *result = HeapObject::cast(*this); |
| return true; |
| } |
| |
| HeapObject Object::GetHeapObject() const { |
| DCHECK(IsHeapObject()); |
| return HeapObject::cast(*this); |
| } |
| |
| int RegExpMatchInfo::NumberOfCaptureRegisters() { |
| DCHECK_GE(length(), kLastMatchOverhead); |
| Object obj = get(kNumberOfCapturesIndex); |
| return Smi::ToInt(obj); |
| } |
| |
| void RegExpMatchInfo::SetNumberOfCaptureRegisters(int value) { |
| DCHECK_GE(length(), kLastMatchOverhead); |
| set(kNumberOfCapturesIndex, Smi::FromInt(value)); |
| } |
| |
| String RegExpMatchInfo::LastSubject() { |
| DCHECK_GE(length(), kLastMatchOverhead); |
| return String::cast(get(kLastSubjectIndex)); |
| } |
| |
| void RegExpMatchInfo::SetLastSubject(String value) { |
| DCHECK_GE(length(), kLastMatchOverhead); |
| set(kLastSubjectIndex, value); |
| } |
| |
| Object RegExpMatchInfo::LastInput() { |
| DCHECK_GE(length(), kLastMatchOverhead); |
| return get(kLastInputIndex); |
| } |
| |
| void RegExpMatchInfo::SetLastInput(Object value) { |
| DCHECK_GE(length(), kLastMatchOverhead); |
| set(kLastInputIndex, value); |
| } |
| |
| int RegExpMatchInfo::Capture(int i) { |
| DCHECK_LT(i, NumberOfCaptureRegisters()); |
| Object obj = get(kFirstCaptureIndex + i); |
| return Smi::ToInt(obj); |
| } |
| |
| void RegExpMatchInfo::SetCapture(int i, int value) { |
| DCHECK_LT(i, NumberOfCaptureRegisters()); |
| set(kFirstCaptureIndex + i, Smi::FromInt(value)); |
| } |
| |
| WriteBarrierMode HeapObject::GetWriteBarrierMode( |
| const DisallowHeapAllocation& promise) { |
| return GetWriteBarrierModeForObject(*this, &promise); |
| } |
| |
| // static |
| AllocationAlignment HeapObject::RequiredAlignment(Map map) { |
| #ifdef V8_COMPRESS_POINTERS |
| // TODO(ishell, v8:8875): Consider using aligned allocations once the |
| // allocation alignment inconsistency is fixed. For now we keep using |
| // unaligned access since both x64 and arm64 architectures (where pointer |
| // compression is supported) allow unaligned access to doubles and full words. |
| #endif // V8_COMPRESS_POINTERS |
| #ifdef V8_HOST_ARCH_32_BIT |
| int instance_type = map->instance_type(); |
| if (instance_type == FIXED_FLOAT64_ARRAY_TYPE || |
| instance_type == FIXED_DOUBLE_ARRAY_TYPE) { |
| return kDoubleAligned; |
| } |
| if (instance_type == HEAP_NUMBER_TYPE) return kDoubleUnaligned; |
| #endif // V8_HOST_ARCH_32_BIT |
| return kWordAligned; |
| } |
| |
| Address HeapObject::GetFieldAddress(int field_offset) const { |
| return FIELD_ADDR(*this, field_offset); |
| } |
| |
| // static |
| Maybe<bool> Object::GreaterThan(Isolate* isolate, Handle<Object> x, |
| Handle<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, Handle<Object> x, |
| Handle<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, Handle<Object> x, |
| Handle<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, Handle<Object> x, |
| Handle<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>(); |
| } |
| |
| MaybeHandle<Object> Object::GetPropertyOrElement(Isolate* isolate, |
| Handle<Object> object, |
| Handle<Name> name) { |
| LookupIterator it = LookupIterator::PropertyOrElement(isolate, object, name); |
| return GetProperty(&it); |
| } |
| |
| MaybeHandle<Object> Object::SetPropertyOrElement( |
| Isolate* isolate, Handle<Object> object, Handle<Name> name, |
| Handle<Object> value, Maybe<ShouldThrow> should_throw, |
| StoreOrigin store_origin) { |
| LookupIterator it = LookupIterator::PropertyOrElement(isolate, object, name); |
| MAYBE_RETURN_NULL(SetProperty(&it, value, store_origin, should_throw)); |
| return value; |
| } |
| |
| MaybeHandle<Object> Object::GetPropertyOrElement(Handle<Object> receiver, |
| Handle<Name> name, |
| Handle<JSReceiver> holder) { |
| LookupIterator it = LookupIterator::PropertyOrElement(holder->GetIsolate(), |
| receiver, name, holder); |
| return GetProperty(&it); |
| } |
| |
| // static |
| Object Object::GetSimpleHash(Object object) { |
| DisallowHeapAllocation no_gc; |
| if (object->IsSmi()) { |
| uint32_t hash = ComputeUnseededHash(Smi::ToInt(object)); |
| return Smi::FromInt(hash & Smi::kMaxValue); |
| } |
| if (object->IsHeapNumber()) { |
| double num = HeapNumber::cast(object)->value(); |
| if (std::isnan(num)) return Smi::FromInt(Smi::kMaxValue); |
| // Use ComputeUnseededHash for all values in Signed32 range, including -0, |
| // which is considered equal to 0 because collections use SameValueZero. |
| uint32_t hash; |
| // Check range before conversion to avoid undefined behavior. |
| if (num >= kMinInt && num <= kMaxInt && FastI2D(FastD2I(num)) == num) { |
| hash = ComputeUnseededHash(FastD2I(num)); |
| } else { |
| hash = ComputeLongHash(double_to_uint64(num)); |
| } |
| return Smi::FromInt(hash & Smi::kMaxValue); |
| } |
| if (object->IsName()) { |
| uint32_t hash = Name::cast(object)->Hash(); |
| return Smi::FromInt(hash); |
| } |
| if (object->IsOddball()) { |
| uint32_t hash = Oddball::cast(object)->to_string()->Hash(); |
| return Smi::FromInt(hash); |
| } |
| if (object->IsBigInt()) { |
| uint32_t hash = BigInt::cast(object)->Hash(); |
| return Smi::FromInt(hash & Smi::kMaxValue); |
| } |
| if (object->IsSharedFunctionInfo()) { |
| uint32_t hash = SharedFunctionInfo::cast(object)->Hash(); |
| return Smi::FromInt(hash & Smi::kMaxValue); |
| } |
| DCHECK(object->IsJSReceiver()); |
| return object; |
| } |
| |
| Object Object::GetHash() { |
| DisallowHeapAllocation no_gc; |
| Object hash = GetSimpleHash(*this); |
| if (hash->IsSmi()) return hash; |
| |
| DCHECK(IsJSReceiver()); |
| JSReceiver receiver = JSReceiver::cast(*this); |
| return receiver->GetIdentityHash(); |
| } |
| |
| Handle<Object> ObjectHashTableShape::AsHandle(Handle<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. |
| static inline uint32_t ObjectAddressForHashing(Address object) { |
| uint32_t value = static_cast<uint32_t>(object); |
| return value & kPageAlignmentMask; |
| } |
| |
| static inline Handle<Object> MakeEntryPair(Isolate* isolate, uint32_t index, |
| Handle<Object> value) { |
| Handle<Object> key = isolate->factory()->Uint32ToString(index); |
| Handle<FixedArray> entry_storage = |
| isolate->factory()->NewUninitializedFixedArray(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); |
| } |
| |
| static inline Handle<Object> MakeEntryPair(Isolate* isolate, Handle<Object> key, |
| Handle<Object> value) { |
| Handle<FixedArray> entry_storage = |
| isolate->factory()->NewUninitializedFixedArray(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); |
| } |
| |
| bool ScopeInfo::IsAsmModule() const { |
| return IsAsmModuleField::decode(Flags()); |
| } |
| |
| bool ScopeInfo::HasSimpleParameters() const { |
| return HasSimpleParametersField::decode(Flags()); |
| } |
| |
| #define FIELD_ACCESSORS(name) \ |
| void ScopeInfo::Set##name(int value) { set(k##name, Smi::FromInt(value)); } \ |
| int ScopeInfo::name() const { \ |
| if (length() > 0) { \ |
| return Smi::ToInt(get(k##name)); \ |
| } else { \ |
| return 0; \ |
| } \ |
| } |
| FOR_EACH_SCOPE_INFO_NUMERIC_FIELD(FIELD_ACCESSORS) |
| #undef FIELD_ACCESSORS |
| |
| FreshlyAllocatedBigInt FreshlyAllocatedBigInt::cast(Object object) { |
| SLOW_DCHECK(object->IsBigInt()); |
| return FreshlyAllocatedBigInt(object->ptr()); |
| } |
| |
| } // namespace internal |
| } // namespace v8 |
| |
| #include "src/objects/object-macros-undef.h" |
| |
| #endif // V8_OBJECTS_INL_H_ |