lostecho/oldlinux-files
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

add directory gnu

Browse Source
This commit is contained in:
gohigh
2024-02-19 00:24:47 -05:00
parent 32616db5a4
commit a40f4cadb0
5086 changed files with 1860970 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
gnu/glibc/glibc-1.03/malloc/ChangeLog Normal file
View File

@@ -0,0 +1,32 @@
Thu Jul 11 18:15:04 1991 Roland McGrath (roland@churchy.gnu.ai.mit.edu)
* Merged with C library version, which now has its own subdir.
* malloc.h, *.c: Use ansideclisms and #ifdefs for portability both
in and out of the C library.
* Makefile: New makefile for malloc subdir in libc.
Has targets to create malloc.tar{,.Z} by ansidecl processing on srcs.
* malloc/Makefile: New file; Makefile for standalone distribution.
* malloc/README: New file; info for same.
Fri Apr 6 00:18:36 1990 Jim Kingdon (kingdon at pogo.ai.mit.edu)
* Makefile: Add comments.
Thu Apr 5 23:08:14 1990 Mike Haertel (mike at albert.ai.mit.edu)
* mcheck.c (mcheck, checkhdr): Support user-supplied abort()
function.
* malloc.h: Declare __free().
* Makefile: New target libmalloc.a.
Thu Apr 5 21:56:03 1990 Jim Kingdon (kingdon at pogo.ai.mit.edu)
* free.c (free): Split into free and __free.
* malloc.c (morecore): Call __free on oldinfo.
Local Variables:
mode: indented-text
left-margin: 8
fill-column: 76
version-control: never
End:

78
gnu/glibc/glibc-1.03/malloc/Makefile Normal file
View File

@@ -0,0 +1,78 @@
# 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.
#
# Makefile for malloc routines
#
subdir := malloc
all:
headers := malloc.h
routines := malloc free cfree realloc calloc morecore \
valloc memalign mcheck mtrace mstats
nodist := cfree
install-lib := libmcheck.a
distribute := mcheck-init.c ChangeLog TODO \
malloc/gmalloc-head.c dist-README dist-Makefile \
mtrace.awk
include ../Rules
$(objpfx)libmcheck.a: $(objpfx)mcheck-init.o
-rm -f $@
ln $< $@
# Make the standalone malloc distribution.
dist-routines := $(filter-out $(nodist),$(routines))
malloc-dist := README COPYING.LIB Makefile ChangeLog \
$(addsuffix .c,$(dist-routines)) $(headers) gmalloc.c \
gmalloc-head.c mtrace.awk
%.uu: %
uuencode $< < $< > $@-tmp
mv $@-tmp $@
%.Z: %
compress -c $< > $@-tmp
mv $@-tmp $@
malloc.tar: $(addprefix malloc/,$(malloc-dist))
tar ch$(verbose)f $@ $^
malloc/%.c: %.c malloc/
$(..)ansidecl -trad $< | indent -stdin -gnu > $@-tmp
mv $@-tmp $@
malloc/%.h: %.h malloc/
$(..)ansidecl -trad $< | indent -stdin -gnu > $@-tmp
mv $@-tmp $@
malloc/Makefile: dist-Makefile
sed -e 's,<DIST-SOURCES>,$(addsuffix .c,$(dist-routines)),' \
-e 's,<DIST-OBJECTS>,$(addsuffix .o,$(dist-routines)),' \
-e 's,<DIST-HEADERS>,$(headers),' < $< > $@-tmp
mv $@-tmp $@
malloc/gmalloc.c: malloc/Makefile \
$(addprefix malloc/,$(headers) \
$(addsuffix .c,$(dist-routines)))
$(MAKE) -C malloc gmalloc.c
malloc/README: dist-README
@rm -f $@
cp $< $@
malloc/%: %
@rm -f $@
cp $< $@

20
gnu/glibc/glibc-1.03/malloc/TODO Normal file
View File

@@ -0,0 +1,20 @@
0. Access data structures with accessor macros, then turn the heapinfo
into several arrays for faster access on machines with addressing modes.
Also, this eventually raises the possibility of maintaining multiple
heaps.
1. Possible heuristic to catch multiple frees. Introduce an extra word
of heapinfo that says whether the remaining info is for something
busy or something free. Then we can catch attempts to free already-free
large blocks, as well as things not belonging to malloc at all. In the
case of a fragment, we can check if the fragment looks like it *already*
belongs to the fragment list, by comparing it with the "first" fragment
of the block, or checking its "prev" pointer to see if it points into
the block. Then if it looks like it might we can exhaustively search
the block's free list to see if the fragment is there or not. Extending
the heapinfo structure would have the benefit of making it a power of
two and thus making array indexing faster, perhaps. Suitably adapted,
this heuristic could also catch invalid pointers passed to realloc.
All of these additional features require the inclusion of <malloc.h>.
3. indirect reference allocator: ialloc(), ifree(), irealloc().
4. garbage collecting allocator: galloc(), garbage(), gfree(), grealloc().

41
gnu/glibc/glibc-1.03/malloc/calloc.c Normal file
View File

