Oilpan: GC_TRACING: Improve object path dump

Source/platform/heap/Heap.cpp

 /*
  * Copyright (C) 2013 Google Inc. 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
@@ skipping 1454 matching lines @@
             fprintf(stderr, "%ld", *it);
             if (--count)
                 fprintf(stderr, ", ");
         }
         ASSERT(!count);
         fprintf(stderr, "}");
     }
 
     static void dumpPathToObjectFromObjectGraph(const ObjectGraph& graph, uintptr_t target)
     {
+        ObjectGraph::const_iterator it = graph.find(target);
+        if (it == graph.end())
+            return;
         fprintf(stderr, "Path to %lx of %s\n", target, classOf(reinterpret_cast<const void*>(target)).ascii().data());
-        ObjectGraph::const_iterator it = graph.find(target);
         while (it != graph.end()) {
-            fprintf(stderr, "<- %lx of %s\n", it->value.first, it->value.second.ascii().data());
+            fprintf(stderr, "<- %lx of %s\n", it->value.first, it->value.second.utf8().data());
             it = graph.find(it->value.first);
         }
         fprintf(stderr, "\n");
     }
 
     static void dumpPathToObjectOnNextGC(void* p)
     {
         objectsToFindPath().add(reinterpret_cast<uintptr_t>(p));
     }
 
@@ skipping 111 matching lines @@
 #if ENABLE(GC_TRACING)
 const GCInfo* Heap::findGCInfo(Address address)
 {
     return ThreadState::findGCInfoFromAllThreads(address);
 }
 
 void Heap::dumpPathToObjectOnNextGC(void* p)
 {
     static_cast<MarkingVisitor*>(s_markingVisitor)->dumpPathToObjectOnNextGC(p);
 }
+
+String Heap::createBacktraceString()
+{
+    int framesToShow = 3;
+    int stackFrameSize = 16;
+    ASSERT(stackFrameSize >= framesToShow);
+    typedef void* FramePointer;
+    FramePointer* stackFrame = static_cast<FramePointer*>(alloca(sizeof(FramePointer) * stackFrameSize));
+    WTFGetBacktrace(stackFrame, &stackFrameSize);
+
+    StringBuilder builder;
+    builder.append("Persistent");
+    bool didAppendFirstName = false;
+    // Skip frames before/including "WebCore::Persistent".
+    bool didSeePersistent = false;
+    for (int i = 0; i < stackFrameSize && framesToShow > 0; ++i) {
+        FrameToNameScope frameToName(stackFrame[i]);
+        if (!frameToName.nullableName())
+            continue;
+        if (strstr(frameToName.nullableName(), "WebCore::Persistent")) {
+            didSeePersistent = true;
+            continue;
+        }
+        if (!didSeePersistent)
+            continue;
+        if (!didAppendFirstName) {
+            didAppendFirstName = true;
+            builder.append(" ... Backtrace:");
+        }
+        builder.append("\n\t");
+        builder.append(frameToName.nullableName());
+        --framesToShow;
+    }
+    return builder.toString().replace("WebCore::", "");
+}
 #endif
 
 void Heap::pushTraceCallback(void* object, TraceCallback callback)
 {
     ASSERT(Heap::contains(object));
     CallbackStack::Item* slot = s_markingStack->allocateEntry(&s_markingStack);
     *slot = CallbackStack::Item(object, callback);
 }
 
 bool Heap::popAndInvokeTraceCallback(Visitor* visitor)
@@ skipping 151 matching lines @@
 template class ThreadHeap<FinalizedHeapObjectHeader>;
 template class ThreadHeap<HeapObjectHeader>;
 
 Visitor* Heap::s_markingVisitor;
 CallbackStack* Heap::s_markingStack;
 CallbackStack* Heap::s_weakCallbackStack;
 HeapDoesNotContainCache* Heap::s_heapDoesNotContainCache;
 bool Heap::s_shutdownCalled = false;
 bool Heap::s_lastGCWasConservative = false;
 }