#include <heap-snapshot-generator.h>

Inheritance diagram for v8::internal::V8HeapExplorer:

Collaboration diagram for v8::internal::V8HeapExplorer:

Public Member Functions
	V8HeapExplorer (HeapSnapshot snapshot, SnapshottingProgressReportingInterface progress, v8::HeapProfiler::ObjectNameResolver *resolver)

virtual	~V8HeapExplorer ()

virtual HeapEntry *	AllocateEntry (HeapThing ptr)

void	AddRootEntries (SnapshotFiller *filler)

int	EstimateObjectsCount (HeapIterator *iterator)

bool	IterateAndExtractReferences (SnapshotFiller *filler)

void	TagGlobalObjects ()

void	TagCodeObject (Code *code)

void	TagBuiltinCodeObject (Code code, const char name)

HeapEntry *	AddEntry (Address address, HeapEntry::Type type, const char *name, size_t size)

Public Member Functions inherited from v8::internal::HeapEntriesAllocator
virtual	~HeapEntriesAllocator ()

Static Public Member Functions
static String *	GetConstructorName (JSObject *object)

Private Types
typedef bool(V8HeapExplorer::*	ExtractReferencesMethod) (int entry, HeapObject *object)

Private Member Functions
HeapEntry *	AddEntry (HeapObject *object)

HeapEntry *	AddEntry (HeapObject object, HeapEntry::Type type, const char name)

const char *	GetSystemEntryName (HeapObject *object)

template<V8HeapExplorer::ExtractReferencesMethod extractor>
bool	IterateAndExtractSinglePass ()

bool	ExtractReferencesPass1 (int entry, HeapObject *obj)

bool	ExtractReferencesPass2 (int entry, HeapObject *obj)

void	ExtractJSGlobalProxyReferences (int entry, JSGlobalProxy *proxy)

void	ExtractJSObjectReferences (int entry, JSObject *js_obj)

void	ExtractStringReferences (int entry, String *obj)

void	ExtractSymbolReferences (int entry, Symbol *symbol)

void	ExtractJSCollectionReferences (int entry, JSCollection *collection)

void	ExtractJSWeakCollectionReferences (int entry, JSWeakCollection *collection)

void	ExtractContextReferences (int entry, Context *context)

void	ExtractMapReferences (int entry, Map *map)

void	ExtractSharedFunctionInfoReferences (int entry, SharedFunctionInfo *shared)

void	ExtractScriptReferences (int entry, Script *script)

void	ExtractAccessorInfoReferences (int entry, AccessorInfo *accessor_info)

void	ExtractAccessorPairReferences (int entry, AccessorPair *accessors)

void	ExtractCodeCacheReferences (int entry, CodeCache *code_cache)

void	ExtractCodeReferences (int entry, Code *code)

void	ExtractBoxReferences (int entry, Box *box)

void	ExtractCellReferences (int entry, Cell *cell)

void	ExtractPropertyCellReferences (int entry, PropertyCell *cell)

void	ExtractAllocationSiteReferences (int entry, AllocationSite *site)

void	ExtractJSArrayBufferReferences (int entry, JSArrayBuffer *buffer)

void	ExtractFixedArrayReferences (int entry, FixedArray *array)

void	ExtractClosureReferences (JSObject *js_obj, int entry)

void	ExtractPropertyReferences (JSObject *js_obj, int entry)

bool	ExtractAccessorPairProperty (JSObject js_obj, int entry, Object key, Object *callback_obj)

void	ExtractElementReferences (JSObject *js_obj, int entry)

void	ExtractInternalReferences (JSObject *js_obj, int entry)

bool	IsEssentialObject (Object *object)

void	SetContextReference (HeapObject parent_obj, int parent, String reference_name, Object *child, int field_offset)

void	SetNativeBindReference (HeapObject parent_obj, int parent, const char reference_name, Object *child)

void	SetElementReference (HeapObject parent_obj, int parent, int index, Object child)

void	SetInternalReference (HeapObject parent_obj, int parent, const char reference_name, Object *child, int field_offset=-1)

void	SetInternalReference (HeapObject parent_obj, int parent, int index, Object child, int field_offset=-1)

void	SetHiddenReference (HeapObject parent_obj, int parent, int index, Object child)

void	SetWeakReference (HeapObject parent_obj, int parent, const char reference_name, Object *child_obj, int field_offset)

void	SetWeakReference (HeapObject parent_obj, int parent, int index, Object child_obj, int field_offset)

void	SetPropertyReference (HeapObject parent_obj, int parent, Name reference_name, Object child, const char name_format_string=NULL, int field_offset=-1)

void	SetUserGlobalReference (Object *user_global)

void	SetRootGcRootsReference ()

void	SetGcRootsReference (VisitorSynchronization::SyncTag tag)

void	SetGcSubrootReference (VisitorSynchronization::SyncTag tag, bool is_weak, Object *child)

const char *	GetStrongGcSubrootName (Object *object)

void	TagObject (Object obj, const char tag)

void	MarkAsWeakContainer (Object *object)

HeapEntry *	GetEntry (Object *obj)

	DISALLOW_COPY_AND_ASSIGN (V8HeapExplorer)

Friends
class	IndexedReferencesExtractor

class	RootsReferencesExtractor

Detailed Description

Definition at line 328 of file heap-snapshot-generator.h.

Member Typedef Documentation

◆ ExtractReferencesMethod

typedef bool(V8HeapExplorer::* v8::internal::V8HeapExplorer::ExtractReferencesMethod) (int entry, HeapObject *object)

private

Definition at line 349 of file heap-snapshot-generator.h.

Constructor & Destructor Documentation

◆ V8HeapExplorer()

v8::internal::V8HeapExplorer::V8HeapExplorer	(	HeapSnapshot *	snapshot,
		SnapshottingProgressReportingInterface *	progress,
		v8::HeapProfiler::ObjectNameResolver *	resolver
	)

Definition at line 781 of file heap-snapshot-generator.cc.

     : heap_(snapshot->profiler()->heap_object_map()->heap()),
       snapshot_(snapshot),
       names_(snapshot_->profiler()->names()),
       heap_object_map_(snapshot_->profiler()->heap_object_map()),
       progress_(progress),
       filler_(NULL),
       global_object_name_resolver_(resolver) {
 }

◆ ~V8HeapExplorer()

v8::internal::V8HeapExplorer::~V8HeapExplorer ( )

virtual

Definition at line 795 of file heap-snapshot-generator.cc.

795 {

796 }

Member Function Documentation

◆ AddEntry() [1/3]

HeapEntry * v8::internal::V8HeapExplorer::AddEntry	(	Address	address,
		HeapEntry::Type	type,
		const char *	name,
		size_t	size
	)

Definition at line 878 of file heap-snapshot-generator.cc.

                                                  {
   SnapshotObjectId object_id = heap_object_map_->FindOrAddEntry(
       address, static_cast<unsigned int>(size));
   unsigned trace_node_id = 0;
   if (AllocationTracker* allocation_tracker =
       snapshot_->profiler()->allocation_tracker()) {
     trace_node_id =
         allocation_tracker->address_to_trace()->GetTraceNodeId(address);
   }
   return snapshot_->AddEntry(type, name, object_id, size, trace_node_id);
 }

References v8::internal::HeapSnapshot::AddEntry(), v8::internal::HeapProfiler::allocation_tracker(), v8::internal::HeapObjectsMap::FindOrAddEntry(), heap_object_map_, name, v8::internal::HeapSnapshot::profiler(), size, and snapshot_.

Referenced by AddEntry(), v8::internal::JSArrayBufferDataEntryAllocator::AllocateEntry(), and AllocateEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ AddEntry() [2/3]

HeapEntry * v8::internal::V8HeapExplorer::AddEntry ( HeapObject * object )

private

Definition at line 804 of file heap-snapshot-generator.cc.

                                                       {
   if (object->IsJSFunction()) {
     JSFunction* func = JSFunction::cast(object);
     SharedFunctionInfo* shared = func->shared();
     const char* name = shared->bound() ? "native_bind" :
         names_->GetName(String::cast(shared->name()));
     return AddEntry(object, HeapEntry::kClosure, name);
   } else if (object->IsJSRegExp()) {
     JSRegExp* re = JSRegExp::cast(object);
     return AddEntry(object,
                     HeapEntry::kRegExp,
                     names_->GetName(re->Pattern()));
   } else if (object->IsJSObject()) {
     const char* name = names_->GetName(
         GetConstructorName(JSObject::cast(object)));
     if (object->IsJSGlobalObject()) {
       const char* tag = objects_tags_.GetTag(object);
       if (tag != NULL) {
         name = names_->GetFormatted("%s / %s", name, tag);
       }
     }
     return AddEntry(object, HeapEntry::kObject, name);
   } else if (object->IsString()) {
     String* string = String::cast(object);
     if (string->IsConsString())
       return AddEntry(object,
                       HeapEntry::kConsString,
                       "(concatenated string)");
     if (string->IsSlicedString())
       return AddEntry(object,
                       HeapEntry::kSlicedString,
                       "(sliced string)");
     return AddEntry(object,
                     HeapEntry::kString,
                     names_->GetName(String::cast(object)));
   } else if (object->IsSymbol()) {
     return AddEntry(object, HeapEntry::kSymbol, "symbol");
   } else if (object->IsCode()) {
     return AddEntry(object, HeapEntry::kCode, "");
   } else if (object->IsSharedFunctionInfo()) {
     String* name = String::cast(SharedFunctionInfo::cast(object)->name());
     return AddEntry(object,
                     HeapEntry::kCode,
                     names_->GetName(name));
   } else if (object->IsScript()) {
     Object* name = Script::cast(object)->name();
     return AddEntry(object,
                     HeapEntry::kCode,
                     name->IsString()
                         ? names_->GetName(String::cast(name))
                         : "");
   } else if (object->IsNativeContext()) {
     return AddEntry(object, HeapEntry::kHidden, "system / NativeContext");
   } else if (object->IsContext()) {
     return AddEntry(object, HeapEntry::kObject, "system / Context");
   } else if (object->IsFixedArray() ||
              object->IsFixedDoubleArray() ||
              object->IsByteArray() ||
              object->IsExternalArray()) {
     return AddEntry(object, HeapEntry::kArray, "");
   } else if (object->IsHeapNumber()) {
     return AddEntry(object, HeapEntry::kHeapNumber, "number");
   }
   return AddEntry(object, HeapEntry::kHidden, GetSystemEntryName(object));
 }

References AddEntry(), GetConstructorName(), v8::internal::StringsStorage::GetFormatted(), v8::internal::StringsStorage::GetName(), GetSystemEntryName(), v8::internal::HeapObjectsSet::GetTag(), name, names_, NULL, objects_tags_, and v8::internal::JSRegExp::Pattern().

Here is the call graph for this function:

◆ AddEntry() [3/3]

HeapEntry * v8::internal::V8HeapExplorer::AddEntry	(	HeapObject *	object,
		HeapEntry::Type	type,
		const char *	name
	)

private

Definition at line 871 of file heap-snapshot-generator.cc.

                                                       {
   return AddEntry(object->address(), type, name, object->Size());
 }

