HeapProfiler: provide human readable names for code objects.

src/heap-snapshot-generator.cc

 // Copyright 2013 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 12 matching lines @@
 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "v8.h"
 
 #include "heap-snapshot-generator-inl.h"
 
 #include "allocation-tracker.h"
+#include "code-stubs.h"
 #include "heap-profiler.h"
 #include "debug.h"
 #include "types.h"
 
 namespace v8 {
 namespace internal {
 
 
 HeapGraphEdge::HeapGraphEdge(Type type, const char* name, int from, int to)
     : type_(type),
@@ skipping 1060 matching lines @@
                              HeapObject* parent_obj,
                              int parent)
       : generator_(generator),
         parent_obj_(parent_obj),
         parent_(parent),
         next_index_(0) {
   }
   void VisitCodeEntry(Address entry_address) {
      Code* code = Code::cast(Code::GetObjectFromEntryAddress(entry_address));
      generator_->SetInternalReference(parent_obj_, parent_, "code", code);
-     generator_->TagObject(code, "(code)");
+     generator_->TagCodeObject(code);
   }
   void VisitPointers(Object** start, Object** end) {
     for (Object** p = start; p < end; p++) {
       if (CheckVisitedAndUnmark(p)) continue;
       generator_->SetHiddenReference(parent_obj_, parent_, next_index_++, *p);
     }
   }
   static void MarkVisitedField(HeapObject* obj, int offset) {
     if (offset < 0) return;
     Address field = obj->address() + offset;
@@ skipping 242 matching lines @@
                        Map::kDependentCodeOffset);
 }
 
 
 void V8HeapExplorer::ExtractSharedFunctionInfoReferences(
     int entry, SharedFunctionInfo* shared) {
   HeapObject* obj = shared;
   SetInternalReference(obj, entry,
                        "name", shared->name(),
                        SharedFunctionInfo::kNameOffset);
-  TagObject(shared->code(), "(code)");
+  Object* empty_string = *heap_->isolate()->factory()->empty_string();
+  StringsStorage* names = collection_->names();
+  Object* shared_name = shared->name();
+  shared_name = !shared_name->IsFailure() ? shared_name : shared->DebugName();

[yurys, 2013/10/31 09:54:01]

shared_name->IsFailure() will always be true here since we just visited the
name() field at line 1374 by calling SetInternalReference.

[loislo, 2013/10/31 10:59:39]

Done.

+  const char* name = NULL;
+  if (shared_name != empty_string) {
+    name = names->GetName(Name::cast(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,
                        "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);
-  TagObject(shared->construct_stub(), "(code)");
+  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);
   SetWeakReference(obj, entry,
                    1, shared->initial_map(),
                    SharedFunctionInfo::kInitialMapOffset);
 }
 
 
 void V8HeapExplorer::ExtractScriptReferences(int entry, Script* script) {
   HeapObject* obj = script;
   SetInternalReference(obj, entry,
                        "source", script->source(),
@@ skipping 29 matching lines @@
   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);
 }
 
 
+void V8HeapExplorer::TagCodeObject(Code* code, const char* external_name) {
+  StringsStorage* names = collection_->names();
+  if (external_name) {
+    TagObject(code, names->GetFormatted("(%s code)", external_name));
+    return;
+  }
+  switch (code->kind()) {
+    case Code::STUB: {
+      TagObject(code, names->GetFormatted("(%s code)",
+          CodeStub::MajorName(static_cast<CodeStub::Major>(code->major_key()),
+              true)));
+      break;
+    }
+    default: {
+      break;
+    }
+  }
+}
+
+
 void V8HeapExplorer::ExtractCodeReferences(int entry, Code* code) {
+  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(),
@@ skipping 225 matching lines @@
 class RootsReferencesExtractor : public ObjectVisitor {
  private:
   struct IndexTag {
     IndexTag(int index, VisitorSynchronization::SyncTag tag)
         : index(index), tag(tag) { }
     int index;
     VisitorSynchronization::SyncTag tag;
   };
 
  public:
-  RootsReferencesExtractor()
+  explicit RootsReferencesExtractor(Heap* heap)
       : collecting_all_references_(false),
-        previous_reference_count_(0) {
+        previous_reference_count_(0),
+        heap_(heap) {
   }
 
   void VisitPointers(Object** start, Object** end) {
     if (collecting_all_references_) {
       for (Object** p = start; p < end; p++) all_references_.Add(*p);
     } else {
       for (Object** p = start; p < end; p++) strong_references_.Add(*p);
     }
   }
 
   void SetCollectingAllReferences() { collecting_all_references_ = true; }
 
   void FillReferences(V8HeapExplorer* explorer) {
     ASSERT(strong_references_.length() <= all_references_.length());
+    Builtins* builtins = heap_->isolate()->builtins();
     for (int i = 0; i < reference_tags_.length(); ++i) {
       explorer->SetGcRootsReference(reference_tags_[i].tag);
     }
-    int strong_index = 0, all_index = 0, tags_index = 0;
+    int strong_index = 0, all_index = 0, tags_index = 0, prev_tag_index = 0;
     while (all_index < all_references_.length()) {
       if (strong_index < strong_references_.length() &&
           strong_references_[strong_index] == all_references_[all_index]) {
         explorer->SetGcSubrootReference(reference_tags_[tags_index].tag,
                                         false,
-                                        all_references_[all_index++]);
+                                        all_references_[all_index]);
         ++strong_index;
       } else {
         explorer->SetGcSubrootReference(reference_tags_[tags_index].tag,
                                         true,
-                                        all_references_[all_index++]);
+                                        all_references_[all_index]);
       }
-      if (reference_tags_[tags_index].index == all_index) ++tags_index;
+      if (reference_tags_[tags_index].tag == VisitorSynchronization::kBuiltins
+          && all_references_[all_index]->IsCode()) {
+        explorer->TagCodeObject(Code::cast(all_references_[all_index]),
+            builtins->name(all_index - prev_tag_index));
+      }
+      ++all_index;
+      if (reference_tags_[tags_index].index == all_index) {
+        prev_tag_index = all_index;
+        ++tags_index;
+      }
     }
   }
 
   void Synchronize(VisitorSynchronization::SyncTag tag) {
     if (collecting_all_references_ &&
         previous_reference_count_ != all_references_.length()) {
       previous_reference_count_ = all_references_.length();
       reference_tags_.Add(IndexTag(previous_reference_count_, tag));
     }
   }
 
  private:
   bool collecting_all_references_;
   List<Object*> strong_references_;
   List<Object*> all_references_;
   int previous_reference_count_;
   List<IndexTag> reference_tags_;
+  Heap* heap_;
 };
 
 
 bool V8HeapExplorer::IterateAndExtractReferences(
     SnapshotFillerInterface* filler) {
   HeapIterator iterator(heap_, HeapIterator::kFilterUnreachable);
 
   filler_ = filler;
   bool interrupted = false;
 
   // Heap iteration with filtering must be finished in any case.
   for (HeapObject* obj = iterator.next();
        obj != NULL;
        obj = iterator.next(), progress_->ProgressStep()) {
     if (!interrupted) {
       ExtractReferences(obj);
       if (!progress_->ProgressReport(false)) interrupted = true;
     }
   }
   if (interrupted) {
     filler_ = NULL;
     return false;
   }
 
   SetRootGcRootsReference();
-  RootsReferencesExtractor extractor;
+  RootsReferencesExtractor extractor(heap_);
   heap_->IterateRoots(&extractor, VISIT_ONLY_STRONG);
   extractor.SetCollectingAllReferences();
   heap_->IterateRoots(&extractor, VISIT_ALL);
   extractor.FillReferences(this);
   filler_ = NULL;
   return progress_->ProgressReport(true);
 }
 
 
 bool V8HeapExplorer::IsEssentialObject(Object* object) {
@@ skipping 1241 matching lines @@
   writer_->AddString("\"<dummy>\"");
   for (int i = 1; i < sorted_strings.length(); ++i) {
     writer_->AddCharacter(',');
     SerializeString(sorted_strings[i]);
     if (writer_->aborted()) return;
   }
 }
 
 
 } }  // namespace v8::internal