#include <objects.h>

Inheritance diagram for v8::internal::DependentCode:

Collaboration diagram for v8::internal::DependentCode:

Classes
class	GroupStartIndexes

Public Types
enum	DependencyGroup { kWeakICGroup , kWeakCodeGroup , kTransitionGroup , kPrototypeCheckGroup , kElementsCantBeAddedGroup , kPropertyCellChangedGroup , kFieldTypeGroup , kInitialMapChangedGroup , kAllocationSiteTenuringChangedGroup , kAllocationSiteTransitionChangedGroup }

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
bool	Contains (DependencyGroup group, Code *code)

void	UpdateToFinishedCode (DependencyGroup group, CompilationInfo info, Code code)

void	RemoveCompilationInfo (DependentCode::DependencyGroup group, CompilationInfo *info)

void	DeoptimizeDependentCodeGroup (Isolate *isolate, DependentCode::DependencyGroup group)

bool	MarkCodeForDeoptimization (Isolate *isolate, DependentCode::DependencyGroup group)

void	AddToDependentICList (Handle< Code > stub)

int	number_of_entries (DependencyGroup group)

void	set_number_of_entries (DependencyGroup group, int value)

bool	is_code_at (int i)

Code *	code_at (int i)

CompilationInfo *	compilation_info_at (int i)

void	set_object_at (int i, Object *object)

Object **	slot_at (int i)

Object *	object_at (int i)

void	clear_at (int i)

void	copy (int from, int to)

Public Member Functions inherited from v8::internal::FixedArray
Object *	get (int index)

void	set (int index, Object *value)

bool	is_the_hole (int index)

void	set (int index, Smi *value)

void	set (int index, Object *value, WriteBarrierMode mode)

void	set_undefined (int index)

void	set_null (int index)

void	set_the_hole (int index)

Object **	GetFirstElementAddress ()

bool	ContainsOnlySmisOrHoles ()

Object **	data_start ()

void	FillWithHoles (int from, int to)

void	Shrink (int length)

void	CopyTo (int pos, FixedArray *dest, int dest_pos, int len)

Object **	RawFieldOfElementAt (int index)

void	SwapPairs (FixedArray *numbers, int i, int j)

void	SortPairs (FixedArray *numbers, uint32_t len)

Public Member Functions inherited from v8::internal::FixedArrayBase
int	length () const

void	set_length (int value)

int	synchronized_length () const

void	synchronized_set_length (int value)

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 Handle< DependentCode >	Insert (Handle< DependentCode > entries, DependencyGroup group, Handle< Object > object)

static DependentCode *	ForObject (Handle< HeapObject > object, DependencyGroup group)

static const char *	DependencyGroupName (DependencyGroup group)

static void	SetMarkedForDeoptimization (Code *code, DependencyGroup group)

Static Public Member Functions inherited from v8::internal::FixedArray
static Handle< Object >	get (Handle< FixedArray > array, int index)

static Handle< FixedArray >	CopySize (Handle< FixedArray > array, int new_length, PretenureFlag pretenure=NOT_TENURED)

static MUST_USE_RESULT MaybeHandle< FixedArray >	AddKeysFromArrayLike (Handle< FixedArray > content, Handle< JSObject > array)

static MUST_USE_RESULT MaybeHandle< FixedArray >	UnionOfKeys (Handle< FixedArray > first, Handle< FixedArray > second)

static int	SizeFor (int length)

static int	OffsetOfElementAt (int index)

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	kGroupCount = kAllocationSiteTransitionChangedGroup + 1

Static Public Attributes inherited from v8::internal::FixedArray
static const int	kMaxSize = 128 * MB * kPointerSize

static const int	kMaxLength = (kMaxSize - kHeaderSize) / kPointerSize

Static Public Attributes inherited from v8::internal::FixedArrayBase
static const int	kLengthOffset = HeapObject::kHeaderSize

static const int	kHeaderSize = kLengthOffset + kPointerSize

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
void	ExtendGroup (DependencyGroup group)

Static Private Attributes
static const int	kCodesStartIndex = kGroupCount

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)

Static Protected Member Functions inherited from v8::internal::FixedArray
static void	NoWriteBarrierSet (FixedArray array, int index, Object value)

static void	NoIncrementalWriteBarrierSet (FixedArray array, int index, Object value)

Detailed Description

Definition at line 5495 of file objects.h.

