v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode > Class Template Reference

Inheritance diagram for v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >:

Collaboration diagram for v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >:

Classes
class	ObjectEvacuationStrategy

Static Public Member Functions
static void	Initialize ()
static VisitorDispatchTable< ScavengingCallback > *	GetTable ()
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)

Private Types
enum	ObjectContents { DATA_OBJECT , POINTER_OBJECT }

Private Member Functions
	INLINE (static void MigrateObject(Heap *heap, HeapObject *source, HeapObject *target, int size))

Static Private Member Functions
static void	RecordCopiedObject (Heap *heap, HeapObject *obj)
template<int alignment>
static bool	SemiSpaceCopyObject (Map *map, HeapObject **slot, HeapObject *object, int object_size)
template<ObjectContents object_contents, int alignment>
static bool	PromoteObject (Map *map, HeapObject **slot, HeapObject *object, int object_size)
template<ObjectContents object_contents, int alignment>
static void	EvacuateObject (Map *map, HeapObject **slot, HeapObject *object, int object_size)
static void	EvacuateJSFunction (Map *map, HeapObject **slot, HeapObject *object)
static void	EvacuateFixedArray (Map *map, HeapObject **slot, HeapObject *object)
static void	EvacuateFixedDoubleArray (Map *map, HeapObject **slot, HeapObject *object)
static void	EvacuateFixedTypedArray (Map *map, HeapObject **slot, HeapObject *object)
static void	EvacuateFixedFloat64Array (Map *map, HeapObject **slot, HeapObject *object)
static void	EvacuateByteArray (Map *map, HeapObject **slot, HeapObject *object)
static void	EvacuateSeqOneByteString (Map *map, HeapObject **slot, HeapObject *object)
static void	EvacuateSeqTwoByteString (Map *map, HeapObject **slot, HeapObject *object)
static void	EvacuateShortcutCandidate (Map *map, HeapObject **slot, HeapObject *object)

Static Private Attributes
static VisitorDispatchTable< ScavengingCallback >	table_

Additional Inherited Members
Public Types inherited from v8::internal::StaticVisitorBase
enum	VisitorId {   kVisitorIdCount , kVisitDataObject = kVisitDataObject2 , kVisitJSObject = kVisitJSObject2 , kVisitStruct = kVisitStruct2 ,   kMinObjectSizeInWords = 2 }
Public Member Functions inherited from v8::internal::StaticVisitorBase
	STATIC_ASSERT (kVisitorIdCount<=256)

Detailed Description

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>
class v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >

Definition at line 1823 of file heap.cc.

Member Enumeration Documentation

ObjectContents

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

enum v8::internal::ScavengingVisitor::ObjectContents

private

Enumerator
DATA_OBJECT
POINTER_OBJECT

Definition at line 1899 of file heap.cc.

{ DATA_OBJECT, POINTER_OBJECT };

Member Function Documentation

EvacuateByteArray()

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

static void v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateByteArray ( Map *  map, HeapObject **  slot, HeapObject *  object  )

inlinestaticprivate

Definition at line 2124 of file heap.cc.

                                                           {
    int object_size = reinterpret_cast<ByteArray*>(object)->ByteArraySize();
    EvacuateObject<DATA_OBJECT, kObjectAlignment>(map, slot, object,
                                                  object_size);
  }

References map.

Referenced by v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::Initialize().

Here is the caller graph for this function:

EvacuateFixedArray()

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

static void v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateFixedArray ( Map *  map, HeapObject **  slot, HeapObject *  object  )

inlinestaticprivate

Definition at line 2091 of file heap.cc.

                                                            {
    int object_size = FixedArray::BodyDescriptor::SizeOf(map, object);
    EvacuateObject<POINTER_OBJECT, kObjectAlignment>(map, slot, object,
                                                     object_size);
  }

References map, and v8::internal::FixedArray::BodyDescriptor::SizeOf().

Referenced by v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

EvacuateFixedDoubleArray()

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

static void v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateFixedDoubleArray ( Map *  map, HeapObject **  slot, HeapObject *  object  )

