#include <objects.h>

Inheritance diagram for v8::internal::Map:

Collaboration diagram for v8::internal::Map:

Classes
class	ConstructionCount

class	Deprecated

class	DictionaryMap

class	DoneInobjectSlackTracking

class	ElementsKindBits

class	EnumLengthBits

class	FunctionWithPrototype

class	HasInstanceCallHandler

class	IsFrozen

class	IsMigrationTarget

class	IsPrototypeMapBits

class	IsUnstable

class	NumberOfOwnDescriptorsBits

class	OwnsDescriptors

Public Types
typedef void(*	TraverseCallback) (Map map, void data)

typedef FixedBodyDescriptor< kPointerFieldsBeginOffset, kPointerFieldsEndOffset, kSize >	BodyDescriptor

Public Types inherited from v8::internal::Object
enum	StoreFromKeyed { MAY_BE_STORE_FROM_KEYED , CERTAINLY_NOT_STORE_FROM_KEYED }

enum	StorePropertyMode { NORMAL_PROPERTY , SUPER_PROPERTY }

Public Member Functions
int	instance_size ()

void	set_instance_size (int value)

int	inobject_properties ()

void	set_inobject_properties (int value)

int	pre_allocated_property_fields ()

void	set_pre_allocated_property_fields (int value)

InstanceType	instance_type ()

void	set_instance_type (InstanceType value)

int	unused_property_fields ()

void	set_unused_property_fields (int value)

byte	bit_field ()

void	set_bit_field (byte value)

byte	bit_field2 ()

void	set_bit_field2 (byte value)

uint32_t	bit_field3 ()

void	set_bit_field3 (uint32_t bits)

	STATIC_ASSERT (kDescriptorIndexBitCount+kDescriptorIndexBitCount==20)

void	set_non_instance_prototype (bool value)

bool	has_non_instance_prototype ()

void	set_function_with_prototype (bool value)

bool	function_with_prototype ()

void	set_is_hidden_prototype ()

bool	is_hidden_prototype ()

void	set_has_named_interceptor ()

bool	has_named_interceptor ()

void	set_has_indexed_interceptor ()

bool	has_indexed_interceptor ()

void	set_is_undetectable ()

bool	is_undetectable ()

void	set_is_observed ()

bool	is_observed ()

void	set_is_extensible (bool value)

bool	is_extensible ()

void	set_is_prototype_map (bool value)

bool	is_prototype_map ()

void	set_elements_kind (ElementsKind elements_kind)

ElementsKind	elements_kind ()

bool	has_fast_smi_elements ()

bool	has_fast_object_elements ()

bool	has_fast_smi_or_object_elements ()

bool	has_fast_double_elements ()

bool	has_fast_elements ()

bool	has_sloppy_arguments_elements ()

bool	has_external_array_elements ()

bool	has_fixed_typed_array_elements ()

bool	has_dictionary_elements ()

bool	has_slow_elements_kind ()

bool	DictionaryElementsInPrototypeChainOnly ()

bool	HasTransitionArray () const

bool	HasElementsTransition ()

Map *	elements_transition_map ()

Map *	GetTransition (int transition_index)

int	SearchTransition (Name *name)

FixedArrayBase *	GetInitialElements ()

Map *	FindRootMap ()

Map *	FindFieldOwner (int descriptor)

int	GetInObjectPropertyOffset (int index)

int	NumberOfFields ()

bool	InstancesNeedRewriting (Map target, int target_number_of_fields, int target_inobject, int target_unused, int old_number_of_fields)

String *	constructor_name ()

void	set_dictionary_map (bool value)

bool	is_dictionary_map ()

void	set_is_access_check_needed (bool access_check_needed)

bool	is_access_check_needed ()

bool	has_code_cache ()

void	InitializeDescriptors (DescriptorArray *descriptors)

Object *	GetBackPointer ()

void	SetBackPointer (Object *value, WriteBarrierMode mode=UPDATE_WRITE_BARRIER)

void	init_back_pointer (Object *undefined)

FixedArray *	GetPrototypeTransitions ()

bool	HasPrototypeTransitions ()

int	NumberOfProtoTransitions ()

void	SetNumberOfProtoTransitions (int value)

void	LookupDescriptor (JSObject holder, Name name, LookupResult *result)

void	LookupTransition (JSObject holder, Name name, LookupResult *result)

PropertyDetails	GetLastDescriptorDetails ()

bool	CanHaveMoreTransitions ()

int	LastAdded ()

int	NumberOfOwnDescriptors ()

void	SetNumberOfOwnDescriptors (int number)

Cell *	RetrieveDescriptorsPointer ()

int	EnumLength ()

void	SetEnumLength (int length)

bool	owns_descriptors ()

void	set_owns_descriptors (bool owns_descriptors)

bool	has_instance_call_handler ()

void	set_has_instance_call_handler ()

void	freeze ()

bool	is_frozen ()

void	mark_unstable ()

bool	is_stable ()

void	set_migration_target (bool value)

bool	is_migration_target ()

void	set_done_inobject_slack_tracking (bool value)

bool	done_inobject_slack_tracking ()

void	set_construction_count (int value)

int	construction_count ()

void	deprecate ()

bool	is_deprecated ()

bool	CanBeDeprecated ()

bool	TooManyFastProperties (StoreFromKeyed store_mode)

void	AppendDescriptor (Descriptor *desc)

int	NextFreePropertyIndex ()

int	NumberOfDescribedProperties (DescriptorFlag which=OWN_DESCRIPTORS, PropertyAttributes filter=NONE)

int	InitialPropertiesLength ()

void	ClearCodeCache (Heap *heap)

Object *	FindInCodeCache (Name *name, Code::Flags flags)

int	IndexInCodeCache (Object name, Code code)

void	RemoveFromCodeCache (Name name, Code code, int index)

void	ClearNonLiveTransitions (Heap *heap)

int	Hash ()

Map *	LookupElementsTransitionMap (ElementsKind elements_kind)

Handle< Map >	FindTransitionedMap (MapHandleList *candidates)

bool	CanTransition ()

bool	IsJSObjectMap ()

bool	IsJSProxyMap ()

bool	IsJSGlobalProxyMap ()

bool	IsJSGlobalObjectMap ()

bool	IsGlobalObjectMap ()

bool	CanOmitMapChecks ()

bool	IsMapInArrayPrototypeChain ()

int	visitor_id ()

void	set_visitor_id (int visitor_id)

void	TraverseTransitionTree (TraverseCallback callback, void *data)

	STATIC_ASSERT (kInstanceTypeAndBitFieldOffset==Internals::kMapInstanceTypeAndBitFieldOffset)

bool	EquivalentToForNormalization (Map *other, PropertyNormalizationMode mode)

Public Member Functions inherited from v8::internal::HeapObject
Map *	map () const

void	set_map (Map *value)

void	set_map_no_write_barrier (Map *value)

Map *	synchronized_map ()

MapWord	synchronized_map_word () const

void	synchronized_set_map (Map *value)

void	synchronized_set_map_no_write_barrier (Map *value)

void	synchronized_set_map_word (MapWord map_word)

MapWord	map_word () const

void	set_map_word (MapWord map_word)

Heap *	GetHeap () const

Isolate *	GetIsolate () const

Address	address ()

void	Iterate (ObjectVisitor *v)

void	IterateBody (InstanceType type, int object_size, ObjectVisitor *v)

int	Size ()

bool	MayContainRawValues ()

int	SizeFromMap (Map *map)

WriteBarrierMode	GetWriteBarrierMode (const DisallowHeapAllocation &promise)

void	HeapObjectShortPrint (OStream &os)

	STATIC_ASSERT (kMapOffset==Internals::kHeapObjectMapOffset)

Public Member Functions inherited from v8::internal::Object
bool	IsObject () const

	INLINE (bool IsFixedArrayBase() const)

	INLINE (bool IsExternal() const)

	INLINE (bool IsAccessorInfo() const)

	INLINE (bool IsStruct() const)

	INLINE (bool IsSpecObject()) const

	INLINE (bool IsSpecFunction()) const

	INLINE (bool IsTemplateInfo()) const

	INLINE (bool IsNameDictionary() const)

	INLINE (bool IsSeededNumberDictionary() const)

	INLINE (bool IsUnseededNumberDictionary() const)

	INLINE (bool IsOrderedHashSet() const)

	INLINE (bool IsOrderedHashMap() const)

bool	IsCallable () const

	INLINE (bool IsUndefined() const)

	INLINE (bool IsNull() const)

	INLINE (bool IsTheHole() const)

	INLINE (bool IsException() const)

	INLINE (bool IsUninitialized() const)

	INLINE (bool IsTrue() const)

	INLINE (bool IsFalse() const)

	INLINE (bool IsArgumentsMarker() const)

	INLINE (bool IsFiller() const)

double	Number ()

	INLINE (bool IsNaN() const)

	INLINE (bool IsMinusZero() const)

bool	ToInt32 (int32_t *value)

bool	ToUint32 (uint32_t *value)

Representation	OptimalRepresentation ()

bool	FitsRepresentation (Representation representation)

Handle< HeapType >	OptimalType (Isolate *isolate, Representation representation)

bool	HasValidElements ()

bool	HasSpecificClassOf (String *name)

bool	BooleanValue ()

Object *	GetHash ()

bool	SameValue (Object *other)

bool	SameValueZero (Object *other)

bool	ToArrayIndex (uint32_t *index)

bool	IsStringObjectWithCharacterAt (uint32_t index)

void	VerifyApiCallResultType ()

void	ShortPrint (FILE *out=stdout)

void	ShortPrint (StringStream *accumulator)

Static Public Member Functions
static bool	IsValidElementsTransition (ElementsKind from_kind, ElementsKind to_kind)

static Handle< String >	ExpectedTransitionKey (Handle< Map > map)

static Handle< Map >	ExpectedTransitionTarget (Handle< Map > map)

static Handle< Map >	FindTransitionToField (Handle< Map > map, Handle< Name > key)

static Handle< Map >	GeneralizeAllFieldRepresentations (Handle< Map > map)

static MUST_USE_RESULT Handle< HeapType >	GeneralizeFieldType (Handle< HeapType > type1, Handle< HeapType > type2, Isolate *isolate)

static void	GeneralizeFieldType (Handle< Map > map, int modify_index, Handle< HeapType > new_field_type)

static Handle< Map >	GeneralizeRepresentation (Handle< Map > map, int modify_index, Representation new_representation, Handle< HeapType > new_field_type, StoreMode store_mode)

static Handle< Map >	CopyGeneralizeAllRepresentations (Handle< Map > map, int modify_index, StoreMode store_mode, PropertyAttributes attributes, const char *reason)

static Handle< Map >	CopyGeneralizeAllRepresentations (Handle< Map > map, int modify_index, StoreMode store_mode, const char *reason)

static Handle< Map >	PrepareForDataProperty (Handle< Map > old_map, int descriptor_number, Handle< Object > value)

static Handle< Map >	Normalize (Handle< Map > map, PropertyNormalizationMode mode)

static MaybeHandle< Map >	TryUpdate (Handle< Map > map) WARN_UNUSED_RESULT

static MaybeHandle< Map >	TryUpdateInternal (Handle< Map > map) WARN_UNUSED_RESULT

static Handle< Map >	Update (Handle< Map > map)

static Handle< Map >	CopyDropDescriptors (Handle< Map > map)

static Handle< Map >	CopyInsertDescriptor (Handle< Map > map, Descriptor *descriptor, TransitionFlag flag)

static MUST_USE_RESULT MaybeHandle< Map >	CopyWithField (Handle< Map > map, Handle< Name > name, Handle< HeapType > type, PropertyAttributes attributes, Representation representation, TransitionFlag flag)

static MUST_USE_RESULT MaybeHandle< Map >	CopyWithConstant (Handle< Map > map, Handle< Name > name, Handle< Object > constant, PropertyAttributes attributes, TransitionFlag flag)

static Handle< Map >	TransitionElementsTo (Handle< Map > map, ElementsKind to_kind)

static Handle< Map >	AsElementsKind (Handle< Map > map, ElementsKind kind)

static Handle< Map >	CopyAsElementsKind (Handle< Map > map, ElementsKind kind, TransitionFlag flag)

static Handle< Map >	CopyForObserved (Handle< Map > map)

static Handle< Map >	CopyForFreeze (Handle< Map > map)

static Handle< Map >	TransitionToDataProperty (Handle< Map > map, Handle< Name > name, Handle< Object > value, PropertyAttributes attributes, StoreFromKeyed store_mode)

static Handle< Map >	TransitionToAccessorProperty (Handle< Map > map, Handle< Name > name, AccessorComponent component, Handle< Object > accessor, PropertyAttributes attributes)

static Handle< Map >	ReconfigureDataProperty (Handle< Map > map, int descriptor, PropertyAttributes attributes)

static Handle< Map >	Copy (Handle< Map > map)

static Handle< Map >	Create (Isolate *isolate, int inobject_properties)

static void	UpdateCodeCache (Handle< Map > map, Handle< Name > name, Handle< Code > code)

static void	AppendCallbackDescriptors (Handle< Map > map, Handle< Object > descriptors)

static void	EnsureDescriptorSlack (Handle< Map > map, int slack)

static void	AddDependentCompilationInfo (Handle< Map > map, DependentCode::DependencyGroup group, CompilationInfo *info)

static void	AddDependentCode (Handle< Map > map, DependentCode::DependencyGroup group, Handle< Code > code)

static void	AddDependentIC (Handle< Map > map, Handle< Code > stub)

static Handle< Map >	TransitionToPrototype (Handle< Map > map, Handle< Object > prototype)

Static Public Member Functions inherited from v8::internal::HeapObject
static HeapObject *	FromAddress (Address address)

static Object **	RawField (HeapObject *obj, int offset)

static void	UpdateMapCodeCache (Handle< HeapObject > object, Handle< Name > name, Handle< Code > code)

Static Public Member Functions inherited from v8::internal::Object
static Handle< Object >	NewStorageFor (Isolate *isolate, Handle< Object > object, Representation representation)

static Handle< Object >	WrapForRead (Isolate *isolate, Handle< Object > object, Representation representation)

static MaybeHandle< JSReceiver >	ToObject (Isolate *isolate, Handle< Object > object)

static MaybeHandle< JSReceiver >	ToObject (Isolate *isolate, Handle< Object > object, Handle< Context > context)

static MUST_USE_RESULT MaybeHandle< Smi >	ToSmi (Isolate *isolate, Handle< Object > object)

static MUST_USE_RESULT MaybeHandle< Object >	GetProperty (LookupIterator *it)

static MUST_USE_RESULT MaybeHandle< Object >	SetProperty (Handle< Object > object, Handle< Name > key, Handle< Object > value, StrictMode strict_mode, StoreFromKeyed store_mode=MAY_BE_STORE_FROM_KEYED)

static MUST_USE_RESULT MaybeHandle< Object >	SetProperty (LookupIterator *it, Handle< Object > value, StrictMode strict_mode, StoreFromKeyed store_mode, StorePropertyMode data_store_mode=NORMAL_PROPERTY)

static MUST_USE_RESULT MaybeHandle< Object >	WriteToReadOnlyProperty (LookupIterator *it, Handle< Object > value, StrictMode strict_mode)

static Handle< Object >	SetDataProperty (LookupIterator *it, Handle< Object > value)

static MUST_USE_RESULT MaybeHandle< Object >	AddDataProperty (LookupIterator *it, Handle< Object > value, PropertyAttributes attributes, StrictMode strict_mode, StoreFromKeyed store_mode)

static MUST_USE_RESULT MaybeHandle< Object >	GetPropertyOrElement (Handle< Object > object, Handle< Name > key)

static MUST_USE_RESULT MaybeHandle< Object >	GetProperty (Isolate isolate, Handle< Object > object, const char key)

static MUST_USE_RESULT MaybeHandle< Object >	GetProperty (Handle< Object > object, Handle< Name > key)

static MUST_USE_RESULT MaybeHandle< Object >	GetPropertyWithAccessor (Handle< Object > receiver, Handle< Name > name, Handle< JSObject > holder, Handle< Object > structure)

static MUST_USE_RESULT MaybeHandle< Object >	SetPropertyWithAccessor (Handle< Object > receiver, Handle< Name > name, Handle< Object > value, Handle< JSObject > holder, Handle< Object > structure, StrictMode strict_mode)

static MUST_USE_RESULT MaybeHandle< Object >	GetPropertyWithDefinedGetter (Handle< Object > receiver, Handle< JSReceiver > getter)

static MUST_USE_RESULT MaybeHandle< Object >	SetPropertyWithDefinedSetter (Handle< Object > receiver, Handle< JSReceiver > setter, Handle< Object > value)

static MUST_USE_RESULT MaybeHandle< Object >	GetElement (Isolate *isolate, Handle< Object > object, uint32_t index)

static MUST_USE_RESULT MaybeHandle< Object >	GetElementWithReceiver (Isolate *isolate, Handle< Object > object, Handle< Object > receiver, uint32_t index)

static Handle< Smi >	GetOrCreateHash (Isolate *isolate, Handle< Object > object)

Static Public Attributes
static const int	kProtoTransitionHeaderSize = 1

static const int	kProtoTransitionNumberOfEntriesOffset = 0

static const int	kProtoTransitionElementsPerEntry = 2

static const int	kProtoTransitionPrototypeOffset = 0

static const int	kProtoTransitionMapOffset = 1

static const int	kMaxCachedPrototypeTransitions = 256

static const int	kMaxPreAllocatedPropertyFields = 255

static const int	kInstanceSizesOffset = HeapObject::kHeaderSize

static const int	kInstanceAttributesOffset = kInstanceSizesOffset + kIntSize

static const int	kBitField3Offset = kInstanceAttributesOffset + kIntSize

static const int	kPrototypeOffset = kBitField3Offset + kPointerSize

static const int	kConstructorOffset = kPrototypeOffset + kPointerSize

static const int	kTransitionsOrBackPointerOffset

static const int	kDescriptorsOffset

static const int	kCodeCacheOffset = kDescriptorsOffset + kPointerSize

static const int	kDependentCodeOffset = kCodeCacheOffset + kPointerSize

static const int	kSize = kDependentCodeOffset + kPointerSize

static const int	kPointerFieldsBeginOffset = Map::kPrototypeOffset

static const int	kPointerFieldsEndOffset = kSize

static const int	kInstanceSizeOffset = kInstanceSizesOffset + 0

static const int	kInObjectPropertiesByte = 1

static const int	kInObjectPropertiesOffset

static const int	kPreAllocatedPropertyFieldsByte = 2

static const int	kPreAllocatedPropertyFieldsOffset

static const int	kVisitorIdByte = 3

static const int	kVisitorIdOffset = kInstanceSizesOffset + kVisitorIdByte

static const int	kBitFieldOffset = kInstanceAttributesOffset + 0

static const int	kInstanceTypeOffset = kInstanceAttributesOffset + 1

static const int	kInstanceTypeAndBitFieldOffset

static const int	kBitField2Offset = kInstanceAttributesOffset + 2

static const int	kUnusedPropertyFieldsOffset = kInstanceAttributesOffset + 3

static const int	kHasNonInstancePrototype = 0

static const int	kIsHiddenPrototype = 1

static const int	kHasNamedInterceptor = 2

static const int	kHasIndexedInterceptor = 3

static const int	kIsUndetectable = 4

static const int	kIsObserved = 5

static const int	kIsAccessCheckNeeded = 6

static const int	kIsExtensible = 0

static const int	kStringWrapperSafeForDefaultValueOf = 1

static const int8_t	kMaximumBitField2FastElementValue

static const int8_t	kMaximumBitField2FastSmiElementValue

static const int8_t	kMaximumBitField2FastHoleyElementValue

static const int8_t	kMaximumBitField2FastHoleySmiElementValue

Static Public Attributes inherited from v8::internal::HeapObject
static const int	kMapOffset = Object::kHeaderSize

static const int	kHeaderSize = kMapOffset + kPointerSize

Static Public Attributes inherited from v8::internal::Object
static const int	kHeaderSize = 0

Private Member Functions
bool	EquivalentToForTransition (Map *other)

void	NotifyLeafMapLayoutChange ()

void	ZapPrototypeTransitions ()

void	ZapTransitions ()

void	DeprecateTransitionTree ()

void	DeprecateTarget (Name key, DescriptorArray new_descriptors)

Map *	FindLastMatchMap (int verbatim, int length, DescriptorArray *descriptors)

void	UpdateFieldType (int descriptor_number, Handle< Name > name, Handle< HeapType > new_type)

void	PrintGeneralization (FILE file, const char reason, int modify_index, int split, int descriptors, bool constant_to_field, Representation old_representation, Representation new_representation, HeapType old_field_type, HeapType new_field_type)

	DISALLOW_IMPLICIT_CONSTRUCTORS (Map)

Static Private Member Functions
static void	ConnectElementsTransition (Handle< Map > parent, Handle< Map > child)

static void	ConnectTransition (Handle< Map > parent, Handle< Map > child, Handle< Name > name, SimpleTransitionFlag flag)

static Handle< Map >	RawCopy (Handle< Map > map, int instance_size)

static Handle< Map >	ShareDescriptor (Handle< Map > map, Handle< DescriptorArray > descriptors, Descriptor *descriptor)

static Handle< Map >	CopyInstallDescriptors (Handle< Map > map, int new_descriptor, Handle< DescriptorArray > descriptors)

static Handle< Map >	CopyAddDescriptor (Handle< Map > map, Descriptor *descriptor, TransitionFlag flag)

static Handle< Map >	CopyReplaceDescriptors (Handle< Map > map, Handle< DescriptorArray > descriptors, TransitionFlag flag, MaybeHandle< Name > maybe_name, SimpleTransitionFlag simple_flag=FULL_TRANSITION)

static Handle< Map >	CopyReplaceDescriptor (Handle< Map > map, Handle< DescriptorArray > descriptors, Descriptor *descriptor, int index, TransitionFlag flag)

static Handle< Map >	CopyNormalized (Handle< Map > map, PropertyNormalizationMode mode)

static Handle< Map >	TransitionElementsToSlow (Handle< Map > object, ElementsKind to_kind)

static void	SetPrototypeTransitions (Handle< Map > map, Handle< FixedArray > prototype_transitions)

static Handle< Map >	GetPrototypeTransition (Handle< Map > map, Handle< Object > prototype)

static Handle< Map >	PutPrototypeTransition (Handle< Map > map, Handle< Object > prototype, Handle< Map > target_map)

Static Private Attributes
static const int	kFastPropertiesSoftLimit = 12

static const int	kMaxFastProperties = 128

Additional Inherited Members
Protected Member Functions inherited from v8::internal::HeapObject
void	IteratePointers (ObjectVisitor *v, int start, int end)

void	IteratePointer (ObjectVisitor *v, int offset)

void	IterateNextCodeLink (ObjectVisitor *v, int offset)

Detailed Description

Definition at line 5597 of file objects.h.

Member Typedef Documentation

◆ BodyDescriptor

typedef FixedBodyDescriptor<kPointerFieldsBeginOffset, kPointerFieldsEndOffset, kSize> v8::internal::Map::BodyDescriptor

Definition at line 6270 of file objects.h.

◆ TraverseCallback

typedef void(* v8::internal::Map::TraverseCallback) (Map *map, void *data)

Definition at line 6169 of file objects.h.

Member Function Documentation

◆ AddDependentCode()

void v8::internal::Map::AddDependentCode	(	Handle< Map >	map,
		DependentCode::DependencyGroup	group,
		Handle< Code >	code
	)

static

Definition at line 11357 of file objects.cc.

                                               {
   Handle<DependentCode> codes = DependentCode::Insert(
       Handle<DependentCode>(map->dependent_code()), group, code);
   if (*codes != map->dependent_code()) map->set_dependent_code(*codes);
 }

References v8::internal::DependentCode::Insert(), and v8::internal::HeapObject::map().

Referenced by AddDependentIC(), and v8::internal::LChunk::CommitDependencies().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddDependentCompilationInfo()