References AddEntry(), v8::internal::HeapObject::address(), name, and v8::internal::HeapObject::Size().

Here is the call graph for this function:

◆ AddRootEntries()

void v8::internal::V8HeapExplorer::AddRootEntries ( SnapshotFiller * filler )

◆ AllocateEntry()

HeapEntry * v8::internal::V8HeapExplorer::AllocateEntry ( HeapThing ptr )

virtual

Implements v8::internal::HeapEntriesAllocator.

Definition at line 799 of file heap-snapshot-generator.cc.

                                                       {
   return AddEntry(reinterpret_cast<HeapObject*>(ptr));
 }

References AddEntry().

Here is the call graph for this function:

◆ DISALLOW_COPY_AND_ASSIGN()

v8::internal::V8HeapExplorer::DISALLOW_COPY_AND_ASSIGN ( V8HeapExplorer )

private

◆ EstimateObjectsCount()

int v8::internal::V8HeapExplorer::EstimateObjectsCount ( HeapIterator * iterator )

Definition at line 975 of file heap-snapshot-generator.cc.

                                                                {
   int objects_count = 0;
   for (HeapObject* obj = iterator->next();
        obj != NULL;
        obj = iterator->next()) {
     objects_count++;
   }
   return objects_count;
 }

References NULL.

Referenced by v8::internal::HeapSnapshotGenerator::SetProgressTotal().

Here is the caller graph for this function:

◆ ExtractAccessorInfoReferences()

void v8::internal::V8HeapExplorer::ExtractAccessorInfoReferences	(	int	entry,
		AccessorInfo *	accessor_info
	)

private

Definition at line 1423 of file heap-snapshot-generator.cc.

                                             {
   SetInternalReference(accessor_info, entry, "name", accessor_info->name(),
                        AccessorInfo::kNameOffset);
   SetInternalReference(accessor_info, entry, "expected_receiver_type",
                        accessor_info->expected_receiver_type(),
                        AccessorInfo::kExpectedReceiverTypeOffset);
   if (accessor_info->IsDeclaredAccessorInfo()) {
     DeclaredAccessorInfo* declared_accessor_info =
         DeclaredAccessorInfo::cast(accessor_info);
     SetInternalReference(declared_accessor_info, entry, "descriptor",
                          declared_accessor_info->descriptor(),
                          DeclaredAccessorInfo::kDescriptorOffset);
   } else if (accessor_info->IsExecutableAccessorInfo()) {
     ExecutableAccessorInfo* executable_accessor_info =
         ExecutableAccessorInfo::cast(accessor_info);
     SetInternalReference(executable_accessor_info, entry, "getter",
                          executable_accessor_info->getter(),
                          ExecutableAccessorInfo::kGetterOffset);
     SetInternalReference(executable_accessor_info, entry, "setter",
                          executable_accessor_info->setter(),
                          ExecutableAccessorInfo::kSetterOffset);
     SetInternalReference(executable_accessor_info, entry, "data",
                          executable_accessor_info->data(),
                          ExecutableAccessorInfo::kDataOffset);
   }
 }

References v8::internal::ExecutableAccessorInfo::kDataOffset, v8::internal::DeclaredAccessorInfo::kDescriptorOffset, v8::internal::AccessorInfo::kExpectedReceiverTypeOffset, v8::internal::ExecutableAccessorInfo::kGetterOffset, v8::internal::AccessorInfo::kNameOffset, v8::internal::ExecutableAccessorInfo::kSetterOffset, and SetInternalReference().

Referenced by ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractAccessorPairProperty()

bool v8::internal::V8HeapExplorer::ExtractAccessorPairProperty	(	JSObject *	js_obj,
		int	entry,
		Object *	key,
		Object *	callback_obj
	)

private

Definition at line 1708 of file heap-snapshot-generator.cc.

                                                                     {
   if (!callback_obj->IsAccessorPair()) return false;
   AccessorPair* accessors = AccessorPair::cast(callback_obj);
   Object* getter = accessors->getter();
   if (!getter->IsOddball()) {
     SetPropertyReference(js_obj, entry, String::cast(key), getter, "get %s");
   }
   Object* setter = accessors->setter();
   if (!setter->IsOddball()) {
     SetPropertyReference(js_obj, entry, String::cast(key), setter, "set %s");
   }
   return true;
 }

References SetPropertyReference().

Referenced by ExtractPropertyReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractAccessorPairReferences()

void v8::internal::V8HeapExplorer::ExtractAccessorPairReferences	(	int	entry,
		AccessorPair *	accessors
	)

private

Definition at line 1452 of file heap-snapshot-generator.cc.

                                         {
   SetInternalReference(accessors, entry, "getter", accessors->getter(),
                        AccessorPair::kGetterOffset);
   SetInternalReference(accessors, entry, "setter", accessors->setter(),
                        AccessorPair::kSetterOffset);
 }

References v8::internal::AccessorPair::kGetterOffset, v8::internal::AccessorPair::kSetterOffset, and SetInternalReference().

Referenced by ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractAllocationSiteReferences()

void v8::internal::V8HeapExplorer::ExtractAllocationSiteReferences	(	int	entry,
		AllocationSite *	site
	)

private

Definition at line 1541 of file heap-snapshot-generator.cc.

                                                                            {
   SetInternalReference(site, entry, "transition_info", site->transition_info(),
                        AllocationSite::kTransitionInfoOffset);
   SetInternalReference(site, entry, "nested_site", site->nested_site(),
                        AllocationSite::kNestedSiteOffset);
   MarkAsWeakContainer(site->dependent_code());
   SetInternalReference(site, entry, "dependent_code", site->dependent_code(),
                        AllocationSite::kDependentCodeOffset);
   // Do not visit weak_next as it is not visited by the StaticVisitor,
   // and we're not very interested in weak_next field here.
   STATIC_ASSERT(AllocationSite::kWeakNextOffset >=
                AllocationSite::BodyDescriptor::kEndOffset);
 }

References v8::internal::AllocationSite::kDependentCodeOffset, v8::internal::FixedBodyDescriptor< start_offset, end_offset, size >::kEndOffset, v8::internal::AllocationSite::kNestedSiteOffset, v8::internal::AllocationSite::kTransitionInfoOffset, v8::internal::AllocationSite::kWeakNextOffset, MarkAsWeakContainer(), SetInternalReference(), and v8::internal::STATIC_ASSERT().

Referenced by ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractBoxReferences()

void v8::internal::V8HeapExplorer::ExtractBoxReferences	(	int	entry,
		Box *	box
	)

private

Definition at line 1520 of file heap-snapshot-generator.cc.

                                                              {
   SetInternalReference(box, entry, "value", box->value(), Box::kValueOffset);
 }

References v8::internal::Box::kValueOffset, and SetInternalReference().

Referenced by ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractCellReferences()

void v8::internal::V8HeapExplorer::ExtractCellReferences	(	int	entry,
		Cell *	cell
	)

private

Definition at line 1525 of file heap-snapshot-generator.cc.

                                                                 {
   SetInternalReference(cell, entry, "value", cell->value(), Cell::kValueOffset);
 }

References v8::internal::Cell::kValueOffset, and SetInternalReference().

Referenced by ExtractPropertyCellReferences(), and ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractClosureReferences()

void v8::internal::V8HeapExplorer::ExtractClosureReferences	(	JSObject *	js_obj,
		int	entry
	)

private

Definition at line 1607 of file heap-snapshot-generator.cc.

                                                                          {
   if (!js_obj->IsJSFunction()) return;
  
   JSFunction* func = JSFunction::cast(js_obj);
   if (func->shared()->bound()) {
     FixedArray* bindings = func->function_bindings();
     SetNativeBindReference(js_obj, entry, "bound_this",
                            bindings->get(JSFunction::kBoundThisIndex));
     SetNativeBindReference(js_obj, entry, "bound_function",
                            bindings->get(JSFunction::kBoundFunctionIndex));
     for (int i = JSFunction::kBoundArgumentsStartIndex;
          i < bindings->length(); i++) {
       const char* reference_name = names_->GetFormatted(
           "bound_argument_%d",
           i - JSFunction::kBoundArgumentsStartIndex);
       SetNativeBindReference(js_obj, entry, reference_name,
                              bindings->get(i));
     }
   }
 }

References v8::internal::JSFunction::function_bindings(), v8::internal::FixedArray::get(), v8::internal::StringsStorage::GetFormatted(), v8::internal::JSFunction::kBoundArgumentsStartIndex, v8::internal::JSFunction::kBoundFunctionIndex, v8::internal::JSFunction::kBoundThisIndex, v8::internal::FixedArrayBase::length(), names_, and SetNativeBindReference().

Referenced by ExtractJSObjectReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractCodeCacheReferences()

void v8::internal::V8HeapExplorer::ExtractCodeCacheReferences	(	int	entry,
		CodeCache *	code_cache
	)

private

Definition at line 1461 of file heap-snapshot-generator.cc.

                                       {
   TagObject(code_cache->default_cache(), "(default code cache)");
   SetInternalReference(code_cache, entry,
                        "default_cache", code_cache->default_cache(),
                        CodeCache::kDefaultCacheOffset);
   TagObject(code_cache->normal_type_cache(), "(code type cache)");
   SetInternalReference(code_cache, entry,
                        "type_cache", code_cache->normal_type_cache(),
                        CodeCache::kNormalTypeCacheOffset);
 }

References v8::internal::CodeCache::kDefaultCacheOffset, v8::internal::CodeCache::kNormalTypeCacheOffset, SetInternalReference(), and TagObject().

Referenced by ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractCodeReferences()

void v8::internal::V8HeapExplorer::ExtractCodeReferences	(	int	entry,
		Code *	code
	)

private

Definition at line 1488 of file heap-snapshot-generator.cc.

                                                                 {
   TagCodeObject(code);
   TagObject(code->relocation_info(), "(code relocation info)");
   SetInternalReference(code, entry,
                        "relocation_info", code->relocation_info(),
                        Code::kRelocationInfoOffset);
   SetInternalReference(code, entry,
                        "handler_table", code->handler_table(),
                        Code::kHandlerTableOffset);
   TagObject(code->deoptimization_data(), "(code deopt data)");
   SetInternalReference(code, entry,
                        "deoptimization_data", code->deoptimization_data(),
                        Code::kDeoptimizationDataOffset);
   if (code->kind() == Code::FUNCTION) {
     SetInternalReference(code, entry,
                          "type_feedback_info", code->type_feedback_info(),
                          Code::kTypeFeedbackInfoOffset);
   }
   SetInternalReference(code, entry,
                        "gc_metadata", code->gc_metadata(),
                        Code::kGCMetadataOffset);
   SetInternalReference(code, entry,
                        "constant_pool", code->constant_pool(),
                        Code::kConstantPoolOffset);
   if (code->kind() == Code::OPTIMIZED_FUNCTION) {
     SetWeakReference(code, entry,
                      "next_code_link", code->next_code_link(),
                      Code::kNextCodeLinkOffset);
   }
 }

