v8::internal::StaticMarkingVisitor< StaticVisitor > Class Template Reference

#include <objects-visiting.h>

Inheritance diagram for v8::internal::StaticMarkingVisitor< StaticVisitor >:

Collaboration diagram for v8::internal::StaticMarkingVisitor< StaticVisitor >:

Classes
class	DataObjectVisitor

Public Member Functions
	INLINE (static void IterateBody(Map *map, HeapObject *obj))
	INLINE (static void VisitPropertyCell(Map *map, HeapObject *object))
	INLINE (static void VisitCodeEntry(Heap *heap, Address entry_address))
	INLINE (static void VisitEmbeddedPointer(Heap *heap, RelocInfo *rinfo))
	INLINE (static void VisitCell(Heap *heap, RelocInfo *rinfo))
	INLINE (static void VisitDebugTarget(Heap *heap, RelocInfo *rinfo))
	INLINE (static void VisitCodeTarget(Heap *heap, RelocInfo *rinfo))
	INLINE (static void VisitCodeAgeSequence(Heap *heap, RelocInfo *rinfo))
	INLINE (static void VisitExternalReference(RelocInfo *rinfo))
	INLINE (static void VisitRuntimeEntry(RelocInfo *rinfo))
	INLINE (static void VisitNextCodeLink(Heap *heap, Object **slot))
Public Member Functions inherited from v8::internal::StaticVisitorBase
	STATIC_ASSERT (kVisitorIdCount<=256)

Static Public Member Functions
static void	Initialize ()
static void	MarkInlinedFunctionsCode (Heap *heap, Code *code)
Static Public Member Functions inherited from v8::internal::StaticVisitorBase
static VisitorId	GetVisitorId (int instance_type, int instance_size)
static VisitorId	GetVisitorId (Map *map)
static VisitorId	GetVisitorIdForSize (VisitorId base, VisitorId generic, int object_size)

Protected Types
typedef FlexibleBodyVisitor< StaticVisitor, FixedArray::BodyDescriptor, void >	FixedArrayVisitor
typedef FlexibleBodyVisitor< StaticVisitor, JSObject::BodyDescriptor, void >	JSObjectVisitor
typedef FlexibleBodyVisitor< StaticVisitor, StructBodyDescriptor, void >	StructObjectVisitor
typedef void(*	Callback) (Map *map, HeapObject *object)

Protected Member Functions
	INLINE (static void VisitMap(Map *map, HeapObject *object))
	INLINE (static void VisitCode(Map *map, HeapObject *object))
	INLINE (static void VisitSharedFunctionInfo(Map *map, HeapObject *object))
	INLINE (static void VisitConstantPoolArray(Map *map, HeapObject *object))
	INLINE (static void VisitAllocationSite(Map *map, HeapObject *object))
	INLINE (static void VisitWeakCollection(Map *map, HeapObject *object))
	INLINE (static void VisitJSFunction(Map *map, HeapObject *object))
	INLINE (static void VisitJSRegExp(Map *map, HeapObject *object))
	INLINE (static void VisitJSArrayBuffer(Map *map, HeapObject *object))
	INLINE (static void VisitJSTypedArray(Map *map, HeapObject *object))
	INLINE (static void VisitJSDataView(Map *map, HeapObject *object))
	INLINE (static void VisitNativeContext(Map *map, HeapObject *object))
	INLINE (static bool IsFlushable(Heap *heap, JSFunction *function))
	INLINE (static bool IsFlushable(Heap *heap, SharedFunctionInfo *shared_info))

Static Protected Member Functions
static void	MarkMapContents (Heap *heap, Map *map)
static void	MarkTransitionArray (Heap *heap, TransitionArray *transitions)
static void	VisitSharedFunctionInfoStrongCode (Heap *heap, HeapObject *object)
static void	VisitSharedFunctionInfoWeakCode (Heap *heap, HeapObject *object)
static void	VisitJSFunctionStrongCode (Heap *heap, HeapObject *object)
static void	VisitJSFunctionWeakCode (Heap *heap, HeapObject *object)

Static Protected Attributes
static VisitorDispatchTable< Callback >	table_