@@ -0,0 +1,41 @@
/* Copyright (C) 1991 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. */
/* IGNORE(@ */
#include <ansidecl.h>
/* @) */
#include <malloc.h>
#if defined(__GNU_LIBRARY__) || defined(STDC_HEADERS) || defined(USG)
#include <string.h>
#else
#define memset(s, zero, n) bzero ((s), (n))
#endif
/* Allocate an array of NMEMB elements each SIZE bytes long.
The entire array is initialized to zeros. */
PTR
DEFUN(calloc, (nmemb, size), register size_t nmemb AND register size_t size)
{
register PTR result = malloc (nmemb * size);
if (result != NULL)
(void) memset (result, 0, nmemb * size);
return result;
}

27
gnu/glibc/glibc-1.03/malloc/cfree.c Normal file
View File

@@ -0,0 +1,27 @@
/* Copyright (C) 1991 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 <ansidecl.h>
#include <stdlib.h>
#undef cfree
#include <gnu-stabs.h>
function_alias(cfree, free, void, (ptr),
DEFUN(cfree, (ptr), PTR ptr))

51
gnu/glibc/glibc-1.03/malloc/dist-Makefile Normal file
View File

@@ -0,0 +1,51 @@
# Copyright (C) 1991 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.
# Makefile for standalone distribution of malloc.
# Use this on System V.
#CPPFLAGS = -DUSG
.PHONY: all
all: libmalloc.a gmalloc.o
sources = <DIST-SOURCES>
objects = <DIST-OBJECTS>
headers = <DIST-HEADERS>
libmalloc.a: $(objects)
ar crv $@ $(objects)
ranlib $@
$(objects): $(headers)
gmalloc.c: gmalloc-head.c $(headers) $(sources)
cat gmalloc-head.c $(headers) $(sources) > $@
.c.o:
$(CC) $(CFLAGS) $(CPPFLAGS) -I. -c $< $(OUTPUT_OPTION)
.PHONY: clean realclean malloc-clean malloc-realclean
clean malloc-clean:
-rm -f libmalloc.a *.o core
realclean malloc-realclean: clean
-rm -f TAGS tags *~
# For inside the C library.
malloc.tar malloc.tar.Z:
$(MAKE) -C .. $@

12
gnu/glibc/glibc-1.03/malloc/dist-README Normal file
View File

@@ -0,0 +1,12 @@
This is the standalone distribution of GNU malloc.
GNU malloc is part of the GNU C Library, but is also distributed separately.
If you find bugs in GNU malloc, send reports to bug-glibc@prep.ai.mit.edu.
GNU malloc is free software. See the file COPYING.LIB for copying conditions.
The makefile builds libmalloc.a and gmalloc.o. If you are using GNU malloc
to replace your system's existing malloc package, it is important to make
sure you get all GNU functions, not some of the GNU functions and some from
the system library. gmalloc.o has all the functions in one file, so using
that will make sure you don't accidentally mix the two malloc packages.

212
gnu/glibc/glibc-1.03/malloc/free.c Normal file
View File

@@ -0,0 +1,212 @@
/* Free a block of memory allocated by `malloc'.
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. */
/* IGNORE(@ */
#include <ansidecl.h>
#include <stddef.h>
#include <stdlib.h>
/* @) */
#define _MALLOC_INTERNAL
#include <malloc.h>
/* Debugging hook for free. */
void EXFUN((*__free_hook), (PTR __ptr));
/* List of blocks allocated by memalign. */
struct alignlist *_aligned_blocks = NULL;
/* Return memory to the heap.
Like `free' but don't call a __free_hook if there is one. */
void
DEFUN(__free, (ptr), PTR ptr)
{
int type;
size_t block, blocks;
register size_t i;
struct list *prev, *next;
block = BLOCK(ptr);
type = _heapinfo[block].busy.type;
switch (type)
{
case 0:
/* Get as many statistics as early as we can. */
--_chunks_used;
_bytes_used -= _heapinfo[block].busy.info.size * BLOCKSIZE;
_bytes_free += _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 = _heapindex;
if (i > block)
while (i > block)
i = _heapinfo[i].free.prev;
else
{
do
i = _heapinfo[i].free.next;
while (i > 0 && i < block);
i = _heapinfo[i].free.prev;
}
/* Determine how to link this block into the free list. */
if (block == i + _heapinfo[i].free.size)
{
/* Coalesce this block with its predecessor. */
_heapinfo[i].free.size += _heapinfo[block].busy.info.size;
block = i;
}
else
{
/* Really link this block back into the free list. */
_heapinfo[block].free.size = _heapinfo[block].busy.info.size;
_heapinfo[block].free.next = _heapinfo[i].free.next;
_heapinfo[block].free.prev = i;
_heapinfo[i].free.next = block;
_heapinfo[_heapinfo[block].free.next].free.prev = block;
++_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 + _heapinfo[block].free.size == _heapinfo[block].free.next)
{
_heapinfo[block].free.size
+= _heapinfo[_heapinfo[block].free.next].free.size;
_heapinfo[block].free.next
= _heapinfo[_heapinfo[block].free.next].free.next;
_heapinfo[_heapinfo[block].free.next].free.prev = block;
--_chunks_free;
}
/* Now see if we can return stuff to the system. */
blocks = _heapinfo[block].free.size;
if (blocks >= FINAL_FREE_BLOCKS && block + blocks == _heaplimit
&& (*__morecore)(0) == ADDRESS(block + blocks))
{
register size_t bytes = blocks * BLOCKSIZE;
_heaplimit -= blocks;
(*__morecore)(- bytes);
_heapinfo[_heapinfo[block].free.prev].free.next
= _heapinfo[block].free.next;
_heapinfo[_heapinfo[block].free.next].free.prev
= _heapinfo[block].free.prev;
block = _heapinfo[block].free.prev;
--_chunks_free;
_bytes_free -= bytes;
}
/* Set the next search to begin at this block. */
_heapindex = block;
break;
default:
/* Do some of the statistics. */
--_chunks_used;
_bytes_used -= 1 << type;
++_chunks_free;
_bytes_free += 1 << type;
/* Get the address of the first free fragment in this block. */
prev = (struct list *) ((char *) ADDRESS(block) +
(_heapinfo[block].busy.info.frag.first << type));
if (_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;
_heapinfo[block].busy.type = 0;
_heapinfo[block].busy.info.size = 1;
/* Keep the statistics accurate. */
++_chunks_used;
_bytes_used += BLOCKSIZE;
_chunks_free -= BLOCKSIZE >> type;
_bytes_free -= BLOCKSIZE;
free(ADDRESS(block));
}
else if (_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;
++_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;
_heapinfo[block].busy.info.frag.nfree = 1;
_heapinfo[block].busy.info.frag.first = (unsigned long int)
((unsigned long int) ((char *) ptr - (char *) NULL)
% BLOCKSIZE >> type);
prev->next = _fraghead[type].next;
prev->prev = &_fraghead[type];
prev->prev->next = prev;
if (prev->next != NULL)
prev->next->prev = prev;
}
break;
}
}
/* Return memory to the heap. */
void
DEFUN(free, (ptr), PTR ptr)
{
register struct alignlist *l;
if (ptr == NULL)
return;
for (l = _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 (__free_hook != NULL)
(*__free_hook) (ptr);
else
__free (ptr);
}

309
gnu/glibc/glibc-1.03/malloc/malloc.c Normal file
View File

@@ -0,0 +1,309 @@
/* Memory allocator `malloc'.
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. */
/* IGNORE(@ */
#include <ansidecl.h>
#include <stddef.h>
#include <stdlib.h>
/* @) */
#define _MALLOC_INTERNAL
#include <malloc.h>
#if defined(__GNU_LIBRARY__) || defined(STDC_HEADERS) || defined(USG)
#include <string.h>
#else
#define memset(s, zero, n) bzero ((s), (n))
#define memcpy(d, s, n) bcopy ((s), (d), (n))
#endif
/* How to really get more memory. */
PTR EXFUN((*__morecore), (ptrdiff_t __size)) = __default_morecore;
/* Debugging hook for `malloc'. */
PTR EXFUN((*__malloc_hook), (size_t __size));
/* Pointer to the base of the first block. */
char *_heapbase;
/* Block information table. Allocated with align/__free (not malloc/free). */
malloc_info *_heapinfo;
/* Number of info entries. */
static size_t heapsize;
/* Search index in the info table. */
size_t _heapindex;
/* Limit of valid info table indices. */
size_t _heaplimit;
/* Free lists for each fragment size. */
struct list _fraghead[BLOCKLOG];
/* Instrumentation. */
size_t _chunks_used;
size_t _bytes_used;
size_t _chunks_free;
size_t _bytes_free;
/* Are you experienced? */
int __malloc_initialized;
/* Aligned allocation. */
static PTR
DEFUN(align, (size), size_t size)
{
PTR result;
unsigned long int adj;
result = (*__morecore)(size);
adj = (unsigned long int) ((unsigned long int) ((char *) result -
(char *) NULL)) % BLOCKSIZE;
if (adj != 0)
{
adj = BLOCKSIZE - adj;
(void) (*__morecore)(adj);
result = (char *) result + adj;
}
return result;
}
/* Set everything up and remember that we have. */
static int
DEFUN_VOID(initialize)
{
heapsize = HEAP / BLOCKSIZE;
_heapinfo = (malloc_info *) align(heapsize * sizeof(malloc_info));
if (_heapinfo == NULL)
return 0;
memset(_heapinfo, 0, heapsize * sizeof(malloc_info));
_heapinfo[0].free.size = 0;
_heapinfo[0].free.next = _heapinfo[0].free.prev = 0;
_heapindex = 0;
_heapbase = (char *) _heapinfo;
__malloc_initialized = 1;
return 1;
}
/* Get neatly aligned memory, initializing or
growing the heap info table as necessary. */
static PTR
DEFUN(morecore, (size), size_t size)
{
PTR result;
malloc_info *newinfo, *oldinfo;
size_t newsize;
result = align(size);
if (result == NULL)
return NULL;
/* Check if we need to grow the info table. */
if ((size_t) BLOCK((char *) result + size) > heapsize)
{
newsize = heapsize;
while ((size_t) BLOCK((char *) result + size) > newsize)
newsize *= 2;
newinfo = (malloc_info *) align(newsize * sizeof(malloc_info));
if (newinfo == NULL)
{
(*__morecore)(- size);
return NULL;
}
memset(newinfo, 0, newsize * sizeof(malloc_info));
memcpy(newinfo, _heapinfo, heapsize * sizeof(malloc_info));
oldinfo = _heapinfo;
newinfo[BLOCK(oldinfo)].busy.type = 0;
newinfo[BLOCK(oldinfo)].busy.info.size
= BLOCKIFY(heapsize * sizeof(malloc_info));
_heapinfo = newinfo;
__free(oldinfo);
heapsize = newsize;
}
_heaplimit = BLOCK((char *) result + size);
return result;
}
/* Allocate memory from the heap. */
PTR
DEFUN(malloc, (size), size_t size)
{
PTR result;
size_t block, blocks, lastblocks, start;
register size_t i;
struct list *next;
if (size == 0)
return NULL;
if (__malloc_hook != NULL)
return (*__malloc_hook)(size);
if (!__malloc_initialized)
if (!initialize())
return NULL;
if (size < sizeof(struct list))
size = sizeof(struct list);
/* Determine the allocation policy based on the request size. */
if (size <= BLOCKSIZE / 2)
{
/* Small allocation to receive a fragment of a block.
Determine the logarithm to base two of the fragment size. */
register size_t log = 1;
--size;
while ((size /= 2) != 0)
++log;
/* Look in the fragment lists for a
free fragment of the desired size. */
next = _fraghead[log].next;
if (next != NULL)
{
/* There are free fragments of this size.
Pop a fragment out of the fragment list and return it.
Update the block's nfree and first counters. */
result = (PTR) next;
next->prev->next = next->next;
if (next->next != NULL)
next->next->prev = next->prev;
block = BLOCK(result);
if (--_heapinfo[block].busy.info.frag.nfree != 0)
_heapinfo[block].busy.info.frag.first = (unsigned long int)
((unsigned long int) ((char *) next->next - (char *) NULL)
% BLOCKSIZE) >> log;
/* Update the statistics. */
++_chunks_used;
_bytes_used += 1 << log;
--_chunks_free;
_bytes_free -= 1 << log;
}
else
{
/* No free fragments of the desired size, so get a new block
and break it into fragments, returning the first. */
result = malloc(BLOCKSIZE);
if (result == NULL)
return NULL;
/* Link all fragments but the first into the free list. */
for (i = 1; i < (size_t) (BLOCKSIZE >> log); ++i)
{
next = (struct list *) ((char *) result + (i << log));
next->next = _fraghead[log].next;
next->prev = &_fraghead[log];
next->prev->next = next;
if (next->next != NULL)
next->next->prev = next;
}
/* Initialize the nfree and first counters for this block. */
block = BLOCK(result);
_heapinfo[block].busy.type = log;
_heapinfo[block].busy.info.frag.nfree = i - 1;
_heapinfo[block].busy.info.frag.first = i - 1;
_chunks_free += (BLOCKSIZE >> log) - 1;
_bytes_free += BLOCKSIZE - (1 << log);
_bytes_used -= BLOCKSIZE - (1 << log);
}
}
else
{
/* Large allocation to receive one or more blocks.
Search the free list in a circle starting at the last place visited.
If we loop completely around without finding a large enough
space we will have to get more memory from the system. */
blocks = BLOCKIFY(size);
start = block = MALLOC_SEARCH_START;
while (_heapinfo[block].free.size < blocks)
{
block = _heapinfo[block].free.next;
if (block == start)
{
/* Need to get more from the system. Check to see if
the new core will be contiguous with the final free
block; if so we don't need to get as much. */
block = _heapinfo[0].free.prev;
lastblocks = _heapinfo[block].free.size;
if (_heaplimit != 0 && block + lastblocks == _heaplimit &&
(*__morecore)(0) == ADDRESS(block + lastblocks) &&
(morecore((blocks - lastblocks) * BLOCKSIZE)) != NULL)
{
_heapinfo[block].free.size = blocks;
_bytes_free += (blocks - lastblocks) * BLOCKSIZE;
continue;
}
result = morecore(blocks * BLOCKSIZE);
if (result == NULL)
return NULL;
block = BLOCK(result);
_heapinfo[block].busy.type = 0;
_heapinfo[block].busy.info.size = blocks;
++_chunks_used;
_bytes_used += blocks * BLOCKSIZE;
return result;
}
}
/* At this point we have found a suitable free list entry.
Figure out how to remove what we need from the list. */
result = ADDRESS(block);
if (_heapinfo[block].free.size > blocks)
{
/* The block we found has a bit left over,
so relink the tail end back into the free list. */
_heapinfo[block + blocks].free.size
= _heapinfo[block].free.size - blocks;
_heapinfo[block + blocks].free.next
= _heapinfo[block].free.next;
_heapinfo[block + blocks].free.prev
= _heapinfo[block].free.prev;
_heapinfo[_heapinfo[block].free.prev].free.next
= _heapinfo[_heapinfo[block].free.next].free.prev
= _heapindex = block + blocks;
}
else
{
/* The block exactly matches our requirements,
so just remove it from the list. */
_heapinfo[_heapinfo[block].free.next].free.prev
= _heapinfo[block].free.prev;
_heapinfo[_heapinfo[block].free.prev].free.next
= _heapindex = _heapinfo[block].free.next;
--_chunks_free;
}
_heapinfo[block].busy.type = 0;
_heapinfo[block].busy.info.size = blocks;
++_chunks_used;
_bytes_used += blocks * BLOCKSIZE;
_bytes_free -= blocks * BLOCKSIZE;
}
return result;
}

205
gnu/glibc/glibc-1.03/malloc/malloc.h Normal file
View File

@@ -0,0 +1,205 @@
/* Declarations for `malloc' and friends.
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. */
#ifndef _MALLOC_H
#define _MALLOC_H 1
/* IGNORE(@ */
#include <features.h>
#define __need_NULL
#define __need_size_t
#define __need_ptrdiff_t
#include <stddef.h>
/* @) */
#ifndef NULL
#define NULL 0
#endif
#ifdef __STDC__
#include <stddef.h>
#else
#undef size_t
#define size_t unsigned int
#endif
/* Allocate SIZE bytes of memory. */
extern PTR EXFUN(malloc, (size_t __size));
/* Re-allocate the previously allocated block
in PTR, making the new block SIZE bytes long. */
extern PTR EXFUN(realloc, (PTR __ptr, size_t __size));
/* Allocate NMEMB elements of SIZE bytes each, all initialized to 0. */
extern PTR EXFUN(calloc, (size_t __nmemb, size_t __size));
/* Free a block allocated by `malloc', `realloc' or `calloc'. */
extern void EXFUN(free, (PTR __ptr));
/* Allocate SIZE bytes allocated to ALIGNMENT bytes. */
extern PTR EXFUN(memalign, (size_t __alignment, size_t __size));
/* Allocate SIZE bytes on a page boundary. */
extern PTR EXFUN(valloc, (size_t __size));
#ifdef _MALLOC_INTERNAL
#if defined(__GNU_LIBRARY__) || defined(__STDC__)
#include <limits.h>
#else
#define CHAR_BIT 8
#endif
/* The allocator divides the heap into blocks of fixed size; large
requests receive one or more whole blocks, and small requests
receive a fragment of a block. Fragment sizes are powers of two,
and all fragments of a block are the same size. When all the
fragments in a block have been freed, the block itself is freed. */
#define INT_BIT (CHAR_BIT * sizeof(int))
#define BLOCKLOG (INT_BIT > 16 ? 12 : 9)
#define BLOCKSIZE (1 << BLOCKLOG)
#define BLOCKIFY(SIZE) (((SIZE) + BLOCKSIZE - 1) / BLOCKSIZE)
/* Determine the amount of memory spanned by the initial heap table
(not an absolute limit). */
#define HEAP (INT_BIT > 16 ? 4194304 : 65536)
/* Number of contiguous free blocks allowed to build up at the end of
memory before they will be returned to the system. */
#define FINAL_FREE_BLOCKS 8
/* Where to start searching the free list when looking for new memory.
The two possible values are 0 and _heapindex. Starting at 0 seems
to reduce total memory usage, while starting at _heapindex seems to
run faster. */
#define MALLOC_SEARCH_START _heapindex
/* Data structure giving per-block information. */
typedef union
{
/* Heap information for a busy block. */
struct
{
/* Zero for a large block, or positive giving the
logarithm to the base two of the fragment size. */
int type;
union
{
struct
{
size_t nfree; /* Free fragments in a fragmented block. */
size_t first; /* First free fragment of the block. */
} frag;
/* Size (in blocks) of a large cluster. */
size_t size;
} info;
} busy;
/* Heap information for a free block (that may be the first of
a free cluster). */
struct
{
size_t size; /* Size (in blocks) of a free cluster. */
size_t next; /* Index of next free cluster. */
size_t prev; /* Index of previous free cluster. */
} free;
} malloc_info;
/* Pointer to first block of the heap. */
extern char *_heapbase;
/* Table indexed by block number giving per-block information. */
extern malloc_info *_heapinfo;
/* Address to block number and vice versa. */
#define BLOCK(A) (((char *) (A) - _heapbase) / BLOCKSIZE + 1)
/* The following line MUST be split! m4 will not process it otherwise. */
#define ADDRESS(B) \
((PTR) (((B) - 1) * BLOCKSIZE + _heapbase))
/* Current search index for the heap table. */
extern size_t _heapindex;
/* Limit of valid info table indices. */
extern size_t _heaplimit;
/* Doubly linked lists of free fragments. */
struct list
{
struct list *next;
struct list *prev;
};
/* Free list headers for each fragment size. */
extern struct list _fraghead[];
/* List of blocks allocated with `memalign' (or `valloc'). */
struct alignlist
{
struct alignlist *next;
PTR aligned; /* The address that memaligned returned. */
PTR exact; /* The address that malloc returned. */
};
extern struct alignlist *_aligned_blocks;
/* Instrumentation. */
extern size_t _chunks_used;
extern size_t _bytes_used;
extern size_t _chunks_free;
extern size_t _bytes_free;
/* Internal version of `free' used in `morecore'. */
extern void EXFUN(__free, (PTR __ptr));
#endif /* _MALLOC_INTERNAL. */
/* Underlying allocation function; successive calls should
return contiguous pieces of memory. */
extern PTR EXFUN((*__morecore), (ptrdiff_t __size));
/* Default value of `__morecore'. */
extern PTR EXFUN(__default_morecore, (ptrdiff_t __size));
/* Nonzero if `malloc' has been called and done its initialization. */
extern int __malloc_initialized;
/* Hooks for debugging versions. */
extern void EXFUN((*__free_hook), (PTR __ptr));
extern PTR EXFUN((*__malloc_hook), (size_t __size));
extern PTR EXFUN((*__realloc_hook), (PTR __ptr, size_t __size));
/* Activate a standard collection of debugging hooks. */
extern void EXFUN(mcheck, (void EXFUN((*__func), (void))));
/* Statistics available to the user. */
struct mstats
{
size_t bytes_total; /* Total size of the heap. */
size_t chunks_used; /* Chunks allocated by the user. */
size_t bytes_used; /* Byte total of user-allocated chunks. */
size_t chunks_free; /* Chunks in the free list. */
size_t bytes_free; /* Byte total of chunks in the free list. */
};
/* Pick up the current statistics. */
extern struct mstats EXFUN(mstats, (NOARGS));
#endif /* malloc.h */

15
gnu/glibc/glibc-1.03/malloc/malloc/gmalloc-head.c Normal file
View File

@@ -0,0 +1,15 @@
/* DO NOT EDIT THIS FILE -- it is automagically generated. -*- C -*- */
#define SKELETON
#if defined(__GNU_LIBRARY__) || defined(STDC_HEADERS) || defined(USG)
#include <string.h>
#else
#define memset(s, zero, n) bzero ((s), (n))
#define memcpy(d, s, n) bcopy ((s), (d), (n))
#define memmove(d, s, n) bcopy ((s), (d), (n))
#endif
#define _MALLOC_INTERNAL
/* The malloc headers and source files from the C library follow here. */

36
gnu/glibc/glibc-1.03/malloc/mcheck-init.c Normal file
View File

@@ -0,0 +1,36 @@
/* Copyright (C) 1991 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. */
/* The object of this file should be installed as libmcheck.a,
so one can do -lmcheck to turn on mcheck. */
#ifdef HAVE_GNU_LD
#include <ansidecl.h>
#include <malloc.h>
#include <gnu-stabs.h>
static void
DEFUN_VOID (turn_on_mcheck)
{
mcheck (NULL);
}
text_set_element (__libc_subinit, turn_on_mcheck);
#endif

124
gnu/glibc/glibc-1.03/malloc/mcheck.c Normal file
View File

@@ -0,0 +1,124 @@
/* Standard debugging hooks for `malloc'.
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. */
/* IGNORE(@ */
#include <ansidecl.h>
#include <stdlib.h>
/* @) */
#include <malloc.h>
/* Old hook values. */
static void EXFUN((*old_free_hook), (PTR ptr));
static PTR EXFUN((*old_malloc_hook), (size_t size));
static PTR EXFUN((*old_realloc_hook), (PTR ptr, size_t size));
/* Function to call when something awful happens. */
extern void EXFUN(abort, (NOARGS));
static void EXFUN((*abortfunc), (NOARGS)) = (void EXFUN((*), (NOARGS))) abort;
/* Arbitrary magical numbers. */
#define MAGICWORD 0xfedabeeb
#define MAGICBYTE ((char) 0xd7)
struct hdr
{
size_t size; /* Exact size requested by user. */
unsigned long int magic; /* Magic number to check header integrity. */
};
static void
DEFUN(checkhdr, (hdr), CONST struct hdr *hdr)
{
if (hdr->magic != MAGICWORD || ((char *) &hdr[1])[hdr->size] != MAGICBYTE)
(*abortfunc)();
}
static void
DEFUN(freehook, (ptr), PTR ptr)
{
struct hdr *hdr = ((struct hdr *) ptr) - 1;
checkhdr(hdr);
hdr->magic = 0;
__free_hook = old_free_hook;
free(hdr);
__free_hook = freehook;
}
static PTR
DEFUN(mallochook, (size), size_t size)
{
struct hdr *hdr;
__malloc_hook = old_malloc_hook;
hdr = (struct hdr *) malloc (sizeof(struct hdr) + size + 1);
__malloc_hook = mallochook;
if (hdr == NULL)
return NULL;
hdr->size = size;
hdr->magic = MAGICWORD;
((char *) &hdr[1])[size] = MAGICBYTE;
return (PTR) (hdr + 1);
}
static PTR
DEFUN(reallochook, (ptr, size), PTR ptr AND size_t size)
{
struct hdr *hdr = ((struct hdr *) ptr) - 1;
checkhdr(hdr);
__free_hook = old_free_hook;
__malloc_hook = old_malloc_hook;
__realloc_hook = old_realloc_hook;
hdr = (struct hdr *) realloc((PTR) hdr, sizeof(struct hdr) + size + 1);
__free_hook = freehook;
__malloc_hook = mallochook;
__realloc_hook = reallochook;
if (hdr == NULL)
return NULL;
hdr->size = size;
((char *) &hdr[1])[size] = MAGICBYTE;
return (PTR) (hdr + 1);
}
void
DEFUN(mcheck, (func), void EXFUN((*func), (void)))
{
static int mcheck_used = 0;
if (func != NULL)
abortfunc = func;
/* These hooks may not be safely inserted if malloc is already in use. */
if (!__malloc_initialized && !mcheck_used)
{
old_free_hook = __free_hook;
__free_hook = freehook;
old_malloc_hook = __malloc_hook;
__malloc_hook = mallochook;
old_realloc_hook = __realloc_hook;
__realloc_hook = reallochook;
mcheck_used = 1;
}
}

64
gnu/glibc/glibc-1.03/malloc/memalign.c Normal file
View File

@@ -0,0 +1,64 @@
/* Copyright (C) 1991 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. */
/* IGNORE(@ */
#include <ansidecl.h>
#include <stdlib.h>
/* @) */
#define _MALLOC_INTERNAL
#include <malloc.h>
PTR
DEFUN(memalign, (alignment, size),
size_t alignment AND size_t size)
{
PTR result;
unsigned long int adj;
size = ((size + alignment - 1) / alignment) * alignment;
result = malloc (size);
if (result == NULL)
return NULL;
adj = (unsigned long int) ((unsigned long int) ((char *) result -
(char *) NULL)) % alignment;
if (adj != 0)
{
struct alignlist *l;
for (l = _aligned_blocks; l != NULL; l = l->next)
if (l->aligned == NULL)
/* This slot is free. Use it. */
break;
if (l == NULL)
{
l = (struct alignlist *) malloc (sizeof (struct alignlist));
if (l == NULL)
{
free (result);
return NULL;
}
}
l->exact = result;
result = l->aligned = (char *) result + alignment - adj;
l->next = _aligned_blocks;
_aligned_blocks = l;
}
return result;
}

41
gnu/glibc/glibc-1.03/malloc/mstats.c Normal file
View File

@@ -0,0 +1,41 @@
/* Access the statistics maintained by `malloc'.
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. */
/* IGNORE(@ */
#include <ansidecl.h>
/* @) */
#define _MALLOC_INTERNAL
#include <malloc.h>
struct mstats
DEFUN_VOID(mstats)
{
struct mstats result;
result.bytes_total = (char *) (*__morecore)(0) - _heapbase;
result.chunks_used = _chunks_used;
result.bytes_used = _bytes_used;
result.chunks_free = _chunks_free;
result.bytes_free = _bytes_free;
return result;
}

36
gnu/glibc/glibc-1.03/malloc/mtrace.awk Normal file
View File

@@ -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];
}