Member Enumeration Documentation

◆ DependencyGroup

enum v8::internal::DependentCode::DependencyGroup

Enumerator
kWeakICGroup
kWeakCodeGroup
kTransitionGroup
kPrototypeCheckGroup
kElementsCantBeAddedGroup
kPropertyCellChangedGroup
kFieldTypeGroup
kInitialMapChangedGroup
kAllocationSiteTenuringChangedGroup
kAllocationSiteTransitionChangedGroup

Definition at line 5497 of file objects.h.

                        {
     // Group of IC stubs that weakly embed this map and depend on being
     // invalidated when the map is garbage collected. Dependent IC stubs form
     // a linked list. This group stores only the head of the list. This means
     // that the number_of_entries(kWeakICGroup) is 0 or 1.
     kWeakICGroup,
     // Group of code that weakly embed this map and depend on being
     // deoptimized when the map is garbage collected.
     kWeakCodeGroup,
     // Group of code that embed a transition to this map, and depend on being
     // deoptimized when the transition is replaced by a new version.
     kTransitionGroup,
     // Group of code that omit run-time prototype checks for prototypes
     // described by this map. The group is deoptimized whenever an object
     // described by this map changes shape (and transitions to a new map),
     // possibly invalidating the assumptions embedded in the code.
     kPrototypeCheckGroup,
     // Group of code that depends on elements not being added to objects with
     // this map.
     kElementsCantBeAddedGroup,
     // Group of code that depends on global property values in property cells
     // not being changed.
     kPropertyCellChangedGroup,
     // Group of code that omit run-time type checks for the field(s) introduced
     // by this map.
     kFieldTypeGroup,
     // Group of code that omit run-time type checks for initial maps of
     // constructors.
     kInitialMapChangedGroup,
     // Group of code that depends on tenuring information in AllocationSites
     // not being changed.
     kAllocationSiteTenuringChangedGroup,
     // Group of code that depends on element transition information in
     // AllocationSites not being changed.
     kAllocationSiteTransitionChangedGroup
   };

Member Function Documentation

◆ AddToDependentICList()

void v8::internal::DependentCode::AddToDependentICList ( Handle< Code > stub )

Definition at line 11584 of file objects.cc.

                                                           {
   DisallowHeapAllocation no_heap_allocation;
   GroupStartIndexes starts(this);
   int i = starts.at(kWeakICGroup);
   Object* head = object_at(i);
   // Try to insert the stub after the head of the list to minimize number of
   // writes to the DependentCode array, since a write to the array can make it
   // strong if it was alread marked by incremental marker.
   if (head->IsCode()) {
     stub->set_next_code_link(Code::cast(head)->next_code_link());
     Code::cast(head)->set_next_code_link(*stub);
   } else {
     stub->set_next_code_link(head);
     set_object_at(i, *stub);
   }
 }

References v8::internal::DependentCode::GroupStartIndexes::at(), kWeakICGroup, object_at(), and set_object_at().

Here is the call graph for this function:

◆ clear_at()

void v8::internal::DependentCode::clear_at ( int i )

inline

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

                                   {
   set_undefined(kCodesStartIndex + i);
 }

References kCodesStartIndex, and v8::internal::FixedArray::set_undefined().

Referenced by v8::internal::MarkCompactCollector::ClearDependentCode(), v8::internal::MarkCompactCollector::ClearNonLiveDependentCode(), MarkCodeForDeoptimization(), and RemoveCompilationInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ code_at()

Code * v8::internal::DependentCode::code_at ( int i )

inline

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

                                   {
   return Code::cast(get(kCodesStartIndex + i));
 }

References v8::internal::FixedArray::get(), and kCodesStartIndex.

Referenced by v8::internal::MarkCompactCollector::ClearDependentCode(), and MarkCodeForDeoptimization().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ compilation_info_at()

CompilationInfo * v8::internal::DependentCode::compilation_info_at ( int i )

inline

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

                                                          {
   return reinterpret_cast<CompilationInfo*>(
       Foreign::cast(get(kCodesStartIndex + i))->foreign_address());
 }

References v8::internal::FixedArray::get(), and kCodesStartIndex.

Referenced by MarkCodeForDeoptimization(), RemoveCompilationInfo(), and UpdateToFinishedCode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Contains()

bool v8::internal::DependentCode::Contains	(	DependencyGroup	group,
		Code *	code
	)