References v8::internal::Code::constant_pool(), v8::internal::Code::kConstantPoolOffset, v8::internal::Code::kDeoptimizationDataOffset, v8::internal::Code::kGCMetadataOffset, v8::internal::Code::kHandlerTableOffset, v8::internal::Code::kind(), v8::internal::Code::kNextCodeLinkOffset, v8::internal::Code::kRelocationInfoOffset, v8::internal::Code::kTypeFeedbackInfoOffset, SetInternalReference(), SetWeakReference(), TagCodeObject(), TagObject(), and v8::internal::Code::type_feedback_info().

Referenced by ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractContextReferences()

void v8::internal::V8HeapExplorer::ExtractContextReferences	(	int	entry,
		Context *	context
	)

private

Definition at line 1235 of file heap-snapshot-generator.cc.

                                                                          {
   if (context == context->declaration_context()) {
     ScopeInfo* scope_info = context->closure()->shared()->scope_info();
     // Add context allocated locals.
     int context_locals = scope_info->ContextLocalCount();
     for (int i = 0; i < context_locals; ++i) {
       String* local_name = scope_info->ContextLocalName(i);
       int idx = Context::MIN_CONTEXT_SLOTS + i;
       SetContextReference(context, entry, local_name, context->get(idx),
                           Context::OffsetOfElementAt(idx));
     }
     if (scope_info->HasFunctionName()) {
       String* name = scope_info->FunctionName();
       VariableMode mode;
       int idx = scope_info->FunctionContextSlotIndex(name, &mode);
       if (idx >= 0) {
         SetContextReference(context, entry, name, context->get(idx),
                             Context::OffsetOfElementAt(idx));
       }
     }
   }
  
 #define EXTRACT_CONTEXT_FIELD(index, type, name) \
   if (Context::index < Context::FIRST_WEAK_SLOT || \
       Context::index == Context::MAP_CACHE_INDEX) { \
     SetInternalReference(context, entry, #name, context->get(Context::index), \
         FixedArray::OffsetOfElementAt(Context::index)); \
   } else { \
     SetWeakReference(context, entry, #name, context->get(Context::index), \
         FixedArray::OffsetOfElementAt(Context::index)); \
   }
   EXTRACT_CONTEXT_FIELD(CLOSURE_INDEX, JSFunction, closure);
   EXTRACT_CONTEXT_FIELD(PREVIOUS_INDEX, Context, previous);
   EXTRACT_CONTEXT_FIELD(EXTENSION_INDEX, Object, extension);
   EXTRACT_CONTEXT_FIELD(GLOBAL_OBJECT_INDEX, GlobalObject, global);
   if (context->IsNativeContext()) {
     TagObject(context->jsfunction_result_caches(),
               "(context func. result caches)");
     TagObject(context->normalized_map_cache(), "(context norm. map cache)");
     TagObject(context->runtime_context(), "(runtime context)");
     TagObject(context->embedder_data(), "(context data)");
     NATIVE_CONTEXT_FIELDS(EXTRACT_CONTEXT_FIELD);
     EXTRACT_CONTEXT_FIELD(OPTIMIZED_FUNCTIONS_LIST, unused,
                           optimized_functions_list);
     EXTRACT_CONTEXT_FIELD(OPTIMIZED_CODE_LIST, unused, optimized_code_list);
     EXTRACT_CONTEXT_FIELD(DEOPTIMIZED_CODE_LIST, unused, deoptimized_code_list);
     EXTRACT_CONTEXT_FIELD(NEXT_CONTEXT_LINK, unused, next_context_link);
 #undef EXTRACT_CONTEXT_FIELD
     STATIC_ASSERT(Context::OPTIMIZED_FUNCTIONS_LIST ==
                   Context::FIRST_WEAK_SLOT);
     STATIC_ASSERT(Context::NEXT_CONTEXT_LINK + 1 ==
                   Context::NATIVE_CONTEXT_SLOTS);
     STATIC_ASSERT(Context::FIRST_WEAK_SLOT + 5 ==
                   Context::NATIVE_CONTEXT_SLOTS);
   }
 }

Referenced by ExtractReferencesPass2().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractElementReferences()

void v8::internal::V8HeapExplorer::ExtractElementReferences	(	JSObject *	js_obj,
		int	entry
	)

private

Definition at line 1724 of file heap-snapshot-generator.cc.

                                                                          {
   if (js_obj->HasFastObjectElements()) {
     FixedArray* elements = FixedArray::cast(js_obj->elements());
     int length = js_obj->IsJSArray() ?
         Smi::cast(JSArray::cast(js_obj)->length())->value() :
         elements->length();
     for (int i = 0; i < length; ++i) {
       if (!elements->get(i)->IsTheHole()) {
         SetElementReference(js_obj, entry, i, elements->get(i));
       }
     }
   } else if (js_obj->HasDictionaryElements()) {
     SeededNumberDictionary* dictionary = js_obj->element_dictionary();
     int length = dictionary->Capacity();
     for (int i = 0; i < length; ++i) {
       Object* k = dictionary->KeyAt(i);
       if (dictionary->IsKey(k)) {
         DCHECK(k->IsNumber());
         uint32_t index = static_cast<uint32_t>(k->Number());
         SetElementReference(js_obj, entry, index, dictionary->ValueAt(i));
       }
     }
   }
 }

References v8::internal::HashTable< Derived, Shape, Key >::Capacity(), DCHECK, v8::internal::JSObject::element_dictionary(), v8::internal::FixedArray::get(), v8::internal::JSObject::HasDictionaryElements(), v8::internal::JSObject::HasFastObjectElements(), v8::internal::HashTable< Derived, Shape, Key >::IsKey(), v8::internal::HashTable< Derived, Shape, Key >::KeyAt(), v8::internal::FixedArrayBase::length(), v8::internal::Object::Number(), SetElementReference(), and v8::internal::Dictionary< Derived, Shape, Key >::ValueAt().

Referenced by ExtractJSObjectReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractFixedArrayReferences()

void v8::internal::V8HeapExplorer::ExtractFixedArrayReferences	(	int	entry,
		FixedArray *	array
	)

private

Definition at line 1593 of file heap-snapshot-generator.cc.

                                                                              {
   bool is_weak = weak_containers_.Contains(array);
   for (int i = 0, l = array->length(); i < l; ++i) {
     if (is_weak) {
       SetWeakReference(array, entry,
                        i, array->get(i), array->OffsetOfElementAt(i));
     } else {
       SetInternalReference(array, entry,
                            i, array->get(i), array->OffsetOfElementAt(i));
     }
   }
 }

References v8::internal::HeapObjectsSet::Contains(), v8::internal::FixedArray::get(), v8::internal::FixedArrayBase::length(), v8::internal::FixedArray::OffsetOfElementAt(), SetInternalReference(), SetWeakReference(), and weak_containers_.

Referenced by ExtractReferencesPass2().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractInternalReferences()

void v8::internal::V8HeapExplorer::ExtractInternalReferences	(	JSObject *	js_obj,
		int	entry
	)

private

Definition at line 1750 of file heap-snapshot-generator.cc.

                                                                           {
   int length = js_obj->GetInternalFieldCount();
   for (int i = 0; i < length; ++i) {
     Object* o = js_obj->GetInternalField(i);
     SetInternalReference(
         js_obj, entry, i, o, js_obj->GetInternalFieldOffset(i));
   }
 }

References v8::internal::JSObject::GetInternalField(), v8::internal::JSObject::GetInternalFieldCount(), v8::internal::JSObject::GetInternalFieldOffset(), and SetInternalReference().

Referenced by ExtractJSObjectReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractJSArrayBufferReferences()

void v8::internal::V8HeapExplorer::ExtractJSArrayBufferReferences	(	int	entry,
		JSArrayBuffer *	buffer
	)

private

Definition at line 1574 of file heap-snapshot-generator.cc.

                                       {
   SetWeakReference(buffer, entry, "weak_next", buffer->weak_next(),
                    JSArrayBuffer::kWeakNextOffset);
   SetWeakReference(buffer, entry,
                    "weak_first_view", buffer->weak_first_view(),
                    JSArrayBuffer::kWeakFirstViewOffset);
   // Setup a reference to a native memory backing_store object.
   if (!buffer->backing_store())
     return;
   size_t data_size = NumberToSize(heap_->isolate(), buffer->byte_length());
   JSArrayBufferDataEntryAllocator allocator(data_size, this);
   HeapEntry* data_entry =
       filler_->FindOrAddEntry(buffer->backing_store(), &allocator);
   filler_->SetNamedReference(HeapGraphEdge::kInternal,
                              entry, "backing_store", data_entry);
 }

References filler_, v8::internal::SnapshotFiller::FindOrAddEntry(), heap_, v8::internal::Heap::isolate(), v8::HeapGraphEdge::kInternal, v8::internal::JSArrayBuffer::kWeakFirstViewOffset, v8::internal::JSArrayBuffer::kWeakNextOffset, v8::internal::NumberToSize(), v8::internal::SnapshotFiller::SetNamedReference(), and SetWeakReference().

Referenced by ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractJSCollectionReferences()

void v8::internal::V8HeapExplorer::ExtractJSCollectionReferences	(	int	entry,
		JSCollection *	collection
	)

private

Definition at line 1219 of file heap-snapshot-generator.cc.

                                                                              {
   SetInternalReference(collection, entry, "table", collection->table(),
                        JSCollection::kTableOffset);
 }

References v8::internal::JSCollection::kTableOffset, and SetInternalReference().

Referenced by ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractJSGlobalProxyReferences()

void v8::internal::V8HeapExplorer::ExtractJSGlobalProxyReferences	(	int	entry,
		JSGlobalProxy *	proxy
	)

private

Definition at line 1103 of file heap-snapshot-generator.cc.

                                      {
   SetInternalReference(proxy, entry,
                        "native_context", proxy->native_context(),
                        JSGlobalProxy::kNativeContextOffset);
 }

References v8::internal::JSGlobalProxy::kNativeContextOffset, and SetInternalReference().

Referenced by ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractJSObjectReferences()

void v8::internal::V8HeapExplorer::ExtractJSObjectReferences	(	int	entry,
		JSObject *	js_obj
	)

private

