| // 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/atomicops.h" |
| #include "src/base/bits.h" |
| #include "src/base/tsan.h" |
| #include "src/builtins/builtins.h" |
| #include "src/contexts-inl.h" |
| #include "src/conversions-inl.h" |
| #include "src/feedback-vector-inl.h" |
| #include "src/field-index-inl.h" |
| #include "src/handles-inl.h" |
| #include "src/heap/factory.h" |
| #include "src/heap/heap-inl.h" |
| #include "src/isolate-inl.h" |
| #include "src/keys.h" |
| #include "src/layout-descriptor-inl.h" |
| #include "src/lookup-cache-inl.h" |
| #include "src/lookup-inl.h" |
| #include "src/maybe-handles-inl.h" |
| #include "src/objects/bigint.h" |
| #include "src/objects/descriptor-array.h" |
| #include "src/objects/js-proxy-inl.h" |
| #include "src/objects/literal-objects.h" |
| #include "src/objects/maybe-object-inl.h" |
| #include "src/objects/regexp-match-info.h" |
| #include "src/objects/scope-info.h" |
| #include "src/objects/template-objects.h" |
| #include "src/objects/templates.h" |
| #include "src/property-details.h" |
| #include "src/property.h" |
| #include "src/prototype-inl.h" |
| #include "src/roots-inl.h" |
| #include "src/transitions-inl.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 == kPointerSize) return 1; |
| return representation().IsDouble() ? kDoubleSize / kPointerSize : 1; |
| } |
| |
| namespace InstanceTypeChecker { |
| |
| // Define type checkers for classes with single instance type. |
| INSTANCE_TYPE_CHECKERS_SINGLE(INSTANCE_TYPE_CHECKER); |
| |
| #define TYPED_ARRAY_INSTANCE_TYPE_CHECKER(Type, type, TYPE, ctype) \ |
| INSTANCE_TYPE_CHECKER(Fixed##Type##Array, FIXED_##TYPE##_ARRAY_TYPE) |
| TYPED_ARRAYS(TYPED_ARRAY_INSTANCE_TYPE_CHECKER) |
| #undef TYPED_ARRAY_INSTANCE_TYPE_CHECKER |
| |
| #define STRUCT_INSTANCE_TYPE_CHECKER(NAME, Name, name) \ |
| INSTANCE_TYPE_CHECKER(Name, NAME##_TYPE) |
| STRUCT_LIST(STRUCT_INSTANCE_TYPE_CHECKER) |
| #undef STRUCT_INSTANCE_TYPE_CHECKER |
| |
| // Define type checkers for classes with ranges of instance types. |
| #define INSTANCE_TYPE_CHECKER_RANGE(type, first_instance_type, \ |
| last_instance_type) \ |
| V8_INLINE bool Is##type(InstanceType instance_type) { \ |
| return instance_type >= first_instance_type && \ |
| instance_type <= last_instance_type; \ |
| } |
| INSTANCE_TYPE_CHECKERS_RANGE(INSTANCE_TYPE_CHECKER_RANGE); |
| #undef INSTANCE_TYPE_CHECKER_RANGE |
| |
| V8_INLINE bool IsFixedArrayBase(InstanceType instance_type) { |
| return IsFixedArray(instance_type) || IsFixedDoubleArray(instance_type) || |
| IsFixedTypedArrayBase(instance_type); |
| } |
| |
| V8_INLINE bool IsHeapObject(InstanceType instance_type) { return true; } |
| |
| V8_INLINE bool IsInternalizedString(InstanceType instance_type) { |
| STATIC_ASSERT(kNotInternalizedTag != 0); |
| return (instance_type & (kIsNotStringMask | kIsNotInternalizedMask)) == |
| (kStringTag | kInternalizedTag); |
| } |
| |
| V8_INLINE bool IsJSObject(InstanceType instance_type) { |
| STATIC_ASSERT(LAST_TYPE == LAST_JS_OBJECT_TYPE); |
| return instance_type >= FIRST_JS_OBJECT_TYPE; |
| } |
| |
| } // namespace InstanceTypeChecker |
| |
| // TODO(v8:7786): For instance types that have a single map instance on the |
| // roots, and when that map is a embedded in the binary, compare against the map |
| // pointer rather than looking up the instance type. |
| INSTANCE_TYPE_CHECKERS(TYPE_CHECKER); |
| |
| #define TYPED_ARRAY_TYPE_CHECKER(Type, type, TYPE, ctype) \ |
| TYPE_CHECKER(Fixed##Type##Array) |
| TYPED_ARRAYS(TYPED_ARRAY_TYPE_CHECKER) |
| #undef TYPED_ARRAY_TYPE_CHECKER |
| |
| bool HeapObject::IsUncompiledData() const { |
| return IsUncompiledDataWithoutPreParsedScope() || |
| IsUncompiledDataWithPreParsedScope(); |
| } |
| |
| bool HeapObject::IsSloppyArgumentsElements() const { |
| return IsFixedArrayExact(); |
| } |
| |
| bool HeapObject::IsJSSloppyArgumentsObject() const { |
| return IsJSArgumentsObject(); |
| } |
| |
| bool HeapObject::IsJSGeneratorObject() const { |
| return map()->instance_type() == JS_GENERATOR_OBJECT_TYPE || |
| IsJSAsyncGeneratorObject(); |
| } |
| |
| bool HeapObject::IsDataHandler() const { |
| return IsLoadHandler() || IsStoreHandler(); |
| } |
| |
| bool HeapObject::IsClassBoilerplate() const { return IsFixedArrayExact(); } |
| |
| bool HeapObject::IsExternal(Isolate* isolate) const { |
| return map()->FindRootMap(isolate) == isolate->heap()->external_map(); |
| } |
| |
| #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::IsJSReceiver() const { |
| STATIC_ASSERT(LAST_JS_RECEIVER_TYPE == LAST_TYPE); |
| return map()->instance_type() >= FIRST_JS_RECEIVER_TYPE; |
| } |
| |
| bool HeapObject::IsJSProxy() const { return map()->IsJSProxyMap(); } |
| |
| 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::IsBoolean() const { |
| return IsOddball() && |
| ((Oddball::cast(this)->kind() & Oddball::kNotBooleanMask) == 0); |
| } |
| |
| bool HeapObject::IsJSArrayBufferView() const { |
| return IsJSDataView() || IsJSTypedArray(); |
| } |
| |
| bool HeapObject::IsStringSet() const { return IsHashTable(); } |
| |
| bool HeapObject::IsObjectHashSet() const { return IsHashTable(); } |
| |
| bool HeapObject::IsNormalizedMapCache() const { |
| return NormalizedMapCache::IsNormalizedMapCache(this); |
| } |
| |
| bool HeapObject::IsCompilationCacheTable() const { return IsHashTable(); } |
| |
| bool HeapObject::IsMapCache() const { return IsHashTable(); } |
| |
| bool HeapObject::IsObjectHashTable() const { return IsHashTable(); } |
| |
| bool Object::IsSmallOrderedHashTable() const { |
| return IsSmallOrderedHashSet() || IsSmallOrderedHashMap(); |
| } |
| |
| 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(NAME, Name, name) \ |
| case NAME##_TYPE: \ |
| return true; |
| STRUCT_LIST(MAKE_STRUCT_CASE) |
| #undef MAKE_STRUCT_CASE |
| 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>(reinterpret_cast<const Smi*>(this)->value()) |
| : reinterpret_cast<const HeapNumber*>(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()); |
| } |
| |
| // ------------------------------------ |
| // Cast operations |
| |
| CAST_ACCESSOR(AccessorPair) |
| CAST_ACCESSOR(AllocationMemento) |
| CAST_ACCESSOR(AllocationSite) |
| CAST_ACCESSOR(AsyncGeneratorRequest) |
| CAST_ACCESSOR(BigInt) |
| CAST_ACCESSOR(ObjectBoilerplateDescription) |
| CAST_ACCESSOR(Cell) |
| CAST_ACCESSOR(ArrayBoilerplateDescription) |
| CAST_ACCESSOR(DataHandler) |
| CAST_ACCESSOR(DescriptorArray) |
| CAST_ACCESSOR(EphemeronHashTable) |
| CAST_ACCESSOR(EnumCache) |
| CAST_ACCESSOR(FeedbackCell) |
| CAST_ACCESSOR(Foreign) |
| CAST_ACCESSOR(GlobalDictionary) |
| CAST_ACCESSOR(HeapObject) |
| CAST_ACCESSOR(JSAsyncFromSyncIterator) |
| CAST_ACCESSOR(JSBoundFunction) |
| CAST_ACCESSOR(JSDataView) |
| CAST_ACCESSOR(JSDate) |
| CAST_ACCESSOR(JSFunction) |
| CAST_ACCESSOR(JSGlobalObject) |
| CAST_ACCESSOR(JSGlobalProxy) |
| CAST_ACCESSOR(JSMessageObject) |
| CAST_ACCESSOR(JSObject) |
| CAST_ACCESSOR(JSReceiver) |
| CAST_ACCESSOR(JSStringIterator) |
| CAST_ACCESSOR(JSValue) |
| CAST_ACCESSOR(HeapNumber) |
| CAST_ACCESSOR(LayoutDescriptor) |
| CAST_ACCESSOR(MutableHeapNumber) |
| CAST_ACCESSOR(NameDictionary) |
| CAST_ACCESSOR(NormalizedMapCache) |
| CAST_ACCESSOR(NumberDictionary) |
| CAST_ACCESSOR(Object) |
| CAST_ACCESSOR(ObjectHashSet) |
| CAST_ACCESSOR(ObjectHashTable) |
| CAST_ACCESSOR(Oddball) |
| CAST_ACCESSOR(OrderedHashMap) |
| CAST_ACCESSOR(OrderedHashSet) |
| CAST_ACCESSOR(PropertyArray) |
| CAST_ACCESSOR(PropertyCell) |
| CAST_ACCESSOR(RegExpMatchInfo) |
| CAST_ACCESSOR(ScopeInfo) |
| CAST_ACCESSOR(SimpleNumberDictionary) |
| CAST_ACCESSOR(SmallOrderedHashMap) |
| CAST_ACCESSOR(SmallOrderedHashSet) |
| CAST_ACCESSOR(Smi) |
| CAST_ACCESSOR(SourcePositionTableWithFrameCache) |
| CAST_ACCESSOR(StackFrameInfo) |
| CAST_ACCESSOR(StringSet) |
| CAST_ACCESSOR(StringTable) |
| CAST_ACCESSOR(Struct) |
| CAST_ACCESSOR(TemplateObjectDescription) |
| CAST_ACCESSOR(Tuple2) |
| CAST_ACCESSOR(Tuple3) |
| |
| bool Object::HasValidElements() { |
| // Dictionary is covered under FixedArray. |
| return IsFixedArray() || IsFixedDoubleArray() || IsFixedTypedArrayBase(); |
| } |
| |
| bool Object::KeyEquals(Object* second) { |
| Object* first = this; |
| if (second->IsNumber()) { |
| if (first->IsNumber()) return first->Number() == second->Number(); |
| Object* temp = first; |
| first = second; |
| second = temp; |
| } |
| if (first->IsNumber()) { |
| DCHECK_LE(0, first->Number()); |
| uint32_t expected = static_cast<uint32_t>(first->Number()); |
| uint32_t index; |
| return Name::cast(second)->AsArrayIndex(&index) && index == expected; |
| } |
| return Name::cast(first)->Equals(Name::cast(second)); |
| } |
| |
| bool Object::FilterKey(PropertyFilter filter) { |
| DCHECK(!IsPropertyCell()); |
| 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; |
| } |
| |
| Handle<Object> Object::NewStorageFor(Isolate* isolate, Handle<Object> object, |
| Representation representation) { |
| if (!representation.IsDouble()) return object; |
| auto result = isolate->factory()->NewMutableHeapNumberWithHoleNaN(); |
| if (object->IsUninitialized(isolate)) { |
| result->set_value_as_bits(kHoleNanInt64); |
| } else if (object->IsMutableHeapNumber()) { |
| // Ensure that all bits of the double value are preserved. |
| result->set_value_as_bits( |
| MutableHeapNumber::cast(*object)->value_as_bits()); |
| } else { |
| result->set_value(object->Number()); |
| } |
| return result; |
| } |
| |
| Handle<Object> Object::WrapForRead(Isolate* isolate, Handle<Object> object, |
| Representation representation) { |
| DCHECK(!object->IsUninitialized(isolate)); |
| if (!representation.IsDouble()) { |
| DCHECK(object->FitsRepresentation(representation)); |
| return object; |
| } |
| return isolate->factory()->NewHeapNumber( |
| MutableHeapNumber::cast(*object)->value()); |
| } |
| |
| 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 ToObject(isolate, object, isolate->native_context(), 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::Template 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> JSReceiver::GetProperty(Isolate* isolate, |
| Handle<JSReceiver> receiver, |
| Handle<Name> name) { |
| LookupIterator it(isolate, receiver, name, receiver); |
| if (!it.IsFound()) return it.factory()->undefined_value(); |
| return Object::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> JSReceiver::GetElement(Isolate* isolate, |
| Handle<JSReceiver> receiver, |
| uint32_t index) { |
| LookupIterator it(isolate, receiver, index, receiver); |
| if (!it.IsFound()) return it.factory()->undefined_value(); |
| return Object::GetProperty(&it); |
| } |
| |
| Handle<Object> JSReceiver::GetDataProperty(Handle<JSReceiver> object, |
| Handle<Name> name) { |
| LookupIterator it(object, name, object, |
| LookupIterator::PROTOTYPE_CHAIN_SKIP_INTERCEPTOR); |
| if (!it.IsFound()) return it.factory()->undefined_value(); |
| return GetDataProperty(&it); |
| } |
| |
| MaybeHandle<Object> Object::SetElement(Isolate* isolate, Handle<Object> object, |
| uint32_t index, Handle<Object> value, |
| LanguageMode language_mode) { |
| LookupIterator it(isolate, object, index); |
| MAYBE_RETURN_NULL( |
| SetProperty(&it, value, language_mode, MAY_BE_STORE_FROM_KEYED)); |
| return value; |
| } |
| |
| MaybeHandle<Object> JSReceiver::GetPrototype(Isolate* isolate, |
| Handle<JSReceiver> receiver) { |
| // We don't expect access checks to be needed on JSProxy objects. |
| DCHECK(!receiver->IsAccessCheckNeeded() || receiver->IsJSObject()); |
| PrototypeIterator iter(isolate, receiver, kStartAtReceiver, |
| PrototypeIterator::END_AT_NON_HIDDEN); |
| do { |
| if (!iter.AdvanceFollowingProxies()) return MaybeHandle<Object>(); |
| } while (!iter.IsAtEnd()); |
| return PrototypeIterator::GetCurrent(iter); |
| } |
| |
| MaybeHandle<Object> JSReceiver::GetProperty(Isolate* isolate, |
| Handle<JSReceiver> receiver, |
| const char* name) { |
| Handle<String> str = isolate->factory()->InternalizeUtf8String(name); |
| return GetProperty(isolate, receiver, str); |
| } |
| |
| // static |
| V8_WARN_UNUSED_RESULT MaybeHandle<FixedArray> JSReceiver::OwnPropertyKeys( |
| Handle<JSReceiver> object) { |
| return KeyAccumulator::GetKeys(object, KeyCollectionMode::kOwnOnly, |
| ALL_PROPERTIES, |
| GetKeysConversion::kConvertToString); |
| } |
| |
| bool JSObject::PrototypeHasNoElements(Isolate* isolate, JSObject* object) { |
| DisallowHeapAllocation no_gc; |
| HeapObject* prototype = HeapObject::cast(object->map()->prototype()); |
| ReadOnlyRoots roots(isolate); |
| HeapObject* null = roots.null_value(); |
| HeapObject* empty_fixed_array = roots.empty_fixed_array(); |
| HeapObject* empty_slow_element_dictionary = |
| roots.empty_slow_element_dictionary(); |
| while (prototype != null) { |
| Map* map = prototype->map(); |
| if (map->IsCustomElementsReceiverMap()) return false; |
| HeapObject* elements = JSObject::cast(prototype)->elements(); |
| if (elements != empty_fixed_array && |
| elements != empty_slow_element_dictionary) { |
| return false; |
| } |
| prototype = HeapObject::cast(map->prototype()); |
| } |
| return true; |
| } |
| |
| Object** HeapObject::RawField(const HeapObject* obj, int byte_offset) { |
| return reinterpret_cast<Object**>(FIELD_ADDR(obj, byte_offset)); |
| } |
| |
| MaybeObject** HeapObject::RawMaybeWeakField(HeapObject* obj, int byte_offset) { |
| return reinterpret_cast<MaybeObject**>(FIELD_ADDR(obj, byte_offset)); |
| } |
| |
| int Smi::ToInt(const Object* object) { return Smi::cast(object)->value(); } |
| |
| MapWord MapWord::FromMap(const Map* map) { |
| return MapWord(reinterpret_cast<uintptr_t>(map)); |
| } |
| |
| Map* MapWord::ToMap() const { return reinterpret_cast<Map*>(value_); } |
| |
| bool MapWord::IsForwardingAddress() const { |
| return HAS_SMI_TAG(reinterpret_cast<Object*>(value_)); |
| } |
| |
| |
| MapWord MapWord::FromForwardingAddress(HeapObject* object) { |
| Address raw = reinterpret_cast<Address>(object) - kHeapObjectTag; |
| return MapWord(static_cast<uintptr_t>(raw)); |
| } |
| |
| |
| HeapObject* MapWord::ToForwardingAddress() { |
| DCHECK(IsForwardingAddress()); |
| return HeapObject::FromAddress(static_cast<Address>(value_)); |
| } |
| |
| |
| #ifdef VERIFY_HEAP |
| void HeapObject::VerifyObjectField(Isolate* isolate, int offset) { |
| VerifyPointer(isolate, READ_FIELD(this, offset)); |
| } |
| |
| void HeapObject::VerifyMaybeObjectField(Isolate* isolate, int offset) { |
| MaybeObject::VerifyMaybeObjectPointer(isolate, READ_WEAK_FIELD(this, offset)); |
| } |
| |
| void HeapObject::VerifySmiField(int offset) { |
| CHECK(READ_FIELD(this, offset)->IsSmi()); |
| } |
| #endif |
| |
| ReadOnlyRoots HeapObject::GetReadOnlyRoots() const { |
| // TODO(v8:7464): When RO_SPACE is embedded, this will access a global |
| // variable instead. |
| return ReadOnlyRoots(MemoryChunk::FromHeapObject(this)->heap()); |
| } |
| |
| Heap* NeverReadOnlySpaceObject::GetHeap() const { |
| MemoryChunk* chunk = |
| MemoryChunk::FromAddress(reinterpret_cast<Address>(this)); |
| // Make sure we are not accessing an object in RO space. |
| SLOW_DCHECK(chunk->owner()->identity() != RO_SPACE); |
| Heap* heap = chunk->heap(); |
| SLOW_DCHECK(heap != nullptr); |
| return heap; |
| } |
| |
| Isolate* NeverReadOnlySpaceObject::GetIsolate() const { |
| return GetHeap()->isolate(); |
| } |
| |
| Map* HeapObject::map() const { |
| return map_word().ToMap(); |
| } |
| |
| |
| void HeapObject::set_map(Map* value) { |
| if (value != nullptr) { |
| #ifdef VERIFY_HEAP |
| Heap::FromWritableHeapObject(this)->VerifyObjectLayoutChange(this, value); |
| #endif |
| } |
| set_map_word(MapWord::FromMap(value)); |
| if (value != nullptr) { |
| // TODO(1600) We are passing nullptr as a slot because maps can never be on |
| // evacuation candidate. |
| MarkingBarrier(this, nullptr, value); |
| } |
| } |
| |
| Map* HeapObject::synchronized_map() const { |
| return synchronized_map_word().ToMap(); |
| } |
| |
| |
| void HeapObject::synchronized_set_map(Map* value) { |
| if (value != nullptr) { |
| #ifdef VERIFY_HEAP |
| Heap::FromWritableHeapObject(this)->VerifyObjectLayoutChange(this, value); |
| #endif |
| } |
| synchronized_set_map_word(MapWord::FromMap(value)); |
| if (value != nullptr) { |
| // TODO(1600) We are passing nullptr as a slot because maps can never be on |
| // evacuation candidate. |
| MarkingBarrier(this, nullptr, value); |
| } |
| } |
| |
| |
| // Unsafe accessor omitting write barrier. |
| void HeapObject::set_map_no_write_barrier(Map* value) { |
| if (value != nullptr) { |
| #ifdef VERIFY_HEAP |
| Heap::FromWritableHeapObject(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_NOT_NULL(value); |
| // TODO(1600) We are passing nullptr as a slot because maps can never be on |
| // evacuation candidate. |
| MarkingBarrier(this, nullptr, value); |
| } |
| } |
| |
| HeapObject** HeapObject::map_slot() { |
| return reinterpret_cast<HeapObject**>(FIELD_ADDR(this, kMapOffset)); |
| } |
| |
| MapWord HeapObject::map_word() const { |
| return MapWord( |
| reinterpret_cast<uintptr_t>(RELAXED_READ_FIELD(this, kMapOffset))); |
| } |
| |
| |
| void HeapObject::set_map_word(MapWord map_word) { |
| RELAXED_WRITE_FIELD(this, kMapOffset, |
| reinterpret_cast<Object*>(map_word.value_)); |
| } |
| |
| |
| MapWord HeapObject::synchronized_map_word() const { |
| return MapWord( |
| reinterpret_cast<uintptr_t>(ACQUIRE_READ_FIELD(this, kMapOffset))); |
| } |
| |
| |
| void HeapObject::synchronized_set_map_word(MapWord map_word) { |
| RELEASE_WRITE_FIELD( |
| this, kMapOffset, reinterpret_cast<Object*>(map_word.value_)); |
| } |
| |
| int HeapObject::Size() const { return SizeFromMap(map()); } |
| |
| double HeapNumberBase::value() const { |
| return READ_DOUBLE_FIELD(this, kValueOffset); |
| } |
| |
| void HeapNumberBase::set_value(double value) { |
| WRITE_DOUBLE_FIELD(this, kValueOffset, value); |
| } |
| |
| uint64_t HeapNumberBase::value_as_bits() const { |
| return READ_UINT64_FIELD(this, kValueOffset); |
| } |
| |
| void HeapNumberBase::set_value_as_bits(uint64_t bits) { |
| WRITE_UINT64_FIELD(this, kValueOffset, bits); |
| } |
| |
| int HeapNumberBase::get_exponent() { |
| return ((READ_INT_FIELD(this, kExponentOffset) & kExponentMask) >> |
| kExponentShift) - kExponentBias; |
| } |
| |
| int HeapNumberBase::get_sign() { |
| return READ_INT_FIELD(this, kExponentOffset) & kSignMask; |
| } |
| |
| ACCESSORS(JSReceiver, raw_properties_or_hash, Object, kPropertiesOrHashOffset) |
| |
| FixedArrayBase* JSObject::elements() const { |
| Object* array = READ_FIELD(this, kElementsOffset); |
| return static_cast<FixedArrayBase*>(array); |
| } |
| |
| bool AllocationSite::HasWeakNext() const { |
| return map() == GetReadOnlyRoots().allocation_site_map(); |
| } |
| |
| void AllocationSite::Initialize() { |
| set_transition_info_or_boilerplate(Smi::kZero); |
| SetElementsKind(GetInitialFastElementsKind()); |
| set_nested_site(Smi::kZero); |
| set_pretenure_data(0); |
| set_pretenure_create_count(0); |
| set_dependent_code( |
| DependentCode::cast(GetReadOnlyRoots().empty_weak_fixed_array()), |
| SKIP_WRITE_BARRIER); |
| } |
| |
| bool AllocationSite::IsZombie() const { |
| return pretenure_decision() == kZombie; |
| } |
| |
| bool AllocationSite::IsMaybeTenure() const { |
| return pretenure_decision() == kMaybeTenure; |
| } |
| |
| bool AllocationSite::PretenuringDecisionMade() const { |
| return pretenure_decision() != kUndecided; |
| } |
| |
| |
| void AllocationSite::MarkZombie() { |
| DCHECK(!IsZombie()); |
| Initialize(); |
| set_pretenure_decision(kZombie); |
| } |
| |
| ElementsKind AllocationSite::GetElementsKind() const { |
| return ElementsKindBits::decode(transition_info()); |
| } |
| |
| |
| void AllocationSite::SetElementsKind(ElementsKind kind) { |
| set_transition_info(ElementsKindBits::update(transition_info(), kind)); |
| } |
| |
| bool AllocationSite::CanInlineCall() const { |
| return DoNotInlineBit::decode(transition_info()) == 0; |
| } |
| |
| |
| void AllocationSite::SetDoNotInlineCall() { |
| set_transition_info(DoNotInlineBit::update(transition_info(), true)); |
| } |
| |
| bool AllocationSite::PointsToLiteral() const { |
| Object* raw_value = transition_info_or_boilerplate(); |
| DCHECK_EQ(!raw_value->IsSmi(), |
| raw_value->IsJSArray() || raw_value->IsJSObject()); |
| return !raw_value->IsSmi(); |
| } |
| |
| |
| // Heuristic: We only need to create allocation site info if the boilerplate |
| // elements kind is the initial elements kind. |
| bool AllocationSite::ShouldTrack(ElementsKind boilerplate_elements_kind) { |
| return IsSmiElementsKind(boilerplate_elements_kind); |
| } |
| |
| inline bool AllocationSite::CanTrack(InstanceType type) { |
| if (FLAG_allocation_site_pretenuring) { |
| // TurboFan doesn't care at all about String pretenuring feedback, |
| // so don't bother even trying to track that. |
| return type == JS_ARRAY_TYPE || type == JS_OBJECT_TYPE; |
| } |
| return type == JS_ARRAY_TYPE; |
| } |
| |
| AllocationSite::PretenureDecision AllocationSite::pretenure_decision() const { |
| return PretenureDecisionBits::decode(pretenure_data()); |
| } |
| |
| void AllocationSite::set_pretenure_decision(PretenureDecision decision) { |
| int32_t value = pretenure_data(); |
| set_pretenure_data(PretenureDecisionBits::update(value, decision)); |
| } |
| |
| bool AllocationSite::deopt_dependent_code() const { |
| return DeoptDependentCodeBit::decode(pretenure_data()); |
| } |
| |
| void AllocationSite::set_deopt_dependent_code(bool deopt) { |
| int32_t value = pretenure_data(); |
| set_pretenure_data(DeoptDependentCodeBit::update(value, deopt)); |
| } |
| |
| int AllocationSite::memento_found_count() const { |
| return MementoFoundCountBits::decode(pretenure_data()); |
| } |
| |
| inline void AllocationSite::set_memento_found_count(int count) { |
| int32_t value = pretenure_data(); |
| // Verify that we can count more mementos than we can possibly find in one |
| // new space collection. |
| DCHECK((GetHeap()->MaxSemiSpaceSize() / |
| (Heap::kMinObjectSizeInWords * kPointerSize + |
| AllocationMemento::kSize)) < MementoFoundCountBits::kMax); |
| DCHECK_LT(count, MementoFoundCountBits::kMax); |
| set_pretenure_data(MementoFoundCountBits::update(value, count)); |
| } |
| |
| int AllocationSite::memento_create_count() const { |
| return pretenure_create_count(); |
| } |
| |
| void AllocationSite::set_memento_create_count(int count) { |
| set_pretenure_create_count(count); |
| } |
| |
| bool AllocationSite::IncrementMementoFoundCount(int increment) { |
| if (IsZombie()) return false; |
| |
| int value = memento_found_count(); |
| set_memento_found_count(value + increment); |
| return memento_found_count() >= kPretenureMinimumCreated; |
| } |
| |
| |
| inline void AllocationSite::IncrementMementoCreateCount() { |
| DCHECK(FLAG_allocation_site_pretenuring); |
| int value = memento_create_count(); |
| set_memento_create_count(value + 1); |
| } |
| |
| bool AllocationMemento::IsValid() const { |
| return allocation_site()->IsAllocationSite() && |
| !AllocationSite::cast(allocation_site())->IsZombie(); |
| } |
| |
| AllocationSite* AllocationMemento::GetAllocationSite() const { |
| DCHECK(IsValid()); |
| return AllocationSite::cast(allocation_site()); |
| } |
| |
| Address AllocationMemento::GetAllocationSiteUnchecked() const { |
| return reinterpret_cast<Address>(allocation_site()); |
| } |
| |
| void JSObject::EnsureCanContainHeapObjectElements(Handle<JSObject> object) { |
| JSObject::ValidateElements(*object); |
| ElementsKind elements_kind = object->map()->elements_kind(); |
| if (!IsObjectElementsKind(elements_kind)) { |
| if (IsHoleyElementsKind(elements_kind)) { |
| TransitionElementsKind(object, HOLEY_ELEMENTS); |
| } else { |
| TransitionElementsKind(object, PACKED_ELEMENTS); |
| } |
| } |
| } |
| |
| |
| void JSObject::EnsureCanContainElements(Handle<JSObject> object, |
| Object** objects, |
| uint32_t count, |
| EnsureElementsMode mode) { |
| ElementsKind current_kind = object->GetElementsKind(); |
| ElementsKind target_kind = current_kind; |
| { |
| DisallowHeapAllocation no_allocation; |
| DCHECK(mode != ALLOW_COPIED_DOUBLE_ELEMENTS); |
| bool is_holey = IsHoleyElementsKind(current_kind); |
| if (current_kind == HOLEY_ELEMENTS) return; |
| Object* the_hole = object->GetReadOnlyRoots().the_hole_value(); |
| for (uint32_t i = 0; i < count; ++i) { |
| Object* current = *objects++; |
| if (current == the_hole) { |
| is_holey = true; |
| target_kind = GetHoleyElementsKind(target_kind); |
| } else if (!current->IsSmi()) { |
| if (mode == ALLOW_CONVERTED_DOUBLE_ELEMENTS && current->IsNumber()) { |
| if (IsSmiElementsKind(target_kind)) { |
| if (is_holey) { |
| target_kind = HOLEY_DOUBLE_ELEMENTS; |
| } else { |
| target_kind = PACKED_DOUBLE_ELEMENTS; |
| } |
| } |
| } else if (is_holey) { |
| target_kind = HOLEY_ELEMENTS; |
| break; |
| } else { |
| target_kind = PACKED_ELEMENTS; |
| } |
| } |
| } |
| } |
| if (target_kind != current_kind) { |
| TransitionElementsKind(object, target_kind); |
| } |
| } |
| |
| |
| void JSObject::EnsureCanContainElements(Handle<JSObject> object, |
| Handle<FixedArrayBase> elements, |
| uint32_t length, |
| EnsureElementsMode mode) { |
| ReadOnlyRoots roots = object->GetReadOnlyRoots(); |
| if (elements->map() != roots.fixed_double_array_map()) { |
| DCHECK(elements->map() == roots.fixed_array_map() || |
| elements->map() == roots.fixed_cow_array_map()); |
| if (mode == ALLOW_COPIED_DOUBLE_ELEMENTS) { |
| mode = DONT_ALLOW_DOUBLE_ELEMENTS; |
| } |
| Object** objects = |
| Handle<FixedArray>::cast(elements)->GetFirstElementAddress(); |
| EnsureCanContainElements(object, objects, length, mode); |
| return; |
| } |
| |
| DCHECK(mode == ALLOW_COPIED_DOUBLE_ELEMENTS); |
| if (object->GetElementsKind() == HOLEY_SMI_ELEMENTS) { |
| TransitionElementsKind(object, HOLEY_DOUBLE_ELEMENTS); |
| } else if (object->GetElementsKind() == PACKED_SMI_ELEMENTS) { |
| Handle<FixedDoubleArray> double_array = |
| Handle<FixedDoubleArray>::cast(elements); |
| for (uint32_t i = 0; i < length; ++i) { |
| if (double_array->is_the_hole(i)) { |
| TransitionElementsKind(object, HOLEY_DOUBLE_ELEMENTS); |
| return; |
| } |
| } |
| TransitionElementsKind(object, PACKED_DOUBLE_ELEMENTS); |
| } |
| } |
| |
| |
| void JSObject::SetMapAndElements(Handle<JSObject> object, |
| Handle<Map> new_map, |
| Handle<FixedArrayBase> value) { |
| JSObject::MigrateToMap(object, new_map); |
| DCHECK((object->map()->has_fast_smi_or_object_elements() || |
| (*value == object->GetReadOnlyRoots().empty_fixed_array()) || |
| object->map()->has_fast_string_wrapper_elements()) == |
| (value->map() == object->GetReadOnlyRoots().fixed_array_map() || |
| value->map() == object->GetReadOnlyRoots().fixed_cow_array_map())); |
| DCHECK((*value == object->GetReadOnlyRoots().empty_fixed_array()) || |
| (object->map()->has_fast_double_elements() == |
| value->IsFixedDoubleArray())); |
| object->set_elements(*value); |
| } |
| |
| |
| void JSObject::set_elements(FixedArrayBase* value, WriteBarrierMode mode) { |
| WRITE_FIELD(this, kElementsOffset, value); |
| CONDITIONAL_WRITE_BARRIER(this, kElementsOffset, value, mode); |
| } |
| |
| |
| void JSObject::initialize_elements() { |
| FixedArrayBase* elements = map()->GetInitialElements(); |
| WRITE_FIELD(this, kElementsOffset, elements); |
| } |
| |
| |
| InterceptorInfo* JSObject::GetIndexedInterceptor() { |
| return map()->GetIndexedInterceptor(); |
| } |
| |
| InterceptorInfo* JSObject::GetNamedInterceptor() { |
| return map()->GetNamedInterceptor(); |
| } |
| |
| double Oddball::to_number_raw() const { |
| return READ_DOUBLE_FIELD(this, kToNumberRawOffset); |
| } |
| |
| void Oddball::set_to_number_raw(double value) { |
| WRITE_DOUBLE_FIELD(this, kToNumberRawOffset, value); |
| } |
| |
| void Oddball::set_to_number_raw_as_bits(uint64_t bits) { |
| WRITE_UINT64_FIELD(this, kToNumberRawOffset, bits); |
| } |
| |
| ACCESSORS(Oddball, to_string, String, kToStringOffset) |
| ACCESSORS(Oddball, to_number, Object, kToNumberOffset) |
| ACCESSORS(Oddball, type_of, String, kTypeOfOffset) |
| |
| byte Oddball::kind() const { return Smi::ToInt(READ_FIELD(this, kKindOffset)); } |
| |
| void Oddball::set_kind(byte value) { |
| WRITE_FIELD(this, kKindOffset, Smi::FromInt(value)); |
| } |
| |
| |
| // static |
| Handle<Object> Oddball::ToNumber(Isolate* isolate, Handle<Oddball> input) { |
| return handle(input->to_number(), isolate); |
| } |
| |
| |
| ACCESSORS(Cell, value, Object, kValueOffset) |
| ACCESSORS(FeedbackCell, value, HeapObject, kValueOffset) |
| ACCESSORS(PropertyCell, dependent_code, DependentCode, kDependentCodeOffset) |
| ACCESSORS(PropertyCell, name, Name, kNameOffset) |
| ACCESSORS(PropertyCell, value, Object, kValueOffset) |
| ACCESSORS(PropertyCell, property_details_raw, Object, kDetailsOffset) |
| |
| PropertyDetails PropertyCell::property_details() const { |
| return PropertyDetails(Smi::cast(property_details_raw())); |
| } |
| |
| |
| void PropertyCell::set_property_details(PropertyDetails details) { |
| set_property_details_raw(details.AsSmi()); |
| } |
| |
| int JSObject::GetHeaderSize() const { return GetHeaderSize(map()); } |
| |
| int JSObject::GetHeaderSize(const Map* map) { |
| // Check for the most common kind of JavaScript object before |
| // falling into the generic switch. This speeds up the internal |
| // field operations considerably on average. |
| InstanceType instance_type = map->instance_type(); |
| return instance_type == JS_OBJECT_TYPE |
| ? JSObject::kHeaderSize |
| : GetHeaderSize(instance_type, map->has_prototype_slot()); |
| } |
| |
| 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()); |
| } |
| |
| // static |
| int JSObject::GetEmbedderFieldCount(const Map* map) { |
| int instance_size = map->instance_size(); |
| if (instance_size == kVariableSizeSentinel) return 0; |
| return ((instance_size - GetHeaderSize(map)) >> kPointerSizeLog2) - |
| map->GetInObjectProperties(); |
| } |
| |
| int JSObject::GetEmbedderFieldCount() const { |
| return GetEmbedderFieldCount(map()); |
| } |
| |
| int JSObject::GetEmbedderFieldOffset(int index) { |
| DCHECK(index < GetEmbedderFieldCount() && index >= 0); |
| return GetHeaderSize() + (kPointerSize * index); |
| } |
| |
| Object* JSObject::GetEmbedderField(int index) { |
| DCHECK(index < GetEmbedderFieldCount() && index >= 0); |
| // Internal objects do follow immediately after the header, whereas in-object |
| // properties are at the end of the object. Therefore there is no need |
| // to adjust the index here. |
| return READ_FIELD(this, GetHeaderSize() + (kPointerSize * index)); |
| } |
| |
| void JSObject::SetEmbedderField(int index, Object* value) { |
| DCHECK(index < GetEmbedderFieldCount() && index >= 0); |
| // Internal objects do follow immediately after the header, whereas in-object |
| // properties are at the end of the object. Therefore there is no need |
| // to adjust the index here. |
| int offset = GetHeaderSize() + (kPointerSize * index); |
| WRITE_FIELD(this, offset, value); |
| WRITE_BARRIER(this, offset, value); |
| } |
| |
| void JSObject::SetEmbedderField(int index, Smi* value) { |
| DCHECK(index < GetEmbedderFieldCount() && index >= 0); |
| // Internal objects do follow immediately after the header, whereas in-object |
| // properties are at the end of the object. Therefore there is no need |
| // to adjust the index here. |
| int offset = GetHeaderSize() + (kPointerSize * index); |
| WRITE_FIELD(this, offset, value); |
| } |
| |
| |
| bool JSObject::IsUnboxedDoubleField(FieldIndex index) { |
| if (!FLAG_unbox_double_fields) return false; |
| return map()->IsUnboxedDoubleField(index); |
| } |
| |
| // Access fast-case object properties at index. The use of these routines |
| // is needed to correctly distinguish between properties stored in-object and |
| // properties stored in the properties array. |
| Object* JSObject::RawFastPropertyAt(FieldIndex index) { |
| DCHECK(!IsUnboxedDoubleField(index)); |
| if (index.is_inobject()) { |
| return READ_FIELD(this, index.offset()); |
| } else { |
| return property_array()->get(index.outobject_array_index()); |
| } |
| } |
| |
| |
| double JSObject::RawFastDoublePropertyAt(FieldIndex index) { |
| DCHECK(IsUnboxedDoubleField(index)); |
| return READ_DOUBLE_FIELD(this, index.offset()); |
| } |
| |
| uint64_t JSObject::RawFastDoublePropertyAsBitsAt(FieldIndex index) { |
| DCHECK(IsUnboxedDoubleField(index)); |
| return READ_UINT64_FIELD(this, index.offset()); |
| } |
| |
| void JSObject::RawFastPropertyAtPut(FieldIndex index, Object* value) { |
| if (index.is_inobject()) { |
| int offset = index.offset(); |
| WRITE_FIELD(this, offset, value); |
| WRITE_BARRIER(this, offset, value); |
| } else { |
| property_array()->set(index.outobject_array_index(), value); |
| } |
| } |
| |
| void JSObject::RawFastDoublePropertyAsBitsAtPut(FieldIndex index, |
| uint64_t bits) { |
| // Double unboxing is enabled only on 64-bit platforms. |
| DCHECK_EQ(kDoubleSize, kPointerSize); |
| Address field_addr = FIELD_ADDR(this, index.offset()); |
| base::Relaxed_Store(reinterpret_cast<base::AtomicWord*>(field_addr), |
| static_cast<base::AtomicWord>(bits)); |
| } |
| |
| void JSObject::FastPropertyAtPut(FieldIndex index, Object* value) { |
| if (IsUnboxedDoubleField(index)) { |
| DCHECK(value->IsMutableHeapNumber()); |
| // Ensure that all bits of the double value are preserved. |
| RawFastDoublePropertyAsBitsAtPut( |
| index, MutableHeapNumber::cast(value)->value_as_bits()); |
| } else { |
| RawFastPropertyAtPut(index, value); |
| } |
| } |
| |
| void JSObject::WriteToField(int descriptor, PropertyDetails details, |
| Object* value) { |
| DCHECK_EQ(kField, details.location()); |
| DCHECK_EQ(kData, details.kind()); |
| DisallowHeapAllocation no_gc; |
| FieldIndex index = FieldIndex::ForDescriptor(map(), descriptor); |
| if (details.representation().IsDouble()) { |
| // Nothing more to be done. |
| if (value->IsUninitialized()) { |
| return; |
| } |
| // Manipulating the signaling NaN used for the hole and uninitialized |
| // double field sentinel in C++, e.g. with bit_cast or value()/set_value(), |
| // will change its value on ia32 (the x87 stack is used to return values |
| // and stores to the stack silently clear the signalling bit). |
| uint64_t bits; |
| if (value->IsSmi()) { |
| bits = bit_cast<uint64_t>(static_cast<double>(Smi::ToInt(value))); |
| } else { |
| DCHECK(value->IsHeapNumber()); |
| bits = HeapNumber::cast(value)->value_as_bits(); |
| } |
| if (IsUnboxedDoubleField(index)) { |
| RawFastDoublePropertyAsBitsAtPut(index, bits); |
| } else { |
| auto box = MutableHeapNumber::cast(RawFastPropertyAt(index)); |
| box->set_value_as_bits(bits); |
| } |
| } else { |
| RawFastPropertyAtPut(index, value); |
| } |
| } |
| |
| int JSObject::GetInObjectPropertyOffset(int index) { |
| return map()->GetInObjectPropertyOffset(index); |
| } |
| |
| |
| Object* JSObject::InObjectPropertyAt(int index) { |
| int offset = GetInObjectPropertyOffset(index); |
| return READ_FIELD(this, offset); |
| } |
| |
| |
| Object* JSObject::InObjectPropertyAtPut(int index, |
| Object* value, |
| WriteBarrierMode mode) { |
| // Adjust for the number of properties stored in the object. |
| int offset = GetInObjectPropertyOffset(index); |
| WRITE_FIELD(this, offset, value); |
| CONDITIONAL_WRITE_BARRIER(this, offset, value, mode); |
| return value; |
| } |
| |
| |
| void JSObject::InitializeBody(Map* map, int start_offset, |
| Object* pre_allocated_value, |
| Object* filler_value) { |
| DCHECK(!filler_value->IsHeapObject() || !Heap::InNewSpace(filler_value)); |
| DCHECK(!pre_allocated_value->IsHeapObject() || |
| !Heap::InNewSpace(pre_allocated_value)); |
| int size = map->instance_size(); |
| int offset = start_offset; |
| if (filler_value != pre_allocated_value) { |
| int end_of_pre_allocated_offset = |
| size - (map->UnusedPropertyFields() * kPointerSize); |
| DCHECK_LE(kHeaderSize, end_of_pre_allocated_offset); |
| while (offset < end_of_pre_allocated_offset) { |
| WRITE_FIELD(this, offset, pre_allocated_value); |
| offset += kPointerSize; |
| } |
| } |
| while (offset < size) { |
| WRITE_FIELD(this, offset, filler_value); |
| offset += kPointerSize; |
| } |
| } |
| |
| void Struct::InitializeBody(int object_size) { |
| Object* value = GetReadOnlyRoots().undefined_value(); |
| for (int offset = kHeaderSize; offset < object_size; offset += kPointerSize) { |
| WRITE_FIELD(this, offset, value); |
| } |
| } |
| |
| bool Object::ToArrayLength(uint32_t* index) const { |
| return Object::ToUint32(index); |
| } |
| |
| bool Object::ToArrayIndex(uint32_t* index) const { |
| return Object::ToUint32(index) && *index != kMaxUInt32; |
| } |
| |
| |
| void Object::VerifyApiCallResultType() { |
| #if DEBUG |
| if (IsSmi()) return; |
| DCHECK(IsHeapObject()); |
| if (!(IsString() || IsSymbol() || IsJSReceiver() || IsHeapNumber() || |
| IsBigInt() || IsUndefined() || IsTrue() || IsFalse() || IsNull())) { |
| FATAL("API call returned invalid object"); |
| } |
| #endif // DEBUG |
| } |
| |
| Object* PropertyArray::get(int index) const { |
| DCHECK_GE(index, 0); |
| DCHECK_LE(index, this->length()); |
| return RELAXED_READ_FIELD(this, kHeaderSize + index * kPointerSize); |
| } |
| |
| void PropertyArray::set(int index, Object* value) { |
| DCHECK(IsPropertyArray()); |
| DCHECK_GE(index, 0); |
| DCHECK_LT(index, this->length()); |
| int offset = kHeaderSize + index * kPointerSize; |
| RELAXED_WRITE_FIELD(this, offset, value); |
| WRITE_BARRIER(this, offset, value); |
| } |
| |
| 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); |
| Object* obj = get(kLastSubjectIndex); |
| return String::cast(obj); |
| } |
| |
| 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) { |
| Heap* heap = Heap::FromWritableHeapObject(this); |
| if (heap->incremental_marking()->IsMarking()) return UPDATE_WRITE_BARRIER; |
| if (Heap::InNewSpace(this)) return SKIP_WRITE_BARRIER; |
| return UPDATE_WRITE_BARRIER; |
| } |
| |
| AllocationAlignment HeapObject::RequiredAlignment(Map* map) { |
| #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; |
| } |
| |
| bool HeapObject::NeedsRehashing() const { |
| switch (map()->instance_type()) { |
| case DESCRIPTOR_ARRAY_TYPE: |
| return DescriptorArray::cast(this)->number_of_descriptors() > 1; |
| case TRANSITION_ARRAY_TYPE: |
| return TransitionArray::cast(this)->number_of_entries() > 1; |
| case ORDERED_HASH_MAP_TYPE: |
| return OrderedHashMap::cast(this)->NumberOfElements() > 0; |
| case ORDERED_HASH_SET_TYPE: |
| return OrderedHashSet::cast(this)->NumberOfElements() > 0; |
| case NAME_DICTIONARY_TYPE: |
| case GLOBAL_DICTIONARY_TYPE: |
| case NUMBER_DICTIONARY_TYPE: |
| case SIMPLE_NUMBER_DICTIONARY_TYPE: |
| case STRING_TABLE_TYPE: |
| case HASH_TABLE_TYPE: |
| case SMALL_ORDERED_HASH_MAP_TYPE: |
| case SMALL_ORDERED_HASH_SET_TYPE: |
| return true; |
| default: |
| return false; |
| } |
| } |
| |
| Address HeapObject::GetFieldAddress(int field_offset) const { |
| return FIELD_ADDR(this, field_offset); |
| } |
| |
| void PropertyArray::set(int index, Object* value, WriteBarrierMode mode) { |
| DCHECK_GE(index, 0); |
| DCHECK_LT(index, this->length()); |
| int offset = kHeaderSize + index * kPointerSize; |
| RELAXED_WRITE_FIELD(this, offset, value); |
| CONDITIONAL_WRITE_BARRIER(this, offset, value, mode); |
| } |
| |
| Object** PropertyArray::data_start() { |
| return HeapObject::RawField(this, kHeaderSize); |
| } |
| |
| ACCESSORS(EnumCache, keys, FixedArray, kKeysOffset) |
| ACCESSORS(EnumCache, indices, FixedArray, kIndicesOffset) |
| |
| int DescriptorArray::number_of_descriptors() const { |
| return Smi::ToInt(get(kDescriptorLengthIndex)->ToSmi()); |
| } |
| |
| int DescriptorArray::number_of_descriptors_storage() const { |
| return (length() - kFirstIndex) / kEntrySize; |
| } |
| |
| int DescriptorArray::NumberOfSlackDescriptors() const { |
| return number_of_descriptors_storage() - number_of_descriptors(); |
| } |
| |
| |
| void DescriptorArray::SetNumberOfDescriptors(int number_of_descriptors) { |
| set(kDescriptorLengthIndex, |
| MaybeObject::FromObject(Smi::FromInt(number_of_descriptors))); |
| } |
| |
| inline int DescriptorArray::number_of_entries() const { |
| return number_of_descriptors(); |
| } |
| |
| void DescriptorArray::CopyEnumCacheFrom(DescriptorArray* array) { |
| set(kEnumCacheIndex, array->get(kEnumCacheIndex)); |
| } |
| |
| EnumCache* DescriptorArray::GetEnumCache() { |
| return EnumCache::cast(get(kEnumCacheIndex)->ToStrongHeapObject()); |
| } |
| |
| // Perform a binary search in a fixed array. |
| template <SearchMode search_mode, typename T> |
| int BinarySearch(T* array, Name* name, int valid_entries, |
| int* out_insertion_index) { |
| DCHECK(search_mode == ALL_ENTRIES || out_insertion_index == nullptr); |
| int low = 0; |
| int high = array->number_of_entries() - 1; |
| uint32_t hash = name->hash_field(); |
| int limit = high; |
| |
| DCHECK(low <= high); |
| |
| while (low != high) { |
| int mid = low + (high - low) / 2; |
| Name* mid_name = array->GetSortedKey(mid); |
| uint32_t mid_hash = mid_name->hash_field(); |
| |
| if (mid_hash >= hash) { |
| high = mid; |
| } else { |
| low = mid + 1; |
| } |
| } |
| |
| for (; low <= limit; ++low) { |
| int sort_index = array->GetSortedKeyIndex(low); |
| Name* entry = array->GetKey(sort_index); |
| uint32_t current_hash = entry->hash_field(); |
| if (current_hash != hash) { |
| if (search_mode == ALL_ENTRIES && out_insertion_index != nullptr) { |
| *out_insertion_index = sort_index + (current_hash > hash ? 0 : 1); |
| } |
| return T::kNotFound; |
| } |
| if (entry == name) { |
| if (search_mode == ALL_ENTRIES || sort_index < valid_entries) { |
| return sort_index; |
| } |
| return T::kNotFound; |
| } |
| } |
| |
| if (search_mode == ALL_ENTRIES && out_insertion_index != nullptr) { |
| *out_insertion_index = limit + 1; |
| } |
| return T::kNotFound; |
| } |
| |
| |
| // Perform a linear search in this fixed array. len is the number of entry |
| // indices that are valid. |
| template <SearchMode search_mode, typename T> |
| int LinearSearch(T* array, Name* name, int valid_entries, |
| int* out_insertion_index) { |
| if (search_mode == ALL_ENTRIES && out_insertion_index != nullptr) { |
| uint32_t hash = name->hash_field(); |
| int len = array->number_of_entries(); |
| for (int number = 0; number < len; number++) { |
| int sorted_index = array->GetSortedKeyIndex(number); |
| Name* entry = array->GetKey(sorted_index); |
| uint32_t current_hash = entry->hash_field(); |
| if (current_hash > hash) { |
| *out_insertion_index = sorted_index; |
| return T::kNotFound; |
| } |
| if (entry == name) return sorted_index; |
| } |
| *out_insertion_index = len; |
| return T::kNotFound; |
| } else { |
| DCHECK_LE(valid_entries, array->number_of_entries()); |
| DCHECK_NULL(out_insertion_index); // Not supported here. |
| for (int number = 0; number < valid_entries; number++) { |
| if (array->GetKey(number) == name) return number; |
| } |
| return T::kNotFound; |
| } |
| } |
| |
| template <SearchMode search_mode, typename T> |
| int Search(T* array, Name* name, int valid_entries, int* out_insertion_index) { |
| SLOW_DCHECK(array->IsSortedNoDuplicates()); |
| |
| if (valid_entries == 0) { |
| if (search_mode == ALL_ENTRIES && out_insertion_index != nullptr) { |
| *out_insertion_index = 0; |
| } |
| return T::kNotFound; |
| } |
| |
| // Fast case: do linear search for small arrays. |
| const int kMaxElementsForLinearSearch = 8; |
| if (valid_entries <= kMaxElementsForLinearSearch) { |
| return LinearSearch<search_mode>(array, name, valid_entries, |
| out_insertion_index); |
| } |
| |
| // Slow case: perform binary search. |
| return BinarySearch<search_mode>(array, name, valid_entries, |
| out_insertion_index); |
| } |
| |
| |
| int DescriptorArray::Search(Name* name, int valid_descriptors) { |
| DCHECK(name->IsUniqueName()); |
| return internal::Search<VALID_ENTRIES>(this, name, valid_descriptors, |
| nullptr); |
| } |
| |
| int DescriptorArray::Search(Name* name, Map* map) { |
| DCHECK(name->IsUniqueName()); |
| int number_of_own_descriptors = map->NumberOfOwnDescriptors(); |
| if (number_of_own_descriptors == 0) return kNotFound; |
| return Search(name, number_of_own_descriptors); |
| } |
| |
| int DescriptorArray::SearchWithCache(Isolate* isolate, Name* name, Map* map) { |
| DCHECK(name->IsUniqueName()); |
| int number_of_own_descriptors = map->NumberOfOwnDescriptors(); |
| if (number_of_own_descriptors == 0) return kNotFound; |
| |
| DescriptorLookupCache* cache = isolate->descriptor_lookup_cache(); |
| int number = cache->Lookup(map, name); |
| |
| if (number == DescriptorLookupCache::kAbsent) { |
| number = Search(name, number_of_own_descriptors); |
| cache->Update(map, name, number); |
| } |
| |
| return number; |
| } |
| |
| |
| Object** DescriptorArray::GetKeySlot(int descriptor_number) { |
| DCHECK(descriptor_number < number_of_descriptors()); |
| DCHECK((*RawFieldOfElementAt(ToKeyIndex(descriptor_number)))->IsObject()); |
| return reinterpret_cast<Object**>( |
| RawFieldOfElementAt(ToKeyIndex(descriptor_number))); |
| } |
| |
| MaybeObject** DescriptorArray::GetDescriptorStartSlot(int descriptor_number) { |
| return reinterpret_cast<MaybeObject**>(GetKeySlot(descriptor_number)); |
| } |
| |
| MaybeObject** DescriptorArray::GetDescriptorEndSlot(int descriptor_number) { |
| return GetValueSlot(descriptor_number - 1) + 1; |
| } |
| |
| |
| Name* DescriptorArray::GetKey(int descriptor_number) { |
| DCHECK(descriptor_number < number_of_descriptors()); |
| return Name::cast(get(ToKeyIndex(descriptor_number))->ToStrongHeapObject()); |
| } |
| |
| |
| int DescriptorArray::GetSortedKeyIndex(int descriptor_number) { |
| return GetDetails(descriptor_number).pointer(); |
| } |
| |
| |
| Name* DescriptorArray::GetSortedKey(int descriptor_number) { |
| return GetKey(GetSortedKeyIndex(descriptor_number)); |
| } |
| |
| |
| void DescriptorArray::SetSortedKey(int descriptor_index, int pointer) { |
| PropertyDetails details = GetDetails(descriptor_index); |
| set(ToDetailsIndex(descriptor_index), |
| MaybeObject::FromObject(details.set_pointer(pointer).AsSmi())); |
| } |
| |
| MaybeObject** DescriptorArray::GetValueSlot(int descriptor_number) { |
| DCHECK(descriptor_number < number_of_descriptors()); |
| return RawFieldOfElementAt(ToValueIndex(descriptor_number)); |
| } |
| |
| |
| int DescriptorArray::GetValueOffset(int descriptor_number) { |
| return OffsetOfElementAt(ToValueIndex(descriptor_number)); |
| } |
| |
| Object* DescriptorArray::GetStrongValue(int descriptor_number) { |
| DCHECK(descriptor_number < number_of_descriptors()); |
| return get(ToValueIndex(descriptor_number))->ToObject(); |
| } |
| |
| |
| void DescriptorArray::SetValue(int descriptor_index, Object* value) { |
| set(ToValueIndex(descriptor_index), MaybeObject::FromObject(value)); |
| } |
| |
| MaybeObject* DescriptorArray::GetValue(int descriptor_number) { |
| DCHECK_LT(descriptor_number, number_of_descriptors()); |
| return get(ToValueIndex(descriptor_number)); |
| } |
| |
| PropertyDetails DescriptorArray::GetDetails(int descriptor_number) { |
| DCHECK(descriptor_number < number_of_descriptors()); |
| MaybeObject* details = get(ToDetailsIndex(descriptor_number)); |
| return PropertyDetails(details->ToSmi()); |
| } |
| |
| int DescriptorArray::GetFieldIndex(int descriptor_number) { |
| DCHECK_EQ(GetDetails(descriptor_number).location(), kField); |
| return GetDetails(descriptor_number).field_index(); |
| } |
| |
| FieldType* DescriptorArray::GetFieldType(int descriptor_number) { |
| DCHECK_EQ(GetDetails(descriptor_number).location(), kField); |
| MaybeObject* wrapped_type = GetValue(descriptor_number); |
| return Map::UnwrapFieldType(wrapped_type); |
| } |
| |
| void DescriptorArray::Set(int descriptor_number, Name* key, MaybeObject* value, |
| PropertyDetails details) { |
| // Range check. |
| DCHECK(descriptor_number < number_of_descriptors()); |
| set(ToKeyIndex(descriptor_number), MaybeObject::FromObject(key)); |
| set(ToValueIndex(descriptor_number), value); |
| set(ToDetailsIndex(descriptor_number), |
| MaybeObject::FromObject(details.AsSmi())); |
| } |
| |
| void DescriptorArray::Set(int descriptor_number, Descriptor* desc) { |
| Name* key = *desc->GetKey(); |
| MaybeObject* value = *desc->GetValue(); |
| Set(descriptor_number, key, value, desc->GetDetails()); |
| } |
| |
| |
| void DescriptorArray::Append(Descriptor* desc) { |
| DisallowHeapAllocation no_gc; |
| int descriptor_number = number_of_descriptors(); |
| SetNumberOfDescriptors(descriptor_number + 1); |
| Set(descriptor_number, desc); |
| |
| uint32_t hash = desc->GetKey()->Hash(); |
| |
| int insertion; |
| |
| for (insertion = descriptor_number; insertion > 0; --insertion) { |
| Name* key = GetSortedKey(insertion - 1); |
| if (key->Hash() <= hash) break; |
| SetSortedKey(insertion, GetSortedKeyIndex(insertion - 1)); |
| } |
| |
| SetSortedKey(insertion, descriptor_number); |
| } |
| |
| |
| void DescriptorArray::SwapSortedKeys(int first, int second) { |
| int first_key = GetSortedKeyIndex(first); |
| SetSortedKey(first, GetSortedKeyIndex(second)); |
| SetSortedKey(second, first_key); |
| } |
| |
| MaybeObject* DescriptorArray::get(int index) const { |
| return WeakFixedArray::Get(index); |
| } |
| |
| void DescriptorArray::set(int index, MaybeObject* value) { |
| WeakFixedArray::Set(index, value); |
| } |
| |
| bool StringSetShape::IsMatch(String* key, Object* value) { |
| DCHECK(value->IsString()); |
| return key->Equals(String::cast(value)); |
| } |
| |
| uint32_t StringSetShape::Hash(Isolate* isolate, String* key) { |
| return key->Hash(); |
| } |
| |
| uint32_t StringSetShape::HashForObject(Isolate* isolate, Object* object) { |
| return String::cast(object)->Hash(); |
| } |
| |
| StringTableKey::StringTableKey(uint32_t hash_field) |
| : HashTableKey(hash_field >> Name::kHashShift), hash_field_(hash_field) {} |
| |
| void StringTableKey::set_hash_field(uint32_t hash_field) { |
| hash_field_ = hash_field; |
| set_hash(hash_field >> Name::kHashShift); |
| } |
| |
| Handle<Object> StringTableShape::AsHandle(Isolate* isolate, |
| StringTableKey* key) { |
| return key->AsHandle(isolate); |
| } |
| |
| uint32_t StringTableShape::HashForObject(Isolate* isolate, Object* object) { |
| return String::cast(object)->Hash(); |
| } |
| |
| int StringTableShape::GetMapRootIndex() { |
| return Heap::kStringTableMapRootIndex; |
| } |
| |
| bool NumberDictionary::requires_slow_elements() { |
| Object* max_index_object = get(kMaxNumberKeyIndex); |
| if (!max_index_object->IsSmi()) return false; |
| return 0 != (Smi::ToInt(max_index_object) & kRequiresSlowElementsMask); |
| } |
| |
| uint32_t NumberDictionary::max_number_key() { |
| DCHECK(!requires_slow_elements()); |
| Object* max_index_object = get(kMaxNumberKeyIndex); |
| if (!max_index_object->IsSmi()) return 0; |
| uint32_t value = static_cast<uint32_t>(Smi::ToInt(max_index_object)); |
| return value >> kRequiresSlowElementsTagSize; |
| } |
| |
| void NumberDictionary::set_requires_slow_elements() { |
| set(kMaxNumberKeyIndex, Smi::FromInt(kRequiresSlowElementsMask)); |
| } |
| |
| DEFINE_DEOPT_ELEMENT_ACCESSORS(TranslationByteArray, ByteArray) |
| DEFINE_DEOPT_ELEMENT_ACCESSORS(InlinedFunctionCount, Smi) |
| DEFINE_DEOPT_ELEMENT_ACCESSORS(LiteralArray, FixedArray) |
| DEFINE_DEOPT_ELEMENT_ACCESSORS(OsrBytecodeOffset, Smi) |
| DEFINE_DEOPT_ELEMENT_ACCESSORS(OsrPcOffset, Smi) |
| DEFINE_DEOPT_ELEMENT_ACCESSORS(OptimizationId, Smi) |
| DEFINE_DEOPT_ELEMENT_ACCESSORS(InliningPositions, PodArray<InliningPosition>) |
| |
| DEFINE_DEOPT_ENTRY_ACCESSORS(BytecodeOffsetRaw, Smi) |
| DEFINE_DEOPT_ENTRY_ACCESSORS(TranslationIndex, Smi) |
| DEFINE_DEOPT_ENTRY_ACCESSORS(Pc, Smi) |
| |
| int PropertyArray::length() const { |
| Object* value_obj = READ_FIELD(this, kLengthAndHashOffset); |
| int value = Smi::ToInt(value_obj); |
| return LengthField::decode(value); |
| } |
| |
| void PropertyArray::initialize_length(int len) { |
| SLOW_DCHECK(len >= 0); |
| SLOW_DCHECK(len < LengthField::kMax); |
| WRITE_FIELD(this, kLengthAndHashOffset, Smi::FromInt(len)); |
| } |
| |
| int PropertyArray::synchronized_length() const { |
| Object* value_obj = ACQUIRE_READ_FIELD(this, kLengthAndHashOffset); |
| int value = Smi::ToInt(value_obj); |
| return LengthField::decode(value); |
| } |
| |
| int PropertyArray::Hash() const { |
| Object* value_obj = READ_FIELD(this, kLengthAndHashOffset); |
| int value = Smi::ToInt(value_obj); |
| return HashField::decode(value); |
| } |
| |
| void PropertyArray::SetHash(int hash) { |
| Object* value_obj = READ_FIELD(this, kLengthAndHashOffset); |
| int value = Smi::ToInt(value_obj); |
| value = HashField::update(value, hash); |
| WRITE_FIELD(this, kLengthAndHashOffset, Smi::FromInt(value)); |
| } |
| |
| SMI_ACCESSORS(FreeSpace, size, kSizeOffset) |
| RELAXED_SMI_ACCESSORS(FreeSpace, size, kSizeOffset) |
| |
| |
| int FreeSpace::Size() { return size(); } |
| |
| |
| FreeSpace* FreeSpace::next() { |
| DCHECK(map() == Heap::FromWritableHeapObject(this)->root( |
| Heap::kFreeSpaceMapRootIndex) || |
| (!Heap::FromWritableHeapObject(this)->deserialization_complete() && |
| map() == nullptr)); |
| DCHECK_LE(kNextOffset + kPointerSize, relaxed_read_size()); |
| return reinterpret_cast<FreeSpace*>(Memory<Address>(address() + kNextOffset)); |
| } |
| |
| |
| void FreeSpace::set_next(FreeSpace* next) { |
| DCHECK(map() == Heap::FromWritableHeapObject(this)->root( |
| Heap::kFreeSpaceMapRootIndex) || |
| (!Heap::FromWritableHeapObject(this)->deserialization_complete() && |
| map() == nullptr)); |
| DCHECK_LE(kNextOffset + kPointerSize, relaxed_read_size()); |
| base::Relaxed_Store( |
| reinterpret_cast<base::AtomicWord*>(address() + kNextOffset), |
| reinterpret_cast<base::AtomicWord>(next)); |
| } |
| |
| |
| FreeSpace* FreeSpace::cast(HeapObject* o) { |
| SLOW_DCHECK(!Heap::FromWritableHeapObject(o)->deserialization_complete() || |
| o->IsFreeSpace()); |
| return reinterpret_cast<FreeSpace*>(o); |
| } |
| |
| int HeapObject::SizeFromMap(Map* map) const { |
| int instance_size = map->instance_size(); |
| if (instance_size != kVariableSizeSentinel) return instance_size; |
| // Only inline the most frequent cases. |
| InstanceType instance_type = map->instance_type(); |
| if (instance_type >= FIRST_FIXED_ARRAY_TYPE && |
| instance_type <= LAST_FIXED_ARRAY_TYPE) { |
| return FixedArray::SizeFor( |
| reinterpret_cast<const FixedArray*>(this)->synchronized_length()); |
| } |
| if (instance_type == ONE_BYTE_STRING_TYPE || |
| instance_type == ONE_BYTE_INTERNALIZED_STRING_TYPE) { |
| // Strings may get concurrently truncated, hence we have to access its |
| // length synchronized. |
| return SeqOneByteString::SizeFor( |
| reinterpret_cast<const SeqOneByteString*>(this)->synchronized_length()); |
| } |
| if (instance_type == BYTE_ARRAY_TYPE) { |
| return ByteArray::SizeFor( |
| reinterpret_cast<const ByteArray*>(this)->synchronized_length()); |
| } |
| if (instance_type == BYTECODE_ARRAY_TYPE) { |
| return BytecodeArray::SizeFor( |
| reinterpret_cast<const BytecodeArray*>(this)->synchronized_length()); |
| } |
| if (instance_type == FREE_SPACE_TYPE) { |
| return reinterpret_cast<const FreeSpace*>(this)->relaxed_read_size(); |
| } |
| if (instance_type == STRING_TYPE || |
| instance_type == INTERNALIZED_STRING_TYPE) { |
| // Strings may get concurrently truncated, hence we have to access its |
| // length synchronized. |
| return SeqTwoByteString::SizeFor( |
| reinterpret_cast<const SeqTwoByteString*>(this)->synchronized_length()); |
| } |
| if (instance_type == FIXED_DOUBLE_ARRAY_TYPE) { |
| return FixedDoubleArray::SizeFor( |
| reinterpret_cast<const FixedDoubleArray*>(this)->synchronized_length()); |
| } |
| if (instance_type == FEEDBACK_METADATA_TYPE) { |
| return FeedbackMetadata::SizeFor( |
| reinterpret_cast<const FeedbackMetadata*>(this) |
| ->synchronized_slot_count()); |
| } |
| if (instance_type >= FIRST_WEAK_FIXED_ARRAY_TYPE && |
| instance_type <= LAST_WEAK_FIXED_ARRAY_TYPE) { |
| return WeakFixedArray::SizeFor( |
| reinterpret_cast<const WeakFixedArray*>(this)->synchronized_length()); |
| } |
| if (instance_type == WEAK_ARRAY_LIST_TYPE) { |
| return WeakArrayList::SizeForCapacity( |
| reinterpret_cast<const WeakArrayList*>(this)->synchronized_capacity()); |
| } |
| if (instance_type >= FIRST_FIXED_TYPED_ARRAY_TYPE && |
| instance_type <= LAST_FIXED_TYPED_ARRAY_TYPE) { |
| return reinterpret_cast<const FixedTypedArrayBase*>(this)->TypedArraySize( |
| instance_type); |
| } |
| if (instance_type == SMALL_ORDERED_HASH_SET_TYPE) { |
| return SmallOrderedHashSet::SizeFor( |
| reinterpret_cast<const SmallOrderedHashSet*>(this)->Capacity()); |
| } |
| if (instance_type == PROPERTY_ARRAY_TYPE) { |
| return PropertyArray::SizeFor( |
| reinterpret_cast<const PropertyArray*>(this)->synchronized_length()); |
| } |
| if (instance_type == SMALL_ORDERED_HASH_MAP_TYPE) { |
| return SmallOrderedHashMap::SizeFor( |
| reinterpret_cast<const SmallOrderedHashMap*>(this)->Capacity()); |
| } |
| if (instance_type == FEEDBACK_VECTOR_TYPE) { |
| return FeedbackVector::SizeFor( |
| reinterpret_cast<const FeedbackVector*>(this)->length()); |
| } |
| if (instance_type == BIGINT_TYPE) { |
| return BigInt::SizeFor(reinterpret_cast<const BigInt*>(this)->length()); |
| } |
| if (instance_type == PRE_PARSED_SCOPE_DATA_TYPE) { |
| return PreParsedScopeData::SizeFor( |
| reinterpret_cast<const PreParsedScopeData*>(this)->length()); |
| } |
| DCHECK(instance_type == CODE_TYPE); |
| return reinterpret_cast<const Code*>(this)->CodeSize(); |
| } |
| |
| Object* JSBoundFunction::raw_bound_target_function() const { |
| return READ_FIELD(this, kBoundTargetFunctionOffset); |
| } |
| |
| ACCESSORS(JSBoundFunction, bound_target_function, JSReceiver, |
| kBoundTargetFunctionOffset) |
| ACCESSORS(JSBoundFunction, bound_this, Object, kBoundThisOffset) |
| ACCESSORS(JSBoundFunction, bound_arguments, FixedArray, kBoundArgumentsOffset) |
| |
| ACCESSORS(JSFunction, shared, SharedFunctionInfo, kSharedFunctionInfoOffset) |
| ACCESSORS(JSFunction, feedback_cell, FeedbackCell, kFeedbackCellOffset) |
| |
| ACCESSORS(JSGlobalObject, native_context, Context, kNativeContextOffset) |
| ACCESSORS(JSGlobalObject, global_proxy, JSObject, kGlobalProxyOffset) |
| |
| ACCESSORS(JSGlobalProxy, native_context, Object, kNativeContextOffset) |
| |
| ACCESSORS(AsyncGeneratorRequest, next, Object, kNextOffset) |
| SMI_ACCESSORS(AsyncGeneratorRequest, resume_mode, kResumeModeOffset) |
| ACCESSORS(AsyncGeneratorRequest, value, Object, kValueOffset) |
| ACCESSORS(AsyncGeneratorRequest, promise, Object, kPromiseOffset) |
| |
| ACCESSORS(Tuple2, value1, Object, kValue1Offset) |
| ACCESSORS(Tuple2, value2, Object, kValue2Offset) |
| ACCESSORS(Tuple3, value3, Object, kValue3Offset) |
| |
| ACCESSORS(TemplateObjectDescription, raw_strings, FixedArray, kRawStringsOffset) |
| ACCESSORS(TemplateObjectDescription, cooked_strings, FixedArray, |
| kCookedStringsOffset) |
| |
| ACCESSORS(AccessorPair, getter, Object, kGetterOffset) |
| ACCESSORS(AccessorPair, setter, Object, kSetterOffset) |
| |
| ACCESSORS(AllocationSite, transition_info_or_boilerplate, Object, |
| kTransitionInfoOrBoilerplateOffset) |
| |
| JSObject* AllocationSite::boilerplate() const { |
| DCHECK(PointsToLiteral()); |
| return JSObject::cast(transition_info_or_boilerplate()); |
| } |
| |
| void AllocationSite::set_boilerplate(JSObject* object, WriteBarrierMode mode) { |
| set_transition_info_or_boilerplate(object, mode); |
| } |
| |
| int AllocationSite::transition_info() const { |
| DCHECK(!PointsToLiteral()); |
| return Smi::cast(transition_info_or_boilerplate())->value(); |
| } |
| |
| void AllocationSite::set_transition_info(int value) { |
| DCHECK(!PointsToLiteral()); |
| set_transition_info_or_boilerplate(Smi::FromInt(value), SKIP_WRITE_BARRIER); |
| } |
| |
| ACCESSORS(AllocationSite, nested_site, Object, kNestedSiteOffset) |
| INT32_ACCESSORS(AllocationSite, pretenure_data, kPretenureDataOffset) |
| INT32_ACCESSORS(AllocationSite, pretenure_create_count, |
| kPretenureCreateCountOffset) |
| ACCESSORS(AllocationSite, dependent_code, DependentCode, |
| kDependentCodeOffset) |
| ACCESSORS_CHECKED(AllocationSite, weak_next, Object, kWeakNextOffset, |
| HasWeakNext()) |
| ACCESSORS(AllocationMemento, allocation_site, Object, kAllocationSiteOffset) |
| |
| SMI_ACCESSORS(StackFrameInfo, line_number, kLineNumberIndex) |
| SMI_ACCESSORS(StackFrameInfo, column_number, kColumnNumberIndex) |
| SMI_ACCESSORS(StackFrameInfo, script_id, kScriptIdIndex) |
| ACCESSORS(StackFrameInfo, script_name, Object, kScriptNameIndex) |
| ACCESSORS(StackFrameInfo, script_name_or_source_url, Object, |
| kScriptNameOrSourceUrlIndex) |
| ACCESSORS(StackFrameInfo, function_name, Object, kFunctionNameIndex) |
| SMI_ACCESSORS(StackFrameInfo, flag, kFlagIndex) |
| BOOL_ACCESSORS(StackFrameInfo, flag, is_eval, kIsEvalBit) |
| BOOL_ACCESSORS(StackFrameInfo, flag, is_constructor, kIsConstructorBit) |
| BOOL_ACCESSORS(StackFrameInfo, flag, is_wasm, kIsWasmBit) |
| SMI_ACCESSORS(StackFrameInfo, id, kIdIndex) |
| |
| ACCESSORS(SourcePositionTableWithFrameCache, source_position_table, ByteArray, |
| kSourcePositionTableIndex) |
| ACCESSORS(SourcePositionTableWithFrameCache, stack_frame_cache, |
| SimpleNumberDictionary, kStackFrameCacheIndex) |
| |
| |
| FeedbackVector* JSFunction::feedback_vector() const { |
| DCHECK(has_feedback_vector()); |
| return FeedbackVector::cast(feedback_cell()->value()); |
| } |
| |
| // Code objects that are marked for deoptimization are not considered to be |
| // optimized. This is because the JSFunction might have been already |
| // deoptimized but its code() still needs to be unlinked, which will happen on |
| // its next activation. |
| // TODO(jupvfranco): rename this function. Maybe RunOptimizedCode, |
| // or IsValidOptimizedCode. |
| bool JSFunction::IsOptimized() { |
| return code()->kind() == Code::OPTIMIZED_FUNCTION && |
| !code()->marked_for_deoptimization(); |
| } |
| |
| bool JSFunction::HasOptimizedCode() { |
| return IsOptimized() || |
| (has_feedback_vector() && feedback_vector()->has_optimized_code() && |
| !feedback_vector()->optimized_code()->marked_for_deoptimization()); |
| } |
| |
| bool JSFunction::HasOptimizationMarker() { |
| return has_feedback_vector() && feedback_vector()->has_optimization_marker(); |
| } |
| |
| void JSFunction::ClearOptimizationMarker() { |
| DCHECK(has_feedback_vector()); |
| feedback_vector()->ClearOptimizationMarker(); |
| } |
| |
| // Optimized code marked for deoptimization will tier back down to running |
| // interpreted on its next activation, and already doesn't count as IsOptimized. |
| bool JSFunction::IsInterpreted() { |
| return code()->is_interpreter_trampoline_builtin() || |
| (code()->kind() == Code::OPTIMIZED_FUNCTION && |
| code()->marked_for_deoptimization()); |
| } |
| |
| bool JSFunction::ChecksOptimizationMarker() { |
| return code()->checks_optimization_marker(); |
| } |
| |
| bool JSFunction::IsMarkedForOptimization() { |
| return has_feedback_vector() && feedback_vector()->optimization_marker() == |
| OptimizationMarker::kCompileOptimized; |
| } |
| |
| |
| bool JSFunction::IsMarkedForConcurrentOptimization() { |
| return has_feedback_vector() && |
| feedback_vector()->optimization_marker() == |
| OptimizationMarker::kCompileOptimizedConcurrent; |
| } |
| |
| |
| bool JSFunction::IsInOptimizationQueue() { |
| return has_feedback_vector() && feedback_vector()->optimization_marker() == |
| OptimizationMarker::kInOptimizationQueue; |
| } |
| |
| |
| void JSFunction::CompleteInobjectSlackTrackingIfActive() { |
| if (!has_prototype_slot()) return; |
| if (has_initial_map() && initial_map()->IsInobjectSlackTrackingInProgress()) { |
| initial_map()->CompleteInobjectSlackTracking(GetIsolate()); |
| } |
| } |
| |
| AbstractCode* JSFunction::abstract_code() { |
| if (IsInterpreted()) { |
| return AbstractCode::cast(shared()->GetBytecodeArray()); |
| } else { |
| return AbstractCode::cast(code()); |
| } |
| } |
| |
| Code* JSFunction::code() { return Code::cast(READ_FIELD(this, kCodeOffset)); } |
| |
| void JSFunction::set_code(Code* value) { |
| DCHECK(!Heap::InNewSpace(value)); |
| WRITE_FIELD(this, kCodeOffset, value); |
| MarkingBarrier(this, HeapObject::RawField(this, kCodeOffset), value); |
| } |
| |
| |
| void JSFunction::set_code_no_write_barrier(Code* value) { |
| DCHECK(!Heap::InNewSpace(value)); |
| WRITE_FIELD(this, kCodeOffset, value); |
| } |
| |
| void JSFunction::ClearOptimizedCodeSlot(const char* reason) { |
| if (has_feedback_vector() && feedback_vector()->has_optimized_code()) { |
| if (FLAG_trace_opt) { |
| PrintF("[evicting entry from optimizing code feedback slot (%s) for ", |
| reason); |
| ShortPrint(); |
| PrintF("]\n"); |
| } |
| feedback_vector()->ClearOptimizedCode(); |
| } |
| } |
| |
| void JSFunction::SetOptimizationMarker(OptimizationMarker marker) { |
| DCHECK(has_feedback_vector()); |
| DCHECK(ChecksOptimizationMarker()); |
| DCHECK(!HasOptimizedCode()); |
| |
| feedback_vector()->SetOptimizationMarker(marker); |
| } |
| |
| bool JSFunction::has_feedback_vector() const { |
| return !feedback_cell()->value()->IsUndefined(); |
| } |
| |
| Context* JSFunction::context() { |
| return Context::cast(READ_FIELD(this, kContextOffset)); |
| } |
| |
| bool JSFunction::has_context() const { |
| return READ_FIELD(this, kContextOffset)->IsContext(); |
| } |
| |
| JSGlobalProxy* JSFunction::global_proxy() { return context()->global_proxy(); } |
| |
| Context* JSFunction::native_context() { return context()->native_context(); } |
| |
| |
| void JSFunction::set_context(Object* value) { |
| DCHECK(value->IsUndefined() || value->IsContext()); |
| WRITE_FIELD(this, kContextOffset, value); |
| WRITE_BARRIER(this, kContextOffset, value); |
| } |
| |
| ACCESSORS_CHECKED(JSFunction, prototype_or_initial_map, Object, |
| kPrototypeOrInitialMapOffset, map()->has_prototype_slot()) |
| |
| bool JSFunction::has_prototype_slot() const { |
| return map()->has_prototype_slot(); |
| } |
| |
| Map* JSFunction::initial_map() { |
| return Map::cast(prototype_or_initial_map()); |
| } |
| |
| |
| bool JSFunction::has_initial_map() { |
| DCHECK(has_prototype_slot()); |
| return prototype_or_initial_map()->IsMap(); |
| } |
| |
| |
| bool JSFunction::has_instance_prototype() { |
| DCHECK(has_prototype_slot()); |
| return has_initial_map() || !prototype_or_initial_map()->IsTheHole(); |
| } |
| |
| bool JSFunction::has_prototype() { |
| DCHECK(has_prototype_slot()); |
| return map()->has_non_instance_prototype() || has_instance_prototype(); |
| } |
| |
| bool JSFunction::has_prototype_property() { |
| return (has_prototype_slot() && IsConstructor()) || |
| IsGeneratorFunction(shared()->kind()); |
| } |
| |
| bool JSFunction::PrototypeRequiresRuntimeLookup() { |
| return !has_prototype_property() || map()->has_non_instance_prototype(); |
| } |
| |
| Object* JSFunction::instance_prototype() { |
| DCHECK(has_instance_prototype()); |
| if (has_initial_map()) return initial_map()->prototype(); |
| // When there is no initial map and the prototype is a JSReceiver, the |
| // initial map field is used for the prototype field. |
| return prototype_or_initial_map(); |
| } |
| |
| |
| Object* JSFunction::prototype() { |
| DCHECK(has_prototype()); |
| // If the function's prototype property has been set to a non-JSReceiver |
| // value, that value is stored in the constructor field of the map. |
| if (map()->has_non_instance_prototype()) { |
| Object* prototype = map()->GetConstructor(); |
| // The map must have a prototype in that field, not a back pointer. |
| DCHECK(!prototype->IsMap()); |
| DCHECK(!prototype->IsFunctionTemplateInfo()); |
| return prototype; |
| } |
| return instance_prototype(); |
| } |
| |
| |
| bool JSFunction::is_compiled() { |
| return code()->builtin_index() != Builtins::kCompileLazy; |
| } |
| |
| // static |
| bool Foreign::IsNormalized(Object* value) { |
| if (value == Smi::kZero) return true; |
| return Foreign::cast(value)->foreign_address() != kNullAddress; |
| } |
| |
| Address Foreign::foreign_address() { |
| return AddressFrom<Address>(READ_INTPTR_FIELD(this, kForeignAddressOffset)); |
| } |
| |
| void Foreign::set_foreign_address(Address value) { |
| WRITE_INTPTR_FIELD(this, kForeignAddressOffset, OffsetFrom(value)); |
| } |
| |
| template <class Derived> |
| void SmallOrderedHashTable<Derived>::SetDataEntry(int entry, int relative_index, |
| Object* value) { |
| Address entry_offset = GetDataEntryOffset(entry, relative_index); |
| RELAXED_WRITE_FIELD(this, entry_offset, value); |
| WRITE_BARRIER(this, static_cast<int>(entry_offset), value); |
| } |
| |
| ACCESSORS(JSValue, value, Object, kValueOffset) |
| |
| |
| ACCESSORS(JSDate, value, Object, kValueOffset) |
| ACCESSORS(JSDate, cache_stamp, Object, kCacheStampOffset) |
| ACCESSORS(JSDate, year, Object, kYearOffset) |
| ACCESSORS(JSDate, month, Object, kMonthOffset) |
| ACCESSORS(JSDate, day, Object, kDayOffset) |
| ACCESSORS(JSDate, weekday, Object, kWeekdayOffset) |
| ACCESSORS(JSDate, hour, Object, kHourOffset) |
| ACCESSORS(JSDate, min, Object, kMinOffset) |
| ACCESSORS(JSDate, sec, Object, kSecOffset) |
| |
| |
| SMI_ACCESSORS(JSMessageObject, type, kTypeOffset) |
| ACCESSORS(JSMessageObject, argument, Object, kArgumentsOffset) |
| ACCESSORS(JSMessageObject, script, Script, kScriptOffset) |
| ACCESSORS(JSMessageObject, stack_frames, Object, kStackFramesOffset) |
| SMI_ACCESSORS(JSMessageObject, start_position, kStartPositionOffset) |
| SMI_ACCESSORS(JSMessageObject, end_position, kEndPositionOffset) |
| SMI_ACCESSORS(JSMessageObject, error_level, kErrorLevelOffset) |
| |
| ElementsKind JSObject::GetElementsKind() const { |
| ElementsKind kind = map()->elements_kind(); |
| #if VERIFY_HEAP && DEBUG |
| FixedArrayBase* fixed_array = |
| reinterpret_cast<FixedArrayBase*>(READ_FIELD(this, kElementsOffset)); |
| |
| // If a GC was caused while constructing this object, the elements |
| // pointer may point to a one pointer filler map. |
| if (ElementsAreSafeToExamine()) { |
| Map* map = fixed_array->map(); |
| if (IsSmiOrObjectElementsKind(kind)) { |
| DCHECK(map == GetReadOnlyRoots().fixed_array_map() || |
| map == GetReadOnlyRoots().fixed_cow_array_map()); |
| } else if (IsDoubleElementsKind(kind)) { |
| DCHECK(fixed_array->IsFixedDoubleArray() || |
| fixed_array == GetReadOnlyRoots().empty_fixed_array()); |
| } else if (kind == DICTIONARY_ELEMENTS) { |
| DCHECK(fixed_array->IsFixedArray()); |
| DCHECK(fixed_array->IsDictionary()); |
| } else { |
| DCHECK(kind > DICTIONARY_ELEMENTS); |
| } |
| DCHECK(!IsSloppyArgumentsElementsKind(kind) || |
| (elements()->IsFixedArray() && elements()->length() >= 2)); |
| } |
| #endif |
| return kind; |
| } |
| |
| bool JSObject::HasObjectElements() { |
| return IsObjectElementsKind(GetElementsKind()); |
| } |
| |
| bool JSObject::HasSmiElements() { return IsSmiElementsKind(GetElementsKind()); } |
| |
| bool JSObject::HasSmiOrObjectElements() { |
| return IsSmiOrObjectElementsKind(GetElementsKind()); |
| } |
| |
| bool JSObject::HasDoubleElements() { |
| return IsDoubleElementsKind(GetElementsKind()); |
| } |
| |
| bool JSObject::HasHoleyElements() { |
| return IsHoleyElementsKind(GetElementsKind()); |
| } |
| |
| |
| bool JSObject::HasFastElements() { |
| return IsFastElementsKind(GetElementsKind()); |
| } |
| |
| bool JSObject::HasFastPackedElements() { |
| return IsFastPackedElementsKind(GetElementsKind()); |
| } |
| |
| bool JSObject::HasDictionaryElements() { |
| return GetElementsKind() == DICTIONARY_ELEMENTS; |
| } |
| |
| |
| bool JSObject::HasFastArgumentsElements() { |
| return GetElementsKind() == FAST_SLOPPY_ARGUMENTS_ELEMENTS; |
| } |
| |
| |
| bool JSObject::HasSlowArgumentsElements() { |
| return GetElementsKind() == SLOW_SLOPPY_ARGUMENTS_ELEMENTS; |
| } |
| |
| |
| bool JSObject::HasSloppyArgumentsElements() { |
| return IsSloppyArgumentsElementsKind(GetElementsKind()); |
| } |
| |
| bool JSObject::HasStringWrapperElements() { |
| return IsStringWrapperElementsKind(GetElementsKind()); |
| } |
| |
| bool JSObject::HasFastStringWrapperElements() { |
| return GetElementsKind() == FAST_STRING_WRAPPER_ELEMENTS; |
| } |
| |
| bool JSObject::HasSlowStringWrapperElements() { |
| return GetElementsKind() == SLOW_STRING_WRAPPER_ELEMENTS; |
| } |
| |
| bool JSObject::HasFixedTypedArrayElements() { |
| DCHECK_NOT_NULL(elements()); |
| return map()->has_fixed_typed_array_elements(); |
| } |
| |
| #define FIXED_TYPED_ELEMENTS_CHECK(Type, type, TYPE, ctype) \ |
| bool JSObject::HasFixed##Type##Elements() { \ |
| HeapObject* array = elements(); \ |
| DCHECK_NOT_NULL(array); \ |
| if (!array->IsHeapObject()) return false; \ |
| return array->map()->instance_type() == FIXED_##TYPE##_ARRAY_TYPE; \ |
| } |
| |
| TYPED_ARRAYS(FIXED_TYPED_ELEMENTS_CHECK) |
| |
| #undef FIXED_TYPED_ELEMENTS_CHECK |
| |
| |
| bool JSObject::HasNamedInterceptor() { |
| return map()->has_named_interceptor(); |
| } |
| |
| |
| bool JSObject::HasIndexedInterceptor() { |
| return map()->has_indexed_interceptor(); |
| } |
| |
| void JSGlobalObject::set_global_dictionary(GlobalDictionary* dictionary) { |
| DCHECK(IsJSGlobalObject()); |
| set_raw_properties_or_hash(dictionary); |
| } |
| |
| GlobalDictionary* JSGlobalObject::global_dictionary() { |
| DCHECK(!HasFastProperties()); |
| DCHECK(IsJSGlobalObject()); |
| return GlobalDictionary::cast(raw_properties_or_hash()); |
| } |
| |
| NumberDictionary* JSObject::element_dictionary() { |
| DCHECK(HasDictionaryElements() || HasSlowStringWrapperElements()); |
| return NumberDictionary::cast(elements()); |
| } |
| |
| // 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, |
| LanguageMode language_mode, |
| StoreFromKeyed store_mode) { |
| LookupIterator it = LookupIterator::PropertyOrElement(isolate, object, name); |
| MAYBE_RETURN_NULL(SetProperty(&it, value, language_mode, store_mode)); |
| 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); |
| } |
| |
| |
| void JSReceiver::initialize_properties() { |
| Heap* heap = GetHeap(); |
| ReadOnlyRoots roots(heap); |
| DCHECK(!Heap::InNewSpace(roots.empty_fixed_array())); |
| DCHECK(!Heap::InNewSpace(heap->empty_property_dictionary())); |
| if (map()->is_dictionary_map()) { |
| WRITE_FIELD(this, kPropertiesOrHashOffset, |
| heap->empty_property_dictionary()); |
| } else { |
| WRITE_FIELD(this, kPropertiesOrHashOffset, roots.empty_fixed_array()); |
| } |
| } |
| |
| bool JSReceiver::HasFastProperties() const { |
| DCHECK( |
| raw_properties_or_hash()->IsSmi() || |
| (raw_properties_or_hash()->IsDictionary() == map()->is_dictionary_map())); |
| return !map()->is_dictionary_map(); |
| } |
| |
| NameDictionary* JSReceiver::property_dictionary() const { |
| DCHECK(!IsJSGlobalObject()); |
| DCHECK(!HasFastProperties()); |
| |
| Object* prop = raw_properties_or_hash(); |
| if (prop->IsSmi()) { |
| return GetHeap()->empty_property_dictionary(); |
| } |
| |
| return NameDictionary::cast(prop); |
| } |
| |
| // TODO(gsathya): Pass isolate directly to this function and access |
| // the heap from this. |
| PropertyArray* JSReceiver::property_array() const { |
| DCHECK(HasFastProperties()); |
| |
| Object* prop = raw_properties_or_hash(); |
| if (prop->IsSmi() || prop == GetReadOnlyRoots().empty_fixed_array()) { |
| return GetReadOnlyRoots().empty_property_array(); |
| } |
| |
| return PropertyArray::cast(prop); |
| } |
| |
| Maybe<bool> JSReceiver::HasProperty(Handle<JSReceiver> object, |
| Handle<Name> name) { |
| LookupIterator it = LookupIterator::PropertyOrElement(object->GetIsolate(), |
| object, name, object); |
| return HasProperty(&it); |
| } |
| |
| |
| Maybe<bool> JSReceiver::HasOwnProperty(Handle<JSReceiver> object, |
| uint32_t index) { |
| if (object->IsJSModuleNamespace()) return Just(false); |
| |
| if (object->IsJSObject()) { // Shortcut. |
| LookupIterator it(object->GetIsolate(), object, index, object, |
| LookupIterator::OWN); |
| return HasProperty(&it); |
| } |
| |
| Maybe<PropertyAttributes> attributes = |
| JSReceiver::GetOwnPropertyAttributes(object, index); |
| MAYBE_RETURN(attributes, Nothing<bool>()); |
| return Just(attributes.FromJust() != ABSENT); |
| } |
| |
| Maybe<PropertyAttributes> JSReceiver::GetPropertyAttributes( |
| Handle<JSReceiver> object, Handle<Name> name) { |
| LookupIterator it = LookupIterator::PropertyOrElement(object->GetIsolate(), |
| object, name, object); |
| return GetPropertyAttributes(&it); |
| } |
| |
| |
| Maybe<PropertyAttributes> JSReceiver::GetOwnPropertyAttributes( |
| Handle<JSReceiver> object, Handle<Name> name) { |
| LookupIterator it = LookupIterator::PropertyOrElement( |
| object->GetIsolate(), object, name, object, LookupIterator::OWN); |
| return GetPropertyAttributes(&it); |
| } |
| |
| Maybe<PropertyAttributes> JSReceiver::GetOwnPropertyAttributes( |
| Handle<JSReceiver> object, uint32_t index) { |
| LookupIterator it(object->GetIsolate(), object, index, object, |
| LookupIterator::OWN); |
| return GetPropertyAttributes(&it); |
| } |
| |
| Maybe<bool> JSReceiver::HasElement(Handle<JSReceiver> object, uint32_t index) { |
| LookupIterator it(object->GetIsolate(), object, index, object); |
| return HasProperty(&it); |
| } |
| |
| |
| Maybe<PropertyAttributes> JSReceiver::GetElementAttributes( |
| Handle<JSReceiver> object, uint32_t index) { |
| Isolate* isolate = object->GetIsolate(); |
| LookupIterator it(isolate, object, index, object); |
| return GetPropertyAttributes(&it); |
| } |
| |
| |
| Maybe<PropertyAttributes> JSReceiver::GetOwnElementAttributes( |
| Handle<JSReceiver> object, uint32_t index) { |
| Isolate* isolate = object->GetIsolate(); |
| LookupIterator it(isolate, object, index, object, LookupIterator::OWN); |
| return GetPropertyAttributes(&it); |
| } |
| |
| |
| bool JSGlobalObject::IsDetached() { |
| return JSGlobalProxy::cast(global_proxy())->IsDetachedFrom(this); |
| } |
| |
| |
| bool JSGlobalProxy::IsDetachedFrom(JSGlobalObject* global) const { |
| const PrototypeIterator iter(this->GetIsolate(), |
| const_cast<JSGlobalProxy*>(this)); |
| return iter.GetCurrent() != global; |
| } |
| |
| inline int JSGlobalProxy::SizeWithEmbedderFields(int embedder_field_count) { |
| DCHECK_GE(embedder_field_count, 0); |
| return kSize + embedder_field_count * kPointerSize; |
| } |
| |
| Object* AccessorPair::get(AccessorComponent component) { |
| return component == ACCESSOR_GETTER ? getter() : setter(); |
| } |
| |
| |
| void AccessorPair::set(AccessorComponent component, Object* value) { |
| if (component == ACCESSOR_GETTER) { |
| set_getter(value); |
| } else { |
| set_setter(value); |
| } |
| } |
| |
| |
| void AccessorPair::SetComponents(Object* getter, Object* setter) { |
| if (!getter->IsNull()) set_getter(getter); |
| if (!setter->IsNull()) set_setter(setter); |
| } |
| |
| bool AccessorPair::Equals(AccessorPair* pair) { |
| return (this == pair) || pair->Equals(getter(), setter()); |
| } |
| |
| |
| bool AccessorPair::Equals(Object* getter_value, Object* setter_value) { |
| return (getter() == getter_value) && (setter() == setter_value); |
| } |
| |
| |
| bool AccessorPair::ContainsAccessor() { |
| return IsJSAccessor(getter()) || IsJSAccessor(setter()); |
| } |
| |
| |
| bool AccessorPair::IsJSAccessor(Object* obj) { |
| return obj->IsCallable() || obj->IsUndefined(); |
| } |
| |
| template <typename Derived, typename Shape> |
| void Dictionary<Derived, Shape>::ClearEntry(Isolate* isolate, int entry) { |
| Object* the_hole = this->GetReadOnlyRoots().the_hole_value(); |
| PropertyDetails details = PropertyDetails::Empty(); |
| Derived::cast(this)->SetEntry(isolate, entry, the_hole, the_hole, details); |
| } |
| |
| template <typename Derived, typename Shape> |
| void Dictionary<Derived, Shape>::SetEntry(Isolate* isolate, int entry, |
| Object* key, Object* value, |
| PropertyDetails details) { |
| DCHECK(Dictionary::kEntrySize == 2 || Dictionary::kEntrySize == 3); |
| DCHECK(!key->IsName() || details.dictionary_index() > 0); |
| int index = DerivedHashTable::EntryToIndex(entry); |
| DisallowHeapAllocation no_gc; |
| WriteBarrierMode mode = this->GetWriteBarrierMode(no_gc); |
| this->set(index + Derived::kEntryKeyIndex, key, mode); |
| this->set(index + Derived::kEntryValueIndex, value, mode); |
| if (Shape::kHasDetails) DetailsAtPut(isolate, entry, details); |
| } |
| |
| Object* GlobalDictionaryShape::Unwrap(Object* object) { |
| return PropertyCell::cast(object)->name(); |
| } |
| |
| int GlobalDictionaryShape::GetMapRootIndex() { |
| return Heap::kGlobalDictionaryMapRootIndex; |
| } |
| |
| Name* NameDictionary::NameAt(int entry) { return Name::cast(KeyAt(entry)); } |
| |
| int NameDictionaryShape::GetMapRootIndex() { |
| return Heap::kNameDictionaryMapRootIndex; |
| } |
| |
| PropertyCell* GlobalDictionary::CellAt(int entry) { |
| DCHECK(KeyAt(entry)->IsPropertyCell()); |
| return PropertyCell::cast(KeyAt(entry)); |
| } |
| |
| bool GlobalDictionaryShape::IsLive(ReadOnlyRoots roots, Object* k) { |
| DCHECK_NE(roots.the_hole_value(), k); |
| return k != roots.undefined_value(); |
| } |
| |
| bool GlobalDictionaryShape::IsKey(ReadOnlyRoots roots, Object* k) { |
| return IsLive(roots, k) && !PropertyCell::cast(k)->value()->IsTheHole(roots); |
| } |
| |
| Name* GlobalDictionary::NameAt(int entry) { return CellAt(entry)->name(); } |
| Object* GlobalDictionary::ValueAt(int entry) { return CellAt(entry)->value(); } |
| |
| void GlobalDictionary::SetEntry(Isolate* isolate, int entry, Object* key, |
| Object* value, PropertyDetails details) { |
| DCHECK_EQ(key, PropertyCell::cast(value)->name()); |
| set(EntryToIndex(entry) + kEntryKeyIndex, value); |
| DetailsAtPut(isolate, entry, details); |
| } |
| |
| void GlobalDictionary::ValueAtPut(int entry, Object* value) { |
| set(EntryToIndex(entry), value); |
| } |
| |
| bool NumberDictionaryBaseShape::IsMatch(uint32_t key, Object* other) { |
| DCHECK(other->IsNumber()); |
| return key == static_cast<uint32_t>(other->Number()); |
| } |
| |
| uint32_t NumberDictionaryBaseShape::Hash(Isolate* isolate, uint32_t key) { |
| return ComputeIntegerHash(key, isolate->heap()->HashSeed()); |
| } |
| |
| uint32_t NumberDictionaryBaseShape::HashForObject(Isolate* isolate, |
| Object* other) { |
| DCHECK(other->IsNumber()); |
| return ComputeIntegerHash(static_cast<uint32_t>(other->Number()), |
| isolate->heap()->HashSeed()); |
| } |
| |
| Handle<Object> NumberDictionaryBaseShape::AsHandle(Isolate* isolate, |
| uint32_t key) { |
| return isolate->factory()->NewNumberFromUint(key); |
| } |
| |
| int NumberDictionaryShape::GetMapRootIndex() { |
| return Heap::kNumberDictionaryMapRootIndex; |
| } |
| |
| int SimpleNumberDictionaryShape::GetMapRootIndex() { |
| return Heap::kSimpleNumberDictionaryMapRootIndex; |
| } |
| |
| bool NameDictionaryShape::IsMatch(Handle<Name> key, Object* other) { |
| DCHECK(other->IsTheHole() || Name::cast(other)->IsUniqueName()); |
| DCHECK(key->IsUniqueName()); |
| return *key == other; |
| } |
| |
| uint32_t NameDictionaryShape::Hash(Isolate* isolate, Handle<Name> key) { |
| return key->Hash(); |
| } |
| |
| uint32_t NameDictionaryShape::HashForObject(Isolate* isolate, Object* other) { |
| return Name::cast(other)->Hash(); |
| } |
| |
| bool GlobalDictionaryShape::IsMatch(Handle<Name> key, Object* other) { |
| DCHECK(PropertyCell::cast(other)->name()->IsUniqueName()); |
| return *key == PropertyCell::cast(other)->name(); |
| } |
| |
| uint32_t GlobalDictionaryShape::HashForObject(Isolate* isolate, Object* other) { |
| return PropertyCell::cast(other)->name()->Hash(); |
| } |
| |
| Handle<Object> NameDictionaryShape::AsHandle(Isolate* isolate, |
| Handle<Name> key) { |
| DCHECK(key->IsUniqueName()); |
| return key; |
| } |
| |
| |
| template <typename Dictionary> |
| PropertyDetails GlobalDictionaryShape::DetailsAt(Dictionary* dict, int entry) { |
| DCHECK_LE(0, entry); // Not found is -1, which is not caught by get(). |
| return dict->CellAt(entry)->property_details(); |
| } |
| |
| template <typename Dictionary> |
| void GlobalDictionaryShape::DetailsAtPut(Isolate* isolate, Dictionary* dict, |
| int entry, PropertyDetails value) { |
| DCHECK_LE(0, entry); // Not found is -1, which is not caught by get(). |
| PropertyCell* cell = dict->CellAt(entry); |
| if (cell->property_details().IsReadOnly() != value.IsReadOnly()) { |
| cell->dependent_code()->DeoptimizeDependentCodeGroup( |
| isolate, DependentCode::kPropertyCellChangedGroup); |
| } |
| cell->set_property_details(value); |
| } |
| |
| bool ObjectHashTableShape::IsMatch(Handle<Object> key, Object* other) { |
| return key->SameValue(other); |
| } |
| |
| uint32_t ObjectHashTableShape::Hash(Isolate* isolate, Handle<Object> key) { |
| return Smi::ToInt(key->GetHash()); |
| } |
| |
| uint32_t ObjectHashTableShape::HashForObject(Isolate* isolate, Object* other) { |
| return Smi::ToInt(other->GetHash()); |
| } |
| |
| // static |
| Object* Object::GetSimpleHash(Object* object) { |
| DisallowHeapAllocation no_gc; |
| if (object->IsSmi()) { |
| uint32_t hash = ComputeIntegerHash(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 ComputeIntegerHash 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 = ComputeIntegerHash(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); |
| } |
| 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); |
| Isolate* isolate = receiver->GetIsolate(); |
| return receiver->GetIdentityHash(isolate); |
| } |
| |
| 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_); |
| } |
| |
| |
| template<class Derived, class TableType> |
| Object* OrderedHashTableIterator<Derived, TableType>::CurrentKey() { |
| TableType* table(TableType::cast(this->table())); |
| int index = Smi::ToInt(this->index()); |
| Object* key = table->KeyAt(index); |
| DCHECK(!key->IsTheHole()); |
| return key; |
| } |
| |
| // Predictably converts HeapObject* or Address to uint32 by calculating |
| // offset of the address in respective MemoryChunk. |
| static inline uint32_t ObjectAddressForHashing(void* object) { |
| uint32_t value = static_cast<uint32_t>(reinterpret_cast<uintptr_t>(object)); |
| return value & MemoryChunk::kAlignmentMask; |
| } |
| |
| 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); |
| } |
| |
| ACCESSORS(JSIteratorResult, value, Object, kValueOffset) |
| ACCESSORS(JSIteratorResult, done, Object, kDoneOffset) |
| |
| ACCESSORS(JSAsyncFromSyncIterator, sync_iterator, JSReceiver, |
| kSyncIteratorOffset) |
| ACCESSORS(JSAsyncFromSyncIterator, next, Object, kNextOffset) |
| |
| ACCESSORS(JSStringIterator, string, String, kStringOffset) |
| SMI_ACCESSORS(JSStringIterator, index, kNextIndexOffset) |
| |
| bool ScopeInfo::IsAsmModule() const { return AsmModuleField::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 reinterpret_cast<FreshlyAllocatedBigInt*>(object); |
| } |
| |
| } // namespace internal |
| } // namespace v8 |
| |
| #include "src/objects/object-macros-undef.h" |
| |
| #endif // V8_OBJECTS_INL_H_ |