Definition at line 11521 of file objects.cc.

                                                               {
   GroupStartIndexes starts(this);
   int start = starts.at(group);
   int end = starts.at(group + 1);
   if (group == kWeakICGroup) {
     return CodeListContains(object_at(start), code);
   }
   for (int i = start; i < end; i++) {
     if (object_at(i) == code) return true;
   }
   return false;
 }

References v8::internal::DependentCode::GroupStartIndexes::at(), v8::internal::CodeListContains(), kWeakICGroup, and object_at().

Here is the call graph for this function:

◆ copy()

void v8::internal::DependentCode::copy	(	int	from,
		int	to
	)

inline

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

                                          {
   set(kCodesStartIndex + to, get(kCodesStartIndex + from));
 }

References v8::internal::FixedArray::get(), kCodesStartIndex, v8::internal::FixedArray::set(), and to().

Referenced by ExtendGroup(), MarkCodeForDeoptimization(), and RemoveCompilationInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DeoptimizeDependentCodeGroup()

void v8::internal::DependentCode::DeoptimizeDependentCodeGroup	(	Isolate *	isolate,
		DependentCode::DependencyGroup	group
	)

Definition at line 11573 of file objects.cc.

                                         {
   DCHECK(AllowCodeDependencyChange::IsAllowed());
   DisallowHeapAllocation no_allocation_scope;
   bool marked = MarkCodeForDeoptimization(isolate, group);
  
   if (marked) Deoptimizer::DeoptimizeMarkedCode(isolate);
 }

References DCHECK, v8::internal::Deoptimizer::DeoptimizeMarkedCode(), and MarkCodeForDeoptimization().

Here is the call graph for this function:

◆ DependencyGroupName()

const char * v8::internal::DependentCode::DependencyGroupName ( DependencyGroup group )

static

Definition at line 11618 of file objects.cc.

                                                                     {
   switch (group) {
     case kWeakICGroup:
       return "weak-ic";
     case kWeakCodeGroup:
       return "weak-code";
     case kTransitionGroup:
       return "transition";
     case kPrototypeCheckGroup:
       return "prototype-check";
     case kElementsCantBeAddedGroup:
       return "elements-cant-be-added";
     case kPropertyCellChangedGroup:
       return "property-cell-changed";
     case kFieldTypeGroup:
       return "field-type";
     case kInitialMapChangedGroup:
       return "initial-map-changed";
     case kAllocationSiteTenuringChangedGroup:
       return "allocation-site-tenuring-changed";
     case kAllocationSiteTransitionChangedGroup:
       return "allocation-site-transition-changed";
   }
   UNREACHABLE();
   return "?";
 }

References kAllocationSiteTenuringChangedGroup, kAllocationSiteTransitionChangedGroup, kElementsCantBeAddedGroup, kFieldTypeGroup, kInitialMapChangedGroup, kPropertyCellChangedGroup, kPrototypeCheckGroup, kTransitionGroup, kWeakCodeGroup, kWeakICGroup, and UNREACHABLE.

Referenced by SetMarkedForDeoptimization().

Here is the caller graph for this function:

◆ ExtendGroup()

void v8::internal::DependentCode::ExtendGroup ( DependencyGroup group )

inlineprivate

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

                                                      {
   GroupStartIndexes starts(this);
   for (int g = kGroupCount - 1; g > group; g--) {
     if (starts.at(g) < starts.at(g + 1)) {
       copy(starts.at(g), starts.at(g + 1));
     }
   }
 }

References v8::internal::DependentCode::GroupStartIndexes::at(), copy(), and kGroupCount.

Here is the call graph for this function:

◆ ForObject()

DependentCode * v8::internal::DependentCode::ForObject	(	Handle< HeapObject >	object,
		DependencyGroup	group
	)

static

Definition at line 11397 of file objects.cc.

                                                                {
   AllowDeferredHandleDereference dependencies_are_safe;
   if (group == DependentCode::kPropertyCellChangedGroup) {
     return Handle<PropertyCell>::cast(object)->dependent_code();
   } else if (group == DependentCode::kAllocationSiteTenuringChangedGroup ||
       group == DependentCode::kAllocationSiteTransitionChangedGroup) {
     return Handle<AllocationSite>::cast(object)->dependent_code();
   }
   return Handle<Map>::cast(object)->dependent_code();
 }

