tc_malloc_usable_size impl

third_party/tcmalloc/chromium/src/tcmalloc.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 264 matching lines @@
   void* memalign(size_t align, size_t s) __THROW ALIAS("tc_memalign");
   void* valloc(size_t size) __THROW              ALIAS("tc_valloc");
   void* pvalloc(size_t size) __THROW             ALIAS("tc_pvalloc");
   int posix_memalign(void** r, size_t a, size_t s) __THROW
       ALIAS("tc_posix_memalign");
   void malloc_stats(void) __THROW                ALIAS("tc_malloc_stats");
   int mallopt(int cmd, int value) __THROW        ALIAS("tc_mallopt");
 #ifdef HAVE_STRUCT_MALLINFO
   struct mallinfo mallinfo(void) __THROW         ALIAS("tc_mallinfo");
 #endif
+  size_t malloc_usable_size(void* ptr) __THROW   ALIAS("tc_malloc_usable_size");
 }   // extern "C"
 #else  // #if defined(__GNUC__) && !defined(__MACH__)
 // Portable wrappers
 void* operator new(size_t size)                  { return tc_new(size);       }
 void operator delete(void* p) __THROW            { tc_delete(p);              }
 void* operator new[](size_t size)                { return tc_newarray(size);  }
 void operator delete[](void* p) __THROW          { tc_deletearray(p);         }
 void* operator new(size_t size, const std::nothrow_t& nt) __THROW {
   return tc_new_nothrow(size, nt);
 }
@@ skipping 16 matching lines @@
   void* valloc(size_t s) __THROW                 { return tc_valloc(s);       }
   void* pvalloc(size_t s) __THROW                { return tc_pvalloc(s);      }
   int posix_memalign(void** r, size_t a, size_t s) __THROW {
     return tc_posix_memalign(r, a, s);
   }
   void malloc_stats(void) __THROW                { tc_malloc_stats();         }
   int mallopt(int cmd, int v) __THROW            { return tc_mallopt(cmd, v); }
 #ifdef HAVE_STRUCT_MALLINFO
   struct mallinfo mallinfo(void) __THROW         { return tc_mallinfo();      }
 #endif
+  size_t malloc_usable_size(void* p) __THROW {
+    return tc_malloc_usable_size(p);
+  }
 }  // extern "C"
 #endif  // #if defined(__GNUC__)
 
 // Some library routines on RedHat 9 allocate memory using malloc()
 // and free it using __libc_free() (or vice-versa).  Since we provide
 // our own implementations of malloc/free, we need to make sure that
 // the __libc_XXX variants (defined as part of glibc) also point to
 // the same implementations.
 #ifdef __GLIBC__       // only glibc defines __libc_*
 extern "C" {
@@ skipping 1187 matching lines @@
 extern "C" PERFTOOLS_DLL_DECL int tc_mallopt(int cmd, int value) __THROW {
   return do_mallopt(cmd, value);
 }
 
 #ifdef HAVE_STRUCT_MALLINFO
 extern "C" PERFTOOLS_DLL_DECL struct mallinfo tc_mallinfo(void) __THROW {
   return do_mallinfo();
 }
 #endif
 
+extern "C" PERFTOOLS_DLL_DECL size_t tc_malloc_usable_size(void* ptr) __THROW {
+  return GetSizeWithCallback(ptr, &InvalidGetAllocatedSize);
+}
+
 // This function behaves similarly to MSVC's _set_new_mode.
 // If flag is 0 (default), calls to malloc will behave normally.
 // If flag is 1, calls to malloc will behave like calls to new,
 // and the std_new_handler will be invoked on failure.
 // Returns the previous mode.
 extern "C" PERFTOOLS_DLL_DECL int tc_set_new_mode(int flag) __THROW {
   int old_mode = tc_new_mode;
   tc_new_mode = flag;
   return old_mode;
 }
@@ skipping 11 matching lines @@
     __THROW ATTRIBUTE_SECTION(google_malloc);
 
 static void *MemalignOverride(size_t align, size_t size, const void *caller)
     __THROW {
   void* result = do_memalign_or_cpp_memalign(align, size);
   MallocHook::InvokeNewHook(result, size);
   return result;
 }
 void *(*__memalign_hook)(size_t, size_t, const void *) = MemalignOverride;
 #endif  // #ifndef TCMALLOC_FOR_DEBUGALLOCATION