inlinestaticprivate

Definition at line 2099 of file heap.cc.

                                                                  {
    int length = reinterpret_cast<FixedDoubleArray*>(object)->length();
    int object_size = FixedDoubleArray::SizeFor(length);
    EvacuateObject<DATA_OBJECT, kDoubleAlignment>(map, slot, object,
                                                  object_size);
  }

References map, and v8::internal::FixedDoubleArray::SizeFor().

Referenced by v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

EvacuateFixedFloat64Array()

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

static void v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateFixedFloat64Array ( Map *  map, HeapObject **  slot, HeapObject *  object  )

inlinestaticprivate

Definition at line 2116 of file heap.cc.

                                                                   {
    int object_size = reinterpret_cast<FixedFloat64Array*>(object)->size();
    EvacuateObject<DATA_OBJECT, kDoubleAlignment>(map, slot, object,
                                                  object_size);
  }

References map, and size.

Referenced by v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::Initialize().

Here is the caller graph for this function:

EvacuateFixedTypedArray()

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

static void v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateFixedTypedArray ( Map *  map, HeapObject **  slot, HeapObject *  object  )

inlinestaticprivate

Definition at line 2108 of file heap.cc.

                                                                 {
    int object_size = reinterpret_cast<FixedTypedArrayBase*>(object)->size();
    EvacuateObject<DATA_OBJECT, kObjectAlignment>(map, slot, object,
                                                  object_size);
  }

References map, and size.

Referenced by v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::Initialize().

Here is the caller graph for this function:

EvacuateJSFunction()

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

static void v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateJSFunction ( Map *  map, HeapObject **  slot, HeapObject *  object  )

inlinestaticprivate

Definition at line 2067 of file heap.cc.

                                                            {
    ObjectEvacuationStrategy<POINTER_OBJECT>::template VisitSpecialized<
        JSFunction::kSize>(map, slot, object);
 
    MapWord map_word = object->map_word();
    DCHECK(map_word.IsForwardingAddress());
    HeapObject* target = map_word.ToForwardingAddress();
 
    MarkBit mark_bit = Marking::MarkBitFrom(target);
    if (Marking::IsBlack(mark_bit)) {
      // This object is black and it might not be rescanned by marker.
      // We should explicitly record code entry slot for compaction because
      // promotion queue processing (IterateAndMarkPointersToFromSpace) will
      // miss it as it is not HeapObject-tagged.
      Address code_entry_slot =
          target->address() + JSFunction::kCodeEntryOffset;
      Code* code = Code::cast(Code::GetObjectFromEntryAddress(code_entry_slot));
      map->GetHeap()->mark_compact_collector()->RecordCodeEntrySlot(
          code_entry_slot, code);
    }
  }

References v8::internal::HeapObject::address(), DCHECK, v8::internal::Code::GetObjectFromEntryAddress(), v8::internal::JSFunction::kCodeEntryOffset, v8::internal::JSFunction::kSize, and map.

Referenced by v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

EvacuateObject()

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

template<ObjectContents object_contents, int alignment>

static void v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateObject ( Map *  map, HeapObject **  slot, HeapObject *  object, int  object_size  )

inlinestaticprivate

Definition at line 2041 of file heap.cc.

                                                                         {
    SLOW_DCHECK(object_size <= Page::kMaxRegularHeapObjectSize);
    SLOW_DCHECK(object->Size() == object_size);
    Heap* heap = map->GetHeap();
 
    if (!heap->ShouldBePromoted(object->address(), object_size)) {
      // A semi-space copy may fail due to fragmentation. In that case, we
      // try to promote the object.
      if (SemiSpaceCopyObject<alignment>(map, slot, object, object_size)) {
        return;
      }
    }
 
    if (PromoteObject<object_contents, alignment>(map, slot, object,
                                                  object_size)) {
      return;
    }
 
    // If promotion failed, we try to copy the object to the other semi-space
    if (SemiSpaceCopyObject<alignment>(map, slot, object, object_size)) return;
 
    UNREACHABLE();
  }