References v8::internal::Handle< T >::cast(), kAllocationSiteTenuringChangedGroup, kAllocationSiteTransitionChangedGroup, and kPropertyCellChangedGroup.

Referenced by v8::internal::CompilationInfo::CommitDependencies(), and v8::internal::CompilationInfo::RollbackDependencies().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ Insert()

Handle< DependentCode > v8::internal::DependentCode::Insert	(	Handle< DependentCode >	entries,
		DependencyGroup	group,
		Handle< Object >	object
	)

static

Definition at line 11410 of file objects.cc.

                                                                    {
   GroupStartIndexes starts(*entries);
   int start = starts.at(group);
   int end = starts.at(group + 1);
   int number_of_entries = starts.number_of_entries();
   // Check for existing entry to avoid duplicates.
   for (int i = start; i < end; i++) {
     if (entries->object_at(i) == *object) return entries;
   }
   if (entries->length() < kCodesStartIndex + number_of_entries + 1) {
     int capacity = kCodesStartIndex + number_of_entries + 1;
     if (capacity > 5) capacity = capacity * 5 / 4;
     Handle<DependentCode> new_entries = Handle<DependentCode>::cast(
         FixedArray::CopySize(entries, capacity, TENURED));
     // The number of codes can change after GC.
     starts.Recompute(*entries);
     start = starts.at(group);
     end = starts.at(group + 1);
     number_of_entries = starts.number_of_entries();
     for (int i = 0; i < number_of_entries; i++) {
       entries->clear_at(i);
     }
     // If the old fixed array was empty, we need to reset counters of the
     // new array.
     if (number_of_entries == 0) {
       for (int g = 0; g < kGroupCount; g++) {
         new_entries->set_number_of_entries(static_cast<DependencyGroup>(g), 0);
       }
     }
     entries = new_entries;
   }
   entries->ExtendGroup(group);
   entries->set_object_at(end, *object);
   entries->set_number_of_entries(group, end + 1 - start);
   return entries;
 }

References v8::internal::DependentCode::GroupStartIndexes::at(), v8::internal::Handle< T >::cast(), v8::internal::FixedArray::CopySize(), kCodesStartIndex, kGroupCount, v8::internal::DependentCode::GroupStartIndexes::number_of_entries(), number_of_entries(), v8::internal::DependentCode::GroupStartIndexes::Recompute(), and v8::internal::TENURED.

Referenced by v8::internal::Map::AddDependentCode(), v8::internal::AllocationSite::AddDependentCompilationInfo(), v8::internal::Map::AddDependentCompilationInfo(), and v8::internal::PropertyCell::AddDependentCompilationInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ is_code_at()

bool v8::internal::DependentCode::is_code_at ( int i )

inline

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

                                     {
   return get(kCodesStartIndex + i)->IsCode();
 }

References v8::internal::FixedArray::get(), and kCodesStartIndex.

Referenced by v8::internal::MarkCompactCollector::ClearDependentCode(), MarkCodeForDeoptimization(), RemoveCompilationInfo(), and UpdateToFinishedCode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ MarkCodeForDeoptimization()

bool v8::internal::DependentCode::MarkCodeForDeoptimization	(	Isolate *	isolate,
		DependentCode::DependencyGroup	group
	)

Definition at line 11535 of file objects.cc.

                                         {
   DisallowHeapAllocation no_allocation_scope;
   DependentCode::GroupStartIndexes starts(this);
   int start = starts.at(group);
   int end = starts.at(group + 1);
   int code_entries = starts.number_of_entries();
   if (start == end) return false;
  
   // Mark all the code that needs to be deoptimized.
   bool marked = false;
   for (int i = start; i < end; i++) {
     if (is_code_at(i)) {
       Code* code = code_at(i);
       if (!code->marked_for_deoptimization()) {
         SetMarkedForDeoptimization(code, group);
         marked = true;
       }
     } else {
       CompilationInfo* info = compilation_info_at(i);
       info->AbortDueToDependencyChange();
     }
   }
   // Compact the array by moving all subsequent groups to fill in the new holes.
   for (int src = end, dst = start; src < code_entries; src++, dst++) {
     copy(src, dst);
   }
   // Now the holes are at the end of the array, zap them for heap-verifier.
   int removed = end - start;
   for (int i = code_entries - removed; i < code_entries; i++) {
     clear_at(i);
   }
   set_number_of_entries(group, 0);
   return marked;
 }

