[gcc.git] / gcc / ada / gmem.c

/****************************************************************************
 *                                                                          *
 *                            GNATMEM COMPONENTS                            *
 *                                                                          *
 *                                 G M E M                                  *
 *                                                                          *
 *                             $Revision$
 *                                                                          *
 *                          C Implementation File                           *
 *                                                                          *
 *         Copyright (C) 2000-2001 Free Software Foundation, Inc.           *
 *                                                                          *
 * GNAT is free software;  you can  redistribute it  and/or modify it under *
 * terms of the  GNU General Public License as published  by the Free Soft- *
 * ware  Foundation;  either version 2,  or (at your option) any later ver- *
 * sion.  GNAT is distributed in the hope that it will be useful, but WITH- *
 * OUT ANY WARRANTY;  without even the  implied warranty of MERCHANTABILITY *
 * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License *
 * for  more details.  You should have  received  a copy of the GNU General *
 * Public License  distributed with GNAT;  see file COPYING.  If not, write *
 * to  the Free Software Foundation,  59 Temple Place - Suite 330,  Boston, *
 * MA 02111-1307, USA.                                                      *
 *                                                                          *
 * As a  special  exception,  if you  link  this file  with other  files to *
 * produce an executable,  this file does not by itself cause the resulting *
 * executable to be covered by the GNU General Public License. This except- *
 * ion does not  however invalidate  any other reasons  why the  executable *
 * file might be covered by the  GNU Public License.                        *
 *                                                                          *
 * GNAT was originally developed  by the GNAT team at  New York University. *
 * It is now maintained by Ada Core Technologies Inc (http://www.gnat.com). *
 *                                                                          *
 ****************************************************************************/

/*  This unit reads the allocation tracking log produced by augmented
    __gnat_malloc and __gnat_free procedures (see file a-raise.c) and
    provides GNATMEM tool with gdb-compliant output. The output is
    processed by GNATMEM to detect dynamic memory allocation errors.

    See GNATMEM section in GNAT User's Guide for more information.

    NOTE: This capability is currently supported on the following targets:

      DEC Unix
      SGI Irix
      GNU/Linux x86
      Solaris (sparc and x86) (*)
      Windows 98/95/NT (x86)

    (*) on these targets, the compilation must be done with -funwind-tables to
    be able to build the stack backtrace.   */

#ifdef __alpha_vxworks
#include "vxWorks.h"
#endif

#ifdef IN_RTS
#include "tconfig.h"
#include "tsystem.h"
#else
#include "config.h"
#include "system.h"
#endif

#include "adaint.h"

static FILE *gmemfile;

/* tb_len is the number of call level supported by this module */
#define TB_LEN 200

static char *tracebk [TB_LEN];
static int cur_tb_len, cur_tb_pos;

extern void convert_addresses		PARAMS ((char *[], int, void *,
						 int *));
static void gmem_read_backtrace 	PARAMS ((void));
static char *spc2nul			PARAMS ((char *));

extern int __gnat_gmem_initialize	PARAMS ((char *));
extern void __gnat_gmem_a2l_initialize	PARAMS ((char *));
extern void __gnat_gmem_read_next	PARAMS ((char *));
extern void __gnat_gmem_read_bt_frame	PARAMS ((char *));
\f
/* Reads backtrace information from gmemfile placing them in tracebk
   array. cur_tb_len is the size of this array.   */

static void
gmem_read_backtrace ()
{
  fread (&cur_tb_len, sizeof (int), 1, gmemfile);
  fread (tracebk, sizeof (char *), cur_tb_len, gmemfile);
  cur_tb_pos = 0;
}

/* Initialize gmem feature from the dumpname file. Return 1 if the
   dumpname has been generated by GMEM (instrumented malloc/free) and 0 if not
   (i.e. probably a GDB generated file). */

int
__gnat_gmem_initialize (dumpname)
     char *dumpname;
{
  char header[10];

  gmemfile = fopen (dumpname, "rb");
  fread (header, 10, 1, gmemfile);

  /* Check for GMEM magic-tag.  */
  if (memcmp (header, "GMEM DUMP\n", 10))
    {
      fclose (gmemfile);
      return 0;
    }

  return 1;
}

/* Initialize addr2line library */

void
__gnat_gmem_a2l_initialize (exename)
     char *exename;
{
  extern char **gnat_argv;
  char s [100];
  int l;

  gnat_argv [0] = exename;
  convert_addresses (tracebk, 1, s, &l);
}

/* Read next allocation of deallocation information from the GMEM file and
   write an alloc/free information in buf to be processed by GDB (see gnatmem
   implementation). */