void v8::internal::Map::AddDependentCompilationInfo	(	Handle< Map >	map,
		DependentCode::DependencyGroup	group,
		CompilationInfo *	info
	)

static

Definition at line 11345 of file objects.cc.

                                                              {
   Handle<DependentCode> codes =
       DependentCode::Insert(handle(map->dependent_code(), info->isolate()),
                             group, info->object_wrapper());
   if (*codes != map->dependent_code()) map->set_dependent_code(*codes);
   info->dependencies(group)->Add(map, info->zone());
 }

References v8::internal::CompilationInfo::dependencies(), v8::internal::handle(), v8::internal::DependentCode::Insert(), v8::internal::CompilationInfo::isolate(), v8::internal::HeapObject::map(), v8::internal::CompilationInfo::object_wrapper(), and v8::internal::CompilationInfo::zone().

Referenced by v8::internal::HOptimizedGraphBuilder::PropertyAccessInfo::LoadFieldMaps(), and v8::internal::FINAL< kOperandKind, kNumCachedOperands >::MarkDependsOnEmptyArrayProtoElements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddDependentIC()

void v8::internal::Map::AddDependentIC	(	Handle< Map >	map,
		Handle< Code >	stub
	)

static

Definition at line 11367 of file objects.cc.

                                             {
   DCHECK(stub->next_code_link()->IsUndefined());
   int n = map->dependent_code()->number_of_entries(DependentCode::kWeakICGroup);
   if (n == 0) {
     // Slow path: insert the head of the list with possible heap allocation.
     Map::AddDependentCode(map, DependentCode::kWeakICGroup, stub);
   } else {
     // Fast path: link the stub to the existing head of the list without any
     // heap allocation.
     DCHECK(n == 1);
     map->dependent_code()->AddToDependentICList(stub);
   }
 }

References AddDependentCode(), DCHECK, v8::internal::DependentCode::kWeakICGroup, and v8::internal::HeapObject::map().

Referenced by v8::internal::IC::RegisterWeakMapDependency().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AppendCallbackDescriptors()

void v8::internal::Map::AppendCallbackDescriptors	(	Handle< Map >	map,
		Handle< Object >	descriptors
	)

static

Definition at line 3174 of file objects.cc.

                                                                 {
   int nof = map->NumberOfOwnDescriptors();
   Handle<DescriptorArray> array(map->instance_descriptors());
   NeanderArray callbacks(descriptors);
   DCHECK(array->NumberOfSlackDescriptors() >= callbacks.length());
   nof = AppendUniqueCallbacks<DescriptorArrayAppender>(&callbacks, array, nof);
   map->SetNumberOfOwnDescriptors(nof);
 }

References DCHECK, v8::NeanderArray::length(), v8::internal::HeapObject::map(), NumberOfOwnDescriptors(), and SetNumberOfOwnDescriptors().

Here is the call graph for this function:

◆ AppendDescriptor()

void v8::internal::Map::AppendDescriptor ( Descriptor * desc )

inline

Definition at line 5125 of file objects-inl.h.

                                            {
   DescriptorArray* descriptors = instance_descriptors();
   int number_of_own_descriptors = NumberOfOwnDescriptors();
   DCHECK(descriptors->number_of_descriptors() == number_of_own_descriptors);
   descriptors->Append(desc);
   SetNumberOfOwnDescriptors(number_of_own_descriptors + 1);
 }

References v8::internal::DescriptorArray::Append(), DCHECK, v8::internal::DescriptorArray::number_of_descriptors(), NumberOfOwnDescriptors(), and SetNumberOfOwnDescriptors().

Here is the call graph for this function:

◆ AsElementsKind()

Handle< Map > v8::internal::Map::AsElementsKind	(	Handle< Map >	map,
		ElementsKind	kind
	)

static

Definition at line 3374 of file objects.cc.

                                                                   {
   Handle<Map> closest_map(FindClosestElementsTransition(*map, kind));
  
   if (closest_map->elements_kind() == kind) {
     return closest_map;
   }
  
   return AddMissingElementsTransitions(closest_map, kind);
 }

References v8::internal::AddMissingElementsTransitions(), v8::internal::FindClosestElementsTransition(), and v8::internal::HeapObject::map().

Referenced by v8::internal::JSObject::AllocateStorageForMap(), v8::internal::ArrayConstructorCommon(), and v8::internal::TypedArrayMap().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ bit_field()

byte v8::internal::Map::bit_field ( )

inline

Definition at line 4343 of file objects-inl.h.

                     {
   return READ_BYTE_FIELD(this, kBitFieldOffset);
 }

References kBitFieldOffset, and READ_BYTE_FIELD.

Referenced by v8::internal::CheckEquivalent(), function_with_prototype(), has_non_instance_prototype(), is_access_check_needed(), RawCopy(), set_function_with_prototype(), set_is_access_check_needed(), and set_non_instance_prototype().

Here is the caller graph for this function:

◆ bit_field2()

byte v8::internal::Map::bit_field2 ( )

inline

Definition at line 4353 of file objects-inl.h.

                      {
   return READ_BYTE_FIELD(this, kBitField2Offset);
 }

References kBitField2Offset, and READ_BYTE_FIELD.

Referenced by v8::internal::CheckEquivalent(), Hash(), is_extensible(), is_prototype_map(), RawCopy(), set_is_extensible(), and set_is_prototype_map().

Here is the caller graph for this function:

◆ bit_field3()

uint32_t v8::internal::Map::bit_field3 ( )

inline

Definition at line 5120 of file objects-inl.h.

                          {
   return READ_UINT32_FIELD(this, kBitField3Offset);
 }

References kBitField3Offset, and READ_UINT32_FIELD.

Referenced by construction_count(), deprecate(), done_inobject_slack_tracking(), freeze(), has_instance_call_handler(), is_deprecated(), is_dictionary_map(), is_frozen(), is_migration_target(), is_stable(), mark_unstable(), owns_descriptors(), RawCopy(), set_construction_count(), set_dictionary_map(), set_done_inobject_slack_tracking(), set_has_instance_call_handler(), set_migration_target(), and set_owns_descriptors().

Here is the caller graph for this function:

◆ CanBeDeprecated()

bool v8::internal::Map::CanBeDeprecated ( )

inline

Definition at line 4525 of file objects-inl.h.

                           {
   int descriptor = LastAdded();
   for (int i = 0; i <= descriptor; i++) {
     PropertyDetails details = instance_descriptors()->GetDetails(i);
     if (details.representation().IsNone()) return true;
     if (details.representation().IsSmi()) return true;
     if (details.representation().IsDouble()) return true;
     if (details.representation().IsHeapObject()) return true;
     if (details.type() == CONSTANT) return true;
   }
   return false;
 }

References v8::internal::CONSTANT, and LastAdded().

Here is the call graph for this function:

◆ CanHaveMoreTransitions()

bool v8::internal::Map::CanHaveMoreTransitions ( )

inline

Definition at line 5162 of file objects-inl.h.

                                  {
   if (!HasTransitionArray()) return true;
   return FixedArray::SizeFor(transitions()->length() +
                              TransitionArray::kTransitionSize)
       <= Page::kMaxRegularHeapObjectSize;
 }

References HasTransitionArray(), v8::internal::Page::kMaxRegularHeapObjectSize, v8::internal::TransitionArray::kTransitionSize, and v8::internal::FixedArray::SizeFor().

Referenced by CopyAddDescriptor(), and CopyReplaceDescriptors().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CanOmitMapChecks()

bool v8::internal::Map::CanOmitMapChecks ( )

inline

Definition at line 4549 of file objects-inl.h.

                            {
   return is_stable() && FLAG_omit_map_checks_for_leaf_maps;
 }

References is_stable().

Here is the call graph for this function:

◆ CanTransition()

bool v8::internal::Map::CanTransition ( )

inline

Definition at line 6119 of file objects.h.

                        {
     // Only JSObject and subtypes have map transitions and back pointers.
     STATIC_ASSERT(LAST_TYPE == LAST_JS_OBJECT_TYPE);
     return instance_type() >= FIRST_JS_OBJECT_TYPE;
   }

References v8::internal::FIRST_JS_OBJECT_TYPE, v8::internal::LAST_JS_OBJECT_TYPE, v8::internal::LAST_TYPE, and v8::internal::STATIC_ASSERT().

Here is the call graph for this function:

◆ ClearCodeCache()

void v8::internal::Map::ClearCodeCache ( Heap * heap )

inline

Definition at line 6945 of file objects-inl.h.

                                    {
   // No write barrier is needed since empty_fixed_array is not in new space.
   // Please note this function is used during marking:
   //  - MarkCompactCollector::MarkUnmarkedObject
   //  - IncrementalMarking::Step
   DCHECK(!heap->InNewSpace(heap->empty_fixed_array()));
   WRITE_FIELD(this, kCodeCacheOffset, heap->empty_fixed_array());
 }

References DCHECK, v8::internal::Heap::InNewSpace(), kCodeCacheOffset, and WRITE_FIELD.

Here is the call graph for this function:

◆ ClearNonLiveTransitions()

void v8::internal::Map::ClearNonLiveTransitions ( Heap * heap )

◆ ConnectElementsTransition()

void v8::internal::Map::ConnectElementsTransition	(	Handle< Map >	parent,
		Handle< Map >	child
	)

staticprivate

Definition at line 1879 of file objects.cc.

                                                                          {
   Isolate* isolate = parent->GetIsolate();
   Handle<Name> name = isolate->factory()->elements_transition_symbol();
   ConnectTransition(parent, child, name, FULL_TRANSITION);
 }

◆ ConnectTransition()

void v8::internal::Map::ConnectTransition	(	Handle< Map >	parent,
		Handle< Map >	child,
		Handle< Name >	name,
		SimpleTransitionFlag	flag
	)

staticprivate

Definition at line 6519 of file objects.cc.

                                                                           {
   parent->set_owns_descriptors(false);
   if (parent->is_prototype_map()) {
     DCHECK(child->is_prototype_map());
   } else {
     Handle<TransitionArray> transitions =
         TransitionArray::CopyInsert(parent, name, child, flag);
     parent->set_transitions(*transitions);
     child->SetBackPointer(*parent);
   }
 }

References v8::internal::TransitionArray::CopyInsert(), DCHECK, v8::internal::flag, and name.

Here is the call graph for this function:

◆ construction_count()

int v8::internal::Map::construction_count ( )

inline

Definition at line 4495 of file objects-inl.h.

                             {
   return ConstructionCount::decode(bit_field3());
 }

References bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::decode().

Referenced by v8::internal::JSFunction::IsInobjectSlackTrackingInProgress().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ constructor_name()

String * v8::internal::Map::constructor_name ( )

Definition at line 1689 of file objects.cc.

                               {
   if (constructor()->IsJSFunction()) {
     JSFunction* constructor = JSFunction::cast(this->constructor());
     String* name = String::cast(constructor->shared()->name());
     if (name->length() > 0) return name;
     String* inferred_name = constructor->shared()->inferred_name();
     if (inferred_name->length() > 0) return inferred_name;
     Object* proto = prototype();
     if (proto->IsJSObject()) return JSObject::cast(proto)->constructor_name();
   }
   // TODO(rossberg): what about proxies?
   // If the constructor is not present, return "Object".
   return GetHeap()->Object_string();
 }

Referenced by PrintGeneralization(), and v8::internal::JSObject::PrintInstanceMigration().

Here is the caller graph for this function:

◆ Copy()

Handle< Map > v8::internal::Map::Copy ( Handle< Map > map )

static

Definition at line 6664 of file objects.cc.

                                      {
   Handle<DescriptorArray> descriptors(map->instance_descriptors());
   int number_of_own_descriptors = map->NumberOfOwnDescriptors();
   Handle<DescriptorArray> new_descriptors =
       DescriptorArray::CopyUpTo(descriptors, number_of_own_descriptors);
   return CopyReplaceDescriptors(
       map, new_descriptors, OMIT_TRANSITION, MaybeHandle<Name>());
 }

References v8::internal::DescriptorArray::CopyUpTo(), v8::internal::HeapObject::map(), NumberOfOwnDescriptors(), and v8::internal::OMIT_TRANSITION.

Referenced by v8::internal::JSObject::Freeze(), v8::internal::NewJSObjectWithNullProto(), v8::internal::NewSloppyArguments(), v8::internal::JSObject::OptimizeAsPrototype(), v8::internal::JSObject::PreventExtensions(), v8::internal::RUNTIME_FUNCTION(), v8::internal::JSFunction::SetInstancePrototype(), v8::internal::JSObject::SetObserved(), v8::internal::JSFunction::SetPrototype(), and v8::Object::TurnOnAccessCheck().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CopyAddDescriptor()

Handle< Map > v8::internal::Map::CopyAddDescriptor	(	Handle< Map >	map,
		Descriptor *	descriptor,
		TransitionFlag	flag
	)

staticprivate

Definition at line 6911 of file objects.cc.

                                                         {
   Handle<DescriptorArray> descriptors(map->instance_descriptors());
  
   // Ensure the key is unique.
   descriptor->KeyToUniqueName();
  
   if (flag == INSERT_TRANSITION &&
       map->owns_descriptors() &&
       map->CanHaveMoreTransitions()) {
     return ShareDescriptor(map, descriptors, descriptor);
   }
  
   Handle<DescriptorArray> new_descriptors = DescriptorArray::CopyUpTo(
       descriptors, map->NumberOfOwnDescriptors(), 1);
   new_descriptors->Append(descriptor);
  
   return CopyReplaceDescriptors(
       map, new_descriptors, flag, descriptor->GetKey(), SIMPLE_TRANSITION);
 }

References CanHaveMoreTransitions(), v8::internal::DescriptorArray::CopyUpTo(), v8::internal::flag, v8::internal::INSERT_TRANSITION, v8::internal::HeapObject::map(), NumberOfOwnDescriptors(), owns_descriptors(), and v8::internal::SIMPLE_TRANSITION.

Here is the call graph for this function:

◆ CopyAsElementsKind()

Handle< Map > v8::internal::Map::CopyAsElementsKind	(	Handle< Map >	map,
		ElementsKind	kind,
		TransitionFlag	flag
	)

static

Definition at line 6592 of file objects.cc.

                                                          {
   if (flag == INSERT_TRANSITION) {
     DCHECK(!map->HasElementsTransition() ||
         ((map->elements_transition_map()->elements_kind() ==
           DICTIONARY_ELEMENTS ||
           IsExternalArrayElementsKind(
               map->elements_transition_map()->elements_kind())) &&
          (kind == DICTIONARY_ELEMENTS ||
           IsExternalArrayElementsKind(kind))));
     DCHECK(!IsFastElementsKind(kind) ||
            IsMoreGeneralElementsKindTransition(map->elements_kind(), kind));
     DCHECK(kind != map->elements_kind());
   }
  
   bool insert_transition =
       flag == INSERT_TRANSITION && !map->HasElementsTransition();
  
   if (insert_transition && map->owns_descriptors()) {
     // In case the map owned its own descriptors, share the descriptors and
     // transfer ownership to the new map.
     Handle<Map> new_map = CopyDropDescriptors(map);
  
     ConnectElementsTransition(map, new_map);
  
     new_map->set_elements_kind(kind);
     new_map->InitializeDescriptors(map->instance_descriptors());
     return new_map;
   }
  
   // In case the map did not own its own descriptors, a split is forced by
   // copying the map; creating a new descriptor array cell.
   // Create a new free-floating map only if we are not allowed to store it.
   Handle<Map> new_map = Copy(map);
  
   new_map->set_elements_kind(kind);
  
   if (insert_transition) {
     ConnectElementsTransition(map, new_map);
   }
  
   return new_map;
 }

References DCHECK, v8::internal::DICTIONARY_ELEMENTS, elements_kind(), elements_transition_map(), v8::internal::flag, HasElementsTransition(), v8::internal::INSERT_TRANSITION, v8::internal::IsExternalArrayElementsKind(), v8::internal::IsFastElementsKind(), v8::internal::IsMoreGeneralElementsKindTransition(), v8::internal::HeapObject::map(), and owns_descriptors().

Referenced by v8::internal::CacheInitialJSArrayMaps(), and v8::internal::HashTable< MapCache, MapCacheShape, HashTableKey * >::Rehash().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CopyDropDescriptors()

Handle< Map > v8::internal::Map::CopyDropDescriptors ( Handle< Map > map )

static

Definition at line 6468 of file objects.cc.

                                                     {
   Handle<Map> result = RawCopy(map, map->instance_size());
  
   // Please note instance_type and instance_size are set when allocated.
   result->set_inobject_properties(map->inobject_properties());
   result->set_unused_property_fields(map->unused_property_fields());
  
   result->set_pre_allocated_property_fields(
       map->pre_allocated_property_fields());
   result->ClearCodeCache(map->GetHeap());
   map->NotifyLeafMapLayoutChange();
   return result;
 }

References v8::internal::HeapObject::GetHeap(), inobject_properties(), instance_size(), v8::internal::HeapObject::map(), NotifyLeafMapLayoutChange(), pre_allocated_property_fields(), and unused_property_fields().

Referenced by v8::internal::JSObject::DeleteNormalizedProperty(), v8::internal::JSObject::MigrateSlowToFast(), and v8::internal::JSObject::SetPropertyCallback().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CopyForFreeze()

Handle< Map > v8::internal::Map::CopyForFreeze ( Handle< Map > map )

static

Definition at line 6699 of file objects.cc.

                                               {
   int num_descriptors = map->NumberOfOwnDescriptors();
   Isolate* isolate = map->GetIsolate();
   Handle<DescriptorArray> new_desc = DescriptorArray::CopyUpToAddAttributes(
       handle(map->instance_descriptors(), isolate), num_descriptors, FROZEN);
   Handle<Map> new_map = CopyReplaceDescriptors(
       map, new_desc, INSERT_TRANSITION, isolate->factory()->frozen_symbol());
   new_map->freeze();
   new_map->set_is_extensible(false);
   new_map->set_elements_kind(DICTIONARY_ELEMENTS);
   return new_map;
 }

References v8::internal::DescriptorArray::CopyUpToAddAttributes(), v8::internal::DICTIONARY_ELEMENTS, v8::internal::Isolate::factory(), FROZEN, v8::internal::HeapObject::GetIsolate(), v8::internal::handle(), v8::internal::INSERT_TRANSITION, v8::internal::HeapObject::map(), and NumberOfOwnDescriptors().

Referenced by v8::internal::JSObject::Freeze().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CopyForObserved()

Handle< Map > v8::internal::Map::CopyForObserved ( Handle< Map > map )

static

Definition at line 6637 of file objects.cc.

                                                 {
   DCHECK(!map->is_observed());
  
   Isolate* isolate = map->GetIsolate();
  
   // In case the map owned its own descriptors, share the descriptors and
   // transfer ownership to the new map.
   Handle<Map> new_map;
   if (map->owns_descriptors()) {
     new_map = CopyDropDescriptors(map);
   } else {
     DCHECK(!map->is_prototype_map());
     new_map = Copy(map);
   }
  
   new_map->set_is_observed();
   if (map->owns_descriptors()) {
     new_map->InitializeDescriptors(map->instance_descriptors());
   }
  
   Handle<Name> name = isolate->factory()->observed_symbol();
   ConnectTransition(map, new_map, name, FULL_TRANSITION);
  
   return new_map;
 }

References DCHECK, v8::internal::Isolate::factory(), v8::internal::FULL_TRANSITION, v8::internal::HeapObject::GetIsolate(), is_observed(), is_prototype_map(), v8::internal::HeapObject::map(), name, and owns_descriptors().

Referenced by v8::internal::JSObject::SetObserved().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CopyGeneralizeAllRepresentations() [1/2]

Handle< Map > v8::internal::Map::CopyGeneralizeAllRepresentations	(	Handle< Map >	map,
		int	modify_index,
		StoreMode	store_mode,
		const char *	reason
	)

static

Definition at line 2158 of file objects.cc.

                                                                       {
   PropertyDetails details =
       map->instance_descriptors()->GetDetails(modify_index);
   return CopyGeneralizeAllRepresentations(map, modify_index, store_mode,
                                           details.attributes(), reason);
 }

References v8::internal::HeapObject::map().

Here is the call graph for this function:

◆ CopyGeneralizeAllRepresentations() [2/2]

Handle< Map > v8::internal::Map::CopyGeneralizeAllRepresentations	(	Handle< Map >	map,
		int	modify_index,
		StoreMode	store_mode,
		PropertyAttributes	attributes,
		const char *	reason
	)

static

Definition at line 2105 of file objects.cc.

                                                                       {
   Isolate* isolate = map->GetIsolate();
   Handle<Map> new_map = Copy(map);
  
   DescriptorArray* descriptors = new_map->instance_descriptors();
   int length = descriptors->number_of_descriptors();
   for (int i = 0; i < length; i++) {
     descriptors->SetRepresentation(i, Representation::Tagged());
     if (descriptors->GetDetails(i).type() == FIELD) {
       descriptors->SetValue(i, HeapType::Any());
     }
   }
  
   // Unless the instance is being migrated, ensure that modify_index is a field.
   PropertyDetails details = descriptors->GetDetails(modify_index);
   if (store_mode == FORCE_FIELD &&
       (details.type() != FIELD || details.attributes() != attributes)) {
     int field_index = details.type() == FIELD ? details.field_index()
                                               : new_map->NumberOfFields();
     FieldDescriptor d(handle(descriptors->GetKey(modify_index), isolate),
                       field_index, attributes, Representation::Tagged());
     descriptors->Replace(modify_index, &d);
     if (details.type() != FIELD) {
       int unused_property_fields = new_map->unused_property_fields() - 1;
       if (unused_property_fields < 0) {
         unused_property_fields += JSObject::kFieldsAdded;
       }
       new_map->set_unused_property_fields(unused_property_fields);
     }
   } else {
     DCHECK(details.attributes() == attributes);
   }
  
   if (FLAG_trace_generalization) {
     HeapType* field_type = (details.type() == FIELD)
         ? map->instance_descriptors()->GetFieldType(modify_index)
         : NULL;
     map->PrintGeneralization(stdout, reason, modify_index,
                         new_map->NumberOfOwnDescriptors(),
                         new_map->NumberOfOwnDescriptors(),
                         details.type() == CONSTANT && store_mode == FORCE_FIELD,
                         details.representation(), Representation::Tagged(),
                         field_type, HeapType::Any());
   }
   return new_map;
 }

References v8::internal::CONSTANT, DCHECK, v8::internal::FIELD, v8::internal::FORCE_FIELD, v8::internal::DescriptorArray::GetDetails(), v8::internal::HeapObject::GetIsolate(), v8::internal::DescriptorArray::GetKey(), v8::internal::handle(), v8::internal::JSObject::kFieldsAdded, v8::internal::HeapObject::map(), NULL, v8::internal::DescriptorArray::number_of_descriptors(), PrintGeneralization(), v8::internal::DescriptorArray::Replace(), v8::internal::DescriptorArray::SetRepresentation(), v8::internal::DescriptorArray::SetValue(), and v8::internal::Representation::Tagged().

Here is the call graph for this function:

◆ CopyInsertDescriptor()

Handle< Map > v8::internal::Map::CopyInsertDescriptor	(	Handle< Map >	map,
		Descriptor *	descriptor,
		TransitionFlag	flag
	)

static

Definition at line 6934 of file objects.cc.

                                                            {
   Handle<DescriptorArray> old_descriptors(map->instance_descriptors());
  
   // Ensure the key is unique.
   descriptor->KeyToUniqueName();
  
   // We replace the key if it is already present.
   int index = old_descriptors->SearchWithCache(*descriptor->GetKey(), *map);
   if (index != DescriptorArray::kNotFound) {
     return CopyReplaceDescriptor(map, old_descriptors, descriptor, index, flag);
   }
   return CopyAddDescriptor(map, descriptor, flag);
 }

References v8::internal::flag, v8::internal::DescriptorArray::kNotFound, and v8::internal::HeapObject::map().

Referenced by TransitionToAccessorProperty().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CopyInstallDescriptors()

