diff options
| -rw-r--r-- | mmalloc/.Sanitize | 50 | ||||
| -rw-r--r-- | mmalloc/ChangeLog | 5 | ||||
| -rw-r--r-- | mmalloc/Makefile.in | 156 | ||||
| -rwxr-xr-x | mmalloc/README | 160 | ||||
| -rw-r--r-- | mmalloc/configure.in | 33 | ||||
| -rw-r--r-- | mmalloc/detach.c | 71 | ||||
| -rwxr-xr-x | mmalloc/fsf.shar.orig | 1841 | ||||
| -rw-r--r-- | mmalloc/keys.c | 64 | ||||
| -rw-r--r-- | mmalloc/mcalloc.c | 53 | ||||
| -rw-r--r-- | mmalloc/mfree.c | 249 | ||||
| -rw-r--r-- | mmalloc/mmemalign.c | 64 | ||||
| -rw-r--r-- | mmalloc/mmstats.c | 46 | ||||
| -rw-r--r-- | mmalloc/mmtrace.awk | 36 | ||||
| -rw-r--r-- | mmalloc/mrealloc.c | 151 | ||||
| -rw-r--r-- | mmalloc/mvalloc.c | 39 |
15 files changed, 3018 insertions, 0 deletions
diff --git a/mmalloc/.Sanitize b/mmalloc/.Sanitize new file mode 100644 index 0000000..35f60d6 --- /dev/null +++ b/mmalloc/.Sanitize @@ -0,0 +1,50 @@ +# Sanitize.in for devo. +# $Id$ +# + +# Each directory to survive it's way into a release will need a file +# like this one called "./.Sanitize". All keyword lines must exist, +# and must exist in the order specified by this file. Each directory +# in the tree will be processed, top down, in the following order. + +# Hash started lines like this one are comments and will be deleted +# before anything else is done. Blank lines will also be squashed +# out. + +# The lines between the "Do-first:" line and the "Things-to-keep:" +# line are executed as a /bin/sh shell script before anything else is +# done in this + +Do-first: + +# All files listed between the "Things-to-keep:" line and the +# "Files-to-sed:" line will be kept. All other files will be removed. +# Directories listed in this section will have their own Sanitize +# called. Directories not listed will be removed in their entirety +# with rm -rf. + +Things-to-keep: + +ChangeLog +Makefile.in +README +attach.c +config +configure.in +detach.c +keys.c +mcalloc.c +mfree.c +mmalloc.c +mmalloc.h +mmap-sup.c +mmcheck.c +mmemalign.c +mmstats.c +mmtrace.awk +mmtrace.c +mrealloc.c +mvalloc.c +sbrk-sup.c + +Do-last: diff --git a/mmalloc/ChangeLog b/mmalloc/ChangeLog new file mode 100644 index 0000000..cbe5d6b --- /dev/null +++ b/mmalloc/ChangeLog @@ -0,0 +1,5 @@ +Sat Mar 14 17:34:59 1992 Fred Fish (fnf@cygnus.com) + + * Initial release, incorporated into gdb. + + diff --git a/mmalloc/Makefile.in b/mmalloc/Makefile.in new file mode 100644 index 0000000..57dfcef --- /dev/null +++ b/mmalloc/Makefile.in @@ -0,0 +1,156 @@ +# +# Makefile +# Copyright (C) 1992 Cygnus Support +# +# This file 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 2 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. +# +# 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. */ +# + +# +# Makefile for mmalloc directory +# + +# Directory containing source files. Don't clean up the spacing, +# this exact string is matched for by the "configure" script. +srcdir = . + +prefix = /usr/local + +bindir = $(prefix)/bin +datadir = $(prefix)/lib +libdir = $(prefix)/lib +mandir = $(datadir)/man +man1dir = $(mandir)/man1 +man2dir = $(mandir)/man2 +man3dir = $(mandir)/man3 +man4dir = $(mandir)/man4 +man5dir = $(mandir)/man5 +man6dir = $(mandir)/man6 +man7dir = $(mandir)/man7 +man8dir = $(mandir)/man8 +man9dir = $(mandir)/man9 +infodir = $(datadir)/info +includedir = $(prefix)/include +docdir = $(datadir)/doc + +SHELL = /bin/sh + +INSTALL = install -c +INSTALL_PROGRAM = $(INSTALL) +INSTALL_DATA = $(INSTALL) + +AR = ar +AR_FLAGS = qv +BISON = bison +MAKEINFO = makeinfo +RANLIB = ranlib +RM = rm + +TARGETLIB = libmmalloc.a + +MINUS_G = -g +CFLAGS = $(MINUS_G) -I. -I$(srcdir)/../include $(HDEFINES) + +CFILES = mcalloc.c mfree.c mmalloc.c mmcheck.c mmemalign.c mmstats.c \ + mmtrace.c mrealloc.c mvalloc.c mmap-sup.c attach.c detach.c \ + keys.c sbrk-sup.c + +HFILES = mmalloc.h + +OFILES = mcalloc.o mfree.o mmalloc.o mmcheck.o mmemalign.o mmstats.o \ + mmtrace.o mrealloc.o mvalloc.o mmap-sup.o attach.o detach.o \ + keys.o sbrk-sup.o + +#### Host, target, and site specific Makefile fragments come in here. +### + +# Do we want/need any config overrides? +# + +STAGESTUFF = $(TARGETLIB) *.o + +all: $(TARGETLIB) + +install: all + $(INSTALL_DATA) $(TARGETLIB) $(libdir)/$(TARGETLIB).n + $(RANLIB) $(libdir)/$(TARGETLIB).n + mv -f $(libdir)/$(TARGETLIB).n $(libdir)/$(TARGETLIB) + +$(TARGETLIB): $(OFILES) + $(RM) -rf $@ + $(AR) $(AR_FLAGS) $@ $(OFILES) + $(RANLIB) $@ + +$(OFILES) : $(HFILES) + +.always.: +# Do nothing. + +.PHONEY: all etags tags ls clean stage1 stage2 .always. + +stage1: force + -mkdir stage1 + -mv -f $(STAGESTUFF) stage1 + +stage2: force + -mkdir stage2 + -mv -f $(STAGESTUFF) stage2 + +stage3: force + -mkdir stage3 + -mv -f $(STAGESTUFF) stage3 + +stage4: force + -mkdir stage4 + -mv -f $(STAGESTUFF) stage4 + +against=stage2 + +comparison: force + for i in *.o ; do cmp $$i $(against)/$$i || exit 1 ; done + +de-stage1: force + -(cd stage1 ; mv -f * ..) + -rmdir stage1 + +de-stage2: force + -(cd stage2 ; mv -f * ..) + -rmdir stage2 + +de-stage3: force + -(cd stage3 ; mv -f * ..) + -rmdir stage3 + +de-stage4: force + -(cd stage4 ; mv -f * ..) + -rmdir stage4 + +etags tags: TAGS + +TAGS: $(CFILES) + etags $(HFILES) $(CFILES) + +ls: + @echo Makefile $(HFILES) $(CFILES) + +# Need to deal with profiled libraries, too. + +clean: + rm -f *.a *.o core errs *~ \#* TAGS *.E a.out errors + +force: + +Makefile: $(srcdir)/Makefile.in $(host_makefile_frag) \ + $(target_makefile_frag) + $(SHELL) ./config.status diff --git a/mmalloc/README b/mmalloc/README new file mode 100755 index 0000000..fc2e4ec --- /dev/null +++ b/mmalloc/README @@ -0,0 +1,160 @@ +The GNU mmalloc (mapped-malloc) package. fnf@cygnus.com + + +Description +----------- + +This is a heavily modified version of GNU malloc which has been extended to +use mmap() as the basic mechanism for for obtaining memory from the system, +rather than sbrk(). This gives it several advantages over the +more traditional malloc: + + * Providing suitable precautions are taken to avoid memory region + collisions, sbrk() is now available for use by applications that + use this package and still need to use some memory management + package that includes functions like malloc/realloc/free. + + * Several different memory pools can be used, each of them growing + or shinking under control of mmap(), with the mmalloc functions + using a specific pool on a call by call basis. + + * By using mmap, it is easy to create data pools which are intended to + be persistent and exist as a filesystem object after the creating + process has gone away. + + * Because multiple memory pools can be managed, data used for a + specific purpose can be allocated into it's own memory pool, making + it easier to allow applications to "dump" and "restore" initialized + malloc-managed memory regions. I.E., the "unexec" hack popularized + by GNU emacs could potentially go away. + + +Implementation +-------------- + +The mmalloc functions contain no internal static state. All of mmalloc +internal data is allocated in the mapped in region, along with the user +data that it manages. This allows it to manage multiple such regions +and to "pick up where it left off" when such regions are later dynamically +mapped back in. + +In some sense, malloc has been "purified" to contain no internal state +information and generalized to use multiple memory regions rather than a +single region managed by sbrk(). However the new routines now need an +extra parameter which informs malloc which memory region it is dealing +with (along with other information). + +For ease of initial implementation, and to avoid exporting or importing +any more global variables or routines than necessary, this package is +implemented with all functions contained within a single source file. +At some future point, once everything has stabilized, it may be desirable +split it up into separate files. + +The functions initially provided by mmalloc are: + + void *mmalloc_attach (int fd, void *baseaddr); + void *mmalloc_detach (void *md); + int mmalloc_errno (void *md); + int mmalloc_setkey (void *md, int keynum, void *key); + void *mmalloc_getkey (void *md, int keynum); + + void *mmalloc (void *md, size_t size); + void *mrealloc (void *md, void *ptr, size_t size); + void *mvalloc (void *md, size_t size); + void mfree (void *md, void *ptr); + +Backwards Compatibility +----------------------- + +To allow a single malloc package to be used in a given application, provision +is made for the traditional malloc/realloc/free functions to be implemented +as special cases of the mmalloc functions. In particular, if any of the +functions that expect malloc descriptors are called with a NULL pointer rather +than a valid malloc descriptor, then they default to using an mmap'd region +starting at the current sbrk() value and mapped to /dev/zero. Applications +can simply include the following defines to use the mmalloc versions: + + #define malloc(size) mmalloc ((void *)0, (size)) + #define realloc(ptr,size) mrealloc ((void *)0, (ptr), (size)); + #define free(ptr) mfree ((void *)0, (ptr)) + +or replace the existing malloc/realloc/free calls with the above patterns +if the #define's cause problems. + +Note that this does not prevent calls to malloc/realloc/free within +libraries from continuing to use the library version of malloc, so if this +is a problem, the compatibility issue needs to be dealt with in another way. + + +Function Descriptions +--------------------- + + void *mmalloc_attach (int fd, void *baseaddr); + + Initialize access to a mmalloc managed region. + + If FD is a valid file descriptor for an open file then data for the + mmalloc managed region is mapped to that file, otherwise "/dev/zero" + is used and the data will not exist in any filesystem object. + + If the open file corresponding to FD is from a previous use of + mmalloc and passes some basic sanity checks to ensure that it is + compatible with the current mmalloc package, then it's data is + mapped in and is immediately accessible at the same addresses in + the current process as the process that created the file. + + If BASEADDR is not NULL, the mapping is established starting at the + specified address in the process address space. If BASEADDR is NULL, + the mmalloc package chooses a suitable address at which to start the + mapped region, which will be the value of the previous mapping if + opening an existing file which was previously built by mmalloc, or + for new files will be a value chosen by mmap. + + Specifying BASEADDR provides more control over where the regions + start and how big they can be before bumping into existing mapped + regions or future mapped regions. + + On success, returns a "malloc descriptor" which is used in subsequent + calls to other mmalloc package functions. It is explicitly "void *" + ("char *" for systems that don't fully support void) so that users + of the package don't have to worry about the actual implementation + details. + + On failure returns NULL. + + void *mmalloc_detach (void *md); + + Terminate access to a mmalloc managed region by closing the base + file and unmapping all memory pages associated with the region. + + Returns NULL on success. + + Returns the malloc descriptor on failure, which can subsequently + be used for further action (such as obtaining more information about + the nature of the failure). + + void *mmalloc (void *md, size_t size); + + Given an mmalloc descriptor MD, allocate additional memory of + SIZE bytes in the associated mapped region. + + void *mrealloc (void *md, void *ptr, size_t size); + + Given an mmalloc descriptor MD and a pointer to memory previously + allocated by mmalloc in PTR, reallocate the memory to be SIZE bytes + long, possibly moving the existing contents of memory if necessary. + + void *mvalloc (void *md, size_t size); + + Like mmalloc but the resulting memory is aligned on a page boundary. + + void mfree (void *md, void *ptr); + + Given an mmalloc descriptor MD and a pointer to memory previously + allocated by mmalloc in PTR, free the previously allocated memory. + + int mmalloc_errno (void *md); + + Given a mmalloc descriptor, if the last mmalloc operation + failed for some reason due to a system call failure, then + returns the associated errno. Returns 0 otherwise. diff --git a/mmalloc/configure.in b/mmalloc/configure.in new file mode 100644 index 0000000..af44b74 --- /dev/null +++ b/mmalloc/configure.in @@ -0,0 +1,33 @@ +# This file is a shell script that supplies the information necessary +# to tailor a template configure script into the configure script +# appropriate for this directory. For more information, check any +# existing configure script. + +srctrigger=mmalloc.c +srcname="mmalloc library" +configdirs="" + +# per-host: + +case "${host_os}" in + +sysv4) + host_makefile_frag=config/mh-sysv4 + ;; + +sunos4*) + host_makefile_frag=config/mh-sunos4 + ;; + +*) + ;; + +esac + +# per-target: + +# +# Local Variables: +# fill-column: 131 +# End: +# diff --git a/mmalloc/detach.c b/mmalloc/detach.c new file mode 100644 index 0000000..69661bc --- /dev/null +++ b/mmalloc/detach.c @@ -0,0 +1,71 @@ +/* Finish access to a mmap'd malloc managed region. + Copyright 1992 Free Software Foundation, Inc. + + Contributed by Fred Fish at Cygnus Support. fnf@cygnus.com + +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 2 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. + +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. */ + + +#include <fcntl.h> +#include "mmalloc.h" + +/* Terminate access to a mmalloc managed region by unmapping all memory pages + associated with the region, and closing the file descriptor if it is one + that we opened. + + Returns NULL on success. + + Returns the malloc descriptor on failure, which can subsequently be used + for further action, such as obtaining more information about the nature of + the failure by examining the preserved errno value. + + Note that the malloc descriptor that we are using is currently located in + region we are about to unmap, so we first make a local copy of it on the + stack and use the copy. */ + +PTR +mmalloc_detach (md) + void *md; +{ + struct mdesc mtemp; + + if (md != NULL) + { + + mtemp = *(struct mdesc *) md; + + /* Now unmap all the pages associated with this region by asking for a + negative increment equal to the current size of the region. */ + + if ((mtemp.morecore (&mtemp, mtemp.base - mtemp.top)) == NULL) + { + /* Update the original malloc descriptor with any changes */ + *(struct mdesc *) md = mtemp; + } + else + { + if (mtemp.flags & MMALLOC_DEVZERO) + { + (void) close (mtemp.fd); + } + md = NULL; + } + } + + return (md); +} + + + diff --git a/mmalloc/fsf.shar.orig b/mmalloc/fsf.shar.orig new file mode 100755 index 0000000..3ece103 --- /dev/null +++ b/mmalloc/fsf.shar.orig @@ -0,0 +1,1841 @@ +#--------CUT---------CUT---------CUT---------CUT--------# +######################################################### +# # +# This is a shell archive file. To extract files: # +# # +# 1) Make a directory for the files. # +# 2) Write a file, such as "file.shar", containing # +# this archive file into the directory. # +# 3) Type "sh file.shar". Do not use csh. # +# # +######################################################### +# +# +echo Extracting ChangeLog: +sed 's/^Z//' >ChangeLog <<\STUNKYFLUFF +ZThu Jul 11 18:15:04 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu) +Z +Z * Merged with C library version, which now has its own subdir. +Z * malloc.h, *.c: Use ansideclisms and #ifdefs for portability both +Z in and out of the C library. +Z * Makefile: New makefile for malloc subdir in libc. +Z Has targets to create malloc.tar{,.Z} by ansidecl processing on srcs. +Z * malloc/Makefile: New file; Makefile for standalone distribution. +Z * malloc/README: New file; info for same. +Z +ZFri Apr 6 00:18:36 1990 Jim Kingdon (kingdon at pogo.ai.mit.edu) +Z +Z * Makefile: Add comments. +Z +ZThu Apr 5 23:08:14 1990 Mike Haertel (mike at albert.ai.mit.edu) +Z +Z * mcheck.c (mcheck, checkhdr): Support user-supplied abort() +Z function. +Z * malloc.h: Declare __free(). +Z * Makefile: New target libmalloc.a. +Z +ZThu Apr 5 21:56:03 1990 Jim Kingdon (kingdon at pogo.ai.mit.edu) +Z +Z * free.c (free): Split into free and __free. +Z * malloc.c (morecore): Call __free on oldinfo. +Z +ZLocal Variables: +Zmode: indented-text +Zleft-margin: 8 +Zfill-column: 76 +Zversion-control: never +ZEnd: +STUNKYFLUFF +set `sum ChangeLog` +if test 21008 != $1 +then +echo ChangeLog: Checksum error. Is: $1, should be: 21008. +fi +# +# +echo Extracting Makefile: +sed 's/^Z//' >Makefile <<\STUNKYFLUFF +Z# Copyright (C) 1991, 1992 Free Software Foundation, Inc. +Z# This file is part of the GNU C Library. +Z +Z# The GNU C Library is free software; you can redistribute it and/or +Z# modify it under the terms of the GNU Library General Public License as +Z# published by the Free Software Foundation; either version 2 of the +Z# License, or (at your option) any later version. +Z +Z# The GNU C Library is distributed in the hope that it will be useful, +Z# but WITHOUT ANY WARRANTY; without even the implied warranty of +Z# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Z# Library General Public License for more details. +Z +Z# You should have received a copy of the GNU Library General Public +Z# License along with the GNU C Library; see the file COPYING.LIB. If +Z# not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Z# Cambridge, MA 02139, USA. +Z +Z# +Z# Makefile for malloc routines +Z# +Zsubdir := malloc +Z +Zall: +Z +Zheaders := malloc.h +Z +Zroutines := malloc free cfree realloc calloc morecore \ +Z valloc memalign mcheck mtrace mstats +Znodist := cfree +Z +Zinstall-lib := libmcheck.a +Z +Zdistribute := mcheck-init.c ChangeLog TODO \ +Z malloc/gmalloc-head.c dist-README dist-Makefile \ +Z mtrace.awk +Z +Z +Zinclude ../Rules +Z +Z$(objpfx)libmcheck.a: $(objpfx)mcheck-init.o +Z ln $< $@ +Z +Z# Make the standalone malloc distribution. +Zdist-routines := $(filter-out $(nodist),$(routines)) +Zmalloc-dist := README COPYING.LIB Makefile ChangeLog \ +Z $(addsuffix .c,$(dist-routines)) $(headers) gmalloc.c \ +Z gmalloc-head.c mtrace.awk +Z%.uu: % +Z uuencode $< < $< > $@-tmp +Z mv $@-tmp $@ +Z%.Z: % +Z compress -c $< > $@-tmp +Z mv $@-tmp $@ +Zmalloc.tar: $(addprefix malloc/,$(malloc-dist)) +Z tar ch$(verbose)f $@ $^ +Zmalloc/%.c: %.c malloc/ +Z $(..)ansidecl -trad $< | indent -stdin -gnu > $@-tmp +Z mv $@-tmp $@ +Zmalloc/%.h: %.h malloc/ +Z $(..)ansidecl -trad $< | indent -stdin -gnu > $@-tmp +Z mv $@-tmp $@ +Zmalloc/Makefile: dist-Makefile +Z sed -e 's,<DIST-SOURCES>,$(addsuffix .c,$(dist-routines)),' \ +Z -e 's,<DIST-OBJECTS>,$(addsuffix .o,$(dist-routines)),' \ +Z -e 's,<DIST-HEADERS>,$(headers),' < $< > $@-tmp +Z mv $@-tmp $@ +Zmalloc/gmalloc.c: malloc/Makefile +Z $(MAKE) -C malloc gmalloc.c +Zmalloc/README: dist-README +Z @rm -f $@ +Z cp $< $@ +Zmalloc/%: % +Z @rm -f $@ +Z cp $< $@ +STUNKYFLUFF +set `sum Makefile` +if test 48180 != $1 +then +echo Makefile: Checksum error. Is: $1, should be: 48180. +fi +# +# +echo Extracting TODO: +sed 's/^Z//' >TODO <<\STUNKYFLUFF +Z0. Access data structures with accessor macros, then turn the heapinfo +Zinto several arrays for faster access on machines with addressing modes. +ZAlso, this eventually raises the possibility of maintaining multiple +Zheaps. +Z1. Possible heuristic to catch multiple frees. Introduce an extra word +Zof heapinfo that says whether the remaining info is for something +Zbusy or something free. Then we can catch attempts to free already-free +Zlarge blocks, as well as things not belonging to malloc at all. In the +Zcase of a fragment, we can check if the fragment looks like it *already* +Zbelongs to the fragment list, by comparing it with the "first" fragment +Zof the block, or checking its "prev" pointer to see if it points into +Zthe block. Then if it looks like it might we can exhaustively search +Zthe block's free list to see if the fragment is there or not. Extending +Zthe heapinfo structure would have the benefit of making it a power of +Ztwo and thus making array indexing faster, perhaps. Suitably adapted, +Zthis heuristic could also catch invalid pointers passed to realloc. +Z +ZAll of these additional features require the inclusion of <malloc.h>. +Z3. indirect reference allocator: ialloc(), ifree(), irealloc(). +Z4. garbage collecting allocator: galloc(), garbage(), gfree(), grealloc(). +STUNKYFLUFF +set `sum TODO` +if test 51437 != $1 +then +echo TODO: Checksum error. Is: $1, should be: 51437. +fi +# +# +echo Extracting calloc.c: +sed 's/^Z//' >calloc.c <<\STUNKYFLUFF +Z/* Copyright (C) 1991 Free Software Foundation, Inc. +ZThis file is part of the GNU C Library. +Z +ZThe GNU C Library is free software; you can redistribute it and/or +Zmodify it under the terms of the GNU Library General Public License as +Zpublished by the Free Software Foundation; either version 2 of the +ZLicense, or (at your option) any later version. +Z +ZThe GNU C Library is distributed in the hope that it will be useful, +Zbut WITHOUT ANY WARRANTY; without even the implied warranty of +ZMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +ZLibrary General Public License for more details. +Z +ZYou should have received a copy of the GNU Library General Public +ZLicense along with the GNU C Library; see the file COPYING.LIB. If +Znot, write to the Free Software Foundation, Inc., 675 Mass Ave, +ZCambridge, MA 02139, USA. */ +Z +Z/* IGNORE(@ */ +Z#include <ansidecl.h> +Z/* @) */ +Z#include <malloc.h> +Z +Z#if defined(__GNU_LIBRARY__) || defined(STDC_HEADERS) || defined(USG) +Z#include <string.h> +Z#else +Z#define memset(s, zero, n) bzero ((s), (n)) +Z#endif +Z +Z/* Allocate an array of NMEMB elements each SIZE bytes long. +Z The entire array is initialized to zeros. */ +ZPTR +ZDEFUN(calloc, (nmemb, size), register size_t nmemb AND register size_t size) +Z{ +Z register PTR result = malloc (nmemb * size); +Z +Z if (result != NULL) +Z (void) memset (result, 0, nmemb * size); +Z +Z return result; +Z} +STUNKYFLUFF +set `sum calloc.c` +if test 48371 != $1 +then +echo calloc.c: Checksum error. Is: $1, should be: 48371. +fi +# +# +echo Extracting cfree.c: +sed 's/^Z//' >cfree.c <<\STUNKYFLUFF +Z/* Copyright (C) 1991 Free Software Foundation, Inc. +ZThis file is part of the GNU C Library. +Z +ZThe GNU C Library is free software; you can redistribute it and/or +Zmodify it under the terms of the GNU Library General Public License as +Zpublished by the Free Software Foundation; either version 2 of the +ZLicense, or (at your option) any later version. +Z +ZThe GNU C Library is distributed in the hope that it will be useful, +Zbut WITHOUT ANY WARRANTY; without even the implied warranty of +ZMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +ZLibrary General Public License for more details. +Z +ZYou should have received a copy of the GNU Library General Public +ZLicense along with the GNU C Library; see the file COPYING.LIB. If +Znot, write to the Free Software Foundation, Inc., 675 Mass Ave, +ZCambridge, MA 02139, USA. */ +Z +Z#include <ansidecl.h> +Z#include <stdlib.h> +Z +Z#undef cfree +Z +Z#include <gnu-stabs.h> +Z +Zfunction_alias(cfree, free, void, (ptr), +Z DEFUN(cfree, (ptr), PTR ptr)) +STUNKYFLUFF +set `sum cfree.c` +if test 17488 != $1 +then +echo cfree.c: Checksum error. Is: $1, should be: 17488. +fi +# +# +echo Extracting dist-Makefile: +sed 's/^Z//' >dist-Makefile <<\STUNKYFLUFF +Z# Copyright (C) 1991 Free Software Foundation, Inc. +Z# This file is part of the GNU C Library. +Z +Z# The GNU C Library is free software; you can redistribute it and/or +Z# modify it under the terms of the GNU Library General Public License +Z# as published by the Free Software Foundation; either version 2 of +Z# the License, or (at your option) any later version. +Z +Z# The GNU C Library is distributed in the hope that it will be useful, +Z# but WITHOUT ANY WARRANTY; without even the implied warranty of +Z# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +Z# Library General Public License for more details. +Z +Z# You should have received a copy of the GNU Library General Public +Z# License along with the GNU C Library; see the file COPYING.LIB. If +Z# not, write to the Free Software Foundation, Inc., 675 Mass Ave, +Z# Cambridge, MA 02139, USA. +Z +Z# Makefile for standalone distribution of malloc. +Z +Z# Use this on System V. +Z#CPPFLAGS = -DUSG +Z +Z.PHONY: all +Zall: libmalloc.a gmalloc.o +Z +Zsources = <DIST-SOURCES> +Zobjects = <DIST-OBJECTS> +Zheaders = <DIST-HEADERS> +Z +Zlibmalloc.a: $(objects) +Z ar crv $@ $(objects) +Z ranlib $@ +Z +Z$(objects): $(headers) +Z +Zgmalloc.c: gmalloc-head.c $(headers) $(sources) +Z cat gmalloc-head.c $(headers) $(sources) > $@ +Z +Z.c.o: +Z $(CC) $(CFLAGS) $(CPPFLAGS) -I. -c $< $(OUTPUT_OPTION) +Z +Z.PHONY: clean realclean malloc-clean malloc-realclean +Zclean malloc-clean: +Z -rm -f libmalloc.a *.o core +Zrealclean malloc-realclean: clean +Z -rm -f TAGS tags *~ +Z +Z# For inside the C library. +Zmalloc.tar malloc.tar.Z: +Z $(MAKE) -C .. $@ +STUNKYFLUFF +set `sum dist-Makefile` +if test 58822 != $1 +then +echo dist-Makefile: Checksum error. Is: $1, should be: 58822. +fi +# +# +echo Extracting dist-README: +sed 's/^Z//' >dist-README <<\STUNKYFLUFF +ZThis is the standalone distribution of GNU malloc. +ZGNU malloc is part of the GNU C Library, but is also distributed separately. +Z +ZIf you find bugs in GNU malloc, send reports to bug-glibc@prep.ai.mit.edu. +Z +ZGNU malloc is free software. See the file COPYING.LIB for copying conditions. +Z +ZThe makefile builds libmalloc.a and gmalloc.o. If you are using GNU malloc +Zto replace your system's existing malloc package, it is important to make +Zsure you get all GNU functions, not some of the GNU functions and some from +Zthe system library. gmalloc.o has all the functions in one file, so using +Zthat will make sure you don't accidentally mix the two malloc packages. +STUNKYFLUFF +set `sum dist-README` +if test 59167 != $1 +then +echo dist-README: Checksum error. Is: $1, should be: 59167. +fi +# +# +echo Extracting free.c: +sed 's/^Z//' >free.c <<\STUNKYFLUFF +Z/* Free a block of memory allocated by `malloc'. +Z Copyright 1990, 1991 Free Software Foundation +Z Written May 1989 by Mike Haertel. +Z +ZThe GNU C Library is free software; you can redistribute it and/or +Zmodify it under the terms of the GNU Library General Public License as +Zpublished by the Free Software Foundation; either version 2 of the +ZLicense, or (at your option) any later version. +Z +ZThe GNU C Library is distributed in the hope that it will be useful, +Zbut WITHOUT ANY WARRANTY; without even the implied warranty of +ZMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +ZLibrary General Public License for more details. +Z +ZYou should have received a copy of the GNU Library General Public +ZLicense along with the GNU C Library; see the file COPYING.LIB. If +Znot, write to the Free Software Foundation, Inc., 675 Mass Ave, +ZCambridge, MA 02139, USA. +Z +Z The author may be reached (Email) at the address mike@ai.mit.edu, +Z or (US mail) as Mike Haertel c/o Free Software Foundation. */ +Z +Z/* IGNORE(@ */ +Z#include <ansidecl.h> +Z#include <stddef.h> +Z#include <stdlib.h> +Z/* @) */ +Z +Z#define _MALLOC_INTERNAL +Z#include <malloc.h> +Z +Z/* Debugging hook for free. */ +Zvoid EXFUN((*__free_hook), (PTR __ptr)); +Z +Z/* List of blocks allocated by memalign. */ +Zstruct alignlist *_aligned_blocks = NULL; +Z +Z/* Return memory to the heap. +Z Like `free' but don't call a __free_hook if there is one. */ +Zvoid +ZDEFUN(__free, (ptr), PTR ptr) +Z{ +Z int type; +Z size_t block, blocks; +Z register size_t i; +Z struct list *prev, *next; +Z +Z block = BLOCK(ptr); +Z +Z type = _heapinfo[block].busy.type; +Z switch (type) +Z { +Z case 0: +Z /* Get as many statistics as early as we can. */ +Z --_chunks_used; +Z _bytes_used -= _heapinfo[block].busy.info.size * BLOCKSIZE; +Z _bytes_free += _heapinfo[block].busy.info.size * BLOCKSIZE; +Z +Z /* Find the free cluster previous to this one in the free list. +Z Start searching at the last block referenced; this may benefit +Z programs with locality of allocation. */ +Z i = _heapindex; +Z if (i > block) +Z while (i > block) +Z i = _heapinfo[i].free.prev; +Z else +Z { +Z do +Z i = _heapinfo[i].free.next; +Z while (i > 0 && i < block); +Z i = _heapinfo[i].free.prev; +Z } +Z +Z /* Determine how to link this block into the free list. */ +Z if (block == i + _heapinfo[i].free.size) +Z { +Z /* Coalesce this block with its predecessor. */ +Z _heapinfo[i].free.size += _heapinfo[block].busy.info.size; +Z block = i; +Z } +Z else +Z { +Z /* Really link this block back into the free list. */ +Z _heapinfo[block].free.size = _heapinfo[block].busy.info.size; +Z _heapinfo[block].free.next = _heapinfo[i].free.next; +Z _heapinfo[block].free.prev = i; +Z _heapinfo[i].free.next = block; +Z _heapinfo[_heapinfo[block].free.next].free.prev = block; +Z ++_chunks_free; +Z } +Z +Z /* Now that the block is linked in, see if we can coalesce it +Z with its successor (by deleting its successor from the list +Z and adding in its size). */ +Z if (block + _heapinfo[block].free.size == _heapinfo[block].free.next) +Z { +Z _heapinfo[block].free.size +Z += _heapinfo[_heapinfo[block].free.next].free.size; +Z _heapinfo[block].free.next +Z = _heapinfo[_heapinfo[block].free.next].free.next; +Z _heapinfo[_heapinfo[block].free.next].free.prev = block; +Z --_chunks_free; +Z } +Z +Z /* Now see if we can return stuff to the system. */ +Z blocks = _heapinfo[block].free.size; +Z if (blocks >= FINAL_FREE_BLOCKS && block + blocks == _heaplimit +Z && (*__morecore)(0) == ADDRESS(block + blocks)) +Z { +Z register size_t bytes = blocks * BLOCKSIZE; +Z _heaplimit -= blocks; +Z (*__morecore)(- bytes); +Z _heapinfo[_heapinfo[block].free.prev].free.next +Z = _heapinfo[block].free.next; +Z _heapinfo[_heapinfo[block].free.next].free.prev +Z = _heapinfo[block].free.prev; +Z block = _heapinfo[block].free.prev; +Z --_chunks_free; +Z _bytes_free -= bytes; +Z } +Z +Z /* Set the next search to begin at this block. */ +Z _heapindex = block; +Z break; +Z +Z default: +Z /* Do some of the statistics. */ +Z --_chunks_used; +Z _bytes_used -= 1 << type; +Z ++_chunks_free; +Z _bytes_free += 1 << type; +Z +Z /* Get the address of the first free fragment in this block. */ +Z prev = (struct list *) ((char *) ADDRESS(block) + +Z (_heapinfo[block].busy.info.frag.first << type)); +Z +Z if (_heapinfo[block].busy.info.frag.nfree == (BLOCKSIZE >> type) - 1) +Z { +Z /* If all fragments of this block are free, remove them +Z from the fragment list and free the whole block. */ +Z next = prev; +Z for (i = 1; i < (size_t) (BLOCKSIZE >> type); ++i) +Z next = next->next; +Z prev->prev->next = next; +Z if (next != NULL) +Z next->prev = prev->prev; +Z _heapinfo[block].busy.type = 0; +Z _heapinfo[block].busy.info.size = 1; +Z +Z /* Keep the statistics accurate. */ +Z ++_chunks_used; +Z _bytes_used += BLOCKSIZE; +Z _chunks_free -= BLOCKSIZE >> type; +Z _bytes_free -= BLOCKSIZE; +Z +Z free(ADDRESS(block)); +Z } +Z else if (_heapinfo[block].busy.info.frag.nfree != 0) +Z { +Z /* If some fragments of this block are free, link this +Z fragment into the fragment list after the first free +Z fragment of this block. */ +Z next = (struct list *) ptr; +Z next->next = prev->next; +Z next->prev = prev; +Z prev->next = next; +Z if (next->next != NULL) +Z next->next->prev = next; +Z ++_heapinfo[block].busy.info.frag.nfree; +Z } +Z else +Z { +Z /* No fragments of this block are free, so link this +Z fragment into the fragment list and announce that +Z it is the first free fragment of this block. */ +Z prev = (struct list *) ptr; +Z _heapinfo[block].busy.info.frag.nfree = 1; +Z _heapinfo[block].busy.info.frag.first = (unsigned long int) +Z ((unsigned long int) ((char *) ptr - (char *) NULL) +Z % BLOCKSIZE >> type); +Z prev->next = _fraghead[type].next; +Z prev->prev = &_fraghead[type]; +Z prev->prev->next = prev; +Z if (prev->next != NULL) +Z prev->next->prev = prev; +Z } +Z break; +Z } +Z} +Z +Z/* Return memory to the heap. */ +Zvoid +ZDEFUN(free, (ptr), PTR ptr) +Z{ +Z register struct alignlist *l; +Z +Z if (ptr == NULL) +Z return; +Z +Z for (l = _aligned_blocks; l != NULL; l = l->next) +Z if (l->aligned == ptr) +Z { +Z l->aligned = NULL; /* Mark the slot in the list as free. */ +Z ptr = l->exact; +Z break; +Z } +Z +Z if (__free_hook != NULL) +Z (*__free_hook) (ptr); +Z else +Z __free (ptr); +Z} +STUNKYFLUFF +set `sum free.c` +if test 53143 != $1 +then +echo free.c: Checksum error. Is: $1, should be: 53143. +fi +# +# +echo Extracting gmalloc-head.c: +sed 's/^Z//' >gmalloc-head.c <<\STUNKYFLUFF +Z/* DO NOT EDIT THIS FILE -- it is automagically generated. -*- C -*- */ +Z +Z#define SKELETON +Z +Z#if defined(__GNU_LIBRARY__) || defined(STDC_HEADERS) || defined(USG) +Z#include <string.h> +Z#else +Z#define memset(s, zero, n) bzero ((s), (n)) +Z#define memcpy(d, s, n) bcopy ((s), (d), (n)) +Z#define memmove(d, s, n) bcopy ((s), (d), (n)) +Z#endif +Z +Z#define _MALLOC_INTERNAL +Z +Z/* The malloc headers and source files from the C library follow here. */ +STUNKYFLUFF +set `sum gmalloc-head.c` +if test 33445 != $1 +then +echo gmalloc-head.c: Checksum error. Is: $1, should be: 33445. +fi +# +# +echo Extracting malloc.c: +sed 's/^Z//' >malloc.c <<\STUNKYFLUFF +Z/* Memory allocator `malloc'. +Z Copyright 1990, 1991 Free Software Foundation +Z Written May 1989 by Mike Haertel. +Z +ZThe GNU C Library is free software; you can redistribute it and/or +Zmodify it under the terms of the GNU Library General Public License as +Zpublished by the Free Software Foundation; either version 2 of the +ZLicense, or (at your option) any later version. +Z +ZThe GNU C Library is distributed in the hope that it will be useful, +Zbut WITHOUT ANY WARRANTY; without even the implied warranty of +ZMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +ZLibrary General Public License for more details. +Z +ZYou should have received a copy of the GNU Library General Public +ZLicense along with the GNU C Library; see the file COPYING.LIB. If +Znot, write to the Free Software Foundation, Inc., 675 Mass Ave, +ZCambridge, MA 02139, USA. +Z +Z The author may be reached (Email) at the address mike@ai.mit.edu, +Z or (US mail) as Mike Haertel c/o Free Software Foundation. */ +Z +Z/* IGNORE(@ */ +Z#include <ansidecl.h> +Z#include <stddef.h> +Z#include <stdlib.h> +Z/* @) */ +Z +Z#define _MALLOC_INTERNAL +Z#include <malloc.h> +Z +Z#if defined(__GNU_LIBRARY__) || defined(STDC_HEADERS) || defined(USG) +Z#include <string.h> +Z#else +Z#define memset(s, zero, n) bzero ((s), (n)) +Z#define memcpy(d, s, n) bcopy ((s), (d), (n)) +Z#endif +Z +Z +Z/* How to really get more memory. */ +ZPTR EXFUN((*__morecore), (ptrdiff_t __size)) = __default_morecore; +Z +Z/* Debugging hook for `malloc'. */ +ZPTR EXFUN((*__malloc_hook), (size_t __size)); +Z +Z/* Pointer to the base of the first block. */ +Zchar *_heapbase; +Z +Z/* Block information table. Allocated with align/__free (not malloc/free). */ +Zmalloc_info *_heapinfo; +Z +Z/* Number of info entries. */ +Zstatic size_t heapsize; +Z +Z/* Search index in the info table. */ +Zsize_t _heapindex; +Z +Z/* Limit of valid info table indices. */ +Zsize_t _heaplimit; +Z +Z/* Free lists for each fragment size. */ +Zstruct list _fraghead[BLOCKLOG]; +Z +Z/* Instrumentation. */ +Zsize_t _chunks_used; +Zsize_t _bytes_used; +Zsize_t _chunks_free; +Zsize_t _bytes_free; +Z +Z/* Are you experienced? */ +Zint __malloc_initialized; +Z +Z/* Aligned allocation. */ +Zstatic PTR +ZDEFUN(align, (size), size_t size) +Z{ +Z PTR result; +Z unsigned long int adj; +Z +Z result = (*__morecore)(size); +Z adj = (unsigned long int) ((unsigned long int) ((char *) result - +Z (char *) NULL)) % BLOCKSIZE; +Z if (adj != 0) +Z { +Z adj = BLOCKSIZE - adj; +Z (void) (*__morecore)(adj); +Z result = (char *) result + adj; +Z } +Z return result; +Z} +Z +Z/* Set everything up and remember that we have. */ +Zstatic int +ZDEFUN_VOID(initialize) +Z{ +Z heapsize = HEAP / BLOCKSIZE; +Z _heapinfo = (malloc_info *) align(heapsize * sizeof(malloc_info)); +Z if (_heapinfo == NULL) +Z return 0; +Z memset(_heapinfo, 0, heapsize * sizeof(malloc_info)); +Z _heapinfo[0].free.size = 0; +Z _heapinfo[0].free.next = _heapinfo[0].free.prev = 0; +Z _heapindex = 0; +Z _heapbase = (char *) _heapinfo; +Z __malloc_initialized = 1; +Z return 1; +Z} +Z +Z/* Get neatly aligned memory, initializing or +Z growing the heap info table as necessary. */ +Zstatic PTR +ZDEFUN(morecore, (size), size_t size) +Z{ +Z PTR result; +Z malloc_info *newinfo, *oldinfo; +Z size_t newsize; +Z +Z result = align(size); +Z if (result == NULL) +Z return NULL; +Z +Z /* Check if we need to grow the info table. */ +Z if ((size_t) BLOCK((char *) result + size) > heapsize) +Z { +Z newsize = heapsize; +Z while ((size_t) BLOCK((char *) result + size) > newsize) +Z newsize *= 2; +Z newinfo = (malloc_info *) align(newsize * sizeof(malloc_info)); +Z if (newinfo == NULL) +Z { +Z (*__morecore)(- size); +Z return NULL; +Z } +Z memset(newinfo, 0, newsize * sizeof(malloc_info)); +Z memcpy(newinfo, _heapinfo, heapsize * sizeof(malloc_info)); +Z oldinfo = _heapinfo; +Z newinfo[BLOCK(oldinfo)].busy.type = 0; +Z newinfo[BLOCK(oldinfo)].busy.info.size +Z = BLOCKIFY(heapsize * sizeof(malloc_info)); +Z _heapinfo = newinfo; +Z __free(oldinfo); +Z heapsize = newsize; +Z } +Z +Z _heaplimit = BLOCK((char *) result + size); +Z return result; +Z} +Z +Z/* Allocate memory from the heap. */ +ZPTR +ZDEFUN(malloc, (size), size_t size) +Z{ +Z PTR result; +Z size_t block, blocks, lastblocks, start; +Z register size_t i; +Z struct list *next; +Z +Z if (size == 0) +Z return NULL; +Z +Z if (__malloc_hook != NULL) +Z return (*__malloc_hook)(size); +Z +Z if (!__malloc_initialized) +Z if (!initialize()) +Z return NULL; +Z +Z if (size < sizeof(struct list)) +Z size = sizeof(struct list); +Z +Z /* Determine the allocation policy based on the request size. */ +Z if (size <= BLOCKSIZE / 2) +Z { +Z /* Small allocation to receive a fragment of a block. +Z Determine the logarithm to base two of the fragment size. */ +Z register size_t log = 1; +Z --size; +Z while ((size /= 2) != 0) +Z ++log; +Z +Z /* Look in the fragment lists for a +Z free fragment of the desired size. */ +Z next = _fraghead[log].next; +Z if (next != NULL) +Z { +Z /* There are free fragments of this size. +Z Pop a fragment out of the fragment list and return it. +Z Update the block's nfree and first counters. */ +Z result = (PTR) next; +Z next->prev->next = next->next; +Z if (next->next != NULL) +Z next->next->prev = next->prev; +Z block = BLOCK(result); +Z if (--_heapinfo[block].busy.info.frag.nfree != 0) +Z _heapinfo[block].busy.info.frag.first = (unsigned long int) +Z ((unsigned long int) ((char *) next->next - (char *) NULL) +Z % BLOCKSIZE) >> log; +Z +Z /* Update the statistics. */ +Z ++_chunks_used; +Z _bytes_used += 1 << log; +Z --_chunks_free; +Z _bytes_free -= 1 << log; +Z } +Z else +Z { +Z /* No free fragments of the desired size, so get a new block +Z and break it into fragments, returning the first. */ +Z result = malloc(BLOCKSIZE); +Z if (result == NULL) +Z return NULL; +Z +Z /* Link all fragments but the first into the free list. */ +Z for (i = 1; i < (size_t) (BLOCKSIZE >> log); ++i) +Z { +Z next = (struct list *) ((char *) result + (i << log)); +Z next->next = _fraghead[log].next; +Z next->prev = &_fraghead[log]; +Z next->prev->next = next; +Z if (next->next != NULL) +Z next->next->prev = next; +Z } +Z +Z /* Initialize the nfree and first counters for this block. */ +Z block = BLOCK(result); +Z _heapinfo[block].busy.type = log; +Z _heapinfo[block].busy.info.frag.nfree = i - 1; +Z _heapinfo[block].busy.info.frag.first = i - 1; +Z +Z _chunks_free += (BLOCKSIZE >> log) - 1; +Z _bytes_free += BLOCKSIZE - (1 << log); +Z _bytes_used -= BLOCKSIZE - (1 << log); +Z } +Z } +Z else +Z { +Z /* Large allocation to receive one or more blocks. +Z Search the free list in a circle starting at the last place visited. +Z If we loop completely around without finding a large enough +Z space we will have to get more memory from the system. */ +Z blocks = BLOCKIFY(size); +Z start = block = MALLOC_SEARCH_START; +Z while (_heapinfo[block].free.size < blocks) +Z { +Z block = _heapinfo[block].free.next; +Z if (block == start) +Z { +Z /* Need to get more from the system. Check to see if +Z the new core will be contiguous with the final free +Z block; if so we don't need to get as much. */ +Z block = _heapinfo[0].free.prev; +Z lastblocks = _heapinfo[block].free.size; +Z if (_heaplimit != 0 && block + lastblocks == _heaplimit && +Z (*__morecore)(0) == ADDRESS(block + lastblocks) && +Z (morecore((blocks - lastblocks) * BLOCKSIZE)) != NULL) +Z { +Z _heapinfo[block].free.size = blocks; +Z _bytes_free += (blocks - lastblocks) * BLOCKSIZE; +Z continue; +Z } +Z result = morecore(blocks * BLOCKSIZE); +Z if (result == NULL) +Z return NULL; +Z block = BLOCK(result); +Z _heapinfo[block].busy.type = 0; +Z _heapinfo[block].busy.info.size = blocks; +Z ++_chunks_used; +Z _bytes_used += blocks * BLOCKSIZE; +Z return result; +Z } +Z } +Z +Z /* At this point we have found a suitable free list entry. +Z Figure out how to remove what we need from the list. */ +Z result = ADDRESS(block); +Z if (_heapinfo[block].free.size > blocks) +Z { +Z /* The block we found has a bit left over, +Z so relink the tail end back into the free list. */ +Z _heapinfo[block + blocks].free.size +Z = _heapinfo[block].free.size - blocks; +Z _heapinfo[block + blocks].free.next +Z = _heapinfo[block].free.next; +Z _heapinfo[block + blocks].free.prev +Z = _heapinfo[block].free.prev; +Z _heapinfo[_heapinfo[block].free.prev].free.next +Z = _heapinfo[_heapinfo[block].free.next].free.prev +Z = _heapindex = block + blocks; +Z } +Z else +Z { +Z /* The block exactly matches our requirements, +Z so just remove it from the list. */ +Z _heapinfo[_heapinfo[block].free.next].free.prev +Z = _heapinfo[block].free.prev; +Z _heapinfo[_heapinfo[block].free.prev].free.next +Z = _heapindex = _heapinfo[block].free.next; +Z --_chunks_free; +Z } +Z +Z _heapinfo[block].busy.type = 0; +Z _heapinfo[block].busy.info.size = blocks; +Z ++_chunks_used; +Z _bytes_used += blocks * BLOCKSIZE; +Z _bytes_free -= blocks * BLOCKSIZE; +Z } +Z +Z return result; +Z} +STUNKYFLUFF +set `sum malloc.c` +if test 64456 != $1 +then +echo malloc.c: Checksum error. Is: $1, should be: 64456. +fi +# +# +echo Extracting malloc.h: +sed 's/^Z//' >malloc.h <<\STUNKYFLUFF +Z/* Declarations for `malloc' and friends. +Z Copyright 1990, 1991 Free Software Foundation +Z Written May 1989 by Mike Haertel. +Z +ZThe GNU C Library is free software; you can redistribute it and/or +Zmodify it under the terms of the GNU Library General Public License as +Zpublished by the Free Software Foundation; either version 2 of the +ZLicense, or (at your option) any later version. +Z +ZThe GNU C Library is distributed in the hope that it will be useful, +Zbut WITHOUT ANY WARRANTY; without even the implied warranty of +ZMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +ZLibrary General Public License for more details. +Z +ZYou should have received a copy of the GNU Library General Public +ZLicense along with the GNU C Library; see the file COPYING.LIB. If +Znot, write to the Free Software Foundation, Inc., 675 Mass Ave, +ZCambridge, MA 02139, USA. +Z +Z The author may be reached (Email) at the address mike@ai.mit.edu, +Z or (US mail) as Mike Haertel c/o Free Software Foundation. */ +Z +Z#ifndef _MALLOC_H +Z +Z#define _MALLOC_H 1 +Z +Z/* IGNORE(@ */ +Z#include <features.h> +Z#define __need_NULL +Z#define __need_size_t +Z#define __need_ptrdiff_t +Z#include <stddef.h> +Z/* @) */ +Z +Z#ifndef NULL +Z#define NULL 0 +Z#endif +Z +Z#ifdef __STDC__ +Z#include <stddef.h> +Z#else +Z#undef size_t +Z#define size_t unsigned int +Z#endif +Z +Z +Z/* Allocate SIZE bytes of memory. */ +Zextern PTR EXFUN(malloc, (size_t __size)); +Z/* Re-allocate the previously allocated block +Z in PTR, making the new block SIZE bytes long. */ +Zextern PTR EXFUN(realloc, (PTR __ptr, size_t __size)); +Z/* Allocate NMEMB elements of SIZE bytes each, all initialized to 0. */ +Zextern PTR EXFUN(calloc, (size_t __nmemb, size_t __size)); +Z/* Free a block allocated by `malloc', `realloc' or `calloc'. */ +Zextern void EXFUN(free, (PTR __ptr)); +Z +Z/* Allocate SIZE bytes allocated to ALIGNMENT bytes. */ +Zextern PTR EXFUN(memalign, (size_t __alignment, size_t __size)); +Z +Z/* Allocate SIZE bytes on a page boundary. */ +Zextern PTR EXFUN(valloc, (size_t __size)); +Z +Z +Z#ifdef _MALLOC_INTERNAL +Z +Z#if defined(__GNU_LIBRARY__) || defined(__STDC__) +Z#include <limits.h> +Z#else +Z#define CHAR_BIT 8 +Z#endif +Z +Z/* The allocator divides the heap into blocks of fixed size; large +Z requests receive one or more whole blocks, and small requests +Z receive a fragment of a block. Fragment sizes are powers of two, +Z and all fragments of a block are the same size. When all the +Z fragments in a block have been freed, the block itself is freed. */ +Z#define INT_BIT (CHAR_BIT * sizeof(int)) +Z#define BLOCKLOG (INT_BIT > 16 ? 12 : 9) +Z#define BLOCKSIZE (1 << BLOCKLOG) +Z#define BLOCKIFY(SIZE) (((SIZE) + BLOCKSIZE - 1) / BLOCKSIZE) +Z +Z/* Determine the amount of memory spanned by the initial heap table +Z (not an absolute limit). */ +Z#define HEAP (INT_BIT > 16 ? 4194304 : 65536) +Z +Z/* Number of contiguous free blocks allowed to build up at the end of +Z memory before they will be returned to the system. */ +Z#define FINAL_FREE_BLOCKS 8 +Z +Z/* Where to start searching the free list when looking for new memory. +Z The two possible values are 0 and _heapindex. Starting at 0 seems +Z to reduce total memory usage, while starting at _heapindex seems to +Z run faster. */ +Z#define MALLOC_SEARCH_START _heapindex +Z +Z/* Data structure giving per-block information. */ +Ztypedef union +Z { +Z /* Heap information for a busy block. */ +Z struct +Z { +Z /* Zero for a large block, or positive giving the +Z logarithm to the base two of the fragment size. */ +Z int type; +Z union +Z { +Z struct +Z { +Z size_t nfree; /* Free fragments in a fragmented block. */ +Z size_t first; /* First free fragment of the block. */ +Z } frag; +Z /* Size (in blocks) of a large cluster. */ +Z size_t size; +Z } info; +Z } busy; +Z /* Heap information for a free block (that may be the first of +Z a free cluster). */ +Z struct +Z { +Z size_t size; /* Size (in blocks) of a free cluster. */ +Z size_t next; /* Index of next free cluster. */ +Z size_t prev; /* Index of previous free cluster. */ +Z } free; +Z } malloc_info; +Z +Z/* Pointer to first block of the heap. */ +Zextern char *_heapbase; +Z +Z/* Table indexed by block number giving per-block information. */ +Zextern malloc_info *_heapinfo; +Z +Z/* Address to block number and vice versa. */ +Z#define BLOCK(A) (((char *) (A) - _heapbase) / BLOCKSIZE + 1) +Z/* The following line MUST be split! m4 will not process it otherwise. */ +Z#define ADDRESS(B) \ +Z ((PTR) (((B) - 1) * BLOCKSIZE + _heapbase)) +Z +Z/* Current search index for the heap table. */ +Zextern size_t _heapindex; +Z +Z/* Limit of valid info table indices. */ +Zextern size_t _heaplimit; +Z +Z/* Doubly linked lists of free fragments. */ +Zstruct list +Z { +Z struct list *next; +Z struct list *prev; +Z }; +Z +Z/* Free list headers for each fragment size. */ +Zextern struct list _fraghead[]; +Z +Z/* List of blocks allocated with `memalign' (or `valloc'). */ +Zstruct alignlist +Z { +Z struct alignlist *next; +Z PTR aligned; /* The address that memaligned returned. */ +Z PTR exact; /* The address that malloc returned. */ +Z }; +Zextern struct alignlist *_aligned_blocks; +Z +Z/* Instrumentation. */ +Zextern size_t _chunks_used; +Zextern size_t _bytes_used; +Zextern size_t _chunks_free; +Zextern size_t _bytes_free; +Z +Z/* Internal version of `free' used in `morecore'. */ +Zextern void EXFUN(__free, (PTR __ptr)); +Z +Z#endif /* _MALLOC_INTERNAL. */ +Z +Z/* Underlying allocation function; successive calls should +Z return contiguous pieces of memory. */ +Zextern PTR EXFUN((*__morecore), (ptrdiff_t __size)); +Z +Z/* Default value of `__morecore'. */ +Zextern PTR EXFUN(__default_morecore, (ptrdiff_t __size)); +Z +Z/* Nonzero if `malloc' has been called and done its initialization. */ +Zextern int __malloc_initialized; +Z +Z/* Hooks for debugging versions. */ +Zextern void EXFUN((*__free_hook), (PTR __ptr)); +Zextern PTR EXFUN((*__malloc_hook), (size_t __size)); +Zextern PTR EXFUN((*__realloc_hook), (PTR __ptr, size_t __size)); +Z +Z/* Activate a standard collection of debugging hooks. */ +Zextern void EXFUN(mcheck, (void EXFUN((*__func), (void)))); +Z +Z/* Statistics available to the user. */ +Zstruct mstats +Z { +Z size_t bytes_total; /* Total size of the heap. */ +Z size_t chunks_used; /* Chunks allocated by the user. */ +Z size_t bytes_used; /* Byte total of user-allocated chunks. */ +Z size_t chunks_free; /* Chunks in the free list. */ +Z size_t bytes_free; /* Byte total of chunks in the free list. */ +Z }; +Z +Z/* Pick up the current statistics. */ +Zextern struct mstats EXFUN(mstats, (NOARGS)); +Z +Z#endif /* malloc.h */ +STUNKYFLUFF +set `sum malloc.h` +if test 10676 != $1 +then +echo malloc.h: Checksum error. Is: $1, should be: 10676. +fi +# +# +echo Extracting mcheck-init.c: +sed 's/^Z//' >mcheck-init.c <<\STUNKYFLUFF +Z/* Copyright (C) 1991 Free Software Foundation, Inc. +ZThis file is part of the GNU C Library. +Z +ZThe GNU C Library is free software; you can redistribute it and/or +Zmodify it under the terms of the GNU Library General Public License as +Zpublished by the Free Software Foundation; either version 2 of the +ZLicense, or (at your option) any later version. +Z +ZThe GNU C Library is distributed in the hope that it will be useful, +Zbut WITHOUT ANY WARRANTY; without even the implied warranty of +ZMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +ZLibrary General Public License for more details. +Z +ZYou should have received a copy of the GNU Library General Public +ZLicense along with the GNU C Library; see the file COPYING.LIB. If +Znot, write to the Free Software Foundation, Inc., 675 Mass Ave, +ZCambridge, MA 02139, USA. */ +Z +Z/* The object of this file should be installed as libmcheck.a, +Z so one can do -lmcheck to turn on mcheck. */ +Z +Z#ifdef __GNU_STAB__ +Z +Z#include <ansidecl.h> +Z#include <malloc.h> +Z#include <gnu-stabs.h> +Z +Zstatic void +ZDEFUN_VOID (turn_on_mcheck) +Z{ +Z mcheck (NULL); +Z} +Z +Ztext_set_element (__libc_subinit, turn_on_mcheck); +Z +Z#endif +STUNKYFLUFF +set `sum mcheck-init.c` +if test 31836 != $1 +then +echo mcheck-init.c: Checksum error. Is: $1, should be: 31836. +fi +# +# +echo Extracting mcheck.c: +sed 's/^Z//' >mcheck.c <<\STUNKYFLUFF +Z/* Standard debugging hooks for `malloc'. +Z Copyright 1990, 1991 Free Software Foundation +Z Written May 1989 by Mike Haertel. +Z +ZThe GNU C Library is free software; you can redistribute it and/or +Zmodify it under the terms of the GNU Library General Public License as +Zpublished by the Free Software Foundation; either version 2 of the +ZLicense, or (at your option) any later version. +Z +ZThe GNU C Library is distributed in the hope that it will be useful, +Zbut WITHOUT ANY WARRANTY; without even the implied warranty of +ZMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +ZLibrary General Public License for more details. +Z +ZYou should have received a copy of the GNU Library General Public +ZLicense along with the GNU C Library; see the file COPYING.LIB. If +Znot, write to the Free Software Foundation, Inc., 675 Mass Ave, +ZCambridge, MA 02139, USA. +Z +Z The author may be reached (Email) at the address mike@ai.mit.edu, +Z or (US mail) as Mike Haertel c/o Free Software Foundation. */ +Z +Z/* IGNORE(@ */ +Z#include <ansidecl.h> +Z#include <stdlib.h> +Z/* @) */ +Z +Z#include <malloc.h> +Z +Z/* Old hook values. */ +Zstatic void EXFUN((*old_free_hook), (PTR ptr)); +Zstatic PTR EXFUN((*old_malloc_hook), (size_t size)); +Zstatic PTR EXFUN((*old_realloc_hook), (PTR ptr, size_t size)); +Z +Z/* Function to call when something awful happens. */ +Zextern void EXFUN(abort, (NOARGS)); +Zstatic void EXFUN((*abortfunc), (NOARGS)) = (void EXFUN((*), (NOARGS))) abort; +Z +Z/* Arbitrary magical numbers. */ +Z#define MAGICWORD 0xfedabeeb +Z#define MAGICBYTE ((char) 0xd7) +Z +Zstruct hdr +Z { +Z size_t size; /* Exact size requested by user. */ +Z unsigned long int magic; /* Magic number to check header integrity. */ +Z }; +Z +Zstatic void +ZDEFUN(checkhdr, (hdr), CONST struct hdr *hdr) +Z{ +Z if (hdr->magic != MAGICWORD || ((char *) &hdr[1])[hdr->size] != MAGICBYTE) +Z (*abortfunc)(); +Z} +Z +Zstatic void +ZDEFUN(freehook, (ptr), PTR ptr) +Z{ +Z struct hdr *hdr = ((struct hdr *) ptr) - 1; +Z checkhdr(hdr); +Z hdr->magic = 0; +Z __free_hook = old_free_hook; +Z free(hdr); +Z __free_hook = freehook; +Z} +Z +Zstatic PTR +ZDEFUN(mallochook, (size), size_t size) +Z{ +Z struct hdr *hdr; +Z +Z __malloc_hook = old_malloc_hook; +Z hdr = (struct hdr *) malloc (sizeof(struct hdr) + size + 1); +Z __malloc_hook = mallochook; +Z if (hdr == NULL) +Z return NULL; +Z +Z hdr->size = size; +Z hdr->magic = MAGICWORD; +Z ((char *) &hdr[1])[size] = MAGICBYTE; +Z return (PTR) (hdr + 1); +Z} +Z +Zstatic PTR +ZDEFUN(reallochook, (ptr, size), PTR ptr AND size_t size) +Z{ +Z struct hdr *hdr = ((struct hdr *) ptr) - 1; +Z +Z checkhdr(hdr); +Z __free_hook = old_free_hook; +Z __malloc_hook = old_malloc_hook; +Z __realloc_hook = old_realloc_hook; +Z hdr = (struct hdr *) realloc((PTR) hdr, sizeof(struct hdr) + size + 1); +Z __free_hook = freehook; +Z __malloc_hook = mallochook; +Z __realloc_hook = reallochook; +Z if (hdr == NULL) +Z return NULL; +Z +Z hdr->size = size; +Z ((char *) &hdr[1])[size] = MAGICBYTE; +Z return (PTR) (hdr + 1); +Z} +Z +Zvoid +ZDEFUN(mcheck, (func), void EXFUN((*func), (void))) +Z{ +Z static int mcheck_used = 0; +Z +Z if (func != NULL) +Z abortfunc = func; +Z +Z /* These hooks may not be safely inserted if malloc is already in use. */ +Z if (!__malloc_initialized && !mcheck_used) +Z { +Z old_free_hook = __free_hook; +Z __free_hook = freehook; +Z old_malloc_hook = __malloc_hook; +Z __malloc_hook = mallochook; +Z old_realloc_hook = __realloc_hook; +Z __realloc_hook = reallochook; +Z mcheck_used = 1; +Z } +Z} +STUNKYFLUFF +set `sum mcheck.c` +if test 15283 != $1 +then +echo mcheck.c: Checksum error. Is: $1, should be: 15283. +fi +# +# +echo Extracting memalign.c: +sed 's/^Z//' >memalign.c <<\STUNKYFLUFF +Z/* Copyright (C) 1991 Free Software Foundation, Inc. +ZThis file is part of the GNU C Library. +Z +ZThe GNU C Library is free software; you can redistribute it and/or +Zmodify it under the terms of the GNU Library General Public License as +Zpublished by the Free Software Foundation; either version 2 of the +ZLicense, or (at your option) any later version. +Z +ZThe GNU C Library is distributed in the hope that it will be useful, +Zbut WITHOUT ANY WARRANTY; without even the implied warranty of +ZMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +ZLibrary General Public License for more details. +Z +ZYou should have received a copy of the GNU Library General Public +ZLicense along with the GNU C Library; see the file COPYING.LIB. If +Znot, write to the Free Software Foundation, Inc., 675 Mass Ave, +ZCambridge, MA 02139, USA. */ +Z +Z/* IGNORE(@ */ +Z#include <ansidecl.h> +Z#include <stdlib.h> +Z/* @) */ +Z +Z#define _MALLOC_INTERNAL +Z#include <malloc.h> +Z +ZPTR +ZDEFUN(memalign, (alignment, size), +Z size_t alignment AND size_t size) +Z{ +Z PTR result; +Z unsigned long int adj; +Z +Z size = ((size + alignment - 1) / alignment) * alignment; +Z +Z result = malloc (size); +Z if (result == NULL) +Z return NULL; +Z adj = (unsigned long int) ((unsigned long int) ((char *) result - +Z (char *) NULL)) % alignment; +Z if (adj != 0) +Z { +Z struct alignlist *l; +Z for (l = _aligned_blocks; l != NULL; l = l->next) +Z if (l->aligned == NULL) +Z /* This slot is free. Use it. */ +Z break; +Z if (l == NULL) +Z { +Z l = (struct alignlist *) malloc (sizeof (struct alignlist)); +Z if (l == NULL) +Z { +Z free (result); +Z return NULL; +Z } +Z } +Z l->exact = result; +Z result = l->aligned = (char *) result + alignment - adj; +Z l->next = _aligned_blocks; +Z _aligned_blocks = l; +Z } +Z +Z return result; +Z} +STUNKYFLUFF +set `sum memalign.c` +if test 11691 != $1 +then +echo memalign.c: Checksum error. Is: $1, should be: 11691. +fi +# +# +echo Extracting mstats.c: +sed 's/^Z//' >mstats.c <<\STUNKYFLUFF +Z/* Access the statistics maintained by `malloc'. +Z Copyright 1990, 1991 Free Software Foundation +Z Written May 1989 by Mike Haertel. +Z +ZThe GNU C Library is free software; you can redistribute it and/or +Zmodify it under the terms of the GNU Library General Public License as +Zpublished by the Free Software Foundation; either version 2 of the +ZLicense, or (at your option) any later version. +Z +ZThe GNU C Library is distributed in the hope that it will be useful, +Zbut WITHOUT ANY WARRANTY; without even the implied warranty of +ZMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +ZLibrary General Public License for more details. +Z +ZYou should have received a copy of the GNU Library General Public +ZLicense along with the GNU C Library; see the file COPYING.LIB. If +Znot, write to the Free Software Foundation, Inc., 675 Mass Ave, +ZCambridge, MA 02139, USA. +Z +Z The author may be reached (Email) at the address mike@ai.mit.edu, +Z or (US mail) as Mike Haertel c/o Free Software Foundation. */ +Z +Z/* IGNORE(@ */ +Z#include <ansidecl.h> +Z/* @) */ +Z +Z#define _MALLOC_INTERNAL +Z#include <malloc.h> +Z +Zstruct mstats +ZDEFUN_VOID(mstats) +Z{ +Z struct mstats result; +Z +Z result.bytes_total = (char *) (*__morecore)(0) - _heapbase; +Z result.chunks_used = _chunks_used; +Z result.bytes_used = _bytes_used; +Z result.chunks_free = _chunks_free; +Z result.bytes_free = _bytes_free; +Z return result; +Z} +STUNKYFLUFF +set `sum mstats.c` +if test 51328 != $1 +then +echo mstats.c: Checksum error. Is: $1, should be: 51328. +fi +# +# +echo Extracting mtrace.awk: +sed 's/^Z//' >mtrace.awk <<\STUNKYFLUFF +Z# +Z# Awk program to analyze mtrace.c output. +Z# +Z$1 == "+" { if (allocated[$2] != "") +Z print "+", $2, "Alloc", NR, "duplicate:", allocated[$2]; +Z else +Z allocated[$2] = $3; +Z } +Z$1 == "-" { if (allocated[$2] != "") { +Z allocated[$2] = ""; +Z if (allocated[$2] != "") +Z print "DELETE FAILED", $2, allocated[$2]; +Z } else +Z print "-", $2, "Free", NR, "was never alloc'd"; +Z } +Z$1 == "<" { if (allocated[$2] != "") +Z allocated[$2] = ""; +Z else +Z print "-", $2, "Realloc", NR, "was never alloc'd"; +Z } +Z$1 == ">" { if (allocated[$2] != "") +Z print "+", $2, "Realloc", NR, "duplicate:", allocated[$2]; +Z else +Z allocated[$2] = $3; +Z } +Z +Z# Ignore "= Start" +Z$1 == "=" { } +Z# Ignore failed realloc attempts for now +Z$1 == "!" { } +Z +Z +ZEND { for (x in allocated) +Z if (allocated[x] != "") +Z print "+", x, allocated[x]; +Z } +STUNKYFLUFF +set `sum mtrace.awk` +if test 57510 != $1 +then +echo mtrace.awk: Checksum error. Is: $1, should be: 57510. +fi +# +# +echo Extracting mtrace.c: +sed 's/^Z//' >mtrace.c <<\STUNKYFLUFF +Z/* More debugging hooks for `malloc'. +Z Copyright 1991 Free Software Foundation +Z Written April 2, 1991 by John Gilmore of Cygnus Support +Z Based on mcheck.c by Mike Haertel. +Z +ZThis program is free software; you can redistribute it and/or modify +Zit under the terms of the GNU General Public License as published by +Zthe Free Software Foundation; either version 2 of the License, or +Z(at your option) any later version. +Z +ZThis program is distributed in the hope that it will be useful, +Zbut WITHOUT ANY WARRANTY; without even the implied warranty of +ZMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +ZGNU General Public License for more details. +Z +ZYou should have received a copy of the GNU General Public License +Zalong with this program; if not, write to the Free Software +ZFoundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ +Z +Z/* IGNORE(@ */ +Z#include <ansidecl.h> +Z#include <stdlib.h> +Z/* @) */ +Z +Z#include <stdio.h> +Z#include <malloc.h> +Z +Z#ifndef __GNU_LIBRARY__ +Zextern char *getenv (); +Z#endif +Z +Zstatic FILE *mallstream; +Zstatic char mallenv[] = "MALLOC_TRACE"; +Zstatic char mallbuf[BUFSIZ]; /* Buffer for the output. */ +Z +Z/* Address to breakpoint on accesses to... */ +ZPTR mallwatch; +Z +Z/* Old hook values. */ +Zstatic void EXFUN((*old_free_hook), (PTR ptr)); +Zstatic PTR EXFUN((*old_malloc_hook), (size_t size)); +Zstatic PTR EXFUN((*old_realloc_hook), (PTR ptr, size_t size)); +Z +Z/* This function is called when the block being alloc'd, realloc'd, or +Z freed has an address matching the variable "mallwatch". In a debugger, +Z set "mallwatch" to the address of interest, then put a breakpoint on +Z tr_break. */ +Z +Zvoid +ZDEFUN_VOID(tr_break) +Z{ +Z} +Z +Zstatic void +ZDEFUN(tr_freehook, (ptr), PTR ptr) +Z{ +Z fprintf(mallstream, "- %p\n", ptr); /* Be sure to print it first. */ +Z if (ptr == mallwatch) +Z tr_break (); +Z __free_hook = old_free_hook; +Z free (ptr); +Z __free_hook = tr_freehook; +Z} +Z +Zstatic PTR +ZDEFUN(tr_mallochook, (size), size_t size) +Z{ +Z PTR hdr; +Z +Z __malloc_hook = old_malloc_hook; +Z hdr = (PTR) malloc (size); +Z __malloc_hook = tr_mallochook; +Z +Z /* We could be printing a NULL here; that's OK. */ +Z fprintf (mallstream, "+ %p %x\n", hdr, size); +Z +Z if (hdr == mallwatch) +Z tr_break (); +Z +Z return hdr; +Z} +Z +Zstatic PTR +ZDEFUN(tr_reallochook, (ptr, size), PTR ptr AND size_t size) +Z{ +Z PTR hdr; +Z +Z if (ptr == mallwatch) +Z tr_break (); +Z +Z __free_hook = old_free_hook; +Z __malloc_hook = old_malloc_hook; +Z __realloc_hook = old_realloc_hook; +Z hdr = (PTR) realloc (ptr, size); +Z __free_hook = tr_freehook; +Z __malloc_hook = tr_mallochook; +Z __realloc_hook = tr_reallochook; +Z if (hdr == NULL) +Z /* Failed realloc. */ +Z fprintf (mallstream, "! %p %x\n", ptr, size); +Z else +Z fprintf (mallstream, "< %p\n> %p %x\n", ptr, hdr, size); +Z +Z if (hdr == mallwatch) +Z tr_break (); +Z +Z return hdr; +Z} +Z +Z/* We enable tracing if either the environment variable MALLOC_TRACE +Z is set, or if the variable mallwatch has been patched to an address +Z that the debugging user wants us to stop on. When patching mallwatch, +Z don't forget to set a breakpoint on tr_break! */ +Z +Zvoid +ZDEFUN_VOID(mtrace) +Z{ +Z char *mallfile; +Z +Z mallfile = getenv (mallenv); +Z if (mallfile != NULL || mallwatch != NULL) +Z { +Z mallstream = fopen (mallfile != NULL ? mallfile : "/dev/null", "w"); +Z if (mallstream != NULL) +Z { +Z /* Be sure it doesn't malloc its buffer! */ +Z setbuf (mallstream, mallbuf); +Z fprintf (mallstream, "= Start\n"); +Z old_free_hook = __free_hook; +Z __free_hook = tr_freehook; +Z old_malloc_hook = __malloc_hook; +Z __malloc_hook = tr_mallochook; +Z old_realloc_hook = __realloc_hook; +Z __realloc_hook = tr_reallochook; +Z } +Z } +Z} +STUNKYFLUFF +set `sum mtrace.c` +if test 38600 != $1 +then +echo mtrace.c: Checksum error. Is: $1, should be: 38600. +fi +# +# +echo Extracting realloc.c: +sed 's/^Z//' >realloc.c <<\STUNKYFLUFF +Z/* Change the size of a block allocated by `malloc'. +Z Copyright 1990, 1991 Free Software Foundation +Z Written May 1989 by Mike Haertel. +Z +ZThe GNU C Library is free software; you can redistribute it and/or +Zmodify it under the terms of the GNU Library General Public License as +Zpublished by the Free Software Foundation; either version 2 of the +ZLicense, or (at your option) any later version. +Z +ZThe GNU C Library is distributed in the hope that it will be useful, +Zbut WITHOUT ANY WARRANTY; without even the implied warranty of +ZMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +ZLibrary General Public License for more details. +Z +ZYou should have received a copy of the GNU Library General Public +ZLicense along with the GNU C Library; see the file COPYING.LIB. If +Znot, write to the Free Software Foundation, Inc., 675 Mass Ave, +ZCambridge, MA 02139, USA. +Z +Z The author may be reached (Email) at the address mike@ai.mit.edu, +Z or (US mail) as Mike Haertel c/o Free Software Foundation. */ +Z +Z/* IGNORE(@ */ +Z#include <ansidecl.h> +Z#include <stdlib.h> +Z/* @) */ +Z +Z#if defined(__GNU_LIBRARY__) || defined(STDC_HEADERS) || defined(USG) +Z#include <string.h> +Z#else +Z#define memcpy(d, s, n) bcopy((s), (d), (n)) +Z#endif +Z +Z#define _MALLOC_INTERNAL +Z#include <malloc.h> +Z +Z#define MIN(A, B) ((A) < (B) ? (A) : (B)) +Z +Z/* Debugging hook for realloc. */ +ZPTR EXFUN((*__realloc_hook), (PTR __ptr, size_t __size)); +Z +Z/* Resize the given region to the new size, returning a pointer +Z to the (possibly moved) region. This is optimized for speed; +Z some benchmarks seem to indicate that greater compactness is +Z achieved by unconditionally allocating and copying to a +Z new region. This module has incestuous knowledge of the +Z internals of both free and malloc. */ +ZPTR +ZDEFUN(realloc, (ptr, size), PTR ptr AND size_t size) +Z{ +Z PTR result; +Z int type; +Z size_t block, blocks, oldlimit; +Z +Z if (size == 0) +Z { +Z free(ptr); +Z return malloc(0); +Z } +Z else if (ptr == NULL) +Z return malloc(size); +Z +Z if (__realloc_hook != NULL) +Z return (*__realloc_hook)(ptr, size); +Z +Z block = BLOCK(ptr); +Z +Z type = _heapinfo[block].busy.type; +Z switch (type) +Z { +Z case 0: +Z /* Maybe reallocate a large block to a small fragment. */ +Z if (size <= BLOCKSIZE / 2) +Z { +Z result = malloc(size); +Z if (result != NULL) +Z { +Z memcpy(result, ptr, size); +Z free(ptr); +Z return result; +Z } +Z } +Z +Z /* The new size is a large allocation as well; +Z see if we can hold it in place. */ +Z blocks = BLOCKIFY(size); +Z if (blocks < _heapinfo[block].busy.info.size) +Z { +Z /* The new size is smaller; return +Z excess memory to the free list. */ +Z _heapinfo[block + blocks].busy.type = 0; +Z _heapinfo[block + blocks].busy.info.size +Z = _heapinfo[block].busy.info.size - blocks; +Z _heapinfo[block].busy.info.size = blocks; +Z free(ADDRESS(block + blocks)); +Z result = ptr; +Z } +Z else if (blocks == _heapinfo[block].busy.info.size) +Z /* No size change necessary. */ +Z result = ptr; +Z else +Z { +Z /* Won't fit, so allocate a new region that will. +Z Free the old region first in case there is sufficient +Z adjacent free space to grow without moving. */ +Z blocks = _heapinfo[block].busy.info.size; +Z /* Prevent free from actually returning memory to the system. */ +Z oldlimit = _heaplimit; +Z _heaplimit = 0; +Z free(ptr); +Z _heaplimit = oldlimit; +Z result = malloc(size); +Z if (result == NULL) +Z { +Z (void) malloc(blocks * BLOCKSIZE); +Z return NULL; +Z } +Z if (ptr != result) +Z memmove(result, ptr, blocks * BLOCKSIZE); +Z } +Z break; +Z +Z default: +Z /* Old size is a fragment; type is logarithm +Z to base two of the fragment size. */ +Z if (size > (size_t) (1 << (type - 1)) && size <= (size_t) (1 << type)) +Z /* The new size is the same kind of fragment. */ +Z result = ptr; +Z else +Z { +Z /* The new size is different; allocate a new space, +Z and copy the lesser of the new size and the old. */ +Z result = malloc(size); +Z if (result == NULL) +Z return NULL; +Z memcpy(result, ptr, MIN(size, (size_t) 1 << type)); +Z free(ptr); +Z } +Z break; +Z } +Z +Z return result; +Z} +STUNKYFLUFF +set `sum realloc.c` +if test 3391 != $1 +then +echo realloc.c: Checksum error. Is: $1, should be: 3391. +fi +# +# +echo Extracting valloc.c: +sed 's/^Z//' >valloc.c <<\STUNKYFLUFF +Z/* Allocate memory on a page boundary. +Z Copyright (C) 1991 Free Software Foundation, Inc. +Z +ZThe GNU C Library is free software; you can redistribute it and/or +Zmodify it under the terms of the GNU Library General Public License as +Zpublished by the Free Software Foundation; either version 2 of the +ZLicense, or (at your option) any later version. +Z +ZThe GNU C Library is distributed in the hope that it will be useful, +Zbut WITHOUT ANY WARRANTY; without even the implied warranty of +ZMERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +ZLibrary General Public License for more details. +Z +ZYou should have received a copy of the GNU Library General Public +ZLicense along with the GNU C Library; see the file COPYING.LIB. If +Znot, write to the Free Software Foundation, Inc., 675 Mass Ave, +ZCambridge, MA 02139, USA. */ +Z +Z/* IGNORE(@ */ +Z#include <ansidecl.h> +Z#include <stdlib.h> +Z/* @) */ +Z +Z#include <malloc.h> +Z +Z#ifdef __GNU_LIBRARY__ +Zextern size_t EXFUN(__getpagesize, (NOARGS)); +Z#else +Z#ifndef USG +Zextern size_t EXFUN(getpagesize, (NOARGS)); +Z#define __getpagesize() getpagesize() +Z#else +Z#include <sys/param.h> +Z#ifdef EXEC_PAGESIZE +Z#define __getpagesize() EXEC_PAGESIZE +Z#else /* No EXEC_PAGESIZE. */ +Z#ifdef NBPG +Z#ifndef CLSIZE +Z#define CLSIZE 1 +Z#endif /* No CLSIZE. */ +Z#define __getpagesize() (NBPG * CLSIZE) +Z#else /* No NBPG. */ +Z#define __getpagesize() NBPC +Z#endif /* NBPG. */ +Z#endif /* EXEC_PAGESIZE. */ +Z#endif /* USG. */ +Z#endif +Z +Zstatic size_t pagesize; +Z +ZPTR +ZDEFUN(valloc, (size), size_t size) +Z{ +Z if (pagesize == 0) +Z pagesize = __getpagesize(); +Z +Z return memalign (pagesize, size); +Z} +STUNKYFLUFF +set `sum valloc.c` +if test 63930 != $1 +then +echo valloc.c: Checksum error. Is: $1, should be: 63930. +fi +echo ALL DONE BUNKY! +exit 0 diff --git a/mmalloc/keys.c b/mmalloc/keys.c new file mode 100644 index 0000000..6686cbc --- /dev/null +++ b/mmalloc/keys.c @@ -0,0 +1,64 @@ +/* Access for application keys in mmap'd malloc managed region. + Copyright 1992 Free Software Foundation, Inc. + + Contributed by Fred Fish at Cygnus Support. fnf@cygnus.com + +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 2 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. + +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. */ + + +/* This module provides access to some keys that the application can use to + provide persistent access to locations in the mapped memory section. + The intent is that these keys are to be used sparingly as sort of + persistent global variables which the application can use to reinitialize + access to data in the mapped region. + + For the moment, these keys are simply stored in the malloc descriptor + itself, in an array of fixed length. This should be fixed so that there + can be an unlimited number of keys, possibly using a multilevel access + scheme of some sort. */ + +#include "mmalloc.h" + +int +mmalloc_setkey (md, keynum, key) + PTR md; + int keynum; + PTR key; +{ + struct mdesc *mdp = (struct mdesc *) md; + int result = 0; + + if ((mdp != NULL) && (keynum >= 0) && (keynum < MMALLOC_KEYS)) + { + mdp -> keys [keynum] = key; + result++; + } + return (result); +} + +PTR +mmalloc_getkey (md, keynum) + PTR md; + int keynum; +{ + struct mdesc *mdp = (struct mdesc *) md; + PTR keyval = NULL; + + if ((mdp != NULL) && (keynum >= 0) && (keynum < MMALLOC_KEYS)) + { + keyval = mdp -> keys [keynum]; + } + return (keyval); +} diff --git a/mmalloc/mcalloc.c b/mmalloc/mcalloc.c new file mode 100644 index 0000000..bc269d5 --- /dev/null +++ b/mmalloc/mcalloc.c @@ -0,0 +1,53 @@ +/* Copyright (C) 1991, 1992 Free Software Foundation, Inc. +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., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#include "mmalloc.h" + +/* Allocate an array of NMEMB elements each SIZE bytes long. + The entire array is initialized to zeros. */ + +PTR +mcalloc (md, nmemb, size) + PTR md; + register size_t nmemb; + register size_t size; +{ + register PTR result; + + if ((result = mmalloc (md, nmemb * size)) != NULL) + { + (void) memset (result, 0, nmemb * size); + } + return (result); +} + +/* When using this package, provide a version of malloc/realloc/free built + on top of it, so that if we use the default sbrk() region we will not + collide with another malloc package trying to do the same thing, if + the application contains any "hidden" calls to malloc/realloc/free (such + as inside a system library). + + NOTE: Defining our own copy of this breaks ANSI conformance. */ + +PTR +calloc (nmemb, size) + size_t nmemb; + size_t size; +{ + return (mcalloc ((void *) NULL, nmemb, size)); +} diff --git a/mmalloc/mfree.c b/mmalloc/mfree.c new file mode 100644 index 0000000..163d31e --- /dev/null +++ b/mmalloc/mfree.c @@ -0,0 +1,249 @@ +/* Free a block of memory allocated by `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., 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 "mmalloc.h" + +/* Return memory to the heap. + Like `mfree' but don't call a mfree_hook if there is one. */ + +void +__mmalloc_free (mdp, ptr) + struct mdesc *mdp; + PTR ptr; +{ + int type; + size_t block, blocks; + register size_t i; + struct list *prev, *next; + + block = BLOCK (ptr); + + type = mdp -> heapinfo[block].busy.type; + switch (type) + { + case 0: + /* Get as many statistics as early as we can. */ + mdp -> heapstats.chunks_used--; + mdp -> heapstats.bytes_used -= + mdp -> heapinfo[block].busy.info.size * BLOCKSIZE; + mdp -> heapstats.bytes_free += + mdp -> heapinfo[block].busy.info.size * BLOCKSIZE; + + /* Find the free cluster previous to this one in the free list. + Start searching at the last block referenced; this may benefit + programs with locality of allocation. */ + i = mdp -> heapindex; + if (i > block) + { + while (i > block) + { + i = mdp -> heapinfo[i].free.prev; + } + } + else + { + do + { + i = mdp -> heapinfo[i].free.next; + } + while (i > 0 && i < block); + i = mdp -> heapinfo[i].free.prev; + } + + /* Determine how to link this block into the free list. */ + if (block == i + mdp -> heapinfo[i].free.size) + { + /* Coalesce this block with its predecessor. */ + mdp -> heapinfo[i].free.size += + mdp -> heapinfo[block].busy.info.size; + block = i; + } + else + { + /* Really link this block back into the free list. */ + mdp -> heapinfo[block].free.size = + mdp -> heapinfo[block].busy.info.size; + mdp -> heapinfo[block].free.next = mdp -> heapinfo[i].free.next; + mdp -> heapinfo[block].free.prev = i; + mdp -> heapinfo[i].free.next = block; + mdp -> heapinfo[mdp -> heapinfo[block].free.next].free.prev = block; + mdp -> heapstats.chunks_free++; + } + + /* Now that the block is linked in, see if we can coalesce it + with its successor (by deleting its successor from the list + and adding in its size). */ + if (block + mdp -> heapinfo[block].free.size == + mdp -> heapinfo[block].free.next) + { + mdp -> heapinfo[block].free.size + += mdp -> heapinfo[mdp -> heapinfo[block].free.next].free.size; + mdp -> heapinfo[block].free.next + = mdp -> heapinfo[mdp -> heapinfo[block].free.next].free.next; + mdp -> heapinfo[mdp -> heapinfo[block].free.next].free.prev = block; + mdp -> heapstats.chunks_free--; + } + + /* Now see if we can return stuff to the system. */ + blocks = mdp -> heapinfo[block].free.size; + if (blocks >= FINAL_FREE_BLOCKS && block + blocks == mdp -> heaplimit + && mdp -> morecore (mdp, 0) == ADDRESS (block + blocks)) + { + register size_t bytes = blocks * BLOCKSIZE; + mdp -> heaplimit -= blocks; + mdp -> morecore (mdp, -bytes); + mdp -> heapinfo[mdp -> heapinfo[block].free.prev].free.next + = mdp -> heapinfo[block].free.next; + mdp -> heapinfo[mdp -> heapinfo[block].free.next].free.prev + = mdp -> heapinfo[block].free.prev; + block = mdp -> heapinfo[block].free.prev; + mdp -> heapstats.chunks_free--; + mdp -> heapstats.bytes_free -= bytes; + } + + /* Set the next search to begin at this block. */ + mdp -> heapindex = block; + break; + + default: + /* Do some of the statistics. */ + mdp -> heapstats.chunks_used--; + mdp -> heapstats.bytes_used -= 1 << type; + mdp -> heapstats.chunks_free++; + mdp -> heapstats.bytes_free += 1 << type; + + /* Get the address of the first free fragment in this block. */ + prev = (struct list *) + ((char *) ADDRESS(block) + + (mdp -> heapinfo[block].busy.info.frag.first << type)); + + if (mdp -> heapinfo[block].busy.info.frag.nfree == + (BLOCKSIZE >> type) - 1) + { + /* If all fragments of this block are free, remove them + from the fragment list and free the whole block. */ + next = prev; + for (i = 1; i < (size_t) (BLOCKSIZE >> type); ++i) + { + next = next -> next; + } + prev -> prev -> next = next; + if (next != NULL) + { + next -> prev = prev -> prev; + } + mdp -> heapinfo[block].busy.type = 0; + mdp -> heapinfo[block].busy.info.size = 1; + + /* Keep the statistics accurate. */ + mdp -> heapstats.chunks_used++; + mdp -> heapstats.bytes_used += BLOCKSIZE; + mdp -> heapstats.chunks_free -= BLOCKSIZE >> type; + mdp -> heapstats.bytes_free -= BLOCKSIZE; + + mfree (mdp, ADDRESS(block)); + } + else if (mdp -> heapinfo[block].busy.info.frag.nfree != 0) + { + /* If some fragments of this block are free, link this + fragment into the fragment list after the first free + fragment of this block. */ + next = (struct list *) ptr; + next -> next = prev -> next; + next -> prev = prev; + prev -> next = next; + if (next -> next != NULL) + { + next -> next -> prev = next; + } + ++mdp -> heapinfo[block].busy.info.frag.nfree; + } + else + { + /* No fragments of this block are free, so link this + fragment into the fragment list and announce that + it is the first free fragment of this block. */ + prev = (struct list *) ptr; + mdp -> heapinfo[block].busy.info.frag.nfree = 1; + mdp -> heapinfo[block].busy.info.frag.first = + RESIDUAL (ptr, BLOCKSIZE) >> type; + prev -> next = mdp -> fraghead[type].next; + prev -> prev = &mdp -> fraghead[type]; + prev -> prev -> next = prev; + if (prev -> next != NULL) + { + prev -> next -> prev = prev; + } + } + break; + } +} + +/* Return memory to the heap. */ + +void +mfree (md, ptr) + PTR md; + PTR ptr; +{ + struct mdesc *mdp; + register struct alignlist *l; + + if (ptr != NULL) + { + mdp = MD_TO_MDP (md); + for (l = mdp -> aligned_blocks; l != NULL; l = l -> next) + { + if (l -> aligned == ptr) + { + l -> aligned = NULL; /* Mark the slot in the list as free. */ + ptr = l -> exact; + break; + } + } + if (mdp -> mfree_hook != NULL) + { + (*mdp -> mfree_hook) (md, ptr); + } + else + { + __mmalloc_free (mdp, ptr); + } + } +} + +/* When using this package, provide a version of malloc/realloc/free built + on top of it, so that if we use the default sbrk() region we will not + collide with another malloc package trying to do the same thing, if + the application contains any "hidden" calls to malloc/realloc/free (such + as inside a system library). + + NOTE: Defining our own copy of this breaks ANSI conformance. */ + +void +free (ptr) + PTR ptr; +{ + mfree ((void *) NULL, ptr); +} diff --git a/mmalloc/mmemalign.c b/mmalloc/mmemalign.c new file mode 100644 index 0000000..63350a2 --- /dev/null +++ b/mmalloc/mmemalign.c @@ -0,0 +1,64 @@ +/* Copyright (C) 1991, 1992 Free Software Foundation, Inc. +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., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#include "mmalloc.h" + +PTR +mmemalign (md, alignment, size) + PTR md; + size_t alignment; + size_t size; +{ + PTR result; + unsigned long int adj; + struct alignlist *l; + struct mdesc *mdp; + + size = ((size + alignment - 1) / alignment) * alignment; + + if ((result = mmalloc (md, size)) != NULL) + { + adj = RESIDUAL (result, alignment); + if (adj != 0) + { + mdp = MD_TO_MDP (md); + for (l = mdp -> aligned_blocks; l != NULL; l = l -> next) + { + if (l -> aligned == NULL) + { + /* This slot is free. Use it. */ + break; + } + } + if (l == NULL) + { + l = (struct alignlist *) mmalloc (md, sizeof (struct alignlist)); + if (l == NULL) + { + mfree (md, result); + return (NULL); + } + } + l -> exact = result; + result = l -> aligned = (char *) result + alignment - adj; + l -> next = mdp -> aligned_blocks; + mdp -> aligned_blocks = l; + } + } + return (result); +} diff --git a/mmalloc/mmstats.c b/mmalloc/mmstats.c new file mode 100644 index 0000000..d3846eb2 --- /dev/null +++ b/mmalloc/mmstats.c @@ -0,0 +1,46 @@ +/* Access the statistics maintained by `mmalloc'. + Copyright 1990, 1991, 1992 Free Software Foundation + + Written May 1989 by Mike Haertel. + 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., 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 "mmalloc.h" + +/* FIXME: See the comment in mmalloc.h where struct mstats is defined. + None of the internal mmalloc structures should be externally visible + outside the library. */ + +struct mstats +mmstats (md) + PTR md; +{ + struct mstats result; + struct mdesc *mdp; + + mdp = MD_TO_MDP (md); + result.bytes_total = + (char *) mdp -> morecore (mdp, 0) - mdp -> heapbase; + result.chunks_used = mdp -> heapstats.chunks_used; + result.bytes_used = mdp -> heapstats.bytes_used; + result.chunks_free = mdp -> heapstats.chunks_free; + result.bytes_free = mdp -> heapstats.bytes_free; + return (result); +} diff --git a/mmalloc/mmtrace.awk b/mmalloc/mmtrace.awk new file mode 100644 index 0000000..d7689ce --- /dev/null +++ b/mmalloc/mmtrace.awk @@ -0,0 +1,36 @@ +# +# Awk program to analyze mtrace.c output. +# +$1 == "+" { if (allocated[$2] != "") + print "+", $2, "Alloc", NR, "duplicate:", allocated[$2]; + else + allocated[$2] = $3; + } +$1 == "-" { if (allocated[$2] != "") { + allocated[$2] = ""; + if (allocated[$2] != "") + print "DELETE FAILED", $2, allocated[$2]; + } else + print "-", $2, "Free", NR, "was never alloc'd"; + } +$1 == "<" { if (allocated[$2] != "") + allocated[$2] = ""; + else + print "-", $2, "Realloc", NR, "was never alloc'd"; + } +$1 == ">" { if (allocated[$2] != "") + print "+", $2, "Realloc", NR, "duplicate:", allocated[$2]; + else + allocated[$2] = $3; + } + +# Ignore "= Start" +$1 == "=" { } +# Ignore failed realloc attempts for now +$1 == "!" { } + + +END { for (x in allocated) + if (allocated[x] != "") + print "+", x, allocated[x]; + } diff --git a/mmalloc/mrealloc.c b/mmalloc/mrealloc.c new file mode 100644 index 0000000..83c8996 --- /dev/null +++ b/mmalloc/mrealloc.c @@ -0,0 +1,151 @@ +/* Change the size of a block allocated by `mmalloc'. + Copyright 1990, 1991 Free Software Foundation + Written May 1989 by Mike Haertel. + +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., 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 "mmalloc.h" + +/* Resize the given region to the new size, returning a pointer + to the (possibly moved) region. This is optimized for speed; + some benchmarks seem to indicate that greater compactness is + achieved by unconditionally allocating and copying to a + new region. This module has incestuous knowledge of the + internals of both mfree and mmalloc. */ + +PTR +mrealloc (md, ptr, size) + PTR md; + PTR ptr; + size_t size; +{ + struct mdesc *mdp; + PTR result; + int type; + size_t block, blocks, oldlimit; + + if (size == 0) + { + mfree (md, ptr); + return (mmalloc (md, 0)); + } + else if (ptr == NULL) + return (mmalloc (md, size)); + + mdp = MD_TO_MDP (md); + + if (mdp -> mrealloc_hook != NULL) + { + return ((*mdp -> mrealloc_hook) (md, ptr, size)); + } + + block = BLOCK(ptr); + + type = mdp -> heapinfo[block].busy.type; + switch (type) + { + case 0: + /* Maybe reallocate a large block to a small fragment. */ + if (size <= BLOCKSIZE / 2) + { + result = mmalloc (md, size); + if (result != NULL) + { + memcpy (result, ptr, size); + mfree (md, ptr); + return (result); + } + } + + /* The new size is a large allocation as well; + see if we can hold it in place. */ + blocks = BLOCKIFY(size); + if (blocks < mdp -> heapinfo[block].busy.info.size) + { + /* The new size is smaller; return + excess memory to the free list. */ + mdp -> heapinfo[block + blocks].busy.type = 0; + mdp -> heapinfo[block + blocks].busy.info.size + = mdp -> heapinfo[block].busy.info.size - blocks; + mdp -> heapinfo[block].busy.info.size = blocks; + mfree (md, ADDRESS(block + blocks)); + result = ptr; + } + else if (blocks == mdp -> heapinfo[block].busy.info.size) + /* No size change necessary. */ + result = ptr; + else + { + /* Won't fit, so allocate a new region that will. + Free the old region first in case there is sufficient + adjacent free space to grow without moving. */ + blocks = mdp -> heapinfo[block].busy.info.size; + /* Prevent free from actually returning memory to the system. */ + oldlimit = mdp -> heaplimit; + mdp -> heaplimit = 0; + mfree (md, ptr); + mdp -> heaplimit = oldlimit; + result = mmalloc (md, size); + if (result == NULL) + { + (void) mmalloc (md, blocks * BLOCKSIZE); + return NULL; + } + if (ptr != result) + memmove (result, ptr, blocks * BLOCKSIZE); + } + break; + + default: + /* Old size is a fragment; type is logarithm + to base two of the fragment size. */ + if (size > (size_t) (1 << (type - 1)) && size <= (size_t) (1 << type)) + /* The new size is the same kind of fragment. */ + result = ptr; + else + { + /* The new size is different; allocate a new space, + and copy the lesser of the new size and the old. */ + result = mmalloc (md, size); + if (result == NULL) + return (NULL); + memcpy (result, ptr, MIN(size, (size_t) 1 << type)); + mfree (md, ptr); + } + break; + } + + return (result); +} + +/* When using this package, provide a version of malloc/realloc/free built + on top of it, so that if we use the default sbrk() region we will not + collide with another malloc package trying to do the same thing, if + the application contains any "hidden" calls to malloc/realloc/free (such + as inside a system library). + + NOTE: Defining our own copy of this breaks ANSI conformance. */ + +PTR +realloc (ptr, size) + PTR ptr; + size_t size; +{ + return (mrealloc ((void *) NULL, ptr, size)); +} diff --git a/mmalloc/mvalloc.c b/mmalloc/mvalloc.c new file mode 100644 index 0000000..683bad0 --- /dev/null +++ b/mmalloc/mvalloc.c @@ -0,0 +1,39 @@ +/* Allocate memory on a page boundary. + Copyright (C) 1991 Free Software Foundation, Inc. + +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., 675 Mass Ave, +Cambridge, MA 02139, USA. */ + +#include "mmalloc.h" + +/* Cache the pagesize for the current host machine. Note that if the host + does not readily provide a getpagesize() function, we need to emulate it + elsewhere, not clutter up this file with lots of kluges to try to figure + it out. */ + +static size_t pagesize; + +PTR +mvalloc (md, size) + PTR md; + size_t size; +{ + if (pagesize == 0) + { + pagesize = getpagesize (); + } + + return (mmemalign (md, pagesize, size)); +} |