A deeper heap profile dumper in third_party/tcmalloc/chromium.

third_party/tcmalloc/chromium/src/malloc_hook.cc

 // Copyright (c) 2005, 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 53 matching lines @@
 
 // __THROW is defined in glibc systems.  It means, counter-intuitively,
 // "This function will never throw an exception."  It's an optional
 // optimization tool, but we may need to use it to match glibc prototypes.
 #ifndef __THROW    // I guess we're not on a glibc system
 # define __THROW   // __THROW is just an optimization, so ok to make it ""
 #endif
 
 using std::copy;
 
+DECLARE_bool(deep_heap_profile);
+
 
 // Declaration of default weak initialization function, that can be overridden
 // by linking-in a strong definition (as heap-checker.cc does).  This is
 // extern "C" so that it doesn't trigger gold's --detect-odr-violations warning,
 // which only looks at C++ symbols.
 //
 // This function is declared here as weak, and defined later, rather than a more
 // straightforward simple weak definition, as a workround for an icc compiler
 // issue ((Intel reference 290819).  This issue causes icc to resolve weak
 // symbols too early, at compile rather than link time.  By declaring it (weak)
@@ skipping 586 matching lines @@
     // and 3 is to account for some hook daisy chaining.
   static const int kStackSize = kMaxSkip + 1;
   void* stack[kStackSize];
   int depth = GetStackTrace(stack, kStackSize, 1);  // skip this function frame
   if (depth == 0)   // silenty propagate cases when GetStackTrace does not work
     return 0;
   for (int i = 0; i < depth; ++i) {  // stack[0] is our immediate caller
     if (InHookCaller(stack[i])) {
       RAW_VLOG(10, "Found hooked allocator at %d: %p <- %p",
                    i, stack[i], stack[i+1]);
-      i += 1;  // skip hook caller frame
+      if (!FLAGS_deep_heap_profile) {
+        i += 1;  // skip hook caller frame
+      }
       depth -= i;  // correct depth
       if (depth > max_depth) depth = max_depth;
       copy(stack + i, stack + i + depth, result);
       if (depth < max_depth  &&  depth + i == kStackSize) {
         // get frames for the missing depth
         depth +=
           GetStackTrace(result + depth, max_depth - depth, 1 + kStackSize);
       }
       return depth;
     }
@@ skipping 206 matching lines @@
 /*static*/int MallocHook::UnhookedMUnmap(void *start, size_t length) {
   int result;
   if (!MallocHook::InvokeMunmapReplacement(start, length, &result)) {
     result = munmap(start, length);
   }
   return result;
 }
 
 #endif  // defined(__linux) &&
         // (defined(__i386__) || defined(__x86_64__) || defined(__PPC__))