Merged third_party/tcmalloc/vendor/src(google-perftools r87) into...

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 405 matching lines @@
   {
     // Fall back to old 32-bit offset mmap() call
     // Old syscall interface cannot handle six args, so pass in an array
     int32 args[6] = { (int32) start, length, prot, flags, fd, (off_t) offset };
     result = (void *)syscall(SYS_mmap, args);
   }
  out:
   return result;
 }
 
-# endif
+# endif  // defined(__x86_64__)
 
 // We use do_mmap64 abstraction to put MallocHook::InvokeMmapHook
 // calls right into mmap and mmap64, so that the stack frames in the caller's
 // stack are at the same offsets for all the calls of memory allocating
 // functions.
 
 // Put all callers of MallocHook::Invoke* in this module into
 // malloc_hook section,
 // so that MallocHook::GetCallerStackTrace can function accurately:
 
@@ skipping 28 matching lines @@
 
 extern "C" void* mmap(void *start, size_t length, int prot, int flags,
                       int fd, off_t offset) __THROW {
   MallocHook::InvokePreMmapHook(start, length, prot, flags, fd, offset);
   void *result = do_mmap64(start, length, prot, flags, fd,
                            static_cast<size_t>(offset)); // avoid sign extension
   MallocHook::InvokeMmapHook(result, start, length, prot, flags, fd, offset);
   return result;
 }
 
-#endif
+#endif  // !defined(__USE_FILE_OFFSET64) || !defined(__REDIRECT_NTH)
 
 extern "C" int munmap(void* start, size_t length) __THROW {
   MallocHook::InvokeMunmapHook(start, length);
   return syscall(SYS_munmap, start, length);
 }
 
 extern "C" void* mremap(void* old_addr, size_t old_size, size_t new_size,
                         int flags, ...) __THROW {
   va_list ap;
   va_start(ap, flags);
   void *new_address = va_arg(ap, void *);
   va_end(ap);
   void* result = sys_mremap(old_addr, old_size, new_size, flags, new_address);
   MallocHook::InvokeMremapHook(result, old_addr, old_size, new_size, flags,
                                new_address);
   return result;
 }
 
 // libc's version:
 extern "C" void* __sbrk(ptrdiff_t increment);
 
 extern "C" void* sbrk(ptrdiff_t increment) __THROW {
   MallocHook::InvokePreSbrkHook(increment);
   void *result = __sbrk(increment);
   MallocHook::InvokeSbrkHook(result, increment);
   return result;
 }
 
-#endif
+/*static*/void* MallocHook::UnhookedMMap(void *start, size_t length, int prot,
+                                         int flags, int fd, off_t offset) {
+  return do_mmap64(start, length, prot, flags, fd, offset);
+}
+
+/*static*/int MallocHook::UnhookedMUnmap(void *start, size_t length) {
+  return sys_munmap(start, length);
+}
+
+#else   // defined(__linux) &&
+        // (defined(__i386__) || defined(__x86_64__) || defined(__PPC__))
+
+/*static*/void* MallocHook::UnhookedMMap(void *start, size_t length, int prot,
+                                         int flags, int fd, off_t offset) {
+  return mmap(start, length, prot, flags, fd, offset);
+}
+
+/*static*/int MallocHook::UnhookedMUnmap(void *start, size_t length) {
+  return munmap(start, length);
+}
+
+#endif  // defined(__linux) &&
+        // (defined(__i386__) || defined(__x86_64__) || defined(__PPC__))