Handle< Map > v8::internal::Map::CopyInstallDescriptors	(	Handle< Map >	map,
		int	new_descriptor,
		Handle< DescriptorArray >	descriptors
	)

staticprivate

Definition at line 6565 of file objects.cc.

                                                                              {
   DCHECK(descriptors->IsSortedNoDuplicates());
  
   Handle<Map> result = CopyDropDescriptors(map);
  
   result->InitializeDescriptors(*descriptors);
   result->SetNumberOfOwnDescriptors(new_descriptor + 1);
  
   int unused_property_fields = map->unused_property_fields();
   if (descriptors->GetDetails(new_descriptor).type() == FIELD) {
     unused_property_fields = map->unused_property_fields() - 1;
     if (unused_property_fields < 0) {
       unused_property_fields += JSObject::kFieldsAdded;
     }
   }
  
   result->set_unused_property_fields(unused_property_fields);
  
   Handle<Name> name = handle(descriptors->GetKey(new_descriptor));
   ConnectTransition(map, result, name, SIMPLE_TRANSITION);
  
   return result;
 }

References DCHECK, v8::internal::FIELD, v8::internal::handle(), v8::internal::JSObject::kFieldsAdded, v8::internal::HeapObject::map(), name, v8::internal::SIMPLE_TRANSITION, and unused_property_fields().

Here is the call graph for this function:

◆ CopyNormalized()

Handle< Map > v8::internal::Map::CopyNormalized	(	Handle< Map >	map,
		PropertyNormalizationMode	mode
	)

staticprivate

Definition at line 6444 of file objects.cc.

                                                                 {
   int new_instance_size = map->instance_size();
   if (mode == CLEAR_INOBJECT_PROPERTIES) {
     new_instance_size -= map->inobject_properties() * kPointerSize;
   }
  
   Handle<Map> result = RawCopy(map, new_instance_size);
  
   if (mode != CLEAR_INOBJECT_PROPERTIES) {
     result->set_inobject_properties(map->inobject_properties());
   }
  
   result->set_dictionary_map(true);
   result->set_migration_target(false);
  
 #ifdef VERIFY_HEAP
   if (FLAG_verify_heap) result->DictionaryMapVerify();
 #endif
  
   return result;
 }

References v8::internal::CLEAR_INOBJECT_PROPERTIES, inobject_properties(), instance_size(), v8::internal::kPointerSize, v8::internal::HeapObject::map(), and mode().

Referenced by Normalize().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CopyReplaceDescriptor()

Handle< Map > v8::internal::Map::CopyReplaceDescriptor	(	Handle< Map >	map,
		Handle< DescriptorArray >	descriptors,
		Descriptor *	descriptor,
		int	index,
		TransitionFlag	flag
	)

staticprivate

Definition at line 7006 of file objects.cc.

                                                             {
   // Ensure the key is unique.
   descriptor->KeyToUniqueName();
  
   Handle<Name> key = descriptor->GetKey();
   DCHECK(*key == descriptors->GetKey(insertion_index));
  
   Handle<DescriptorArray> new_descriptors = DescriptorArray::CopyUpTo(
       descriptors, map->NumberOfOwnDescriptors());
  
   new_descriptors->Replace(insertion_index, descriptor);
  
   SimpleTransitionFlag simple_flag =
       (insertion_index == descriptors->number_of_descriptors() - 1)
       ? SIMPLE_TRANSITION
       : FULL_TRANSITION;
   return CopyReplaceDescriptors(map, new_descriptors, flag, key, simple_flag);
 }

References v8::internal::DescriptorArray::CopyUpTo(), DCHECK, v8::internal::flag, v8::internal::FULL_TRANSITION, v8::internal::HeapObject::map(), NumberOfOwnDescriptors(), and v8::internal::SIMPLE_TRANSITION.

Here is the call graph for this function:

◆ CopyReplaceDescriptors()

Handle< Map > v8::internal::Map::CopyReplaceDescriptors	(	Handle< Map >	map,
		Handle< DescriptorArray >	descriptors,
		TransitionFlag	flag,
		MaybeHandle< Name >	maybe_name,
		SimpleTransitionFlag	simple_flag = `FULL_TRANSITION`
	)

staticprivate

Definition at line 6533 of file objects.cc.

                                                                           {
   DCHECK(descriptors->IsSortedNoDuplicates());
  
   Handle<Map> result = CopyDropDescriptors(map);
   result->InitializeDescriptors(*descriptors);
  
   if (!map->is_prototype_map()) {
     if (flag == INSERT_TRANSITION && map->CanHaveMoreTransitions()) {
       Handle<Name> name;
       CHECK(maybe_name.ToHandle(&name));
       ConnectTransition(map, result, name, simple_flag);
     } else {
       int length = descriptors->number_of_descriptors();
       for (int i = 0; i < length; i++) {
         descriptors->SetRepresentation(i, Representation::Tagged());
         if (descriptors->GetDetails(i).type() == FIELD) {
           descriptors->SetValue(i, HeapType::Any());
         }
       }
     }
   }
  
   return result;
 }

References CanHaveMoreTransitions(), CHECK, DCHECK, v8::internal::FIELD, v8::internal::flag, v8::internal::INSERT_TRANSITION, is_prototype_map(), v8::internal::HeapObject::map(), name, and v8::internal::Representation::Tagged().

Here is the call graph for this function:

◆ CopyWithConstant()

MaybeHandle< Map > v8::internal::Map::CopyWithConstant	(	Handle< Map >	map,
		Handle< Name >	name,
		Handle< Object >	constant,
		PropertyAttributes	attributes,
		TransitionFlag	flag
	)

static

Definition at line 1746 of file objects.cc.

                                                             {
   // Ensure the descriptor array does not get too big.
   if (map->NumberOfOwnDescriptors() >= kMaxNumberOfDescriptors) {
     return MaybeHandle<Map>();
   }
  
   // Allocate new instance descriptors with (name, constant) added.
   ConstantDescriptor new_constant_desc(name, constant, attributes);
   return Map::CopyAddDescriptor(map, &new_constant_desc, flag);
 }

Referenced by TransitionToDataProperty().

Here is the caller graph for this function:

◆ CopyWithField()

MaybeHandle< Map > v8::internal::Map::CopyWithField	(	Handle< Map >	map,
		Handle< Name >	name,
		Handle< HeapType >	type,
		PropertyAttributes	attributes,
		Representation	representation,
		TransitionFlag	flag
	)

static

Definition at line 1710 of file objects.cc.

                                                          {
   DCHECK(DescriptorArray::kNotFound ==
          map->instance_descriptors()->Search(
              *name, map->NumberOfOwnDescriptors()));
  
   // Ensure the descriptor array does not get too big.
   if (map->NumberOfOwnDescriptors() >= kMaxNumberOfDescriptors) {
     return MaybeHandle<Map>();
   }
  
   Isolate* isolate = map->GetIsolate();
  
   // Compute the new index for new field.
   int index = map->NextFreePropertyIndex();
  
   if (map->instance_type() == JS_CONTEXT_EXTENSION_OBJECT_TYPE) {
     representation = Representation::Tagged();
     type = HeapType::Any(isolate);
   }
  
   FieldDescriptor new_field_desc(name, index, type, attributes, representation);
   Handle<Map> new_map = Map::CopyAddDescriptor(map, &new_field_desc, flag);
   int unused_property_fields = new_map->unused_property_fields() - 1;
   if (unused_property_fields < 0) {
     unused_property_fields += JSObject::kFieldsAdded;
   }
   new_map->set_unused_property_fields(unused_property_fields);
   return new_map;
 }

Referenced by TransitionToDataProperty().

Here is the caller graph for this function:

◆ Create()

Handle< Map > v8::internal::Map::Create	(	Isolate *	isolate,
		int	inobject_properties
	)

static

Definition at line 6674 of file objects.cc.

                                                                  {
   Handle<Map> copy = Copy(handle(isolate->object_function()->initial_map()));
  
   // Check that we do not overflow the instance size when adding the extra
   // inobject properties. If the instance size overflows, we allocate as many
   // properties as we can as inobject properties.
   int max_extra_properties =
       (JSObject::kMaxInstanceSize - JSObject::kHeaderSize) >> kPointerSizeLog2;
  
   if (inobject_properties > max_extra_properties) {
     inobject_properties = max_extra_properties;
   }
  
   int new_instance_size =
       JSObject::kHeaderSize + kPointerSize * inobject_properties;
  
   // Adjust the map with the extra inobject properties.
   copy->set_inobject_properties(inobject_properties);
   copy->set_unused_property_fields(inobject_properties);
   copy->set_instance_size(new_instance_size);
   copy->set_visitor_id(StaticVisitorBase::GetVisitorId(*copy));
   return copy;
 }

References v8::internal::StaticVisitorBase::GetVisitorId(), v8::internal::handle(), v8::internal::JSObject::kHeaderSize, v8::internal::JSObject::kMaxInstanceSize, v8::internal::kPointerSize, and v8::internal::kPointerSizeLog2.

Referenced by v8::internal::ComputeObjectLiteralMap().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ deprecate()

void v8::internal::Map::deprecate ( )

inline

Definition at line 4460 of file objects-inl.h.

                     {
   set_bit_field3(Deprecated::update(bit_field3(), true));
 }

References bit_field3(), set_bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::update().

Here is the call graph for this function:

◆ DeprecateTarget()

void v8::internal::Map::DeprecateTarget	(	Name *	key,
		DescriptorArray *	new_descriptors
	)

private

Definition at line 2187 of file objects.cc.

                                                                      {
   if (HasTransitionArray()) {
     TransitionArray* transitions = this->transitions();
     int transition = transitions->Search(key);
     if (transition != TransitionArray::kNotFound) {
       transitions->GetTarget(transition)->DeprecateTransitionTree();
     }
   }
  
   // Don't overwrite the empty descriptor array.
   if (NumberOfOwnDescriptors() == 0) return;
  
   DescriptorArray* to_replace = instance_descriptors();
   Map* current = this;
   GetHeap()->incremental_marking()->RecordWrites(to_replace);
   while (current->instance_descriptors() == to_replace) {
     current->SetEnumLength(kInvalidEnumCacheSentinel);
     current->set_instance_descriptors(new_descriptors);
     Object* next = current->GetBackPointer();
     if (next->IsUndefined()) break;
     current = Map::cast(next);
   }
  
   set_owns_descriptors(false);
 }

References DeprecateTransitionTree(), GetBackPointer(), v8::internal::HeapObject::GetHeap(), v8::internal::TransitionArray::GetTarget(), v8::internal::Heap::incremental_marking(), v8::internal::kInvalidEnumCacheSentinel, v8::internal::TransitionArray::kNotFound, v8::internal::IncrementalMarking::RecordWrites(), v8::internal::TransitionArray::Search(), and SetEnumLength().

Here is the call graph for this function:

◆ DeprecateTransitionTree()

void v8::internal::Map::DeprecateTransitionTree ( )

private

Definition at line 2169 of file objects.cc.

                                   {
   if (is_deprecated()) return;
   if (HasTransitionArray()) {
     TransitionArray* transitions = this->transitions();
     for (int i = 0; i < transitions->number_of_transitions(); i++) {
       transitions->GetTarget(i)->DeprecateTransitionTree();
     }
   }
   deprecate();
   dependent_code()->DeoptimizeDependentCodeGroup(
       GetIsolate(), DependentCode::kTransitionGroup);
   NotifyLeafMapLayoutChange();
 }

References v8::internal::dependent_code, DeprecateTransitionTree(), v8::internal::HeapObject::GetIsolate(), v8::internal::TransitionArray::GetTarget(), v8::internal::DependentCode::kTransitionGroup, and v8::internal::TransitionArray::number_of_transitions().

Referenced by DeprecateTarget(), and DeprecateTransitionTree().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DictionaryElementsInPrototypeChainOnly()

bool v8::internal::Map::DictionaryElementsInPrototypeChainOnly ( )

Definition at line 6003 of file objects.cc.

                                                  {
   if (IsDictionaryElementsKind(elements_kind())) {
     return false;
   }
  
   for (PrototypeIterator iter(this); !iter.IsAtEnd(); iter.Advance()) {
     if (iter.GetCurrent()->IsJSProxy()) {
       // Be conservative, don't walk into proxies.
       return true;
     }
  
     if (IsDictionaryElementsKind(
             JSObject::cast(iter.GetCurrent())->map()->elements_kind())) {
       return true;
     }
   }
  
   return false;
 }

References v8::internal::PrototypeIterator::IsAtEnd(), and v8::internal::IsDictionaryElementsKind().

Here is the call graph for this function:

◆ DISALLOW_IMPLICIT_CONSTRUCTORS()

v8::internal::Map::DISALLOW_IMPLICIT_CONSTRUCTORS ( Map )

private

◆ done_inobject_slack_tracking()

bool v8::internal::Map::done_inobject_slack_tracking ( )

inline

Definition at line 4485 of file objects-inl.h.

                                        {
   return DoneInobjectSlackTracking::decode(bit_field3());
 }

References bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::decode().

Referenced by v8::internal::JSFunction::CompleteInobjectSlackTracking(), and v8::internal::JSFunction::StartInobjectSlackTracking().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elements_kind()

ElementsKind v8::internal::Map::elements_kind ( )

inline

Definition at line 5730 of file objects.h.

                                       {
     return Map::ElementsKindBits::decode(bit_field2());
   }

References v8::internal::BitFieldBase< T, shift, size, U >::decode().

Referenced by v8::internal::JSObject::AllocateStorageForMap(), CopyAsElementsKind(), v8::internal::JSObject::GetElementsKind(), v8::internal::IC::IsTransitionOfMonomorphicTarget(), v8::internal::HashTable< MapCache, MapCacheShape, HashTableKey * >::IterateElements(), LookupElementsTransitionMap(), v8::internal::JSTypedArray::MaterializeArrayBuffer(), v8::internal::HashTable< MapCache, MapCacheShape, HashTableKey * >::New(), v8::internal::RUNTIME_FUNCTION(), TransitionElementsTo(), and TransitionElementsToSlow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ elements_transition_map()

Map * v8::internal::Map::elements_transition_map ( )

inline

Definition at line 5156 of file objects-inl.h.

                                   {
   int index = transitions()->Search(GetHeap()->elements_transition_symbol());
   return transitions()->GetTarget(index);
 }

References v8::internal::HeapObject::GetHeap().

Referenced by CopyAsElementsKind(), v8::internal::HashTable< MapCache, MapCacheShape, HashTableKey * >::IterateElements(), and v8::internal::HashTable< MapCache, MapCacheShape, HashTableKey * >::New().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ EnsureDescriptorSlack()

void v8::internal::Map::EnsureDescriptorSlack	(	Handle< Map >	map,
		int	slack
	)

static

Definition at line 3057 of file objects.cc.

                                                           {
   // Only supports adding slack to owned descriptors.
   DCHECK(map->owns_descriptors());
  
   Handle<DescriptorArray> descriptors(map->instance_descriptors());
   int old_size = map->NumberOfOwnDescriptors();
   if (slack <= descriptors->NumberOfSlackDescriptors()) return;
  
   Handle<DescriptorArray> new_descriptors = DescriptorArray::CopyUpTo(
       descriptors, old_size, slack);
  
   if (old_size == 0) {
     map->set_instance_descriptors(*new_descriptors);
     return;
   }
  
   // If the source descriptors had an enum cache we copy it. This ensures
   // that the maps to which we push the new descriptor array back can rely
   // on a cache always being available once it is set. If the map has more
   // enumerated descriptors than available in the original cache, the cache
   // will be lazily replaced by the extended cache when needed.
   if (descriptors->HasEnumCache()) {
     new_descriptors->CopyEnumCacheFrom(*descriptors);
   }
  
   // Replace descriptors by new_descriptors in all maps that share it.
   map->GetHeap()->incremental_marking()->RecordWrites(*descriptors);
  
   Map* walk_map;
   for (Object* current = map->GetBackPointer();
        !current->IsUndefined();
        current = walk_map->GetBackPointer()) {
     walk_map = Map::cast(current);
     if (walk_map->instance_descriptors() != *descriptors) break;
     walk_map->set_instance_descriptors(*new_descriptors);
   }
  
   map->set_instance_descriptors(*new_descriptors);
 }

References v8::internal::DescriptorArray::CopyUpTo(), DCHECK, GetBackPointer(), v8::internal::HeapObject::GetHeap(), v8::internal::Heap::incremental_marking(), v8::internal::HeapObject::map(), NumberOfOwnDescriptors(), owns_descriptors(), and v8::internal::IncrementalMarking::RecordWrites().

Here is the call graph for this function:

◆ EnumLength()

int v8::internal::Map::EnumLength ( )

inline

Definition at line 5955 of file objects.h.

                    {
     return EnumLengthBits::decode(bit_field3());
   }

Referenced by v8::internal::JSReceiver::IsSimpleEnum(), and v8::internal::JSObject::NumberOfOwnProperties().

Here is the caller graph for this function:

◆ EquivalentToForNormalization()

bool v8::internal::Map::EquivalentToForNormalization	(	Map *	other,
		PropertyNormalizationMode	mode
	)

Definition at line 9054 of file objects.cc.

                                                                        {
   int properties = mode == CLEAR_INOBJECT_PROPERTIES
       ? 0 : other->inobject_properties();
   return CheckEquivalent(this, other) && inobject_properties() == properties;
 }

References v8::internal::CheckEquivalent(), v8::internal::CLEAR_INOBJECT_PROPERTIES, inobject_properties(), and mode().

Here is the call graph for this function:

◆ EquivalentToForTransition()

bool v8::internal::Map::EquivalentToForTransition ( Map * other )

private

Definition at line 9049 of file objects.cc.

                                               {
   return CheckEquivalent(this, other);
 }

References v8::internal::CheckEquivalent().

Here is the call graph for this function:

◆ ExpectedTransitionKey()

Handle< String > v8::internal::Map::ExpectedTransitionKey ( Handle< Map > map )

inlinestatic

Definition at line 1847 of file objects-inl.h.

                                                          {
   DisallowHeapAllocation no_gc;
   if (!map->HasTransitionArray()) return Handle<String>::null();
   TransitionArray* transitions = map->transitions();
   if (!transitions->IsSimpleTransition()) return Handle<String>::null();
   int transition = TransitionArray::kSimpleTransitionIndex;
   PropertyDetails details = transitions->GetTargetDetails(transition);
   Name* name = transitions->GetKey(transition);
   if (details.type() != FIELD) return Handle<String>::null();
   if (details.attributes() != NONE) return Handle<String>::null();
   if (!name->IsString()) return Handle<String>::null();
   return Handle<String>(String::cast(name));
 }

References v8::internal::FIELD, v8::internal::TransitionArray::GetKey(), v8::internal::TransitionArray::GetTargetDetails(), HasTransitionArray(), v8::internal::TransitionArray::IsSimpleTransition(), v8::internal::TransitionArray::kSimpleTransitionIndex, v8::internal::HeapObject::map(), name, NONE, and v8::internal::Handle< T >::null().

Referenced by ExpectedTransitionTarget().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExpectedTransitionTarget()

Handle< Map > v8::internal::Map::ExpectedTransitionTarget ( Handle< Map > map )

inlinestatic

Definition at line 1862 of file objects-inl.h.

                                                          {
   DCHECK(!ExpectedTransitionKey(map).is_null());
   return Handle<Map>(map->transitions()->GetTarget(
       TransitionArray::kSimpleTransitionIndex));
 }

References DCHECK, ExpectedTransitionKey(), v8::internal::TransitionArray::kSimpleTransitionIndex, and v8::internal::HeapObject::map().

Here is the call graph for this function:

◆ FindFieldOwner()

Map * v8::internal::Map::FindFieldOwner ( int descriptor )

Definition at line 2262 of file objects.cc.

                                        {
   DisallowHeapAllocation no_allocation;
   DCHECK_EQ(FIELD, instance_descriptors()->GetDetails(descriptor).type());
   Map* result = this;
   while (true) {
     Object* back = result->GetBackPointer();
     if (back->IsUndefined()) break;
     Map* parent = Map::cast(back);
     if (parent->NumberOfOwnDescriptors() <= descriptor) break;
     result = parent;
   }
   return result;
 }

References DCHECK_EQ, v8::internal::FIELD, GetBackPointer(), and NumberOfOwnDescriptors().

Referenced by GeneralizeFieldType().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ FindInCodeCache()

Object * v8::internal::Map::FindInCodeCache	(	Name *	name,
		Code::Flags	flags
	)

Definition at line 7047 of file objects.cc.

                                                         {
   // Do a lookup if a code cache exists.
   if (!code_cache()->IsFixedArray()) {
     return CodeCache::cast(code_cache())->Lookup(name, flags);
   } else {
     return GetHeap()->undefined_value();
   }
 }

References v8::internal::anonymous_namespace{flags.cc}::flags, v8::internal::HeapObject::GetHeap(), and name.

Here is the call graph for this function:

◆ FindLastMatchMap()

Map * v8::internal::Map::FindLastMatchMap	(	int	verbatim,
		int	length,
		DescriptorArray *	descriptors
	)

private

Definition at line 2224 of file objects.cc.

                                                          {
   DisallowHeapAllocation no_allocation;
  
   // This can only be called on roots of transition trees.
   DCHECK(GetBackPointer()->IsUndefined());
  
   Map* current = this;
  
   for (int i = verbatim; i < length; i++) {
     if (!current->HasTransitionArray()) break;
     Name* name = descriptors->GetKey(i);
     TransitionArray* transitions = current->transitions();
     int transition = transitions->Search(name);
     if (transition == TransitionArray::kNotFound) break;
  
     Map* next = transitions->GetTarget(transition);
     DescriptorArray* next_descriptors = next->instance_descriptors();
  
     PropertyDetails details = descriptors->GetDetails(i);
     PropertyDetails next_details = next_descriptors->GetDetails(i);
     if (details.type() != next_details.type()) break;
     if (details.attributes() != next_details.attributes()) break;
     if (!details.representation().Equals(next_details.representation())) break;
     if (next_details.type() == FIELD) {
       if (!descriptors->GetFieldType(i)->NowIs(
               next_descriptors->GetFieldType(i))) break;
     } else {
       if (descriptors->GetValue(i) != next_descriptors->GetValue(i)) break;
     }
  
     current = next;
   }
   return current;
 }

References DCHECK, v8::internal::FIELD, v8::internal::DescriptorArray::GetDetails(), v8::internal::DescriptorArray::GetFieldType(), v8::internal::DescriptorArray::GetKey(), v8::internal::TransitionArray::GetTarget(), v8::internal::DescriptorArray::GetValue(), HasTransitionArray(), v8::internal::TransitionArray::kNotFound, name, v8::internal::TypeImpl< Config >::NowIs(), and v8::internal::TransitionArray::Search().

Here is the call graph for this function:

◆ FindRootMap()

Map * v8::internal::Map::FindRootMap ( )

Definition at line 2214 of file objects.cc.

                       {
   Map* result = this;
   while (true) {
     Object* back = result->GetBackPointer();
     if (back->IsUndefined()) return result;
     result = Map::cast(back);
   }
 }

References GetBackPointer().

Here is the call graph for this function:

◆ FindTransitionedMap()

Handle< Map > v8::internal::Map::FindTransitionedMap ( MapHandleList * candidates )

Definition at line 3212 of file objects.cc.

                                                               {
   ElementsKind kind = elements_kind();
   Handle<Map> transitioned_map = Handle<Map>::null();
   Handle<Map> current_map(this);
   bool packed = IsFastPackedElementsKind(kind);
   if (IsTransitionableFastElementsKind(kind)) {
     while (CanTransitionToMoreGeneralFastElementsKind(kind, false)) {
       kind = GetNextMoreGeneralFastElementsKind(kind, false);
       Handle<Map> maybe_transitioned_map =
           MaybeNull(current_map->LookupElementsTransitionMap(kind));
       if (maybe_transitioned_map.is_null()) break;
       if (ContainsMap(candidates, maybe_transitioned_map) &&
           (packed || !IsFastPackedElementsKind(kind))) {
         transitioned_map = maybe_transitioned_map;
         if (!IsFastPackedElementsKind(kind)) packed = false;
       }
       current_map = maybe_transitioned_map;
     }
   }
   return transitioned_map;
 }