Additional Inherited Members
Public Types inherited from v8::internal::StaticVisitorBase
enum	VisitorId {   kVisitorIdCount , kVisitDataObject = kVisitDataObject2 , kVisitJSObject = kVisitJSObject2 , kVisitStruct = kVisitStruct2 ,   kMinObjectSizeInWords = 2 }

Detailed Description

template<typename StaticVisitor>
class v8::internal::StaticMarkingVisitor< StaticVisitor >

Definition at line 356 of file objects-visiting.h.

Member Typedef Documentation

Callback

template<typename StaticVisitor >

typedef void(* v8::internal::StaticMarkingVisitor< StaticVisitor >::Callback) (Map *map, HeapObject *object)

protected

Definition at line 428 of file objects-visiting.h.

FixedArrayVisitor

template<typename StaticVisitor >

typedef FlexibleBodyVisitor<StaticVisitor, FixedArray::BodyDescriptor, void> v8::internal::StaticMarkingVisitor< StaticVisitor >::FixedArrayVisitor

protected

Definition at line 420 of file objects-visiting.h.

JSObjectVisitor

template<typename StaticVisitor >

typedef FlexibleBodyVisitor<StaticVisitor, JSObject::BodyDescriptor, void> v8::internal::StaticMarkingVisitor< StaticVisitor >::JSObjectVisitor

protected

Definition at line 423 of file objects-visiting.h.

StructObjectVisitor

template<typename StaticVisitor >

typedef FlexibleBodyVisitor<StaticVisitor, StructBodyDescriptor, void> v8::internal::StaticMarkingVisitor< StaticVisitor >::StructObjectVisitor

protected

Definition at line 426 of file objects-visiting.h.

Member Function Documentation

Initialize()

template<typename StaticVisitor >

void v8::internal::StaticMarkingVisitor< StaticVisitor >::Initialize

static

Definition at line 127 of file objects-visiting-inl.h.

                                                     {
  table_.Register(kVisitShortcutCandidate,
                  &FixedBodyVisitor<StaticVisitor, ConsString::BodyDescriptor,
                                    void>::Visit);
 
  table_.Register(kVisitConsString,
                  &FixedBodyVisitor<StaticVisitor, ConsString::BodyDescriptor,
                                    void>::Visit);
 
  table_.Register(kVisitSlicedString,
                  &FixedBodyVisitor<StaticVisitor, SlicedString::BodyDescriptor,
                                    void>::Visit);
 
  table_.Register(
      kVisitSymbol,
      &FixedBodyVisitor<StaticVisitor, Symbol::BodyDescriptor, void>::Visit);
 
  table_.Register(kVisitFixedArray, &FixedArrayVisitor::Visit);
 
  table_.Register(kVisitFixedDoubleArray, &DataObjectVisitor::Visit);
 
  table_.Register(kVisitFixedTypedArray, &DataObjectVisitor::Visit);
 
  table_.Register(kVisitFixedFloat64Array, &DataObjectVisitor::Visit);
 
  table_.Register(kVisitConstantPoolArray, &VisitConstantPoolArray);
 
  table_.Register(kVisitNativeContext, &VisitNativeContext);
 
  table_.Register(kVisitAllocationSite, &VisitAllocationSite);
 
  table_.Register(kVisitByteArray, &DataObjectVisitor::Visit);
 
  table_.Register(kVisitFreeSpace, &DataObjectVisitor::Visit);
 
  table_.Register(kVisitSeqOneByteString, &DataObjectVisitor::Visit);
 
  table_.Register(kVisitSeqTwoByteString, &DataObjectVisitor::Visit);
 
  table_.Register(kVisitJSWeakCollection, &VisitWeakCollection);
 
  table_.Register(
      kVisitOddball,
      &FixedBodyVisitor<StaticVisitor, Oddball::BodyDescriptor, void>::Visit);
 
  table_.Register(kVisitMap, &VisitMap);
 
  table_.Register(kVisitCode, &VisitCode);
 
  table_.Register(kVisitSharedFunctionInfo, &VisitSharedFunctionInfo);
 
  table_.Register(kVisitJSFunction, &VisitJSFunction);
 
  table_.Register(kVisitJSArrayBuffer, &VisitJSArrayBuffer);
 
  table_.Register(kVisitJSTypedArray, &VisitJSTypedArray);
 
  table_.Register(kVisitJSDataView, &VisitJSDataView);
 
  // Registration for kVisitJSRegExp is done by StaticVisitor.
 
  table_.Register(
      kVisitCell,
      &FixedBodyVisitor<StaticVisitor, Cell::BodyDescriptor, void>::Visit);
 
  table_.Register(kVisitPropertyCell, &VisitPropertyCell);
 
  table_.template RegisterSpecializations<DataObjectVisitor, kVisitDataObject,
                                          kVisitDataObjectGeneric>();
 
  table_.template RegisterSpecializations<JSObjectVisitor, kVisitJSObject,
                                          kVisitJSObjectGeneric>();
 
  table_.template RegisterSpecializations<StructObjectVisitor, kVisitStruct,
                                          kVisitStructGeneric>();
}