Definition at line 1111 of file heap-snapshot-generator.cc.

                                  {
   HeapObject* obj = js_obj;
   ExtractClosureReferences(js_obj, entry);
   ExtractPropertyReferences(js_obj, entry);
   ExtractElementReferences(js_obj, entry);
   ExtractInternalReferences(js_obj, entry);
   PrototypeIterator iter(heap_->isolate(), js_obj);
   SetPropertyReference(obj, entry, heap_->proto_string(), iter.GetCurrent());
   if (obj->IsJSFunction()) {
     JSFunction* js_fun = JSFunction::cast(js_obj);
     Object* proto_or_map = js_fun->prototype_or_initial_map();
     if (!proto_or_map->IsTheHole()) {
       if (!proto_or_map->IsMap()) {
         SetPropertyReference(
             obj, entry,
             heap_->prototype_string(), proto_or_map,
             NULL,
             JSFunction::kPrototypeOrInitialMapOffset);
       } else {
         SetPropertyReference(
             obj, entry,
             heap_->prototype_string(), js_fun->prototype());
         SetInternalReference(
             obj, entry, "initial_map", proto_or_map,
             JSFunction::kPrototypeOrInitialMapOffset);
       }
     }
     SharedFunctionInfo* shared_info = js_fun->shared();
     // JSFunction has either bindings or literals and never both.
     bool bound = shared_info->bound();
     TagObject(js_fun->literals_or_bindings(),
               bound ? "(function bindings)" : "(function literals)");
     SetInternalReference(js_fun, entry,
                          bound ? "bindings" : "literals",
                          js_fun->literals_or_bindings(),
                          JSFunction::kLiteralsOffset);
     TagObject(shared_info, "(shared function info)");
     SetInternalReference(js_fun, entry,
                          "shared", shared_info,
                          JSFunction::kSharedFunctionInfoOffset);
     TagObject(js_fun->context(), "(context)");
     SetInternalReference(js_fun, entry,
                          "context", js_fun->context(),
                          JSFunction::kContextOffset);
     SetWeakReference(js_fun, entry,
                      "next_function_link", js_fun->next_function_link(),
                      JSFunction::kNextFunctionLinkOffset);
     STATIC_ASSERT(JSFunction::kNextFunctionLinkOffset
                  == JSFunction::kNonWeakFieldsEndOffset);
     STATIC_ASSERT(JSFunction::kNextFunctionLinkOffset + kPointerSize
                  == JSFunction::kSize);
   } else if (obj->IsGlobalObject()) {
     GlobalObject* global_obj = GlobalObject::cast(obj);
     SetInternalReference(global_obj, entry,
                          "builtins", global_obj->builtins(),
                          GlobalObject::kBuiltinsOffset);
     SetInternalReference(global_obj, entry,
                          "native_context", global_obj->native_context(),
                          GlobalObject::kNativeContextOffset);
     SetInternalReference(global_obj, entry,
                          "global_context", global_obj->global_context(),
                          GlobalObject::kGlobalContextOffset);
     SetInternalReference(global_obj, entry,
                          "global_proxy", global_obj->global_proxy(),
                          GlobalObject::kGlobalProxyOffset);
     STATIC_ASSERT(GlobalObject::kHeaderSize - JSObject::kHeaderSize ==
                  4 * kPointerSize);
   } else if (obj->IsJSArrayBufferView()) {
     JSArrayBufferView* view = JSArrayBufferView::cast(obj);
     SetInternalReference(view, entry, "buffer", view->buffer(),
                          JSArrayBufferView::kBufferOffset);
     SetWeakReference(view, entry, "weak_next", view->weak_next(),
                      JSArrayBufferView::kWeakNextOffset);
   }
   TagObject(js_obj->properties(), "(object properties)");
   SetInternalReference(obj, entry,
                        "properties", js_obj->properties(),
                        JSObject::kPropertiesOffset);
   TagObject(js_obj->elements(), "(object elements)");
   SetInternalReference(obj, entry,
                        "elements", js_obj->elements(),
                        JSObject::kElementsOffset);
 }

References v8::internal::JSFunction::context(), ExtractClosureReferences(), ExtractElementReferences(), ExtractInternalReferences(), ExtractPropertyReferences(), v8::internal::PrototypeIterator::GetCurrent(), heap_, v8::internal::Heap::isolate(), v8::internal::JSArrayBufferView::kBufferOffset, v8::internal::GlobalObject::kBuiltinsOffset, v8::internal::JSFunction::kContextOffset, v8::internal::JSObject::kElementsOffset, v8::internal::GlobalObject::kGlobalContextOffset, v8::internal::GlobalObject::kGlobalProxyOffset, v8::internal::JSObject::kHeaderSize, v8::internal::GlobalObject::kHeaderSize, v8::internal::JSFunction::kLiteralsOffset, v8::internal::GlobalObject::kNativeContextOffset, v8::internal::JSFunction::kNextFunctionLinkOffset, v8::internal::JSFunction::kNonWeakFieldsEndOffset, v8::internal::kPointerSize, v8::internal::JSObject::kPropertiesOffset, v8::internal::JSFunction::kPrototypeOrInitialMapOffset, v8::internal::JSFunction::kSharedFunctionInfoOffset, v8::internal::JSFunction::kSize, v8::internal::JSArrayBufferView::kWeakNextOffset, NULL, v8::internal::JSFunction::prototype(), SetInternalReference(), SetPropertyReference(), SetWeakReference(), v8::internal::STATIC_ASSERT(), and TagObject().

Referenced by ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractJSWeakCollectionReferences()

void v8::internal::V8HeapExplorer::ExtractJSWeakCollectionReferences	(	int	entry,
		JSWeakCollection *	collection
	)

private

Definition at line 1226 of file heap-snapshot-generator.cc.

                                              {
   MarkAsWeakContainer(collection->table());
   SetInternalReference(collection, entry,
                        "table", collection->table(),
                        JSWeakCollection::kTableOffset);
 }

References v8::internal::JSWeakCollection::kTableOffset, MarkAsWeakContainer(), and SetInternalReference().

Referenced by ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractMapReferences()

void v8::internal::V8HeapExplorer::ExtractMapReferences	(	int	entry,
		Map *	map
	)

private

Definition at line 1293 of file heap-snapshot-generator.cc.

                                                              {
   if (map->HasTransitionArray()) {
     TransitionArray* transitions = map->transitions();
     int transitions_entry = GetEntry(transitions)->index();
     Object* back_pointer = transitions->back_pointer_storage();
     TagObject(back_pointer, "(back pointer)");
     SetInternalReference(transitions, transitions_entry,
                          "back_pointer", back_pointer);
  
     if (FLAG_collect_maps && map->CanTransition()) {
       if (!transitions->IsSimpleTransition()) {
         if (transitions->HasPrototypeTransitions()) {
           FixedArray* prototype_transitions =
               transitions->GetPrototypeTransitions();
           MarkAsWeakContainer(prototype_transitions);
           TagObject(prototype_transitions, "(prototype transitions");
           SetInternalReference(transitions, transitions_entry,
                                "prototype_transitions", prototype_transitions);
         }
         // TODO(alph): transitions keys are strong links.
         MarkAsWeakContainer(transitions);
       }
     }
  
     TagObject(transitions, "(transition array)");
     SetInternalReference(map, entry,
                          "transitions", transitions,
                          Map::kTransitionsOrBackPointerOffset);
   } else {
     Object* back_pointer = map->GetBackPointer();
     TagObject(back_pointer, "(back pointer)");
     SetInternalReference(map, entry,
                          "back_pointer", back_pointer,
                          Map::kTransitionsOrBackPointerOffset);
   }
   DescriptorArray* descriptors = map->instance_descriptors();
   TagObject(descriptors, "(map descriptors)");
   SetInternalReference(map, entry,
                        "descriptors", descriptors,
                        Map::kDescriptorsOffset);
  
   MarkAsWeakContainer(map->code_cache());
   SetInternalReference(map, entry,
                        "code_cache", map->code_cache(),
                        Map::kCodeCacheOffset);
   SetInternalReference(map, entry,
                        "prototype", map->prototype(), Map::kPrototypeOffset);
   SetInternalReference(map, entry,
                        "constructor", map->constructor(),
                        Map::kConstructorOffset);
   TagObject(map->dependent_code(), "(dependent code)");
   MarkAsWeakContainer(map->dependent_code());
   SetInternalReference(map, entry,
                        "dependent_code", map->dependent_code(),
                        Map::kDependentCodeOffset);
 }

References v8::internal::TransitionArray::back_pointer_storage(), GetEntry(), v8::internal::TransitionArray::GetPrototypeTransitions(), v8::internal::TransitionArray::HasPrototypeTransitions(), v8::internal::TransitionArray::IsSimpleTransition(), v8::internal::Map::kCodeCacheOffset, v8::internal::Map::kConstructorOffset, v8::internal::Map::kDependentCodeOffset, v8::internal::Map::kDescriptorsOffset, v8::internal::Map::kPrototypeOffset, v8::internal::Map::kTransitionsOrBackPointerOffset, map, MarkAsWeakContainer(), SetInternalReference(), and TagObject().

Referenced by ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractPropertyCellReferences()

void v8::internal::V8HeapExplorer::ExtractPropertyCellReferences	(	int	entry,
		PropertyCell *	cell
	)

private

Definition at line 1530 of file heap-snapshot-generator.cc.

                                                                        {
   ExtractCellReferences(entry, cell);
   SetInternalReference(cell, entry, "type", cell->type(),
                        PropertyCell::kTypeOffset);
   MarkAsWeakContainer(cell->dependent_code());
   SetInternalReference(cell, entry, "dependent_code", cell->dependent_code(),
                        PropertyCell::kDependentCodeOffset);
 }

References ExtractCellReferences(), v8::internal::PropertyCell::kDependentCodeOffset, v8::internal::PropertyCell::kTypeOffset, MarkAsWeakContainer(), SetInternalReference(), and v8::internal::PropertyCell::type().

Referenced by ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractPropertyReferences()

void v8::internal::V8HeapExplorer::ExtractPropertyReferences	(	JSObject *	js_obj,
		int	entry
	)

private

Definition at line 1629 of file heap-snapshot-generator.cc.

                                                                           {
   if (js_obj->HasFastProperties()) {
     DescriptorArray* descs = js_obj->map()->instance_descriptors();
     int real_size = js_obj->map()->NumberOfOwnDescriptors();
     for (int i = 0; i < real_size; i++) {
       switch (descs->GetType(i)) {
         case FIELD: {
           Representation r = descs->GetDetails(i).representation();
           if (r.IsSmi() || r.IsDouble()) break;
           int index = descs->GetFieldIndex(i);
  
           Name* k = descs->GetKey(i);
           if (index < js_obj->map()->inobject_properties()) {
             Object* value = js_obj->InObjectPropertyAt(index);
             if (k != heap_->hidden_string()) {
               SetPropertyReference(
                   js_obj, entry,
                   k, value,
                   NULL,
                   js_obj->GetInObjectPropertyOffset(index));
             } else {
               TagObject(value, "(hidden properties)");
               SetInternalReference(
                   js_obj, entry,
                   "hidden_properties", value,
                   js_obj->GetInObjectPropertyOffset(index));
             }
           } else {
             FieldIndex field_index =
                 FieldIndex::ForDescriptor(js_obj->map(), i);
             Object* value = js_obj->RawFastPropertyAt(field_index);
             if (k != heap_->hidden_string()) {
               SetPropertyReference(js_obj, entry, k, value);
             } else {
               TagObject(value, "(hidden properties)");
               SetInternalReference(js_obj, entry, "hidden_properties", value);
             }
           }
           break;
         }
         case CONSTANT:
           SetPropertyReference(
               js_obj, entry,
               descs->GetKey(i), descs->GetConstant(i));
           break;
         case CALLBACKS:
           ExtractAccessorPairProperty(
               js_obj, entry,
               descs->GetKey(i), descs->GetValue(i));
           break;
         case NORMAL:  // only in slow mode
           UNREACHABLE();
           break;
       }
     }
   } else {
     NameDictionary* dictionary = js_obj->property_dictionary();
     int length = dictionary->Capacity();
     for (int i = 0; i < length; ++i) {
       Object* k = dictionary->KeyAt(i);
       if (dictionary->IsKey(k)) {
         Object* target = dictionary->ValueAt(i);
         // We assume that global objects can only have slow properties.
         Object* value = target->IsPropertyCell()
             ? PropertyCell::cast(target)->value()
             : target;
         if (k == heap_->hidden_string()) {
           TagObject(value, "(hidden properties)");
           SetInternalReference(js_obj, entry, "hidden_properties", value);
           continue;
         }
         if (ExtractAccessorPairProperty(js_obj, entry, k, value)) continue;
         SetPropertyReference(js_obj, entry, String::cast(k), value);
       }
     }
   }
 }