References v8::internal::CompilationInfo::AbortDueToDependencyChange(), v8::internal::DependentCode::GroupStartIndexes::at(), clear_at(), code_at(), compilation_info_at(), copy(), is_code_at(), v8::internal::Code::marked_for_deoptimization(), v8::internal::DependentCode::GroupStartIndexes::number_of_entries(), set_number_of_entries(), and SetMarkedForDeoptimization().

Referenced by DeoptimizeDependentCodeGroup().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ number_of_entries()

int v8::internal::DependentCode::number_of_entries ( DependencyGroup group )

inline

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

                                                           {
   if (length() == 0) return 0;
   return Smi::cast(get(group))->value();
 }

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

Referenced by Insert(), and v8::internal::DependentCode::GroupStartIndexes::Recompute().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ object_at()

Object * v8::internal::DependentCode::object_at ( int i )

inline

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

                                       {
   return get(kCodesStartIndex + i);
 }

References v8::internal::FixedArray::get(), and kCodesStartIndex.

Referenced by AddToDependentICList(), v8::internal::MarkCompactCollector::ClearDependentCode(), v8::internal::MarkCompactCollector::ClearNonLiveDependentCodeInGroup(), Contains(), RemoveCompilationInfo(), and UpdateToFinishedCode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ RemoveCompilationInfo()

void v8::internal::DependentCode::RemoveCompilationInfo	(	DependentCode::DependencyGroup	group,
		CompilationInfo *	info
	)

Definition at line 11474 of file objects.cc.

                                                                  {
   DisallowHeapAllocation no_allocation;
   AllowDeferredHandleDereference get_object_wrapper;
   Foreign* info_wrapper = *info->object_wrapper();
   GroupStartIndexes starts(this);
   int start = starts.at(group);
   int end = starts.at(group + 1);
   // Find compilation info wrapper.
   int info_pos = -1;
   for (int i = start; i < end; i++) {
     if (object_at(i) == info_wrapper) {
       info_pos = i;
       break;
     }
   }
   if (info_pos == -1) return;  // Not found.
   int gap = info_pos;
   // Use the last of each group to fill the gap in the previous group.
   for (int i = group; i < kGroupCount; i++) {
     int last_of_group = starts.at(i + 1) - 1;
     DCHECK(last_of_group >= gap);
     if (last_of_group == gap) continue;
     copy(last_of_group, gap);
     gap = last_of_group;
   }
   DCHECK(gap == starts.number_of_entries() - 1);
   clear_at(gap);  // Clear last gap.
   set_number_of_entries(group, end - start - 1);
  
 #ifdef DEBUG
   for (int i = start; i < end - 1; i++) {
     DCHECK(is_code_at(i) || compilation_info_at(i) != info);
   }
 #endif
 }

References v8::internal::DependentCode::GroupStartIndexes::at(), clear_at(), compilation_info_at(), copy(), DCHECK, is_code_at(), kGroupCount, v8::internal::DependentCode::GroupStartIndexes::number_of_entries(), object_at(), v8::internal::CompilationInfo::object_wrapper(), and set_number_of_entries().

Here is the call graph for this function:

◆ set_number_of_entries()

void v8::internal::DependentCode::set_number_of_entries	(	DependencyGroup	group,
		int	value
	)

inline

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

                                                                           {
   set(group, Smi::FromInt(value));
 }

References v8::internal::Smi::FromInt(), and v8::internal::FixedArray::set().

Referenced by v8::internal::MarkCompactCollector::ClearNonLiveDependentCodeInGroup(), MarkCodeForDeoptimization(), and RemoveCompilationInfo().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set_object_at()

void v8::internal::DependentCode::set_object_at	(	int	i,
		Object *	object
	)

inline

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

                                                        {
   set(kCodesStartIndex + i, object);
 }

References kCodesStartIndex, and v8::internal::FixedArray::set().

Referenced by AddToDependentICList(), v8::internal::MarkCompactCollector::ClearNonLiveDependentCodeInGroup(), and UpdateToFinishedCode().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetMarkedForDeoptimization()

void v8::internal::DependentCode::SetMarkedForDeoptimization	(	Code *	code,
		DependencyGroup	group
	)

static

