Subversion Repositories or1k

/* More debugging hooks for `mmalloc'.

   Copyright 1991, 1992, 1994 Free Software Foundation

   Written April 2, 1991 by John Gilmore of Cygnus Support

   Based on mcheck.c by Mike Haertel.

   Modified Mar 1992 by Fred Fish.  (fnf@cygnus.com)

This file is part of the GNU C Library.

The GNU C Library is free software; you can redistribute it and/or

modify it under the terms of the GNU Library General Public License as

published by the Free Software Foundation; either version 2 of the

License, or (at your option) any later version.

The GNU C Library is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

Library General Public License for more details.

You should have received a copy of the GNU Library General Public

License along with the GNU C Library; see the file COPYING.LIB.  If

not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,

Boston, MA 02111-1307, USA.  */

#include <stdio.h>

#include "mmprivate.h"

static void tr_break PARAMS ((void));

static void tr_freehook PARAMS ((PTR, PTR));

static PTR tr_mallochook PARAMS ((PTR, size_t));

static PTR tr_reallochook PARAMS ((PTR, PTR, size_t));

#ifndef __GNU_LIBRARY__

extern char *getenv ();

#endif

static FILE *mallstream;

#if 0   /* FIXME:  Disabled for now. */

static char mallenv[] = "MALLOC_TRACE";

static char mallbuf[BUFSIZ];    /* Buffer for the output.  */

#endif

/* Address to breakpoint on accesses to... */

static PTR mallwatch;

/* Old hook values.  */

static void (*old_mfree_hook) PARAMS ((PTR, PTR));

static PTR (*old_mmalloc_hook) PARAMS ((PTR, size_t));

static PTR (*old_mrealloc_hook) PARAMS ((PTR, PTR, size_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,

   set "mallwatch" to the address of interest, then put a breakpoint on

   tr_break.  */

static void

tr_break ()

{

}

static void

tr_freehook (md, ptr)

  PTR md;

  PTR ptr;

{

  struct mdesc *mdp;

  mdp = MD_TO_MDP (md);

  /* Be sure to print it first.  */

  fprintf (mallstream, "- %08lx\n", (unsigned long) ptr);

  if (ptr == mallwatch)

    tr_break ();

  mdp -> mfree_hook = old_mfree_hook;

  mfree (md, ptr);

  mdp -> mfree_hook = tr_freehook;

}

static PTR

tr_mallochook (md, size)

  PTR md;

  size_t size;

{

  PTR hdr;

  struct mdesc *mdp;

  mdp = MD_TO_MDP (md);

  mdp -> mmalloc_hook = old_mmalloc_hook;

  hdr = (PTR) mmalloc (md, size);

  mdp -> mmalloc_hook = tr_mallochook;

  /* We could be printing a NULL here; that's OK.  */

  fprintf (mallstream, "+ %08lx %x\n", (unsigned long) hdr, size);

  if (hdr == mallwatch)

    tr_break ();

  return (hdr);

}

static PTR

tr_reallochook (md, ptr, size)

  PTR md;

  PTR ptr;

  size_t size;

{

  PTR hdr;

  struct mdesc *mdp;

  mdp = MD_TO_MDP (md);

  if (ptr == mallwatch)

    tr_break ();

  mdp -> mfree_hook = old_mfree_hook;

  mdp -> mmalloc_hook = old_mmalloc_hook;

  mdp -> mrealloc_hook = old_mrealloc_hook;

  hdr = (PTR) mrealloc (md, ptr, size);

  mdp -> mfree_hook = tr_freehook;

  mdp -> mmalloc_hook = tr_mallochook;

  mdp -> mrealloc_hook = tr_reallochook;

  if (hdr == NULL)

    /* Failed realloc.  */

    fprintf (mallstream, "! %08lx %x\n", (unsigned long) ptr, size);

  else

    fprintf (mallstream, "< %08lx\n> %08lx %x\n", (unsigned long) ptr,

             (unsigned long) hdr, size);

  if (hdr == mallwatch)

    tr_break ();

  return hdr;

}

/* 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,

   don't forget to set a breakpoint on tr_break!  */

int

mmtrace ()

{

#if 0   /* FIXME!  This is disabled for now until we figure out how to

           maintain a stack of hooks per heap, since we might have other

           hooks (such as set by mmcheck/mmcheckf) active also. */

  char *mallfile;

  mallfile = getenv (mallenv);

  if (mallfile  != NULL || mallwatch != NULL)

    {

      mallstream = fopen (mallfile != NULL ? mallfile : "/dev/null", "w");

      if (mallstream != NULL)

        {

          /* Be sure it doesn't mmalloc its buffer!  */

          setbuf (mallstream, mallbuf);

          fprintf (mallstream, "= Start\n");

          old_mfree_hook = mdp -> mfree_hook;

          mdp -> mfree_hook = tr_freehook;

          old_mmalloc_hook = mdp -> mmalloc_hook;

          mdp -> mmalloc_hook = tr_mallochook;

          old_mrealloc_hook = mdp -> mrealloc_hook;

          mdp -> mrealloc_hook = tr_reallochook;

        }

    }

#endif  /* 0 */

  return (1);

}