References v8::internal::CALLBACKS, v8::internal::HashTable< Derived, Shape, Key >::Capacity(), v8::internal::CONSTANT, ExtractAccessorPairProperty(), v8::internal::FIELD, v8::internal::DescriptorArray::GetConstant(), v8::internal::DescriptorArray::GetDetails(), v8::internal::DescriptorArray::GetFieldIndex(), v8::internal::JSObject::GetInObjectPropertyOffset(), v8::internal::DescriptorArray::GetKey(), v8::internal::DescriptorArray::GetType(), v8::internal::DescriptorArray::GetValue(), v8::internal::JSObject::HasFastProperties(), heap_, v8::internal::Heap::hidden_string(), v8::internal::JSObject::InObjectPropertyAt(), v8::internal::Representation::IsDouble(), v8::internal::HashTable< Derived, Shape, Key >::IsKey(), v8::internal::Representation::IsSmi(), v8::internal::HashTable< Derived, Shape, Key >::KeyAt(), map, v8::internal::HeapObject::map(), v8::internal::NORMAL, NULL, v8::internal::Map::NumberOfOwnDescriptors(), v8::internal::JSObject::property_dictionary(), v8::internal::JSObject::RawFastPropertyAt(), SetInternalReference(), SetPropertyReference(), TagObject(), UNREACHABLE, and v8::internal::Dictionary< Derived, Shape, Key >::ValueAt().

Referenced by ExtractJSObjectReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractReferencesPass1()

bool v8::internal::V8HeapExplorer::ExtractReferencesPass1	(	int	entry,
		HeapObject *	obj
	)

private

Definition at line 1042 of file heap-snapshot-generator.cc.

                                                                       {
   if (obj->IsFixedArray()) return false;  // FixedArrays are processed on pass 2
  
   if (obj->IsJSGlobalProxy()) {
     ExtractJSGlobalProxyReferences(entry, JSGlobalProxy::cast(obj));
   } else if (obj->IsJSArrayBuffer()) {
     ExtractJSArrayBufferReferences(entry, JSArrayBuffer::cast(obj));
   } else if (obj->IsJSObject()) {
     if (obj->IsJSWeakSet()) {
       ExtractJSWeakCollectionReferences(entry, JSWeakSet::cast(obj));
     } else if (obj->IsJSWeakMap()) {
       ExtractJSWeakCollectionReferences(entry, JSWeakMap::cast(obj));
     } else if (obj->IsJSSet()) {
       ExtractJSCollectionReferences(entry, JSSet::cast(obj));
     } else if (obj->IsJSMap()) {
       ExtractJSCollectionReferences(entry, JSMap::cast(obj));
     }
     ExtractJSObjectReferences(entry, JSObject::cast(obj));
   } else if (obj->IsString()) {
     ExtractStringReferences(entry, String::cast(obj));
   } else if (obj->IsSymbol()) {
     ExtractSymbolReferences(entry, Symbol::cast(obj));
   } else if (obj->IsMap()) {
     ExtractMapReferences(entry, Map::cast(obj));
   } else if (obj->IsSharedFunctionInfo()) {
     ExtractSharedFunctionInfoReferences(entry, SharedFunctionInfo::cast(obj));
   } else if (obj->IsScript()) {
     ExtractScriptReferences(entry, Script::cast(obj));
   } else if (obj->IsAccessorInfo()) {
     ExtractAccessorInfoReferences(entry, AccessorInfo::cast(obj));
   } else if (obj->IsAccessorPair()) {
     ExtractAccessorPairReferences(entry, AccessorPair::cast(obj));
   } else if (obj->IsCodeCache()) {
     ExtractCodeCacheReferences(entry, CodeCache::cast(obj));
   } else if (obj->IsCode()) {
     ExtractCodeReferences(entry, Code::cast(obj));
   } else if (obj->IsBox()) {
     ExtractBoxReferences(entry, Box::cast(obj));
   } else if (obj->IsCell()) {
     ExtractCellReferences(entry, Cell::cast(obj));
   } else if (obj->IsPropertyCell()) {
     ExtractPropertyCellReferences(entry, PropertyCell::cast(obj));
   } else if (obj->IsAllocationSite()) {
     ExtractAllocationSiteReferences(entry, AllocationSite::cast(obj));
   }
   return true;
 }

Here is the call graph for this function:

◆ ExtractReferencesPass2()

bool v8::internal::V8HeapExplorer::ExtractReferencesPass2	(	int	entry,
		HeapObject *	obj
	)

private

Definition at line 1091 of file heap-snapshot-generator.cc.

                                                                       {
   if (!obj->IsFixedArray()) return false;
  
   if (obj->IsContext()) {
     ExtractContextReferences(entry, Context::cast(obj));
   } else {
     ExtractFixedArrayReferences(entry, FixedArray::cast(obj));
   }
   return true;
 }

References v8::internal::Context::cast(), ExtractContextReferences(), and ExtractFixedArrayReferences().

Here is the call graph for this function:

◆ ExtractScriptReferences()

void v8::internal::V8HeapExplorer::ExtractScriptReferences	(	int	entry,
		Script *	script
	)

private

Definition at line 1405 of file heap-snapshot-generator.cc.

                                                                       {
   HeapObject* obj = script;
   SetInternalReference(obj, entry,
                        "source", script->source(),
                        Script::kSourceOffset);
   SetInternalReference(obj, entry,
                        "name", script->name(),
                        Script::kNameOffset);
   SetInternalReference(obj, entry,
                        "context_data", script->context_data(),
                        Script::kContextOffset);
   TagObject(script->line_ends(), "(script line ends)");
   SetInternalReference(obj, entry,
                        "line_ends", script->line_ends(),
                        Script::kLineEndsOffset);
 }

References v8::internal::Script::kContextOffset, v8::internal::Script::kLineEndsOffset, v8::internal::Script::kNameOffset, v8::internal::Script::kSourceOffset, SetInternalReference(), and TagObject().

Referenced by ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractSharedFunctionInfoReferences()

void v8::internal::V8HeapExplorer::ExtractSharedFunctionInfoReferences	(	int	entry,
		SharedFunctionInfo *	shared
	)

private

Definition at line 1351 of file heap-snapshot-generator.cc.

                                            {
   HeapObject* obj = shared;
   String* shared_name = shared->DebugName();
   const char* name = NULL;
   if (shared_name != *heap_->isolate()->factory()->empty_string()) {
     name = names_->GetName(shared_name);
     TagObject(shared->code(), names_->GetFormatted("(code for %s)", name));
   } else {
     TagObject(shared->code(), names_->GetFormatted("(%s code)",
         Code::Kind2String(shared->code()->kind())));
   }
  
   SetInternalReference(obj, entry,
                        "name", shared->name(),
                        SharedFunctionInfo::kNameOffset);
   SetInternalReference(obj, entry,
                        "code", shared->code(),
                        SharedFunctionInfo::kCodeOffset);
   TagObject(shared->scope_info(), "(function scope info)");
   SetInternalReference(obj, entry,
                        "scope_info", shared->scope_info(),
                        SharedFunctionInfo::kScopeInfoOffset);
   SetInternalReference(obj, entry,
                        "instance_class_name", shared->instance_class_name(),
                        SharedFunctionInfo::kInstanceClassNameOffset);
   SetInternalReference(obj, entry,
                        "script", shared->script(),
                        SharedFunctionInfo::kScriptOffset);
   const char* construct_stub_name = name ?
       names_->GetFormatted("(construct stub code for %s)", name) :
       "(construct stub code)";
   TagObject(shared->construct_stub(), construct_stub_name);
   SetInternalReference(obj, entry,
                        "construct_stub", shared->construct_stub(),
                        SharedFunctionInfo::kConstructStubOffset);
   SetInternalReference(obj, entry,
                        "function_data", shared->function_data(),
                        SharedFunctionInfo::kFunctionDataOffset);
   SetInternalReference(obj, entry,
                        "debug_info", shared->debug_info(),
                        SharedFunctionInfo::kDebugInfoOffset);
   SetInternalReference(obj, entry,
                        "inferred_name", shared->inferred_name(),
                        SharedFunctionInfo::kInferredNameOffset);
   SetInternalReference(obj, entry,
                        "optimized_code_map", shared->optimized_code_map(),
                        SharedFunctionInfo::kOptimizedCodeMapOffset);
   SetInternalReference(obj, entry,
                        "feedback_vector", shared->feedback_vector(),
                        SharedFunctionInfo::kFeedbackVectorOffset);
 }

Referenced by ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractStringReferences()

void v8::internal::V8HeapExplorer::ExtractStringReferences	(	int	entry,
		String *	obj
	)

private

Definition at line 1197 of file heap-snapshot-generator.cc.

                                                                       {
   if (string->IsConsString()) {
     ConsString* cs = ConsString::cast(string);
     SetInternalReference(cs, entry, "first", cs->first(),
                          ConsString::kFirstOffset);
     SetInternalReference(cs, entry, "second", cs->second(),
                          ConsString::kSecondOffset);
   } else if (string->IsSlicedString()) {
     SlicedString* ss = SlicedString::cast(string);
     SetInternalReference(ss, entry, "parent", ss->parent(),
                          SlicedString::kParentOffset);
   }
 }

References v8::internal::cs, v8::internal::ConsString::kFirstOffset, v8::internal::SlicedString::kParentOffset, v8::internal::ConsString::kSecondOffset, v8::internal::SlicedString::parent(), and SetInternalReference().

Referenced by ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ ExtractSymbolReferences()

void v8::internal::V8HeapExplorer::ExtractSymbolReferences	(	int	entry,
		Symbol *	symbol
	)

private

Definition at line 1212 of file heap-snapshot-generator.cc.

                                                                       {
   SetInternalReference(symbol, entry,
                        "name", symbol->name(),
                        Symbol::kNameOffset);
 }

References v8::internal::Symbol::kNameOffset, and SetInternalReference().

Referenced by ExtractReferencesPass1().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetConstructorName()

String * v8::internal::V8HeapExplorer::GetConstructorName ( JSObject * object )

static

Definition at line 1760 of file heap-snapshot-generator.cc.

                                                            {
   Heap* heap = object->GetHeap();
   if (object->IsJSFunction()) return heap->closure_string();
   String* constructor_name = object->constructor_name();
   if (constructor_name == heap->Object_string()) {
     // TODO(verwaest): Try to get object.constructor.name in this case.
     // This requires handlification of the V8HeapExplorer.
   }
   return object->constructor_name();
 }