References v8::internal::HeapObject::address(), v8::internal::Page::kMaxRegularHeapObjectSize, map, v8::internal::Heap::ShouldBePromoted(), v8::internal::HeapObject::Size(), SLOW_DCHECK, and UNREACHABLE.

Here is the call graph for this function:

EvacuateSeqOneByteString()

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

static void v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateSeqOneByteString ( Map *  map, HeapObject **  slot, HeapObject *  object  )

inlinestaticprivate

Definition at line 2132 of file heap.cc.

                                                                  {
    int object_size = SeqOneByteString::cast(object)
                          ->SeqOneByteStringSize(map->instance_type());
    EvacuateObject<DATA_OBJECT, kObjectAlignment>(map, slot, object,
                                                  object_size);
  }

References map.

Referenced by v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::Initialize().

Here is the caller graph for this function:

EvacuateSeqTwoByteString()

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

static void v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateSeqTwoByteString ( Map *  map, HeapObject **  slot, HeapObject *  object  )

inlinestaticprivate

Definition at line 2141 of file heap.cc.

                                                                  {
    int object_size = SeqTwoByteString::cast(object)
                          ->SeqTwoByteStringSize(map->instance_type());
    EvacuateObject<DATA_OBJECT, kObjectAlignment>(map, slot, object,
                                                  object_size);
  }

References map.

Referenced by v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::Initialize().

Here is the caller graph for this function:

EvacuateShortcutCandidate()

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

static void v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateShortcutCandidate ( Map *  map, HeapObject **  slot, HeapObject *  object  )

inlinestaticprivate

Definition at line 2150 of file heap.cc.

                                                                   {
    DCHECK(IsShortcutCandidate(map->instance_type()));
 
    Heap* heap = map->GetHeap();
 
    if (marks_handling == IGNORE_MARKS &&
        ConsString::cast(object)->unchecked_second() == heap->empty_string()) {
      HeapObject* first =
          HeapObject::cast(ConsString::cast(object)->unchecked_first());
 
      *slot = first;
 
      if (!heap->InNewSpace(first)) {
        object->set_map_word(MapWord::FromForwardingAddress(first));
        return;
      }
 
      MapWord first_word = first->map_word();
      if (first_word.IsForwardingAddress()) {
        HeapObject* target = first_word.ToForwardingAddress();
 
        *slot = target;
        object->set_map_word(MapWord::FromForwardingAddress(target));
        return;
      }
 
      heap->DoScavengeObject(first->map(), slot, first);
      object->set_map_word(MapWord::FromForwardingAddress(*slot));
      return;
    }
 
    int object_size = ConsString::kSize;
    EvacuateObject<POINTER_OBJECT, kObjectAlignment>(map, slot, object,
                                                     object_size);
  }

References DCHECK, v8::internal::Heap::DoScavengeObject(), v8::internal::IGNORE_MARKS, v8::internal::Heap::InNewSpace(), v8::internal::IsShortcutCandidate(), v8::internal::ConsString::kSize, map, v8::internal::HeapObject::map(), v8::internal::HeapObject::map_word(), and v8::internal::HeapObject::set_map_word().

Referenced by v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::Initialize().

Here is the call graph for this function:

Here is the caller graph for this function:

GetTable()

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

static VisitorDispatchTable<ScavengingCallback>* v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::GetTable ( )

inlinestatic

Definition at line 1894 of file heap.cc.

                                                              {
    return &table_;
  }

References v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::table_.

Initialize()

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

static void v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::Initialize ( )

inlinestatic

