Likewise.
authordrepper <drepper>
Sat, 27 Sep 1997 00:15:37 +0000 (00:15 +0000)
committerdrepper <drepper>
Sat, 27 Sep 1997 00:15:37 +0000 (00:15 +0000)
(tr_where): If no information in _mtrace_file is given use the
information about the caller.

malloc/mtrace.c

index 3f0cbb9..aeefd56 100644 (file)
@@ -1,5 +1,5 @@
 /* More debugging hooks for `malloc'.
-   Copyright (C) 1991, 1992, 1993, 1994, 1996 Free Software Foundation, Inc.
+   Copyright (C) 1991, 92, 93, 94, 96, 97 Free Software Foundation, Inc.
                 Written April 2, 1991 by John Gilmore of Cygnus Support.
                 Based on mcheck.c by Mike Haertel.
 
 #include <bits/libc-lock.h>
 #endif
 
+#ifdef HAVE_ELF
+#include <link.h>
+#endif
+
 #include <stdio.h>
 
 #ifndef        __GNU_LIBRARY__
@@ -51,9 +55,12 @@ char *_mtrace_file;
 int _mtrace_line;
 
 /* Old hook values.  */
-static void (*tr_old_free_hook) __P ((__ptr_t ptr));
-static __ptr_t (*tr_old_malloc_hook) __P ((__malloc_size_t size));
-static __ptr_t (*tr_old_realloc_hook) __P ((__ptr_t ptr, __malloc_size_t size));
+static void (*tr_old_free_hook) __P ((__ptr_t ptr, const __ptr_t));
+static __ptr_t (*tr_old_malloc_hook) __P ((__malloc_size_t size,
+                                          const __ptr_t));
+static __ptr_t (*tr_old_realloc_hook) __P ((__ptr_t ptr,
+                                           __malloc_size_t size,
+                                           const __ptr_t));
 
 /* This function is called when the block being alloc'd, realloc'd, or
    freed has an address matching the variable "mallwatch".  In a debugger,
@@ -66,51 +73,77 @@ tr_break ()
 {
 }
 
-static void tr_where __P ((void));
+static void tr_where __P ((const __ptr_t));
 static void
-tr_where ()
+tr_where (caller)
+     const __ptr_t caller;
 {
   if (_mtrace_file)
     {
       fprintf (mallstream, "@ %s:%d ", _mtrace_file, _mtrace_line);
       _mtrace_file = NULL;
     }
+  else if (caller != NULL)
+    {
+#ifdef HAVE_ELF
+      Dl_info info;
+      if (_dl_addr (caller, &info))
+       {
+         fprintf (mallstream, "@ %s%s%s%s%s[%p]",
+                  info.dli_fname ?: "", info.dli_fname ? ":" : "",
+                  info.dli_sname ? "(" : "",
+                  info.dli_sname ?: "", info.dli_sname ? ") " : " ",
+                  caller);
+       }
+      else
+#endif
+       fprintf (mallstream, "@ [%p] ", caller);
+    }
 }
 
-static void tr_freehook __P ((__ptr_t));
+static void tr_freehook __P ((__ptr_t, const __ptr_t));
 static void
-tr_freehook (ptr)
+tr_freehook (ptr, caller)
      __ptr_t ptr;
+     const __ptr_t caller;
 {
-  tr_where ();
-  fprintf (mallstream, "- %p\n", ptr); /* Be sure to print it first.  */
+  tr_where (caller);
+  /* Be sure to print it first.  */
+  fprintf (mallstream, "- %p\n", ptr);
   if (ptr == mallwatch)
     tr_break ();
   __libc_lock_lock (lock);
   __free_hook = tr_old_free_hook;
-  free (ptr);
+  if (tr_old_free_hook != NULL)
+    (*tr_old_free_hook) (ptr, caller);
+  else
+    free (ptr);
   __free_hook = tr_freehook;
   __libc_lock_unlock (lock);
 }
 
-static __ptr_t tr_mallochook __P ((__malloc_size_t));
+static __ptr_t tr_mallochook __P ((__malloc_size_t, const __ptr_t));
 static __ptr_t
-tr_mallochook (size)
+tr_mallochook (size, caller)
      __malloc_size_t size;
+     const __ptr_t caller;
 {
   __ptr_t hdr;
 
   __libc_lock_lock (lock);
 
   __malloc_hook = tr_old_malloc_hook;
-  hdr = (__ptr_t) malloc (size);
+  if (tr_old_malloc_hook != NULL)
+    hdr = (__ptr_t) (*tr_old_malloc_hook) (size, caller);
+  else
+    hdr = (__ptr_t) malloc (size);
   __malloc_hook = tr_mallochook;
 
   __libc_lock_unlock (lock);
 
-  tr_where ();
+  tr_where (caller);
   /* We could be printing a NULL here; that's OK.  */
-  fprintf (mallstream, "+ %p %lx\n", hdr, (unsigned long)size);
+  fprintf (mallstream, "+ %p %#lx\n", hdr, (unsigned long)size);
 
   if (hdr == mallwatch)
     tr_break ();
@@ -118,11 +151,12 @@ tr_mallochook (size)
   return hdr;
 }
 
-static __ptr_t tr_reallochook __P ((__ptr_t, __malloc_size_t));
+static __ptr_t tr_reallochook __P ((__ptr_t, __malloc_size_t, const __ptr_t));
 static __ptr_t
-tr_reallochook (ptr, size)
+tr_reallochook (ptr, size, caller)
      __ptr_t ptr;
      __malloc_size_t size;
+     const __ptr_t caller;
 {
   __ptr_t hdr;
 
@@ -134,21 +168,24 @@ tr_reallochook (ptr, size)
   __free_hook = tr_old_free_hook;
   __malloc_hook = tr_old_malloc_hook;
   __realloc_hook = tr_old_realloc_hook;
-  hdr = (__ptr_t) realloc (ptr, size);
+  if (tr_old_realloc_hook != NULL)
+    hdr = (__ptr_t) (*tr_old_realloc_hook) (ptr, size, caller);
+  else
+    hdr = (__ptr_t) realloc (ptr, size);
   __free_hook = tr_freehook;
   __malloc_hook = tr_mallochook;
   __realloc_hook = tr_reallochook;
 
   __libc_lock_unlock (lock);
 
-  tr_where ();
+  tr_where (caller);
   if (hdr == NULL)
     /* Failed realloc.  */
-    fprintf (mallstream, "! %p %lx\n", ptr, (unsigned long)size);
+    fprintf (mallstream, "! %p %#lx\n", ptr, (unsigned long)size);
   else if (ptr == NULL)
-    fprintf (mallstream, "+ %p %lx\n", hdr, (unsigned long)size);
+    fprintf (mallstream, "+ %p %#lx\n", hdr, (unsigned long)size);
   else
-    fprintf (mallstream, "< %p\n> %p %lx\n", ptr, hdr, (unsigned long)size);
+    fprintf (mallstream, "< %p\n> %p %#lx\n", ptr, hdr, (unsigned long)size);
 
   if (hdr == mallwatch)
     tr_break ();