References v8::internal::CanTransitionToMoreGeneralFastElementsKind(), v8::internal::ContainsMap(), v8::internal::GetNextMoreGeneralFastElementsKind(), v8::internal::Handle< T >::is_null(), v8::internal::IsFastPackedElementsKind(), v8::internal::IsTransitionableFastElementsKind(), v8::internal::MaybeNull(), and v8::internal::Handle< T >::null().

Here is the call graph for this function:

◆ FindTransitionToField()

Handle< Map > v8::internal::Map::FindTransitionToField	(	Handle< Map >	map,
		Handle< Name >	key
	)

inlinestatic

Definition at line 1869 of file objects-inl.h.

                                                                         {
   DisallowHeapAllocation no_allocation;
   if (!map->HasTransitionArray()) return Handle<Map>::null();
   TransitionArray* transitions = map->transitions();
   int transition = transitions->Search(*key);
   if (transition == TransitionArray::kNotFound) return Handle<Map>::null();
   PropertyDetails target_details = transitions->GetTargetDetails(transition);
   if (target_details.type() != FIELD) return Handle<Map>::null();
   if (target_details.attributes() != NONE) return Handle<Map>::null();
   return Handle<Map>(transitions->GetTarget(transition));
 }

References v8::internal::FIELD, v8::internal::TransitionArray::GetTarget(), v8::internal::TransitionArray::GetTargetDetails(), HasTransitionArray(), v8::internal::TransitionArray::kNotFound, v8::internal::HeapObject::map(), NONE, v8::internal::Handle< T >::null(), and v8::internal::TransitionArray::Search().

Here is the call graph for this function:

◆ freeze()

void v8::internal::Map::freeze ( )

inline

Definition at line 4500 of file objects-inl.h.

                  {
   set_bit_field3(IsFrozen::update(bit_field3(), true));
 }

References bit_field3(), set_bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::update().

Here is the call graph for this function:

◆ function_with_prototype()

bool v8::internal::Map::function_with_prototype ( )

inline

Definition at line 4382 of file objects-inl.h.

                                   {
   return FunctionWithPrototype::decode(bit_field());
 }

References bit_field(), and v8::internal::BitFieldBase< T, shift, size, U >::decode().

Referenced by v8::internal::JSFunction::should_have_prototype().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GeneralizeAllFieldRepresentations()

Handle< Map > v8::internal::Map::GeneralizeAllFieldRepresentations ( Handle< Map > map )

static

Definition at line 2676 of file objects.cc.

                      {
   Handle<DescriptorArray> descriptors(map->instance_descriptors());
   for (int i = 0; i < map->NumberOfOwnDescriptors(); ++i) {
     if (descriptors->GetDetails(i).type() == FIELD) {
       map = GeneralizeRepresentation(map, i, Representation::Tagged(),
                                      HeapType::Any(map->GetIsolate()),
                                      FORCE_FIELD);
     }
   }
   return map;
 }

References v8::internal::FIELD, v8::internal::FORCE_FIELD, v8::internal::HeapObject::GetIsolate(), v8::internal::HeapObject::map(), NumberOfOwnDescriptors(), and v8::internal::Representation::Tagged().

Referenced by v8::internal::Deoptimizer::MaterializeNextHeapObject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GeneralizeFieldType() [1/2]

Handle< HeapType > v8::internal::Map::GeneralizeFieldType	(	Handle< HeapType >	type1,
		Handle< HeapType >	type2,
		Isolate *	isolate
	)

static

Definition at line 2297 of file objects.cc.

                                                             {
   static const int kMaxClassesPerFieldType = 5;
   if (type1->NowIs(type2)) return type2;
   if (type2->NowIs(type1)) return type1;
   if (type1->NowStable() && type2->NowStable()) {
     Handle<HeapType> type = HeapType::Union(type1, type2, isolate);
     if (type->NumClasses() <= kMaxClassesPerFieldType) {
       DCHECK(type->NowStable());
       DCHECK(type1->NowIs(type));
       DCHECK(type2->NowIs(type));
       return type;
     }
   }
   return HeapType::Any(isolate);
 }

References DCHECK, and v8::internal::TypeImpl< Config >::Union().

Referenced by GeneralizeFieldType().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GeneralizeFieldType() [2/2]

void v8::internal::Map::GeneralizeFieldType	(	Handle< Map >	map,
		int	modify_index,
		Handle< HeapType >	new_field_type
	)

static

Definition at line 2317 of file objects.cc.

                                                                {
   Isolate* isolate = map->GetIsolate();
  
   // Check if we actually need to generalize the field type at all.
   Handle<HeapType> old_field_type(
       map->instance_descriptors()->GetFieldType(modify_index), isolate);
   if (new_field_type->NowIs(old_field_type)) {
     DCHECK(Map::GeneralizeFieldType(old_field_type,
                                     new_field_type,
                                     isolate)->NowIs(old_field_type));
     return;
   }
  
   // Determine the field owner.
   Handle<Map> field_owner(map->FindFieldOwner(modify_index), isolate);
   Handle<DescriptorArray> descriptors(
       field_owner->instance_descriptors(), isolate);
   DCHECK_EQ(*old_field_type, descriptors->GetFieldType(modify_index));
  
   // Determine the generalized new field type.
   new_field_type = Map::GeneralizeFieldType(
       old_field_type, new_field_type, isolate);
  
   PropertyDetails details = descriptors->GetDetails(modify_index);
   Handle<Name> name(descriptors->GetKey(modify_index));
   field_owner->UpdateFieldType(modify_index, name, new_field_type);
   field_owner->dependent_code()->DeoptimizeDependentCodeGroup(
       isolate, DependentCode::kFieldTypeGroup);
  
   if (FLAG_trace_generalization) {
     map->PrintGeneralization(
         stdout, "field type generalization",
         modify_index, map->NumberOfOwnDescriptors(),
         map->NumberOfOwnDescriptors(), false,
         details.representation(), details.representation(),
         *old_field_type, *new_field_type);
   }
 }

References DCHECK, DCHECK_EQ, FindFieldOwner(), GeneralizeFieldType(), v8::internal::HeapObject::GetIsolate(), v8::internal::DependentCode::kFieldTypeGroup, v8::internal::HeapObject::map(), name, NumberOfOwnDescriptors(), and PrintGeneralization().

Here is the call graph for this function:

◆ GeneralizeRepresentation()

Handle< Map > v8::internal::Map::GeneralizeRepresentation	(	Handle< Map >	map,
		int	modify_index,
		Representation	new_representation,
		Handle< HeapType >	new_field_type,
		StoreMode	store_mode
	)

static

Definition at line 2378 of file objects.cc.

                                                                 {
   Isolate* isolate = old_map->GetIsolate();
  
   Handle<DescriptorArray> old_descriptors(
       old_map->instance_descriptors(), isolate);
   int old_nof = old_map->NumberOfOwnDescriptors();
   PropertyDetails old_details = old_descriptors->GetDetails(modify_index);
   Representation old_representation = old_details.representation();
  
   // It's fine to transition from None to anything but double without any
   // modification to the object, because the default uninitialized value for
   // representation None can be overwritten by both smi and tagged values.
   // Doubles, however, would require a box allocation.
   if (old_representation.IsNone() &&
       !new_representation.IsNone() &&
       !new_representation.IsDouble()) {
     DCHECK(old_details.type() == FIELD);
     DCHECK(old_descriptors->GetFieldType(modify_index)->NowIs(
             HeapType::None()));
     if (FLAG_trace_generalization) {
       old_map->PrintGeneralization(
           stdout, "uninitialized field",
           modify_index, old_map->NumberOfOwnDescriptors(),
           old_map->NumberOfOwnDescriptors(), false,
           old_representation, new_representation,
           old_descriptors->GetFieldType(modify_index), *new_field_type);
     }
     old_descriptors->SetRepresentation(modify_index, new_representation);
     old_descriptors->SetValue(modify_index, *new_field_type);
     return old_map;
   }
  
   // Check the state of the root map.
   Handle<Map> root_map(old_map->FindRootMap(), isolate);
   if (!old_map->EquivalentToForTransition(*root_map)) {
     return CopyGeneralizeAllRepresentations(
         old_map, modify_index, store_mode, "not equivalent");
   }
   int root_nof = root_map->NumberOfOwnDescriptors();
   if (modify_index < root_nof) {
     PropertyDetails old_details = old_descriptors->GetDetails(modify_index);
     if ((old_details.type() != FIELD && store_mode == FORCE_FIELD) ||
         (old_details.type() == FIELD &&
          (!new_field_type->NowIs(old_descriptors->GetFieldType(modify_index)) ||
           !new_representation.fits_into(old_details.representation())))) {
       return CopyGeneralizeAllRepresentations(
           old_map, modify_index, store_mode, "root modification");
     }
   }
  
   Handle<Map> target_map = root_map;
   for (int i = root_nof; i < old_nof; ++i) {
     int j = target_map->SearchTransition(old_descriptors->GetKey(i));
     if (j == TransitionArray::kNotFound) break;
     Handle<Map> tmp_map(target_map->GetTransition(j), isolate);
     Handle<DescriptorArray> tmp_descriptors = handle(
         tmp_map->instance_descriptors(), isolate);
  
     // Check if target map is incompatible.
     PropertyDetails old_details = old_descriptors->GetDetails(i);
     PropertyDetails tmp_details = tmp_descriptors->GetDetails(i);
     PropertyType old_type = old_details.type();
     PropertyType tmp_type = tmp_details.type();
     if (tmp_details.attributes() != old_details.attributes() ||
         ((tmp_type == CALLBACKS || old_type == CALLBACKS) &&
          (tmp_type != old_type ||
           tmp_descriptors->GetValue(i) != old_descriptors->GetValue(i)))) {
       return CopyGeneralizeAllRepresentations(
           old_map, modify_index, store_mode, "incompatible");
     }
     Representation old_representation = old_details.representation();
     Representation tmp_representation = tmp_details.representation();
     if (!old_representation.fits_into(tmp_representation) ||
         (!new_representation.fits_into(tmp_representation) &&
          modify_index == i)) {
       break;
     }
     if (tmp_type == FIELD) {
       // Generalize the field type as necessary.
       Handle<HeapType> old_field_type = (old_type == FIELD)
           ? handle(old_descriptors->GetFieldType(i), isolate)
           : old_descriptors->GetValue(i)->OptimalType(
               isolate, tmp_representation);
       if (modify_index == i) {
         old_field_type = GeneralizeFieldType(
             new_field_type, old_field_type, isolate);
       }
       GeneralizeFieldType(tmp_map, i, old_field_type);
     } else if (tmp_type == CONSTANT) {
       if (old_type != CONSTANT ||
           old_descriptors->GetConstant(i) != tmp_descriptors->GetConstant(i)) {
         break;
       }
     } else {
       DCHECK_EQ(tmp_type, old_type);
       DCHECK_EQ(tmp_descriptors->GetValue(i), old_descriptors->GetValue(i));
     }
     target_map = tmp_map;
   }
  
   // Directly change the map if the target map is more general.
   Handle<DescriptorArray> target_descriptors(
       target_map->instance_descriptors(), isolate);
   int target_nof = target_map->NumberOfOwnDescriptors();
   if (target_nof == old_nof &&
       (store_mode != FORCE_FIELD ||
        target_descriptors->GetDetails(modify_index).type() == FIELD)) {
     DCHECK(modify_index < target_nof);
     DCHECK(new_representation.fits_into(
             target_descriptors->GetDetails(modify_index).representation()));
     DCHECK(target_descriptors->GetDetails(modify_index).type() != FIELD ||
            new_field_type->NowIs(
                target_descriptors->GetFieldType(modify_index)));
     return target_map;
   }
  
   // Find the last compatible target map in the transition tree.
   for (int i = target_nof; i < old_nof; ++i) {
     int j = target_map->SearchTransition(old_descriptors->GetKey(i));
     if (j == TransitionArray::kNotFound) break;
     Handle<Map> tmp_map(target_map->GetTransition(j), isolate);
     Handle<DescriptorArray> tmp_descriptors(
         tmp_map->instance_descriptors(), isolate);
  
     // Check if target map is compatible.
     PropertyDetails old_details = old_descriptors->GetDetails(i);
     PropertyDetails tmp_details = tmp_descriptors->GetDetails(i);
     if (tmp_details.attributes() != old_details.attributes() ||
         ((tmp_details.type() == CALLBACKS || old_details.type() == CALLBACKS) &&
          (tmp_details.type() != old_details.type() ||
           tmp_descriptors->GetValue(i) != old_descriptors->GetValue(i)))) {
       return CopyGeneralizeAllRepresentations(
           old_map, modify_index, store_mode, "incompatible");
     }
     target_map = tmp_map;
   }
   target_nof = target_map->NumberOfOwnDescriptors();
   target_descriptors = handle(target_map->instance_descriptors(), isolate);
  
   // Allocate a new descriptor array large enough to hold the required
   // descriptors, with minimally the exact same size as the old descriptor
   // array.
   int new_slack = Max(
       old_nof, old_descriptors->number_of_descriptors()) - old_nof;
   Handle<DescriptorArray> new_descriptors = DescriptorArray::Allocate(
       isolate, old_nof, new_slack);
   DCHECK(new_descriptors->length() > target_descriptors->length() ||
          new_descriptors->NumberOfSlackDescriptors() > 0 ||
          new_descriptors->number_of_descriptors() ==
          old_descriptors->number_of_descriptors());
   DCHECK(new_descriptors->number_of_descriptors() == old_nof);
  
   // 0 -> |root_nof|
   int current_offset = 0;
   for (int i = 0; i < root_nof; ++i) {
     PropertyDetails old_details = old_descriptors->GetDetails(i);
     if (old_details.type() == FIELD) current_offset++;
     Descriptor d(handle(old_descriptors->GetKey(i), isolate),
                  handle(old_descriptors->GetValue(i), isolate),
                  old_details);
     new_descriptors->Set(i, &d);
   }
  
   // |root_nof| -> |target_nof|
   for (int i = root_nof; i < target_nof; ++i) {
     Handle<Name> target_key(target_descriptors->GetKey(i), isolate);
     PropertyDetails old_details = old_descriptors->GetDetails(i);
     PropertyDetails target_details = target_descriptors->GetDetails(i);
     target_details = target_details.CopyWithRepresentation(
         old_details.representation().generalize(
             target_details.representation()));
     if (modify_index == i) {
       target_details = target_details.CopyWithRepresentation(
           new_representation.generalize(target_details.representation()));
     }
     DCHECK_EQ(old_details.attributes(), target_details.attributes());
     if (old_details.type() == FIELD ||
         target_details.type() == FIELD ||
         (modify_index == i && store_mode == FORCE_FIELD) ||
         (target_descriptors->GetValue(i) != old_descriptors->GetValue(i))) {
       Handle<HeapType> old_field_type = (old_details.type() == FIELD)
           ? handle(old_descriptors->GetFieldType(i), isolate)
           : old_descriptors->GetValue(i)->OptimalType(
               isolate, target_details.representation());
       Handle<HeapType> target_field_type = (target_details.type() == FIELD)
           ? handle(target_descriptors->GetFieldType(i), isolate)
           : target_descriptors->GetValue(i)->OptimalType(
               isolate, target_details.representation());
       target_field_type = GeneralizeFieldType(
           target_field_type, old_field_type, isolate);
       if (modify_index == i) {
         target_field_type = GeneralizeFieldType(
             target_field_type, new_field_type, isolate);
       }
       FieldDescriptor d(target_key,
                         current_offset++,
                         target_field_type,
                         target_details.attributes(),
                         target_details.representation());
       new_descriptors->Set(i, &d);
     } else {
       DCHECK_NE(FIELD, target_details.type());
       Descriptor d(target_key,
                    handle(target_descriptors->GetValue(i), isolate),
                    target_details);
       new_descriptors->Set(i, &d);
     }
   }
  
   // |target_nof| -> |old_nof|
   for (int i = target_nof; i < old_nof; ++i) {
     PropertyDetails old_details = old_descriptors->GetDetails(i);
     Handle<Name> old_key(old_descriptors->GetKey(i), isolate);
     if (modify_index == i) {
       old_details = old_details.CopyWithRepresentation(
           new_representation.generalize(old_details.representation()));
     }
     if (old_details.type() == FIELD) {
       Handle<HeapType> old_field_type(
           old_descriptors->GetFieldType(i), isolate);
       if (modify_index == i) {
         old_field_type = GeneralizeFieldType(
             old_field_type, new_field_type, isolate);
       }
       FieldDescriptor d(old_key,
                         current_offset++,
                         old_field_type,
                         old_details.attributes(),
                         old_details.representation());
       new_descriptors->Set(i, &d);
     } else {
       DCHECK(old_details.type() == CONSTANT || old_details.type() == CALLBACKS);
       if (modify_index == i && store_mode == FORCE_FIELD) {
         FieldDescriptor d(old_key,
                           current_offset++,
                           GeneralizeFieldType(
                               old_descriptors->GetValue(i)->OptimalType(
                                   isolate, old_details.representation()),
                               new_field_type, isolate),
                           old_details.attributes(),
                           old_details.representation());
         new_descriptors->Set(i, &d);
       } else {
         DCHECK_NE(FIELD, old_details.type());
         Descriptor d(old_key,
                      handle(old_descriptors->GetValue(i), isolate),
                      old_details);
         new_descriptors->Set(i, &d);
       }
     }
   }
  
   new_descriptors->Sort();
  
   DCHECK(store_mode != FORCE_FIELD ||
          new_descriptors->GetDetails(modify_index).type() == FIELD);
  
   Handle<Map> split_map(root_map->FindLastMatchMap(
           root_nof, old_nof, *new_descriptors), isolate);
   int split_nof = split_map->NumberOfOwnDescriptors();
   DCHECK_NE(old_nof, split_nof);
  
   split_map->DeprecateTarget(
       old_descriptors->GetKey(split_nof), *new_descriptors);
  
   if (FLAG_trace_generalization) {
     PropertyDetails old_details = old_descriptors->GetDetails(modify_index);
     PropertyDetails new_details = new_descriptors->GetDetails(modify_index);
     Handle<HeapType> old_field_type = (old_details.type() == FIELD)
         ? handle(old_descriptors->GetFieldType(modify_index), isolate)
         : HeapType::Constant(handle(old_descriptors->GetValue(modify_index),
                                     isolate), isolate);
     Handle<HeapType> new_field_type = (new_details.type() == FIELD)
         ? handle(new_descriptors->GetFieldType(modify_index), isolate)
         : HeapType::Constant(handle(new_descriptors->GetValue(modify_index),
                                     isolate), isolate);
     old_map->PrintGeneralization(
         stdout, "", modify_index, split_nof, old_nof,
         old_details.type() == CONSTANT && store_mode == FORCE_FIELD,
         old_details.representation(), new_details.representation(),
         *old_field_type, *new_field_type);
   }
  
   // Add missing transitions.
   Handle<Map> new_map = split_map;
   for (int i = split_nof; i < old_nof; ++i) {
     new_map = CopyInstallDescriptors(new_map, i, new_descriptors);
   }
   new_map->set_owns_descriptors(true);
   return new_map;
 }

References v8::internal::DescriptorArray::Allocate(), v8::internal::CALLBACKS, v8::internal::CONSTANT, v8::internal::TypeImpl< Config >::Constant(), DCHECK, DCHECK_EQ, DCHECK_NE, v8::internal::FIELD, v8::internal::Representation::fits_into(), v8::internal::FORCE_FIELD, v8::internal::Representation::generalize(), v8::internal::handle(), v8::internal::Representation::IsDouble(), v8::internal::Representation::IsNone(), v8::internal::TransitionArray::kNotFound, v8::internal::Max(), and v8::None.

Referenced by v8::internal::JSObject::GeneralizeFieldRepresentation().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetBackPointer()

Object * v8::internal::Map::GetBackPointer ( )

inline

Definition at line 5134 of file objects-inl.h.

                             {
   Object* object = READ_FIELD(this, kTransitionsOrBackPointerOffset);
   if (object->IsDescriptorArray()) {
     return TransitionArray::cast(object)->back_pointer_storage();
   } else {
     DCHECK(object->IsMap() || object->IsUndefined());
     return object;
   }
 }

References v8::internal::TransitionArray::back_pointer_storage(), v8::internal::TransitionArray::cast(), DCHECK, kTransitionsOrBackPointerOffset, and READ_FIELD.

Referenced by DeprecateTarget(), EnsureDescriptorSlack(), FindFieldOwner(), FindRootMap(), v8::internal::TransitionArray::NewWith(), and SetBackPointer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetInitialElements()

FixedArrayBase * v8::internal::Map::GetInitialElements ( )

inline

Definition at line 2891 of file objects-inl.h.

                                         {
   if (has_fast_smi_or_object_elements() ||
       has_fast_double_elements()) {
     DCHECK(!GetHeap()->InNewSpace(GetHeap()->empty_fixed_array()));
     return GetHeap()->empty_fixed_array();
   } else if (has_external_array_elements()) {
     ExternalArray* empty_array = GetHeap()->EmptyExternalArrayForMap(this);
     DCHECK(!GetHeap()->InNewSpace(empty_array));
     return empty_array;
   } else if (has_fixed_typed_array_elements()) {
     FixedTypedArrayBase* empty_array =
       GetHeap()->EmptyFixedTypedArrayForMap(this);
     DCHECK(!GetHeap()->InNewSpace(empty_array));
     return empty_array;
   } else {
     UNREACHABLE();
   }
   return NULL;
 }

References DCHECK, v8::internal::Heap::EmptyExternalArrayForMap(), v8::internal::Heap::EmptyFixedTypedArrayForMap(), v8::internal::HeapObject::GetHeap(), has_external_array_elements(), has_fast_double_elements(), has_fast_smi_or_object_elements(), has_fixed_typed_array_elements(), NULL, and UNREACHABLE.

Referenced by v8::internal::JSObject::initialize_elements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetInObjectPropertyOffset()

int v8::internal::Map::GetInObjectPropertyOffset ( int index )

inline

Definition at line 4251 of file objects-inl.h.

                                             {
   // Adjust for the number of properties stored in the object.
   index -= inobject_properties();
   DCHECK(index <= 0);
   return instance_size() + (index * kPointerSize);
 }

References DCHECK, inobject_properties(), instance_size(), and v8::internal::kPointerSize.

Referenced by v8::internal::JSObject::GetInObjectPropertyOffset().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetLastDescriptorDetails()

PropertyDetails v8::internal::Map::GetLastDescriptorDetails ( )

inline

Definition at line 2867 of file objects-inl.h.

                                               {
   return instance_descriptors()->GetDetails(LastAdded());
 }

References LastAdded().

Referenced by v8::internal::TransitionArray::GetTargetDetails(), and v8::internal::JSObject::MigrateToNewProperty().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetPrototypeTransition()

Handle< Map > v8::internal::Map::GetPrototypeTransition	(	Handle< Map >	map,
		Handle< Object >	prototype
	)

staticprivate

Definition at line 11267 of file objects.cc.

                                                                   {
   FixedArray* cache = map->GetPrototypeTransitions();
   int number_of_transitions = map->NumberOfProtoTransitions();
   const int proto_offset =
       kProtoTransitionHeaderSize + kProtoTransitionPrototypeOffset;
   const int map_offset = kProtoTransitionHeaderSize + kProtoTransitionMapOffset;
   const int step = kProtoTransitionElementsPerEntry;
   for (int i = 0; i < number_of_transitions; i++) {
     if (cache->get(proto_offset + i * step) == *prototype) {
       Object* result = cache->get(map_offset + i * step);
       return Handle<Map>(Map::cast(result));
     }
   }
   return Handle<Map>();
 }