Definition at line 1825 of file heap.cc.

                           {
    table_.Register(kVisitSeqOneByteString, &EvacuateSeqOneByteString);
    table_.Register(kVisitSeqTwoByteString, &EvacuateSeqTwoByteString);
    table_.Register(kVisitShortcutCandidate, &EvacuateShortcutCandidate);
    table_.Register(kVisitByteArray, &EvacuateByteArray);
    table_.Register(kVisitFixedArray, &EvacuateFixedArray);
    table_.Register(kVisitFixedDoubleArray, &EvacuateFixedDoubleArray);
    table_.Register(kVisitFixedTypedArray, &EvacuateFixedTypedArray);
    table_.Register(kVisitFixedFloat64Array, &EvacuateFixedFloat64Array);
 
    table_.Register(
        kVisitNativeContext,
        &ObjectEvacuationStrategy<POINTER_OBJECT>::template VisitSpecialized<
            Context::kSize>);
 
    table_.Register(
        kVisitConsString,
        &ObjectEvacuationStrategy<POINTER_OBJECT>::template VisitSpecialized<
            ConsString::kSize>);
 
    table_.Register(
        kVisitSlicedString,
        &ObjectEvacuationStrategy<POINTER_OBJECT>::template VisitSpecialized<
            SlicedString::kSize>);
 
    table_.Register(
        kVisitSymbol,
        &ObjectEvacuationStrategy<POINTER_OBJECT>::template VisitSpecialized<
            Symbol::kSize>);
 
    table_.Register(
        kVisitSharedFunctionInfo,
        &ObjectEvacuationStrategy<POINTER_OBJECT>::template VisitSpecialized<
            SharedFunctionInfo::kSize>);
 
    table_.Register(kVisitJSWeakCollection,
                    &ObjectEvacuationStrategy<POINTER_OBJECT>::Visit);
 
    table_.Register(kVisitJSArrayBuffer,
                    &ObjectEvacuationStrategy<POINTER_OBJECT>::Visit);
 
    table_.Register(kVisitJSTypedArray,
                    &ObjectEvacuationStrategy<POINTER_OBJECT>::Visit);
 
    table_.Register(kVisitJSDataView,
                    &ObjectEvacuationStrategy<POINTER_OBJECT>::Visit);
 
    table_.Register(kVisitJSRegExp,
                    &ObjectEvacuationStrategy<POINTER_OBJECT>::Visit);
 
    if (marks_handling == IGNORE_MARKS) {
      table_.Register(
          kVisitJSFunction,
          &ObjectEvacuationStrategy<POINTER_OBJECT>::template VisitSpecialized<
              JSFunction::kSize>);
    } else {
      table_.Register(kVisitJSFunction, &EvacuateJSFunction);
    }
 
    table_.RegisterSpecializations<ObjectEvacuationStrategy<DATA_OBJECT>,
                                   kVisitDataObject, kVisitDataObjectGeneric>();
 
    table_.RegisterSpecializations<ObjectEvacuationStrategy<POINTER_OBJECT>,
                                   kVisitJSObject, kVisitJSObjectGeneric>();
 
    table_.RegisterSpecializations<ObjectEvacuationStrategy<POINTER_OBJECT>,
                                   kVisitStruct, kVisitStructGeneric>();
  }

References v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateByteArray(), v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateFixedArray(), v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateFixedDoubleArray(), v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateFixedFloat64Array(), v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateFixedTypedArray(), v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateJSFunction(), v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateSeqOneByteString(), v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateSeqTwoByteString(), v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::EvacuateShortcutCandidate(), v8::internal::IGNORE_MARKS, v8::internal::Context::kSize, v8::internal::SharedFunctionInfo::kSize, v8::internal::JSFunction::kSize, v8::internal::Symbol::kSize, v8::internal::ConsString::kSize, v8::internal::SlicedString::kSize, v8::internal::StaticVisitorBase::kVisitDataObject, v8::internal::StaticVisitorBase::kVisitJSObject, v8::internal::StaticVisitorBase::kVisitStruct, v8::internal::VisitorDispatchTable< Callback >::Register(), v8::internal::VisitorDispatchTable< Callback >::RegisterSpecializations(), and v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::table_.

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

Here is the call graph for this function:

Here is the caller graph for this function:

INLINE()

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::INLINE ( static void   MigrateObjectHeap *heap, HeapObject *source, HeapObject *target, int size )

inlineprivate