Referenced by AddEntry().

Here is the caller graph for this function:

◆ GetEntry()

HeapEntry * v8::internal::V8HeapExplorer::GetEntry ( Object * obj )

private

Definition at line 1772 of file heap-snapshot-generator.cc.

                                                {
   if (!obj->IsHeapObject()) return NULL;
   return filler_->FindOrAddEntry(obj, this);
 }

References filler_, v8::internal::SnapshotFiller::FindOrAddEntry(), and NULL.

Referenced by ExtractMapReferences(), IterateAndExtractSinglePass(), SetContextReference(), SetElementReference(), SetGcSubrootReference(), SetHiddenReference(), SetInternalReference(), SetNativeBindReference(), SetPropertyReference(), SetUserGlobalReference(), SetWeakReference(), and TagObject().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetStrongGcSubrootName()

const char * v8::internal::V8HeapExplorer::GetStrongGcSubrootName ( Object * object )

private

Definition at line 2155 of file heap-snapshot-generator.cc.

                                                                  {
   if (strong_gc_subroot_names_.is_empty()) {
 #define NAME_ENTRY(name) strong_gc_subroot_names_.SetTag(heap_->name(), #name);
 #define ROOT_NAME(type, name, camel_name) NAME_ENTRY(name)
     STRONG_ROOT_LIST(ROOT_NAME)
 #undef ROOT_NAME
 #define STRUCT_MAP_NAME(NAME, Name, name) NAME_ENTRY(name##_map)
     STRUCT_LIST(STRUCT_MAP_NAME)
 #undef STRUCT_MAP_NAME
 #define STRING_NAME(name, str) NAME_ENTRY(name)
     INTERNALIZED_STRING_LIST(STRING_NAME)
 #undef STRING_NAME
 #undef NAME_ENTRY
     CHECK(!strong_gc_subroot_names_.is_empty());
   }
   return strong_gc_subroot_names_.GetTag(object);
 }

References CHECK, v8::internal::HeapObjectsSet::GetTag(), INTERNALIZED_STRING_LIST, v8::internal::HeapObjectsSet::is_empty(), ROOT_NAME, STRING_NAME, strong_gc_subroot_names_, STRONG_ROOT_LIST, STRUCT_LIST, and STRUCT_MAP_NAME.

Referenced by SetGcSubrootReference().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetSystemEntryName()

const char * v8::internal::V8HeapExplorer::GetSystemEntryName ( HeapObject * object )

private

Definition at line 952 of file heap-snapshot-generator.cc.

                                                                  {
   switch (object->map()->instance_type()) {
     case MAP_TYPE:
       switch (Map::cast(object)->instance_type()) {
 #define MAKE_STRING_MAP_CASE(instance_type, size, name, Name) \
         case instance_type: return "system / Map (" #Name ")";
       STRING_TYPE_LIST(MAKE_STRING_MAP_CASE)
 #undef MAKE_STRING_MAP_CASE
         default: return "system / Map";
       }
     case CELL_TYPE: return "system / Cell";
     case PROPERTY_CELL_TYPE: return "system / PropertyCell";
     case FOREIGN_TYPE: return "system / Foreign";
     case ODDBALL_TYPE: return "system / Oddball";
 #define MAKE_STRUCT_CASE(NAME, Name, name) \
     case NAME##_TYPE: return "system / "#Name;
   STRUCT_LIST(MAKE_STRUCT_CASE)
 #undef MAKE_STRUCT_CASE
     default: return "system";
   }
 }

References v8::internal::CELL_TYPE, v8::internal::FOREIGN_TYPE, v8::internal::Map::instance_type(), MAKE_STRING_MAP_CASE, MAKE_STRUCT_CASE, v8::internal::HeapObject::map(), v8::internal::MAP_TYPE, v8::internal::ODDBALL_TYPE, v8::internal::PROPERTY_CELL_TYPE, STRING_TYPE_LIST, and STRUCT_LIST.

Referenced by AddEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IsEssentialObject()

bool v8::internal::V8HeapExplorer::IsEssentialObject ( Object * object )

private

Definition at line 1909 of file heap-snapshot-generator.cc.

                                                      {
   return object->IsHeapObject()
       && !object->IsOddball()
       && object != heap_->empty_byte_array()
       && object != heap_->empty_fixed_array()
       && object != heap_->empty_descriptor_array()
       && object != heap_->fixed_array_map()
       && object != heap_->cell_map()
       && object != heap_->global_property_cell_map()
       && object != heap_->shared_function_info_map()
       && object != heap_->free_space_map()
       && object != heap_->one_pointer_filler_map()
       && object != heap_->two_pointer_filler_map();
 }

References heap_.

Referenced by MarkAsWeakContainer(), SetHiddenReference(), SetInternalReference(), SetWeakReference(), and TagObject().

Here is the caller graph for this function:

◆ IterateAndExtractReferences()

bool v8::internal::V8HeapExplorer::IterateAndExtractReferences ( SnapshotFiller * filler )

Definition at line 1845 of file heap-snapshot-generator.cc.

                             {
   filler_ = filler;
  
   // Create references to the synthetic roots.
   SetRootGcRootsReference();
   for (int tag = 0; tag < VisitorSynchronization::kNumberOfSyncTags; tag++) {
     SetGcRootsReference(static_cast<VisitorSynchronization::SyncTag>(tag));
   }
  
   // Make sure builtin code objects get their builtin tags
   // first. Otherwise a particular JSFunction object could set
   // its custom name to a generic builtin.
   RootsReferencesExtractor extractor(heap_);
   heap_->IterateRoots(&extractor, VISIT_ONLY_STRONG);
   extractor.SetCollectingAllReferences();
   heap_->IterateRoots(&extractor, VISIT_ALL);
   extractor.FillReferences(this);
  
   // We have to do two passes as sometimes FixedArrays are used
   // to weakly hold their items, and it's impossible to distinguish
   // between these cases without processing the array owner first.
   bool interrupted =
       IterateAndExtractSinglePass<&V8HeapExplorer::ExtractReferencesPass1>() ||
       IterateAndExtractSinglePass<&V8HeapExplorer::ExtractReferencesPass2>();
  
   if (interrupted) {
     filler_ = NULL;
     return false;
   }
  
   filler_ = NULL;
   return progress_->ProgressReport(true);
 }

References filler_, v8::internal::RootsReferencesExtractor::FillReferences(), heap_, v8::internal::Heap::IterateRoots(), v8::internal::VisitorSynchronization::kNumberOfSyncTags, NULL, progress_, v8::internal::SnapshottingProgressReportingInterface::ProgressReport(), v8::internal::RootsReferencesExtractor::SetCollectingAllReferences(), SetGcRootsReference(), SetRootGcRootsReference(), v8::internal::VISIT_ALL, and v8::internal::VISIT_ONLY_STRONG.

Referenced by v8::internal::HeapSnapshotGenerator::FillReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ IterateAndExtractSinglePass()

template<V8HeapExplorer::ExtractReferencesMethod extractor>

bool v8::internal::V8HeapExplorer::IterateAndExtractSinglePass

private

Definition at line 1882 of file heap-snapshot-generator.cc.

                                                  {
   // Now iterate the whole heap.
   bool interrupted = false;
   HeapIterator iterator(heap_, HeapIterator::kFilterUnreachable);
   // Heap iteration with filtering must be finished in any case.
   for (HeapObject* obj = iterator.next();
        obj != NULL;
        obj = iterator.next(), progress_->ProgressStep()) {
     if (interrupted) continue;
  
     HeapEntry* heap_entry = GetEntry(obj);
     int entry = heap_entry->index();
     if ((this->*extractor)(entry, obj)) {
       SetInternalReference(obj, entry,
                            "map", obj->map(), HeapObject::kMapOffset);
       // Extract unvisited fields as hidden references and restore tags
       // of visited fields.
       IndexedReferencesExtractor refs_extractor(this, obj, entry);
       obj->Iterate(&refs_extractor);
     }
  
     if (!progress_->ProgressReport(false)) interrupted = true;
   }
   return interrupted;
 }

References GetEntry(), heap_, v8::internal::HeapObject::kMapOffset, NULL, progress_, v8::internal::SnapshottingProgressReportingInterface::ProgressReport(), v8::internal::SnapshottingProgressReportingInterface::ProgressStep(), and SetInternalReference().

Here is the call graph for this function:

◆ MarkAsWeakContainer()

void v8::internal::V8HeapExplorer::MarkAsWeakContainer ( Object * object )

private

Definition at line 2184 of file heap-snapshot-generator.cc.

                                                        {
   if (IsEssentialObject(object) && object->IsFixedArray()) {
     weak_containers_.Insert(object);
   }
 }

References v8::internal::HeapObjectsSet::Insert(), IsEssentialObject(), and weak_containers_.

Referenced by ExtractAllocationSiteReferences(), ExtractJSWeakCollectionReferences(), ExtractMapReferences(), and ExtractPropertyCellReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetContextReference()

void v8::internal::V8HeapExplorer::SetContextReference	(	HeapObject *	parent_obj,
		int	parent,
		String *	reference_name,
		Object *	child,
		int	field_offset
	)

private

Definition at line 1925 of file heap-snapshot-generator.cc.

                                                            {
   DCHECK(parent_entry == GetEntry(parent_obj)->index());
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry != NULL) {
     filler_->SetNamedReference(HeapGraphEdge::kContextVariable,
                                parent_entry,
                                names_->GetName(reference_name),
                                child_entry);
     IndexedReferencesExtractor::MarkVisitedField(parent_obj, field_offset);
   }
 }

References DCHECK, filler_, GetEntry(), v8::internal::StringsStorage::GetName(), v8::HeapGraphEdge::kContextVariable, v8::internal::IndexedReferencesExtractor::MarkVisitedField(), names_, NULL, and v8::internal::SnapshotFiller::SetNamedReference().

Referenced by ExtractContextReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetElementReference()

void v8::internal::V8HeapExplorer::SetElementReference	(	HeapObject *	parent_obj,
		int	parent,
		int	index,
		Object *	child
	)

private

Definition at line 1957 of file heap-snapshot-generator.cc.

                                                             {
   DCHECK(parent_entry == GetEntry(parent_obj)->index());
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry != NULL) {
     filler_->SetIndexedReference(HeapGraphEdge::kElement,
                                  parent_entry,
                                  index,
                                  child_entry);
   }
 }

References DCHECK, filler_, GetEntry(), v8::HeapGraphEdge::kElement, NULL, and v8::internal::SnapshotFiller::SetIndexedReference().

Referenced by ExtractElementReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetGcRootsReference()

void v8::internal::V8HeapExplorer::SetGcRootsReference ( VisitorSynchronization::SyncTag tag )

private

Definition at line 2105 of file heap-snapshot-generator.cc.

                                                                           {
   filler_->SetIndexedAutoIndexReference(
       HeapGraphEdge::kElement,
       snapshot_->gc_roots()->index(),
       snapshot_->gc_subroot(tag));
 }