References v8::internal::FixedArray::get(), GetPrototypeTransitions(), kProtoTransitionElementsPerEntry, kProtoTransitionHeaderSize, kProtoTransitionMapOffset, kProtoTransitionPrototypeOffset, v8::internal::HeapObject::map(), and NumberOfProtoTransitions().

Here is the call graph for this function:

◆ GetPrototypeTransitions()

FixedArray * v8::internal::Map::GetPrototypeTransitions ( )

inline

Definition at line 5181 of file objects-inl.h.

                                          {
   if (!HasTransitionArray()) return GetHeap()->empty_fixed_array();
   if (!transitions()->HasPrototypeTransitions()) {
     return GetHeap()->empty_fixed_array();
   }
   return transitions()->GetPrototypeTransitions();
 }

References v8::internal::HeapObject::GetHeap(), HasPrototypeTransitions(), and HasTransitionArray().

Referenced by GetPrototypeTransition(), PutPrototypeTransition(), SetPrototypeTransitions(), and ZapPrototypeTransitions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetTransition()

Map * v8::internal::Map::GetTransition ( int transition_index )

inline

Definition at line 5170 of file objects-inl.h.

                                             {
   return transitions()->GetTarget(transition_index);
 }

Referenced by LookupTransition(), TransitionToAccessorProperty(), TransitionToDataProperty(), and TryUpdateInternal().

Here is the caller graph for this function:

◆ has_code_cache()

bool v8::internal::Map::has_code_cache ( )

inline

Definition at line 4520 of file objects-inl.h.

                          {
   return code_cache() != GetIsolate()->heap()->empty_fixed_array();
 }

References v8::internal::HeapObject::GetIsolate(), and v8::internal::Isolate::heap().

Referenced by v8::internal::MarkCompactMarkingVisitor::ObjectStatsTracker< MarkCompactMarkingVisitor::kVisitMap >::Visit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_dictionary_elements()

bool v8::internal::Map::has_dictionary_elements ( )

inline

Definition at line 5768 of file objects.h.

                                         {
     return IsDictionaryElementsKind(elements_kind());
   }

References v8::internal::IsDictionaryElementsKind().

Here is the call graph for this function:

◆ has_external_array_elements()

bool v8::internal::Map::has_external_array_elements ( )

inline

Definition at line 5760 of file objects.h.

                                             {
     return IsExternalArrayElementsKind(elements_kind());
   }

References v8::internal::IsExternalArrayElementsKind().

Referenced by GetInitialElements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_fast_double_elements()

bool v8::internal::Map::has_fast_double_elements ( )

inline

Definition at line 5748 of file objects.h.

                                          {
     return IsFastDoubleElementsKind(elements_kind());
   }

References v8::internal::IsFastDoubleElementsKind().

Referenced by GetInitialElements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_fast_elements()

bool v8::internal::Map::has_fast_elements ( )

inline

Definition at line 5752 of file objects.h.

                                   {
     return IsFastElementsKind(elements_kind());
   }

References v8::internal::IsFastElementsKind().

Here is the call graph for this function:

◆ has_fast_object_elements()

bool v8::internal::Map::has_fast_object_elements ( )

inline

Definition at line 5740 of file objects.h.

                                          {
     return IsFastObjectElementsKind(elements_kind());
   }

References v8::internal::IsFastObjectElementsKind().

Referenced by v8::internal::JSFunction::EnsureHasInitialMap().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_fast_smi_elements()

bool v8::internal::Map::has_fast_smi_elements ( )

inline

Definition at line 5735 of file objects.h.

                                       {
     return IsFastSmiElementsKind(elements_kind());
   }

References v8::internal::IsFastSmiElementsKind().

Here is the call graph for this function:

◆ has_fast_smi_or_object_elements()

bool v8::internal::Map::has_fast_smi_or_object_elements ( )

inline

Definition at line 5744 of file objects.h.

                                                 {
     return IsFastSmiOrObjectElementsKind(elements_kind());
   }

References v8::internal::IsFastSmiOrObjectElementsKind().

Referenced by GetInitialElements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_fixed_typed_array_elements()

bool v8::internal::Map::has_fixed_typed_array_elements ( )

inline

Definition at line 5764 of file objects.h.

                                                {
     return IsFixedTypedArrayElementsKind(elements_kind());
   }

References v8::internal::IsFixedTypedArrayElementsKind().

Referenced by GetInitialElements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_indexed_interceptor()

bool v8::internal::Map::has_indexed_interceptor ( )

inline

Definition at line 5691 of file objects.h.

                                         {
     return ((1 << kHasIndexedInterceptor) & bit_field()) != 0;
   }

Referenced by v8::internal::JSObject::HasIndexedInterceptor().

Here is the caller graph for this function:

◆ has_instance_call_handler()

bool v8::internal::Map::has_instance_call_handler ( )

inline

Definition at line 4455 of file objects-inl.h.

                                     {
   return HasInstanceCallHandler::decode(bit_field3());
 }

References bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::decode().

Referenced by v8::internal::CheckEquivalent(), and v8::internal::HandleApiCallAsFunctionOrConstructor().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_named_interceptor()

bool v8::internal::Map::has_named_interceptor ( )

inline

Definition at line 5682 of file objects.h.

                                       {
     return ((1 << kHasNamedInterceptor) & bit_field()) != 0;
   }

Referenced by v8::internal::JSObject::HasNamedInterceptor().

Here is the caller graph for this function:

◆ has_non_instance_prototype()

bool v8::internal::Map::has_non_instance_prototype ( )

inline

Definition at line 4372 of file objects-inl.h.

                                      {
   return ((1 << kHasNonInstancePrototype) & bit_field()) != 0;
 }

References bit_field(), and kHasNonInstancePrototype.

Referenced by v8::internal::JSFunction::has_prototype().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ has_sloppy_arguments_elements()

bool v8::internal::Map::has_sloppy_arguments_elements ( )

inline

Definition at line 5756 of file objects.h.

                                               {
     return elements_kind() == SLOPPY_ARGUMENTS_ELEMENTS;
   }

References v8::internal::SLOPPY_ARGUMENTS_ELEMENTS.

◆ has_slow_elements_kind()

bool v8::internal::Map::has_slow_elements_kind ( )

inline

Definition at line 5772 of file objects.h.

                                        {
     return elements_kind() == DICTIONARY_ELEMENTS
         || elements_kind() == SLOPPY_ARGUMENTS_ELEMENTS;
   }

References v8::internal::DICTIONARY_ELEMENTS, and v8::internal::SLOPPY_ARGUMENTS_ELEMENTS.

◆ HasElementsTransition()

bool v8::internal::Map::HasElementsTransition ( )

inline

Definition at line 5145 of file objects-inl.h.

                                 {
   return HasTransitionArray() && transitions()->HasElementsTransition();
 }

References HasTransitionArray().

Referenced by CopyAsElementsKind(), and v8::internal::HashTable< MapCache, MapCacheShape, HashTableKey * >::New().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Hash()

int v8::internal::Map::Hash ( )

Definition at line 9019 of file objects.cc.

               {
   // For performance reasons we only hash the 3 most variable fields of a map:
   // constructor, prototype and bit_field2. For predictability reasons we
   // use objects' offsets in respective pages for hashing instead of raw
   // addresses.
  
   // Shift away the tag.
   int hash = ObjectAddressForHashing(constructor()) >> 2;
  
   // XOR-ing the prototype and constructor directly yields too many zero bits
   // when the two pointers are close (which is fairly common).
   // To avoid this we shift the prototype bits relatively to the constructor.
   hash ^= ObjectAddressForHashing(prototype()) << (32 - kPageSizeBits);
  
   return hash ^ (hash >> 16) ^ bit_field2();
 }

References bit_field2(), kPageSizeBits, and v8::internal::ObjectAddressForHashing().

Referenced by v8::internal::NormalizedMapCache::GetIndex().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasPrototypeTransitions()

bool v8::internal::Map::HasPrototypeTransitions ( )

inline

Definition at line 5205 of file objects-inl.h.

                                   {
   return HasTransitionArray() && transitions()->HasPrototypeTransitions();
 }

References HasTransitionArray().

Referenced by GetPrototypeTransitions(), and SetPrototypeTransitions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ HasTransitionArray()

bool v8::internal::Map::HasTransitionArray ( ) const

inline

Definition at line 5150 of file objects-inl.h.

                                    {
   Object* object = READ_FIELD(this, kTransitionsOrBackPointerOffset);
   return object->IsTransitionArray();
 }

References kTransitionsOrBackPointerOffset, and READ_FIELD.

Referenced by CanHaveMoreTransitions(), v8::internal::TransitionArray::CopyInsert(), ExpectedTransitionKey(), FindLastMatchMap(), FindTransitionToField(), GetPrototypeTransitions(), HasElementsTransition(), HasPrototypeTransitions(), SearchTransition(), and v8::internal::MarkCompactMarkingVisitor::ObjectStatsTracker< MarkCompactMarkingVisitor::kVisitMap >::Visit().

Here is the caller graph for this function:

◆ IndexInCodeCache()

int v8::internal::Map::IndexInCodeCache	(	Object *	name,
		Code *	code
	)

Definition at line 7057 of file objects.cc.

                                                   {
   // Get the internal index if a code cache exists.
   if (!code_cache()->IsFixedArray()) {
     return CodeCache::cast(code_cache())->GetIndex(name, code);
   }
   return -1;
 }

References name.

◆ init_back_pointer()

void v8::internal::Map::init_back_pointer ( Object * undefined )

inline

Definition at line 5245 of file objects-inl.h.

                                              {
   DCHECK(undefined->IsUndefined());
   WRITE_FIELD(this, kTransitionsOrBackPointerOffset, undefined);
 }

References DCHECK, kTransitionsOrBackPointerOffset, and WRITE_FIELD.

◆ InitializeDescriptors()

void v8::internal::Map::InitializeDescriptors ( DescriptorArray * descriptors )

inline

Definition at line 5102 of file objects-inl.h.

                                                             {
   int len = descriptors->number_of_descriptors();
   set_instance_descriptors(descriptors);
   SetNumberOfOwnDescriptors(len);
 }

References v8::internal::DescriptorArray::number_of_descriptors(), and SetNumberOfOwnDescriptors().

Here is the call graph for this function:

◆ InitialPropertiesLength()

int v8::internal::Map::InitialPropertiesLength ( )

inline

Definition at line 6066 of file objects.h.

                                 {
     return pre_allocated_property_fields() + unused_property_fields() -
         inobject_properties();
   }

◆ inobject_properties()

int v8::internal::Map::inobject_properties ( )

inline

Definition at line 4241 of file objects-inl.h.

                              {
   return READ_BYTE_FIELD(this, kInObjectPropertiesOffset);
 }

References kInObjectPropertiesOffset, and READ_BYTE_FIELD.

Referenced by v8::internal::JSObject::AllocateStorageForMap(), CopyDropDescriptors(), CopyNormalized(), EquivalentToForNormalization(), GetInObjectPropertyOffset(), v8::internal::JSObject::GetInternalFieldCount(), and TooManyFastProperties().

Here is the caller graph for this function:

◆ instance_size()

int v8::internal::Map::instance_size ( )

inline

Definition at line 4235 of file objects-inl.h.

                        {
   return NOBARRIER_READ_BYTE_FIELD(
       this, kInstanceSizeOffset) << kPointerSizeLog2;
 }

References kInstanceSizeOffset, v8::internal::kPointerSizeLog2, and NOBARRIER_READ_BYTE_FIELD.

Referenced by CopyDropDescriptors(), CopyNormalized(), GetInObjectPropertyOffset(), v8::internal::JSObject::InitializeBody(), v8::internal::JSObject::MigrateFastToSlow(), v8::internal::HeapObject::SizeFromMap(), and v8::internal::JSObject::BodyDescriptor::SizeOf().

Here is the caller graph for this function:

◆ instance_type()

InstanceType v8::internal::Map::instance_type ( )

inline

Definition at line 4323 of file objects-inl.h.

                                 {
   return static_cast<InstanceType>(READ_BYTE_FIELD(this, kInstanceTypeOffset));
 }

References kInstanceTypeOffset, and READ_BYTE_FIELD.

Referenced by v8::internal::Heap::AllowedToBeMigrated(), v8::internal::CheckEquivalent(), v8::DumpHeapConstants(), v8::internal::ElementsKindForArray(), v8::internal::JSObject::GetHeaderSize(), v8::internal::V8HeapExplorer::GetSystemEntryName(), v8::internal::String::HasOnlyOneByteChars(), v8::internal::String::IsOneByteRepresentation(), v8::internal::String::IsOneByteRepresentationUnderneath(), v8::internal::String::IsTwoByteRepresentation(), v8::internal::String::IsTwoByteRepresentationUnderneath(), v8::internal::HeapObject::MayContainRawValues(), v8::internal::ConsStringIteratorOp::NextLeaf(), RawCopy(), v8::internal::NewSpace::RecordAllocation(), v8::internal::NewSpace::RecordPromotion(), v8::internal::RUNTIME_FUNCTION(), v8::internal::ConsStringIteratorOp::Search(), v8::internal::Serializer::ObjectSerializer::Serialize(), SetBackPointer(), v8::internal::JSFunction::SetInstancePrototype(), v8::internal::HeapObject::SizeFromMap(), and v8::internal::Heap::UpdateAllocationSiteFeedback().

Here is the caller graph for this function:

◆ InstancesNeedRewriting()

bool v8::internal::Map::InstancesNeedRewriting	(	Map *	target,
		int	target_number_of_fields,
		int	target_inobject,
		int	target_unused,
		int *	old_number_of_fields
	)

Definition at line 1844 of file objects.cc.

                                                             {
   // If fields were added (or removed), rewrite the instance.
   *old_number_of_fields = NumberOfFields();
   DCHECK(target_number_of_fields >= *old_number_of_fields);
   if (target_number_of_fields != *old_number_of_fields) return true;
  
   // If smi descriptors were replaced by double descriptors, rewrite.
   DescriptorArray* old_desc = instance_descriptors();
   DescriptorArray* new_desc = target->instance_descriptors();
   int limit = NumberOfOwnDescriptors();
   for (int i = 0; i < limit; i++) {
     if (new_desc->GetDetails(i).representation().IsDouble() !=
         old_desc->GetDetails(i).representation().IsDouble()) {
       return true;
     }
   }
  
   // If no fields were added, and no inobject properties were removed, setting
   // the map is sufficient.
   if (target_inobject == inobject_properties()) return false;
   // In-object slack tracking may have reduced the object size of the new map.
   // In that case, succeed if all existing fields were inobject, and they still
   // fit within the new inobject size.
   DCHECK(target_inobject < inobject_properties());
   if (target_number_of_fields <= target_inobject) {
     DCHECK(target_number_of_fields + target_unused == target_inobject);
     return false;
   }
   // Otherwise, properties will need to be moved to the backing store.
   return true;
 }

◆ is_access_check_needed()

bool v8::internal::Map::is_access_check_needed ( )

inline

Definition at line 4396 of file objects-inl.h.

                                  {
   return ((1 << kIsAccessCheckNeeded) & bit_field()) != 0;
 }

References bit_field(), and kIsAccessCheckNeeded.

Here is the call graph for this function:

◆ is_deprecated()

bool v8::internal::Map::is_deprecated ( )

inline

Definition at line 4465 of file objects-inl.h.

                         {
   return Deprecated::decode(bit_field3());
 }

References bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::decode().

Referenced by v8::internal::JSObject::JSObjectShortPrint(), and Update().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_dictionary_map()

bool v8::internal::Map::is_dictionary_map ( )

inline

Definition at line 4430 of file objects-inl.h.

                             {
   return DictionaryMap::decode(bit_field3());
 }

References bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::decode().

Referenced by PrepareForDataProperty(), PutPrototypeTransition(), RawCopy(), ReconfigureDataProperty(), TransitionToAccessorProperty(), and TransitionToDataProperty().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_extensible()

bool v8::internal::Map::is_extensible ( )

inline

Definition at line 4409 of file objects-inl.h.

                         {
   return ((1 << kIsExtensible) & bit_field2()) != 0;
 }

References bit_field2(), and kIsExtensible.

Here is the call graph for this function:

◆ is_frozen()

bool v8::internal::Map::is_frozen ( )

inline

Definition at line 4505 of file objects-inl.h.

                     {
   return IsFrozen::decode(bit_field3());
 }

References bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::decode().

Referenced by v8::internal::CheckEquivalent().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_hidden_prototype()

bool v8::internal::Map::is_hidden_prototype ( )

inline

Definition at line 5673 of file objects.h.

                                     {
     return ((1 << kIsHiddenPrototype) & bit_field()) != 0;
   }

◆ is_migration_target()

bool v8::internal::Map::is_migration_target ( )

inline

Definition at line 4475 of file objects-inl.h.

                               {
   return IsMigrationTarget::decode(bit_field3());
 }

References bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::decode().

Here is the call graph for this function:

◆ is_observed()

bool v8::internal::Map::is_observed ( )

inline

Definition at line 5714 of file objects.h.

                             {
     return ((1 << kIsObserved) & bit_field()) != 0;
   }

Referenced by CopyForObserved().

Here is the caller graph for this function:

◆ is_prototype_map()

bool v8::internal::Map::is_prototype_map ( )

inline

Definition at line 4418 of file objects-inl.h.

                            {
   return IsPrototypeMapBits::decode(bit_field2());
 }

References bit_field2(), and v8::internal::BitFieldBase< T, shift, size, U >::decode().

Referenced by CopyForObserved(), CopyReplaceDescriptors(), PutPrototypeTransition(), TooManyFastProperties(), and TransitionToAccessorProperty().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_stable()

bool v8::internal::Map::is_stable ( )

inline

Definition at line 4515 of file objects-inl.h.

                     {
   return !IsUnstable::decode(bit_field3());
 }

References bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::decode().

Referenced by CanOmitMapChecks(), and NotifyLeafMapLayoutChange().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_undetectable()

bool v8::internal::Map::is_undetectable ( )

inline

Definition at line 5705 of file objects.h.

                                 {
     return ((1 << kIsUndetectable) & bit_field()) != 0;
   }

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the caller graph for this function:

◆ IsGlobalObjectMap()

bool v8::internal::Map::IsGlobalObjectMap ( )

inline

Definition at line 6138 of file objects.h.

                            {
     const InstanceType type = instance_type();
     return type == JS_GLOBAL_OBJECT_TYPE || type == JS_BUILTINS_OBJECT_TYPE;
   }

References v8::internal::JS_BUILTINS_OBJECT_TYPE, and v8::internal::JS_GLOBAL_OBJECT_TYPE.

Referenced by TransitionToAccessorProperty().

Here is the caller graph for this function:

◆ IsJSGlobalObjectMap()

bool v8::internal::Map::IsJSGlobalObjectMap ( )

inline

Definition at line 6135 of file objects.h.

                              {
     return instance_type() == JS_GLOBAL_OBJECT_TYPE;
   }

References v8::internal::JS_GLOBAL_OBJECT_TYPE.

◆ IsJSGlobalProxyMap()

bool v8::internal::Map::IsJSGlobalProxyMap ( )

inline

Definition at line 6132 of file objects.h.

                             {
     return instance_type() == JS_GLOBAL_PROXY_TYPE;
   }

References v8::internal::JS_GLOBAL_PROXY_TYPE.

◆ IsJSObjectMap()

bool v8::internal::Map::IsJSObjectMap ( )

inline

Definition at line 6125 of file objects.h.

                        {
     return instance_type() >= FIRST_JS_OBJECT_TYPE;
   }

References v8::internal::FIRST_JS_OBJECT_TYPE.

Referenced by v8::internal::AccessorInfo::IsCompatibleReceiverType(), and v8::internal::FunctionTemplateInfo::IsTemplateFor().

Here is the caller graph for this function:

◆ IsJSProxyMap()

bool v8::internal::Map::IsJSProxyMap ( )

inline

Definition at line 6128 of file objects.h.

                       {
     InstanceType type = instance_type();
     return FIRST_JS_PROXY_TYPE <= type && type <= LAST_JS_PROXY_TYPE;
   }

References v8::internal::FIRST_JS_PROXY_TYPE, and v8::internal::LAST_JS_PROXY_TYPE.

◆ IsMapInArrayPrototypeChain()

bool v8::internal::Map::IsMapInArrayPrototypeChain ( )

Definition at line 3280 of file objects.cc.

                                      {
   Isolate* isolate = GetIsolate();
   if (isolate->initial_array_prototype()->map() == this) {
     return true;
   }
  
   if (isolate->initial_object_prototype()->map() == this) {
     return true;
   }
  
   return false;
 }

References v8::internal::HeapObject::GetIsolate().

Here is the call graph for this function:

◆ IsValidElementsTransition()

bool v8::internal::Map::IsValidElementsTransition	(	ElementsKind	from_kind,
		ElementsKind	to_kind
	)

static

Definition at line 12775 of file objects.cc.

                                                           {
   // Transitions can't go backwards.
   if (!IsMoreGeneralElementsKindTransition(from_kind, to_kind)) {
     return false;
   }
  
   // Transitions from HOLEY -> PACKED are not allowed.
   return !IsFastHoleyElementsKind(from_kind) ||
       IsFastHoleyElementsKind(to_kind);
 }

References v8::internal::IsFastHoleyElementsKind(), and v8::internal::IsMoreGeneralElementsKindTransition().

Referenced by v8::internal::HOptimizedGraphBuilder::HandlePolymorphicElementAccess(), and v8::internal::TransitionElements().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LastAdded()

int v8::internal::Map::LastAdded ( )

inline

Definition at line 5938 of file objects.h.

                   {
     int number_of_own_descriptors = NumberOfOwnDescriptors();
     DCHECK(number_of_own_descriptors > 0);
     return number_of_own_descriptors - 1;
   }

References DCHECK.

Referenced by CanBeDeprecated(), v8::internal::TransitionArray::GetKey(), GetLastDescriptorDetails(), v8::internal::JSObject::MigrateToNewProperty(), and v8::internal::BASE_EMBEDDED< Visitor >::TransitionResult().

Here is the caller graph for this function:

◆ LookupDescriptor()

void v8::internal::Map::LookupDescriptor	(	JSObject *	holder,
		Name *	name,
		LookupResult *	result
	)

inline

Definition at line 2872 of file objects-inl.h.

                                                  {
   DescriptorArray* descriptors = this->instance_descriptors();
   int number = descriptors->SearchWithCache(name, this);
   if (number == DescriptorArray::kNotFound) return result->NotFound();
   result->DescriptorResult(holder, descriptors->GetDetails(number), number);
 }

References v8::internal::DescriptorArray::GetDetails(), v8::internal::DescriptorArray::kNotFound, and name.

Here is the call graph for this function:

◆ LookupElementsTransitionMap()

Map * v8::internal::Map::LookupElementsTransitionMap ( ElementsKind elements_kind )

Definition at line 3273 of file objects.cc.

                                                           {
   Map* to_map = FindClosestElementsTransition(this, to_kind);
   if (to_map->elements_kind() == to_kind) return to_map;
   return NULL;
 }

References elements_kind(), v8::internal::FindClosestElementsTransition(), and NULL.

Referenced by v8::internal::IC::IsTransitionOfMonomorphicTarget().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ LookupTransition()

void v8::internal::Map::LookupTransition	(	JSObject *	holder,
		Name *	name,
		LookupResult *	result
	)

inline

Definition at line 2882 of file objects-inl.h.

                                                  {
   int transition_index = this->SearchTransition(name);
   if (transition_index == TransitionArray::kNotFound) return result->NotFound();
   result->TransitionResult(holder, this->GetTransition(transition_index));
 }

References GetTransition(), v8::internal::TransitionArray::kNotFound, and SearchTransition().

Here is the call graph for this function:

◆ mark_unstable()

void v8::internal::Map::mark_unstable ( )

inline

Definition at line 4510 of file objects-inl.h.

                         {
   set_bit_field3(IsUnstable::update(bit_field3(), true));
 }

References bit_field3(), set_bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::update().