void
__gnat_gmem_read_next (buf)
     char *buf;
{
  void *addr;
  int size;
  int j;

  j = fgetc (gmemfile);
  if (j == EOF)
    {
      fclose (gmemfile);
      sprintf (buf, "Program exited.");
    }
  else
    {
      switch (j)
        {
          case 'A' :
            fread (&addr, sizeof (char *), 1, gmemfile);
            fread (&size, sizeof (int), 1, gmemfile);
            sprintf (buf, "ALLOC^%d^0x%lx^", size, (long) addr);
            break;
          case 'D' :
            fread (&addr, sizeof (char *), 1, gmemfile);
            sprintf (buf, "DEALL^0x%lx^", (long) addr);
            break;
          default:
            puts ("GMEM dump file corrupt");
            __gnat_os_exit (1);
        }

      gmem_read_backtrace ();
    }
}

/* Scans the line until the space or new-line character is encountered;
   this character is replaced by nul and its position is returned.  */

static char *
spc2nul (s)
     char *s;
{
  while (*++s)
    if (*s == ' ' || *s == '\n')
      {
	*s = 0;
	return s;
      }

  abort ();
}

/* Convert backtrace address in tracebk at position cur_tb_pos to a symbolic
   traceback information returned in buf and to be processed by GDB (see
   gnatmem implementation).  */

