mirror of
https://sourceware.org/git/binutils-gdb.git
synced 2024-12-03 04:12:10 +08:00
224 lines
6.8 KiB
C
224 lines
6.8 KiB
C
|
/* Standard debugging hooks for `mmalloc'.
|
||
|
Copyright 1990, 1991, 1992 Free Software Foundation
|
||
|
|
||
|
Written May 1989 by Mike Haertel.
|
||
|
Heavily modified Mar 1992 by Fred Fish (fnf@cygnus.com)
|
||
|
|
||
|
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.
|
||
|
|
||
|
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 "mmprivate.h"
|
||
|
|
||
|
/* Default function to call when something awful happens. The application
|
||
|
can specify an alternate function to be called instead (and probably will
|
||
|
want to). */
|
||
|
|
||
|
extern void abort PARAMS ((void));
|
||
|
|
||
|
/* Arbitrary magical numbers. */
|
||
|
|
||
|
#define MAGICWORD (unsigned int) 0xfedabeeb /* Active chunk */
|
||
|
#define MAGICWORDFREE (unsigned int) 0xdeadbeef /* Inactive chunk */
|
||
|
#define MAGICBYTE ((char) 0xd7)
|
||
|
|
||
|
/* Each memory allocation is bounded by a header structure and a trailer
|
||
|
byte. I.E.
|
||
|
|
||
|
<size><magicword><user's allocation><magicbyte>
|
||
|
|
||
|
The pointer returned to the user points to the first byte in the
|
||
|
user's allocation area. The magic word can be tested to detect
|
||
|
buffer underruns and the magic byte can be tested to detect overruns. */
|
||
|
|
||
|
struct hdr
|
||
|
{
|
||
|
size_t size; /* Exact size requested by user. */
|
||
|
unsigned long int magic; /* Magic number to check header integrity. */
|
||
|
};
|
||
|
|
||
|
static void checkhdr PARAMS ((struct mdesc *, CONST struct hdr *));
|
||
|
static void mfree_check PARAMS ((PTR, PTR));
|
||
|
static PTR mmalloc_check PARAMS ((PTR, size_t));
|
||
|
static PTR mrealloc_check PARAMS ((PTR, PTR, size_t));
|
||
|
|
||
|
/* Check the magicword and magicbyte, and if either is corrupted then
|
||
|
call the emergency abort function specified for the heap in use. */
|
||
|
|
||
|
static void
|
||
|
checkhdr (mdp, hdr)
|
||
|
struct mdesc *mdp;
|
||
|
CONST struct hdr *hdr;
|
||
|
{
|
||
|
if (hdr -> magic != MAGICWORD ||
|
||
|
((char *) &hdr[1])[hdr -> size] != MAGICBYTE)
|
||
|
{
|
||
|
(*mdp -> abortfunc)();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static void
|
||
|
mfree_check (md, ptr)
|
||
|
PTR md;
|
||
|
PTR ptr;
|
||
|
{
|
||
|
struct hdr *hdr = ((struct hdr *) ptr) - 1;
|
||
|
struct mdesc *mdp;
|
||
|
|
||
|
mdp = MD_TO_MDP (md);
|
||
|
checkhdr (mdp, hdr);
|
||
|
hdr -> magic = MAGICWORDFREE;
|
||
|
mdp -> mfree_hook = NULL;
|
||
|
mfree (md, (PTR)hdr);
|
||
|
mdp -> mfree_hook = mfree_check;
|
||
|
}
|
||
|
|
||
|
static PTR
|
||
|
mmalloc_check (md, size)
|
||
|
PTR md;
|
||
|
size_t size;
|
||
|
{
|
||
|
struct hdr *hdr;
|
||
|
struct mdesc *mdp;
|
||
|
size_t nbytes;
|
||
|
|
||
|
mdp = MD_TO_MDP (md);
|
||
|
mdp -> mmalloc_hook = NULL;
|
||
|
nbytes = sizeof (struct hdr) + size + 1;
|
||
|
hdr = (struct hdr *) mmalloc (md, nbytes);
|
||
|
mdp -> mmalloc_hook = mmalloc_check;
|
||
|
if (hdr != NULL)
|
||
|
{
|
||
|
hdr -> size = size;
|
||
|
hdr -> magic = MAGICWORD;
|
||
|
hdr++;
|
||
|
*((char *) hdr + size) = MAGICBYTE;
|
||
|
}
|
||
|
return ((PTR) hdr);
|
||
|
}
|
||
|
|
||
|
static PTR
|
||
|
mrealloc_check (md, ptr, size)
|
||
|
PTR md;
|
||
|
PTR ptr;
|
||
|
size_t size;
|
||
|
{
|
||
|
struct hdr *hdr = ((struct hdr *) ptr) - 1;
|
||
|
struct mdesc *mdp;
|
||
|
size_t nbytes;
|
||
|
|
||
|
mdp = MD_TO_MDP (md);
|
||
|
checkhdr (mdp, hdr);
|
||
|
mdp -> mfree_hook = NULL;
|
||
|
mdp -> mmalloc_hook = NULL;
|
||
|
mdp -> mrealloc_hook = NULL;
|
||
|
nbytes = sizeof (struct hdr) + size + 1;
|
||
|
hdr = (struct hdr *) mrealloc (md, (PTR) hdr, nbytes);
|
||
|
mdp -> mfree_hook = mfree_check;
|
||
|
mdp -> mmalloc_hook = mmalloc_check;
|
||
|
mdp -> mrealloc_hook = mrealloc_check;
|
||
|
if (hdr != NULL)
|
||
|
{
|
||
|
hdr -> size = size;
|
||
|
hdr++;
|
||
|
*((char *) hdr + size) = MAGICBYTE;
|
||
|
}
|
||
|
return ((PTR) hdr);
|
||
|
}
|
||
|
|
||
|
/* Turn on default checking for mmalloc/mrealloc/mfree, for the heap specified
|
||
|
by MD. If FUNC is non-NULL, it is a pointer to the function to call
|
||
|
to abort whenever memory corruption is detected. By default, this is the
|
||
|
standard library function abort().
|
||
|
|
||
|
Note that we disallow installation of initial checking hooks if mmalloc
|
||
|
has been called at any time for this particular heap, since if any region
|
||
|
that is allocated prior to installation of the hooks is subsequently
|
||
|
reallocated or freed after installation of the hooks, it is guaranteed
|
||
|
to trigger a memory corruption error. We do this by checking the state
|
||
|
of the MMALLOC_INITIALIZED flag. If the FORCE argument is non-zero, this
|
||
|
checking is disabled and it is allowed to install the checking hooks at any
|
||
|
time. This is useful on systems where the C runtime makes one or more
|
||
|
malloc calls before the user code had a chance to call mmcheck or mmcheckf,
|
||
|
but never calls free with these values. Thus if we are certain that only
|
||
|
values obtained from mallocs after an mmcheck/mmcheckf will ever be passed
|
||
|
to free(), we can go ahead and force installation of the useful checking
|
||
|
hooks.
|
||
|
|
||
|
However, we can call this function at any time after the initial call,
|
||
|
to update the function pointers to the checking routines and to the
|
||
|
user defined corruption handler routine, as long as these function pointers
|
||
|
have been previously extablished by the initial call. Note that we
|
||
|
do this automatically when remapping a previously used heap, to ensure
|
||
|
that the hooks get updated to the correct values, although the corruption
|
||
|
handler pointer gets set back to the default. The application can then
|
||
|
call mmcheck to use a different corruption handler if desired.
|
||
|
|
||
|
Returns non-zero if checking is successfully enabled, zero otherwise. */
|
||
|
|
||
|
int
|
||
|
mmcheckf (md, func, force)
|
||
|
PTR md;
|
||
|
void (*func) PARAMS ((void));
|
||
|
int force;
|
||
|
{
|
||
|
struct mdesc *mdp;
|
||
|
int rtnval;
|
||
|
|
||
|
mdp = MD_TO_MDP (md);
|
||
|
|
||
|
/* We can safely set or update the abort function at any time, regardless
|
||
|
of whether or not we successfully do anything else. */
|
||
|
|
||
|
mdp -> abortfunc = (func != NULL ? func : abort);
|
||
|
|
||
|
/* If we haven't yet called mmalloc the first time for this heap, or if we
|
||
|
have hooks that were previously installed, then allow the hooks to be
|
||
|
initialized or updated. */
|
||
|
|
||
|
if (force ||
|
||
|
!(mdp -> flags & MMALLOC_INITIALIZED) ||
|
||
|
(mdp -> mfree_hook != NULL))
|
||
|
{
|
||
|
mdp -> mfree_hook = mfree_check;
|
||
|
mdp -> mmalloc_hook = mmalloc_check;
|
||
|
mdp -> mrealloc_hook = mrealloc_check;
|
||
|
mdp -> flags |= MMALLOC_MMCHECK_USED;
|
||
|
rtnval = 1;
|
||
|
}
|
||
|
else
|
||
|
{
|
||
|
rtnval = 0;
|
||
|
}
|
||
|
|
||
|
return (rtnval);
|
||
|
}
|
||
|
|
||
|
/* This routine is for backwards compatibility only, in case there are
|
||
|
still callers to the original mmcheck function. */
|
||
|
|
||
|
int
|
||
|
mmcheck (md, func)
|
||
|
PTR md;
|
||
|
void (*func) PARAMS ((void));
|
||
|
{
|
||
|
int rtnval;
|
||
|
|
||
|
rtnval = mmcheckf (md, func, 0);
|
||
|
return (rtnval);
|
||
|
}
|