Referenced by NotifyLeafMapLayoutChange().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NextFreePropertyIndex()

int v8::internal::Map::NextFreePropertyIndex ( )

Definition at line 5663 of file objects.cc.

                                {
   int max_index = -1;
   int number_of_own_descriptors = NumberOfOwnDescriptors();
   DescriptorArray* descs = instance_descriptors();
   for (int i = 0; i < number_of_own_descriptors; i++) {
     if (descs->GetType(i) == FIELD) {
       int current_index = descs->GetFieldIndex(i);
       if (current_index > max_index) max_index = current_index;
     }
   }
   return max_index + 1;
 }

References v8::internal::FIELD, v8::internal::DescriptorArray::GetFieldIndex(), and v8::internal::DescriptorArray::GetType().

Here is the call graph for this function:

◆ Normalize()

Handle< Map > v8::internal::Map::Normalize	(	Handle< Map >	map,
		PropertyNormalizationMode	mode
	)

static

Definition at line 6398 of file objects.cc.

                                                            {
   DCHECK(!fast_map->is_dictionary_map());
  
   Isolate* isolate = fast_map->GetIsolate();
   Handle<Object> maybe_cache(isolate->native_context()->normalized_map_cache(),
                              isolate);
   bool use_cache = !maybe_cache->IsUndefined();
   Handle<NormalizedMapCache> cache;
   if (use_cache) cache = Handle<NormalizedMapCache>::cast(maybe_cache);
  
   Handle<Map> new_map;
   if (use_cache && cache->Get(fast_map, mode).ToHandle(&new_map)) {
 #ifdef VERIFY_HEAP
     if (FLAG_verify_heap) new_map->DictionaryMapVerify();
 #endif
 #ifdef ENABLE_SLOW_DCHECKS
     if (FLAG_enable_slow_asserts) {
       // The cached map should match newly created normalized map bit-by-bit,
       // except for the code cache, which can contain some ics which can be
       // applied to the shared map.
       Handle<Map> fresh = Map::CopyNormalized(fast_map, mode);
  
       DCHECK(memcmp(fresh->address(),
                     new_map->address(),
                     Map::kCodeCacheOffset) == 0);
       STATIC_ASSERT(Map::kDependentCodeOffset ==
                     Map::kCodeCacheOffset + kPointerSize);
       int offset = Map::kDependentCodeOffset + kPointerSize;
       DCHECK(memcmp(fresh->address() + offset,
                     new_map->address() + offset,
                     Map::kSize - offset) == 0);
     }
 #endif
   } else {
     new_map = Map::CopyNormalized(fast_map, mode);
     if (use_cache) {
       cache->Set(fast_map, new_map);
       isolate->counters()->normalized_maps()->Increment();
     }
   }
   fast_map->NotifyLeafMapLayoutChange();
   return new_map;
 }

References v8::internal::Handle< T >::cast(), CopyNormalized(), v8::internal::Isolate::counters(), DCHECK, v8::internal::FLAG_enable_slow_asserts, kCodeCacheOffset, kDependentCodeOffset, v8::internal::kPointerSize, kSize, mode(), v8::internal::Isolate::native_context(), and v8::internal::HeapObject::STATIC_ASSERT().

Referenced by v8::internal::JSObject::NormalizeProperties(), TransitionToAccessorProperty(), and TransitionToDataProperty().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NotifyLeafMapLayoutChange()

void v8::internal::Map::NotifyLeafMapLayoutChange ( )

inlineprivate

Definition at line 4539 of file objects-inl.h.

                                     {
   if (is_stable()) {
     mark_unstable();
     dependent_code()->DeoptimizeDependentCodeGroup(
         GetIsolate(),
         DependentCode::kPrototypeCheckGroup);
   }
 }

References v8::internal::dependent_code, v8::internal::HeapObject::GetIsolate(), is_stable(), v8::internal::DependentCode::kPrototypeCheckGroup, and mark_unstable().

Referenced by CopyDropDescriptors().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NumberOfDescribedProperties()

int v8::internal::Map::NumberOfDescribedProperties	(	DescriptorFlag	which = `OWN_DESCRIPTORS`,
		PropertyAttributes	filter = `NONE`
	)

Definition at line 5646 of file objects.cc.

                                                                 {
   int result = 0;
   DescriptorArray* descs = instance_descriptors();
   int limit = which == ALL_DESCRIPTORS
       ? descs->number_of_descriptors()
       : NumberOfOwnDescriptors();
   for (int i = 0; i < limit; i++) {
     if ((descs->GetDetails(i).attributes() & filter) == 0 &&
         !FilterKey(descs->GetKey(i), filter)) {
       result++;
     }
   }
   return result;
 }

References v8::internal::ALL_DESCRIPTORS, v8::internal::FilterKey(), v8::internal::DescriptorArray::GetDetails(), v8::internal::DescriptorArray::GetKey(), and v8::internal::DescriptorArray::number_of_descriptors().

Referenced by v8::internal::JSObject::NumberOfOwnProperties().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NumberOfFields()

int v8::internal::Map::NumberOfFields ( )

Definition at line 2095 of file objects.cc.

                         {
   DescriptorArray* descriptors = instance_descriptors();
   int result = 0;
   for (int i = 0; i < NumberOfOwnDescriptors(); i++) {
     if (descriptors->GetDetails(i).type() == FIELD) result++;
   }
   return result;
 }

References v8::internal::FIELD, and v8::internal::DescriptorArray::GetDetails().

Referenced by TooManyFastProperties().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ NumberOfOwnDescriptors()

int v8::internal::Map::NumberOfOwnDescriptors ( )

inline

Definition at line 5944 of file objects.h.

                                {
     return NumberOfOwnDescriptorsBits::decode(bit_field3());
   }

Referenced by AppendCallbackDescriptors(), AppendDescriptor(), Copy(), CopyAddDescriptor(), CopyForFreeze(), CopyReplaceDescriptor(), EnsureDescriptorSlack(), v8::internal::V8HeapExplorer::ExtractPropertyReferences(), FindFieldOwner(), GeneralizeAllFieldRepresentations(), GeneralizeFieldType(), v8::internal::GetEnumPropertyKeys(), v8::internal::JSObject::GetOwnPropertyNames(), v8::internal::JSObject::MigrateFastToSlow(), v8::internal::JSObject::NumberOfOwnProperties(), v8::internal::JSObject::PrintInstanceMigration(), ShareDescriptor(), v8::internal::JSObject::SlowReverseLookup(), TransitionToAccessorProperty(), and TryUpdateInternal().

Here is the caller graph for this function:

◆ NumberOfProtoTransitions()

int v8::internal::Map::NumberOfProtoTransitions ( )

inline

Definition at line 5907 of file objects.h.

                                         {
     FixedArray* cache = GetPrototypeTransitions();
     if (cache->length() == 0) return 0;
     return
         Smi::cast(cache->get(kProtoTransitionNumberOfEntriesOffset))->value();
   }

References v8::internal::FixedArray::get(), and v8::internal::FixedArrayBase::length().

Referenced by GetPrototypeTransition(), PutPrototypeTransition(), and SetPrototypeTransitions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ owns_descriptors()

bool v8::internal::Map::owns_descriptors ( )

inline

Definition at line 4445 of file objects-inl.h.

                            {
   return OwnsDescriptors::decode(bit_field3());
 }

References bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::decode().

Referenced by CopyAddDescriptor(), CopyAsElementsKind(), CopyForObserved(), EnsureDescriptorSlack(), set_owns_descriptors(), and v8::internal::MarkCompactMarkingVisitor::ObjectStatsTracker< MarkCompactMarkingVisitor::kVisitMap >::Visit().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ pre_allocated_property_fields()

int v8::internal::Map::pre_allocated_property_fields ( )

inline

Definition at line 4246 of file objects-inl.h.

                                        {
   return READ_BYTE_FIELD(this, kPreAllocatedPropertyFieldsOffset);
 }

References kPreAllocatedPropertyFieldsOffset, and READ_BYTE_FIELD.

Referenced by CopyDropDescriptors(), and v8::internal::JSObject::InitializeBody().

Here is the caller graph for this function:

◆ PrepareForDataProperty()

Handle< Map > v8::internal::Map::PrepareForDataProperty	(	Handle< Map >	old_map,
		int	descriptor_number,
		Handle< Object >	value
	)

static

Definition at line 6738 of file objects.cc.

                                                               {
   // Dictionaries can store any property value.
   if (map->is_dictionary_map()) return map;
  
   // Migrate to the newest map before storing the property.
   map = Update(map);
  
   Handle<DescriptorArray> descriptors(map->instance_descriptors());
  
   if (descriptors->CanHoldValue(descriptor, *value)) return map;
  
   Isolate* isolate = map->GetIsolate();
   Representation representation = value->OptimalRepresentation();
   Handle<HeapType> type = value->OptimalType(isolate, representation);
  
   return GeneralizeRepresentation(map, descriptor, representation, type,
                                   FORCE_FIELD);
 }

References v8::internal::FORCE_FIELD, v8::internal::HeapObject::GetIsolate(), is_dictionary_map(), and v8::internal::HeapObject::map().

Referenced by TransitionToDataProperty().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PrintGeneralization()

void v8::internal::Map::PrintGeneralization	(	FILE *	file,
		const char *	reason,
		int	modify_index,
		int	split,
		int	descriptors,
		bool	constant_to_field,
		Representation	old_representation,
		Representation	new_representation,
		HeapType *	old_field_type,
		HeapType *	new_field_type
	)

private

Definition at line 1303 of file objects.cc.

                                                         {
   OFStream os(file);
   os << "[generalizing ";
   constructor_name()->PrintOn(file);
   os << "] ";
   Name* name = instance_descriptors()->GetKey(modify_index);
   if (name->IsString()) {
     String::cast(name)->PrintOn(file);
   } else {
     os << "{symbol " << static_cast<void*>(name) << "}";
   }
   os << ":";
   if (constant_to_field) {
     os << "c";
   } else {
     os << old_representation.Mnemonic() << "{";
     old_field_type->PrintTo(os, HeapType::SEMANTIC_DIM);
     os << "}";
   }
   os << "->" << new_representation.Mnemonic() << "{";
   new_field_type->PrintTo(os, HeapType::SEMANTIC_DIM);
   os << "} (";
   if (strlen(reason) > 0) {
     os << reason;
   } else {
     os << "+" << (descriptors - split) << " maps";
   }
   os << ") [";
   JavaScriptFrame::PrintTop(GetIsolate(), file, false, true);
   os << "]\n";
 }

References constructor_name(), file(), v8::internal::HeapObject::GetIsolate(), v8::internal::Representation::Mnemonic(), name, v8::internal::String::PrintOn(), v8::internal::TypeImpl< Config >::PrintTo(), v8::internal::JavaScriptFrame::PrintTop(), and v8::internal::TypeImpl< Config >::SEMANTIC_DIM.

Referenced by CopyGeneralizeAllRepresentations(), and GeneralizeFieldType().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ PutPrototypeTransition()

Handle< Map > v8::internal::Map::PutPrototypeTransition	(	Handle< Map >	map,
		Handle< Object >	prototype,
		Handle< Map >	target_map
	)

staticprivate

Definition at line 11285 of file objects.cc.

                                                                 {
   DCHECK(target_map->IsMap());
   DCHECK(HeapObject::cast(*prototype)->map()->IsMap());
   // Don't cache prototype transition if this map is either shared, or a map of
   // a prototype.
   if (map->is_prototype_map()) return map;
   if (map->is_dictionary_map() || !FLAG_cache_prototype_transitions) return map;
  
   const int step = kProtoTransitionElementsPerEntry;
   const int header = kProtoTransitionHeaderSize;
  
   Handle<FixedArray> cache(map->GetPrototypeTransitions());
   int capacity = (cache->length() - header) / step;
   int transitions = map->NumberOfProtoTransitions() + 1;
  
   if (transitions > capacity) {
     if (capacity > kMaxCachedPrototypeTransitions) return map;
  
     // Grow array by factor 2 over and above what we need.
     cache = FixedArray::CopySize(cache, transitions * 2 * step + header);
  
     SetPrototypeTransitions(map, cache);
   }
  
   // Reload number of transitions as GC might shrink them.
   int last = map->NumberOfProtoTransitions();
   int entry = header + last * step;
  
   cache->set(entry + kProtoTransitionPrototypeOffset, *prototype);
   cache->set(entry + kProtoTransitionMapOffset, *target_map);
   map->SetNumberOfProtoTransitions(last + 1);
  
   return map;
 }

References v8::internal::FixedArray::CopySize(), DCHECK, GetPrototypeTransitions(), is_dictionary_map(), is_prototype_map(), kMaxCachedPrototypeTransitions, kProtoTransitionElementsPerEntry, kProtoTransitionHeaderSize, kProtoTransitionMapOffset, kProtoTransitionPrototypeOffset, v8::internal::HeapObject::map(), NumberOfProtoTransitions(), SetNumberOfProtoTransitions(), and SetPrototypeTransitions().

Here is the call graph for this function:

◆ RawCopy()

Handle< Map > v8::internal::Map::RawCopy	(	Handle< Map >	map,
		int	instance_size
	)

staticprivate

Definition at line 6375 of file objects.cc.

                                                            {
   Handle<Map> result = map->GetIsolate()->factory()->NewMap(
       map->instance_type(), instance_size);
   result->set_prototype(map->prototype());
   result->set_constructor(map->constructor());
   result->set_bit_field(map->bit_field());
   result->set_bit_field2(map->bit_field2());
   int new_bit_field3 = map->bit_field3();
   new_bit_field3 = OwnsDescriptors::update(new_bit_field3, true);
   new_bit_field3 = NumberOfOwnDescriptorsBits::update(new_bit_field3, 0);
   new_bit_field3 = EnumLengthBits::update(new_bit_field3,
                                           kInvalidEnumCacheSentinel);
   new_bit_field3 = Deprecated::update(new_bit_field3, false);
   if (!map->is_dictionary_map()) {
     new_bit_field3 = IsUnstable::update(new_bit_field3, false);
   }
   new_bit_field3 = ConstructionCount::update(new_bit_field3,
                                              JSFunction::kNoSlackTracking);
   result->set_bit_field3(new_bit_field3);
   return result;
 }

References bit_field(), bit_field2(), bit_field3(), v8::internal::Isolate::factory(), v8::internal::HeapObject::GetIsolate(), instance_type(), is_dictionary_map(), v8::internal::kInvalidEnumCacheSentinel, v8::internal::JSFunction::kNoSlackTracking, and v8::internal::HeapObject::map().

Here is the call graph for this function:

◆ ReconfigureDataProperty()

Handle< Map > v8::internal::Map::ReconfigureDataProperty	(	Handle< Map >	map,
		int	descriptor,
		PropertyAttributes	attributes
	)

static

Definition at line 6804 of file objects.cc.

                                                                         {
   // Dictionaries have to be reconfigured in-place.
   DCHECK(!map->is_dictionary_map());
  
   // For now, give up on transitioning and just create a unique map.
   // TODO(verwaest/ishell): Cache transitions with different attributes.
   return CopyGeneralizeAllRepresentations(map, descriptor, FORCE_FIELD,
                                           attributes, "attributes mismatch");
 }

References DCHECK, v8::internal::FORCE_FIELD, is_dictionary_map(), and v8::internal::HeapObject::map().

Here is the call graph for this function:

◆ RemoveFromCodeCache()

void v8::internal::Map::RemoveFromCodeCache	(	Name *	name,
		Code *	code,
		int	index
	)

Definition at line 7066 of file objects.cc.

                                                                {
   // No GC is supposed to happen between a call to IndexInCodeCache and
   // RemoveFromCodeCache so the code cache must be there.
   DCHECK(!code_cache()->IsFixedArray());
   CodeCache::cast(code_cache())->RemoveByIndex(name, code, index);
 }

References DCHECK, and name.

◆ RetrieveDescriptorsPointer()

Cell* v8::internal::Map::RetrieveDescriptorsPointer ( )

inline

◆ SearchTransition()

int v8::internal::Map::SearchTransition ( Name * name )

inline

Definition at line 5175 of file objects-inl.h.

                                     {
   if (HasTransitionArray()) return transitions()->Search(name);
   return TransitionArray::kNotFound;
 }

References HasTransitionArray(), v8::internal::TransitionArray::kNotFound, and name.

Referenced by LookupTransition(), TransitionToAccessorProperty(), TransitionToDataProperty(), and TryUpdateInternal().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_bit_field()

void v8::internal::Map::set_bit_field ( byte value )

inline

Definition at line 4348 of file objects-inl.h.

                                   {
   WRITE_BYTE_FIELD(this, kBitFieldOffset, value);
 }

References kBitFieldOffset, and WRITE_BYTE_FIELD.

Referenced by set_function_with_prototype(), set_is_access_check_needed(), and set_non_instance_prototype().

Here is the caller graph for this function:

◆ set_bit_field2()

void v8::internal::Map::set_bit_field2 ( byte value )

inline

Definition at line 4358 of file objects-inl.h.

                                    {
   WRITE_BYTE_FIELD(this, kBitField2Offset, value);
 }

References kBitField2Offset, and WRITE_BYTE_FIELD.

Referenced by set_is_extensible(), and set_is_prototype_map().

Here is the caller graph for this function:

◆ set_bit_field3()

void v8::internal::Map::set_bit_field3 ( uint32_t bits )

inline

Definition at line 5112 of file objects-inl.h.

                                       {
   if (kInt32Size != kPointerSize) {
     WRITE_UINT32_FIELD(this, kBitField3Offset + kInt32Size, 0);
   }
   WRITE_UINT32_FIELD(this, kBitField3Offset, bits);
 }

References v8::internal::kInt32Size, v8::internal::kPointerSize, and WRITE_UINT32_FIELD.

Referenced by deprecate(), freeze(), mark_unstable(), set_construction_count(), set_dictionary_map(), set_done_inobject_slack_tracking(), set_has_instance_call_handler(), set_migration_target(), and set_owns_descriptors().

Here is the caller graph for this function:

◆ set_construction_count()

void v8::internal::Map::set_construction_count ( int value )

inline

Definition at line 4490 of file objects-inl.h.

                                           {
   set_bit_field3(ConstructionCount::update(bit_field3(), value));
 }

References bit_field3(), set_bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::update().

Referenced by v8::internal::JSFunction::CompleteInobjectSlackTracking(), and v8::internal::JSFunction::StartInobjectSlackTracking().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_dictionary_map()

void v8::internal::Map::set_dictionary_map ( bool value )

inline

Definition at line 4423 of file objects-inl.h.

                                        {
   uint32_t new_bit_field3 = DictionaryMap::update(bit_field3(), value);
   new_bit_field3 = IsUnstable::update(new_bit_field3, value);
   set_bit_field3(new_bit_field3);
 }

References bit_field3(), set_bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::update().

Here is the call graph for this function:

◆ set_done_inobject_slack_tracking()

void v8::internal::Map::set_done_inobject_slack_tracking ( bool value )

inline

Definition at line 4480 of file objects-inl.h.

                                                      {
   set_bit_field3(DoneInobjectSlackTracking::update(bit_field3(), value));
 }

References bit_field3(), set_bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::update().

Referenced by v8::internal::JSFunction::StartInobjectSlackTracking().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_elements_kind()

void v8::internal::Map::set_elements_kind ( ElementsKind elements_kind )

inline

Definition at line 5723 of file objects.h.

                                                             {
     DCHECK(elements_kind < kElementsKindCount);
     DCHECK(kElementsKindCount <= (1 << Map::ElementsKindBits::kSize));
     set_bit_field2(Map::ElementsKindBits::update(bit_field2(), elements_kind));
     DCHECK(this->elements_kind() == elements_kind);
   }

References DCHECK, v8::internal::kElementsKindCount, v8::internal::BitFieldBase< T, shift, size, U >::kSize, and v8::internal::BitFieldBase< T, shift, size, U >::update().

Here is the call graph for this function:

◆ set_function_with_prototype()

void v8::internal::Map::set_function_with_prototype ( bool value )

inline

Definition at line 4377 of file objects-inl.h.

                                                 {
   set_bit_field(FunctionWithPrototype::update(bit_field(), value));
 }

References bit_field(), set_bit_field(), and v8::internal::BitFieldBase< T, shift, size, U >::update().

Here is the call graph for this function:

◆ set_has_indexed_interceptor()

void v8::internal::Map::set_has_indexed_interceptor ( )

inline

Definition at line 5687 of file objects.h.

                                             {
     set_bit_field(bit_field() | (1 << kHasIndexedInterceptor));
   }

◆ set_has_instance_call_handler()

void v8::internal::Map::set_has_instance_call_handler ( )

inline

Definition at line 4450 of file objects-inl.h.

                                         {
   set_bit_field3(HasInstanceCallHandler::update(bit_field3(), true));
 }

References bit_field3(), set_bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::update().

Here is the call graph for this function:

◆ set_has_named_interceptor()

void v8::internal::Map::set_has_named_interceptor ( )

inline

Definition at line 5678 of file objects.h.

                                           {
     set_bit_field(bit_field() | (1 << kHasNamedInterceptor));
   }

◆ set_inobject_properties()

void v8::internal::Map::set_inobject_properties ( int value )

inline

Definition at line 4309 of file objects-inl.h.

                                            {
   DCHECK(0 <= value && value < 256);
   WRITE_BYTE_FIELD(this, kInObjectPropertiesOffset, static_cast<byte>(value));
 }

References DCHECK, kInObjectPropertiesOffset, and WRITE_BYTE_FIELD.

Referenced by v8::internal::JSFunction::EnsureHasInitialMap().

Here is the caller graph for this function:

◆ set_instance_size()

void v8::internal::Map::set_instance_size ( int value )

inline

Definition at line 4300 of file objects-inl.h.

                                      {
   DCHECK_EQ(0, value & (kPointerSize - 1));
   value >>= kPointerSizeLog2;
   DCHECK(0 <= value && value < 256);
   NOBARRIER_WRITE_BYTE_FIELD(
       this, kInstanceSizeOffset, static_cast<byte>(value));
 }

References DCHECK, DCHECK_EQ, kInstanceSizeOffset, v8::internal::kPointerSize, v8::internal::kPointerSizeLog2, and NOBARRIER_WRITE_BYTE_FIELD.

◆ set_instance_type()

void v8::internal::Map::set_instance_type ( InstanceType value )

inline

Definition at line 4328 of file objects-inl.h.

                                               {
   WRITE_BYTE_FIELD(this, kInstanceTypeOffset, value);
 }

References kInstanceTypeOffset, and WRITE_BYTE_FIELD.

◆ set_is_access_check_needed()

void v8::internal::Map::set_is_access_check_needed ( bool access_check_needed )

inline

Definition at line 4387 of file objects-inl.h.

                                                              {
   if (access_check_needed) {
     set_bit_field(bit_field() | (1 << kIsAccessCheckNeeded));
   } else {
     set_bit_field(bit_field() & ~(1 << kIsAccessCheckNeeded));
   }
 }

References bit_field(), kIsAccessCheckNeeded, and set_bit_field().

Here is the call graph for this function:

◆ set_is_extensible()

void v8::internal::Map::set_is_extensible ( bool value )

inline

Definition at line 4401 of file objects-inl.h.

                                       {
   if (value) {
     set_bit_field2(bit_field2() | (1 << kIsExtensible));
   } else {
     set_bit_field2(bit_field2() & ~(1 << kIsExtensible));
   }
 }

References bit_field2(), kIsExtensible, and set_bit_field2().

Here is the call graph for this function:

◆ set_is_hidden_prototype()

void v8::internal::Map::set_is_hidden_prototype ( )

inline

Definition at line 5669 of file objects.h.

                                         {
     set_bit_field(bit_field() | (1 << kIsHiddenPrototype));
   }

◆ set_is_observed()

void v8::internal::Map::set_is_observed ( )

inline

Definition at line 5710 of file objects.h.

                                 {
     set_bit_field(bit_field() | (1 << kIsObserved));
   }

◆ set_is_prototype_map()