137
gnu/glibc/glibc-1.03/malloc/mtrace.c Normal file
View File

@@ -0,0 +1,137 @@
/* More debugging hooks for `malloc'.
Copyright 1991 Free Software Foundation
Written April 2, 1991 by John Gilmore of Cygnus Support
Based on mcheck.c by Mike Haertel.
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. */
/* IGNORE(@ */
#include <ansidecl.h>
#include <stdlib.h>
/* @) */
#include <stdio.h>
#include <malloc.h>
#ifndef __GNU_LIBRARY__
extern char *getenv ();
#endif
static FILE *mallstream;
static char mallenv[] = "MALLOC_TRACE";
static char mallbuf[BUFSIZ]; /* Buffer for the output. */
/* Address to breakpoint on accesses to... */
PTR mallwatch;
/* Old hook values. */
static void EXFUN((*old_free_hook), (PTR ptr));
static PTR EXFUN((*old_malloc_hook), (size_t size));
static PTR EXFUN((*old_realloc_hook), (PTR ptr, size_t size));
/* This function is called when the block being alloc'd, realloc'd, or
freed has an address matching the variable "mallwatch". In a debugger,
set "mallwatch" to the address of interest, then put a breakpoint on
tr_break. */
void
DEFUN_VOID(tr_break)
{
}
static void
DEFUN(tr_freehook, (ptr), PTR ptr)
{
fprintf(mallstream, "- %p\n", ptr); /* Be sure to print it first. */
if (ptr == mallwatch)
tr_break ();
__free_hook = old_free_hook;
free (ptr);
__free_hook = tr_freehook;
}
static PTR
DEFUN(tr_mallochook, (size), size_t size)
{
PTR hdr;
__malloc_hook = old_malloc_hook;
hdr = (PTR) malloc (size);
__malloc_hook = tr_mallochook;
/* We could be printing a NULL here; that's OK. */
fprintf (mallstream, "+ %p %x\n", hdr, size);
if (hdr == mallwatch)
tr_break ();
return hdr;
}
static PTR
DEFUN(tr_reallochook, (ptr, size), PTR ptr AND size_t size)
{
PTR hdr;
if (ptr == mallwatch)
tr_break ();
__free_hook = old_free_hook;
__malloc_hook = old_malloc_hook;
__realloc_hook = old_realloc_hook;
hdr = (PTR) realloc (ptr, size);
__free_hook = tr_freehook;
__malloc_hook = tr_mallochook;
__realloc_hook = tr_reallochook;
if (hdr == NULL)
/* Failed realloc. */
fprintf (mallstream, "! %p %x\n", ptr, size);
else
fprintf (mallstream, "< %p\n> %p %x\n", ptr, hdr, size);
if (hdr == mallwatch)
tr_break ();
return hdr;
}
/* We enable tracing if either the environment variable MALLOC_TRACE
is set, or if the variable mallwatch has been patched to an address
that the debugging user wants us to stop on. When patching mallwatch,
don't forget to set a breakpoint on tr_break! */
void
DEFUN_VOID(mtrace)
{
char *mallfile;
mallfile = getenv (mallenv);
if (mallfile != NULL || mallwatch != NULL)
{
mallstream = fopen (mallfile != NULL ? mallfile : "/dev/null", "w");
if (mallstream != NULL)
{
/* Be sure it doesn't malloc its buffer! */
setbuf (mallstream, mallbuf);
fprintf (mallstream, "= Start\n");
old_free_hook = __free_hook;
__free_hook = tr_freehook;
old_malloc_hook = __malloc_hook;
__malloc_hook = tr_mallochook;
old_realloc_hook = __realloc_hook;
__realloc_hook = tr_reallochook;
}
}
}