Referenced by v8::internal::IncrementalMarkingMarkingVisitor::Initialize(), and v8::internal::MarkCompactMarkingVisitor::Initialize().

Here is the caller graph for this function:

INLINE() [1/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static bool   IsFlushableHeap *heap, JSFunction *function )

protected

INLINE() [2/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static bool   IsFlushableHeap *heap, SharedFunctionInfo *shared_info )

protected

INLINE() [3/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static void   IterateBodyMap *map, HeapObject *obj )

inline

Definition at line 360 of file objects-visiting.h.

                                                             {
    table_.GetVisitor(map)(map, obj);
  }

References map, and v8::internal::StaticMarkingVisitor< StaticVisitor >::table_.

INLINE() [4/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static void   VisitAllocationSiteMap *map, HeapObject *object )

protected

INLINE() [5/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE

(

static void

VisitCellHeap *heap, RelocInfo *rinfo

)

INLINE() [6/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static void   VisitCodeMap *map, HeapObject *object )

protected

INLINE() [7/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE

(

static void

VisitCodeAgeSequenceHeap *heap, RelocInfo *rinfo

)

INLINE() [8/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE

(

static void

VisitCodeEntryHeap *heap, Address entry_address

)

INLINE() [9/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE

(

static void

VisitCodeTargetHeap *heap, RelocInfo *rinfo

)

INLINE() [10/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static void   VisitConstantPoolArrayMap *map, HeapObject *object )

protected

INLINE() [11/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE

(

static void

VisitDebugTargetHeap *heap, RelocInfo *rinfo

)

INLINE() [12/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE

(

static void

VisitEmbeddedPointerHeap *heap, RelocInfo *rinfo

)

INLINE() [13/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static void   VisitExternalReferenceRelocInfo *rinfo )

inline

Definition at line 371 of file objects-visiting.h.

{}

INLINE() [14/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static void   VisitJSArrayBufferMap *map, HeapObject *object )

protected

INLINE() [15/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static void   VisitJSDataViewMap *map, HeapObject *object )

protected

INLINE() [16/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static void   VisitJSFunctionMap *map, HeapObject *object )

protected

INLINE() [17/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static void   VisitJSRegExpMap *map, HeapObject *object )

protected

INLINE() [18/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static void   VisitJSTypedArrayMap *map, HeapObject *object )

protected

INLINE() [19/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static void   VisitMapMap *map, HeapObject *object )

protected

INLINE() [20/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static void   VisitNativeContextMap *map, HeapObject *object )

protected

INLINE() [21/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static void   VisitNextCodeLinkHeap *heap, Object **slot )

inline

Definition at line 374 of file objects-visiting.h.

{}

INLINE() [22/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE

(

static void

VisitPropertyCellMap *map, HeapObject *object

)

INLINE() [23/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static void   VisitRuntimeEntryRelocInfo *rinfo )

inline

Definition at line 372 of file objects-visiting.h.

{}

INLINE() [24/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static void   VisitSharedFunctionInfoMap *map, HeapObject *object )

protected

INLINE() [25/25]

template<typename StaticVisitor >

v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE ( static void   VisitWeakCollectionMap *map, HeapObject *object )

protected

MarkInlinedFunctionsCode()

template<typename StaticVisitor >

void v8::internal::StaticMarkingVisitor< StaticVisitor >::MarkInlinedFunctionsCode ( Heap *  heap, Code *  code  )

static

Definition at line 678 of file objects-visiting-inl.h.

                                                                               {
  // Skip in absence of inlining.
  // TODO(turbofan): Revisit once we support inlining.
  if (code->is_turbofanned()) return;
  // For optimized functions we should retain both non-optimized version
  // of its code and non-optimized version of all inlined functions.
  // This is required to support bailing out from inlined code.
  DeoptimizationInputData* data =
      DeoptimizationInputData::cast(code->deoptimization_data());
  FixedArray* literals = data->LiteralArray();
  for (int i = 0, count = data->InlinedFunctionCount()->value(); i < count;
       i++) {
    JSFunction* inlined = JSFunction::cast(literals->get(i));
    StaticVisitor::MarkObject(heap, inlined->shared()->code());
  }
}

References v8::internal::JSFunction::code(), v8::internal::Code::is_turbofanned(), and literals().

Here is the call graph for this function:

MarkMapContents()

template<typename StaticVisitor >

void v8::internal::StaticMarkingVisitor< StaticVisitor >::MarkMapContents ( Heap *  heap, Map *  map  )

staticprotected

Definition at line 601 of file objects-visiting-inl.h.

                                                                    {
  // Make sure that the back pointer stored either in the map itself or
  // inside its transitions array is marked. Skip recording the back
  // pointer slot since map space is not compacted.
  StaticVisitor::MarkObject(heap, HeapObject::cast(map->GetBackPointer()));
 
  // Treat pointers in the transitions array as weak and also mark that
  // array to prevent visiting it later. Skip recording the transition
  // array slot, since it will be implicitly recorded when the pointer
  // fields of this map are visited.
  if (map->HasTransitionArray()) {
    TransitionArray* transitions = map->transitions();
    MarkTransitionArray(heap, transitions);
  }
 
  // Since descriptor arrays are potentially shared, ensure that only the
  // descriptors that belong to this map are marked. The first time a
  // non-empty descriptor array is marked, its header is also visited. The slot
  // holding the descriptor array will be implicitly recorded when the pointer
  // fields of this map are visited.
  DescriptorArray* descriptors = map->instance_descriptors();
  if (StaticVisitor::MarkObjectWithoutPush(heap, descriptors) &&
      descriptors->length() > 0) {
    StaticVisitor::VisitPointers(heap, descriptors->GetFirstElementAddress(),
                                 descriptors->GetDescriptorEndSlot(0));
  }
  int start = 0;
  int end = map->NumberOfOwnDescriptors();
  if (start < end) {
    StaticVisitor::VisitPointers(heap,
                                 descriptors->GetDescriptorStartSlot(start),
                                 descriptors->GetDescriptorEndSlot(end));
  }
 
  // Mark prototype dependent codes array but do not push it onto marking
  // stack, this will make references from it weak. We will clean dead
  // codes when we iterate over maps in ClearNonLiveTransitions.
  Object** slot = HeapObject::RawField(map, Map::kDependentCodeOffset);
  HeapObject* obj = HeapObject::cast(*slot);
  heap->mark_compact_collector()->RecordSlot(slot, slot, obj);
  StaticVisitor::MarkObjectWithoutPush(heap, obj);
 
  // Mark the pointer fields of the Map. Since the transitions array has
  // been marked already, it is fine that one of these fields contains a
  // pointer to it.
  StaticVisitor::VisitPointers(
      heap, HeapObject::RawField(map, Map::kPointerFieldsBeginOffset),
      HeapObject::RawField(map, Map::kPointerFieldsEndOffset));
}

References v8::internal::DescriptorArray::GetDescriptorEndSlot(), v8::internal::DescriptorArray::GetDescriptorStartSlot(), v8::internal::FixedArray::GetFirstElementAddress(), v8::internal::Map::kDependentCodeOffset, v8::internal::Map::kPointerFieldsBeginOffset, v8::internal::Map::kPointerFieldsEndOffset, v8::internal::FixedArrayBase::length(), map, v8::internal::Heap::mark_compact_collector(), and v8::internal::HeapObject::RawField().

Here is the call graph for this function:

MarkTransitionArray()

template<typename StaticVisitor >

void v8::internal::StaticMarkingVisitor< StaticVisitor >::MarkTransitionArray ( Heap *  heap, TransitionArray *  transitions  )

staticprotected

Definition at line 654 of file objects-visiting-inl.h.

                                              {
  if (!StaticVisitor::MarkObjectWithoutPush(heap, transitions)) return;
 
  // Simple transitions do not have keys nor prototype transitions.
  if (transitions->IsSimpleTransition()) return;
 
  if (transitions->HasPrototypeTransitions()) {
    // Mark prototype transitions array but do not push it onto marking
    // stack, this will make references from it weak. We will clean dead
    // prototype transitions in ClearNonLiveTransitions.
    Object** slot = transitions->GetPrototypeTransitionsSlot();
    HeapObject* obj = HeapObject::cast(*slot);
    heap->mark_compact_collector()->RecordSlot(slot, slot, obj);
    StaticVisitor::MarkObjectWithoutPush(heap, obj);
  }
 
  for (int i = 0; i < transitions->number_of_transitions(); ++i) {
    StaticVisitor::VisitPointer(heap, transitions->GetKeySlot(i));
  }
}

References v8::internal::TransitionArray::GetKeySlot(), v8::internal::TransitionArray::GetPrototypeTransitionsSlot(), v8::internal::TransitionArray::HasPrototypeTransitions(), v8::internal::TransitionArray::IsSimpleTransition(), v8::internal::Heap::mark_compact_collector(), and v8::internal::TransitionArray::number_of_transitions().

Here is the call graph for this function:

VisitJSFunctionStrongCode()

template<typename StaticVisitor >

void v8::internal::StaticMarkingVisitor< StaticVisitor >::VisitJSFunctionStrongCode ( Heap *  heap, HeapObject *  object  )

staticprotected

Definition at line 832 of file objects-visiting-inl.h.

                                    {
  Object** start_slot =
      HeapObject::RawField(object, JSFunction::kPropertiesOffset);
  Object** end_slot =
      HeapObject::RawField(object, JSFunction::kCodeEntryOffset);
  StaticVisitor::VisitPointers(heap, start_slot, end_slot);
 
  VisitCodeEntry(heap, object->address() + JSFunction::kCodeEntryOffset);
  STATIC_ASSERT(JSFunction::kCodeEntryOffset + kPointerSize ==
                JSFunction::kPrototypeOrInitialMapOffset);
 
  start_slot =
      HeapObject::RawField(object, JSFunction::kPrototypeOrInitialMapOffset);
  end_slot = HeapObject::RawField(object, JSFunction::kNonWeakFieldsEndOffset);
  StaticVisitor::VisitPointers(heap, start_slot, end_slot);
}

References v8::internal::HeapObject::address(), v8::internal::JSFunction::kCodeEntryOffset, v8::internal::JSFunction::kNonWeakFieldsEndOffset, v8::internal::kPointerSize, v8::internal::JSObject::kPropertiesOffset, v8::internal::JSFunction::kPrototypeOrInitialMapOffset, v8::internal::HeapObject::RawField(), and v8::internal::STATIC_ASSERT().

Here is the call graph for this function:

VisitJSFunctionWeakCode()

template<typename StaticVisitor >

void v8::internal::StaticMarkingVisitor< StaticVisitor >::VisitJSFunctionWeakCode ( Heap *  heap, HeapObject *  object  )

staticprotected

Definition at line 852 of file objects-visiting-inl.h.

                                    {
  Object** start_slot =
      HeapObject::RawField(object, JSFunction::kPropertiesOffset);
  Object** end_slot =
      HeapObject::RawField(object, JSFunction::kCodeEntryOffset);
  StaticVisitor::VisitPointers(heap, start_slot, end_slot);
 
  // Skip visiting kCodeEntryOffset as it is treated weakly here.
  STATIC_ASSERT(JSFunction::kCodeEntryOffset + kPointerSize ==
                JSFunction::kPrototypeOrInitialMapOffset);
 
  start_slot =
      HeapObject::RawField(object, JSFunction::kPrototypeOrInitialMapOffset);
  end_slot = HeapObject::RawField(object, JSFunction::kNonWeakFieldsEndOffset);
  StaticVisitor::VisitPointers(heap, start_slot, end_slot);
}

References v8::internal::JSFunction::kCodeEntryOffset, v8::internal::JSFunction::kNonWeakFieldsEndOffset, v8::internal::kPointerSize, v8::internal::JSObject::kPropertiesOffset, v8::internal::JSFunction::kPrototypeOrInitialMapOffset, v8::internal::HeapObject::RawField(), and v8::internal::STATIC_ASSERT().

Here is the call graph for this function:

VisitSharedFunctionInfoStrongCode()

template<typename StaticVisitor >

void v8::internal::StaticMarkingVisitor< StaticVisitor >::VisitSharedFunctionInfoStrongCode ( Heap *  heap, HeapObject *  object  )

staticprotected

Definition at line 800 of file objects-visiting-inl.h.

                                    {
  Object** start_slot = HeapObject::RawField(
      object, SharedFunctionInfo::BodyDescriptor::kStartOffset);
  Object** end_slot = HeapObject::RawField(
      object, SharedFunctionInfo::BodyDescriptor::kEndOffset);
  StaticVisitor::VisitPointers(heap, start_slot, end_slot);
}

References v8::internal::FixedBodyDescriptor< start_offset, end_offset, size >::kEndOffset, v8::internal::FixedBodyDescriptor< start_offset, end_offset, size >::kStartOffset, and v8::internal::HeapObject::RawField().

Here is the call graph for this function:

VisitSharedFunctionInfoWeakCode()

template<typename StaticVisitor >

void v8::internal::StaticMarkingVisitor< StaticVisitor >::VisitSharedFunctionInfoWeakCode ( Heap *  heap, HeapObject *  object  )

staticprotected

Definition at line 811 of file objects-visiting-inl.h.

                                    {
  Object** name_slot =
      HeapObject::RawField(object, SharedFunctionInfo::kNameOffset);
  StaticVisitor::VisitPointer(heap, name_slot);
 
  // Skip visiting kCodeOffset as it is treated weakly here.
  STATIC_ASSERT(SharedFunctionInfo::kNameOffset + kPointerSize ==
                SharedFunctionInfo::kCodeOffset);
  STATIC_ASSERT(SharedFunctionInfo::kCodeOffset + kPointerSize ==
                SharedFunctionInfo::kOptimizedCodeMapOffset);
 
  Object** start_slot =
      HeapObject::RawField(object, SharedFunctionInfo::kOptimizedCodeMapOffset);
  Object** end_slot = HeapObject::RawField(
      object, SharedFunctionInfo::BodyDescriptor::kEndOffset);
  StaticVisitor::VisitPointers(heap, start_slot, end_slot);
}

References v8::internal::SharedFunctionInfo::kCodeOffset, v8::internal::FixedBodyDescriptor< start_offset, end_offset, size >::kEndOffset, v8::internal::SharedFunctionInfo::kNameOffset, v8::internal::SharedFunctionInfo::kOptimizedCodeMapOffset, v8::internal::kPointerSize, v8::internal::HeapObject::RawField(), and v8::internal::STATIC_ASSERT().

Here is the call graph for this function:

Member Data Documentation

table_

template<typename StaticVisitor >

VisitorDispatchTable< typename StaticMarkingVisitor< StaticVisitor >::Callback > v8::internal::StaticMarkingVisitor< StaticVisitor >::table_

staticprotected

Definition at line 430 of file objects-visiting.h.

Referenced by v8::internal::StaticMarkingVisitor< StaticVisitor >::INLINE().

---

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

• /mnt/V8SourceCode/src/heap/objects-visiting.h
• /mnt/V8SourceCode/src/heap/objects-visiting-inl.h