Heap profiler: add a missing link between a function closure and shared function info.

src/profile-generator.cc

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 800 matching lines @@
 
   profiles_->AddPathToCurrentProfiles(entries);
 }
 
 
 HeapGraphEdge::HeapGraphEdge(Type type,
                              const char* name,
                              HeapEntry* from,
                              HeapEntry* to)
     : type_(type), name_(name), from_(from), to_(to) {
-  ASSERT(type_ == CONTEXT_VARIABLE || type_ == PROPERTY);
+  ASSERT(type_ == CONTEXT_VARIABLE || type_ == PROPERTY || type_ == INTERNAL);
 }
 
 
 HeapGraphEdge::HeapGraphEdge(int index,
                              HeapEntry* from,
                              HeapEntry* to)
     : type_(ELEMENT), index_(index), from_(from), to_(to) {
 }
 
 
 static void DeleteHeapGraphEdge(HeapGraphEdge** edge_ptr) {
   delete *edge_ptr;
 }
 
 
 static void DeleteHeapGraphPath(HeapGraphPath** path_ptr) {
   delete *path_ptr;
 }
 
 
 HeapEntry::~HeapEntry() {
   children_.Iterate(DeleteHeapGraphEdge);
   retaining_paths_.Iterate(DeleteHeapGraphPath);
 }
 
 
+void HeapEntry::AddEdge(HeapGraphEdge* edge) {
+  children_.Add(edge);
+  edge->to()->retainers_.Add(edge);
+}
+
+
 void HeapEntry::SetClosureReference(const char* name, HeapEntry* entry) {
-  HeapGraphEdge* edge =
-      new HeapGraphEdge(HeapGraphEdge::CONTEXT_VARIABLE, name, this, entry);
-  children_.Add(edge);
-  entry->retainers_.Add(edge);
+  AddEdge(
+      new HeapGraphEdge(HeapGraphEdge::CONTEXT_VARIABLE, name, this, entry));
 }
 
 
 void HeapEntry::SetElementReference(int index, HeapEntry* entry) {
-  HeapGraphEdge* edge = new HeapGraphEdge(index, this, entry);
-  children_.Add(edge);
-  entry->retainers_.Add(edge);
+  AddEdge(new HeapGraphEdge(index, this, entry));
+}
+
+
+void HeapEntry::SetInternalReference(const char* name, HeapEntry* entry) {
+  AddEdge(new HeapGraphEdge(HeapGraphEdge::INTERNAL, name, this, entry));
 }
 
 
 void HeapEntry::SetPropertyReference(const char* name, HeapEntry* entry) {
-  HeapGraphEdge* edge =
-      new HeapGraphEdge(HeapGraphEdge::PROPERTY, name, this, entry);
-  children_.Add(edge);
-  entry->retainers_.Add(edge);
+  AddEdge(new HeapGraphEdge(HeapGraphEdge::PROPERTY, name, this, entry));
 }
 
 
 void HeapEntry::SetAutoIndexReference(HeapEntry* entry) {
   SetElementReference(next_auto_index_++, entry);
 }
 
 
 int HeapEntry::TotalSize() {
   return total_size_ != kUnknownSize ? total_size_ : CalculateTotalSize();
@@ skipping 189 matching lines @@
 
   for (int i = 0; i < retainers_.length(); ++i) {
     HeapGraphEdge* edge = retainers_[i];
     edge->from()->RemoveChild(edge);
   }
   retainers_.Clear();
 }
 
 
 void HeapEntry::Print(int max_depth, int indent) {
-  OS::Print("%6d %6d %6d", self_size_, TotalSize(), NonSharedTotalSize());
+  OS::Print("%6d %6d %6d ", self_size_, TotalSize(), NonSharedTotalSize());
   if (type_ != STRING) {
     OS::Print("%s %.40s\n", TypeAsString(), name_);
   } else {
     OS::Print("\"");
     const char* c = name_;
     while (*c && (c - name_) <= 40) {
       if (*c != '\n')
         OS::Print("%c", *c);
       else
         OS::Print("\\n");
       ++c;
     }
     OS::Print("\"\n");
   }
   if (--max_depth == 0) return;
   const int children_count = children_.length();
   for (int i = 0; i < children_count; ++i) {
     HeapGraphEdge* edge = children_[i];
     switch (edge->type()) {
       case HeapGraphEdge::CONTEXT_VARIABLE:
         OS::Print("  %*c #%s: ", indent, ' ', edge->name());
         break;
       case HeapGraphEdge::ELEMENT:
         OS::Print("  %*c %d: ", indent, ' ', edge->index());
         break;
+      case HeapGraphEdge::INTERNAL:
+        OS::Print("  %*c $%s: ", indent, ' ', edge->name());
+        break;
       case HeapGraphEdge::PROPERTY:
         OS::Print("  %*c %s: ", indent, ' ', edge->name());
         break;
       default:
         OS::Print("!!! unknown edge type: %d ", edge->type());
     }
     edge->to()->Print(max_depth, indent + 2);
   }
 }
 