void v8::internal::Map::set_is_prototype_map ( bool value )

inline

Definition at line 4414 of file objects-inl.h.

                                          {
   set_bit_field2(IsPrototypeMapBits::update(bit_field2(), value));
 }

References bit_field2(), set_bit_field2(), and v8::internal::BitFieldBase< T, shift, size, U >::update().

Here is the call graph for this function:

◆ set_is_undetectable()

void v8::internal::Map::set_is_undetectable ( )

inline

Definition at line 5701 of file objects.h.

                                     {
     set_bit_field(bit_field() | (1 << kIsUndetectable));
   }

◆ set_migration_target()

void v8::internal::Map::set_migration_target ( bool value )

inline

Definition at line 4470 of file objects-inl.h.

                                          {
   set_bit_field3(IsMigrationTarget::update(bit_field3(), value));
 }

References bit_field3(), set_bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::update().

Referenced by v8::internal::JSObject::MigrateInstance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_non_instance_prototype()

void v8::internal::Map::set_non_instance_prototype ( bool value )

inline

Definition at line 4363 of file objects-inl.h.

                                                {
   if (value) {
     set_bit_field(bit_field() | (1 << kHasNonInstancePrototype));
   } else {
     set_bit_field(bit_field() & ~(1 << kHasNonInstancePrototype));
   }
 }

References bit_field(), kHasNonInstancePrototype, and set_bit_field().

Here is the call graph for this function:

◆ set_owns_descriptors()

void v8::internal::Map::set_owns_descriptors ( bool owns_descriptors )

inline

Definition at line 4440 of file objects-inl.h.

                                                     {
   set_bit_field3(OwnsDescriptors::update(bit_field3(), owns_descriptors));
 }

References bit_field3(), owns_descriptors(), set_bit_field3(), and v8::internal::BitFieldBase< T, shift, size, U >::update().

Here is the call graph for this function:

◆ set_pre_allocated_property_fields()

void v8::internal::Map::set_pre_allocated_property_fields ( int value )

inline

Definition at line 4315 of file objects-inl.h.

                                                      {
   DCHECK(0 <= value && value < 256);
   WRITE_BYTE_FIELD(this,
                    kPreAllocatedPropertyFieldsOffset,
                    static_cast<byte>(value));
 }

References DCHECK, kPreAllocatedPropertyFieldsOffset, and WRITE_BYTE_FIELD.

◆ set_unused_property_fields()

void v8::internal::Map::set_unused_property_fields ( int value )

inline

Definition at line 4338 of file objects-inl.h.

                                               {
   WRITE_BYTE_FIELD(this, kUnusedPropertyFieldsOffset, Min(value, 255));
 }

References kUnusedPropertyFieldsOffset, v8::internal::Min(), and WRITE_BYTE_FIELD.

Referenced by v8::internal::JSFunction::EnsureHasInitialMap().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_visitor_id()

void v8::internal::Map::set_visitor_id ( int visitor_id )

inline

Definition at line 4229 of file objects-inl.h.

                                {
   DCHECK(0 <= id && id < 256);
   WRITE_BYTE_FIELD(this, kVisitorIdOffset, static_cast<byte>(id));
 }

References DCHECK, kVisitorIdOffset, and WRITE_BYTE_FIELD.

◆ SetBackPointer()

void v8::internal::Map::SetBackPointer	(	Object *	value,
		WriteBarrierMode	mode = `UPDATE_WRITE_BARRIER`
	)

inline

Definition at line 5251 of file objects-inl.h.

                                                              {
   DCHECK(instance_type() >= FIRST_JS_RECEIVER_TYPE);
   DCHECK((value->IsUndefined() && GetBackPointer()->IsMap()) ||
          (value->IsMap() && GetBackPointer()->IsUndefined()));
   Object* object = READ_FIELD(this, kTransitionsOrBackPointerOffset);
   if (object->IsTransitionArray()) {
     TransitionArray::cast(object)->set_back_pointer_storage(value);
   } else {
     WRITE_FIELD(this, kTransitionsOrBackPointerOffset, value);
     CONDITIONAL_WRITE_BARRIER(
         GetHeap(), this, kTransitionsOrBackPointerOffset, value, mode);
   }
 }

References v8::internal::TransitionArray::cast(), CONDITIONAL_WRITE_BARRIER, DCHECK, v8::internal::FIRST_JS_RECEIVER_TYPE, GetBackPointer(), v8::internal::HeapObject::GetHeap(), instance_type(), kTransitionsOrBackPointerOffset, mode(), READ_FIELD, v8::internal::TransitionArray::set_back_pointer_storage(), and WRITE_FIELD.

Referenced by v8::internal::MarkCompactCollector::ClearMapBackPointer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetEnumLength()

void v8::internal::Map::SetEnumLength ( int length )

inline

Definition at line 5959 of file objects.h.

                                  {
     if (length != kInvalidEnumCacheSentinel) {
       DCHECK(length >= 0);
       DCHECK(length == 0 || instance_descriptors()->HasEnumCache());
       DCHECK(length <= NumberOfOwnDescriptors());
     }
     set_bit_field3(EnumLengthBits::update(bit_field3(), length));
   }

References DCHECK, and v8::internal::kInvalidEnumCacheSentinel.

Referenced by DeprecateTarget(), and v8::internal::GetEnumPropertyKeys().

Here is the caller graph for this function:

◆ SetNumberOfOwnDescriptors()

void v8::internal::Map::SetNumberOfOwnDescriptors ( int number )

inline

Definition at line 5948 of file objects.h.

                                              {
     DCHECK(number <= instance_descriptors()->number_of_descriptors());
     set_bit_field3(NumberOfOwnDescriptorsBits::update(bit_field3(), number));
   }

References DCHECK.

Referenced by AppendCallbackDescriptors(), AppendDescriptor(), and InitializeDescriptors().

Here is the caller graph for this function:

◆ SetNumberOfProtoTransitions()

void v8::internal::Map::SetNumberOfProtoTransitions ( int value )

inline

Definition at line 5914 of file objects.h.

                                                      {
     FixedArray* cache = GetPrototypeTransitions();
     DCHECK(cache->length() != 0);
     cache->set(kProtoTransitionNumberOfEntriesOffset, Smi::FromInt(value));
   }

References DCHECK, v8::internal::Smi::FromInt(), v8::internal::FixedArrayBase::length(), v8::internal::FixedArray::set(), and v8::internal::Smi::value().

Referenced by PutPrototypeTransition(), and SetPrototypeTransitions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetPrototypeTransitions()

void v8::internal::Map::SetPrototypeTransitions	(	Handle< Map >	map,
		Handle< FixedArray >	prototype_transitions
	)

inlinestaticprivate

Definition at line 5190 of file objects-inl.h.

                                                            {
   EnsureHasTransitionArray(map);
   int old_number_of_transitions = map->NumberOfProtoTransitions();
 #ifdef DEBUG
   if (map->HasPrototypeTransitions()) {
     DCHECK(map->GetPrototypeTransitions() != *proto_transitions);
     map->ZapPrototypeTransitions();
   }
 #endif
   map->transitions()->SetPrototypeTransitions(*proto_transitions);
   map->SetNumberOfProtoTransitions(old_number_of_transitions);
 }

References DCHECK, v8::internal::EnsureHasTransitionArray(), GetPrototypeTransitions(), HasPrototypeTransitions(), v8::internal::HeapObject::map(), NumberOfProtoTransitions(), SetNumberOfProtoTransitions(), SetPrototypeTransitions(), and ZapPrototypeTransitions().

Referenced by PutPrototypeTransition(), and SetPrototypeTransitions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ShareDescriptor()

Handle< Map > v8::internal::Map::ShareDescriptor	(	Handle< Map >	map,
		Handle< DescriptorArray >	descriptors,
		Descriptor *	descriptor
	)

staticprivate

Definition at line 6483 of file objects.cc.

                                                          {
   // Sanity check. This path is only to be taken if the map owns its descriptor
   // array, implying that its NumberOfOwnDescriptors equals the number of
   // descriptors in the descriptor array.
   DCHECK(map->NumberOfOwnDescriptors() ==
          map->instance_descriptors()->number_of_descriptors());
  
   Handle<Map> result = CopyDropDescriptors(map);
   Handle<Name> name = descriptor->GetKey();
  
   // Ensure there's space for the new descriptor in the shared descriptor array.
   if (descriptors->NumberOfSlackDescriptors() == 0) {
     int old_size = descriptors->number_of_descriptors();
     if (old_size == 0) {
       descriptors = DescriptorArray::Allocate(map->GetIsolate(), 0, 1);
     } else {
       EnsureDescriptorSlack(map, old_size < 4 ? 1 : old_size / 2);
       descriptors = handle(map->instance_descriptors());
     }
   }
  
   {
     DisallowHeapAllocation no_gc;
     descriptors->Append(descriptor);
     result->InitializeDescriptors(*descriptors);
   }
  
   DCHECK(result->NumberOfOwnDescriptors() == map->NumberOfOwnDescriptors() + 1);
   ConnectTransition(map, result, name, SIMPLE_TRANSITION);
  
   return result;
 }

References v8::internal::DescriptorArray::Allocate(), DCHECK, v8::internal::HeapObject::GetIsolate(), v8::internal::handle(), v8::internal::HeapObject::map(), name, NumberOfOwnDescriptors(), and v8::internal::SIMPLE_TRANSITION.

Here is the call graph for this function:

◆ STATIC_ASSERT() [1/2]

v8::internal::Map::STATIC_ASSERT ( kDescriptorIndexBitCount+ kDescriptorIndexBitCount = =20 )

◆ STATIC_ASSERT() [2/2]

v8::internal::Map::STATIC_ASSERT ( kInstanceTypeAndBitFieldOffset = =Internals::kMapInstanceTypeAndBitFieldOffset )

◆ TooManyFastProperties()

bool v8::internal::Map::TooManyFastProperties ( StoreFromKeyed store_mode )

inline

Definition at line 2098 of file objects-inl.h.

                                                          {
   if (unused_property_fields() != 0) return false;
   if (is_prototype_map()) return false;
   int minimum = store_mode == CERTAINLY_NOT_STORE_FROM_KEYED ? 128 : 12;
   int limit = Max(minimum, inobject_properties());
   int external = NumberOfFields() - inobject_properties();
   return external > limit;
 }

References v8::internal::Object::CERTAINLY_NOT_STORE_FROM_KEYED, inobject_properties(), is_prototype_map(), v8::internal::Max(), NumberOfFields(), and unused_property_fields().

Referenced by TransitionToAccessorProperty(), and TransitionToDataProperty().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TransitionElementsTo()

Handle< Map > v8::internal::Map::TransitionElementsTo	(	Handle< Map >	map,
		ElementsKind	to_kind
	)

static

Definition at line 3321 of file objects.cc.

                                                             {
   ElementsKind from_kind = map->elements_kind();
   if (from_kind == to_kind) return map;
  
   Isolate* isolate = map->GetIsolate();
   Context* native_context = isolate->context()->native_context();
   Object* maybe_array_maps = native_context->js_array_maps();
   if (maybe_array_maps->IsFixedArray()) {
     DisallowHeapAllocation no_gc;
     FixedArray* array_maps = FixedArray::cast(maybe_array_maps);
     if (array_maps->get(from_kind) == *map) {
       Object* maybe_transitioned_map = array_maps->get(to_kind);
       if (maybe_transitioned_map->IsMap()) {
         return handle(Map::cast(maybe_transitioned_map));
       }
     }
   }
  
   return TransitionElementsToSlow(map, to_kind);
 }

References v8::internal::Isolate::context(), elements_kind(), v8::internal::FixedArray::get(), v8::internal::HeapObject::GetIsolate(), v8::internal::handle(), v8::internal::HeapObject::map(), and v8::internal::Context::native_context().

Referenced by v8::internal::KeyedStoreIC::ComputeTransitionedMap(), v8::internal::JSObject::GetElementsTransitionMap(), and v8::internal::JSTypedArray::MaterializeArrayBuffer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TransitionElementsToSlow()

Handle< Map > v8::internal::Map::TransitionElementsToSlow	(	Handle< Map >	object,
		ElementsKind	to_kind
	)

staticprivate

Definition at line 3344 of file objects.cc.

                                                                 {
   ElementsKind from_kind = map->elements_kind();
  
   if (from_kind == to_kind) {
     return map;
   }
  
   bool allow_store_transition =
       // Only remember the map transition if there is not an already existing
       // non-matching element transition.
       !map->IsUndefined() && !map->is_dictionary_map() &&
       IsTransitionElementsKind(from_kind);
  
   // Only store fast element maps in ascending generality.
   if (IsFastElementsKind(to_kind)) {
     allow_store_transition &=
         IsTransitionableFastElementsKind(from_kind) &&
         IsMoreGeneralElementsKindTransition(from_kind, to_kind);
   }
  
   if (!allow_store_transition) {
     return Map::CopyAsElementsKind(map, to_kind, OMIT_TRANSITION);
   }
  
   return Map::AsElementsKind(map, to_kind);
 }

References elements_kind(), and v8::internal::HeapObject::map().

Here is the call graph for this function:

◆ TransitionToAccessorProperty()

Handle< Map > v8::internal::Map::TransitionToAccessorProperty	(	Handle< Map >	map,
		Handle< Name >	name,
		AccessorComponent	component,
		Handle< Object >	accessor,
		PropertyAttributes	attributes
	)

static

Definition at line 6816 of file objects.cc.

                                                                              {
   Isolate* isolate = name->GetIsolate();
  
   // Dictionary maps can always have additional data properties.
   if (map->is_dictionary_map()) {
     // For global objects, property cells are inlined. We need to change the
     // map.
     if (map->IsGlobalObjectMap()) return Copy(map);
     return map;
   }
  
   // Migrate to the newest map before transitioning to the new property.
   map = Update(map);
  
   PropertyNormalizationMode mode = map->is_prototype_map()
                                        ? KEEP_INOBJECT_PROPERTIES
                                        : CLEAR_INOBJECT_PROPERTIES;
  
   int index = map->SearchTransition(*name);
   if (index != TransitionArray::kNotFound) {
     Handle<Map> transition(map->GetTransition(index));
     DescriptorArray* descriptors = transition->instance_descriptors();
     // Fast path, assume that we're modifying the last added descriptor.
     int descriptor = transition->LastAdded();
     if (descriptors->GetKey(descriptor) != *name) {
       // If not, search for the descriptor.
       descriptor = descriptors->SearchWithCache(*name, *transition);
     }
  
     if (descriptors->GetDetails(descriptor).type() != CALLBACKS) {
       return Map::Normalize(map, mode);
     }
  
     // TODO(verwaest): Handle attributes better.
     if (descriptors->GetDetails(descriptor).attributes() != attributes) {
       return Map::Normalize(map, mode);
     }
  
     Handle<Object> maybe_pair(descriptors->GetValue(descriptor), isolate);
     if (!maybe_pair->IsAccessorPair()) {
       return Map::Normalize(map, mode);
     }
  
     Handle<AccessorPair> pair = Handle<AccessorPair>::cast(maybe_pair);
     if (pair->get(component) != *accessor) {
       return Map::Normalize(map, mode);
     }
  
     return transition;
   }
  
   Handle<AccessorPair> pair;
   DescriptorArray* old_descriptors = map->instance_descriptors();
   int descriptor = old_descriptors->SearchWithCache(*name, *map);
   if (descriptor != DescriptorArray::kNotFound) {
     PropertyDetails old_details = old_descriptors->GetDetails(descriptor);
     if (old_details.type() != CALLBACKS) {
       return Map::Normalize(map, mode);
     }
  
     if (old_details.attributes() != attributes) {
       return Map::Normalize(map, mode);
     }
  
     Handle<Object> maybe_pair(old_descriptors->GetValue(descriptor), isolate);
     if (!maybe_pair->IsAccessorPair()) {
       return Map::Normalize(map, mode);
     }
  
     Object* current = Handle<AccessorPair>::cast(maybe_pair)->get(component);
     if (current == *accessor) return map;
  
     if (!current->IsTheHole()) {
       return Map::Normalize(map, mode);
     }
  
     pair = AccessorPair::Copy(Handle<AccessorPair>::cast(maybe_pair));
   } else if (map->NumberOfOwnDescriptors() >= kMaxNumberOfDescriptors ||
              map->TooManyFastProperties(CERTAINLY_NOT_STORE_FROM_KEYED)) {
     return Map::Normalize(map, CLEAR_INOBJECT_PROPERTIES);
   } else {
     pair = isolate->factory()->NewAccessorPair();
   }
  
   pair->set(component, *accessor);
   TransitionFlag flag = INSERT_TRANSITION;
   CallbacksDescriptor new_desc(name, pair, attributes);
   return Map::CopyInsertDescriptor(map, &new_desc, flag);
 }

References v8::internal::CALLBACKS, v8::internal::Handle< T >::cast(), v8::internal::Object::CERTAINLY_NOT_STORE_FROM_KEYED, v8::internal::CLEAR_INOBJECT_PROPERTIES, v8::internal::AccessorPair::Copy(), CopyInsertDescriptor(), v8::internal::Isolate::factory(), v8::internal::flag, v8::internal::DescriptorArray::GetDetails(), v8::internal::DescriptorArray::GetKey(), GetTransition(), v8::internal::DescriptorArray::GetValue(), v8::internal::INSERT_TRANSITION, is_dictionary_map(), is_prototype_map(), IsGlobalObjectMap(), v8::internal::KEEP_INOBJECT_PROPERTIES, v8::internal::kMaxNumberOfDescriptors, v8::internal::DescriptorArray::kNotFound, v8::internal::TransitionArray::kNotFound, v8::internal::HeapObject::map(), mode(), name, Normalize(), NumberOfOwnDescriptors(), SearchTransition(), and TooManyFastProperties().

Here is the call graph for this function:

◆ TransitionToDataProperty()

Handle< Map > v8::internal::Map::TransitionToDataProperty	(	Handle< Map >	map,
		Handle< Name >	name,
		Handle< Object >	value,
		PropertyAttributes	attributes,
		StoreFromKeyed	store_mode
	)

static

Definition at line 6759 of file objects.cc.

                                                                      {
   // Dictionary maps can always have additional data properties.
   if (map->is_dictionary_map()) return map;
  
   // Migrate to the newest map before storing the property.
   map = Update(map);
  
   int index = map->SearchTransition(*name);
   if (index != TransitionArray::kNotFound) {
     Handle<Map> transition(map->GetTransition(index));
     int descriptor = transition->LastAdded();
  
     // TODO(verwaest): Handle attributes better.
     DescriptorArray* descriptors = transition->instance_descriptors();
     if (descriptors->GetDetails(descriptor).attributes() != attributes) {
       return Map::Normalize(map, CLEAR_INOBJECT_PROPERTIES);
     }
  
     return Map::PrepareForDataProperty(transition, descriptor, value);
   }
  
   TransitionFlag flag = INSERT_TRANSITION;
   MaybeHandle<Map> maybe_map;
   if (value->IsJSFunction()) {
     maybe_map = Map::CopyWithConstant(map, name, value, attributes, flag);
   } else if (!map->TooManyFastProperties(store_mode)) {
     Isolate* isolate = name->GetIsolate();
     Representation representation = value->OptimalRepresentation();
     Handle<HeapType> type = value->OptimalType(isolate, representation);
     maybe_map =
         Map::CopyWithField(map, name, type, attributes, representation, flag);
   }
  
   Handle<Map> result;
   if (!maybe_map.ToHandle(&result)) {
     return Map::Normalize(map, CLEAR_INOBJECT_PROPERTIES);
   }
  
   return result;
 }

References v8::internal::CLEAR_INOBJECT_PROPERTIES, CopyWithConstant(), CopyWithField(), v8::internal::flag, v8::internal::DescriptorArray::GetDetails(), GetTransition(), v8::internal::INSERT_TRANSITION, is_dictionary_map(), v8::internal::TransitionArray::kNotFound, v8::internal::HeapObject::map(), name, Normalize(), PrepareForDataProperty(), SearchTransition(), and TooManyFastProperties().

Here is the call graph for this function:

◆ TransitionToPrototype()

Handle< Map > v8::internal::Map::TransitionToPrototype	(	Handle< Map >	map,
		Handle< Object >	prototype
	)

static

Definition at line 11646 of file objects.cc.

                                                                  {
   Handle<Map> new_map = GetPrototypeTransition(map, prototype);
   if (new_map.is_null()) {
     new_map = Copy(map);
     PutPrototypeTransition(map, prototype, new_map);
     new_map->set_prototype(*prototype);
   }
   return new_map;
 }

References v8::internal::Handle< T >::is_null(), and v8::internal::HeapObject::map().

Referenced by v8::internal::JSObject::SetPrototype().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TraverseTransitionTree()

void v8::internal::Map::TraverseTransitionTree	(	TraverseCallback	callback,
		void *	data
	)

Definition at line 7257 of file objects.cc.

                                                                       {
   // Make sure that we do not allocate in the callback.
   DisallowHeapAllocation no_allocation;
  
   TraversableMap* current = static_cast<TraversableMap*>(this);
   // Get the root constructor here to restore it later when finished iterating
   // over maps.
   Object* root_constructor = constructor();
   while (true) {
     TraversableMap* child = current->ChildIteratorNext(root_constructor);
     if (child != NULL) {
       child->SetParent(current);
       current = child;
     } else {
       TraversableMap* parent = current->GetAndResetParent();
       callback(current, data);
       if (current == this) break;
       current = parent;
     }
   }
 }

References v8::internal::TraversableMap::ChildIteratorNext(), v8::internal::TraversableMap::GetAndResetParent(), NULL, and v8::internal::TraversableMap::SetParent().

Referenced by v8::internal::JSFunction::CompleteInobjectSlackTracking().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TryUpdate()

MaybeHandle< Map > v8::internal::Map::TryUpdate ( Handle< Map > map )

static

Definition at line 2691 of file objects.cc.

                                                {
   Handle<Map> proto_map(map);
   while (proto_map->prototype()->IsJSObject()) {
     Handle<JSObject> holder(JSObject::cast(proto_map->prototype()));
     proto_map = Handle<Map>(holder->map());
     if (proto_map->is_deprecated() && JSObject::TryMigrateInstance(holder)) {
       proto_map = Handle<Map>(holder->map());
     }
   }
   return TryUpdateInternal(map);
 }

References v8::internal::HeapObject::map(), and v8::internal::JSObject::TryMigrateInstance().

Referenced by v8::internal::FINAL< kOperandKind, kNumCachedOperands >::AddMapIfMissing(), v8::internal::TypeFeedbackOracle::CompareType(), and v8::internal::JSObject::TryMigrateInstance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TryUpdateInternal()

MaybeHandle< Map > v8::internal::Map::TryUpdateInternal ( Handle< Map > map )

static

Definition at line 2714 of file objects.cc.

                                                            {
   DisallowHeapAllocation no_allocation;
   DisallowDeoptimization no_deoptimization(old_map->GetIsolate());
  
   if (!old_map->is_deprecated()) return old_map;
  
   // Check the state of the root map.
   Map* root_map = old_map->FindRootMap();
   if (!old_map->EquivalentToForTransition(root_map)) return MaybeHandle<Map>();
   int root_nof = root_map->NumberOfOwnDescriptors();
  
   int old_nof = old_map->NumberOfOwnDescriptors();
   DescriptorArray* old_descriptors = old_map->instance_descriptors();
  
   Map* new_map = root_map;
   for (int i = root_nof; i < old_nof; ++i) {
     int j = new_map->SearchTransition(old_descriptors->GetKey(i));
     if (j == TransitionArray::kNotFound) return MaybeHandle<Map>();
     new_map = new_map->GetTransition(j);
     DescriptorArray* new_descriptors = new_map->instance_descriptors();
  
     PropertyDetails new_details = new_descriptors->GetDetails(i);
     PropertyDetails old_details = old_descriptors->GetDetails(i);
     if (old_details.attributes() != new_details.attributes() ||
         !old_details.representation().fits_into(new_details.representation())) {
       return MaybeHandle<Map>();
     }
     PropertyType new_type = new_details.type();
     PropertyType old_type = old_details.type();
     Object* new_value = new_descriptors->GetValue(i);
     Object* old_value = old_descriptors->GetValue(i);
     switch (new_type) {
       case FIELD:
         if ((old_type == FIELD &&
              !HeapType::cast(old_value)->NowIs(HeapType::cast(new_value))) ||
             (old_type == CONSTANT &&
              !HeapType::cast(new_value)->NowContains(old_value)) ||
             (old_type == CALLBACKS &&
              !HeapType::Any()->Is(HeapType::cast(new_value)))) {
           return MaybeHandle<Map>();
         }
         break;
  
       case CONSTANT:
       case CALLBACKS:
         if (old_type != new_type || old_value != new_value) {
           return MaybeHandle<Map>();
         }
         break;
  
       case NORMAL:
         UNREACHABLE();
     }
   }
   if (new_map->NumberOfOwnDescriptors() != old_nof) return MaybeHandle<Map>();
   return handle(new_map);
 }