References filler_, v8::internal::HeapSnapshot::gc_roots(), v8::internal::HeapSnapshot::gc_subroot(), v8::HeapGraphEdge::kElement, v8::internal::SnapshotFiller::SetIndexedAutoIndexReference(), and snapshot_.

Referenced by IterateAndExtractReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetGcSubrootReference()

void v8::internal::V8HeapExplorer::SetGcSubrootReference	(	VisitorSynchronization::SyncTag	tag,
		bool	is_weak,
		Object *	child
	)

private

Definition at line 2113 of file heap-snapshot-generator.cc.

                                                                         {
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry != NULL) {
     const char* name = GetStrongGcSubrootName(child_obj);
     if (name != NULL) {
       filler_->SetNamedReference(
           HeapGraphEdge::kInternal,
           snapshot_->gc_subroot(tag)->index(),
           name,
           child_entry);
     } else {
       if (is_weak) {
         filler_->SetNamedAutoIndexReference(
             HeapGraphEdge::kWeak,
             snapshot_->gc_subroot(tag)->index(),
             child_entry);
       } else {
         filler_->SetIndexedAutoIndexReference(
             HeapGraphEdge::kElement,
             snapshot_->gc_subroot(tag)->index(),
             child_entry);
       }
     }
  
     // Add a shortcut to JS global object reference at snapshot root.
     if (child_obj->IsNativeContext()) {
       Context* context = Context::cast(child_obj);
       GlobalObject* global = context->global_object();
       if (global->IsJSGlobalObject()) {
         bool is_debug_object = false;
         is_debug_object = heap_->isolate()->debug()->IsDebugGlobal(global);
         if (!is_debug_object && !user_roots_.Contains(global)) {
           user_roots_.Insert(global);
           SetUserGlobalReference(global);
         }
       }
     }
   }
 }

References v8::internal::Context::cast(), v8::internal::HeapObjectsSet::Contains(), v8::internal::Isolate::debug(), filler_, v8::internal::HeapSnapshot::gc_subroot(), GetEntry(), GetStrongGcSubrootName(), v8::internal::Context::global_object(), heap_, v8::internal::HeapObjectsSet::Insert(), v8::internal::Debug::IsDebugGlobal(), v8::internal::Heap::isolate(), v8::HeapGraphEdge::kElement, v8::HeapGraphEdge::kInternal, v8::HeapGraphEdge::kWeak, name, NULL, v8::internal::SnapshotFiller::SetIndexedAutoIndexReference(), v8::internal::SnapshotFiller::SetNamedAutoIndexReference(), v8::internal::SnapshotFiller::SetNamedReference(), SetUserGlobalReference(), snapshot_, and user_roots_.

Referenced by v8::internal::RootsReferencesExtractor::FillReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetHiddenReference()

void v8::internal::V8HeapExplorer::SetHiddenReference	(	HeapObject *	parent_obj,
		int	parent,
		int	index,
		Object *	child
	)

private

Definition at line 2008 of file heap-snapshot-generator.cc.

                                                            {
   DCHECK(parent_entry == GetEntry(parent_obj)->index());
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry != NULL && IsEssentialObject(child_obj)) {
     filler_->SetIndexedReference(HeapGraphEdge::kHidden,
                                  parent_entry,
                                  index,
                                  child_entry);
   }
 }

References DCHECK, filler_, GetEntry(), IsEssentialObject(), v8::HeapGraphEdge::kHidden, NULL, and v8::internal::SnapshotFiller::SetIndexedReference().

Referenced by v8::internal::IndexedReferencesExtractor::VisitPointers().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetInternalReference() [1/2]

void v8::internal::V8HeapExplorer::SetInternalReference	(	HeapObject *	parent_obj,
		int	parent,
		const char *	reference_name,
		Object *	child,
		int	field_offset = `-1`
	)

private

Definition at line 1972 of file heap-snapshot-generator.cc.

                                                             {
   DCHECK(parent_entry == GetEntry(parent_obj)->index());
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry == NULL) return;
   if (IsEssentialObject(child_obj)) {
     filler_->SetNamedReference(HeapGraphEdge::kInternal,
                                parent_entry,
                                reference_name,
                                child_entry);
   }
   IndexedReferencesExtractor::MarkVisitedField(parent_obj, field_offset);
 }

References DCHECK, filler_, GetEntry(), IsEssentialObject(), v8::HeapGraphEdge::kInternal, v8::internal::IndexedReferencesExtractor::MarkVisitedField(), NULL, and v8::internal::SnapshotFiller::SetNamedReference().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetInternalReference() [2/2]

void v8::internal::V8HeapExplorer::SetInternalReference	(	HeapObject *	parent_obj,
		int	parent,
		int	index,
		Object *	child,
		int	field_offset = `-1`
	)

private

Definition at line 1990 of file heap-snapshot-generator.cc.

                                                             {
   DCHECK(parent_entry == GetEntry(parent_obj)->index());
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry == NULL) return;
   if (IsEssentialObject(child_obj)) {
     filler_->SetNamedReference(HeapGraphEdge::kInternal,
                                parent_entry,
                                names_->GetName(index),
                                child_entry);
   }
   IndexedReferencesExtractor::MarkVisitedField(parent_obj, field_offset);
 }

References DCHECK, filler_, GetEntry(), v8::internal::StringsStorage::GetName(), IsEssentialObject(), v8::HeapGraphEdge::kInternal, v8::internal::IndexedReferencesExtractor::MarkVisitedField(), names_, NULL, and v8::internal::SnapshotFiller::SetNamedReference().

Here is the call graph for this function:

◆ SetNativeBindReference()

void v8::internal::V8HeapExplorer::SetNativeBindReference	(	HeapObject *	parent_obj,
		int	parent,
		const char *	reference_name,
		Object *	child
	)

private

Definition at line 1942 of file heap-snapshot-generator.cc.

                                                                {
   DCHECK(parent_entry == GetEntry(parent_obj)->index());
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry != NULL) {
     filler_->SetNamedReference(HeapGraphEdge::kShortcut,
                                parent_entry,
                                reference_name,
                                child_entry);
   }
 }

References DCHECK, filler_, GetEntry(), v8::HeapGraphEdge::kShortcut, NULL, and v8::internal::SnapshotFiller::SetNamedReference().

Referenced by ExtractClosureReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetPropertyReference()

void v8::internal::V8HeapExplorer::SetPropertyReference	(	HeapObject *	parent_obj,
		int	parent,
		Name *	reference_name,
		Object *	child,
		const char *	name_format_string = `NULL`,
		int	field_offset = `-1`
	)

private

Definition at line 2059 of file heap-snapshot-generator.cc.

                                                             {
   DCHECK(parent_entry == GetEntry(parent_obj)->index());
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry != NULL) {
     HeapGraphEdge::Type type =
         reference_name->IsSymbol() || String::cast(reference_name)->length() > 0
             ? HeapGraphEdge::kProperty : HeapGraphEdge::kInternal;
     const char* name = name_format_string != NULL && reference_name->IsString()
         ? names_->GetFormatted(
               name_format_string,
               String::cast(reference_name)->ToCString(
                   DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL).get()) :
         names_->GetName(reference_name);
  
     filler_->SetNamedReference(type,
                                parent_entry,
                                name,
                                child_entry);
     IndexedReferencesExtractor::MarkVisitedField(parent_obj, field_offset);
   }
 }

References DCHECK, v8::internal::DISALLOW_NULLS, filler_, GetEntry(), v8::internal::StringsStorage::GetFormatted(), v8::internal::StringsStorage::GetName(), v8::HeapGraphEdge::kInternal, v8::HeapGraphEdge::kProperty, v8::internal::IndexedReferencesExtractor::MarkVisitedField(), name, names_, NULL, v8::internal::ROBUST_STRING_TRAVERSAL, and v8::internal::SnapshotFiller::SetNamedReference().

Referenced by ExtractAccessorPairProperty(), ExtractJSObjectReferences(), and ExtractPropertyReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetRootGcRootsReference()

void v8::internal::V8HeapExplorer::SetRootGcRootsReference ( )

private

Definition at line 2087 of file heap-snapshot-generator.cc.

                                              {
   filler_->SetIndexedAutoIndexReference(
       HeapGraphEdge::kElement,
       snapshot_->root()->index(),
       snapshot_->gc_roots());
 }

References filler_, v8::internal::HeapSnapshot::gc_roots(), v8::HeapGraphEdge::kElement, v8::internal::HeapSnapshot::root(), v8::internal::SnapshotFiller::SetIndexedAutoIndexReference(), and snapshot_.

Referenced by IterateAndExtractReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetUserGlobalReference()

void v8::internal::V8HeapExplorer::SetUserGlobalReference ( Object * user_global )

private

Definition at line 2095 of file heap-snapshot-generator.cc.

                                                              {
   HeapEntry* child_entry = GetEntry(child_obj);
   DCHECK(child_entry != NULL);
   filler_->SetNamedAutoIndexReference(
       HeapGraphEdge::kShortcut,
       snapshot_->root()->index(),
       child_entry);
 }

References DCHECK, filler_, GetEntry(), v8::HeapGraphEdge::kShortcut, NULL, v8::internal::HeapSnapshot::root(), v8::internal::SnapshotFiller::SetNamedAutoIndexReference(), and snapshot_.

Referenced by SetGcSubrootReference().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetWeakReference() [1/2]

void v8::internal::V8HeapExplorer::SetWeakReference	(	HeapObject *	parent_obj,
		int	parent,
		const char *	reference_name,
		Object *	child_obj,
		int	field_offset
	)

private

Definition at line 2023 of file heap-snapshot-generator.cc.

                                                         {
   DCHECK(parent_entry == GetEntry(parent_obj)->index());
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry == NULL) return;
   if (IsEssentialObject(child_obj)) {
     filler_->SetNamedReference(HeapGraphEdge::kWeak,
                                parent_entry,
                                reference_name,
                                child_entry);
   }
   IndexedReferencesExtractor::MarkVisitedField(parent_obj, field_offset);
 }

References DCHECK, filler_, GetEntry(), IsEssentialObject(), v8::HeapGraphEdge::kWeak, v8::internal::IndexedReferencesExtractor::MarkVisitedField(), NULL, and v8::internal::SnapshotFiller::SetNamedReference().

Referenced by ExtractCodeReferences(), ExtractFixedArrayReferences(), ExtractJSArrayBufferReferences(), and ExtractJSObjectReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetWeakReference() [2/2]

void v8::internal::V8HeapExplorer::SetWeakReference	(	HeapObject *	parent_obj,
		int	parent,
		int	index,
		Object *	child_obj,
		int	field_offset
	)

private

Definition at line 2041 of file heap-snapshot-generator.cc.

                                                         {
   DCHECK(parent_entry == GetEntry(parent_obj)->index());
   HeapEntry* child_entry = GetEntry(child_obj);
   if (child_entry == NULL) return;
   if (IsEssentialObject(child_obj)) {
     filler_->SetNamedReference(HeapGraphEdge::kWeak,
                                parent_entry,
                                names_->GetFormatted("%d", index),
                                child_entry);
   }
   IndexedReferencesExtractor::MarkVisitedField(parent_obj, field_offset);
 }