@@ skipping 25 matching lines @@
   for (int i = 0; i < path_.length(); ++i) {
     OS::Print(" -> ");
     HeapGraphEdge* edge = path_[i];
     switch (edge->type()) {
       case HeapGraphEdge::CONTEXT_VARIABLE:
         OS::Print("[#%s] ", edge->name());
         break;
       case HeapGraphEdge::ELEMENT:
         OS::Print("[%d] ", edge->index());
         break;
+      case HeapGraphEdge::INTERNAL:
+        OS::Print("[$%s] ", edge->name());
+        break;
       case HeapGraphEdge::PROPERTY:
         OS::Print("[%s] ", edge->name());
         break;
       default:
         OS::Print("!!! unknown edge type: %d ", edge->type());
     }
     edge->to()->Print(1, 0);
   }
   OS::Print("\n");
 }
@@ skipping 153 matching lines @@
 void HeapSnapshot::SetElementReference(HeapEntry* parent,
                                        int index,
                                        Object* child) {
   HeapEntry* child_entry = GetEntry(child);
   if (child_entry != NULL) {
     parent->SetElementReference(index, child_entry);
   }
 }
 
 
+void HeapSnapshot::SetInternalReference(HeapEntry* parent,
+                                        const char* reference_name,
+                                        Object* child) {
+  HeapEntry* child_entry = GetEntry(child);
+  if (child_entry != NULL) {
+    parent->SetInternalReference(reference_name, child_entry);
+  }
+}
+
+
 void HeapSnapshot::SetPropertyReference(HeapEntry* parent,
                                         String* reference_name,
                                         Object* child) {
   HeapEntry* child_entry = GetEntry(child);
   if (child_entry != NULL) {
     parent->SetPropertyReference(
         collection_->GetName(reference_name), child_entry);
   }
 }
 
@@ skipping 208 matching lines @@
         context->closure()->shared()->code());
     int locals_number = scope_info.NumberOfLocals();
     for (int i = 0; i < locals_number; ++i) {
       String* local_name = *scope_info.LocalName(i);
       int idx = ScopeInfo<>::ContextSlotIndex(
           context->closure()->shared()->code(), local_name, NULL);
       if (idx >= 0 && idx < context->length()) {
         snapshot_->SetClosureReference(entry, local_name, context->get(idx));
       }
     }
+    snapshot_->SetInternalReference(entry, "code", func->shared());
   }
 }
 
 
 void HeapSnapshotGenerator::ExtractPropertyReferences(JSObject* js_obj,
                                                       HeapEntry* entry) {
   if (js_obj->HasFastProperties()) {
     DescriptorArray* descs = js_obj->map()->instance_descriptors();
     for (int i = 0; i < descs->number_of_descriptors(); i++) {
       switch (descs->GetType(i)) {
@@ skipping 46 matching lines @@
         uint32_t index = static_cast<uint32_t>(k->Number());
         snapshot_->SetElementReference(entry, index, dictionary->ValueAt(i));
       }
     }
   }
 }
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_LOGGING_AND_PROFILING