Definition at line 11602 of file objects.cc.

                                                                       {
   code->set_marked_for_deoptimization(true);
   if (FLAG_trace_deopt &&
       (code->deoptimization_data() != code->GetHeap()->empty_fixed_array())) {
     DeoptimizationInputData* deopt_data =
         DeoptimizationInputData::cast(code->deoptimization_data());
     CodeTracer::Scope scope(code->GetHeap()->isolate()->GetCodeTracer());
     PrintF(scope.file(), "[marking dependent code 0x%08" V8PRIxPTR
                          " (opt #%d) for deoptimization, reason: %s]\n",
            reinterpret_cast<intptr_t>(code),
            deopt_data->OptimizationId()->value(), DependencyGroupName(group));
   }
 }

References DependencyGroupName(), v8::internal::Isolate::GetCodeTracer(), v8::internal::HeapObject::GetHeap(), v8::internal::Heap::isolate(), v8::internal::PrintF(), v8::internal::Code::set_marked_for_deoptimization(), and V8PRIxPTR.

Referenced by v8::internal::MarkCompactCollector::ClearDependentCode(), and MarkCodeForDeoptimization().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ slot_at()

Object ** v8::internal::DependentCode::slot_at ( int i )

inline

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

                                      {
   return RawFieldOfElementAt(kCodesStartIndex + i);
 }

References kCodesStartIndex, and v8::internal::FixedArray::RawFieldOfElementAt().

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

Here is the call graph for this function:

Here is the caller graph for this function:

◆ UpdateToFinishedCode()

void v8::internal::DependentCode::UpdateToFinishedCode	(	DependencyGroup	group,
		CompilationInfo *	info,
		Code *	code
	)

Definition at line 11450 of file objects.cc.

                                                      {
   DisallowHeapAllocation no_gc;
   AllowDeferredHandleDereference get_object_wrapper;
   Foreign* info_wrapper = *info->object_wrapper();
   GroupStartIndexes starts(this);
   int start = starts.at(group);
   int end = starts.at(group + 1);
   for (int i = start; i < end; i++) {
     if (object_at(i) == info_wrapper) {
       set_object_at(i, code);
       break;
     }
   }
  
 #ifdef DEBUG
   for (int i = start; i < end; i++) {
     DCHECK(is_code_at(i) || compilation_info_at(i) != info);
   }
 #endif
 }

References v8::internal::DependentCode::GroupStartIndexes::at(), compilation_info_at(), DCHECK, is_code_at(), object_at(), v8::internal::CompilationInfo::object_wrapper(), and set_object_at().

Here is the call graph for this function:

Member Data Documentation

◆ kCodesStartIndex

const int v8::internal::DependentCode::kCodesStartIndex = kGroupCount

staticprivate

Definition at line 5589 of file objects.h.

Referenced by clear_at(), code_at(), compilation_info_at(), copy(), Insert(), is_code_at(), object_at(), set_object_at(), and slot_at().

◆ kGroupCount

const int v8::internal::DependentCode::kGroupCount = kAllocationSiteTransitionChangedGroup + 1

static

Definition at line 5534 of file objects.h.

Referenced by v8::internal::MarkCompactCollector::ClearNonLiveDependentCode(), v8::internal::CompilationInfo::CommitDependencies(), ExtendGroup(), v8::internal::CompilationInfo::Initialize(), Insert(), v8::internal::DependentCode::GroupStartIndexes::Recompute(), RemoveCompilationInfo(), v8::internal::CompilationInfo::RollbackDependencies(), and v8::internal::CompilationInfo::~CompilationInfo().

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 Attributes

Additional Inherited Members

Detailed Description

Member Enumeration Documentation

◆ DependencyGroup

Member Function Documentation

◆ AddToDependentICList()

◆ clear_at()

◆ code_at()

◆ compilation_info_at()

◆ Contains()

◆ copy()

◆ DeoptimizeDependentCodeGroup()

◆ DependencyGroupName()

◆ ExtendGroup()

◆ ForObject()

◆ Insert()

◆ is_code_at()

◆ MarkCodeForDeoptimization()

◆ number_of_entries()

◆ object_at()

◆ RemoveCompilationInfo()

◆ set_number_of_entries()

◆ set_object_at()

◆ SetMarkedForDeoptimization()

◆ slot_at()

◆ UpdateToFinishedCode()

Member Data Documentation

◆ kCodesStartIndex

◆ kGroupCount