void
__gnat_gmem_read_bt_frame (buf)
     char *buf;
{
  int l = 0;
  char s[1000];
  char *name, *file;

  if (cur_tb_pos >= cur_tb_len)
    {
      buf [0] = ' ';
      buf [1] = '\0';
      return;
    }

  convert_addresses (tracebk + cur_tb_pos, 1, s, &l);
  s[l] = '\0';
  name = spc2nul (s) + 4;
  file = spc2nul (name) + 4;
  spc2nul (file);
  ++cur_tb_pos;

  sprintf (buf, "#  %s () at %s", name, file);
}
Commit	Line	Data
38cbfe40 RK	1	/****************************************************************************
	2	* *
	3	* GNATMEM COMPONENTS *
	4	* *
	5	* G M E M *
	6	* *
5d1a9698	7	* $Revision$
38cbfe40 RK	8	* *
	9	* C Implementation File *
	10	* *
	11	* Copyright (C) 2000-2001 Free Software Foundation, Inc. *
	12	* *
	13	* GNAT is free software; you can redistribute it and/or modify it under *
	14	* terms of the GNU General Public License as published by the Free Soft- *
	15	* ware Foundation; either version 2, or (at your option) any later ver- *
	16	* sion. GNAT is distributed in the hope that it will be useful, but WITH- *
	17	* OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY *
	18	* or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License *
	19	* for more details. You should have received a copy of the GNU General *
	20	* Public License distributed with GNAT; see file COPYING. If not, write *
	21	* to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, *
	22	* MA 02111-1307, USA. *
	23	* *
	24	* As a special exception, if you link this file with other files to *
	25	* produce an executable, this file does not by itself cause the resulting *
	26	* executable to be covered by the GNU General Public License. This except- *
	27	* ion does not however invalidate any other reasons why the executable *
	28	* file might be covered by the GNU Public License. *
	29	* *
	30	* GNAT was originally developed by the GNAT team at New York University. *
	31	* It is now maintained by Ada Core Technologies Inc (http://www.gnat.com). *
	32	* *
	33	****************************************************************************/
	34
	35	/* This unit reads the allocation tracking log produced by augmented
	36	__gnat_malloc and __gnat_free procedures (see file a-raise.c) and
	37	provides GNATMEM tool with gdb-compliant output. The output is
	38	processed by GNATMEM to detect dynamic memory allocation errors.
	39
	40	See GNATMEM section in GNAT User's Guide for more information.
	41
	42	NOTE: This capability is currently supported on the following targets:
	43
	44	DEC Unix
	45	SGI Irix
5d1a9698	46	GNU/Linux x86
38cbfe40 RK	47	Solaris (sparc and x86) (*)
	48	Windows 98/95/NT (x86)
	49
	50	(*) on these targets, the compilation must be done with -funwind-tables to
	51	be able to build the stack backtrace. */
	52
	53	#ifdef __alpha_vxworks
	54	#include "vxWorks.h"
	55	#endif
	56
	57	#ifdef IN_RTS
	58	#include "tconfig.h"
	59	#include "tsystem.h"
	60	#else
	61	#include "config.h"
	62	#include "system.h"
	63	#endif
	64
	65	#include "adaint.h"
	66
	67	static FILE *gmemfile;
	68
	69	/* tb_len is the number of call level supported by this module */
	70	#define TB_LEN 200
	71
	72	static char *tracebk [TB_LEN];
	73	static int cur_tb_len, cur_tb_pos;
	74
	75	extern void convert_addresses PARAMS ((char [], int, void ,
	76	int *));
	77	static void gmem_read_backtrace PARAMS ((void));
	78	static char spc2nul PARAMS ((char ));
	79
	80	extern int __gnat_gmem_initialize PARAMS ((char *));
	81	extern void __gnat_gmem_a2l_initialize PARAMS ((char *));
	82	extern void __gnat_gmem_read_next PARAMS ((char *));
	83	extern void __gnat_gmem_read_bt_frame PARAMS ((char *));
	84	\f
	85	/* Reads backtrace information from gmemfile placing them in tracebk
	86	array. cur_tb_len is the size of this array. */
	87
	88	static void
	89	gmem_read_backtrace ()
	90	{
	91	fread (&cur_tb_len, sizeof (int), 1, gmemfile);
	92	fread (tracebk, sizeof (char *), cur_tb_len, gmemfile);
	93	cur_tb_pos = 0;
	94	}
	95
	96	/* Initialize gmem feature from the dumpname file. Return 1 if the
	97	dumpname has been generated by GMEM (instrumented malloc/free) and 0 if not
	98	(i.e. probably a GDB generated file). */
	99
	100	int
	101	__gnat_gmem_initialize (dumpname)
	102	char *dumpname;
	103	{
	104	char header[10];
	105
	106	gmemfile = fopen (dumpname, "rb");
	107	fread (header, 10, 1, gmemfile);
	108
	109	/* Check for GMEM magic-tag. */
	110	if (memcmp (header, "GMEM DUMP\n", 10))
111	{
112	fclose (gmemfile);
113	return 0;
114	}
c0b1738d	115
38cbfe40 RK	116	return 1;
	117	}
	118
	119	/* Initialize addr2line library */
	120
	121	void
	122	__gnat_gmem_a2l_initialize (exename)
	123	char *exename;
	124	{
	125	extern char **gnat_argv;
	126	char s [100];
	127	int l;
	128
	129	gnat_argv [0] = exename;
	130	convert_addresses (tracebk, 1, s, &l);
	131	}
	132
	133	/* Read next allocation of deallocation information from the GMEM file and
	134	write an alloc/free information in buf to be processed by GDB (see gnatmem
	135	implementation). */
	136
	137	void
	138	__gnat_gmem_read_next (buf)
	139	char *buf;
	140	{
	141	void *addr;
	142	int size;
c0b1738d	143	int j;
38cbfe40	144
c0b1738d RK	145	j = fgetc (gmemfile);
c0b1738d RK	146	if (j == EOF)
38cbfe40 RK	147	{
	148	fclose (gmemfile);
	149	sprintf (buf, "Program exited.");
	150	}
	151	else
	152	{
c0b1738d	153	switch (j)
38cbfe40 RK	154	{
	155	case 'A' :
	156	fread (&addr, sizeof (char *), 1, gmemfile);
	157	fread (&size, sizeof (int), 1, gmemfile);
	158	sprintf (buf, "ALLOC^%d^0x%lx^", size, (long) addr);
	159	break;
	160	case 'D' :
	161	fread (&addr, sizeof (char *), 1, gmemfile);
	162	sprintf (buf, "DEALL^0x%lx^", (long) addr);
	163	break;
	164	default:
	165	puts ("GMEM dump file corrupt");
	166	__gnat_os_exit (1);
	167	}
	168
	169	gmem_read_backtrace ();
	170	}
	171	}
	172
	173	/* Scans the line until the space or new-line character is encountered;
	174	this character is replaced by nul and its position is returned. */
	175
	176	static char *
	177	spc2nul (s)
	178	char *s;
	179	{
	180	while (*++s)
	181	if (s == ' ' \|\| s == '\n')
	182	{
	183	*s = 0;
	184	return s;
	185	}
	186
	187	abort ();
	188	}
	189
	190	/* Convert backtrace address in tracebk at position cur_tb_pos to a symbolic
	191	traceback information returned in buf and to be processed by GDB (see
	192	gnatmem implementation). */
	193
	194	void
	195	__gnat_gmem_read_bt_frame (buf)
	196	char *buf;
	197	{
	198	int l = 0;
	199	char s[1000];
	200	char name, file;
	201
	202	if (cur_tb_pos >= cur_tb_len)
	203	{
	204	buf [0] = ' ';
	205	buf [1] = '\0';
	206	return;
	207	}
	208
	209	convert_addresses (tracebk + cur_tb_pos, 1, s, &l);
	210	s[l] = '\0';
	211	name = spc2nul (s) + 4;
	212	file = spc2nul (name) + 4;
	213	spc2nul (file);
	214	++cur_tb_pos;
	215
	216	sprintf (buf, "# %s () at %s", name, file);
	217	}