Merge tcmalloc r111 (perftools v. 1.8) with the chromium/ branch.

third_party/tcmalloc/chromium/src/symbolize.cc

 // Copyright (c) 2009, 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 30 matching lines @@
 #endif
 #ifdef HAVE_SYS_SOCKET_H
 #include <sys/socket.h>   // for socketpair() -- needed by Symbolize
 #endif
 #ifdef HAVE_SYS_WAIT_H
 #include <sys/wait.h>   // for wait() -- needed by Symbolize
 #endif
 #ifdef HAVE_POLL_H
 #include <poll.h>
 #endif
+#ifdef __MACH__
+#include <mach-o/dyld.h>   // for GetProgramInvocationName()
+#include <limits.h>        // for PATH_MAX
+#endif
+#if defined(__CYGWIN__) || defined(__CYGWIN32__)
+#include <io.h>            // for get_osfhandle()
+#endif
 #include <string>
 #include "base/commandlineflags.h"
 #include "base/sysinfo.h"
 
 using std::string;
 using tcmalloc::DumpProcSelfMaps;   // from sysinfo.h
 
 
 DEFINE_string(symbolize_pprof,
               EnvToString("PPROF_PATH", "pprof"),
               "Path to pprof to call for reporting function names.");
 
 // heap_profile_table_pprof may be referenced after destructors are
 // called (since that's when leak-checking is done), so we make
 // a more-permanent copy that won't ever get destroyed.
 static string* g_pprof_path = new string(FLAGS_symbolize_pprof);
 
+// Returns NULL if we're on an OS where we can't get the invocation name.
+// Using a static var is ok because we're not called from a thread.
+static char* GetProgramInvocationName() {
+#if defined(HAVE_PROGRAM_INVOCATION_NAME)
+  extern char* program_invocation_name;  // gcc provides this
+  return program_invocation_name;
+#elif defined(__MACH__)
+  // We don't want to allocate memory for this since we may be
+  // calculating it when memory is corrupted.
+  static char program_invocation_name[PATH_MAX];
+  if (program_invocation_name[0] == '\0') {  // first time calculating
+    uint32_t length = sizeof(program_invocation_name);
+    if (_NSGetExecutablePath(program_invocation_name, &length))
+      return NULL;
+  }
+  return program_invocation_name;
+#else
+  return NULL;   // figure out a way to get argv[0]
+#endif
+}
+
 void SymbolTable::Add(const void* addr) {
   symbolization_table_[addr] = "";
 }
 
 const char* SymbolTable::GetSymbol(const void* addr) {
   return symbolization_table_[addr];
 }
 
 // Updates symbolization_table with the pointers to symbol names corresponding
 // to its keys. The symbol names are stored in out, which is allocated and
 // freed by the caller of this routine.
 // Note that the forking/etc is not thread-safe or re-entrant.  That's
 // ok for the purpose we need -- reporting leaks detected by heap-checker
 // -- but be careful if you decide to use this routine for other purposes.
 int SymbolTable::Symbolize() {
 #if !defined(HAVE_UNISTD_H)  || !defined(HAVE_SYS_SOCKET_H) || !defined(HAVE_SYS_WAIT_H)
   return 0;
-#elif !defined(HAVE_PROGRAM_INVOCATION_NAME)
-  return 0;   // TODO(csilvers): get argv[0] somehow
 #else
+  const char* argv0 = GetProgramInvocationName();
+  if (argv0 == NULL)   // can't call symbolize if we can't figure out our name
+    return 0;
+
   // All this work is to do two-way communication.  ugh.
-  extern char* program_invocation_name;  // gcc provides this
   int *child_in = NULL;   // file descriptors
   int *child_out = NULL;  // for now, we don't worry about child_err
   int child_fds[5][2];    // socketpair may be called up to five times below
 
   // The client program may close its stdin and/or stdout and/or stderr
   // thus allowing socketpair to reuse file descriptors 0, 1 or 2.
   // In this case the communication between the forked processes may be broken
   // if either the parent or the child tries to close or duplicate these
   // descriptors. The loop below produces two pairs of file descriptors, each
   // greater than 2 (stderr).
@@ skipping 35 matching lines @@
       close(0);
       close(1);
       if (dup2(child_in[0], 0) == -1) _exit(1);
       if (dup2(child_out[0], 1) == -1) _exit(2);
       // Unset vars that might cause trouble when we fork
       unsetenv("CPUPROFILE");
       unsetenv("HEAPPROFILE");
       unsetenv("HEAPCHECK");
       unsetenv("PERFTOOLS_VERBOSE");
       execlp(g_pprof_path->c_str(), g_pprof_path->c_str(),
-             "--symbols", program_invocation_name, NULL);
+             "--symbols", argv0, NULL);
       _exit(3);  // if execvp fails, it's bad news for us
     }
     default: {  // parent
       close(child_in[0]);   // child uses the 0's, parent uses the 1's
       close(child_out[0]);  // child uses the 0's, parent uses the 1's
 #ifdef HAVE_POLL_H
       // For maximum safety, we check to make sure the execlp
       // succeeded before trying to write.  (Otherwise we'll get a
       // SIGPIPE.)  For systems without poll.h, we'll just skip this
       // check, and trust that the user set PPROF_PATH correctly!
       struct pollfd pfd = { child_in[1], POLLOUT, 0 };
       if (!poll(&pfd, 1, 0) || !(pfd.revents & POLLOUT) ||
           (pfd.revents & (POLLHUP|POLLERR))) {
         return 0;
       }
 #endif
+#if defined(__CYGWIN__) || defined(__CYGWIN32__)
+      // On cygwin, DumpProcSelfMaps() takes a HANDLE, not an fd.  Convert.
+      const HANDLE symbols_handle = (HANDLE) get_osfhandle(child_in[1]);
+      DumpProcSelfMaps(symbols_handle);
+#else
       DumpProcSelfMaps(child_in[1]);  // what pprof expects on stdin
+#endif
 
       // Allocate 24 bytes = ("0x" + 8 bytes + "\n" + overhead) for each
       // address to feed to pprof.
       const int kOutBufSize = 24 * symbolization_table_.size();
       char *pprof_buffer = new char[kOutBufSize];
       int written = 0;
       for (SymbolMap::const_iterator iter = symbolization_table_.begin();
            iter != symbolization_table_.end(); ++iter) {
         written += snprintf(pprof_buffer + written, kOutBufSize - written,
                  // pprof expects format to be 0xXXXXXX
@@ skipping 37 matching lines @@
           fill++;
           num_symbols++;
         }
       }
       return num_symbols;
     }
   }
   return 0;  // shouldn't be reachable
 #endif
 }