References DCHECK, filler_, GetEntry(), v8::internal::StringsStorage::GetFormatted(), IsEssentialObject(), v8::HeapGraphEdge::kWeak, v8::internal::IndexedReferencesExtractor::MarkVisitedField(), names_, NULL, and v8::internal::SnapshotFiller::SetNamedReference().

Here is the call graph for this function:

◆ TagBuiltinCodeObject()

void v8::internal::V8HeapExplorer::TagBuiltinCodeObject	(	Code *	code,
		const char *	name
	)

Definition at line 1474 of file heap-snapshot-generator.cc.

                                                                       {
   TagObject(code, names_->GetFormatted("(%s builtin)", name));
 }

References v8::internal::StringsStorage::GetFormatted(), name, names_, and TagObject().

Referenced by v8::internal::RootsReferencesExtractor::FillReferences().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TagCodeObject()

void v8::internal::V8HeapExplorer::TagCodeObject ( Code * code )

Definition at line 1479 of file heap-snapshot-generator.cc.

                                              {
   if (code->kind() == Code::STUB) {
     TagObject(code, names_->GetFormatted(
                         "(%s code)", CodeStub::MajorName(
                                          CodeStub::GetMajorKey(code), true)));
   }
 }

References v8::internal::StringsStorage::GetFormatted(), v8::internal::Code::kind(), names_, v8::internal::STUB, and TagObject().

Referenced by ExtractCodeReferences(), and v8::internal::IndexedReferencesExtractor::VisitCodeEntry().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TagGlobalObjects()

void v8::internal::V8HeapExplorer::TagGlobalObjects ( )

Definition at line 2216 of file heap-snapshot-generator.cc.

                                       {
   Isolate* isolate = heap_->isolate();
   HandleScope scope(isolate);
   GlobalObjectsEnumerator enumerator;
   isolate->global_handles()->IterateAllRoots(&enumerator);
   const char** urls = NewArray<const char*>(enumerator.count());
   for (int i = 0, l = enumerator.count(); i < l; ++i) {
     if (global_object_name_resolver_) {
       HandleScope scope(isolate);
       Handle<JSGlobalObject> global_obj = enumerator.at(i);
       urls[i] = global_object_name_resolver_->GetName(
           Utils::ToLocal(Handle<JSObject>::cast(global_obj)));
     } else {
       urls[i] = NULL;
     }
   }
  
   DisallowHeapAllocation no_allocation;
   for (int i = 0, l = enumerator.count(); i < l; ++i) {
     objects_tags_.SetTag(*enumerator.at(i), urls[i]);
   }
  
   DeleteArray(urls);
 }

References v8::internal::GlobalObjectsEnumerator::at(), v8::internal::GlobalObjectsEnumerator::count(), v8::internal::DeleteArray(), v8::HeapProfiler::ObjectNameResolver::GetName(), v8::internal::Isolate::global_handles(), global_object_name_resolver_, heap_, v8::internal::Heap::isolate(), v8::internal::GlobalHandles::IterateAllRoots(), NULL, objects_tags_, v8::internal::HeapObjectsSet::SetTag(), and v8::Utils::ToLocal().

Referenced by v8::internal::HeapSnapshotGenerator::GenerateSnapshot().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ TagObject()

void v8::internal::V8HeapExplorer::TagObject	(	Object *	obj,
		const char *	tag
	)

private

Definition at line 2174 of file heap-snapshot-generator.cc.

                                                            {
   if (IsEssentialObject(obj)) {
     HeapEntry* entry = GetEntry(obj);
     if (entry->name()[0] == '\0') {
       entry->set_name(tag);
     }
   }
 }

References GetEntry(), and IsEssentialObject().

Referenced by ExtractCodeCacheReferences(), ExtractCodeReferences(), ExtractContextReferences(), ExtractJSObjectReferences(), ExtractMapReferences(), ExtractPropertyReferences(), ExtractScriptReferences(), ExtractSharedFunctionInfoReferences(), TagBuiltinCodeObject(), and TagCodeObject().

Here is the call graph for this function:

Here is the caller graph for this function:

Friends And Related Function Documentation

◆ IndexedReferencesExtractor

friend class IndexedReferencesExtractor

friend

Definition at line 460 of file heap-snapshot-generator.h.

◆ RootsReferencesExtractor

friend class RootsReferencesExtractor

friend

Definition at line 461 of file heap-snapshot-generator.h.

Member Data Documentation

◆ filler_

SnapshotFiller* v8::internal::V8HeapExplorer::filler_

private

Definition at line 453 of file heap-snapshot-generator.h.

Referenced by ExtractJSArrayBufferReferences(), GetEntry(), IterateAndExtractReferences(), SetContextReference(), SetElementReference(), SetGcRootsReference(), SetGcSubrootReference(), SetHiddenReference(), SetInternalReference(), SetNativeBindReference(), SetPropertyReference(), SetRootGcRootsReference(), SetUserGlobalReference(), and SetWeakReference().

◆ global_object_name_resolver_

v8::HeapProfiler::ObjectNameResolver* v8::internal::V8HeapExplorer::global_object_name_resolver_

private

Definition at line 458 of file heap-snapshot-generator.h.

Referenced by TagGlobalObjects().

◆ heap_

Heap* v8::internal::V8HeapExplorer::heap_

private

Definition at line 448 of file heap-snapshot-generator.h.

Referenced by ExtractJSArrayBufferReferences(), ExtractJSObjectReferences(), ExtractPropertyReferences(), ExtractSharedFunctionInfoReferences(), IsEssentialObject(), IterateAndExtractReferences(), IterateAndExtractSinglePass(), SetGcSubrootReference(), and TagGlobalObjects().

◆ heap_object_map_

HeapObjectsMap* v8::internal::V8HeapExplorer::heap_object_map_

private

Definition at line 451 of file heap-snapshot-generator.h.

Referenced by AddEntry().

◆ names_

StringsStorage* v8::internal::V8HeapExplorer::names_

private

Definition at line 450 of file heap-snapshot-generator.h.

Referenced by AddEntry(), ExtractClosureReferences(), ExtractSharedFunctionInfoReferences(), SetContextReference(), SetInternalReference(), SetPropertyReference(), SetWeakReference(), TagBuiltinCodeObject(), and TagCodeObject().

◆ objects_tags_

HeapObjectsSet v8::internal::V8HeapExplorer::objects_tags_

private

Definition at line 454 of file heap-snapshot-generator.h.

Referenced by AddEntry(), and TagGlobalObjects().

◆ progress_

SnapshottingProgressReportingInterface* v8::internal::V8HeapExplorer::progress_

private

Definition at line 452 of file heap-snapshot-generator.h.

Referenced by IterateAndExtractReferences(), and IterateAndExtractSinglePass().

◆ snapshot_

HeapSnapshot* v8::internal::V8HeapExplorer::snapshot_

private

Definition at line 449 of file heap-snapshot-generator.h.

Referenced by AddEntry(), SetGcRootsReference(), SetGcSubrootReference(), SetRootGcRootsReference(), and SetUserGlobalReference().

◆ strong_gc_subroot_names_

HeapObjectsSet v8::internal::V8HeapExplorer::strong_gc_subroot_names_

private

Definition at line 455 of file heap-snapshot-generator.h.

Referenced by GetStrongGcSubrootName().

◆ user_roots_

HeapObjectsSet v8::internal::V8HeapExplorer::user_roots_

private

Definition at line 456 of file heap-snapshot-generator.h.

Referenced by SetGcSubrootReference().

◆ weak_containers_

HeapObjectsSet v8::internal::V8HeapExplorer::weak_containers_

private

Definition at line 457 of file heap-snapshot-generator.h.

Referenced by ExtractFixedArrayReferences(), and MarkAsWeakContainer().

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

/mnt/V8SourceCode/src/heap-snapshot-generator.h
/mnt/V8SourceCode/src/heap-snapshot-generator.cc

Private Attributes
Heap *	heap_

HeapSnapshot *	snapshot_

StringsStorage *	names_

HeapObjectsMap *	heap_object_map_

SnapshottingProgressReportingInterface *	progress_

SnapshotFiller *	filler_

HeapObjectsSet	objects_tags_

HeapObjectsSet	strong_gc_subroot_names_

HeapObjectsSet	user_roots_

HeapObjectsSet	weak_containers_

v8::HeapProfiler::ObjectNameResolver *	global_object_name_resolver_

Public Member Functions

Static Public Member Functions

Private Types

Private Member Functions

Private Attributes

Friends

Detailed Description

Member Typedef Documentation

◆ ExtractReferencesMethod

Constructor & Destructor Documentation

◆ V8HeapExplorer()

◆ ~V8HeapExplorer()

Member Function Documentation

◆ AddEntry() [1/3]

◆ AddEntry() [2/3]

◆ AddEntry() [3/3]

◆ AddRootEntries()

◆ AllocateEntry()

◆ DISALLOW_COPY_AND_ASSIGN()

◆ EstimateObjectsCount()

◆ ExtractAccessorInfoReferences()

◆ ExtractAccessorPairProperty()

◆ ExtractAccessorPairReferences()

◆ ExtractAllocationSiteReferences()

◆ ExtractBoxReferences()

◆ ExtractCellReferences()

◆ ExtractClosureReferences()

◆ ExtractCodeCacheReferences()

◆ ExtractCodeReferences()

◆ ExtractContextReferences()

◆ ExtractElementReferences()

◆ ExtractFixedArrayReferences()

◆ ExtractInternalReferences()

◆ ExtractJSArrayBufferReferences()

◆ ExtractJSCollectionReferences()

◆ ExtractJSGlobalProxyReferences()

◆ ExtractJSObjectReferences()

◆ ExtractJSWeakCollectionReferences()

◆ ExtractMapReferences()

◆ ExtractPropertyCellReferences()

◆ ExtractPropertyReferences()

◆ ExtractReferencesPass1()

◆ ExtractReferencesPass2()

◆ ExtractScriptReferences()

◆ ExtractSharedFunctionInfoReferences()

◆ ExtractStringReferences()

◆ ExtractSymbolReferences()

◆ GetConstructorName()

◆ GetEntry()

◆ GetStrongGcSubrootName()

◆ GetSystemEntryName()

◆ IsEssentialObject()

◆ IterateAndExtractReferences()

◆ IterateAndExtractSinglePass()

◆ MarkAsWeakContainer()

◆ SetContextReference()

◆ SetElementReference()

◆ SetGcRootsReference()

◆ SetGcSubrootReference()

◆ SetHiddenReference()

◆ SetInternalReference() [1/2]

◆ SetInternalReference() [2/2]

◆ SetNativeBindReference()

◆ SetPropertyReference()

◆ SetRootGcRootsReference()

◆ SetUserGlobalReference()

◆ SetWeakReference() [1/2]

◆ SetWeakReference() [2/2]

◆ TagBuiltinCodeObject()

◆ TagCodeObject()

◆ TagGlobalObjects()

◆ TagObject()

Friends And Related Function Documentation

◆ IndexedReferencesExtractor

◆ RootsReferencesExtractor

Member Data Documentation

◆ filler_

◆ global_object_name_resolver_

◆ heap_

◆ heap_object_map_