Fix HEAP_PROFILE_MMAP in google-perftools.

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 111 matching lines @@
 
 HeapProfileTable::HeapProfileTable(Allocator alloc, DeAllocator dealloc)
     : alloc_(alloc), dealloc_(dealloc) {
   // Make the table
   const int table_bytes = kHashTableSize * sizeof(*table_);
   table_ = reinterpret_cast<Bucket**>(alloc_(table_bytes));
   memset(table_, 0, table_bytes);
   // Make allocation map
   allocation_ =
     new(alloc_(sizeof(AllocationMap))) AllocationMap(alloc_, dealloc_);
+
+  allocation_mmap_ =
+      new(alloc_(sizeof(AllocationMap))) AllocationMap(alloc_, dealloc_);
+  mmap_record_ = false;
+
   // init the rest:
   memset(&total_, 0, sizeof(total_));
   num_buckets_ = 0;
 }
 
 HeapProfileTable::~HeapProfileTable() {
   // free allocation map
   allocation_->~AllocationMap();
   dealloc_(allocation_);
   allocation_ = NULL;
+
+  allocation_mmap_->~AllocationMap();
+  dealloc_(allocation_mmap_);
+  allocation_mmap_ = NULL;
+
   // free hash table
   for (int b = 0; b < kHashTableSize; b++) {
     for (Bucket* x = table_[b]; x != 0; /**/) {
       Bucket* b = x;
       x = x->next;
       dealloc_(b->stack);
       dealloc_(b);
     }
   }
   dealloc_(table_);
@@ skipping 50 matching lines @@
     const void* const call_stack[]) {
   Bucket* b = GetBucket(stack_depth, call_stack);
   b->allocs++;
   b->alloc_size += bytes;
   total_.allocs++;
   total_.alloc_size += bytes;
 
   AllocValue v;
   v.set_bucket(b);  // also did set_live(false); set_ignore(false)
   v.bytes = bytes;
-  allocation_->Insert(ptr, v);
+
+  if(mmap_record_)
+    allocation_mmap_->Insert(ptr, v);
+  else
+    allocation_->Insert(ptr, v);
 }
 
 void HeapProfileTable::RecordFree(const void* ptr) {
   AllocValue v;
-  if (allocation_->FindAndRemove(ptr, &v)) {
+  AllocationMap* a;
+  if(mmap_record_)
+    a = allocation_mmap_;
+  else
+    a = allocation_;
+
+  if(a->FindAndRemove(ptr, &v)){
     Bucket* b = v.bucket();
     b->frees++;
     b->free_size += v.bytes;
     total_.frees++;
     total_.free_size += v.bytes;
   }
 }
 
 bool HeapProfileTable::FindAlloc(const void* ptr, size_t* object_size) const {
   const AllocValue* alloc_value = allocation_->Find(ptr);
@@ skipping 367 matching lines @@
                                               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);
 }