/* malloc.c - dynamic memory allocation for bash. */
-/* Copyright (C) 1985, 1987, 1997 Free Software Foundation, Inc.
+/* Copyright (C) 1985-2005 Free Software Foundation, Inc.
- This program is free software; you can redistribute it and/or modify
- it under the terms of the GNU General Public License as published by
- the Free Software Foundation; either version 1, or (at your option)
- any later version.
+ This file is part of GNU Bash, the Bourne-Again SHell.
+
+ Bash is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
- This program 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 General Public License for more details.
+ Bash 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 General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-In other words, you are welcome to use, share and improve this program.
-You are forbidden to forbid anyone else to use, share and improve
-what you give them. Help stamp out software-hoarding! */
+ You should have received a copy of the GNU General Public License
+ along with Bash. If not, see <http://www.gnu.org/licenses/>.
+*/
/*
* @(#)nmalloc.c 1 (Caltech) 2/21/82
* realloc knows how to return same block given, just changing its size,
* if the power of 2 is correct.
*/
-#define MALLOC_STATS /* for the time being */
/*
* nextf[i] is the pointer to the next free block of size 2^(i+3). The
* to the second.
*/
-/* Define this to have free() write 0xcf into memory as it's freed, to
- uncover callers that refer to freed memory. */
-/* SCO 3.2v4 getcwd and possibly other libc routines fail with MEMSCRAMBLE */
-#if !defined (NO_MEMSCRAMBLE)
-# define MEMSCRAMBLE
-#endif
+/* Define MEMSCRAMBLE to have free() write 0xcf into memory as it's freed, to
+ uncover callers that refer to freed memory, and to have malloc() write 0xdf
+ into memory as it's allocated to avoid referring to previous contents. */
+
+/* SCO 3.2v4 getcwd and possibly other libc routines fail with MEMSCRAMBLE;
+ handled by configure. */
#if defined (HAVE_CONFIG_H)
# include <config.h>
#if defined (SHELL)
# include "bashtypes.h"
+# include "stdc.h"
#else
# include <sys/types.h>
#endif
# include <strings.h>
#endif
-#if defined (MALLOC_STATS) || !defined (botch)
-# include <stdio.h>
-#endif /* MALLOC_STATS || !botch */
+#include <stdio.h>
/* Define getpagesize () if the system does not. */
#ifndef HAVE_GETPAGESIZE
# include "getpagesize.h"
#endif
-#if __GNUC__ > 1
-# define FASTCOPY(s, d, n) __builtin_memcpy (d, s, n)
-#else /* !__GNUC__ */
-# if !defined (HAVE_BCOPY)
-# if !defined (HAVE_MEMMOVE)
-# define FASTCOPY(s, d, n) memcpy (d, s, n)
-# else
-# define FASTCOPY(s, d, n) memmove (d, s, n)
-# endif /* !HAVE_MEMMOVE */
-# else /* HAVE_BCOPY */
-# define FASTCOPY(s, d, n) bcopy (s, d, n)
-# endif /* HAVE_BCOPY */
-#endif /* !__GNUC__ */
+#include "imalloc.h"
+#ifdef MALLOC_STATS
+# include "mstats.h"
+#endif
+#ifdef MALLOC_REGISTER
+# include "table.h"
+#endif
+#ifdef MALLOC_WATCH
+# include "watch.h"
+#endif
-#if !defined (NULL)
-# define NULL 0
+/* System-specific omissions. */
+#ifdef HPUX
+# define NO_VALLOC
#endif
#define NBUCKETS 30
being the distance to the true
beginning of the block. */
-#if !defined (SBRK_DECLARED)
-extern char *sbrk ();
-#endif /* !SBRK_DECLARED */
-
-#ifdef MALLOC_STATS
-/*
- * NMALLOC[i] is the difference between the number of mallocs and frees
- * for a given block size. TMALLOC[i] is the total number of mallocs for
- * a given block size. NMORECORE[i] is the total number of calls to
- * morecore(i). NMAL and NFRE are counts of the number of calls to malloc()
- * and free(), respectively. NREALLOC is the total number of calls to
- * realloc(); NRCOPY is the number of times realloc() had to allocate new
- * memory and copy to it. NRECURSE is a count of the number of recursive
- * calls to malloc() for the same bucket size, which can be caused by calls
- * to malloc() from a signal handler. NSBRK is the number of calls to sbrk()
- * (whether by morecore() or for alignment); TSBRK is the total number of
- * bytes requested from the kernel with sbrk(). BYTESUSED is the total
- * number of bytes consumed by blocks currently in use; BYTESFREE is the
- * total number of bytes currently on all of the free lists. NBSPLIT is
- * the number of times a larger block was split to satisfy a smaller request.
- * NBCOALESCE is the number of times two adjacent smaller blocks off the free
- * list were combined to satisfy a larger request.
- */
-struct _malstats {
- int nmalloc[NBUCKETS];
- int tmalloc[NBUCKETS];
- int nmorecore[NBUCKETS];
- int nmal;
- int nfre;
- int nrealloc;
- int nrcopy;
- int nrecurse;
- int nsbrk;
- int32_t tsbrk;
- int32_t bytesused;
- int32_t bytesfree;
- int nbsplit;
- int nbcoalesce;
-};
-
-static struct _malstats _mstats;
-
-/* Return statistics describing allocation of blocks of size BLOCKSIZE.
- NFREE is the number of free blocks for this allocation size. NUSED
- is the number of blocks in use. NMAL is the number of requests for
- blocks of size BLOCKSIZE. NMORECORE is the number of times we had
- to call MORECORE to repopulate the free list for this bucket. */
-struct bucket_stats {
- u_int32_t blocksize;
- int nfree;
- int nused;
- int nmal;
- int nmorecore;
-};
-#endif /* MALLOC_STATS */
/* We have a flag indicating whether memory is allocated, an index in
nextf[], a size field, and a sentinel value to determine whether or
enough room in the block for the new size. Range checking is always
done. */
union mhead {
- bits64_t mh_align; /* 8 */
+ bits64_t mh_align; /* 8 */
struct {
- char mi_alloc; /* ISALLOC or ISFREE */ /* 1 */
- char mi_index; /* index in nextf[] */ /* 1 */
+ char mi_alloc; /* ISALLOC or ISFREE */ /* 1 */
+ char mi_index; /* index in nextf[] */ /* 1 */
/* Remainder are valid only when block is allocated */
- u_int32_t mi_nbytes; /* # of bytes allocated */ /* 4 */
- unsigned short mi_magic2;/* should be == MAGIC2 */ /* 2 */
+ u_bits16_t mi_magic2; /* should be == MAGIC2 */ /* 2 */
+ u_bits32_t mi_nbytes; /* # of bytes allocated */ /* 4 */
} minfo;
};
#define mh_alloc minfo.mi_alloc
#define mh_nbytes minfo.mi_nbytes
#define mh_magic2 minfo.mi_magic2
+#define MOVERHEAD sizeof(union mhead)
+#define MALIGN_MASK 7 /* one less than desired alignment */
+
+typedef union _malloc_guard {
+ char s[4];
+ u_bits32_t i;
+} mguard_t;
+
/* Access free-list pointer of a block.
It is stored at block + sizeof (char *).
This is not a field in the minfo structure member of union mhead
#define CHAIN(a) \
(*(union mhead **) (sizeof (char *) + (char *) (a)))
-#if defined (botch)
-extern void botch ();
-#else
-static void
-botch (s)
- char *s;
-{
- fprintf (stderr, "\r\nmalloc: assertion botched: %s\r\n", s);
- (void)fflush (stderr);
- abort ();
-}
-#endif /* !botch */
-
-#if !defined (__STRING)
-# if defined (__STDC__)
-# define __STRING(x) #x
-# else
-# define __STRING(x) "x"
-# endif
-#endif /* !__STRING */
-
/* To implement range checking, we write magic values in at the beginning
and end of each allocated block, and make sure they are undisturbed
whenever a free or a realloc occurs. */
-/* Written in each of the 4 bytes following the block's real space */
-#define MAGIC1 0x55
-/* Written in the 2 bytes before the block's real space */
+/* Written in the 2 bytes before the block's real space (-4 bytes) */
#define MAGIC2 0x5555
-#define ASSERT(p) do { if (!(p)) botch(__STRING(p)); } while (0)
-#define MSLOP 4 /* 4 bytes extra for MAGIC1s */
+#define MSLOP 4 /* 4 bytes extra for u_bits32_t size */
+
+/* How many bytes are actually allocated for a request of size N --
+ rounded up to nearest multiple of 8 after accounting for malloc
+ overhead. */
+#define ALLOCATED_BYTES(n) \
+ (((n) + MOVERHEAD + MSLOP + MALIGN_MASK) & ~MALIGN_MASK)
+
+#define ASSERT(p) \
+ do \
+ { \
+ if (!(p)) xbotch((PTR_T)0, ERR_ASSERT_FAILED, __STRING(p), file, line); \
+ } \
+ while (0)
/* Minimum and maximum bucket indices for block splitting (and to bound
the search for a block to split). */
-#define SPLIT_MIN 3
-#define SPLIT_MID 9
-#define SPLIT_MAX 12
+#define SPLIT_MIN 2 /* XXX - was 3 */
+#define SPLIT_MID 11
+#define SPLIT_MAX 14
/* Minimum and maximum bucket indices for block coalescing. */
-#define COMBINE_MIN 6
-#define COMBINE_MAX (pagebucket - 1)
-
-#define MIN_COMBINE_FREE 4
+#define COMBINE_MIN 2
+#define COMBINE_MAX (pagebucket - 1) /* XXX */
+
+#define LESSCORE_MIN 10
+#define LESSCORE_FRC 13
+
+#define STARTBUCK 1
+
+/* Flags for the internal functions. */
+#define MALLOC_WRAPPER 0x01 /* wrapper function */
+#define MALLOC_INTERNAL 0x02 /* internal function calling another */
+#define MALLOC_NOTRACE 0x04 /* don't trace this allocation or free */
+#define MALLOC_NOREG 0x08 /* don't register this allocation or free */
+
+/* Future use. */
+#define ERR_DUPFREE 0x01
+#define ERR_UNALLOC 0x02
+#define ERR_UNDERFLOW 0x04
+#define ERR_ASSERT_FAILED 0x08
+
+/* Evaluates to true if NB is appropriate for bucket NU. NB is adjusted
+ appropriately by the caller to account for malloc overhead. This only
+ checks that the recorded size is not too big for the bucket. We
+ can't check whether or not it's in between NU and NU-1 because we
+ might have encountered a busy bucket when allocating and moved up to
+ the next size. */
+#define IN_BUCKET(nb, nu) ((nb) <= binsizes[(nu)])
+
+/* Use this when we want to be sure that NB is in bucket NU. */
+#define RIGHT_BUCKET(nb, nu) \
+ (((nb) > binsizes[(nu)-1]) && ((nb) <= binsizes[(nu)]))
/* nextf[i] is free list of blocks of size 2**(i + 3) */
static union mhead *nextf[NBUCKETS];
-/* busy[i] is nonzero while allocation of block size i is in progress. */
+/* busy[i] is nonzero while allocation or free of block size i is in progress. */
static char busy[NBUCKETS];
static int pagesz; /* system page size. */
static int pagebucket; /* bucket for requests a page in size */
+static int maxbuck; /* highest bucket receiving allocation request. */
+
+static char *memtop; /* top of heap */
+
+static const unsigned long binsizes[NBUCKETS] = {
+ 8UL, 16UL, 32UL, 64UL, 128UL, 256UL, 512UL, 1024UL, 2048UL, 4096UL,
+ 8192UL, 16384UL, 32768UL, 65536UL, 131072UL, 262144UL, 524288UL,
+ 1048576UL, 2097152UL, 4194304UL, 8388608UL, 16777216UL, 33554432UL,
+ 67108864UL, 134217728UL, 268435456UL, 536870912UL, 1073741824UL,
+ 2147483648UL, 4294967295UL
+};
+
+/* binsizes[x] == (1 << ((x) + 3)) */
+#define binsize(x) binsizes[(x)]
+
+/* Declarations for internal functions */
+static PTR_T internal_malloc __P((size_t, const char *, int, int));
+static PTR_T internal_realloc __P((PTR_T, size_t, const char *, int, int));
+static void internal_free __P((PTR_T, const char *, int, int));
+static PTR_T internal_memalign __P((size_t, size_t, const char *, int, int));
+#ifndef NO_CALLOC
+static PTR_T internal_calloc __P((size_t, size_t, const char *, int, int));
+static void internal_cfree __P((PTR_T, const char *, int, int));
+#endif
+#ifndef NO_VALLOC
+static PTR_T internal_valloc __P((size_t, const char *, int, int));
+#endif
+
+#if defined (botch)
+extern void botch ();
+#else
+static void botch __P((const char *, const char *, int));
+#endif
+static void xbotch __P((PTR_T, int, const char *, const char *, int));
+
+#if !HAVE_DECL_SBRK
+extern char *sbrk ();
+#endif /* !HAVE_DECL_SBRK */
+
+#ifdef SHELL
+extern int interrupt_immediately;
+extern int signal_is_trapped __P((int));
+#endif
+
+#ifdef MALLOC_STATS
+struct _malstats _mstats;
+#endif /* MALLOC_STATS */
+
+/* Debugging variables available to applications. */
+int malloc_flags = 0; /* future use */
+int malloc_trace = 0; /* trace allocations and frees to stderr */
+int malloc_register = 0; /* future use */
+
+#ifdef MALLOC_TRACE
+char _malloc_trace_buckets[NBUCKETS];
+
+/* These should really go into a header file. */
+extern void mtrace_alloc __P((const char *, PTR_T, size_t, const char *, int));
+extern void mtrace_free __P((PTR_T, int, const char *, int));
+#endif
+
+#if !defined (botch)
+static void
+botch (s, file, line)
+ const char *s;
+ const char *file;
+ int line;
+{
+ fprintf (stderr, _("malloc: failed assertion: %s\n"), s);
+ (void)fflush (stderr);
+ abort ();
+}
+#endif
+
+/* print the file and line number that caused the assertion failure and
+ call botch() to do whatever the application wants with the information */
+static void
+xbotch (mem, e, s, file, line)
+ PTR_T mem;
+ int e;
+ const char *s;
+ const char *file;
+ int line;
+{
+ fprintf (stderr, _("\r\nmalloc: %s:%d: assertion botched\r\n"),
+ file ? file : _("unknown"), line);
+#ifdef MALLOC_REGISTER
+ if (mem != NULL && malloc_register)
+ mregister_describe_mem (mem, stderr);
+#endif
+ (void)fflush (stderr);
+ botch(s, file, line);
+}
-#if 0
/* Coalesce two adjacent free blocks off the free list for size NU - 1,
- as long as there are at least MIN_COMBINE_FREE free blocks and we
- can find two adjacent free blocks. nextf[NU -1] is assumed to not
- be busy; the caller (morecore()) checks for this. */
+ as long as we can find two adjacent free blocks. nextf[NU -1] is
+ assumed to not be busy; the caller (morecore()) checks for this.
+ BUSY[NU] must be set to 1. */
static void
bcoalesce (nu)
register int nu;
{
register union mhead *mp, *mp1, *mp2;
- register int nfree, nbuck;
+ register int nbuck;
unsigned long siz;
nbuck = nu - 1;
- if (nextf[nbuck] == 0)
+ if (nextf[nbuck] == 0 || busy[nbuck])
return;
- nfree = 1;
- mp1 = nextf[nbuck];
+ busy[nbuck] = 1;
+ siz = binsize (nbuck);
+
+ mp2 = mp1 = nextf[nbuck];
mp = CHAIN (mp1);
- mp2 = (union mhead *)0;
- while (CHAIN (mp))
+ while (mp && mp != (union mhead *)((char *)mp1 + siz))
{
mp2 = mp1;
mp1 = mp;
mp = CHAIN (mp);
- nfree++;
- /* We may not want to run all the way through the free list here;
- if we do not, we need to check a threshold value here and break
- if nfree exceeds it. */
}
- if (nfree < MIN_COMBINE_FREE)
- return;
+
+ if (mp == 0)
+ {
+ busy[nbuck] = 0;
+ return;
+ }
+
/* OK, now we have mp1 pointing to the block we want to add to nextf[NU].
CHAIN(mp2) must equal mp1. Check that mp1 and mp are adjacent. */
- if (CHAIN(mp2) != mp1)
- botch ("bcoalesce: CHAIN(mp2) != mp1");
- siz = 1 << (nbuck + 3);
- if (CHAIN (mp1) != (union mhead *)((char *)mp1 + siz))
- return; /* not adjacent */
+ if (mp2 != mp1 && CHAIN(mp2) != mp1)
+ {
+ busy[nbuck] = 0;
+ xbotch ((PTR_T)0, 0, "bcoalesce: CHAIN(mp2) != mp1", (char *)NULL, 0);
+ }
-#ifdef MALLOC_STATS
- _mstats.nbcoalesce++;
+#ifdef MALLOC_DEBUG
+ if (CHAIN (mp1) != (union mhead *)((char *)mp1 + siz))
+ {
+ busy[nbuck] = 0;
+ return; /* not adjacent */
+ }
#endif
/* Since they are adjacent, remove them from the free list */
- CHAIN (mp2) = CHAIN (mp);
+ if (mp1 == nextf[nbuck])
+ nextf[nbuck] = CHAIN (mp);
+ else
+ CHAIN (mp2) = CHAIN (mp);
+ busy[nbuck] = 0;
+
+#ifdef MALLOC_STATS
+ _mstats.tbcoalesce++;
+ _mstats.ncoalesce[nbuck]++;
+#endif
/* And add the combined two blocks to nextf[NU]. */
mp1->mh_alloc = ISFREE;
CHAIN (mp1) = nextf[nu];
nextf[nu] = mp1;
}
-#endif
/* Split a block at index > NU (but less than SPLIT_MAX) into a set of
blocks of the correct size, and attach them to nextf[NU]. nextf[NU]
is assumed to be empty. Must be called with signals blocked (e.g.,
- by morecore()). */
+ by morecore()). BUSY[NU] must be set to 1. */
static void
bsplit (nu)
register int nu;
{
register union mhead *mp;
- int nbuck, nblks;
+ int nbuck, nblks, split_max;
unsigned long siz;
+ split_max = (maxbuck > SPLIT_MAX) ? maxbuck : SPLIT_MAX;
+
if (nu >= SPLIT_MID)
{
- for (nbuck = SPLIT_MAX; nbuck > nu; nbuck--)
+ for (nbuck = split_max; nbuck > nu; nbuck--)
{
if (busy[nbuck] || nextf[nbuck] == 0)
continue;
}
else
{
- for (nbuck = nu + 1; nbuck <= SPLIT_MAX; nbuck++)
+ for (nbuck = nu + 1; nbuck <= split_max; nbuck++)
{
if (busy[nbuck] || nextf[nbuck] == 0)
continue;
}
}
- if (nbuck > SPLIT_MAX || nbuck <= nu)
+ if (nbuck > split_max || nbuck <= nu)
return;
/* XXX might want to split only if nextf[nbuck] has >= 2 blocks free
and nbuck is below some threshold. */
+ /* Remove the block from the chain of larger blocks. */
+ busy[nbuck] = 1;
+ mp = nextf[nbuck];
+ nextf[nbuck] = CHAIN (mp);
+ busy[nbuck] = 0;
+
#ifdef MALLOC_STATS
- _mstats.nbsplit++;
+ _mstats.tbsplit++;
+ _mstats.nsplit[nbuck]++;
#endif
/* Figure out how many blocks we'll get. */
- siz = (1 << (nu + 3));
- nblks = (1 << (nbuck + 3)) / siz;
-
- /* Remove the block from the chain of larger blocks. */
- mp = nextf[nbuck];
- nextf[nbuck] = CHAIN (mp);
+ siz = binsize (nu);
+ nblks = binsize (nbuck) / siz;
/* Split the block and put it on the requested chain. */
nextf[nu] = mp;
CHAIN (mp) = 0;
}
+/* Take the memory block MP and add it to a chain < NU. NU is the right bucket,
+ but is busy. This avoids memory orphaning. */
static void
-morecore (nu) /* ask system for more memory */
+xsplit (mp, nu)
+ union mhead *mp;
+ int nu;
+{
+ union mhead *nh;
+ int nbuck, nblks, split_max;
+ unsigned long siz;
+
+ nbuck = nu - 1;
+ while (nbuck >= SPLIT_MIN && busy[nbuck])
+ nbuck--;
+ if (nbuck < SPLIT_MIN)
+ return;
+
+#ifdef MALLOC_STATS
+ _mstats.tbsplit++;
+ _mstats.nsplit[nu]++;
+#endif
+
+ /* Figure out how many blocks we'll get. */
+ siz = binsize (nu); /* original block size */
+ nblks = siz / binsize (nbuck); /* should be 2 most of the time */
+
+ /* And add it to nextf[nbuck] */
+ siz = binsize (nbuck); /* XXX - resetting here */
+ nh = mp;
+ while (1)
+ {
+ mp->mh_alloc = ISFREE;
+ mp->mh_index = nbuck;
+ if (--nblks <= 0) break;
+ CHAIN (mp) = (union mhead *)((char *)mp + siz);
+ mp = (union mhead *)((char *)mp + siz);
+ }
+ busy[nbuck] = 1;
+ CHAIN (mp) = nextf[nbuck];
+ nextf[nbuck] = nh;
+ busy[nbuck] = 0;
+}
+
+static void
+block_signals (setp, osetp)
+ sigset_t *setp, *osetp;
+{
+#ifdef HAVE_POSIX_SIGNALS
+ sigfillset (setp);
+ sigemptyset (osetp);
+ sigprocmask (SIG_BLOCK, setp, osetp);
+#else
+# if defined (HAVE_BSD_SIGNALS)
+ *osetp = sigsetmask (-1);
+# endif
+#endif
+}
+
+static void
+unblock_signals (setp, osetp)
+ sigset_t *setp, *osetp;
+{
+#ifdef HAVE_POSIX_SIGNALS
+ sigprocmask (SIG_SETMASK, osetp, (sigset_t *)NULL);
+#else
+# if defined (HAVE_BSD_SIGNALS)
+ sigsetmask (*osetp);
+# endif
+#endif
+}
+
+/* Return some memory to the system by reducing the break. This is only
+ called with NU > pagebucket, so we're always assured of giving back
+ more than one page of memory. */
+static void
+lesscore (nu) /* give system back some memory */
+ register int nu; /* size index we're discarding */
+{
+ long siz;
+
+ siz = binsize (nu);
+ /* Should check for errors here, I guess. */
+ sbrk (-siz);
+ memtop -= siz;
+
+#ifdef MALLOC_STATS
+ _mstats.nsbrk++;
+ _mstats.tsbrk -= siz;
+ _mstats.nlesscore[nu]++;
+#endif
+}
+
+/* Ask system for more memory; add to NEXTF[NU]. BUSY[NU] must be set to 1. */
+static void
+morecore (nu)
register int nu; /* size index to get more of */
{
register union mhead *mp;
register int nblks;
register long siz;
long sbrk_amt; /* amount to get via sbrk() */
+ sigset_t set, oset;
+ int blocked_sigs;
/* Block all signals in case we are executed from a signal handler. */
-#if defined (HAVE_BSD_SIGNALS)
- int oldmask;
- oldmask = sigsetmask (-1);
-#else
-# if defined (HAVE_POSIX_SIGNALS)
- sigset_t set, oset;
- sigfillset (&set);
- sigemptyset (&oset);
- sigprocmask (SIG_BLOCK, &set, &oset);
-# endif /* HAVE_POSIX_SIGNALS */
-#endif /* HAVE_BSD_SIGNALS */
+ blocked_sigs = 0;
+#ifdef SHELL
+ if (interrupt_immediately || signal_is_trapped (SIGINT) || signal_is_trapped (SIGCHLD))
+#endif
+ {
+ block_signals (&set, &oset);
+ blocked_sigs = 1;
+ }
- siz = 1 << (nu + 3); /* size of desired block for nextf[nu] */
+ siz = binsize (nu); /* size of desired block for nextf[nu] */
if (siz < 0)
- return; /* oops */
+ goto morecore_done; /* oops */
#ifdef MALLOC_STATS
_mstats.nmorecore[nu]++;
/* Try to split a larger block here, if we're within the range of sizes
to split. */
- if (nu >= SPLIT_MIN && nu < SPLIT_MAX)
+ if (nu >= SPLIT_MIN)
{
bsplit (nu);
if (nextf[nu] != 0)
goto morecore_done;
}
-#if 0
/* Try to coalesce two adjacent blocks from the free list on nextf[nu - 1],
- if we can, and we're withing the range of the block coalescing limits. */
+ if we can, and we're within the range of the block coalescing limits. */
if (nu >= COMBINE_MIN && nu < COMBINE_MAX && busy[nu - 1] == 0 && nextf[nu - 1])
{
bcoalesce (nu);
if (nextf[nu] != 0)
- goto morecore_done;
+ goto morecore_done;
}
-#endif
/* Take at least a page, and figure out how many blocks of the requested
size we're getting. */
an amount. If it is, we can just request it. If not, we want
the smallest integral multiple of pagesize that is larger than
`siz' and will satisfy the request. */
- sbrk_amt = siz % pagesz;
+ sbrk_amt = siz & (pagesz - 1);
if (sbrk_amt == 0)
sbrk_amt = siz;
else
/* Totally out of memory. */
if ((long)mp == -1)
- return;
+ goto morecore_done;
+
+ memtop += sbrk_amt;
/* shouldn't happen, but just in case -- require 8-byte alignment */
- if ((long)mp & 7)
+ if ((long)mp & MALIGN_MASK)
{
- mp = (union mhead *) (((long)mp + 8) & ~7);
+ mp = (union mhead *) (((long)mp + MALIGN_MASK) & ~MALIGN_MASK);
nblks--;
}
CHAIN (mp) = 0;
morecore_done:
-#if defined (HAVE_BSD_SIGNALS)
- sigsetmask (oldmask);
-#else
-# if defined (HAVE_POSIX_SIGNALS)
- sigprocmask (SIG_SETMASK, &oset, (sigset_t *)NULL);
-# else
- ; /* nothing to do, but need a null statement before the brace */
-# endif
-#endif /* HAVE_BSD_SIGNALS */
-}
-
-#if defined (MEMSCRAMBLE) || !defined (NO_CALLOC)
-static char *
-zmemset (s, c, n)
- char *s;
- int c;
- register int n;
-{
- register char *sp;
-
- sp = s;
- while (--n >= 0)
- *sp++ = c;
- return (s);
+ if (blocked_sigs)
+ unblock_signals (&set, &oset);
}
-#endif /* MEMSCRAMBLE || !NO_CALLOC */
static void
malloc_debug_dummy ()
{
- ;
+ write (1, "malloc_debug_dummy\n", 19);
}
-char *
-malloc (n) /* get a block */
+#define PREPOP_BIN 2
+#define PREPOP_SIZE 32
+
+static int
+pagealign ()
+{
+ register int nunits;
+ register union mhead *mp;
+ long sbrk_needed;
+ char *curbrk;
+
+ pagesz = getpagesize ();
+ if (pagesz < 1024)
+ pagesz = 1024;
+
+ /* OK, how much do we need to allocate to make things page-aligned?
+ Some of this partial page will be wasted space, but we'll use as
+ much as we can. Once we figure out how much to advance the break
+ pointer, go ahead and do it. */
+ memtop = curbrk = sbrk (0);
+ sbrk_needed = pagesz - ((long)curbrk & (pagesz - 1)); /* sbrk(0) % pagesz */
+ if (sbrk_needed < 0)
+ sbrk_needed += pagesz;
+
+ /* Now allocate the wasted space. */
+ if (sbrk_needed)
+ {
+#ifdef MALLOC_STATS
+ _mstats.nsbrk++;
+ _mstats.tsbrk += sbrk_needed;
+#endif
+ curbrk = sbrk (sbrk_needed);
+ if ((long)curbrk == -1)
+ return -1;
+ memtop += sbrk_needed;
+
+ /* Take the memory which would otherwise be wasted and populate the most
+ popular bin (2 == 32 bytes) with it. Add whatever we need to curbrk
+ to make things 32-byte aligned, compute how many 32-byte chunks we're
+ going to get, and set up the bin. */
+ curbrk += sbrk_needed & (PREPOP_SIZE - 1);
+ sbrk_needed -= sbrk_needed & (PREPOP_SIZE - 1);
+ nunits = sbrk_needed / PREPOP_SIZE;
+
+ if (nunits > 0)
+ {
+ mp = (union mhead *)curbrk;
+
+ nextf[PREPOP_BIN] = mp;
+ while (1)
+ {
+ mp->mh_alloc = ISFREE;
+ mp->mh_index = PREPOP_BIN;
+ if (--nunits <= 0) break;
+ CHAIN(mp) = (union mhead *)((char *)mp + PREPOP_SIZE);
+ mp = (union mhead *)((char *)mp + PREPOP_SIZE);
+ }
+ CHAIN(mp) = 0;
+ }
+ }
+
+ /* compute which bin corresponds to the page size. */
+ for (nunits = 7; nunits < NBUCKETS; nunits++)
+ if (pagesz <= binsize(nunits))
+ break;
+ pagebucket = nunits;
+
+ return 0;
+}
+
+static PTR_T
+internal_malloc (n, file, line, flags) /* get a block */
size_t n;
+ const char *file;
+ int line, flags;
{
register union mhead *p;
- register long nbytes;
register int nunits;
+ register char *m, *z;
+ long nbytes;
+ mguard_t mg;
- /* Get the system page size and align break pointer so everything will
+ /* Get the system page size and align break pointer so future sbrks will
be page-aligned. The page size must be at least 1K -- anything
smaller is increased. */
if (pagesz == 0)
- {
- register long sbrk_needed;
-
- pagesz = getpagesize ();
- if (pagesz < 1024)
- pagesz = 1024;
- /* OK, how much do we need to allocate to make things page-aligned?
- This partial page is wasted space. Once we figure out how much
- to advance the break pointer, go ahead and do it. */
- sbrk_needed = pagesz - ((long)sbrk (0) & (pagesz - 1)); /* sbrk(0) % pagesz */
- if (sbrk_needed < 0)
- sbrk_needed += pagesz;
- /* Now allocate the wasted space. */
- if (sbrk_needed)
- {
-#ifdef MALLOC_STATS
- _mstats.nsbrk++;
- _mstats.tsbrk += sbrk_needed;
-#endif
- if ((long)sbrk (sbrk_needed) == -1)
- return (NULL);
- }
- nunits = 0;
- nbytes = 8;
- while (pagesz > nbytes)
- {
- nbytes <<= 1;
- nunits++;
- }
- pagebucket = nunits;
- }
+ if (pagealign () < 0)
+ return ((PTR_T)NULL);
/* Figure out how many bytes are required, rounding up to the nearest
- multiple of 4, then figure out which nextf[] area to use. Try to
+ multiple of 8, then figure out which nextf[] area to use. Try to
be smart about where to start searching -- if the number of bytes
needed is greater than the page size, we can start at pagebucket. */
- nbytes = (n + sizeof *p + MSLOP + 3) & ~3;
- nunits = 0;
- if (nbytes <= (pagesz >> 1))
- {
- register unsigned int shiftr;
+ nbytes = ALLOCATED_BYTES(n);
+ nunits = (nbytes <= (pagesz >> 1)) ? STARTBUCK : pagebucket;
+ for ( ; nunits < NBUCKETS; nunits++)
+ if (nbytes <= binsize(nunits))
+ break;
- shiftr = (nbytes - 1) >> 2; /* == (nbytes - 1) / 4 */
- while (shiftr >>= 1) /* == (nbytes - 1) / {8,16,32,...} */
- nunits++;
- }
- else
- {
- register u_int32_t amt;
-
- nunits = pagebucket;
- amt = pagesz;
- while (nbytes > amt)
- {
- amt <<= 1;
- nunits++;
- }
- }
+ /* Silently reject too-large requests. */
+ if (nunits >= NBUCKETS)
+ return ((PTR_T) NULL);
/* In case this is reentrant use of malloc from signal handler,
pick a block size that no other malloc level is currently
while (busy[nunits]) nunits++;
busy[nunits] = 1;
+ if (nunits > maxbuck)
+ maxbuck = nunits;
+
/* If there are no blocks of the appropriate size, go get some */
if (nextf[nunits] == 0)
morecore (nunits);
/* If not for this check, we would gobble a clobbered free chain ptr
and bomb out on the NEXT allocate of this size block */
if (p->mh_alloc != ISFREE || p->mh_index != nunits)
- botch ("malloc: block on free list clobbered");
+ xbotch ((PTR_T)(p+1), 0, _("malloc: block on free list clobbered"), file, line);
- /* Fill in the info, and if range checking, set up the magic numbers */
+ /* Fill in the info, and set up the magic numbers for range checking. */
p->mh_alloc = ISALLOC;
- p->mh_nbytes = n;
p->mh_magic2 = MAGIC2;
- {
- register char *m = (char *) (p + 1) + n;
+ p->mh_nbytes = n;
- *m++ = MAGIC1, *m++ = MAGIC1, *m++ = MAGIC1, *m = MAGIC1;
- }
+ /* End guard */
+ mg.i = n;
+ z = mg.s;
+ m = (char *) (p + 1) + n;
+ *m++ = *z++, *m++ = *z++, *m++ = *z++, *m++ = *z++;
#ifdef MEMSCRAMBLE
- zmemset ((char *)(p + 1), 0xdf, n); /* scramble previous contents */
+ if (n)
+ MALLOC_MEMSET ((char *)(p + 1), 0xdf, n); /* scramble previous contents */
#endif
#ifdef MALLOC_STATS
_mstats.nmalloc[nunits]++;
_mstats.tmalloc[nunits]++;
_mstats.nmal++;
+ _mstats.bytesreq += n;
#endif /* MALLOC_STATS */
- return (char *) (p + 1);
+
+#ifdef MALLOC_TRACE
+ if (malloc_trace && (flags & MALLOC_NOTRACE) == 0)
+ mtrace_alloc ("malloc", p + 1, n, file, line);
+ else if (_malloc_trace_buckets[nunits])
+ mtrace_alloc ("malloc", p + 1, n, file, line);
+#endif
+
+#ifdef MALLOC_REGISTER
+ if (malloc_register && (flags & MALLOC_NOREG) == 0)
+ mregister_alloc ("malloc", p + 1, n, file, line);
+#endif
+
+#ifdef MALLOC_WATCH
+ if (_malloc_nwatch > 0)
+ _malloc_ckwatch (p + 1, file, line, W_ALLOC, n);
+#endif
+
+ return (PTR_T) (p + 1);
}
-void
-free (mem)
- char *mem;
+static void
+internal_free (mem, file, line, flags)
+ PTR_T mem;
+ const char *file;
+ int line, flags;
{
register union mhead *p;
- register char *ap;
+ register char *ap, *z;
register int nunits;
+ register unsigned int nbytes;
+ int ubytes; /* caller-requested size */
+ mguard_t mg;
- if ((ap = mem) == 0)
+ if ((ap = (char *)mem) == 0)
return;
p = (union mhead *) ap - 1;
p = (union mhead *) ap - 1;
}
+#if defined (MALLOC_TRACE) || defined (MALLOC_REGISTER)
+ if (malloc_trace || malloc_register)
+ ubytes = p->mh_nbytes;
+#endif
+
if (p->mh_alloc != ISALLOC)
{
if (p->mh_alloc == ISFREE)
- botch ("free: called with already freed block argument");
+ xbotch (mem, ERR_DUPFREE,
+ _("free: called with already freed block argument"), file, line);
else
- botch ("free: called with unallocated block argument");
+ xbotch (mem, ERR_UNALLOC,
+ _("free: called with unallocated block argument"), file, line);
}
ASSERT (p->mh_magic2 == MAGIC2);
+
+ nunits = p->mh_index;
+ nbytes = ALLOCATED_BYTES(p->mh_nbytes);
+ /* Since the sizeof(u_bits32_t) bytes before the memory handed to the user
+ are now used for the number of bytes allocated, a simple check of
+ mh_magic2 is no longer sufficient to catch things like p[-1] = 'x'.
+ We sanity-check the value of mh_nbytes against the size of the blocks
+ in the appropriate bucket before we use it. This can still cause problems
+ and obscure errors if mh_nbytes is wrong but still within range; the
+ checks against the size recorded at the end of the chunk will probably
+ fail then. Using MALLOC_REGISTER will help here, since it saves the
+ original number of bytes requested. */
+
+ if (IN_BUCKET(nbytes, nunits) == 0)
+ xbotch (mem, ERR_UNDERFLOW,
+ _("free: underflow detected; mh_nbytes out of range"), file, line);
+
ap += p->mh_nbytes;
- ASSERT (*ap++ == MAGIC1); ASSERT (*ap++ == MAGIC1);
- ASSERT (*ap++ == MAGIC1); ASSERT (*ap == MAGIC1);
+ z = mg.s;
+ *z++ = *ap++, *z++ = *ap++, *z++ = *ap++, *z++ = *ap++;
+ if (mg.i != p->mh_nbytes)
+ xbotch (mem, ERR_ASSERT_FAILED, _("free: start and end chunk sizes differ"), file, line);
-#ifdef MEMSCRAMBLE
- zmemset (mem, 0xcf, p->mh_nbytes);
+#if 1
+ if (nunits >= LESSCORE_MIN && ((char *)p + binsize(nunits) == memtop))
+#else
+ if (((char *)p + binsize(nunits) == memtop) && nunits >= LESSCORE_MIN)
#endif
+ {
+ /* If above LESSCORE_FRC, give back unconditionally. This should be set
+ high enough to be infrequently encountered. If between LESSCORE_MIN
+ and LESSCORE_FRC, call lesscore if the bucket is marked as busy or if
+ there's already a block on the free list. */
+ if ((nunits >= LESSCORE_FRC) || busy[nunits] || nextf[nunits] != 0)
+ {
+ lesscore (nunits);
+ /* keeps the tracing and registering code in one place */
+ goto free_return;
+ }
+ }
- nunits = p->mh_index;
+#ifdef MEMSCRAMBLE
+ if (p->mh_nbytes)
+ MALLOC_MEMSET (mem, 0xcf, p->mh_nbytes);
+#endif
ASSERT (nunits < NBUCKETS);
- p->mh_alloc = ISFREE;
+ if (busy[nunits] == 1)
+ {
+ xsplit (p, nunits); /* split block and add to different chain */
+ goto free_return;
+ }
+
+ p->mh_alloc = ISFREE;
/* Protect against signal handlers calling malloc. */
busy[nunits] = 1;
/* Put this block on the free list. */
nextf[nunits] = p;
busy[nunits] = 0;
+free_return:
+ ; /* Empty statement in case this is the end of the function */
+
#ifdef MALLOC_STATS
_mstats.nmalloc[nunits]--;
_mstats.nfre++;
#endif /* MALLOC_STATS */
+
+#ifdef MALLOC_TRACE
+ if (malloc_trace && (flags & MALLOC_NOTRACE) == 0)
+ mtrace_free (mem, ubytes, file, line);
+ else if (_malloc_trace_buckets[nunits])
+ mtrace_free (mem, ubytes, file, line);
+#endif
+
+#ifdef MALLOC_REGISTER
+ if (malloc_register && (flags & MALLOC_NOREG) == 0)
+ mregister_free (mem, ubytes, file, line);
+#endif
+
+#ifdef MALLOC_WATCH
+ if (_malloc_nwatch > 0)
+ _malloc_ckwatch (mem, file, line, W_FREE, ubytes);
+#endif
}
-char *
-realloc (mem, n)
- char *mem;
+static PTR_T
+internal_realloc (mem, n, file, line, flags)
+ PTR_T mem;
register size_t n;
+ const char *file;
+ int line, flags;
{
register union mhead *p;
- register u_int32_t tocopy;
+ register u_bits32_t tocopy;
register unsigned int nbytes;
register int nunits;
- register char *m;
+ register char *m, *z;
+ mguard_t mg;
#ifdef MALLOC_STATS
_mstats.nrealloc++;
if (n == 0)
{
- free (mem);
+ internal_free (mem, file, line, MALLOC_INTERNAL);
return (NULL);
}
if ((p = (union mhead *) mem) == 0)
- return malloc (n);
+ return internal_malloc (n, file, line, MALLOC_INTERNAL);
+
p--;
nunits = p->mh_index;
- ASSERT (p->mh_alloc == ISALLOC);
- ASSERT (p->mh_magic2 == MAGIC2);
+ ASSERT (nunits < NBUCKETS);
+
+ if (p->mh_alloc != ISALLOC)
+ xbotch (mem, ERR_UNALLOC,
+ _("realloc: called with unallocated block argument"), file, line);
- m = mem + (tocopy = p->mh_nbytes);
- ASSERT (*m++ == MAGIC1); ASSERT (*m++ == MAGIC1);
- ASSERT (*m++ == MAGIC1); ASSERT (*m == MAGIC1);
+ ASSERT (p->mh_magic2 == MAGIC2);
+ nbytes = ALLOCATED_BYTES(p->mh_nbytes);
+ /* Since the sizeof(u_bits32_t) bytes before the memory handed to the user
+ are now used for the number of bytes allocated, a simple check of
+ mh_magic2 is no longer sufficient to catch things like p[-1] = 'x'.
+ We sanity-check the value of mh_nbytes against the size of the blocks
+ in the appropriate bucket before we use it. This can still cause problems
+ and obscure errors if mh_nbytes is wrong but still within range; the
+ checks against the size recorded at the end of the chunk will probably
+ fail then. Using MALLOC_REGISTER will help here, since it saves the
+ original number of bytes requested. */
+ if (IN_BUCKET(nbytes, nunits) == 0)
+ xbotch (mem, ERR_UNDERFLOW,
+ _("realloc: underflow detected; mh_nbytes out of range"), file, line);
+
+ m = (char *)mem + (tocopy = p->mh_nbytes);
+ z = mg.s;
+ *z++ = *m++, *z++ = *m++, *z++ = *m++, *z++ = *m++;
+ if (mg.i != p->mh_nbytes)
+ xbotch (mem, ERR_ASSERT_FAILED, _("realloc: start and end chunk sizes differ"), file, line);
+
+#ifdef MALLOC_WATCH
+ if (_malloc_nwatch > 0)
+ _malloc_ckwatch (p + 1, file, line, W_REALLOC, n);
+#endif
+#ifdef MALLOC_STATS
+ _mstats.bytesreq += (n < tocopy) ? 0 : n - tocopy;
+#endif
/* See if desired size rounds to same power of 2 as actual size. */
- nbytes = (n + sizeof *p + MSLOP + 7) & ~7;
+ nbytes = ALLOCATED_BYTES(n);
/* If ok, use the same block, just marking its size as changed. */
- if (nbytes > (4 << nunits) && nbytes <= (8 << nunits))
+ if (RIGHT_BUCKET(nbytes, nunits))
{
- m = mem + tocopy;
+#if 0
+ m = (char *)mem + p->mh_nbytes;
+#else
+ /* Compensate for increment above. */
+ m -= 4;
+#endif
*m++ = 0; *m++ = 0; *m++ = 0; *m++ = 0;
- p->mh_nbytes = n;
- m = mem + n;
- *m++ = MAGIC1; *m++ = MAGIC1; *m++ = MAGIC1; *m++ = MAGIC1;
+ m = (char *)mem + (p->mh_nbytes = n);
+
+ mg.i = n;
+ z = mg.s;
+ *m++ = *z++, *m++ = *z++, *m++ = *z++, *m++ = *z++;
+
return mem;
}
+ if (n < tocopy)
+ tocopy = n;
+
#ifdef MALLOC_STATS
_mstats.nrcopy++;
#endif
- if (n < tocopy)
- tocopy = n;
-
- if ((m = malloc (n)) == 0)
+ if ((m = internal_malloc (n, file, line, MALLOC_INTERNAL|MALLOC_NOTRACE|MALLOC_NOREG)) == 0)
return 0;
FASTCOPY (mem, m, tocopy);
- free (mem);
+ internal_free (mem, file, line, MALLOC_INTERNAL);
+
+#ifdef MALLOC_TRACE
+ if (malloc_trace && (flags & MALLOC_NOTRACE) == 0)
+ mtrace_alloc ("realloc", m, n, file, line);
+ else if (_malloc_trace_buckets[nunits])
+ mtrace_alloc ("realloc", m, n, file, line);
+#endif
+
+#ifdef MALLOC_REGISTER
+ if (malloc_register && (flags & MALLOC_NOREG) == 0)
+ mregister_alloc ("realloc", m, n, file, line);
+#endif
+
+#ifdef MALLOC_WATCH
+ if (_malloc_nwatch > 0)
+ _malloc_ckwatch (m, file, line, W_RESIZED, n);
+#endif
+
return m;
}
-char *
-memalign (alignment, size)
- unsigned int alignment;
+static PTR_T
+internal_memalign (alignment, size, file, line, flags)
+ size_t alignment;
size_t size;
+ const char *file;
+ int line, flags;
{
register char *ptr;
register char *aligned;
register union mhead *p;
- ptr = malloc (size + alignment);
+ ptr = internal_malloc (size + alignment, file, line, MALLOC_INTERNAL);
if (ptr == 0)
return 0;
/* If entire block has the desired alignment, just accept it. */
- if (((int) ptr & (alignment - 1)) == 0)
+ if (((long) ptr & (alignment - 1)) == 0)
return ptr;
/* Otherwise, get address of byte in the block that has that alignment. */
- aligned = (char *) (((int) ptr + alignment - 1) & -alignment);
+#if 0
+ aligned = (char *) (((long) ptr + alignment - 1) & -alignment);
+#else
+ aligned = (char *) (((long) ptr + alignment - 1) & (~alignment + 1));
+#endif
/* Store a suitable indication of how to free the block,
so that free can find the true beginning of it. */
p = (union mhead *) aligned - 1;
p->mh_nbytes = aligned - ptr;
p->mh_alloc = ISMEMALIGN;
+
return aligned;
}
-#if !defined (HPUX)
+#if !defined (NO_VALLOC)
/* This runs into trouble with getpagesize on HPUX, and Multimax machines.
Patching out seems cleaner than the ugly fix needed. */
-#if defined (__STDC__)
-void *
-#else
-char *
-#endif
-valloc (size)
+static PTR_T
+internal_valloc (size, file, line, flags)
size_t size;
+ const char *file;
+ int line, flags;
{
- return memalign (getpagesize (), size);
+ return internal_memalign (getpagesize (), size, file, line, flags|MALLOC_INTERNAL);
}
-#endif /* !HPUX */
+#endif /* !NO_VALLOC */
#ifndef NO_CALLOC
-char *
-calloc (n, s)
+static PTR_T
+internal_calloc (n, s, file, line, flags)
size_t n, s;
+ const char *file;
+ int line, flags;
{
size_t total;
- char *result;
+ PTR_T result;
total = n * s;
- result = malloc (total);
+ result = internal_malloc (total, file, line, flags|MALLOC_INTERNAL);
if (result)
- zmemset (result, 0, total);
+ memset (result, 0, total);
return result;
}
-void
-cfree (p)
- char *p;
+static void
+internal_cfree (p, file, line, flags)
+ PTR_T p;
+ const char *file;
+ int line, flags;
{
- free (p);
+ internal_free (p, file, line, flags|MALLOC_INTERNAL);
}
#endif /* !NO_CALLOC */
#ifdef MALLOC_STATS
-
-struct bucket_stats
-malloc_bucket_stats (size)
+int
+malloc_free_blocks (size)
int size;
{
- struct bucket_stats v;
+ int nfree;
register union mhead *p;
- v.nfree = 0;
+ nfree = 0;
+ for (p = nextf[size]; p; p = CHAIN (p))
+ nfree++;
- if (size < 0 || size >= NBUCKETS)
- {
- v.blocksize = 0;
- v.nused = v.nmal = 0;
- return v;
- }
+ return nfree;
+}
+#endif
- v.blocksize = 1 << (size + 3);
- v.nused = _mstats.nmalloc[size];
- v.nmal = _mstats.tmalloc[size];
- v.nmorecore = _mstats.nmorecore[size];
+#if defined (MALLOC_WRAPFUNCS)
+PTR_T
+sh_malloc (bytes, file, line)
+ size_t bytes;
+ const char *file;
+ int line;
+{
+ return internal_malloc (bytes, file, line, MALLOC_WRAPPER);
+}
- for (p = nextf[size]; p; p = CHAIN (p))
- v.nfree++;
+PTR_T
+sh_realloc (ptr, size, file, line)
+ PTR_T ptr;
+ size_t size;
+ const char *file;
+ int line;
+{
+ return internal_realloc (ptr, size, file, line, MALLOC_WRAPPER);
+}
- return v;
+void
+sh_free (mem, file, line)
+ PTR_T mem;
+ const char *file;
+ int line;
+{
+ internal_free (mem, file, line, MALLOC_WRAPPER);
}
-/* Return a copy of _MSTATS, with two additional fields filled in:
- BYTESFREE is the total number of bytes on free lists. BYTESUSED
- is the total number of bytes in use. These two fields are fairly
- expensive to compute, so we do it only when asked to. */
-struct _malstats
-malloc_stats ()
+PTR_T
+sh_memalign (alignment, size, file, line)
+ size_t alignment;
+ size_t size;
+ const char *file;
+ int line;
{
- struct _malstats result;
- struct bucket_stats v;
- register int i;
+ return internal_memalign (alignment, size, file, line, MALLOC_WRAPPER);
+}
- result = _mstats;
- result.bytesused = result.bytesfree = 0;
- for (i = 0; i < NBUCKETS; i++)
- {
- v = malloc_bucket_stats (i);
- result.bytesfree += v.nfree * v.blocksize;
- result.bytesused += v.nused * v.blocksize;
- }
- return (result);
+#ifndef NO_CALLOC
+PTR_T
+sh_calloc (n, s, file, line)
+ size_t n, s;
+ const char *file;
+ int line;
+{
+ return internal_calloc (n, s, file, line, MALLOC_WRAPPER);
}
void
-print_malloc_stats (s)
- char *s;
+sh_cfree (mem, file, line)
+ PTR_T mem;
+ const char *file;
+ int line;
{
- register int i;
- int totused, totfree;
- struct bucket_stats v;
+ internal_cfree (mem, file, line, MALLOC_WRAPPER);
+}
+#endif
- fprintf (stderr, "Memory allocation statistics: %s\n\tsize\tfree\tin use\ttotal\tmorecore\n", s ? s : "");
- for (i = totused = totfree = 0; i < NBUCKETS; i++)
- {
- v = malloc_bucket_stats (i);
- fprintf (stderr, "%12lu\t%4d\t%6d\t%5d\t%8d\n", v.blocksize, v.nfree, v.nused, v.nmal, v.nmorecore);
- totfree += v.nfree * v.blocksize;
- totused += v.nused * v.blocksize;
- }
- fprintf (stderr, "\nTotal bytes in use: %d, total bytes free: %d\n",
- totused, totfree);
- fprintf (stderr, "Total mallocs: %d, total frees: %d, total reallocs: %d (%d copies)\n",
- _mstats.nmal, _mstats.nfre, _mstats.nrealloc, _mstats.nrcopy);
- fprintf (stderr, "Total sbrks: %d, total bytes via sbrk: %d\n",
- _mstats.nsbrk, _mstats.tsbrk);
- fprintf (stderr, "Total blocks split: %d, total block coalesces: %d\n",
- _mstats.nbsplit, _mstats.nbcoalesce);
+#ifndef NO_VALLOC
+PTR_T
+sh_valloc (size, file, line)
+ size_t size;
+ const char *file;
+ int line;
+{
+ return internal_valloc (size, file, line, MALLOC_WRAPPER);
}
-#endif /* MALLOC_STATS */
+#endif /* !NO_VALLOC */
+
+#endif /* MALLOC_WRAPFUNCS */
+
+/* Externally-available functions that call their internal counterparts. */
+
+PTR_T
+malloc (size)
+ size_t size;
+{
+ return internal_malloc (size, (char *)NULL, 0, 0);
+}
+
+PTR_T
+realloc (mem, nbytes)
+ PTR_T mem;
+ size_t nbytes;
+{
+ return internal_realloc (mem, nbytes, (char *)NULL, 0, 0);
+}
+
+void
+free (mem)
+ PTR_T mem;
+{
+ internal_free (mem, (char *)NULL, 0, 0);
+}
+
+PTR_T
+memalign (alignment, size)
+ size_t alignment;
+ size_t size;
+{
+ return internal_memalign (alignment, size, (char *)NULL, 0, 0);
+}
+
+#ifndef NO_VALLOC
+PTR_T
+valloc (size)
+ size_t size;
+{
+ return internal_valloc (size, (char *)NULL, 0, 0);
+}
+#endif
+
+#ifndef NO_CALLOC
+PTR_T
+calloc (n, s)
+ size_t n, s;
+{
+ return internal_calloc (n, s, (char *)NULL, 0, 0);
+}
+
+void
+cfree (mem)
+ PTR_T mem;
+{
+ internal_cfree (mem, (char *)NULL, 0, 0);
+}
+#endif
projects / platform / upstream / bash.git / blobdiff