143
gnu/glibc/glibc-1.03/malloc/realloc.c Normal file
View File

@@ -0,0 +1,143 @@
/* Change the size of a block allocated by `malloc'.
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. */
/* IGNORE(@ */
#include <ansidecl.h>
#include <stdlib.h>
/* @) */
#if defined(__GNU_LIBRARY__) || defined(STDC_HEADERS) || defined(USG)
#include <string.h>
#else
#define memcpy(d, s, n) bcopy((s), (d), (n))
#endif
#define _MALLOC_INTERNAL
#include <malloc.h>
#define MIN(A, B) ((A) < (B) ? (A) : (B))
/* Debugging hook for realloc. */
PTR EXFUN((*__realloc_hook), (PTR __ptr, size_t __size));
/* 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 free and malloc. */
PTR
DEFUN(realloc, (ptr, size), PTR ptr AND size_t size)
{
PTR result;
int type;
size_t block, blocks, oldlimit;
if (size == 0)
{
free(ptr);
return malloc(0);
}
else if (ptr == NULL)
return malloc(size);
if (__realloc_hook != NULL)
return (*__realloc_hook)(ptr, size);
block = BLOCK(ptr);
type = _heapinfo[block].busy.type;
switch (type)
{
case 0:
/* Maybe reallocate a large block to a small fragment. */
if (size <= BLOCKSIZE / 2)
{
result = malloc(size);
if (result != NULL)
{
memcpy(result, ptr, size);
free(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 < _heapinfo[block].busy.info.size)
{
/* The new size is smaller; return
excess memory to the free list. */
_heapinfo[block + blocks].busy.type = 0;
_heapinfo[block + blocks].busy.info.size
= _heapinfo[block].busy.info.size - blocks;
_heapinfo[block].busy.info.size = blocks;
free(ADDRESS(block + blocks));
result = ptr;
}
else if (blocks == _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 = _heapinfo[block].busy.info.size;
/* Prevent free from actually returning memory to the system. */
oldlimit = _heaplimit;
_heaplimit = 0;
free(ptr);
_heaplimit = oldlimit;
result = malloc(size);
if (result == NULL)
{
(void) malloc(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 = malloc(size);
if (result == NULL)
return NULL;
memcpy(result, ptr, MIN(size, (size_t) 1 << type));
free(ptr);
}
break;
}
return result;
}

58
gnu/glibc/glibc-1.03/malloc/valloc.c Normal file
View File

@@ -0,0 +1,58 @@
/* 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. */
/* IGNORE(@ */
#include <ansidecl.h>
#include <stdlib.h>
/* @) */
#include <malloc.h>
#ifdef __GNU_LIBRARY__
extern size_t EXFUN(__getpagesize, (NOARGS));
#else
#ifndef USG
extern size_t EXFUN(getpagesize, (NOARGS));
#define __getpagesize() getpagesize()
#else
#include <sys/param.h>
#ifdef EXEC_PAGESIZE
#define __getpagesize() EXEC_PAGESIZE
#else /* No EXEC_PAGESIZE. */
#ifdef NBPG
#ifndef CLSIZE
#define CLSIZE 1
#endif /* No CLSIZE. */
#define __getpagesize() (NBPG * CLSIZE)
#else /* No NBPG. */
#define __getpagesize() NBPC
#endif /* NBPG. */
#endif /* EXEC_PAGESIZE. */
#endif /* USG. */
#endif
static size_t pagesize;
PTR
DEFUN(valloc, (size), size_t size)
{
if (pagesize == 0)
pagesize = __getpagesize();
return memalign (pagesize, size);
}