References v8::internal::CALLBACKS, v8::internal::TypeImpl< Config >::cast(), v8::internal::CONSTANT, v8::internal::FIELD, v8::internal::DescriptorArray::GetDetails(), v8::internal::DescriptorArray::GetKey(), GetTransition(), v8::internal::DescriptorArray::GetValue(), v8::internal::handle(), v8::internal::Is(), v8::internal::TransitionArray::kNotFound, v8::internal::NORMAL, NumberOfOwnDescriptors(), SearchTransition(), and UNREACHABLE.

Here is the call graph for this function:

◆ unused_property_fields()

int v8::internal::Map::unused_property_fields ( )

inline

Definition at line 4333 of file objects-inl.h.

                                 {
   return READ_BYTE_FIELD(this, kUnusedPropertyFieldsOffset);
 }

References kUnusedPropertyFieldsOffset, and READ_BYTE_FIELD.

Referenced by v8::internal::JSFunction::CompleteInobjectSlackTracking(), CopyDropDescriptors(), CopyInstallDescriptors(), v8::internal::JSFunction::StartInobjectSlackTracking(), and TooManyFastProperties().

Here is the caller graph for this function:

◆ Update()

Handle< Map > v8::internal::Map::Update ( Handle< Map > map )

static

Definition at line 2705 of file objects.cc.

                                        {
   if (!map->is_deprecated()) return map;
   return GeneralizeRepresentation(map, 0, Representation::None(),
                                   HeapType::None(map->GetIsolate()),
                                   ALLOW_AS_CONSTANT);
 }

References v8::internal::ALLOW_AS_CONSTANT, v8::internal::HeapObject::GetIsolate(), is_deprecated(), v8::internal::HeapObject::map(), v8::None, and v8::internal::Representation::None().

Referenced by v8::internal::JSObject::MigrateInstance().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateCodeCache()

void v8::internal::Map::UpdateCodeCache	(	Handle< Map >	map,
		Handle< Name >	name,
		Handle< Code >	code
	)

static

Definition at line 7030 of file objects.cc.

                                              {
   Isolate* isolate = map->GetIsolate();
   HandleScope scope(isolate);
   // Allocate the code cache if not present.
   if (map->code_cache()->IsFixedArray()) {
     Handle<Object> result = isolate->factory()->NewCodeCache();
     map->set_code_cache(*result);
   }
  
   // Update the code cache.
   Handle<CodeCache> code_cache(CodeCache::cast(map->code_cache()), isolate);
   CodeCache::Update(code_cache, name, code);
 }

References v8::internal::Isolate::factory(), v8::internal::HeapObject::GetIsolate(), v8::internal::HeapObject::map(), name, and v8::internal::CodeCache::Update().

Referenced by v8::internal::CompareICStub::AddToSpecialCache(), v8::internal::LoadIC::CompileHandler(), v8::internal::PropertyICCompiler::ComputeCompareNil(), v8::internal::IC::ComputeHandler(), v8::internal::PropertyICCompiler::ComputeKeyedLoadMonomorphic(), v8::internal::PropertyICCompiler::ComputeKeyedStoreMonomorphic(), v8::internal::NamedLoadHandlerCompiler::ComputeLoadNonexistent(), v8::internal::PropertyICCompiler::ComputeMonomorphic(), and v8::internal::HeapObject::UpdateMapCodeCache().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateFieldType()

void v8::internal::Map::UpdateFieldType	(	int	descriptor_number,
		Handle< Name >	name,
		Handle< HeapType >	new_type
	)

private

Definition at line 2277 of file objects.cc.

                                                      {
   DisallowHeapAllocation no_allocation;
   PropertyDetails details = instance_descriptors()->GetDetails(descriptor);
   if (details.type() != FIELD) return;
   if (HasTransitionArray()) {
     TransitionArray* transitions = this->transitions();
     for (int i = 0; i < transitions->number_of_transitions(); ++i) {
       transitions->GetTarget(i)->UpdateFieldType(descriptor, name, new_type);
     }
   }
   // Skip if already updated the shared descriptor.
   if (instance_descriptors()->GetFieldType(descriptor) == *new_type) return;
   FieldDescriptor d(name, instance_descriptors()->GetFieldIndex(descriptor),
                     new_type, details.attributes(), details.representation());
   instance_descriptors()->Replace(descriptor, &d);
 }

References v8::internal::FIELD, v8::internal::TransitionArray::GetTarget(), name, v8::internal::TransitionArray::number_of_transitions(), and UpdateFieldType().

Referenced by UpdateFieldType().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ visitor_id()

int v8::internal::Map::visitor_id ( )

inline

Definition at line 4224 of file objects-inl.h.

                     {
   return READ_BYTE_FIELD(this, kVisitorIdOffset);
 }

References kVisitorIdOffset, and READ_BYTE_FIELD.

◆ ZapPrototypeTransitions()

void v8::internal::Map::ZapPrototypeTransitions ( )

private

Definition at line 11336 of file objects.cc.

                                   {
   FixedArray* proto_transitions = GetPrototypeTransitions();
   MemsetPointer(proto_transitions->data_start(),
                 GetHeap()->the_hole_value(),
                 proto_transitions->length());
 }

References v8::internal::FixedArray::data_start(), v8::internal::HeapObject::GetHeap(), GetPrototypeTransitions(), v8::internal::FixedArrayBase::length(), and v8::internal::MemsetPointer().

Referenced by SetPrototypeTransitions().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ZapTransitions()

void v8::internal::Map::ZapTransitions ( )

private

Definition at line 11323 of file objects.cc.

                          {
   TransitionArray* transition_array = transitions();
   // TODO(mstarzinger): Temporarily use a slower version instead of the faster
   // MemsetPointer to investigate a crasher. Switch back to MemsetPointer.
   Object** data = transition_array->data_start();
   Object* the_hole = GetHeap()->the_hole_value();
   int length = transition_array->length();
   for (int i = 0; i < length; i++) {
     data[i] = the_hole;
   }
 }

References v8::internal::FixedArray::data_start(), v8::internal::HeapObject::GetHeap(), and v8::internal::FixedArrayBase::length().

Here is the call graph for this function:

Member Data Documentation

◆ kBitField2Offset

const int v8::internal::Map::kBitField2Offset = kInstanceAttributesOffset + 2

static

Definition at line 6233 of file objects.h.

Referenced by bit_field2(), v8::internal::FINAL< kOperandKind, kNumCachedOperands >::ForMapBitField2(), and set_bit_field2().

◆ kBitField3Offset

const int v8::internal::Map::kBitField3Offset = kInstanceAttributesOffset + kIntSize

static

Definition at line 6189 of file objects.h.

Referenced by bit_field3().

◆ kBitFieldOffset

const int v8::internal::Map::kBitFieldOffset = kInstanceAttributesOffset + 0

static

Definition at line 6228 of file objects.h.

Referenced by bit_field(), v8::internal::LCodeGen::EmitIsObject(), v8::internal::LCodeGen::EmitTypeofIs(), v8::internal::FINAL< kOperandKind, kNumCachedOperands >::ForMapBitField(), v8::internal::FINAL< kOperandKind, kNumCachedOperands >::ForMapInstanceTypeAndBitField(), and set_bit_field().

◆ kCodeCacheOffset

const int v8::internal::Map::kCodeCacheOffset = kDescriptorsOffset + kPointerSize

static

Definition at line 6200 of file objects.h.

Referenced by ClearCodeCache(), v8::internal::V8HeapExplorer::ExtractMapReferences(), and Normalize().

◆ kConstructorOffset

const int v8::internal::Map::kConstructorOffset = kPrototypeOffset + kPointerSize

static

Definition at line 6191 of file objects.h.

Referenced by v8::internal::LCodeGen::EmitClassOfTest(), v8::internal::V8HeapExplorer::ExtractMapReferences(), v8::internal::IntrusiveMapTransitionIterator::IteratorField(), and v8::internal::IntrusivePrototypeTransitionIterator::IteratorField().

◆ kDependentCodeOffset

const int v8::internal::Map::kDependentCodeOffset = kCodeCacheOffset + kPointerSize

static

Definition at line 6201 of file objects.h.

Referenced by v8::internal::V8HeapExplorer::ExtractMapReferences(), v8::internal::StaticMarkingVisitor< StaticVisitor >::MarkMapContents(), and Normalize().

◆ kDescriptorsOffset

const int v8::internal::Map::kDescriptorsOffset

static

Initial value:

=

kTransitionsOrBackPointerOffset + kPointerSize

Definition at line 6198 of file objects.h.

Referenced by v8::internal::CodeStubGraphBuilder< Stub >::BuildCodeStub(), and v8::internal::V8HeapExplorer::ExtractMapReferences().

◆ kFastPropertiesSoftLimit

const int v8::internal::Map::kFastPropertiesSoftLimit = 12

staticprivate

Definition at line 6356 of file objects.h.

◆ kHasIndexedInterceptor

const int v8::internal::Map::kHasIndexedInterceptor = 3

static

Definition at line 6243 of file objects.h.

Referenced by v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub().

◆ kHasNamedInterceptor

const int v8::internal::Map::kHasNamedInterceptor = 2

static

Definition at line 6242 of file objects.h.

Referenced by v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub().

◆ kHasNonInstancePrototype

const int v8::internal::Map::kHasNonInstancePrototype = 0

static

Definition at line 6240 of file objects.h.

Referenced by has_non_instance_prototype(), and set_non_instance_prototype().

◆ kInObjectPropertiesByte

const int v8::internal::Map::kInObjectPropertiesByte = 1

static

Definition at line 6211 of file objects.h.

◆ kInObjectPropertiesOffset

const int v8::internal::Map::kInObjectPropertiesOffset

static

Initial value:

=

kInstanceSizesOffset + kInObjectPropertiesByte

v8::internal::Map::kInObjectPropertiesByte

static const int kInObjectPropertiesByte

Definition: objects.h:6211

v8::internal::Map::kInstanceSizesOffset

static const int kInstanceSizesOffset

Definition: objects.h:6187

Definition at line 6212 of file objects.h.

Referenced by v8::internal::FINAL< kOperandKind, kNumCachedOperands >::ForMapInObjectProperties(), inobject_properties(), and set_inobject_properties().

◆ kInstanceAttributesOffset

const int v8::internal::Map::kInstanceAttributesOffset = kInstanceSizesOffset + kIntSize

static

Definition at line 6188 of file objects.h.

◆ kInstanceSizeOffset

const int v8::internal::Map::kInstanceSizeOffset = kInstanceSizesOffset + 0

static

Definition at line 6210 of file objects.h.

Referenced by v8::internal::FINAL< kOperandKind, kNumCachedOperands >::ForMapInstanceSize(), instance_size(), and set_instance_size().

◆ kInstanceSizesOffset

const int v8::internal::Map::kInstanceSizesOffset = HeapObject::kHeaderSize

static

Definition at line 6187 of file objects.h.

◆ kInstanceTypeAndBitFieldOffset

const int v8::internal::Map::kInstanceTypeAndBitFieldOffset

static

Initial value:

=

kInstanceAttributesOffset + 0

v8::internal::Map::kInstanceAttributesOffset

static const int kInstanceAttributesOffset

Definition: objects.h:6188

Definition at line 6231 of file objects.h.

Referenced by v8::internal::FINAL< kOperandKind, kNumCachedOperands >::ForMapInstanceTypeAndBitField().

◆ kInstanceTypeOffset

const int v8::internal::Map::kInstanceTypeOffset = kInstanceAttributesOffset + 1

static

Definition at line 6229 of file objects.h.

Referenced by v8::internal::LCodeGen::EmitClassOfTest(), v8::internal::LCodeGen::EmitIsObject(), v8::internal::FINAL< kOperandKind, kNumCachedOperands >::ForMapInstanceType(), v8::internal::FINAL< kOperandKind, kNumCachedOperands >::ForMapInstanceTypeAndBitField(), instance_type(), v8::internal::MacroAssembler::IsInstanceJSObjectType(), v8::internal::MacroAssembler::IsObjectJSStringType(), v8::internal::MacroAssembler::IsObjectStringType(), and set_instance_type().

◆ kIsAccessCheckNeeded

const int v8::internal::Map::kIsAccessCheckNeeded = 6

static

Definition at line 6246 of file objects.h.

Referenced by v8::internal::CodeStubGraphBuilder< KeyedLoadGenericStub >::BuildCodeStub(), is_access_check_needed(), and set_is_access_check_needed().

◆ kIsExtensible

const int v8::internal::Map::kIsExtensible = 0

static

Definition at line 6250 of file objects.h.

Referenced by v8::internal::Heap::AllocateMap(), is_extensible(), and set_is_extensible().

◆ kIsHiddenPrototype

const int v8::internal::Map::kIsHiddenPrototype = 1

static

Definition at line 6241 of file objects.h.

◆ kIsObserved

const int v8::internal::Map::kIsObserved = 5

static

Definition at line 6245 of file objects.h.

◆ kIsUndetectable

const int v8::internal::Map::kIsUndetectable = 4

static

Definition at line 6244 of file objects.h.

Referenced by v8::internal::LCodeGen::EmitIsObject(), and v8::internal::LCodeGen::EmitTypeofIs().

◆ kMaxCachedPrototypeTransitions

const int v8::internal::Map::kMaxCachedPrototypeTransitions = 256

static

Definition at line 6180 of file objects.h.

Referenced by PutPrototypeTransition().

◆ kMaxFastProperties

const int v8::internal::Map::kMaxFastProperties = 128

staticprivate

Definition at line 6357 of file objects.h.

◆ kMaximumBitField2FastElementValue

const int8_t v8::internal::Map::kMaximumBitField2FastElementValue

static

Initial value:

= static_cast<int8_t>(

(FAST_ELEMENTS + 1) << Map::ElementsKindBits::kShift) - 1

v8::internal::BitFieldBase::kShift

static const U kShift

Definition: utils.h:204

v8::internal::FAST_ELEMENTS

@ FAST_ELEMENTS

Definition: elements-kind.h:22

Definition at line 6256 of file objects.h.

◆ kMaximumBitField2FastHoleyElementValue

const int8_t v8::internal::Map::kMaximumBitField2FastHoleyElementValue

static

Initial value:

=
      static_cast<int8_t>((FAST_HOLEY_ELEMENTS + 1) <<
                          Map::ElementsKindBits::kShift) - 1

Definition at line 6261 of file objects.h.

◆ kMaximumBitField2FastHoleySmiElementValue

const int8_t v8::internal::Map::kMaximumBitField2FastHoleySmiElementValue

static

Initial value:

=
      static_cast<int8_t>((FAST_HOLEY_SMI_ELEMENTS + 1) <<
                          Map::ElementsKindBits::kShift) - 1

Definition at line 6264 of file objects.h.

◆ kMaximumBitField2FastSmiElementValue

const int8_t v8::internal::Map::kMaximumBitField2FastSmiElementValue

static

Initial value:

=
      static_cast<int8_t>((FAST_SMI_ELEMENTS + 1) <<
                          Map::ElementsKindBits::kShift) - 1

Definition at line 6258 of file objects.h.

◆ kMaxPreAllocatedPropertyFields

const int v8::internal::Map::kMaxPreAllocatedPropertyFields = 255

static

Definition at line 6184 of file objects.h.

◆ kPointerFieldsBeginOffset

const int v8::internal::Map::kPointerFieldsBeginOffset = Map::kPrototypeOffset

static

Definition at line 6206 of file objects.h.

Referenced by v8::internal::StoreBuffer::IteratePointersToNewSpace(), and v8::internal::StaticMarkingVisitor< StaticVisitor >::MarkMapContents().

◆ kPointerFieldsEndOffset

const int v8::internal::Map::kPointerFieldsEndOffset = kSize

static

Definition at line 6207 of file objects.h.

Referenced by v8::internal::StoreBuffer::IteratePointersToNewSpace(), and v8::internal::StaticMarkingVisitor< StaticVisitor >::MarkMapContents().

◆ kPreAllocatedPropertyFieldsByte

const int v8::internal::Map::kPreAllocatedPropertyFieldsByte = 2

static

Definition at line 6214 of file objects.h.

◆ kPreAllocatedPropertyFieldsOffset

const int v8::internal::Map::kPreAllocatedPropertyFieldsOffset

static

Initial value:

=

kInstanceSizesOffset + kPreAllocatedPropertyFieldsByte

v8::internal::Map::kPreAllocatedPropertyFieldsByte

static const int kPreAllocatedPropertyFieldsByte

Definition: objects.h:6214

Definition at line 6215 of file objects.h.

Referenced by pre_allocated_property_fields(), and set_pre_allocated_property_fields().

◆ kProtoTransitionElementsPerEntry

const int v8::internal::Map::kProtoTransitionElementsPerEntry = 2

static

Definition at line 5903 of file objects.h.

Referenced by v8::internal::MarkCompactCollector::ClearNonLivePrototypeTransitions(), GetPrototypeTransition(), v8::internal::IntrusivePrototypeTransitionIterator::IndexFor(), and PutPrototypeTransition().

◆ kProtoTransitionHeaderSize

const int v8::internal::Map::kProtoTransitionHeaderSize = 1

static

Definition at line 5901 of file objects.h.

Referenced by v8::internal::MarkCompactCollector::ClearNonLivePrototypeTransitions(), GetPrototypeTransition(), v8::internal::IntrusivePrototypeTransitionIterator::IndexFor(), and PutPrototypeTransition().

◆ kProtoTransitionMapOffset

const int v8::internal::Map::kProtoTransitionMapOffset = 1

static

Definition at line 5905 of file objects.h.

Referenced by v8::internal::MarkCompactCollector::ClearNonLivePrototypeTransitions(), GetPrototypeTransition(), v8::internal::IntrusivePrototypeTransitionIterator::IndexFor(), and PutPrototypeTransition().

◆ kProtoTransitionNumberOfEntriesOffset

const int v8::internal::Map::kProtoTransitionNumberOfEntriesOffset = 0

static

Definition at line 5902 of file objects.h.

Referenced by v8::internal::IntrusivePrototypeTransitionIterator::NumberOfTransitions().

◆ kProtoTransitionPrototypeOffset

const int v8::internal::Map::kProtoTransitionPrototypeOffset = 0

static

Definition at line 5904 of file objects.h.

Referenced by v8::internal::MarkCompactCollector::ClearNonLivePrototypeTransitions(), GetPrototypeTransition(), and PutPrototypeTransition().

◆ kPrototypeOffset

const int v8::internal::Map::kPrototypeOffset = kBitField3Offset + kPointerSize

static

Definition at line 6190 of file objects.h.

Referenced by v8::internal::V8HeapExplorer::ExtractMapReferences().

◆ kSize

const int v8::internal::Map::kSize = kDependentCodeOffset + kPointerSize

static

Definition at line 6202 of file objects.h.

Referenced by v8::internal::Heap::AllocateMap(), v8::internal::Heap::AllocatePartialMap(), v8::internal::Heap::CreateInitialMaps(), Normalize(), and v8::internal::MapSpace::RoundSizeDownToObjectAlignment().

◆ kStringWrapperSafeForDefaultValueOf

const int v8::internal::Map::kStringWrapperSafeForDefaultValueOf = 1

static

Definition at line 6251 of file objects.h.

◆ kTransitionsOrBackPointerOffset

const int v8::internal::Map::kTransitionsOrBackPointerOffset

static

Initial value:

=

kConstructorOffset + kPointerSize

v8::internal::Map::kConstructorOffset

static const int kConstructorOffset

Definition: objects.h:6191

Definition at line 6196 of file objects.h.

Referenced by v8::internal::V8HeapExplorer::ExtractMapReferences(), GetBackPointer(), HasTransitionArray(), init_back_pointer(), and SetBackPointer().

◆ kUnusedPropertyFieldsOffset

const int v8::internal::Map::kUnusedPropertyFieldsOffset = kInstanceAttributesOffset + 3

static

Definition at line 6234 of file objects.h.

Referenced by set_unused_property_fields(), and unused_property_fields().

◆ kVisitorIdByte

const int v8::internal::Map::kVisitorIdByte = 3

static

Definition at line 6217 of file objects.h.

◆ kVisitorIdOffset

const int v8::internal::Map::kVisitorIdOffset = kInstanceSizesOffset + kVisitorIdByte

static

Definition at line 6218 of file objects.h.

Referenced by set_visitor_id(), and visitor_id().

The documentation for this class was generated from the following files:

/mnt/V8SourceCode/src/objects.h
/mnt/V8SourceCode/src/objects-inl.h
/mnt/V8SourceCode/src/objects.cc

Classes

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Static Private Member Functions

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ BodyDescriptor

◆ TraverseCallback

Member Function Documentation

◆ AddDependentCode()

◆ AddDependentCompilationInfo()

◆ AddDependentIC()

◆ AppendCallbackDescriptors()

◆ AppendDescriptor()

◆ AsElementsKind()

◆ bit_field()

◆ bit_field2()

◆ bit_field3()

◆ CanBeDeprecated()

◆ CanHaveMoreTransitions()

◆ CanOmitMapChecks()

◆ CanTransition()

◆ ClearCodeCache()

◆ ClearNonLiveTransitions()

◆ ConnectElementsTransition()

◆ ConnectTransition()

◆ construction_count()

◆ constructor_name()

◆ Copy()

◆ CopyAddDescriptor()

◆ CopyAsElementsKind()

◆ CopyDropDescriptors()

◆ CopyForFreeze()

◆ CopyForObserved()

◆ CopyGeneralizeAllRepresentations() [1/2]

◆ CopyGeneralizeAllRepresentations() [2/2]

◆ CopyInsertDescriptor()

◆ CopyInstallDescriptors()

◆ CopyNormalized()

◆ CopyReplaceDescriptor()

◆ CopyReplaceDescriptors()

◆ CopyWithConstant()

◆ CopyWithField()

◆ Create()

◆ deprecate()

◆ DeprecateTarget()

◆ DeprecateTransitionTree()

◆ DictionaryElementsInPrototypeChainOnly()

◆ DISALLOW_IMPLICIT_CONSTRUCTORS()

◆ done_inobject_slack_tracking()

◆ elements_kind()

◆ elements_transition_map()

◆ EnsureDescriptorSlack()

◆ EnumLength()

◆ EquivalentToForNormalization()

◆ EquivalentToForTransition()

◆ ExpectedTransitionKey()

◆ ExpectedTransitionTarget()

◆ FindFieldOwner()

◆ FindInCodeCache()

◆ FindLastMatchMap()

◆ FindRootMap()

◆ FindTransitionedMap()

◆ FindTransitionToField()

◆ freeze()

◆ function_with_prototype()

◆ GeneralizeAllFieldRepresentations()

◆ GeneralizeFieldType() [1/2]

◆ GeneralizeFieldType() [2/2]

◆ GeneralizeRepresentation()

◆ GetBackPointer()

◆ GetInitialElements()

◆ GetInObjectPropertyOffset()

◆ GetLastDescriptorDetails()

◆ GetPrototypeTransition()