Imported existing code

libraries/i686-linux/include/google/malloc_hook.h

@@ -0,0 +1,184 @@
+// 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
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// ---
+// Author: Sanjay Ghemawat
+//
+// Some of our malloc implementations can invoke the following hooks
+// whenever memory is allocated or deallocated.  If the hooks are
+// NULL, they are not invoked.
+//
+// One important user of these hooks is the heap profiler.
+//
+// CAVEAT: If you add new MallocHook::Invoke* calls (not for chaining hooks),
+// then those calls must be directly in the code of the (de)allocation
+// function that is provided to the user and that function must have
+// an ATTRIBUTE_SECTION(malloc_hook) attribute.
+
+#ifndef _MALLOC_HOOK_H
+#define _MALLOC_HOOK_H
+
+#include <stddef.h>
+#include <sys/types.h>
+
+// Annoying stuff for windows -- makes sure clients can import these functions
+#ifndef PERFTOOLS_DLL_DECL
+# ifdef WIN32
+#   define PERFTOOLS_DLL_DECL  __declspec(dllimport)
+# else
+#   define PERFTOOLS_DLL_DECL
+# endif
+#endif
+
+
+class PERFTOOLS_DLL_DECL MallocHook {
+ public:
+  // The NewHook is invoked whenever an object is allocated.
+  // It may be passed NULL if the allocator returned NULL.
+  typedef void (*NewHook)(const void* ptr, size_t size);
+  inline static NewHook GetNewHook() { return new_hook_; }
+  inline static NewHook SetNewHook(NewHook hook) {
+    NewHook result = new_hook_;
+    new_hook_ = hook;
+    return result;
+  }
+  inline static void InvokeNewHook(const void* p, size_t s) {
+    if (new_hook_ != NULL) (*new_hook_)(p, s);
+  }
+
+  // The DeleteHook is invoked whenever an object is deallocated.
+  // It may be passed NULL if the caller is trying to delete NULL.
+  typedef void (*DeleteHook)(const void* ptr);
+  inline static DeleteHook GetDeleteHook() { return delete_hook_; }
+  inline static DeleteHook SetDeleteHook(DeleteHook hook) {
+    DeleteHook result = delete_hook_;
+    delete_hook_ = hook;
+    return result;
+  }
+  inline static void InvokeDeleteHook(const void* p) {
+    if (delete_hook_ != NULL) (*delete_hook_)(p);
+  }
+
+  // The MmapHook is invoked whenever a region of memory is mapped.
+  // It may be passed MAP_FAILED if the mmap failed.
+  typedef void (*MmapHook)(const void* result,
+                           const void* start,
+                           size_t size,
+                           int protection,
+                           int flags,
+                           int fd,
+                           off_t offset);
+  inline static MmapHook GetMmapHook() { return mmap_hook_; }
+  inline static MmapHook SetMmapHook(MmapHook hook) {
+    MmapHook result = mmap_hook_;
+    mmap_hook_ = hook;
+    return result;
+  }
+  inline static void InvokeMmapHook(const void* result,
+                                    const void* start,
+                                    size_t size,
+                                    int protection,
+                                    int flags,
+                                    int fd,
+                                    off_t offset) {
+    if (mmap_hook_ != NULL) (*mmap_hook_)(result,
+                                          start, size,
+                                          protection, flags,
+                                          fd, offset);
+  }
+
+  // The MunmapHook is invoked whenever a region of memory is unmapped.
+  typedef void (*MunmapHook)(const void* ptr, size_t size);
+  inline static MunmapHook GetMunmapHook() { return munmap_hook_; }
+  inline static MunmapHook SetMunmapHook(MunmapHook hook) {
+    MunmapHook result = munmap_hook_;
+    munmap_hook_ = hook;
+    return result;
+  }
+  inline static void InvokeMunmapHook(const void* p, size_t size) {
+    if (munmap_hook_ != NULL) (*munmap_hook_)(p, size);
+  }
+
+  // The MremapHook is invoked whenever a region of memory is remapped.
+  typedef void (*MremapHook)(const void* result,
+                             const void* old_addr,
+                             size_t old_size,
+                             size_t new_size,
+                             int flags,
+                             const void* new_addr);
+  inline static MremapHook GetMremapHook() { return mremap_hook_; }
+  inline static MremapHook SetMremapHook(MremapHook hook) {
+    MremapHook result = mremap_hook_;
+    mremap_hook_ = hook;
+    return result;
+  }
+  inline static void InvokeMremapHook(const void* result,
+                                      const void* old_addr,
+                                      size_t old_size,
+                                      size_t new_size,
+                                      int flags,
+                                      const void* new_addr) {
+    if (mremap_hook_ != NULL) (*mremap_hook_)(result,
+                                              old_addr, old_size,
+                                              new_size, flags, new_addr);
+  }
+
+  // The SbrkHook is invoked whenever sbrk is called -- except when
+  // the increment is 0.  This is because sbrk(0) is often called
+  // to get the top of the memory stack, and is not actually a
+  // memory-allocation call.
+  typedef void (*SbrkHook)(const void* result, ptrdiff_t increment);
+  inline static SbrkHook GetSbrkHook() { return sbrk_hook_; }
+  inline static SbrkHook SetSbrkHook(SbrkHook hook) {
+    SbrkHook result = sbrk_hook_;
+    sbrk_hook_ = hook;
+    return result;
+  }
+  inline static void InvokeSbrkHook(const void* result, ptrdiff_t increment) {
+    if (sbrk_hook_ != NULL && increment != 0) (*sbrk_hook_)(result, increment);
+  }
+
+  // Get the current stack trace.  Try to skip all routines up to and
+  // and including the caller of MallocHook::Invoke*.
+  // Use "skip_count" (similarly to GetStackTrace from stacktrace.h)
+  // as a hint about how many routines to skip if better information
+  // is not available.
+  static int GetCallerStackTrace(void** result, int max_depth, int skip_count);
+
+ private:
+
+  static NewHook     new_hook_;
+  static DeleteHook  delete_hook_;
+  static MmapHook    mmap_hook_;
+  static MunmapHook  munmap_hook_;
+  static MremapHook  mremap_hook_;
+  static SbrkHook    sbrk_hook_;
+};
+
+#endif /* _MALLOC_HOOK_H */