Definition at line 1919 of file heap.cc.

                                                                  {
    // If we migrate into to-space, then the to-space top pointer should be
    // right after the target object. Incorporate double alignment
    // over-allocation.
    DCHECK(!heap->InToSpace(target) ||
           target->address() + size == heap->new_space()->top() ||
           target->address() + size + kPointerSize == heap->new_space()->top());
 
    // Make sure that we do not overwrite the promotion queue which is at
    // the end of to-space.
    DCHECK(!heap->InToSpace(target) ||
           heap->promotion_queue()->IsBelowPromotionQueue(
               heap->new_space()->top()));
 
    // Copy the content of source to target.
    heap->CopyBlock(target->address(), source->address(), size);
 
    // Set the forwarding address.
    source->set_map_word(MapWord::FromForwardingAddress(target));
 
    if (logging_and_profiling_mode == LOGGING_AND_PROFILING_ENABLED) {
      // Update NewSpace stats if necessary.
      RecordCopiedObject(heap, target);
      heap->OnMoveEvent(target, source, size);
    }
 
    if (marks_handling == TRANSFER_MARKS) {
      if (Marking::TransferColor(source, target)) {
        MemoryChunk::IncrementLiveBytesFromGC(target->address(), size);
      }
    }
  }

References v8::internal::HeapObject::address(), v8::internal::Heap::CopyBlock(), DCHECK, v8::internal::MemoryChunk::IncrementLiveBytesFromGC(), v8::internal::Heap::InToSpace(), v8::internal::PromotionQueue::IsBelowPromotionQueue(), v8::internal::kPointerSize, v8::internal::LOGGING_AND_PROFILING_ENABLED, v8::internal::Heap::new_space(), v8::internal::Heap::OnMoveEvent(), v8::internal::Heap::promotion_queue(), v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::RecordCopiedObject(), v8::internal::HeapObject::set_map_word(), size, v8::internal::NewSpace::top(), and v8::internal::TRANSFER_MARKS.

Here is the call graph for this function:

PromoteObject()

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

template<ObjectContents object_contents, int alignment>

static bool v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::PromoteObject ( Map *  map, HeapObject **  slot, HeapObject *  object, int  object_size  )

inlinestaticprivate

Definition at line 1994 of file heap.cc.

                                                                        {
    Heap* heap = map->GetHeap();
 
    int allocation_size = object_size;
    if (alignment != kObjectAlignment) {
      DCHECK(alignment == kDoubleAlignment);
      allocation_size += kPointerSize;
    }
 
    AllocationResult allocation;
    if (object_contents == DATA_OBJECT) {
      DCHECK(heap->AllowedToBeMigrated(object, OLD_DATA_SPACE));
      allocation = heap->old_data_space()->AllocateRaw(allocation_size);
    } else {
      DCHECK(heap->AllowedToBeMigrated(object, OLD_POINTER_SPACE));
      allocation = heap->old_pointer_space()->AllocateRaw(allocation_size);
    }
 
    HeapObject* target = NULL;  // Initialization to please compiler.
    if (allocation.To(&target)) {
      if (alignment != kObjectAlignment) {
        target = EnsureDoubleAligned(heap, target, allocation_size);
      }
 
      // Order is important: slot might be inside of the target if target
      // was allocated over a dead object and slot comes from the store
      // buffer.
      *slot = target;
      MigrateObject(heap, object, target, object_size);
 
      if (object_contents == POINTER_OBJECT) {
        if (map->instance_type() == JS_FUNCTION_TYPE) {
          heap->promotion_queue()->insert(target,
                                          JSFunction::kNonWeakFieldsEndOffset);
        } else {
          heap->promotion_queue()->insert(target, object_size);
        }
      }
      heap->IncrementPromotedObjectsSize(object_size);
      return true;
    }
    return false;
  }

