/*
 * More debugging hooks for `malloc'.
 * * Copyright (C) 1991, 1992, 1993, 1994 Free Software Foundation, Inc.
 * * Written April 2, 1991 by John Gilmore of Cygnus Support.
 * * Based on mcheck.c by Mike Haertel.
 * * 
 * * This 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.
 * * 
 * * This 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 this library; see the file COPYING.LIB.  If
 * * not, write to the Free Software Foundation, Inc., 675 Mass Ave,
 * * Cambridge, MA 02139, USA.
 * * 
 * * The author may be reached (Email) at the address mike@ai.mit.edu,
 * * or (US mail) as Mike Haertel c/o Free Software Foundation.  
 */

#include <stdio.h>

#include "copyright.h"
#include "autoconf.h"
#include "malloc.h"

static FILE *mallstream;
static char mallbuf[BUFSIZ];	/*

				 * Buffer for the output.  
				 */

/*
 * Address to breakpoint on accesses to... 
 */
__ptr_t mallwatch;

/*
 * File name and line number information, for callers that had
 * * the foresight to call through a macro.  
 */
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));

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

void tr_break __P((void));
void tr_break()
{
}

static void tr_where __P((void));
static void tr_where()
{
	if (_mtrace_file) {
		fprintf(mallstream, "@ %s:%d ", _mtrace_file, _mtrace_line);
		fflush(mallstream);
		_mtrace_file = NULL;
	}
}

static void tr_freehook __P((__ptr_t));
static void tr_freehook(ptr)
__ptr_t ptr;
{
	tr_where();
	fprintf(mallstream, "- %p\n", ptr);	/*
						 * Be sure to print it first. 
						 * 
						 * fflush(mallstream);
						 * 
						 * *  
						 */
	if (ptr == mallwatch)
		tr_break();
	__free_hook = tr_old_free_hook;
	free(ptr);
	__free_hook = tr_freehook;
}

static __ptr_t tr_mallochook __P((__malloc_size_t));
static __ptr_t
 tr_mallochook(size)
__malloc_size_t size;
{
	__ptr_t hdr;

	__malloc_hook = tr_old_malloc_hook;
	hdr = (__ptr_t) malloc(size);
	__malloc_hook = tr_mallochook;

	tr_where();
	/*
	 * We could be printing a NULL here; that's OK.  
	 */
	fprintf(mallstream, "+ %p %lx\n", hdr, (unsigned long)size);
	fflush(mallstream);


	if (hdr == mallwatch)
		tr_break();

	return hdr;
}

static __ptr_t tr_reallochook __P((__ptr_t, __malloc_size_t));
static __ptr_t
 tr_reallochook(ptr, size)
__ptr_t ptr;
__malloc_size_t size;
{
	__ptr_t hdr;

	if (ptr == mallwatch)
		tr_break();

	__free_hook = tr_old_free_hook;
	__malloc_hook = tr_old_malloc_hook;
	__realloc_hook = tr_old_realloc_hook;
	hdr = (__ptr_t) realloc(ptr, size);
	__free_hook = tr_freehook;
	__malloc_hook = tr_mallochook;
	__realloc_hook = tr_reallochook;
	tr_where();
	if (hdr == NULL)
		/*
		 * Failed realloc.  
		 */
		fprintf(mallstream, "! %p %lx\n", ptr, (unsigned long)size);
	else
		fprintf(mallstream, "< %p\n> %p %lx\n", ptr, hdr, (unsigned long)size);

	fflush(mallstream);

	if (hdr == mallwatch)
		tr_break();

	return hdr;
}

void mtrace()
{
	const char *mallfile = MTRACE_FILE;

	/*
	 * Don't panic if we're called more than once.  
	 */
	if (mallstream != NULL)
		return;

	if (mallfile != NULL || mallwatch != NULL) {
		mallstream = fopen(mallfile != NULL ? mallfile : "/dev/null", "w");
		if (mallstream != NULL) {
			/*
			 * Be sure it doesn't malloc its buffer!  
			 */
			setbuf(mallstream, mallbuf);
			fprintf(mallstream, "= Start\n");
			fflush(mallstream);

			tr_old_free_hook = __free_hook;
			__free_hook = tr_freehook;
			tr_old_malloc_hook = __malloc_hook;
			__malloc_hook = tr_mallochook;
			tr_old_realloc_hook = __realloc_hook;
			__realloc_hook = tr_reallochook;
		}
	}
}

void muntrace()
{
	if (mallstream == NULL)
		return;

	fprintf(mallstream, "= End\n");
	fflush(mallstream);

	fclose(mallstream);
	mallstream = NULL;
	__free_hook = tr_old_free_hook;
	__malloc_hook = tr_old_malloc_hook;
	__realloc_hook = tr_old_realloc_hook;
}