/* More debugging hooks for `malloc'.
- Copyright (C) 1991, 1992, 1993, 1994, 1996 Free Software Foundation, Inc.
+ Copyright (C) 1991, 92, 93, 94, 96, 97, 98 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
-#include <stdio.h>
+#include <ldsodefs.h>
-#ifndef __GNU_LIBRARY__
-extern char *getenv ();
-#else
+#include <stdio.h>
+#include <string.h>
#include <stdlib.h>
+
+#include <stdio-common/_itoa.h>
+
+#ifdef USE_IN_LIBIO
+# include <libio/iolibio.h>
+# define setvbuf(s, b, f, l) _IO_setvbuf (s, b, f, l)
#endif
+#define TRACE_BUFFER_SIZE 512
+
static FILE *mallstream;
-static char mallenv[]= "MALLOC_TRACE";
-static char mallbuf[BUFSIZ]; /* Buffer for the output. */
+static const char mallenv[]= "MALLOC_TRACE";
+static char malloc_trace_buffer[TRACE_BUFFER_SIZE];
__libc_lock_define_initialized (static, lock);
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,
{
}
-static void tr_where __P ((void));
+static void tr_where __P ((const __ptr_t)) internal_function;
static void
-tr_where ()
+internal_function
+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))
+ {
+ char *buf = (char *) "";
+ if (info.dli_sname && info.dli_sname[0])
+ {
+ size_t len = strlen (info.dli_sname);
+ buf = alloca (len + 6 + 2 * sizeof (void *));
+
+ buf[0] = '(';
+ __stpcpy (_fitoa (caller >= (const __ptr_t) info.dli_saddr
+ ? caller - (const __ptr_t) info.dli_saddr
+ : (const __ptr_t) info.dli_saddr - caller,
+ __stpcpy (__mempcpy (buf + 1, info.dli_sname,
+ len),
+ caller >= (__ptr_t) info.dli_saddr
+ ? "+0x" : "-0x"),
+ 16, 0),
+ ")");
+ }
+
+ fprintf (mallstream, "@ %s%s%s[%p] ",
+ info.dli_fname ?: "", info.dli_fname ? ":" : "",
+ buf, 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 int) size);
if (hdr == mallwatch)
tr_break ();
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;
__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 int) size);
else if (ptr == NULL)
- fprintf (mallstream, "+ %p %lx\n", hdr, (unsigned long)size);
+ fprintf (mallstream, "+ %p %#lx\n", hdr, (unsigned long int) size);
else
- fprintf (mallstream, "< %p\n> %p %lx\n", ptr, hdr, (unsigned long)size);
+ {
+ fprintf (mallstream, "< %p\n", ptr);
+ tr_where (caller);
+ fprintf (mallstream, "> %p %#lx\n", hdr, (unsigned long int) size);
+ }
if (hdr == mallwatch)
tr_break ();
return hdr;
}
+
+#ifdef _LIBC
+extern void __libc_freeres (void);
+
+/* This function gets called to make sure all memory the library
+ allocates get freed and so does not irritate the user when studying
+ the mtrace output. */
+static void
+release_libc_mem (void)
+{
+ /* Only call the free function if we still are running in mtrace mode. */
+ if (mallstream != NULL)
+ __libc_freeres ();
+}
+#endif
+
+
/* We enable tracing if either the environment variable MALLOC_TRACE
is set, or if the variable mallwatch has been patched to an address
that the debugging user wants us to stop on. When patching mallwatch,
void
mtrace ()
{
+#ifdef _LIBC
+ static int added_atexit_handler = 0;
+#endif
char *mallfile;
/* Don't panic if we're called more than once. */
if (mallstream != NULL)
{
/* Be sure it doesn't malloc its buffer! */
- setbuf (mallstream, mallbuf);
+ setvbuf (mallstream, malloc_trace_buffer, _IOFBF, TRACE_BUFFER_SIZE);
fprintf (mallstream, "= Start\n");
tr_old_free_hook = __free_hook;
__free_hook = tr_freehook;
__malloc_hook = tr_mallochook;
tr_old_realloc_hook = __realloc_hook;
__realloc_hook = tr_reallochook;
+#ifdef _LIBC
+ if (!added_atexit_handler)
+ {
+ added_atexit_handler = 1;
+ atexit (release_libc_mem);
+ }
+#endif
}
}
}
projects / kopensolaris-gnu / glibc.git / blobdiff