Revert 41938 - Merged third_party/tcmalloc/vendor/src(googleperftools r87) in...

third_party/tcmalloc/chromium/src/heap-profile-table.cc

 // Copyright (c) 2006, 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 531 matching lines @@
   sort(entries, entries + n);
 
   // Report a bounded number of leaks to keep the leak report from
   // growing too long.
   const int to_report =
       (FLAGS_heap_check_max_leaks > 0 &&
        n > FLAGS_heap_check_max_leaks) ? FLAGS_heap_check_max_leaks : n;
   RAW_LOG(ERROR, "The %d largest leaks:", to_report);
 
   // Print
-  SymbolTable symbolization_table;
+  SymbolMap symbolization_table;
+  int num_symbols = 0;
   for (int i = 0; i < to_report; i++) {
     const Entry& e = entries[i];
     for (int j = 0; j < e.bucket->depth; j++) {
-      symbolization_table.Add(e.bucket->stack[j]);
+      const void* pc = e.bucket->stack[j];
+      symbolization_table[reinterpret_cast<uintptr_t>(pc)] = "";
+      num_symbols++;
     }
   }
   static const int kBufSize = 2<<10;
   char buffer[kBufSize];
+  int sym_buffer_len = kSymbolSize * num_symbols;
+  char *sym_buffer = new char[sym_buffer_len];
   if (should_symbolize)
-    symbolization_table.Symbolize();
+    Symbolize(sym_buffer, sym_buffer_len, &symbolization_table);
   for (int i = 0; i < to_report; i++) {
     const Entry& e = entries[i];
     base::RawPrinter printer(buffer, kBufSize);
     printer.Printf("Leak of %d bytes in %d objects allocated from:\n",
                    e.bytes, e.count);
     for (int j = 0; j < e.bucket->depth; j++) {
       const void* pc = e.bucket->stack[j];
-      printer.Printf("\t@ %"PRIxPTR" %s\n",
-          reinterpret_cast<uintptr_t>(pc), symbolization_table.GetSymbol(pc));
+      printer.Printf("\t@ %p %s\n",
+                     pc, symbolization_table[reinterpret_cast<uintptr_t>(pc)]);
     }
     RAW_LOG(ERROR, "%s", buffer);
   }
+  delete[] sym_buffer;
 
   if (to_report < n) {
     RAW_LOG(ERROR, "Skipping leaks numbered %d..%d",
             to_report, n-1);
   }
   delete[] entries;
 
   // TODO: Dump the sorted Entry list instead of dumping raw data?
   // (should be much shorter)
   if (!HeapProfileTable::WriteProfile(filename, total_, &map_)) {
     RAW_LOG(ERROR, "Could not write pprof profile to %s", filename);
   }
 }
 
 void HeapProfileTable::Snapshot::ReportObject(const void* ptr,
                                               AllocValue* v,
                                               char* unused) {
   // Perhaps also log the allocation stack trace (unsymbolized)
   // on this line in case somebody finds it useful.
   RAW_LOG(ERROR, "leaked %"PRIuS" byte object %p", v->bytes, ptr);
 }
 
 void HeapProfileTable::Snapshot::ReportIndividualObjects() {
   char unused;
   map_.Iterate(ReportObject, &unused);
 }