References v8::internal::PagedSpace::AllocateRaw(), v8::internal::Heap::AllowedToBeMigrated(), v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::DATA_OBJECT, DCHECK, v8::internal::EnsureDoubleAligned(), v8::internal::Heap::IncrementPromotedObjectsSize(), v8::internal::PromotionQueue::insert(), v8::internal::JS_FUNCTION_TYPE, v8::internal::kDoubleAlignment, v8::internal::JSFunction::kNonWeakFieldsEndOffset, v8::internal::kObjectAlignment, v8::internal::kPointerSize, map, NULL, v8::internal::OLD_DATA_SPACE, v8::internal::Heap::old_data_space(), v8::internal::OLD_POINTER_SPACE, v8::internal::Heap::old_pointer_space(), v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::POINTER_OBJECT, v8::internal::Heap::promotion_queue(), and v8::internal::AllocationResult::To().

Here is the call graph for this function:

RecordCopiedObject()

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

static void v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::RecordCopiedObject ( Heap *  heap, HeapObject *  obj  )

inlinestaticprivate

Definition at line 1901 of file heap.cc.

                                                              {
    bool should_record = false;
#ifdef DEBUG
    should_record = FLAG_heap_stats;
#endif
    should_record = should_record || FLAG_log_gc;
    if (should_record) {
      if (heap->new_space()->Contains(obj)) {
        heap->new_space()->RecordAllocation(obj);
      } else {
        heap->new_space()->RecordPromotion(obj);
      }
    }
  }

References v8::internal::NewSpace::Contains(), v8::internal::Heap::new_space(), v8::internal::NewSpace::RecordAllocation(), and v8::internal::NewSpace::RecordPromotion().

Referenced by v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::INLINE().

Here is the call graph for this function:

Here is the caller graph for this function:

SemiSpaceCopyObject()

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

template<int alignment>

static bool v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::SemiSpaceCopyObject ( Map *  map, HeapObject **  slot, HeapObject *  object, int  object_size  )

inlinestaticprivate

Definition at line 1954 of file heap.cc.

                                                                              {
    Heap* heap = map->GetHeap();
 
    int allocation_size = object_size;
    if (alignment != kObjectAlignment) {
      DCHECK(alignment == kDoubleAlignment);
      allocation_size += kPointerSize;
    }
 
    DCHECK(heap->AllowedToBeMigrated(object, NEW_SPACE));
    AllocationResult allocation =
        heap->new_space()->AllocateRaw(allocation_size);
 
    HeapObject* target = NULL;  // Initialization to please compiler.
    if (allocation.To(&target)) {
      // Order is important here: Set the promotion limit before storing a
      // filler for double alignment or migrating the object. Otherwise we
      // may end up overwriting promotion queue entries when we migrate the
      // object.
      heap->promotion_queue()->SetNewLimit(heap->new_space()->top());
 
      if (alignment != kObjectAlignment) {
        target = EnsureDoubleAligned(heap, target, allocation_size);
      }
 
      // Order is important: slot might be inside of the target if target
      // was allocated over a dead object and slot comes from the store
      // buffer.
      *slot = target;
      MigrateObject(heap, object, target, object_size);
 
      heap->IncrementSemiSpaceCopiedObjectSize(object_size);
      return true;
    }
    return false;
  }

References v8::internal::Heap::AllowedToBeMigrated(), DCHECK, v8::internal::EnsureDoubleAligned(), v8::internal::Heap::IncrementSemiSpaceCopiedObjectSize(), v8::internal::kDoubleAlignment, v8::internal::kObjectAlignment, v8::internal::kPointerSize, map, v8::internal::NEW_SPACE, v8::internal::Heap::new_space(), NULL, v8::internal::Heap::promotion_queue(), v8::internal::PromotionQueue::SetNewLimit(), v8::internal::AllocationResult::To(), and v8::internal::NewSpace::top().

Here is the call graph for this function:

Member Data Documentation

table_

template<MarksHandling marks_handling, LoggingAndProfiling logging_and_profiling_mode>

VisitorDispatchTable< ScavengingCallback > v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::table_

staticprivate

Definition at line 2204 of file heap.cc.

Referenced by v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::GetTable(), and v8::internal::ScavengingVisitor< marks_handling, logging_and_profiling_mode >::Initialize().

---

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

• /mnt/V8SourceCode/src/heap/heap.cc