TOPDIR=../../../
include $(TOPDIR)Rules.mak
-CSRC=calloc.c free.c malloc.c memalign.c morecore.c realloc.c valloc.c
+CSRC=calloc.c malloc.c
COBJS=$(patsubst %.c,%.o, $(CSRC))
MSRC=../malloc/alloc.c
-MOBJ=malloc_dbg.o free_dbg.o calloc_dbg.o
+MOBJ=#malloc_dbg.o free_dbg.o calloc_dbg.o
OBJS=$(COBJS) $(MOBJ)
all: $(OBJS) $(LIBC)
WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS
SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. */
+#include <stdlib.h>
#include <string.h>
-#include "malloc.h"
/* Allocate space for the given number of elements of the given
size, initializing the whole region to binary zeroes. */
-void *
-calloc(size_t nelem, size_t size)
+void * calloc(size_t nelem, size_t size)
{
void *result;
+++ /dev/null
-/* free.c - C standard library routine.
- Copyright (c) 1989, 1993 Michael J. Haertel
- You may redistribute this library under the terms of the
- GNU Library General Public License (version 2 or any later
- version) as published by the Free Software Foundation.
- THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY EXPRESS OR IMPLIED
- WARRANTY. IN PARTICULAR, THE AUTHOR MAKES NO REPRESENTATION OR
- WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS
- SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. */
-
-#include <limits.h>
-#include <stddef.h>
-#include <stdlib.h>
-#include "malloc.h"
-
-/* Return memory to the heap. */
-void
-_free_internal (void *ptr)
-{
- int block, blocks, i, type;
- struct list *prev, *next;
-
- if (!ptr)
- return;
-
- block = BLOCK(ptr);
-
- switch (type = _heapinfo[block].busy.type) {
- case 0:
- /* 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;
- }
-
- /* 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;
- }
-
- /* 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)) {
- _heaplimit -= blocks;
- (*__morecore)(-blocks * BLOCKSIZE);
- _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;
- }
-
- /* Set the next search to begin at this block. */
- _heapindex = block;
- break;
-
- default:
- /* 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
- && _fragblocks[type] > 1) {
- /* If all fragments of this block are free, remove them
- from the fragment list and free the whole block. */
- --_fragblocks[type];
- for (next = prev, i = 1; i < BLOCKSIZE >> type; ++i)
- next = next->next;
- prev->prev->next = next;
- if (next)
- next->prev = prev->prev;
- _heapinfo[block].busy.type = 0;
- _heapinfo[block].busy.info.size = 1;
- free(ADDRESS(block));
- } else if (_heapinfo[block].busy.info.frag.nfree) {
- /* If some fragments of this block are free, link this fragment
- into the fragment list after the first free fragment of
- this block. */
- next = ptr;
- next->next = prev->next;
- next->prev = prev;
- prev->next = next;
- if (next->next)
- 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 int) ((char *) ptr - (char *) NULL) % BLOCKSIZE
- >> type;
- prev->next = _fraghead[type].next;
- prev->prev = &_fraghead[type];
- prev->prev->next = prev;
- if (prev->next)
- prev->next->prev = prev;
- }
- break;
- }
-}
-
-struct alignlist *_aligned_blocks = NULL;
-
-void
-free (void *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;
- }
- }
-
- _free_internal (ptr);
-}
WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS
SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. */
+#define _GNU_SOURCE
+#include <features.h>
#include <limits.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
+#include <unistd.h>
#include "malloc.h"
+#define MIN(x,y) ({ \
+ const typeof(x) _x = (x); \
+ const typeof(y) _y = (y); \
+ (void) (&_x == &_y); \
+ _x < _y ? _x : _y; })
+
+
+#ifdef __UCLIBC_HAS_THREADS__
+#include <pthread.h>
+static pthread_mutex_t malloclock = PTHREAD_MUTEX_INITIALIZER;
+# define LOCK pthread_mutex_lock(&malloclock)
+# define UNLOCK pthread_mutex_unlock(&malloclock);
+#else
+# define LOCK
+# define UNLOCK
+#endif
+
+static void * malloc_unlocked (size_t size);
+static void free_unlocked(void *ptr);
+static void * __default_morecore_init(long size);
+
/* How to really get more memory. */
-void *(*__morecore)(long) = __default_morecore_init;
+static void *(*__morecore)(long) = __default_morecore_init;
/* Pointer to the base of the first block. */
-char *_heapbase;
+static char *_heapbase;
/* Block information table. */
-union info *_heapinfo;
+static union info *_heapinfo;
/* Number of info entries. */
-static int heapsize;
+static size_t heapsize;
/* Search index in the info table. */
-int _heapindex;
+static size_t _heapindex;
/* Limit of valid info table indices. */
-int _heaplimit;
+static size_t _heaplimit;
/* Count of large blocks allocated for each fragment size. */
-int _fragblocks[BLOCKLOG];
+static size_t _fragblocks[BLOCKLOG];
/* Free lists for each fragment size. */
-struct list _fraghead[BLOCKLOG];
+static struct list _fraghead[BLOCKLOG];
/* Are we experienced? */
static int initialized;
-/* Aligned allocation. */
-static void *
-align(size_t size)
+
+
+/* Aligned allocation.
+ * Called within the lock in initialize() and morecore(),
+ * so no explicit locking needed... */
+static void * align(size_t size)
{
void *result;
unsigned int adj;
return result;
}
-/* Set everything up and remember that we have. */
-static int
-initialize(void)
+/* Set everything up and remember that we have.
+ * Called within the lock in malloc(), so no
+ * explicit locking needed... */
+static int initialize(void)
{
heapsize = HEAP / BLOCKSIZE;
_heapinfo = align(heapsize * sizeof (union info));
- if (!_heapinfo)
+ if (!_heapinfo) {
return 0;
+ }
memset(_heapinfo, 0, heapsize * sizeof (union info));
_heapinfo[0].free.size = 0;
_heapinfo[0].free.next = _heapinfo[0].free.prev = 0;
return 1;
}
-/* Get neatly aligned memory, initializing or growing the
- heap info table as necessary. */
-static void *
-morecore(size_t size)
+/* Get neatly aligned memory, initializing or growing the
+ * heap info table as necessary.
+ * Called within a lock in malloc() and free(),
+ * so no explicit locking needed... */
+static void * morecore(size_t size)
{
void *result;
union info *newinfo, *oldinfo;
- int newsize;
+ size_t newsize;
result = align(size);
if (!result)
newinfo[BLOCK(oldinfo)].busy.info.size
= BLOCKIFY(heapsize * sizeof (union info));
_heapinfo = newinfo;
-#if 0
- free(oldinfo);
-#else
- _free_internal (oldinfo);
-#endif
+ free_unlocked(oldinfo);
heapsize = newsize;
}
return result;
}
+/* Note that morecore has to take a signed argument so
+ that negative values can return memory to the system. */
+static void * __default_morecore_init(long size)
+{
+ void *result;
+
+ result = sbrk(size);
+ if (result == (void *) -1)
+ return NULL;
+ return result;
+}
+
/* Allocate memory from the heap. */
-void *
-malloc (size_t size)
+void * malloc (size_t size)
+{
+ void * ptr;
+ LOCK;
+ ptr = malloc_unlocked(size);
+ UNLOCK;
+ return(ptr);
+}
+
+static void * malloc_unlocked (size_t size)
{
void *result;
- int log, block, blocks, i, lastblocks, start;
+ size_t log, block, blocks, i, lastblocks, start;
struct list *next;
- if (!initialized && !initialize())
+#if 1
+ /* Some programs will call malloc (0). Lets be strict and return NULL */
+ if (size == 0)
return NULL;
+#endif
+
+ if (size < sizeof (struct list))
+ size = sizeof (struct list);
#if 1
/* Some programs will call malloc (0). Lets be strict and return NULL */
if (size < sizeof (struct list))
size = sizeof (struct list);
+ if (!initialized && !initialize()) {
+ return NULL;
+ }
+
/* Determine the allocation policy based on the request size. */
if (size <= BLOCKSIZE / 2) {
/* Small allocation to receive a fragment of a block. Determine
} 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)
+ result = malloc_unlocked(BLOCKSIZE);
+ if (!result) {
return NULL;
+ }
++_fragblocks[log];
/* Link all fragments but the first into the free list. */
continue;
}
result = morecore(blocks * BLOCKSIZE);
- if (!result)
+ if (!result) {
return NULL;
+ }
block = BLOCK(result);
_heapinfo[block].busy.type = 0;
_heapinfo[block].busy.info.size = blocks;
return result;
}
+
+
+
+/* Return memory to the heap. */
+void free(void *ptr)
+{
+ LOCK;
+ free_unlocked(ptr);
+ UNLOCK;
+}
+
+static void free_unlocked(void *ptr)
+{
+ int block, blocks, i, type;
+ struct list *prev, *next;
+
+ if (ptr == NULL)
+ return;
+
+ block = BLOCK(ptr);
+
+ switch (type = _heapinfo[block].busy.type) {
+ case 0:
+ /* 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;
+ }
+
+ /* 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;
+ }
+
+ /* 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)) {
+ _heaplimit -= blocks;
+ (*__morecore)(-blocks * BLOCKSIZE);
+ _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;
+ }
+
+ /* Set the next search to begin at this block. */
+ _heapindex = block;
+ break;
+
+ default:
+ /* 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
+ && _fragblocks[type] > 1) {
+ /* If all fragments of this block are free, remove them
+ from the fragment list and free the whole block. */
+ --_fragblocks[type];
+ for (next = prev, i = 1; i < BLOCKSIZE >> type; ++i)
+ next = next->next;
+ prev->prev->next = next;
+ if (next)
+ next->prev = prev->prev;
+ _heapinfo[block].busy.type = 0;
+ _heapinfo[block].busy.info.size = 1;
+ free_unlocked(ADDRESS(block));
+ } else if (_heapinfo[block].busy.info.frag.nfree) {
+ /* If some fragments of this block are free, link this fragment
+ into the fragment list after the first free fragment of
+ this block. */
+ next = ptr;
+ next->next = prev->next;
+ next->prev = prev;
+ prev->next = next;
+ if (next->next)
+ 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 int) ((char *) ptr - (char *) NULL) % BLOCKSIZE
+ >> type;
+ prev->next = _fraghead[type].next;
+ prev->prev = &_fraghead[type];
+ prev->prev->next = prev;
+ if (prev->next)
+ prev->next->prev = prev;
+ }
+ break;
+ }
+}
+
+/* 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. */
+void * realloc (void *ptr, size_t size)
+{
+ void *result, *previous;
+ size_t block, blocks, type;
+ size_t oldlimit;
+
+ if (!ptr)
+ return malloc(size);
+ if (!size) {
+ LOCK;
+ free_unlocked(ptr);
+ result = malloc_unlocked(0);
+ UNLOCK;
+ return(result);
+ }
+
+ LOCK;
+ block = BLOCK(ptr);
+
+ switch (type = _heapinfo[block].busy.type) {
+ case 0:
+ /* Maybe reallocate a large block to a small fragment. */
+ if (size <= BLOCKSIZE / 2) {
+ if ((result = malloc_unlocked(size)) != NULL) {
+ memcpy(result, ptr, size);
+ free(ptr);
+ }
+ UNLOCK;
+ 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));
+ UNLOCK;
+ return ptr;
+ } else if (blocks == _heapinfo[block].busy.info.size) {
+ /* No size change necessary. */
+ UNLOCK;
+ return 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_unlocked(size);
+ if (!result) {
+ /* Now we're really in trouble. We have to unfree
+ the thing we just freed. Unfortunately it might
+ have been coalesced with its neighbors. */
+ if (_heapindex == block)
+ malloc_unlocked(blocks * BLOCKSIZE);
+ else {
+ previous = malloc_unlocked((block - _heapindex) * BLOCKSIZE);
+ malloc_unlocked(blocks * BLOCKSIZE);
+ free(previous);
+ }
+ UNLOCK;
+ return NULL;
+ }
+ if (ptr != result)
+ memmove(result, ptr, blocks * BLOCKSIZE);
+ UNLOCK;
+ return result;
+ }
+ break;
+
+ default:
+ /* Old size is a fragment; type is logarithm to base two of
+ the fragment size. */
+ if ((size > 1 << (type - 1)) && (size <= 1 << type)) {
+ /* New size is the same kind of fragment. */
+ UNLOCK;
+ return ptr;
+ }
+ else {
+ /* New size is different; allocate a new space, and copy
+ the lesser of the new size and the old. */
+ result = malloc_unlocked(size);
+ if (!result) {
+ UNLOCK;
+ return NULL;
+ }
+ memcpy(result, ptr, MIN(size, (size_t)(1 << type)));
+ free(ptr);
+ UNLOCK;
+ return result;
+ }
+ break;
+ }
+ UNLOCK;
+}
+
#include <sys/cdefs.h>
-/* Underlying allocation function; successive calls should return
- contiguous pieces of memory. */
-extern void *(*__morecore)(long);
-
-/* Default value of previous. */
-extern void *__default_morecore_init(long);
-extern void *__default_morecore(long);
-
/* 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.
- WARNING: BLOCKSIZE must be set greater than or equal to the
- machine's page size for valloc() to work correctly. The default
- definition here is 4096 bytes. */
-#define INT_BIT (CHAR_BIT * sizeof (int))
+ */
+#define INT_BIT (CHAR_BIT * sizeof (size_t))
#define BLOCKLOG (INT_BIT > 16 ? 12 : 9)
#define BLOCKSIZE (1 << BLOCKLOG)
#define BLOCKIFY(SIZE) (((SIZE) + BLOCKSIZE - 1) / BLOCKSIZE)
/* Data structure giving per-block information. */
union info {
struct {
- int type; /* Zero for a large block, or positive
+ size_t type; /* Zero for a large block, or positive
giving the logarithm to the base two
of the fragment size. */
union {
struct {
- int nfree; /* Free fragments in a fragmented block. */
- int first; /* First free fragment of the block. */
+ size_t nfree; /* Free fragments in a fragmented block. */
+ size_t first; /* First free fragment of the block. */
} frag;
- int size; /* Size (in blocks) of a large cluster. */
+ size_t size; /* Size (in blocks) of a large cluster. */
} info;
} busy;
struct {
- int size; /* Size (in blocks) of a free cluster. */
- int next; /* Index of next free cluster. */
- int prev; /* Index of previous free cluster. */
+ 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;
};
-/* Pointer to first block of the heap. */
-extern char *_heapbase;
-
-/* Table indexed by block number giving per-block information. */
-extern union info *_heapinfo;
-
/* Address to block number and vice versa. */
#define BLOCK(A) (((char *) (A) - _heapbase) / BLOCKSIZE + 1)
#define ADDRESS(B) ((void *) (((B) - 1) * BLOCKSIZE + _heapbase))
-/* Current search index for the heap table. */
-extern int _heapindex;
-
-/* Limit of valid info table indices. */
-extern int _heaplimit;
-
/* Doubly linked lists of free fragments. */
struct list {
struct list *next;
struct list *prev;
};
-/* Count of blocks for each fragment size. */
-extern int _fragblocks[];
-
-/* 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_t aligned; /* The address that memaligned returned. */
- __ptr_t exact; /* The address that malloc returned. */
-};
-extern struct alignlist *_aligned_blocks;
-
-extern void _free_internal __P ((__ptr_t __ptr));
-
-extern void free (void *);
-extern void * malloc (size_t);
-extern void * calloc (size_t, size_t);
-extern void * valloc (size_t);
-extern void * memalign (size_t, size_t);
-extern void * realloc (void *, size_t);
+++ /dev/null
-/* Copyright (C) 1991, 1992 Free Software Foundation, Inc.
-
-This 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.
-
-This 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 this library; see the file COPYING.LIB. If
-not, write to the Free Software Foundation, Inc., 675 Mass Ave,
-Cambridge, MA 02139, USA. */
-
-#include <stdlib.h>
-#include "malloc.h"
-
-__ptr_t
-memalign (alignment, size)
- size_t alignment;
- size_t size;
-{
- __ptr_t result;
- unsigned long int adj;
-
- result = malloc (size + alignment - 1);
- 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)
- {
-#if 1
- free (result);
-#else
- _free_internal (result);
-#endif
- return NULL;
- }
- l->next = _aligned_blocks;
- _aligned_blocks = l;
- }
- l->exact = result;
- result = l->aligned = (char *) result + alignment - adj;
- }
-
- return result;
-}
+++ /dev/null
-/* morecore.c - C library support routine for UNIX.
- Copyright (c) 1989, 1993 Michael J. Haertel
- You may redistribute this library under the terms of the
- GNU Library General Public License (version 2 or any later
- version) as published by the Free Software Foundation.
- THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY EXPRESS OR IMPLIED
- WARRANTY. IN PARTICULAR, THE AUTHOR MAKES NO REPRESENTATION OR
- WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS
- SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. */
-
-#include <limits.h>
-#include <stddef.h>
-#include "malloc.h"
-
-extern void *sbrk(int);
-
-/* Note that morecore has to take a signed argument so
- that negative values can return memory to the system. */
-void *
-__default_morecore_init(long size)
-{
- void *result;
-
- result = sbrk(size);
- if (result == (void *) -1)
- return NULL;
- return result;
-}
+++ /dev/null
-/* realloc.c - C standard library routine.
- Copyright (c) 1989, 1993 Michael J. Haertel
- You may redistribute this library under the terms of the
- GNU Library General Public License (version 2 or any later
- version) as published by the Free Software Foundation.
- THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT ANY EXPRESS OR IMPLIED
- WARRANTY. IN PARTICULAR, THE AUTHOR MAKES NO REPRESENTATION OR
- WARRANTY OF ANY KIND CONCERNING THE MERCHANTABILITY OF THIS
- SOFTWARE OR ITS FITNESS FOR ANY PARTICULAR PURPOSE. */
-
-#include <limits.h>
-#include <stddef.h>
-#include <stdlib.h>
-#include <string.h>
-#include "malloc.h"
-
-#define MIN(A, B) ((A) < (B) ? (A) : (B))
-
-/* 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. */
-void *
-realloc (void *ptr, size_t size)
-{
- void *result, *previous;
- int block, blocks, type;
- int oldlimit;
-
- if (!ptr)
- return malloc(size);
- if (!size) {
- free(ptr);
- return malloc(0);
- }
-
- block = BLOCK(ptr);
-
- switch (type = _heapinfo[block].busy.type) {
- case 0:
- /* Maybe reallocate a large block to a small fragment. */
- if (size <= BLOCKSIZE / 2) {
- if ((result = malloc(size)) != NULL) {
- memcpy(result, ptr, size);
-#if 1
- free(ptr);
-#else
- _free_internal(ptr);
-#endif
-
- }
- 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;
-#if 1
- free(ADDRESS(block + blocks));
-#else
- _free_internal(ADDRESS(block + blocks));
-#endif
- return ptr;
- } else if (blocks == _heapinfo[block].busy.info.size)
- /* No size change necessary. */
- return 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;
-#if 1
- free(ptr);
-#else
- _free_internal(ptr);
-#endif
- _heaplimit = oldlimit;
- result = malloc(size);
- if (!result) {
- /* Now we're really in trouble. We have to unfree
- the thing we just freed. Unfortunately it might
- have been coalesced with its neighbors. */
- if (_heapindex == block)
- malloc(blocks * BLOCKSIZE);
- else {
- previous = malloc((block - _heapindex) * BLOCKSIZE);
- malloc(blocks * BLOCKSIZE);
-#if 1
- free(previous);
-#else
- _free_internal(previous);
-#endif
- }
- return NULL;
- }
- if (ptr != result)
- memmove(result, ptr, blocks * BLOCKSIZE);
- return result;
- }
- break;
-
- default:
- /* Old size is a fragment; type is logarithm to base two of
- the fragment size. */
- if ((size > 1 << (type - 1)) && (size <= 1 << type))
- /* New size is the same kind of fragment. */
- return ptr;
- else {
- /* New size is different; allocate a new space, and copy
- the lesser of the new size and the old. */
- result = malloc(size);
- if (!result)
- return NULL;
- memcpy(result, ptr, MIN(size, 1 << type));
- free(ptr);
- return result;
- }
- break;
- }
-}
+++ /dev/null
-/* Allocate memory on a page boundary.
- Copyright (C) 1991, 1992 Free Software Foundation, Inc.
-
-This 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.
-
-This 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 this 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 <stdlib.h>
-#include "malloc.h"
-
-#ifdef emacs
-#include "config.h"
-#endif
-
-#ifdef __GNU_LIBRARY__
-extern size_t __getpagesize __P ((void));
-#else
-#ifndef USG
-extern size_t getpagesize __P ((void));
-#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_t
-valloc (size)
- size_t size;
-{
- if (pagesize == 0)
- pagesize = __getpagesize ();
-
- return memalign (pagesize, size);
-}
OSDN Git Service
